Demo docs

import { TezosToolkit } from '@taquito/taquito';
import { InMemorySigner } from '@taquito/signer';
import {
  FreeRouteTezosX, tezosXMainnet, XTZ, toEvmUnits, targetForMinOut,
  michelsonToEvmAlias, resolveApproval, objkt, buildBatchTransaction,
} from '@baking-bad/free-route-tezos-x';

// your Taquito toolkit + signer (a Beacon wallet in a browser dApp)
const tezos = new TezosToolkit(MICHELSON_RPC);
tezos.setSignerProvider(new InMemorySigner(SECRET_KEY));

const freeRoute = new FreeRouteTezosX({
  baseUrl: FREE_ROUTE_API,
  network: tezosXMainnet,
  apiKey: FREE_ROUTE_API_KEY, // free-route API key
});

const buyerAddress = await tezos.signer.publicKeyHash();   // your Michelson (tz1) address
const buyerAlias = michelsonToEvmAlias(buyerAddress);      // its EVM identity (holds the ERC20)
const payToken = (await freeRoute.getTokens()).find((token) => token.symbol === 'USDC')!;

const priceMutez = 4_000n; // the objkt ask price (read it from the marketplace)
const slippageBps = 200;   // 2%

// exact-out: size the XTZ out so the on-chain floor still covers the price
const minOutTarget = targetForMinOut(priceMutez, slippageBps);
const swapAmount = toEvmUnits(minOutTarget, XTZ.address); // mutez -> wei for the EVM API
const swap = await freeRoute.getSwap({
  src: payToken.address,
  dst: XTZ.address,
  amount: swapAmount,
  isExactOut: true,
  from: buyerAlias,
  receiver: buyerAlias,
  slippageBps,
});

// read the on-chain allowance -> pick the minimal safe approval mode (none / approve / reset+approve)
const approval = await resolveApproval({
  evmRpc: EVM_RPC,
  token: payToken.address,
  owner: buyerAlias,
  spender: swap.tx.to,
  amount: swap.srcAmount,
});

// approve(s) + swap, composed with the objkt fulfill -> one atomic group
const swapOps = freeRoute.michelson.buildSwapOperation({
  swap,
  srcAddress: payToken.address,
  approval,
});
const fulfill = objkt.buildMichelsonFulfillAskOperation({
  marketplace: OBJKT_MARKETPLACE,
  askId: '1',
  editions: 1,
  amountMutez: priceMutez,
  // recipient: 'tz1… | KT1…', // optional: send the NFT to another Michelson address (objkt proxy_for)
});

const ops = buildBatchTransaction(swapOps, fulfill);
// size the group on the node (call_evm margin + end-to-end check before signing)
const readyOps = await freeRoute.michelson.estimateOperation({ tezos, ops });
const op = await tezos.contract.batch().with(readyOps).send(); // a single signature
await op.confirmation();

import { TezosToolkit } from '@taquito/taquito';
import { InMemorySigner } from '@taquito/signer';
import {
  FreeRouteTezosX, tezosXMainnet, XTZ, toEvmUnits, isXtz,
  michelsonToEvmAlias, resolveApproval,
} from '@baking-bad/free-route-tezos-x';

const tezos = new TezosToolkit(MICHELSON_RPC);
tezos.setSignerProvider(new InMemorySigner(SECRET_KEY));

const freeRoute = new FreeRouteTezosX({
  baseUrl: FREE_ROUTE_API,
  network: tezosXMainnet,
  apiKey: FREE_ROUTE_API_KEY, // free-route API key
});

const myAddress = await tezos.signer.publicKeyHash();
const alias = michelsonToEvmAlias(myAddress); // EVM identity that runs the swap
const slippageBps = 50;                        // 0.5%

// pick any pair + the amount in src base units
const tokens = await freeRoute.getTokens();
const src = tokens.find((token) => token.symbol === 'USDC')!;
const dst = XTZ;            // receive native XTZ
const amount = 1_000_000n; // 1 USDC

// exact-in: any token -> any token (XTZ <-> ERC20, ERC20 <-> ERC20)
const swapAmount = toEvmUnits(amount, src.address); // to wei for the EVM API
const swap = await freeRoute.getSwap({
  src: src.address,
  dst: dst.address,
  amount: swapAmount,
  isExactOut: false,
  from: alias,
  receiver: alias, // optional: any EVM 0x address — the swap output lands here (defaults to the sender)
  slippageBps,
});

// native XTZ carries value as msg.value (no approve); an ERC20 picks the minimal safe mode (none / approve / reset+approve)
const approval = isXtz(src.address)
  ? 'none'
  : await resolveApproval({
      evmRpc: EVM_RPC,
      token: src.address,
      owner: alias,
      spender: swap.tx.to,
      amount: swap.srcAmount,
    });

// approve(s) + swap -> one atomic group; native-XTZ output auto-forwards to your Michelson address
const ops = freeRoute.michelson.buildSwapOperation({
  swap,
  srcAddress: src.address,
  approval,
});
const readyOps = await freeRoute.michelson.estimateOperation({ tezos, ops }); // size on the node before signing
const op = await tezos.contract.batch().with(readyOps).send(); // a single signature
await op.confirmation();