EVM Swap Integration Guide

How to execute same-chain swaps on EVM networks using Fly Trade's APIs

This guide shows how to execute a swap on EVM networks (Ethereum, Polygon, BSC, Arbitrum, etc.) using Fly Trade's API in 3 steps:

1. Get a quote (pricing + route + constraints)

2. Fetch transaction payload with the quote ID

3. Sign and send the transaction to the network

Prerequisites

• An EVM RPC connection (Infura, Alchemy, QuickNode, or self-hosted node)

• A wallet that can sign EVM transactions (MetaMask, WalletConnect, ethers.js Signer, or backend private key)

• Sufficient balance of the tokens you want to swap and their token contract addresses

How the Flow Works

The high-level swap flow is:

• Call /aggregator/quote to receive a quoteId, estimated output amount, and swap details

• Call /aggregator/transaction with the quoteId to receive the transaction data (to, data, value, gas parameters)

• Sign the transaction with the user's wallet

• Send the signed transaction to the network

• Wait for confirmation

Alternative: Instead of calling quote and transaction separately, you can use the /aggregator/quote/transaction endpoint to get both in a single request. Note that this combined endpoint does not provide gas estimation.

Step 1 — Get a Quote

Endpoint:

• Method: GET

• Path: /aggregator/quote

Required Parameters:

Parameter	Description
network	Network name (e.g., ethereum, polygon, bsc, arbitrum, base). See the network dropdown on Swagger for all supported network names
fromTokenAddress	Token contract address to swap from. Use 0x0000000000000000000000000000000000000000 for native token (ETH/MATIC/BNB)
toTokenAddress	Token contract address to swap to. Use 0x0000000000000000000000000000000000000000 for native token
sellAmount	Amount in smallest unit (wei). For 1 ETH write 1000000000000000000
slippage	Allowed slippage (e.g., 0.005 for 0.5%, 0.01 for 1%)
fromAddress	Wallet address initiating the swap
toAddress	Wallet address receiving the swapped tokens
gasless	Set to true for gasless transactions (Fly Trade pays gas), or false for standard transactions

Optional Parameters

Affiliate Fee:

• affiliateAddress: Address to receive affiliate fees

• affiliateFee: The fee percentage. For example: 1% = 0.01

Affiliate fees are deducted from the fromTokenAddress amount and sent to the specified address.

Example Request:

GET /aggregator/quote?network=ethereum&fromTokenAddress=0x0000000000000000000000000000000000000000&toTokenAddress=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&fromAddress=0xff270dc360ef80314c7d6b2564fe76eaf3979b1a&toAddress=0xff270dc360ef80314c7d6b2564fe76eaf3979b1a&sellAmount=1000000000000000000&slippage=0.005&gasless=false

Example Response:

{
  "id": "8de05661-09d6-4b82-ab63-1e32ee1fa297",
  "amountOut": "1956398549",
  "targetAddress": "0xa6e941eab67569ca4522f70d343714ff51d571c4",
  "fees": [
    {
      "type": "gas",
      "value": "0.0150"
    }
  ],
  "resourceEstimate": {
    "gasLimit": "191157"
  },
  "typedData": {
    "types": {
      "Swap": [
        {
          "name": "router",
          "type": "address"
        },
        {
          "name": "sender",
          "type": "address"
        },
        {
          "name": "recipient",
          "type": "address"
        },
        {
          "name": "fromAsset",
          "type": "address"
        },
        {
          "name": "toAsset",
          "type": "address"
        },
        {
          "name": "deadline",
          "type": "uint256"
        },
        {
          "name": "amountOutMin",
          "type": "uint256"
        },
        {
          "name": "swapFee",
          "type": "uint256"
        },
        {
          "name": "amountIn",
          "type": "uint256"
        }
      ]
    },
    "domain": {
      "name": "Magpie Router",
      "version": "3",
      "chainId": "1",
      "verifyingContract": "0xa6e941eab67569ca4522f70d343714ff51d571c4"
    },
    "message": {
      "router": "0xa6e941eab67569ca4522f70d343714ff51d571c4",
      "sender": "0xff270dc360ef80314c7d6b2564fe76eaf3979b1a",
      "recipient": "0xff270dc360ef80314c7d6b2564fe76eaf3979b1a",
      "fromAsset": "0x0000000000000000000000000000000000000000",
      "toAsset": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
      "deadline": "1770978796",
      "amountOutMin": "1946616556",
      "swapFee": "0",
      "amountIn": "1000000000000000000"
    }
  }
}

