Batch Swap

Split liquidity across multiple DEXes for optimal rates

Batch Swap intelligently splits your trade across multiple DEX adapters in parallel, optimizing for the best combined rate while managing price impact.

Structure

         ┌──[DEX A: 60%]──┐
TokenA ──┤                 ├──> TokenB
         └──[DEX B: 40%]──┘

Characteristics:

• Multiple parallel routes

• Same tokenIn and tokenOut

• Liquidity splitting by percentage

• Optimized for large orders

How It Works

Liquidity Distribution

The API calculates optimal splits based on:

1. Pool Depths - Available liquidity in each pool

2. Price Curves - Price impact at different volumes

3. Gas Costs - Additional overhead vs. rate improvement

4. Slippage - Combined slippage across routes

Example Calculation:

Total Swap: 10 BNB → USDT

Pool Analysis:
- PancakeSwapV3: 50 BNB depth, 0.3% fee → 60% allocation
- UniswapV2: 30 BNB depth, 0.25% fee → 40% allocation

Result:
- 6 BNB via PancakeSwapV3 → 3,480 USDT
- 4 BNB via UniswapV2 → 2,320 USDT
Total: 5,800 USDT (better than 5,750 via single pool)

When Batch Swap is Used

The API automatically selects Batch Swap when:

✅ Multiple competitive pools - Several DEXes offer similar rates ✅ Large swap amounts - Price impact reduction justifies extra gas ✅ Rate improvement > Gas cost - Net benefit after considering fees ✅ Sufficient liquidity - Multiple pools can handle split amounts

Example Response

Real-World Example: 5 BNB → USDT

{
  "swapType": "batch",
  "amountIn": "5000000000000000000",
  "amountOut": "2901234567890123456789",
  "minAmountOut": "2886725691358024691358",
  "gas": "180000",
  "routeInfo": {
    "routes": [
      {
        "adapter": "PancakeSwapV3",
        "adapterAddress": "0x38BF57A209b9CAeCd3525B08B0CB1BCC7a598E4B",
        "percentage": 60,
        "path": {
          "tokens": [
            "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
            "0x55d398326f99059fF775485246999027B3197955"
          ],
          "fees": [3000]
        }
      },
      {
        "adapter": "UniswapV2",
        "adapterAddress": "0x90e1C85D0542B8963906330825ddE2dec66b78C3",
        "percentage": 40,
        "path": {
          "tokens": [
            "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
            "0x55d398326f99059fF775485246999027B3197955"
          ]
        }
      }
    ]
  }
}

Breakdown:

• Route 1: 3 BNB (60%) via PancakeSwapV3 → 1,740.74 USDT

• Route 2: 2 BNB (40%) via UniswapV2 → 1,160.49 USDT

• Total: 2,901.23 USDT

• vs Single Route: ~2,895 USDT (saves ~$6)

Smart Contract Encoding

BatchSwapRoute Structure

struct BatchSwapParams {
    uint8 swapType;        // 1 = Batch
    address tokenIn;
    address tokenOut;
    uint256 amountIn;
    uint256 minAmountOut;
    address receiver;
    uint256 deadline;
}

struct BatchRoute {
    address adapter;
    uint16 percentage;     // Basis points (6000 = 60%)
    address[] path;
    uint24[] fees;
}

struct BatchSwapData {
    BatchRoute[] routes;
}

Execution Flow

