Token Swap

// From useSwapContract.ts
const ROUTER_ADDRESS = '0x...'  // Verified on BaseScan

const executeSwap = async ({
  tokenInAddress,   // FROM token contract
  tokenOutAddress,  // TO token contract
  amountIn,         // Amount to swap
  tokenInDecimals,  // Token decimals (6, 8, or 18)
  tokenOutDecimals, // Output token decimals
  slippageBps       // 50 = 0.5%
}) => {
  // Step 1: Get quote from router
  const quote = await getSwapQuote(params);
  
  // Step 2: Approve token spending (if first time)
  if (currentAllowance < amountIn) {
    await approveRouter();
  }
  
  // Step 3: Execute swap
  const txHash = await router.swap(
    tokenInAddress,
    tokenOutAddress,
    amountIn,
    minAmountOut  // Protected by slippage
  );
  
  return txHash;
};

// From useSwapContract.ts
const getSwapQuote = async (params) => {
  const [amountOut, protocolFee] = await publicClient.readContract({
    address: ROUTER_ADDRESS,
    abi: routerAbi,
    functionName: 'getQuote',
    args: [
      tokenInAddress,
      tokenOutAddress,
      amountInWei
    ]
  });
  
  return {
    amountOut: formatUnits(amountOut, tokenOutDecimals),
    protocolFee: formatUnits(protocolFee, tokenOutDecimals),
    route: tokenInAddress === USDC || tokenOutAddress === USDC 
      ? 'Direct' 
      : 'Via USDC'
  };
};

// Calculate minimum output with 0.5% slippage
const expectedOut = parseUnits(quote.amountOut, tokenOutDecimals);
const minAmountOut = (expectedOut * BigInt(9950)) / BigInt(10000);
// 9950/10000 = 99.5% of expected = 0.5% slippage tolerance

BTC → SOL
  ↓
BTC → USDC → SOL
  (swap 1)  (swap 2)

// From useSwapTransactions.ts
const { transactions, loading } = useSwapTransactions(
  userAddress,  // Only your swaps
  connected     // Only when wallet connected
);

// Fetches Swap events from Router contract
const logs = await publicClient.getLogs({
  address: ROUTER_ADDRESS,
  event: {
    name: 'Swap',
    inputs: [
      { name: 'user', type: 'address', indexed: true },
      { name: 'tokenIn', type: 'address' },
      { name: 'tokenOut', type: 'address' },
      { name: 'amountIn', type: 'uint256' },
      { name: 'amountOut', type: 'uint256' }
    ]
  },
  args: {
    user: userAddress  // Filter to your address
  },
  fromBlock: 'earliest'
});

Swapping: 100 USDC → SOL
Expected Out: 0.7194 SOL
Protocol Fee: 0.0022 SOL (0.3%)
Actual Received: 0.7172 SOL
Gas Fee: 0.15 USDC

// From useSwapContract.ts
if (!isVerifiedToken(tokenInAddress)) {
  throw new Error('Input token not in whitelist');
}

if (!isVerifiedToken(tokenOutAddress)) {
  throw new Error('Output token not in whitelist');
}

const validation = await validateTransaction({
  contractAddress: ROUTER_ADDRESS,
  contractType: 'ROUTER',
  userAddress: address
});

if (!validation.valid) {
  throw new Error(validation.error);
}

// From tokens.ts
export const TOKENS = {
  BTC: {
    symbol: 'BTC',
    name: 'Bitcoin',
    logo: 'https://s2.coinmarketcap.com/static/img/coins/64x64/1.png',
    decimals: 8,
    coinGeckoId: 'bitcoin'
  },
  // ... other tokens
};

// From SwapPage.tsx
const formatTokenAmount = (amount: string, symbol: string): string => {
  const decimals = TOKENS[symbol]?.decimals || 18;
  const formatted = formatUnits(BigInt(amount), decimals);
  return parseFloat(formatted).toFixed(
    decimals === 6 ? 2 :   // USDC: 2 decimals
    decimals === 8 ? 8 :   // BTC: 8 decimals
    4                      // Others: 4 decimals
  );
};