Save the id as quoteId for Step 2.

Important Quote Constraints:

Quote Expiry: Each quote has a 5-minute expiration window. After 5 minutes, the quoteId becomes invalid and you will not be able to fetch the transaction payload. If your quote has expired, you must request a fresh quote before proceeding.

Single-Use Quotes: Each quote can only be used to fetch the transaction payload once. After successfully calling /aggregator/transaction with a quoteId, that quote is consumed and cannot be reused. If you need to execute another swap or retry, you must fetch a new quote.

Step 2 — Get Transaction Payload

Endpoint:

• Method: GET

• Path: /aggregator/transaction

Required Parameters:

Parameter	Description
quoteId	The quote id returned from Step 1

Optional Parameters:

Parameter	Description	Default
estimateGas	Whether to estimate gas when building the transaction. If true, ensures token approval and balance checks are performed. If gas estimation fails, returns error "Couldn't estimate gas"	true

Important: When estimateGas=true, you must have:

• Sufficient token approval for the router contract (for ERC-20 swaps)

• Enough token balance for the swap

• Otherwise, the endpoint will return an error and fail to generate the transaction

Example Request:

GET /aggregator/transaction?quoteId=8de05661-09d6-4b82-ab63-1e32ee1fa297

Example Response:

{
  "from": "0xff270dc360ef80314c7d6b2564fe76eaf3979b1a",
  "to": "0xa6e941eab67569ca4522f70d343714ff51d571c4",
  "data": "0x73fc44570000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000028b023800e06820587e343da884230b6611d1802b92359e5a720000000000000000000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48e000d4e000d9f800dec800e06e56ebccdd4913e5a2237edfd027143f1676f1ebc69ed7c08cb80f21950ce07a3b39fe615ad5647ee02714e905116ef1f543e7c00d10317b81bd72e5746752c31c0000e0698efe33e0012917bbf800c82386f26fc10000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20200e70300df128acb08000000000000000000000000fffd8963efd1fc6a506488495d951d5263988d2500000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000014c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000000101010603008a0300df04010500801445f32d1a74872ba41f3d8cf4022e9996120b3100070a0000000000000000000000000000000000000000000000000000000000000301a8050000020070000206070706000000000000000000000000000000000000000000000000000000e0012a95ec0301d20500600301f300020a0b00000000000000000000000000000000000000000000000000000000000302010500800301f3eda49bce2f38d284f839be1f4f2e23e6c7cc7dbd02007002022b0500a00005060708070000000000000000000000000000000000000000000000000000000302480500800301f30500600200700200480500c004000000fb0101000000004001850194019407002001c901cf000006002001cf01d2000008002001f8020100000700200222022b0000030000023f024800000800200269027500000300000275027e0000000000000000000000000000000000000000000000",
  "chainId": 1,
  "type": 2,
  "gasLimit": "314086",
  "maxFeePerGas": "228922087",
  "maxPriorityFeePerGas": "190605439",
  "value": "10000000000000000"
}

Alternative: Combined Quote + Transaction Endpoint

For faster integration, you can fetch both quote and transaction data in a single request.

Endpoint:

• Method: GET

• Path: /aggregator/quote/transaction

Parameters:

Accepts all parameters from the /aggregator/quote endpoint (network, fromTokenAddress, toTokenAddress, sellAmount, slippage, fromAddress, toAddress, gasless).

Note: fromAddress and toAddress are required for this endpoint and it doesn't estimate gas.

Example Request:

GET /aggregator/quote/transaction?network=ethereum&fromTokenAddress=0x0000000000000000000000000000000000000000&toTokenAddress=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&fromAddress=0xff270dc360ef80314c7d6b2564fe76eaf3979b1a&toAddress=0xff270dc360ef80314c7d6b2564fe76eaf3979b1a&sellAmount=1000000000000000000&slippage=0.005&gasless=false&estimateGas=true

Example Response:

Returns both quote data and transaction payload in one response:

json

