Parallel Multi-Hop

Advanced parallel routing with internal multi-hop chains

Parallel Multi-Hop is the most sophisticated swap type, combining batch splitting with multi-hop routing to optimize very large trades across multiple complex paths.

Structure

         ┌─[DEX A]→ TokenB ─[DEX B]→┐
         │     (Path 1: 2 hops)       │
TokenA ──┤                             ├─> TokenD
         │     (Path 2: 2 hops)       │
         └─[DEX C]→ TokenC ─[DEX D]→ ┘

Characteristics:

• Multiple parallel routes

• Each route has multiple hops

• Combines Batch + Multi-Hop strategies

• Maximum liquidity access

• Highest complexity

When Parallel Multi-Hop is Used

The API automatically selects this type when:

✅ Very large trade - Amount exceeds single-path capacity ✅ Multiple indirect paths - Several multi-hop routes available ✅ Rate optimization - Complex routing beats simpler approaches ✅ Sufficient gas budget - Extra gas cost justified by rate improvement

Real-World Example

Scenario: $500k TokenA → TokenD Swap

Why Parallel Multi-Hop:

Simple swap via TokenA/TokenD:
  Pool depth: $200k
  Price impact: 15%
  Output: $425k ❌

Parallel Multi-Hop:
  Path 1 (60%): TokenA → WBNB → TokenD ($300k)
    Impact: 3% + 2% = 5%
  Path 2 (40%): TokenA → USDT → TokenD ($200k)
    Impact: 2% + 3% = 5%

  Combined output: $475k ✅
  Savings: $50k (10.5% better!)

Example Response

{
  "swapType": "parallel_multihop",
  "amountIn": "500000000000000000000000",
  "amountOut": "475123456789012345678901",
  "minAmountOut": "470872222222222222222222",
  "gas": "450000",
  "routeInfo": {
    "routes": [
      {
        "adapter": "MultiHopPath1",
        "percentage": 60,
        "path": {
          "tokens": [
            "0xTokenA",
            "0xWBNB",
            "0xTokenD"
          ],
          "adapters": [
            "PancakeSwapV3",
            "UniswapV2"
          ],
          "fees": [3000, 0]
        }
      },
      {
        "adapter": "MultiHopPath2",
        "percentage": 40,
        "path": {
          "tokens": [
            "0xTokenA",
            "0xUSDT",
            "0xTokenD"
          ],
          "adapters": [
            "UniswapV3",
            "PancakeSwapV2"
          ],
          "fees": [500, 0]
        }
      }
    ]
  }
}

Breakdown:

• Path 1 (60%):

  • 300k TokenA → 174 WBNB (PancakeSwapV3)

  • 174 WBNB → 285k TokenD (UniswapV2)

• Path 2 (40%):

  • 200k TokenA → 190k USDT (UniswapV3)

  • 190k USDT → 190k TokenD (PancakeSwapV2)

• Total: 475k TokenD

• Gas: 450k units (~$1.50 on BSC)

Smart Contract Encoding

ParallelMultiHopParams Structure

struct ParallelMultiHopParams {
    uint8 swapType;        // 3 = ParallelMultiHop
    address tokenIn;
    address tokenOut;
    uint256 amountIn;
    uint256 minAmountOut;
    address receiver;
    uint256 deadline;
}

struct ParallelPath {
    uint16 percentage;        // Allocation in basis points
    address[] adapters;       // Adapters for each hop in this path
    address[] tokens;         // Full token path including intermediates
    uint24[] fees;            // Fees for each pool in this path
}

struct ParallelMultiHopData {
    ParallelPath[] paths;
}

Execution Flow

