Multi-Hop Swap

Sequential swaps through intermediate tokens

Multi-Hop Swap routes trades through one or more intermediate tokens when no direct liquidity pool exists between the input and output tokens.

Structure

TokenA ──[DEX 1]──> TokenB ──[DEX 2]──> TokenC
       (Hop 1)              (Hop 2)

Characteristics:

• Sequential token swaps

• Uses intermediate "bridge" tokens (WBNB, WETH, USDT, etc.)

• Single path through multiple pools

• Necessary when direct pair doesn't exist

When Multi-Hop is Used

The API automatically selects Multi-Hop when:

✅ No direct pool - TokenA/TokenC pool doesn't exist ✅ Intermediate liquidity - Strong pools for TokenA→TokenB and TokenB→TokenC ✅ Common bridge token - TokenB is a major token (WBNB, USDT, BUSD) ✅ Better than alternatives - More efficient than batch splitting

Common Routing Patterns

Pattern 1: Through Native Token

ExoticToken → WBNB → USDT

Most common pattern for tokens without USDT pair.

Pattern 2: Through Stablecoin

TokenA → USDT → BUSD

Common for stablecoin swaps or tokens with better stablecoin liquidity.

Pattern 3: Extended Hop (Rare)

TokenA → WBNB → USDT → TokenD

Used when TokenA has no USDT pool but has WBNB pool.

Example Response

Real Example: CAKE → USDT

{
  "swapType": "multihop",
  "amountIn": "100000000000000000000",
  "amountOut": "580123456789012345678",
  "minAmountOut": "577222222222222222222",
  "gas": "220000",
  "routeInfo": {
    "routes": [{
      "adapter": "MultiHop",
      "percentage": 100,
      "path": {
        "tokens": [
          "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82", // CAKE
          "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c", // WBNB (bridge)
          "0x55d398326f99059fF775485246999027B3197955"  // USDT
        ],
        "adapters": [
          "PancakeSwapV3",  // CAKE → WBNB
          "UniswapV2"       // WBNB → USDT
        ],
        "fees": [3000, 0]   // 0.3% for V3, none for V2
      }
    }]
  }
}

Breakdown:

• Hop 1: 100 CAKE → 2.5 WBNB (via PancakeSwapV3)

• Hop 2: 2.5 WBNB → 580.12 USDT (via UniswapV2)

• Total Gas: 220k (vs 120k for simple)

Smart Contract Encoding

MultiHopSwapParams Structure

struct MultiHopSwapParams {
    uint8 swapType;        // 2 = MultiHop
    address tokenIn;
    address tokenOut;
    uint256 amountIn;
    uint256 minAmountOut;
    address receiver;
    uint256 deadline;
}

struct MultiHopRoute {
    address[] adapters;    // One per hop
    address[] path;        // All tokens including intermediates
    uint24[] fees;         // Fees for each pool
}

Execution Flow

function executeMultiHopSwap(
    MultiHopSwapParams memory params,
    MultiHopRoute memory route
) external {
    uint256 currentAmount = params.amountIn;

    // Execute each hop sequentially
    for (uint i = 0; i < route.adapters.length; i++) {
        address adapter = route.adapters[i];
        address tokenIn = route.path[i];
        address tokenOut = route.path[i + 1];

        // Execute hop
        currentAmount = IAdapter(adapter).swap(
            currentAmount,
            0,  // No min for intermediate hops
            tokenIn,
            tokenOut
        );
    }

    // Verify final output
    require(currentAmount >= params.minAmountOut, "Slippage exceeded");

    // Transfer to receiver
    IERC20(params.tokenOut).transfer(params.receiver, currentAmount);
}

Gas Costs

Hops	BSC Gas	Ethereum Gas	vs Simple
2 hops	200k-250k	220k-300k	+80-130k
3 hops	280k-350k	320k-450k	+160-230k
4 hops	350k-450k	420k-600k	+230-330k

Gas increases with:

• Number of hops

• DEX protocol complexity (V3 > V2)

• Token transfer costs

Example Calculation:

// 2-hop multi-hop on BSC
const gasUnits = 220000;
const gasPrice = 5e9; // 5 gwei
const bnbPrice = 580;

const gasCost = gasUnits * gasPrice / 1e18 * bnbPrice;
console.log(`Gas cost: $${gasCost.toFixed(2)}`);
// Output: Gas cost: $0.638

// vs Simple swap gas: $0.348
// Extra cost: $0.29

Advantages

✅ Enables Unavailable Swaps

Without multi-hop, many token pairs would be impossible:

❌ Direct: CAKE → USDT pool doesn't exist
✅ Multi-Hop: CAKE → WBNB → USDT works!

✅ Accesses Deep Liquidity

Bridge tokens have the deepest liquidity:

WBNB pools: $2B+ total liquidity
Direct exotic pairs: $10M liquidity

Multi-hop often provides better rates!

✅ Predictable Routing

Standard routing patterns:

• Most tokens have WBNB pair

• WBNB has pairs with all major tokens

• Easy to predict and understand

Limitations

❌ Higher Gas Costs