{
  "quote": {
    "id": "8de05661-09d6-4b82-ab63-1e32ee1fa297",
    "amountOut": "1956398549",
    "targetAddress": "0xa6e941eab67569ca4522f70d343714ff51d571c4",
    "fees": [
      {
        "type": "gas",
        "value": "0.0150"
      }
    ],
    "resourceEstimate": {
      "gasLimit": "191157"
    }
  },
  "transaction": {
    "from": "0xff270dc360ef80314c7d6b2564fe76eaf3979b1a",
    "to": "0xa6e941eab67569ca4522f70d343714ff51d571c4",
    "data": "0x73fc44570000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000028b023800e06820587e343da884230b6611d1802b92359e5a720000000000000000000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48e000d4e000d9f800dec800e06e56ebccdd4913e5a2237edfd027143f1676f1ebc69ed7c08cb80f21950ce07a3b39fe615ad5647ee02714e905116ef1f543e7c00d10317b81bd72e5746752c31c0000e0698efe33e0012917bbf800c82386f26fc10000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20200e70300df128acb08000000000000000000000000fffd8963efd1fc6a506488495d951d5263988d2500000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000014c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000000101010603008a0300df04010500801445f32d1a74872ba41f3d8cf4022e9996120b3100070a0000000000000000000000000000000000000000000000000000000000000301a8050000020070000206070706000000000000000000000000000000000000000000000000000000e0012a95ec0301d20500600301f300020a0b00000000000000000000000000000000000000000000000000000000000302010500800301f3eda49bce2f38d284f839be1f4f2e23e6c7cc7dbd02007002022b0500a00005060708070000000000000000000000000000000000000000000000000000000302480500800301f30500600200700200480500c004000000fb0101000000004001850194019407002001c901cf000006002001cf01d2000008002001f8020100000700200222022b0000030000023f024800000800200269027500000300000275027e0000000000000000000000000000000000000000000000",
    "chainId": 1,
    "type": 2,
    "gasLimit": "314086",
    "maxFeePerGas": "228922087",
    "maxPriorityFeePerGas": "190605439",
    "value": "10000000000000000"
  }
}

Gasless Swaps (Optional)

When gasless=true in the quote request, the user pays for gas in fromToken instead of native tokens, and Fly Trade's relayer executes the transaction on your behalf.

Important Constraints:

• Only works for ERC-20 tokens - Native token swaps cannot be gasless

• You still need to approve tokens first before executing the swap for the tokens which don't support permit

• The gas fee is deducted from the fromToken amount

Example Gasless Quote Request:

GET /aggregator/quote?network=sonic&fromTokenAddress=0x29219dd400f2bf60e5a23d13be72b486d4038894&toTokenAddress=0xd3dce716f3ef535c5ff8d041c1a41c3bd89b97ae&fromAddress=0x28de4113921BD79388B0ef80A259f871977442E9&toAddress=0x6820587e343da884230b6611d1802b92359e5a72&sellAmount=10000000&slippage=0.005&gasless=true

Example Gasless Quote Response:

json

{
  "id": "d74e0978-010d-48cb-ba59-f86df26d9ea0",
  "amountOut": "10016611",
  "targetAddress": "0xc325856e5585823aac0d1fd46c35c608d95e65a9",
  "fees": [
    {
      "type": "gas",
      "value": "0.0009"
    }
  ],
  "resourceEstimate": {
    "gasLimit": "374574"
  },
  "typedData": {
    "types": {
      "Swap": [
        {
          "name": "router",
          "type": "address"
        },
        {
          "name": "sender",
          "type": "address"
        },
        {
          "name": "recipient",
          "type": "address"
        },
        {
          "name": "fromAsset",
          "type": "address"
        },
        {
          "name": "toAsset",
          "type": "address"
        },
        {
          "name": "deadline",
          "type": "uint256"
        },
        {
          "name": "amountOutMin",
          "type": "uint256"
        },
        {
          "name": "swapFee",
          "type": "uint256"
        },
        {
          "name": "amountIn",
          "type": "uint256"
        }
      ]
    },
    "domain": {
      "name": "Magpie Router",
      "version": "3",
      "chainId": "146",
      "verifyingContract": "0xc325856e5585823aac0d1fd46c35c608d95e65a9"
    },
    "message": {
      "router": "0xc325856e5585823aac0d1fd46c35c608d95e65a9",
      "sender": "0x28de4113921BD79388B0ef80A259f871977442E9",
      "recipient": "0x6820587e343da884230b6611d1802b92359e5a72",
      "fromAsset": "0x29219dd400f2bf60e5a23d13be72b486d4038894",
      "toAsset": "0xd3dce716f3ef535c5ff8d041c1a41c3bd89b97ae",
      "deadline": "1770983503",
      "amountOutMin": "9966528",
      "swapFee": "369",
      "amountIn": "9999631"
    }
  }
}