function executeParallelMultiHopSwap(
    ParallelMultiHopParams memory params,
    ParallelMultiHopData memory data
) external {
    uint256 totalOutput = 0;

    // Execute each path in parallel
    for (uint i = 0; i < data.paths.length; i++) {
        ParallelPath memory path = data.paths[i];

        // Calculate this path's input amount
        uint256 pathAmountIn = params.amountIn * path.percentage / 10000;
        uint256 currentAmount = pathAmountIn;

        // Execute hops within this path sequentially
        for (uint j = 0; j < path.adapters.length; j++) {
            address adapter = path.adapters[j];
            address tokenIn = path.tokens[j];
            address tokenOut = path.tokens[j + 1];
            uint24 fee = path.fees[j];

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

        // Add this path's output to total
        totalOutput += currentAmount;
    }

    // Verify total output meets minimum
    require(totalOutput >= params.minAmountOut, "Slippage exceeded");

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

Gas Costs

Parallel Multi-Hop is the most expensive:

Configuration	BSC Gas	Ethereum Gas	Cost @ 5 gwei
2 paths × 2 hops	350k-450k	400k-550k	$1.01-$1.30
3 paths × 2 hops	500k-650k	600k-800k	$1.45-$1.88
2 paths × 3 hops	450k-600k	550k-750k	$1.30-$1.74
3 paths × 3 hops	650k-850k	800k-1100k	$1.88-$2.46

Gas Formula:

estimatedGas = baseGas + (numPaths * 80000) + (totalHops * 50000)

Example: 3 paths × 2 hops each
= 100000 + (3 * 80000) + (6 * 50000)
= 100000 + 240000 + 300000
= 640000 gas

Advantages

✅ Maximum Liquidity Access

Combines liquidity from:

• Multiple DEX protocols

• Multiple token pairs

• Multiple routing paths

Total accessible liquidity =
  Σ (liquidity of each path)

Can easily handle $1M+ swaps

✅ Minimal Price Impact

Large amounts split intelligently:

Swap Size	Single Path Impact	Parallel Multi-Hop Impact	Savings
$100k	2%	0.8%	$1,200
$500k	10%	3%	$35,000
$1M	25%	6%	$190,000
$5M	70%+	15%	$2,750,000+

✅ MEV Resistance

Complex routing makes front-running less profitable:

• Multiple pools to manipulate

• Split makes individual manipulation ineffective

• Higher complexity = higher MEV bot cost

✅ Best Rates for Whales

For institutional-size trades:

• Gas cost negligible vs. savings

• Access to all available liquidity

• Optimal route selection by algorithm

Limitations

❌ Very High Gas Cost

Simple swap: 120k gas = $0.35
Parallel Multi-Hop: 600k gas = $1.74

Break-even: Need ~$5+ improvement
Only worthwhile for $50k+ swaps

❌ Maximum Complexity

• Hardest to understand

• Most points of failure

• Complex debugging

• Difficult to predict output

❌ Compounding Risks

Each path has multiple failure points:

Success rate calculation:
Path 1: 99% × 99% = 98.01% (2 hops)
Path 2: 99% × 99% = 98.01% (2 hops)
Path 3: 99% × 99% = 98.01% (2 hops)

All paths succeed: 98.01%³ = 94.12%
Failure risk: ~6%

❌ High Slippage Tolerance Required

Compounding slippage across paths and hops:

Path 1: Hop1 (0.3%) + Hop2 (0.2%) = 0.5%
Path 2: Hop1 (0.4%) + Hop2 (0.3%) = 0.7%
Weighted: 60% × 0.5% + 40% × 0.7% = 0.58%

Recommended slippage: 1-2%

Code Examples

JavaScript Implementation

import { ethers } from 'ethers';

async function executeParallelMultiHopSwap() {
  // 1. Build route for large swap
  const response = await fetch('/api/v1/route/build', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      chain: 'bsc',
      tokenIn: '0xTokenA',
      tokenOut: '0xTokenD',
      amountIn: ethers.parseEther('500000').toString(), // $500k
      sender: wallet.address,
      recipient: wallet.address,
      slippageTolerance: 150, // 1.5% for complex routing
      includedSources: [
        'pancake',
        'pancake-v3',
        'uniswap',
        'uniswapv3'
      ]
    })
  });

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

  // 2. Analyze parallel multi-hop structure
  if (data.swapType === 'parallel_multihop') {
    console.log('Parallel Multi-Hop Detected:');
    console.log(`Total paths: ${data.routeInfo.routes.length}`);

    let totalHops = 0;

    data.routeInfo.routes.forEach((route, i) => {
      const pathAmount = BigInt(data.amountIn) * BigInt(route.percentage) / 100n;
      const hops = route.path.tokens.length - 1;
      totalHops += hops;

      console.log(`\nPath ${i + 1} (${route.percentage}%):`);
      console.log(`  Amount: ${ethers.formatEther(pathAmount)} TokenA`);
      console.log(`  Hops: ${hops}`);

      for (let j = 0; j < hops; j++) {
        console.log(`    Hop ${j + 1}: ${route.path.tokens[j]}`);
        console.log(`      → ${route.path.tokens[j + 1]}`);
        console.log(`      via ${route.path.adapters?.[j] || 'Unknown'}`);
      }
    });

    console.log(`\nTotal hops across all paths: ${totalHops}`);
    console.log(`Estimated gas: ${data.gas} units`);

    // 3. Calculate cost/benefit
    const gasCost = BigInt(data.gas) * BigInt(data.gasPrice);
    const gasCostUSD = Number(gasCost) / 1e18 * 580; // BNB price

    console.log(`\nGas cost: $${gasCostUSD.toFixed(2)}`);

    // Compare with simpler routing (if available)
    const improvement = data.amountOutUsd - estimatedSimpleSwapUsd;
    console.log(`Rate improvement: $${improvement.toFixed(2)}`);
    console.log(`Net benefit: $${(improvement - gasCostUSD).toFixed(2)}`);
  }

  // 4. Pre-flight checks
  console.log('\nPre-flight checks:');

  // Check each path individually
  for (const [idx, route] of data.routeInfo.routes.entries()) {
    console.log(`\nPath ${idx + 1} verification:`);

    // Simulate each hop in this path
    let currentAmount = BigInt(data.amountIn) * BigInt(route.percentage) / 100n;

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

      try {
        const simulated = await simulateSwap(
          adapter,
          tokenIn,
          tokenOut,
          currentAmount
        );

        console.log(`  ✓ Hop ${i + 1} OK: ${ethers.formatEther(simulated)} ${tokenOut}`);
        currentAmount = simulated;
      } catch (error) {
        console.error(`  ✗ Hop ${i + 1} FAIL:`, error.message);
        throw new Error(`Path ${idx + 1} Hop ${i + 1} would fail`);
      }
    }
  }

  console.log('\n✅ All paths verified');

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

  console.log('\nExecuting swap...');

  const tx = await aggregator.smartSwapByOrderId(
    orderId,
    data.executorAddress,
    data.executorData,
    {
      gasLimit: Math.floor(Number(data.gas) * 1.2), // +20% buffer
      gasPrice: data.gasPrice
    }
  );

  console.log(`Transaction sent: ${tx.hash}`);

  const receipt = await tx.wait();
  console.log(`\n✅ Parallel Multi-Hop swap confirmed!`);
  console.log(`Block: ${receipt.blockNumber}`);
  console.log(`Gas used: ${receipt.gasUsed.toString()}`);
}