Each hop adds ~80-100k gas:

Simple: 120k gas
2-hop: 220k gas (+83%)
3-hop: 320k gas (+167%)

❌ Compounding Slippage

Each hop has its own slippage:

Hop 1: 100 CAKE → 2.5 WBNB (0.3% slippage)
Hop 2: 2.5 WBNB → 580 USDT (0.2% slippage)

Total slippage: ~0.5% (0.3% + 0.2%)

Must set higher slippage tolerance!

❌ Increased Failure Risk

Any hop can fail:

• Bridge token price spike

• Intermediate pool depleted

• MEV attack on any hop

Atomic execution means one failure = entire swap reverts.

❌ Higher Price Impact

Affects two pools instead of one:

Single pool impact: 0.5%
Two pools impact: 0.3% + 0.4% = 0.7% total

Code Examples

JavaScript Implementation

import { ethers } from 'ethers';

async function executeMultiHopSwap() {
  // 1. Build multi-hop route
  const response = await fetch('/api/v1/route/build', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      chain: 'bsc',
      tokenIn: '0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82', // CAKE
      tokenOut: '0x55d398326f99059fF775485246999027B3197955', // USDT
      amountIn: ethers.parseEther('100').toString(),
      sender: wallet.address,
      recipient: wallet.address,
      slippageTolerance: 100 // Higher for multi-hop!
    })
  });

  const { data } = await response.json();

  // 2. Analyze multi-hop path
  if (data.swapType === 'multihop') {
    const route = data.routeInfo.routes[0];
    console.log('Multi-Hop Path:');

    for (let i = 0; i < route.path.tokens.length - 1; i++) {
      const tokenIn = route.path.tokens[i];
      const tokenOut = route.path.tokens[i + 1];
      const adapter = route.path.adapters?.[i] || 'Unknown';

      console.log(`  Hop ${i + 1}: ${tokenIn} → ${tokenOut}`);
      console.log(`    via ${adapter}`);
    }

    console.log(`\nTotal hops: ${route.path.tokens.length - 1}`);
    console.log(`Gas: ${data.gas} units`);
  }

  // 3. Calculate effective slippage
  const expectedOutput = BigInt(data.amountOut);
  const minOutput = BigInt(data.minAmountOut);
  const slippage = Number((expectedOutput - minOutput) * 10000n / expectedOutput) / 100;
  console.log(`Slippage protection: ${slippage.toFixed(2)}%`);

  // 4. Approve tokenIn
  const tokenIn = new ethers.Contract(
    data.tokenIn,
    ['function approve(address,uint256) external'],
    wallet
  );

  const approveTx = await tokenIn.approve(
    data.aggregatorAddress,
    data.amountIn
  );
  await approveTx.wait();

  // 5. Execute swap
  const aggregator = new ethers.Contract(
    data.aggregatorAddress,
    AGGREGATOR_ABI,
    wallet
  );

  const tx = await aggregator.smartSwapByOrderId(
    orderId,
    data.executorAddress,
    data.executorData,
    {
      gasLimit: data.gas,
      gasPrice: data.gasPrice
    }
  );

  console.log(`Transaction sent: ${tx.hash}`);
  const receipt = await tx.wait();
  console.log(`Multi-hop swap confirmed in block ${receipt.blockNumber}`);
}

Python Implementation

from web3 import Web3
import requests

def execute_multihop_swap(w3, wallet_address, private_key):
    # Build route
    response = requests.post('http://localhost:8081/api/v1/route/build', json={
        'chain': 'bsc',
        'tokenIn': '0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82',  # CAKE
        'tokenOut': '0x55d398326f99059fF775485246999027B3197955',  # USDT
        'amountIn': str(Web3.to_wei(100, 'ether')),
        'sender': wallet_address,
        'recipient': wallet_address,
        'slippageTolerance': 100  # 1% for multi-hop
    })

    data = response.json()['data']

    # Analyze path
    if data['swapType'] == 'multihop':
        route = data['routeInfo']['routes'][0]
        tokens = route['path']['tokens']
        adapters = route['path'].get('adapters', [])

        print("Multi-Hop Path:")
        for i in range(len(tokens) - 1):
            token_in = tokens[i]
            token_out = tokens[i + 1]
            adapter = adapters[i] if i < len(adapters) else 'Unknown'

            print(f"  Hop {i+1}: {token_in[:10]}... → {token_out[:10]}...")
            print(f"    via {adapter}")

        print(f"\nTotal hops: {len(tokens) - 1}")
        print(f"Gas: {data['gas']} units")

    # Approve token
    token_in = w3.eth.contract(
        address=data['tokenIn'],
        abi=[{
            'constant': False,
            'inputs': [
                {'name': 'spender', 'type': 'address'},
                {'name': 'amount', 'type': 'uint256'}
            ],
            'name': 'approve',
            'outputs': [{'name': '', 'type': 'bool'}],
            'type': 'function'
        }]
    )

    approve_tx = token_in.functions.approve(
        data['aggregatorAddress'],
        int(data['amountIn'])
    ).build_transaction({
        'from': wallet_address,
        'nonce': w3.eth.get_transaction_count(wallet_address)
    })

    signed_approve = w3.eth.account.sign_transaction(approve_tx, private_key)
    w3.eth.send_raw_transaction(signed_approve.rawTransaction)

    # Execute swap
    aggregator = w3.eth.contract(
        address=data['aggregatorAddress'],
        abi=AGGREGATOR_ABI
    )

    swap_tx = aggregator.functions.smartSwapByOrderId(
        order_id,
        data['executorAddress'],
        bytes.fromhex(data['executorData'][2:])
    ).build_transaction({
        'from': wallet_address,
        'gas': int(data['gas']),
        'gasPrice': int(data['gasPrice']),
        'nonce': w3.eth.get_transaction_count(wallet_address)
    })

    signed_swap = w3.eth.account.sign_transaction(swap_tx, private_key)
    tx_hash = w3.eth.send_raw_transaction(signed_swap.rawTransaction)

    print(f"Transaction hash: {tx_hash.hex()}")

    receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
    print(f"Multi-hop swap confirmed!")