Executing a Gasless Swap:

After receiving the quote response, you need to:

1. Sign the message from typedData in the quote response with your wallet to generate swapSignature

2. (Optional) Handle token approval:

   • If the token supports EIP-2612 permit: Sign a permit message to generate permitSignature and permitDeadline

   • If the token doesn't support permit: Approve the token for the router address first, then leave permitSignature and permitDeadline empty

3. Call the execute swap endpoint with the signatures

Execute Swap Endpoint:

• Method: POST

• Path: /user-manager/execute-swap

Required Parameters:

Parameter	Description	Required
networkName	Network name (e.g., sonic, ethereum, polygon)	Yes
quoteId	The quote id returned from the quote endpoint	Yes
swapSignature	Signature of the typedData message from the quote response	Yes
permitSignature	EIP-2612 permit signature (only if token supports permit)	Conditional
permitDeadline	Unix timestamp for permit expiration (only if token supports permit)	Conditional

Example Request:

POST /user-manager/execute-swap?networkName=sonic&quoteId=d74e0978-010d-48cb-ba59-f86df26d9ea0&swapSignature=0x1b40ebfe734e90fe402dee623530e3e7669ad4df119b0173a58778f27b6ed3a152fa7b1be1458679c83e06a4e56b8243beabfc48304401ac14999af3a57da2931c&permitSignature=0xdcc1e88a9fc875cdc8dbad1d2d439e8679e105542f0a5c3c6204127b76be21af20fdcaf4090296d12db76e93227390a917dbb5c9292dc682edf6e0b5b0adf8051c&permitDeadline=1771001220

Gasless Swap Flow Example (TypeScript):

typescript

import { ethers } from 'ethers';

async function executeGaslessSwap() {
  const provider = new ethers.providers.Web3Provider(window.ethereum);
  const signer = provider.getSigner();
  const userAddress = await signer.getAddress();

  // Step 1: Get gasless quote
  const quoteUrl = new URL('https://api.fly.trade/aggregator/quote');
  quoteUrl.searchParams.set('network', 'sonic');
  quoteUrl.searchParams.set('fromTokenAddress', '0x29219dd400f2bf60e5a23d13be72b486d4038894');
  quoteUrl.searchParams.set('toTokenAddress', '0xd3dce716f3ef535c5ff8d041c1a41c3bd89b97ae');
  quoteUrl.searchParams.set('fromAddress', userAddress);
  quoteUrl.searchParams.set('toAddress', userAddress);
  quoteUrl.searchParams.set('sellAmount', '10000000');
  quoteUrl.searchParams.set('slippage', '0.005');
  quoteUrl.searchParams.set('gasless', 'true');

  const quoteRes = await fetch(quoteUrl.toString());
  const quote = await quoteRes.json();

  // Step 2: Sign the swap message
  const swapSignature = await signer._signTypedData(
    quote.typedData.domain,
    quote.typedData.types,
    quote.typedData.message
  );

  // Step 3: Handle permit (if token supports it)
  let permitSignature = '';
  let permitDeadline = '';
  
  // Check if token supports permit and sign permit message
  // If not, approve the token manually first
  const tokenContract = new ethers.Contract(
    quote.typedData.message.fromAsset,
    ['function approve(address,uint256) returns (bool)'],
    signer
  );
  await tokenContract.approve(quote.targetAddress, quote.typedData.message.amountIn);

  // Step 4: Execute gasless swap
  const executeUrl = new URL('https://api.fly.trade/user-manager/execute-swap');
  executeUrl.searchParams.set('networkName', 'sonic');
  executeUrl.searchParams.set('quoteId', quote.id);
  executeUrl.searchParams.set('swapSignature', swapSignature);
  if (permitSignature) {
    executeUrl.searchParams.set('permitSignature', permitSignature);
    executeUrl.searchParams.set('permitDeadline', permitDeadline);
  }

  const executeRes = await fetch(executeUrl.toString(), { method: 'POST' });
  const result = await executeRes.json();

  console.log('Gasless swap executed:', result);
}

