SwapRouter contract development

2025-03-27

Author of this section: @mocha.wiz @Fish

this talk we will guide you through SwapRouter.sol development of contracts.

Contract Introduction

SwapRouter contracts are used to pool multiple trades Pool the trading portfolio of a contract is one transaction. Each token pair may have multiple trading pools, because the liquidity, fees, and price limits of the trading pool are different, so a user's one-time trading demand may occur in multiple trading pools. In Uniswap, cross-transaction-to-transaction is also supported. For example, there are only two transaction pairs A/B and B/C, and users can complete A/C transactions through the two transaction pairs A/B and B/C. However, our course will be relatively simple, only need to support different trading pools of the same trading pair, but overall we will also refer to Uniswap's SwapRouter.sol code.

In this contract, we mainly provide exactInput and exactOutput method, which is used to determine how many tokens are exchanged and how many tokens are exchanged. In their input parameters, you need to specify which trading pools to trade in (array. indexPath Specify), so the choice of which trading pools to trade in needs to be implemented in subsequent front-end courses, combining liquidity and fees, etc. to select a specific trading pool, while the contract only needs to implement trading in accordance with the specified trading pool order.

In addition, there is a need to implement quoteExactInput and quoteExactOutput method to simulate transactions and provide front-end information (users need to know the Token they need or obtain before trading). These two methods will refer to Uniswap's Quoter.sol implementation, Quoter it means "offer.

Contract Development

the complete code is in demo-contract/contracts/wtfswap/SwapRouter.sol in.

1. Implement the transaction interface

we first realize exactInput , the logic is also very simple, is to traverse indexPath , and then get the address of the corresponding trading pool, and then call the trading pool's swap interface, if the Midway transaction is completed, exit the traversal in advance.

The specific code is as follows:

function exactInput(
    ExactInputParams calldata params
) external payable override returns (uint256 amountOut) {
    // 记录确定的输入 token 的 amount
    uint256 amountIn = params.amountIn;

    // 根据 tokenIn 和 tokenOut 的大小关系，确定是从 token0 到 token1 还是从 token1 到 token0
    bool zeroForOne = params.tokenIn < params.tokenOut;

    // 遍历指定的每一个 pool
    for (uint256 i = 0; i < params.indexPath.length; i++) {
        address poolAddress = poolManager.getPool(
            params.tokenIn,
            params.tokenOut,
            params.indexPath[i]
        );

        // 如果 pool 不存在，则抛出错误
        require(poolAddress != address(0), "Pool not found");

        // 获取 pool 实例
        IPool pool = IPool(poolAddress);

        // 构造 swapCallback 函数需要的参数
        bytes memory data = abi.encode(
            params.tokenIn,
            params.tokenOut,
            params.indexPath[i],
            params.recipient == address(0) ? address(0) : msg.sender,
            true
        );

        // 调用 pool 的 swap 函数，进行交换，并拿到返回的 token0 和 token1 的数量
        (int256 amount0, int256 amount1) = pool.swap(
            params.recipient,
            zeroForOne,
            int256(amountIn),
            params.sqrtPriceLimitX96,
            data
        );

        // 更新 amountIn 和 amountOut
        amountIn -= uint256(zeroForOne ? amount0 : amount1);
        amountOut += uint256(zeroForOne ? -amount1 : -amount0);

        // 如果 amountIn 为 0，表示交换完成，跳出循环
        if (amountIn == 0) {
            break;
        }
    }

    // 如果交换到的 amountOut 小于指定的最少数量 amountOutMinimum，则抛出错误
    require(amountOut >= params.amountOutMinimum, "Slippage exceeded");

    // 发送 Swap 事件
    emit Swap(msg.sender, zeroForOne, params.amountIn, amountIn, amountOut);

    // 返回 amountOut
    return amountOut;
}

where we call swap function is constructed with a data , it will be in Pool when the contract callback is passed back, we need to pass the relevant information in the callback function to continue the transaction.

Next we continue to implement the callback function swapCallback and the code is as follows:

function swapCallback(
    int256 amount0Delta,
    int256 amount1Delta,
    bytes calldata data
) external override {
    // transfer token
    (
        address tokenIn,
        address tokenOut,
        uint32 index,
        address payer,
        bool isExactInput
    ) = abi.decode(data, (address, address, uint32, address, bool));
    address _pool = poolManager.getPool(tokenIn, tokenOut, index);

    // 检查 callback 的合约地址是否是 Pool
    require(_pool == msg.sender, "Invalid callback caller");

    (uint256 amountToPay, uint256 amountReceived) = amount0Delta > 0
        ? (uint256(amount0Delta), uint256(-amount1Delta))
        : (uint256(amount1Delta), uint256(-amount0Delta));
    // payer 是 address(0)，这是一个用于预估 token 的请求（quoteExactInput or quoteExactOutput）
    // 参考代码 https://github.com/Uniswap/v3-periphery/blob/main/contracts/lens/Quoter.sol#L38
    if (payer == address(0)) {
        if (isExactInput) {
            // 指定输入情况下，抛出可以接收多少 token
            assembly {
                let ptr := mload(0x40)
                mstore(ptr, amountReceived)
                revert(ptr, 32)
            }
        } else {
            // 指定输出情况下，抛出需要转入多少 token
            assembly {
                let ptr := mload(0x40)
                mstore(ptr, amountToPay)
                revert(ptr, 32)
            }
        }
    }

    // 正常交易，转账给交易池
    if (amountToPay > 0) {
        IERC20(tokenIn).transferFrom(payer, _pool, amountToPay);
    }
}