// 1. Aggregator receives swap request
function smartSwapByOrderId(
    bytes32 orderId,
    address executor,
    bytes calldata data
) external payable {
    // Decode batch swap data
    BatchSwapData memory batchData = abi.decode(data, (BatchSwapData));

    // 2. Split amountIn by percentages
    for (uint i = 0; i < batchData.routes.length; i++) {
        uint256 routeAmount = amountIn * routes[i].percentage / 10000;

        // 3. Execute swap on each adapter
        uint256 output = adapter.swap(
            routeAmount,
            routes[i].path,
            routes[i].fees
        );

        totalOutput += output;
    }

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

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

Gas Costs

Routes	BSC Gas	Ethereum Gas	Additional Cost
2 DEXes	150k-200k	160k-220k	+30-50k vs Simple
3 DEXes	200k-280k	220k-320k	+60-100k vs Simple
4 DEXes	280k-350k	320k-450k	+100-150k vs Simple

Gas Cost Analysis:

// Calculate if batch swap is worth it
const simpleSwapOutput = 2895; // USDT
const batchSwapOutput = 2901;  // USDT
const improvement = batchSwapOutput - simpleSwapOutput; // $6

const simpleGas = 120000;
const batchGas = 180000;
const extraGas = batchGas - simpleGas; // 60000

const bnbPrice = 580; // USD
const gasPrice = 5; // gwei
const gasCost = extraGas * gasPrice / 1e9 * bnbPrice; // $0.174

// Net benefit: $6 - $0.174 = $5.826 ✅ Worth it!

Advantages

✅ Better Rates for Large Orders

Price Impact Comparison:

Swap Amount	Simple Swap Impact	Batch Swap Impact	Savings
$10k	0.2%	0.15%	$5
$50k	1.2%	0.6%	$300
$100k	3.5%	1.5%	$2,000
$500k	15%	6%	$45,000

✅ Reduced Slippage Risk

Multiple pools = diversified price exposure:

• Less vulnerable to single pool manipulation

• Better average execution price

• Lower total price impact

✅ Access More Liquidity

Single Pool: 100 BNB available
Batch Across 3 Pools: 100 + 80 + 60 = 240 BNB available

✅ Automatic Optimization

The API handles:

• Optimal percentage splits

• Gas cost calculations

• Route selection

• Slippage management

Limitations

❌ Higher Gas Costs

Simple: 120k gas = $0.348 (@ 5 gwei, $580 BNB)
Batch (2 DEXes): 180k gas = $0.522
Batch (3 DEXes): 250k gas = $0.725

Break-even point: ~$5 improvement needed per extra DEX

❌ Increased Complexity

• More points of failure

• Complex slippage calculations

• Harder to debug

• Potential atomic revert if one route fails

❌ Percentage Precision

// Routes must sum to 100%
Route 1: 60%
Route 2: 40%
Total: 100% ✅

// Small rounding errors possible
Route 1: 33.33%
Route 2: 33.33%
Route 3: 33.34%  // +0.01% to account for rounding

Code Examples

JavaScript Implementation

import { ethers } from 'ethers';

async function executeBatchSwap() {
  // 1. Build batch swap route
  const response = await fetch('/api/v1/route/build', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      chain: 'bsc',
      tokenIn: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
      tokenOut: '0x55d398326f99059fF775485246999027B3197955',
      amountIn: ethers.parseEther('5.0').toString(),
      sender: wallet.address,
      recipient: wallet.address,
      slippageTolerance: 50,
      includedSources: ['pancake', 'pancake-v3', 'uniswap', 'uniswapv3']
    })
  });

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

  // 2. Verify it's a batch swap
  if (data.swapType === 'batch') {
    console.log('Batch swap detected:');

    data.routeInfo.routes.forEach((route, i) => {
      const amount = BigInt(data.amountIn) * BigInt(route.percentage) / 100n;
      console.log(`  Route ${i + 1}: ${route.percentage}% via ${route.adapter}`);
      console.log(`    Amount: ${ethers.formatEther(amount)} BNB`);
    });

    // 3. Calculate improvement
    const improvement = data.amountOut - estimatedSimpleSwapOutput;
    console.log(`Rate improvement: ${ethers.formatUnits(improvement, 18)} USDT`);

    // 4. Check if worth the extra gas
    const extraGas = BigInt(data.gas) - 120000n;
    const extraGasCost = extraGas * BigInt(data.gasPrice) * 580n / 1000000000n;
    console.log(`Extra gas cost: $${ethers.formatEther(extraGasCost)}`);
  }

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

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

  const receipt = await tx.wait();
  console.log(`Batch swap executed: ${receipt.hash}`);
}

Python Implementation