Step 3 — Execute the Swap Transaction

Once you have the transaction payload (from Step 2 or the combined endpoint), you can execute it using your preferred web3 library.

Important: Depending on the blockchain, the transaction response may use EIP-1559 format with maxFeePerGas and maxPriorityFeePerGas (if the chain supports EIP-1559) or legacy format with gasPrice. Make sure your wallet/library supports both transaction types.

Integration Examples

Example 1: Frontend Integration (React + Ethers.js)

Example for integrating swaps in a React frontend application:

import { useState } from 'react';
import { ethers } from 'ethers';

function SwapComponent() {
  const [loading, setLoading] = useState(false);
  const [status, setStatus] = useState('');

  async function handleSwap() {
    if (!window.ethereum) {
      alert('Please install MetaMask');
      return;
    }

    setLoading(true);
    setStatus('Connecting wallet...');

    try {
      // Connect wallet
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      await provider.send('eth_requestAccounts', []);
      const signer = provider.getSigner();
      const userAddress = await signer.getAddress();

      // Swap parameters
      const fromToken = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'; // USDC
      const toToken = '0x0000000000000000000000000000000000000000'; // ETH
      const amount = '1000000'; // 1 USDC (6 decimals)

      // Check and approve if needed (ERC-20 only)
      if (fromToken !== '0x0000000000000000000000000000000000000000') {
        setStatus('Checking token approval...');
        
        // Get router address from a sample quote
        const sampleQuoteUrl = `https://api.fly.trade/aggregator/quote?network=ethereum&fromTokenAddress=${fromToken}&toTokenAddress=${toToken}&sellAmount=${amount}&slippage=0.005&fromAddress=${userAddress}&toAddress=${userAddress}&gasless=false`;
        const sampleQuoteRes = await fetch(sampleQuoteUrl);
        const sampleQuote = await sampleQuoteRes.json();
        const routerAddress = sampleQuote.targetAddress;

        // Check allowance
        const tokenContract = new ethers.Contract(
          fromToken,
          ['function allowance(address,address) view returns (uint256)', 'function approve(address,uint256) returns (bool)'],
          signer
        );
        const allowance = await tokenContract.allowance(userAddress, routerAddress);

        if (allowance.lt(amount)) {
          setStatus('Approving tokens...');
          const approveTx = await tokenContract.approve(routerAddress, ethers.constants.MaxUint256);
          await approveTx.wait();
          setStatus('Approval confirmed');
        }
      }

      // Get quote and transaction in one call
      setStatus('Fetching quote...');
      const quoteUrl = new URL('https://api.fly.trade/aggregator/quote/transaction');
      quoteUrl.searchParams.set('network', 'ethereum');
      quoteUrl.searchParams.set('fromTokenAddress', fromToken);
      quoteUrl.searchParams.set('toTokenAddress', toToken);
      quoteUrl.searchParams.set('sellAmount', amount);
      quoteUrl.searchParams.set('slippage', '0.005');
      quoteUrl.searchParams.set('fromAddress', userAddress);
      quoteUrl.searchParams.set('toAddress', userAddress);
      quoteUrl.searchParams.set('gasless', 'false');

      const response = await fetch(quoteUrl.toString());
      if (!response.ok) {
        const error = await response.text();
        throw new Error(error);
      }

      const { quote, transaction } = await response.json();
      
      setStatus(`Swapping for ${ethers.utils.formatUnits(quote.amountOut, 18)} ETH...`);

      // Execute swap
      const tx = await signer.sendTransaction({
        to: transaction.to,
        data: transaction.data,
        value: transaction.value,
        gasLimit: transaction.gasLimit,
      });

      setStatus('Transaction sent. Waiting for confirmation...');
      const receipt = await tx.wait();

      setStatus(`✅ Swap completed! Tx: ${receipt.transactionHash}`);
      
    } catch (error) {
      console.error('Swap failed:', error);
      setStatus(`❌ Error: ${error.message}`);
    } finally {
      setLoading(false);
    }
  }

  return (
    <div>
      <button onClick={handleSwap} disabled={loading}>
        {loading ? 'Processing...' : 'Swap 1 USDC → ETH'}
      </button>
      {status && <p>{status}</p>}
    </div>
  );
}