// Helper function to simulate individual swaps
async function simulateSwap(
  adapter: string,
  tokenIn: string,
  tokenOut: string,
  amount: bigint
): Promise<bigint> {
  // Call adapter's getAmountOut or simulate transaction
  const adapterContract = new ethers.Contract(adapter, ADAPTER_ABI, provider);

  try {
    const output = await adapterContract.getAmountOut.staticCall(
      amount,
      tokenIn,
      tokenOut
    );
    return output;
  } catch (error) {
    throw new Error(`Simulation failed: ${error.message}`);
  }
}

Python Implementation

from web3 import Web3
import requests

def execute_parallel_multihop(w3, wallet_address, private_key):
    # Build route
    response = requests.post('http://localhost:8081/api/v1/route/build', json={
        'chain': 'bsc',
        'tokenIn': '0xTokenA',
        'tokenOut': '0xTokenD',
        'amountIn': str(Web3.to_wei(500000, 'ether')),
        'sender': wallet_address,
        'recipient': wallet_address,
        'slippageTolerance': 150,  # 1.5%
        'includedSources': ['pancake', 'pancake-v3', 'uniswap', 'uniswapv3']
    })

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

    # Analyze structure
    if data['swapType'] == 'parallel_multihop':
        print(f"Parallel Multi-Hop: {len(data['routeInfo']['routes'])} paths")

        total_hops = 0
        for i, route in enumerate(data['routeInfo']['routes']):
            path_amount = int(data['amountIn']) * route['percentage'] // 100
            hops = len(route['path']['tokens']) - 1
            total_hops += hops

            print(f"\nPath {i+1} ({route['percentage']}%):")
            print(f"  Amount: {Web3.from_wei(path_amount, 'ether')} TokenA")
            print(f"  Hops: {hops}")

            tokens = route['path']['tokens']
            adapters = route['path'].get('adapters', [])

            for j in range(hops):
                print(f"    Hop {j+1}: {tokens[j][:10]}...")
                print(f"      → {tokens[j+1][:10]}...")
                print(f"      via {adapters[j] if j < len(adapters) else 'Unknown'}")

        print(f"\nTotal hops: {total_hops}")
        print(f"Gas: {data['gas']} units")

        # Calculate costs
        gas_cost_wei = int(data['gas']) * int(data['gasPrice'])
        bnb_price = 580
        gas_cost_usd = Web3.from_wei(gas_cost_wei, 'ether') * bnb_price

        print(f"Gas cost: ${gas_cost_usd:.2f}")

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

    tx = aggregator.functions.smartSwapByOrderId(
        order_id,
        data['executorAddress'],
        bytes.fromhex(data['executorData'][2:])
    ).build_transaction({
        'from': wallet_address,
        'gas': int(data['gas']) * 12 // 10,  # +20% buffer
        'gasPrice': int(data['gasPrice']),
        'nonce': w3.eth.get_transaction_count(wallet_address)
    })

    signed_tx = w3.eth.account.sign_transaction(tx, private_key)
    tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)

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

    receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
    print(f"✅ Confirmed in block {receipt['blockNumber']}")
    print(f"Gas used: {receipt['gasUsed']}")

