Swaps & Routing

​

Path encoding

​

The router

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

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

struct ExactOutputSingleParams {
    address tokenIn; address tokenOut; PoolType poolType;
    address recipient; uint256 deadline;
    uint256 amountOut; uint256 amountInMaximum; uint160 sqrtPriceLimitX96;
}
function exactOutputSingle(ExactOutputSingleParams calldata) external payable returns (uint256 amountIn);

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

• Deadline: Expired() past it. Slippage: TooLittleReceived() / TooMuchRequested().
• Price limit: 0 means “the widest the pool accepts” (MIN_SQRT_RATIO+1 / MAX_SQRT_RATIO−1) — a real bound, not “no limit”. A limit at or beyond the current price reverts InvalidSqrtPriceLimit(). Multi-hop entries always pass the widest per hop; there is no per-hop limit.
• A binding limit under-delivers instead of failing — and unlike upstream, this router checks the shortfall itself: an exact-output swap that cannot fill reverts TooLittleReceived() rather than silently delivering less.
• Exact-output pulls only what the swap cost — no ERC-20 change is left behind. Native over-send must be reclaimed by you (below).
• Fee taken on the output side: on a pool whose fee coin is the token you buy, the pool grosses an exact-output request up, so you still receive exactly amountOut unless the price limit binds. Swap deltas are always net, so slippage checks are unaffected.
• Amounts above int256.max revert AmountOutOfRange() — beyond it the cast flips exact-input into a monstrous exact-output.
• Gasless approvals: selfPermit / selfPermitIfNecessary on the router.

​

Native coin, multicall, and the one hard requirement

• msg.value is not a budget: every batched call sees the full amount. Payment logic spends the contract’s actual balance, so batching stays safe — but do not meter by msg.value.
• The router must hold nothing between transactions. The sweep helpers (refundNative, unwrapNative, sweepToken) send the whole balance to anyone who calls (anything a periphery contract reserves for others is left behind — on the router, that is nothing), and they revert NotWhileWorking() if called in the middle of an operation. Therefore: every entry point that can leave a balance must be called inside one atomic multicall that ends with the matching sweep. This is a hard requirement of the API, not a recommendation — a payable swap sent bare, stopped at its price limit, leaves coin the next caller takes.
• On a chain with no native wrapper (wrappedNative() == 0 — the Arc case, where the gas token is the quote ERC-20 seen at 18 decimals): refundNative and unwrapNative revert NoNativeWrapper(); use sweepToken. The router’s receive() rejects unsolicited native. Send no msg.value at all: every payable entry point, multicall included, reverts ValueNotAccepted() when value arrives on such a chain.

​

The quoter

function quoteExactInputSingle(address tokenIn, address tokenOut, PoolType poolType,
    uint256 amountIn, uint160 sqrtPriceLimitX96) external returns (uint256 amountOut);
function quoteExactOutputSingle(address tokenIn, address tokenOut, PoolType poolType,
    uint256 amountOut, uint160 sqrtPriceLimitX96) external returns (uint256 amountIn, uint256 amountOutReceived);
function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut);
function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn, uint256 amountOutReceived);

• Not a view — it prices by starting the swap and aborting it from the callback (revert-and-catch). Call it with eth_call; on-chain it burns a swap’s gas.
• amountOutReceived on the exact-output quoters reports what would actually arrive when a price limit cuts the swap short — compare routes on it, or you will pick one that cannot fill. V3’s quoter has no equivalent.
• A route may not visit the same pool twice (PoolVisitedTwice()): each simulated hop rolls back before the next, so a second visit would price against pre-trade reserves. Split such routes or price them yourself.
• Quotes are bids, not promises: dynamic fees price on measured volatility (and may price on the swap’s own size), so a quote ages faster than on a static-fee venue.

​

The pool-level swap

function swap(
    address recipient,
    bool zeroForOne,
    int256 amountSpecified,     // positive = exact input, negative = exact output
    uint160 sqrtPriceLimitX96,
    bytes calldata data
) external returns (int256 amount0, int256 amount1);   // deltas from the pool's view

function lunyaSwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external;