export default SwapComponent;

Example 2: Smart Contract Integration

If you're building a smart contract that needs to execute swaps, here's how to integrate:

Solidity Contract Example:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IERC20 {
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract MySwapContract {
    address public flyRouter = 0xa6e941eab67569ca4522f70d343714ff51d571c4;
    
    // Execute swap by calling Fly Trade router with transaction data
    function executeSwap(
        address fromToken,
        uint256 amountIn,
        bytes calldata swapCallData
    ) external payable returns (bool) {
        // If swapping ERC-20 token, transfer it from user and approve router
        if (fromToken != address(0)) {
            require(
                IERC20(fromToken).transferFrom(msg.sender, address(this), amountIn),
                "Transfer failed"
            );
            require(
                IERC20(fromToken).approve(flyRouter, amountIn),
                "Approval failed"
            );
        }
        
        // Execute swap by calling the router with the provided calldata
        (bool success, ) = flyRouter.call{value: msg.value}(swapCallData);
        require(success, "Swap failed");
        
        return true;
    }
    
    // Allow contract to receive ETH
    receive() external payable {}
}

Off-chain Script to Call Contract:

import { ethers } from 'ethers';

async function executeContractSwap() {
  const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
  const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
  
  // Your contract instance
  const mySwapContract = new ethers.Contract(
    CONTRACT_ADDRESS,
    ['function executeSwap(address,uint256,bytes) payable returns (bool)'],
    wallet
  );
  
  // Step 1: Get quote and transaction data from Fly Trade API
  const quoteUrl = new URL('https://api.fly.trade/aggregator/quote/transaction');
  quoteUrl.searchParams.set('network', 'ethereum');
  quoteUrl.searchParams.set('fromTokenAddress', '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'); // USDC
  quoteUrl.searchParams.set('toTokenAddress', '0x0000000000000000000000000000000000000000'); // ETH
  quoteUrl.searchParams.set('sellAmount', '1000000'); // 1 USDC
  quoteUrl.searchParams.set('slippage', '0.005');
  quoteUrl.searchParams.set('fromAddress', CONTRACT_ADDRESS); // Your contract address
  quoteUrl.searchParams.set('toAddress', wallet.address); // User receives tokens
  quoteUrl.searchParams.set('gasless', 'false');
  quoteUrl.searchParams.set('estimateGas', 'false'); // Disable gas estimation for contracts
  
  const response = await fetch(quoteUrl.toString());
  const { quote, transaction } = await response.json();
  
  // Step 2: Approve USDC for your contract (if user hasn't already)
  const usdcContract = new ethers.Contract(
    '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
    ['function approve(address,uint256) returns (bool)'],
    wallet
  );
  
  const approveTx = await usdcContract.approve(CONTRACT_ADDRESS, '1000000');
  await approveTx.wait();
  
  // Step 3: Call your contract's executeSwap function with the transaction calldata
  const swapTx = await mySwapContract.executeSwap(
    '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // fromToken (USDC)
    '1000000', // amountIn
    transaction.data, // calldata from Fly Trade
    { value: 0 } // msg.value (0 for ERC-20 → ETH swap)
  );
  
  const receipt = await swapTx.wait();
  console.log('Swap executed:', receipt.transactionHash);
}

Important Notes for Contract Integration:

• Set estimateGas=false when getting transaction data for contract calls

• The contract must approve the Fly router before swapping ERC-20 tokens

• Pass the transaction data from Fly Trade API directly to the router as calldata

• The router address is 0xa6e941eab67569ca4522f70d343714ff51d571c4 on Ethereum (check for other chains)

---

Network Support

Fly Trade supports swaps on multiple EVM networks. You must use the network name (not chain ID) in API requests:

Network Name	Description
ethereum	Ethereum Mainnet
polygon	Polygon
bsc	BNB Smart Chain
arbitrum	Arbitrum One
optimism	Optimism
base	Base
avalanche	Avalanche C-Chain
blast	Blast
manta	Manta Pacific
scroll	Scroll
fantom	Fantom
polygonzk	Polygon zkEVM
zksync	zkSync Era
linea	Linea
solana	Solana (see separate guide)

For the complete and up-to-date list of supported network names, refer to the network dropdown in our Swagger documentation for aggregator/quote endpoint or get it from /token-manager/networks endpoint.