Simple Swap

Direct single-DEX token swaps

Simple Swap is the most straightforward and gas-efficient swap type, routing the entire trade through a single DEX adapter.

Structure

TokenA ────[Single DEX Adapter]────> TokenB
         (100% of liquidity)

Characteristics:

Single liquidity pool
Direct token pair
Lowest gas cost
Fastest execution

When Simple Swap is Used

The API automatically selects Simple Swap when:

✅ Direct pool exists - TokenA/TokenB pool is available ✅ Sufficient liquidity - Pool depth handles the swap amount ✅ Best rate - Single pool offers competitive pricing ✅ Gas efficiency priority - Minimizing transaction cost

Example Scenarios

Scenario 1: WBNB → USDT on BSC

{
  "swapType": "simple",
  "routeInfo": {
    "routes": [{
      "adapter": "PancakeSwapV3",
      "adapterAddress": "0x38BF57A209b9CAeCd3525B08B0CB1BCC7a598E4B",
      "percentage": 100,
      "path": {
        "tokens": [
          "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c", // WBNB
          "0x55d398326f99059fF775485246999027B3197955"  // USDT
        ]
      }
    }]
  }
}

Analysis:

100% liquidity via PancakeSwapV3
Direct WBNB/USDT pool
Gas: ~120k units
Single transaction

Scenario 2: ETH → USDC on Ethereum

{
  "swapType": "simple",
  "routeInfo": {
    "routes": [{
      "adapter": "UniswapV3",
      "adapterAddress": "0x1EAe07d4997Ce9A1C87aFAE924c257fdb7813607",
      "percentage": 100,
      "path": {
        "tokens": [
          "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
          "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"  // USDC
        ],
        "fees": [3000] // 0.3% pool fee
      }
    }]
  }
}

Analysis:

UniswapV3 0.3% fee tier
Most liquid ETH/USDC pool
Optimal for amounts < $100k

Smart Contract Encoding

SwapParams Structure

struct SwapParams {
    uint8 swapType;           // 0 = Simple
    address tokenIn;
    address tokenOut;
    uint256 amountIn;
    uint256 minAmountOut;
    address receiver;
    uint256 deadline;
}

struct SimpleSwapRoute {
    address adapter;
    address[] path;
    uint24[] fees;  // For V3 pools
}

Execution Flow

// 1. User approves tokenIn to Aggregator
tokenIn.approve(aggregator, amountIn);

// 2. Call aggregator with encoded data
aggregator.smartSwapByOrderId(
    orderId,
    executorAddress,
    executorData  // ABI-encoded SimpleSwapRoute
);

// 3. Aggregator forwards to Executor
executor.executeSimpleSwap(swapParams, route);

// 4. Executor calls DEX adapter
adapter.swap(amountIn, minAmountOut, path);

// 5. Tokens sent to receiver

Gas Costs

Network

DEX Type

Typical Gas

BSC

PancakeSwapV2

100k-120k

BSC

PancakeSwapV3

120k-150k

Ethereum

UniswapV2

110k-130k

Ethereum

UniswapV3

130k-180k

Note: V3 pools cost more due to concentrated liquidity calculations.

Advantages

✅ Lowest Gas Cost

Simple Swap has minimal overhead:

Single adapter call
No liquidity splitting
No intermediate swaps

✅ Fastest Execution

Fewer operations mean:

Lower transaction time
Less block space usage
Higher success rate

✅ Predictable Slippage

Single pool = single price impact:

Easy to calculate expected output
Transparent price mechanics
Consistent behavior

✅ Best for Small Amounts

For typical retail swaps ($100-$10k):

Pool depth is sufficient
Gas savings matter more
Price difference negligible vs. batch swaps

Limitations

❌ Limited by Pool Depth

Large swaps may experience:

High price impact
Insufficient liquidity
Better rates available via splitting

Example:

Swap: $500k WBNB → USDT
Simple Swap: 2.5% price impact
Batch Swap: 0.8% price impact (splits across 3 DEXes)

❌ Single Point of Failure

If the pool:

Has low liquidity temporarily
Experiences a price anomaly
Is being manipulated

Alternative routes might be better.

Code Examples

JavaScript (ethers.js)

import { ethers } from 'ethers';

// Build simple 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('1.0').toString(),
    sender: walletAddress,
    recipient: walletAddress,
    slippageTolerance: 50
  })
});

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

// Verify it's a simple swap
console.log('Swap type:', data.swapType); // "simple"
console.log('Using adapter:', data.routeInfo.routes[0].adapter);
console.log('Expected output:', ethers.formatUnits(data.amountOut, 18));

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

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

await tx.wait();

Python

import requests
from web3 import Web3

# Build route
response = requests.post('http://localhost:8081/api/v1/route/build', json={
    'chain': 'bsc',
    'tokenIn': '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
    'tokenOut': '0x55d398326f99059fF775485246999027B3197955',
    'amountIn': Web3.to_wei(1.0, 'ether'),
    'sender': wallet_address,
    'recipient': wallet_address,
    'slippageTolerance': 50
})

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

# Check swap type
if data['swapType'] == 'simple':
    print(f"Simple swap via {data['routeInfo']['routes'][0]['adapter']}")
    print(f"Expected output: {Web3.from_wei(int(data['amountOut']), 'ether')} USDT")

# 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:])
).transact({'from': wallet_address, 'value': int(data['value'])})

Best Practices

✅ Verify Pool Liquidity

Before executing large simple swaps:

// Check expected price impact
const priceImpact = (
  (parseFloat(data.amountIn) / parseFloat(data.amountOut)) - marketPrice
) / marketPrice * 100;

if (priceImpact > 1.0) {
  console.warn(`High price impact: ${priceImpact.toFixed(2)}%`);
  console.log('Consider using batch swap for better rates');
}

✅ Set Appropriate Slippage

// For simple swaps on stable pairs
const slippage = 10; // 0.1%

// For volatile pairs
const slippage = 50; // 0.5%

// During high volatility
const slippage = 100; // 1.0%

✅ Monitor Gas Prices

const feeData = await provider.getFeeData();
const gasPrice = feeData.gasPrice;

// Calculate total cost
const gasCost = BigInt(data.gas) * gasPrice;
const gasCostUSD = parseFloat(ethers.formatEther(gasCost)) * bnbPrice;

console.log(`Gas cost: ${gasCostUSD.toFixed(2)} USD`);

// Check if swap is profitable after gas
const swapProfit = data.amountOutUsd - data.amountInUsd;
if (swapProfit < gasCostUSD) {
  console.warn('Swap value less than gas cost!');
}

Comparison with Other Swap Types

Feature

Simple

Batch

Multi-Hop

Gas Cost

⭐⭐⭐⭐⭐ Lowest

⭐⭐⭐ Medium

⭐⭐ Higher

Best Rate

⭐⭐⭐ Good

⭐⭐⭐⭐⭐ Best

⭐⭐⭐ Variable

Complexity

⭐ Simplest

⭐⭐⭐ Complex

⭐⭐⭐⭐ Most Complex

Large Orders

⭐⭐ Limited

⭐⭐⭐⭐⭐ Excellent

⭐⭐⭐ Good

Slippage

⭐⭐⭐ Predictable

⭐⭐⭐⭐ Lower

⭐⭐⭐ Variable

Troubleshooting

Issue: High Price Impact

Solution:

Reduce swap amount
Try batch swap instead
Wait for better liquidity

Issue: Transaction Fails

Possible causes:

Pool liquidity changed
Slippage too tight
Deadline expired