Best Practices

✅ Only for Large Swaps

Minimum viable swap size:

const gasUnits = 600000;
const gasPrice = 5e9; // 5 gwei
const bnbPrice = 580;

const gasCost = gasUnits * gasPrice / 1e18 * bnbPrice;
// $1.74

// Need 0.5% improvement to justify
const minSwapSize = gasCost / 0.005;
// $348 minimum

// Conservative: $50k+ for parallel multi-hop

✅ Verify All Paths

// Test each path independently before executing
const pathSimulations = await Promise.all(
  data.routeInfo.routes.map(async (route, i) => {
    try {
      const output = await simulatePath(route);
      return { success: true, path: i, output };
    } catch (error) {
      return { success: false, path: i, error };
    }
  })
);

const failures = pathSimulations.filter(s => !s.success);
if (failures.length > 0) {
  console.error('Some paths will fail:', failures);
  throw new Error('Path verification failed');
}

✅ Higher Gas Limit

Always add buffer:

const estimatedGas = BigInt(data.gas);
const gasLimit = estimatedGas * 130n / 100n; // +30% buffer

// Parallel multi-hop can spike unexpectedly

✅ Monitor Intermediate Tokens

Track bridge token prices:

// Monitor all bridge tokens used
const bridgeTokens = new Set();

data.routeInfo.routes.forEach(route => {
  route.path.tokens.slice(1, -1).forEach(token => {
    bridgeTokens.add(token);
  });
});

console.log('Bridge tokens:', Array.from(bridgeTokens));

// Alert on unusual volatility
bridgeTokens.forEach(async (token) => {
  const volatility = await getVolatility(token, '10m');
  if (volatility > 3) {
    console.warn(`High volatility in ${token}: ${volatility}%`);
  }
});

When to Use

✅ Ideal For:

• Whale trades ($500k+)

• Institutional swaps

• Large OTC deals

• Treasury operations

• When rate >> gas cost

❌ Avoid For:

• Small swaps (<$50k)

• Retail traders

• High-frequency trading

• Gas-sensitive operations

• Simple token pairs with deep direct pools

Comparison Summary

Feature	Simple	Batch	Multi-Hop	Parallel Multi-Hop
Gas Cost	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐ Highest
Best Rate	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐ Best
Liquidity Access	⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐ Maximum
Complexity	⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐ Highest
Min Swap Size	Any	$100+	$50+	$50k+
Slippage	0.1-0.5%	0.3-0.8%	0.5-1%	1-2%

Related Topics

• Simple Swap - Basic routing

• Batch Swap - Parallel splitting

• Multi-Hop Swap - Sequential routing

• Gas Optimization - Reduce costs

• Slippage Guide - Configure tolerance

Summary

Parallel Multi-Hop is the ultimate routing strategy for:

• ✅ Maximizing rate on very large trades

• ✅ Accessing all available liquidity

• ✅ Minimizing price impact for whales

• ✅ When gas cost is negligible vs. swap size

It's overkill for:

• ❌ Retail-sized swaps

• ❌ Gas-sensitive use cases

• ❌ Simple token pairs

• ❌ When simpler routing suffices

Rule of thumb: If your swap is <$50k, you probably don't need this.