as shown in the code above, in the callback function we resolve exactInput method passed in data , in addition to combining amount0Delta and amount1Delta complete the following logic:

by tokenIn and tokenOut and index get the corresponding Pool contract address, then and msg.sender Comparison, make sure that the call is from Pool contracts (to avoid being attacked).
By payer determine whether it is a quotation ( quoteExactInput or quoteExactOutput ) request, if yes, throw an error, throw the error with the number of token to be transferred in or received, later we need to use when implementing the quotation interface.
If it is not a quote request, the normal transfer to the transaction pool. We need to pass amount0Delta and amount1Delta to determine the number of tokens transferred in or out.

And exactInput similar, exactOutput the method is similar, except that one is based on amountIn to determine whether the transaction is closed, one is to follow. amountOut to determine whether the transaction is closed. The specific code will not be posted here, you can refer to it. demo-contract/contracts/wtfswap/SwapRouter.sol view the specific code content.

2. Implement quotation interface

for the quotation interface, we refer to Uniswap's Quoter.sol to achieve, it uses a little trick. Is to use try catch the wrap. swap interface, and then parse the number of tokens that need to be transferred in or received from the thrown error.

Why is this? Because we need to simulate swap method to estimate the Token required for the transaction, but because the Token exchange will not actually occur during the estimation, an error will be reported. By actively throwing a special error and then catching the error, the required information is parsed from the error message.

The specific code is as follows:

// 报价，指定 tokenIn 的数量和 tokenOut 的最小值，返回 tokenOut 的实际数量
function quoteExactInput(
    QuoteExactInputParams calldata params
) external override returns (uint256 amountOut) {
    // 因为没有实际 approve，所以这里交易会报错，我们捕获错误信息，解析需要多少 token
    try
        this.exactInput(
            ExactInputParams({
                tokenIn: params.tokenIn,
                tokenOut: params.tokenOut,
                indexPath: params.indexPath,
                recipient: address(0),
                deadline: block.timestamp + 1 hours,
                amountIn: params.amountIn,
                amountOutMinimum: 0,
                sqrtPriceLimitX96: params.sqrtPriceLimitX96
            })
        )
    {} catch (bytes memory reason) {
        return parseRevertReason(reason);
    }
}

we also refer to the code for parsing errors. Code for Uniswap introduce the following method:

/// @dev Parses a revert reason that should contain the numeric quote
function parseRevertReason(
    bytes memory reason
) private pure returns (uint256) {
    if (reason.length != 32) {
        if (reason.length < 68) revert("Unexpected error");
        assembly {
            reason := add(reason, 0x04)
        }
        revert(abi.decode(reason, (string)));
    }
    return abi.decode(reason, (uint256));
}

it looks pretty Hack, but it's also very practical. This eliminates the need to adapt the swap method to the needs of the estimated transaction, and the logic is simpler.

Contract Testing

Finally, let's add the relevant test code. In the process of writing the test code, the author found several imperceptible bugs. In the process of writing the smart contract, the test code is very important and can help us find some imperceptible problems.

The complete test code will not be posted, you can demo-contract/test/wtfswap/SwapRouter.ts view.

The following short paragraph is posted here as a note:

it("quoteExactInput", async function () {
  const { swapRouter, token0, token1 } = await deployFixture();

  const data = await swapRouter.simulate.quoteExactInput([
    {
      tokenIn: token0.address,
      tokenOut: token1.address,
      amountIn: 10n * 10n ** 18n,
      indexPath: [0, 1],
      sqrtPriceLimitX96: BigInt(encodeSqrtRatioX96(100, 1).toString()),
    },
  ]);
  expect(data.result).to.equal(97750848089103280585132n); // 10 个 token0 按照 10000 的价格大概可以换 97750 token1
});

in the call quoteExactInput method when we pass simulate the way to call because. quoteExactInput the method is to write the method, but in fact what we do is to estimate, so we pass simulate the way to call so that the transaction is not really executed.

This is also the case in the front-end courses. We will use this interface to estimate the user's transactions, so the front-end code can also be implemented by referring to our test code.

Support, congratulations, you have completed all the contract part of the course learning and code development, then let's continue to enter the front-end part of the learning. 🚀