Best Practices

✅ Higher Slippage Tolerance

Multi-hop needs more buffer:

// Calculate appropriate slippage
const hops = route.path.tokens.length - 1;
const baseSlippage = 50; // 0.5% per hop

// Add buffer for each hop
const slippageTolerance = baseSlippage * (1 + hops * 0.2);
console.log(`Recommended slippage: ${slippageTolerance} bps`);

// 2 hops: 50 * 1.4 = 70 bps (0.7%)
// 3 hops: 50 * 1.6 = 80 bps (0.8%)

✅ Verify Bridge Token Liquidity

Check intermediate pools before executing:

// Verify each hop has sufficient liquidity
for (let i = 0; i < route.path.tokens.length - 1; i++) {
  const tokenIn = route.path.tokens[i];
  const tokenOut = route.path.tokens[i + 1];

  // Query pool reserves
  const reserves = await getPoolReserves(tokenIn, tokenOut);

  if (reserves.tokenOut < expectedHopOutput * 2) {
    console.warn(`Low liquidity in hop ${i + 1}!`);
  }
}

✅ Monitor Bridge Token Prices

Sudden bridge token price moves affect your swap:

// Check bridge token volatility
const wbnbPrice = await getPrice('WBNB/USDT');
const priceHistory = await getPriceHistory('WBNB/USDT', '5m');

const volatility = calculateVolatility(priceHistory);
if (volatility > 2) {
  console.warn('High WBNB volatility - consider waiting');
}

✅ Set Appropriate Deadline

Longer paths need more time:

// Calculate deadline based on hops
const hops = route.path.tokens.length - 1;
const baseDeadline = 10 * 60; // 10 minutes

// Add 5 minutes per hop
const deadline = Math.floor(Date.now() / 1000) + baseDeadline + (hops * 5 * 60);

Troubleshooting

Issue: "Insufficient output amount" Error

Causes:

• Slippage too tight for multi-hop

• Bridge token price moved

• One pool had high price impact

Solution:

// Increase slippage tolerance
const slippageTolerance = 100; // 1% for 2-hop

// Or rebuild route
const freshRoute = await buildRoute({...params});

Issue: One Hop Fails, TX Reverts

Diagnose which hop:

// Simulate each hop individually
for (let i = 0; i < hops; i++) {
  const hopInput = calculateHopInput(i);
  const simulation = await simulateHop(
    route.adapters[i],
    route.path[i],
    route.path[i + 1],
    hopInput
  );

  if (!simulation.success) {
    console.error(`Hop ${i + 1} will fail:`, simulation.reason);
  }
}

Issue: Worse Rate Than Expected

Check:

• Bridge token arbitrage opportunities

• MEV bots front-running

• Recent price movements

Solution:

• Use private transaction relay (Flashbots, BloXroute)

• Add MEV protection

• Increase slippage slightly

Comparison with Other Types

Feature	Simple	Multi-Hop	Batch
Direct pair needed	✅ Yes	❌ No	✅ Yes
Gas cost	⭐⭐⭐⭐⭐ Lowest	⭐⭐⭐ Medium	⭐⭐ Higher
Slippage	⭐⭐⭐⭐ Low	⭐⭐⭐ Medium	⭐⭐⭐⭐ Low
Complexity	⭐ Simple	⭐⭐⭐ Medium	⭐⭐⭐⭐ Complex
Use case	Common pairs	Exotic pairs	Large orders

Related Topics

• Simple Swap - Direct single-DEX routing

• Batch Swap - Parallel liquidity splitting

• Parallel Multi-Hop - Complex routing

• Slippage Configuration - Configure tolerance

Summary

Multi-Hop Swap is ideal for:

• ✅ Token pairs without direct pools

• ✅ Accessing deeper liquidity through bridge tokens

• ✅ Swapping exotic/new tokens

• ✅ When indirect routing provides better rates

Not recommended for:

• ❌ High-frequency trading (gas cost)

• ❌ Very tight slippage requirements

• ❌ During bridge token volatility

• ❌ When direct pool exists with good liquidity