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

Solution:

• Fetch fresh route

• Increase slippage tolerance

• Set longer deadline

Issue: Unexpected Output

Check:

• Pool fee tier (0.05%, 0.3%, 1%)

• Recent price movements

• MEV sandwich attacks (use private relay)

Related Topics

• Batch Swap - Split liquidity across DEXes

• Multi-Hop Swap - Sequential routing

• API Reference - Build route endpoint

• Gas Optimization - Reduce costs

Summary

Simple Swap is ideal for:

• ✅ Small to medium-sized trades ($100-$50k)

• ✅ Popular token pairs with deep liquidity

• ✅ When gas cost matters

• ✅ Quick, straightforward swaps

Use Batch or Multi-Hop swaps for:

• ❌ Large trades requiring price optimization

• ❌ Exotic token pairs without direct pools

• ❌ When saving 0.1-0.5% on rate justifies extra gas