Swap Router

Stateless router for executing token swaps against WarpX V3 pools with optimal routing.

Exact Input (Single Hop)

struct ExactInputSingleParams {    address tokenIn;    address tokenOut;    uint24 fee;    address recipient;    uint256 deadline;    uint256 amountIn;    uint256 amountOutMinimum;    uint160 sqrtPriceLimitX96;}function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut)

Swaps an exact amount of input tokens for as many output tokens as possible in a single pool.

Parameters:

Field	Description
tokenIn	Token to swap from
tokenOut	Token to swap to
fee	Pool fee tier (100, 500, 3000, 10000)
recipient	Address to receive output tokens
deadline	Transaction expiry timestamp
amountIn	Exact amount of input tokens
amountOutMinimum	Minimum output (slippage protection)
sqrtPriceLimitX96	Price limit (0 = no limit)

Example:

// Swap exactly 1000 USDC for WETHISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({    tokenIn: USDC,    tokenOut: WETH,    fee: 3000,    recipient: msg.sender,    deadline: block.timestamp + 300,    amountIn: 1000e6,    amountOutMinimum: 0.4e18,  // Min 0.4 WETH    sqrtPriceLimitX96: 0});uint256 amountOut = swapRouter.exactInputSingle(params);

---

Exact Input (Multi-Hop)

struct ExactInputParams {    bytes path;    address recipient;    uint256 deadline;    uint256 amountIn;    uint256 amountOutMinimum;}function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut)

Swaps an exact amount of input tokens through multiple pools for maximum output.

Path Encoding:

• Format: abi.encodePacked(tokenA, feeAB, tokenB, feeBC, tokenC)

• Example: USDC → (3000) → WETH → (3000) → DAI

Example:

// Swap USDC → WETH → DAIbytes memory path = abi.encodePacked(USDC,uint24(3000),  // 0.3% USDC/WETH poolWETH,uint24(3000),  // 0.3% WETH/DAI pool DAI);ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({    path: path,    recipient: msg.sender,    deadline: block.timestamp + 300,    amountIn: 1000e6,    amountOutMinimum: 950e18});uint256 amountOut = swapRouter.exactInput(params);

---

Exact Output (Single Hop)

struct ExactOutputSingleParams {
    address tokenIn;    
    address tokenOut;    
    uint24 fee;    
    address recipient;    
    uint256 deadline;    
    uint256 amountOut;    
    uint256 amountInMaximum;    
    uint160 sqrtPriceLimitX96;
}

function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn)

Swaps as few input tokens as possible for an exact amount of output tokens.

Example:

// Receive exactly 1 WETH, spending at most 2500 USDCISwapRouter.ExactOutputSingleParams memory params = ISwapRouter.ExactOutputSingleParams({    tokenIn: USDC,    tokenOut: WETH,    fee: 3000,    recipient: msg.sender,    deadline: block.timestamp + 300,    amountOut: 1e18,       // Exactly 1 WETH    amountInMaximum: 2500e6,    sqrtPriceLimitX96: 0});uint256 amountIn = swapRouter.exactOutputSingle(params);// Refund excess: if (amountIn < 2500e6) refund the difference

---

Exact Output (Multi-Hop)

struct ExactOutputParams {
    bytes path;
    address recipient;
    uint256 deadline;
    uint256 amountOut;
    uint256 amountInMaximum;
}
function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn)

Swaps through multiple pools to receive an exact output amount.

Path Encoding (Reversed):

• Format: abi.encodePacked(tokenC, feeBC, tokenB, feeAB, tokenA)

• For USDC → WETH → DAI, encode as: DAI → WETH → USDC

Example:

// Get exactly 1000 DAI via USDC → WETH → DAIbytes memory path = abi.encodePacked(    DAI,           // Output token (reversed!)    uint24(3000),    WETH,    uint24(3000),    USDC           // Input token (reversed!));ISwapRouter.ExactOutputParams memory params = ISwapRouter.ExactOutputParams({    path: path,    recipient: msg.sender,    deadline: block.timestamp + 300,    amountOut: 1000e18,    amountInMaximum: 1050e6});uint256 amountIn = swapRouter.exactOutput(params);

---

Token Approvals

Before swapping, approve the router to spend your tokens:

IERC20(tokenIn).approve(address(swapRouter), amountIn);

---

Handling Native ETH

For ETH swaps, use WETH as tokenIn or tokenOut and send ETH with the transaction:

// Swap ETH for USDC
ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({tokenIn: WETH,tokenOut: USDC,fee: 3000,recipient: msg.sender,deadline: block.timestamp + 300,amountIn: 1e18,amountOutMinimum: 2000e6,sqrtPriceLimitX96: 0});swapRouter.exactInputSingle{value: 1e18}(params);

---

Price Limits

Set sqrtPriceLimitX96 to prevent execution beyond a certain price:

• Zero for one (token0 → token1): Price cannot go below this value

• One for zero (token1 → token0): Price cannot go above this value

• Set to 0: No price limit

---

Best Practices

1. Always set slippage protection: Use amountOutMinimum / amountInMaximum

2. Use deadlines: Set reasonable expiry times (e.g., 5 minutes)

3. Multi-hop carefully: More hops = more gas + more slippage

4. Check routes: Use off-chain router to find optimal paths

5. Handle refunds: For exact output swaps, refund unused input tokens

---

Interface

interface ISwapRouter {
    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut); 
    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
    function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}