from web3 import Web3
import requests

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

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

    # Analyze batch routes
    if data['swapType'] == 'batch':
        print("Batch Swap Routes:")
        for i, route in enumerate(data['routeInfo']['routes']):
            amount = int(data['amountIn']) * route['percentage'] // 100
            print(f"  Route {i+1}: {route['percentage']}% via {route['adapter']}")
            print(f"    Amount: {Web3.from_wei(amount, 'ether')} BNB")

    # 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,
        'value': int(data['value']),
        'gas': int(data['gas']),
        '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"Transaction hash: {tx_hash.hex()}")

    receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
    print(f"Batch swap confirmed in block {receipt['blockNumber']}")

Best Practices

✅ Minimum Swap Amount

Only use batch swaps for amounts where improvement justifies gas:

// Calculate minimum viable swap amount
const extraGas = 60000; // vs simple swap
const gasPrice = 5e9; // 5 gwei
const bnbPrice = 580;

const extraGasCost = extraGas * gasPrice / 1e18 * bnbPrice;
console.log(`Extra gas: $${extraGasCost.toFixed(2)}`);

// Need at least 0.2% improvement to justify
const minSwapAmount = extraGasCost / 0.002;
console.log(`Min swap amount: $${minSwapAmount.toFixed(2)}`);
// Result: ~$87 minimum for batch to be worthwhile

✅ Monitor Individual Routes

// Track which routes succeeded
const routeResults = await Promise.allSettled(
  data.routeInfo.routes.map(async (route) => {
    // Simulate each route
    return simulateSwap(route);
  })
);

// Check for failures
const failures = routeResults.filter(r => r.status === 'rejected');
if (failures.length > 0) {
  console.warn(`${failures.length} routes may fail`);
}

✅ Set Conservative Slippage

Batch swaps have compounding slippage:

// Each route has its own slippage
// Total slippage is weighted average

const calculateTotalSlippage = (routes, slippageTolerance) => {
  let weightedSlippage = 0;

  routes.forEach(route => {
    const weight = route.percentage / 100;
    weightedSlippage += weight * slippageTolerance;
  });

  // Add safety buffer
  return Math.ceil(weightedSlippage * 1.1);
};

// Use higher slippage for batch
const slippage = calculateTotalSlippage(data.routeInfo.routes, 50);
console.log(`Recommended slippage: ${slippage} bps`);

Troubleshooting

Issue: One Route Fails, Entire TX Reverts

Cause: Atomic execution - all routes must succeed

Solution:

// Before executing, verify each route independently
for (const route of data.routeInfo.routes) {
  const simulation = await provider.call({
    to: route.adapterAddress,
    data: encodeSwap(route)
  });

  if (simulation.error) {
    console.error(`Route via ${route.adapter} will fail:`, simulation.error);
    // Rebuild without this DEX
  }
}

Issue: Worse Rate Than Expected

Check:

• Market moved between quote and execution

• MEV sandwich attack

• One pool had stale price

Solution:

• Fetch fresh route

• Use private transaction relay

• Increase slippage slightly

Issue: High Gas Cost

Optimize:

// Limit number of routes
const maxRoutes = 3;

// Filter out low-percentage routes
const filteredRoutes = data.routeInfo.routes
  .filter(r => r.percentage >= 10)
  .slice(0, maxRoutes);

Comparison Table

Metric	Simple	Batch (2 DEX)	Batch (3 DEX)
Gas Cost	120k	180k (+50%)	250k (+108%)
Rate	Baseline	+0.2-0.5%	+0.3-0.8%
Complexity	Low	Medium	High
Min Amount	Any	$100+	$500+
Slippage Risk	Single pool	Diversified	Most diversified

Related Topics

• Simple Swap - Single DEX routing

• Multi-Hop Swap - Sequential routing

• Parallel Multi-Hop - Complex routing

• Gas Optimization - Reduce costs

Summary

Batch Swap is ideal for:

• ✅ Large trades ($100k+)

• ✅ When multiple DEXes have competitive rates

• ✅ Price optimization over gas savings

• ✅ Reducing price impact

Use Simple Swap for:

• ❌ Small trades (<$100)

• ❌ When gas cost matters most

• ❌ Single pool has dominant liquidity

• ❌ Quick, straightforward swaps