Swap Tokens with Li.Fi

import { Magic } from "magic-sdk";
import { createWalletClient, createPublicClient, custom, http } from "viem";
import { base } from "viem/chains";

const magic = new Magic("YOUR_PUBLISHABLE_KEY", {
  network: {
    rpcUrl: "https://base-mainnet.g.alchemy.com/v2/YOUR_ALCHEMY_KEY",
    chainId: 8453,
  },
});

const publicClient = createPublicClient({
  chain: base,
  transport: http("https://base-mainnet.g.alchemy.com/v2/YOUR_ALCHEMY_KEY"),
});

const walletClient = createWalletClient({
  chain: base,
  transport: custom(magic.rpcProvider),
});

const [userAddress] = await walletClient.getAddresses();

const LIFI_API = "https://li.quest/v1";

interface QuoteResponse {
  estimate: {
    toAmount: string;
    toAmountMin: string;
    approvalAddress: string;
    gasCosts: { estimate: string; token: { symbol: string } }[];
  };
  transactionRequest: {
    from: string;
    to: string;
    data: string;
    value: string;
    gasLimit: string;
    gasPrice: string;
    chainId: number;
  };
}

async function getQuote(
  fromToken: string,
  toToken: string,
  amount: string,
  fromAddress: string,
): Promise<QuoteResponse> {
  const params = new URLSearchParams({
    fromChain: "8453",
    toChain: "8453",
    fromToken,
    toToken,
    fromAmount: amount,
    fromAddress,
    slippage: "0.005",
  });

  const res = await fetch(`${LIFI_API}/quote?${params}`);
  if (!res.ok) {
    const err = await res.json();
    throw new Error(err.message || `Quote failed: ${res.status}`);
  }
  return res.json();
}

import { type Address, parseUnits, erc20Abi } from "viem";

async function checkAndApprove(
  tokenAddress: Address,
  spender: Address,
  amount: bigint,
) {
  // Check current allowance
  const allowance = await publicClient.readContract({
    address: tokenAddress,
    abi: erc20Abi,
    functionName: "allowance",
    args: [userAddress, spender],
  });

  if (allowance >= amount) return; // Already approved

  // Approve the exact amount
  const hash = await walletClient.writeContract({
    address: tokenAddress,
    abi: erc20Abi,
    functionName: "approve",
    args: [spender, amount],
    account: userAddress,
  });

  await publicClient.waitForTransactionReceipt({ hash });
}

// Native ETH is represented by the zero address in Li.Fi
const NATIVE_TOKEN = "0x0000000000000000000000000000000000000000";
const USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const USDC_DECIMALS = 6;

async function swapTokens(
  fromToken: Address,
  toToken: Address,
  amount: string,
  decimals: number,
) {
  const fromAmount = parseUnits(amount, decimals).toString();

  // 1. Get quote
  const quote = await getQuote(fromToken, toToken, fromAmount, userAddress);

  // 2. Approve if swapping an ERC-20 (not native ETH)
  if (fromToken !== NATIVE_TOKEN) {
    await checkAndApprove(
      fromToken,
      quote.estimate.approvalAddress as Address,
      BigInt(fromAmount),
    );
  }

  // 3. Execute the swap
  const hash = await walletClient.sendTransaction({
    to: quote.transactionRequest.to as Address,
    data: quote.transactionRequest.data as `0x${string}`,
    value: BigInt(quote.transactionRequest.value),
    gas: BigInt(quote.transactionRequest.gasLimit),
    account: userAddress,
  });

  const receipt = await publicClient.waitForTransactionReceipt({ hash });
  return {
    hash: receipt.transactionHash,
    toAmount: quote.estimate.toAmount,
    toAmountMin: quote.estimate.toAmountMin,
  };
}

// Swap 0.01 ETH for USDC on Base
const result = await swapTokens(
  NATIVE_TOKEN,          // from: native ETH
  USDC_ADDRESS,          // to: USDC
  "0.01",                // amount
  18,                    // ETH has 18 decimals
);

console.log(`Swap tx: ${result.hash}`);

// Swap 10 USDC for ETH on Base
const result = await swapTokens(
  USDC_ADDRESS,          // from: USDC
  NATIVE_TOKEN,          // to: native ETH
  "10",                  // amount
  USDC_DECIMALS,         // USDC has 6 decimals
);

console.log(`Swap tx: ${result.hash}`);

// Native ETH (use zero address in Li.Fi)
const ETH = "0x0000000000000000000000000000000000000000";

// USDC on Base (native, issued by Circle)
const USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";

// DAI on Base
const DAI = "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb";