Execute a swap

// execute-swap.ts. Run: node execute-swap.ts
import {
  BaseError,
  ExecutionRevertedError,
  createPublicClient,
  createWalletClient,
  erc20Abi,
  http,
  isAddressEqual,
  parseUnits,
  type Address,
  type Hex,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { polygon } from "viem/chains";
import { OlympexApiError, olympexRequest } from "./sign-request.ts"; // /authentication/sign-requests

const NATIVE_TOKEN: Address = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
const GWEI = 1_000_000_000n;
const account = privateKeyToAccount(process.env.WALLET_PRIVATE_KEY as Hex);
const publicClient = createPublicClient({ chain: polygon, transport: http(process.env.POLYGON_RPC_URL) });
const walletClient = createWalletClient({ account, chain: polygon, transport: http(process.env.POLYGON_RPC_URL) });

const trade = {
  chainId: 137,
  inTokenAddress: "0xc2132d05d31c914a87c6611c10748aeb04b58e8f" as Address, // USDT
  outTokenAddress: "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359" as Address, // USDC
  amount: "10", // human-readable units of the input token
  slippage: "1", // percent
  gasPrice: (((await publicClient.getGasPrice()) + GWEI - 1n) / GWEI).toString(), // hint in whole gwei, rounded up: some sources reject fractions ("1" below 1 gwei)
};
const isNative = isAddressEqual(trade.inTokenAddress, NATIVE_TOKEN);

type QuoteData = { quote: { aggregatorId: string; aggregatorOrder: string[] | null } };

const { quote } = await olympexRequest<QuoteData>("POST", "/quotes", {
  mode: "single-chain",
  params: trade,
});

type SingleChainSwap = {
  to: Address;
  data: Hex;
  value: string; // wei
  contractToApprove: Address;
  outAmount: string; // base units of the output token
  minOutAmount: string; // base units; the transaction reverts below this
  gasLimit: string; // estimatedGas × 2: a fallback only
};

// The winning source first, then the other sources that quoted, best first.
const sources = [quote.aggregatorId, ...(quote.aggregatorOrder ?? []).filter((id) => id !== quote.aggregatorId)];
const revertedSources = new Set<string>(); // sources whose calldata reverted in the gas estimate (step 4)
let aggregatorId = sources[0]; // the source that built the current swap

async function buildSwap(): Promise<SingleChainSwap> {
  let lastError: unknown = new Error("No source left to build this swap: request a new quote");
  for (const id of sources) {
    if (revertedSources.has(id)) continue;
    try {
      const { swap } = await olympexRequest<{ swap: SingleChainSwap }>("POST", "/swap", {
        mode: "single-chain",
        params: { ...trade, account: account.address, aggregatorId: id },
      });
      // ERC-20 input never sends native value. See /concepts/security-model#check-before-you-sign.
      if (!isNative && swap.value !== "0") throw new Error(`Unexpected value ${swap.value} from ${id}`);
      aggregatorId = id;
      return swap;
    } catch (error) {
      if (!(error instanceof OlympexApiError) || !["NO_ROUTE", "SWAP_ERROR"].includes(error.code)) throw error;
      console.warn(`${error.code} from ${id} (requestId ${error.requestId}); trying the next source`);
      lastError = error;
    }
  }
  throw lastError;
}

let swap = await buildSwap();
console.log(`Expect ${swap.outAmount}, at least ${swap.minOutAmount} (base units of USDC)`);

/** Approves exactly `amount` for `spender`. Returns true if it sent a transaction. */
async function ensureAllowance(token: Address, spender: Address, amount: bigint): Promise<boolean> {
  const allowance = await publicClient.readContract({
    address: token,
    abi: erc20Abi,
    functionName: "allowance",
    args: [account.address, spender],
  });
  if (allowance >= amount) return false;

  const approve = async (value: bigint) => {
    const hash = await walletClient.writeContract({ address: token, abi: erc20Abi, functionName: "approve", args: [spender, value] });
    const receipt = await publicClient.waitForTransactionReceipt({ hash });
    if (receipt.status !== "success") throw new Error(`approve(${value}) reverted: ${hash}`);
  };
  // Some tokens (USDT on Ethereum, for example) revert when one non-zero allowance
  // replaces another, so reset it to 0 first.
  if (allowance > 0n) await approve(0n);
  await approve(amount);
  return true;
}

/** Checks the balance and approves the current swap's spender, building again after each approval. */
async function approveInput(): Promise<void> {
  if (isNative) return; // native input: `value` carries the amount, nothing to approve
  const decimals = await publicClient.readContract({ address: trade.inTokenAddress, abi: erc20Abi, functionName: "decimals" });
  const amountIn = parseUnits(trade.amount, decimals); // "10" USDT is 10000000 base units
  const balance = await publicClient.readContract({ address: trade.inTokenAddress, abi: erc20Abi, functionName: "balanceOf", args: [account.address] });
  if (balance < amountIn) throw new Error(`The wallet holds ${balance} base units of the input token, less than ${amountIn}`);
  // Build again after each approval, and check the allowance against the spender in the new response.
  while (await ensureAllowance(trade.inTokenAddress, swap.contractToApprove, amountIn)) {
    swap = await buildSwap();
  }
}

await approveInput();

/** Estimates the current swap's gas with a 20% buffer, or returns undefined if its calldata reverts. */
async function estimateSwapGas(): Promise<bigint | undefined> {
  try {
    const estimate = await publicClient.estimateGas({ account, to: swap.to, data: swap.data, value: BigInt(swap.value) });
    return (estimate * 120n) / 100n; // +20% buffer
  } catch (error) {
    if (error instanceof BaseError && error.walk((e) => e instanceof ExecutionRevertedError)) return undefined; // would revert
    if (swap.gasLimit === "0") throw error; // no usable fallback: don't send it
    return BigInt(swap.gasLimit); // the RPC could not estimate: fall back to the API's value
  }
}

let gas = await estimateSwapGas();
while (gas === undefined) {
  // The balance and the allowance are in place, so this route can't execute: build with the next source.
  console.warn(`Calldata from ${aggregatorId} reverts in eth_estimateGas; trying the next source`);
  revertedSources.add(aggregatorId);
  swap = await buildSwap(); // throws when no source is left: request a new quote then
  await approveInput(); // another source can use another spender
  gas = await estimateSwapGas();
}
const request = { account, to: swap.to, data: swap.data, value: BigInt(swap.value) };
console.log(`Sending ${aggregatorId} calldata: expect ${swap.outAmount}, at least ${swap.minOutAmount}`);

const hash = await walletClient.sendTransaction({ ...request, gas });
console.log(`Sent ${hash}`);

const receipt = await publicClient.waitForTransactionReceipt({ hash });
if (receipt.status !== "success") {
  throw new Error(`Swap reverted in block ${receipt.blockNumber}: ${hash}`);
}
console.log(`Confirmed in block ${receipt.blockNumber}`);