@diwantanushh/rapiddex-contracts 1.0.0

package/lib/v3-periphery-main/contracts/SwapRouter.sol

@@ -0,0 +1,244 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+import '@uniswap/v3-core/contracts/libraries/SafeCast.sol';
+import '@uniswap/v3-core/contracts/libraries/TickMath.sol';
+import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
+
+import './interfaces/ISwapRouter.sol';
+import './base/PeripheryImmutableState.sol';
+import './base/PeripheryValidation.sol';
+import './base/PeripheryPaymentsWithFee.sol';
+import './base/Multicall.sol';
+import './base/SelfPermit.sol';
+import './libraries/Path.sol';
+import './libraries/PoolAddress.sol';
+import './libraries/CallbackValidation.sol';
+import './interfaces/external/IWETH9.sol';
+
+/// @title Uniswap V3 Swap Router
+/// @notice Router for stateless execution of swaps against Uniswap V3
+contract SwapRouter is
+    ISwapRouter,
+    PeripheryImmutableState,
+    PeripheryValidation,
+    PeripheryPaymentsWithFee,
+    Multicall,
+    SelfPermit
+{
+    using Path for bytes;
+    using SafeCast for uint256;
+
+    /// @dev Used as the placeholder value for amountInCached, because the computed amount in for an exact output swap
+    /// can never actually be this value
+    uint256 private constant DEFAULT_AMOUNT_IN_CACHED = type(uint256).max;
+
+    /// @dev Transient storage variable used for returning the computed amount in for an exact output swap.
+    uint256 private amountInCached = DEFAULT_AMOUNT_IN_CACHED;
+
+    constructor(address _factory, address _WETH9) PeripheryImmutableState(_factory, _WETH9) {}
+
+    /// @dev Returns the pool for the given token pair and fee. The pool contract may or may not exist.
+    function getPool(
+        address tokenA,
+        address tokenB,
+        uint24 fee
+    ) private view returns (IUniswapV3Pool) {
+        return IUniswapV3Pool(PoolAddress.computeAddress(factory, PoolAddress.getPoolKey(tokenA, tokenB, fee)));
+    }
+
+    struct SwapCallbackData {
+        bytes path;
+        address payer;
+    }
+
+    /// @inheritdoc IUniswapV3SwapCallback
+    function uniswapV3SwapCallback(
+        int256 amount0Delta,
+        int256 amount1Delta,
+        bytes calldata _data
+    ) external override {
+        require(amount0Delta > 0 || amount1Delta > 0); // swaps entirely within 0-liquidity regions are not supported
+        SwapCallbackData memory data = abi.decode(_data, (SwapCallbackData));
+        (address tokenIn, address tokenOut, uint24 fee) = data.path.decodeFirstPool();
+        CallbackValidation.verifyCallback(factory, tokenIn, tokenOut, fee);
+
+        (bool isExactInput, uint256 amountToPay) =
+            amount0Delta > 0
+                ? (tokenIn < tokenOut, uint256(amount0Delta))
+                : (tokenOut < tokenIn, uint256(amount1Delta));
+        if (isExactInput) {
+            pay(tokenIn, data.payer, msg.sender, amountToPay);
+        } else {
+            // either initiate the next swap or pay
+            if (data.path.hasMultiplePools()) {
+                data.path = data.path.skipToken();
+                exactOutputInternal(amountToPay, msg.sender, 0, data);
+            } else {
+                amountInCached = amountToPay;
+                tokenIn = tokenOut; // swap in/out because exact output swaps are reversed
+                pay(tokenIn, data.payer, msg.sender, amountToPay);
+            }
+        }
+    }
+
+    /// @dev Performs a single exact input swap
+    function exactInputInternal(
+        uint256 amountIn,
+        address recipient,
+        uint160 sqrtPriceLimitX96,
+        SwapCallbackData memory data
+    ) private returns (uint256 amountOut) {
+        // allow swapping to the router address with address 0
+        if (recipient == address(0)) recipient = address(this);
+
+        (address tokenIn, address tokenOut, uint24 fee) = data.path.decodeFirstPool();
+
+        bool zeroForOne = tokenIn < tokenOut;
+
+        (int256 amount0, int256 amount1) =
+            getPool(tokenIn, tokenOut, fee).swap(
+                recipient,
+                zeroForOne,
+                amountIn.toInt256(),
+                sqrtPriceLimitX96 == 0
+                    ? (zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1)
+                    : sqrtPriceLimitX96,
+                abi.encode(data)
+            );
+
+        return uint256(-(zeroForOne ? amount1 : amount0));
+    }
+
+    /// @inheritdoc ISwapRouter
+    function exactInputSingle(ExactInputSingleParams calldata params)
+        external
+        payable
+        override
+        checkDeadline(params.deadline)
+        returns (uint256 amountOut)
+    {
+        amountOut = exactInputInternal(
+            params.amountIn,
+            params.recipient,
+            params.sqrtPriceLimitX96,
+            SwapCallbackData({path: abi.encodePacked(params.tokenIn, params.fee, params.tokenOut), payer: msg.sender})
+        );
+        require(amountOut >= params.amountOutMinimum, 'Too little received');
+    }
+
+    /// @inheritdoc ISwapRouter
+    function exactInput(ExactInputParams memory params)
+        external
+        payable
+        override
+        checkDeadline(params.deadline)
+        returns (uint256 amountOut)
+    {
+        address payer = msg.sender; // msg.sender pays for the first hop
+
+        while (true) {
+            bool hasMultiplePools = params.path.hasMultiplePools();
+
+            // the outputs of prior swaps become the inputs to subsequent ones
+            params.amountIn = exactInputInternal(
+                params.amountIn,
+                hasMultiplePools ? address(this) : params.recipient, // for intermediate swaps, this contract custodies
+                0,
+                SwapCallbackData({
+                    path: params.path.getFirstPool(), // only the first pool in the path is necessary
+                    payer: payer
+                })
+            );
+
+            // decide whether to continue or terminate
+            if (hasMultiplePools) {
+                payer = address(this); // at this point, the caller has paid
+                params.path = params.path.skipToken();
+            } else {
+                amountOut = params.amountIn;
+                break;
+            }
+        }
+
+        require(amountOut >= params.amountOutMinimum, 'Too little received');
+    }
+
+    /// @dev Performs a single exact output swap
+    function exactOutputInternal(
+        uint256 amountOut,
+        address recipient,
+        uint160 sqrtPriceLimitX96,
+        SwapCallbackData memory data
+    ) private returns (uint256 amountIn) {
+        // allow swapping to the router address with address 0
+        if (recipient == address(0)) recipient = address(this);
+
+        (address tokenOut, address tokenIn, uint24 fee) = data.path.decodeFirstPool();
+
+        bool zeroForOne = tokenIn < tokenOut;
+
+        (int256 amount0Delta, int256 amount1Delta) =
+            getPool(tokenIn, tokenOut, fee).swap(
+                recipient,
+                zeroForOne,
+                -amountOut.toInt256(),
+                sqrtPriceLimitX96 == 0
+                    ? (zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1)
+                    : sqrtPriceLimitX96,
+                abi.encode(data)
+            );
+
+        uint256 amountOutReceived;
+        (amountIn, amountOutReceived) = zeroForOne
+            ? (uint256(amount0Delta), uint256(-amount1Delta))
+            : (uint256(amount1Delta), uint256(-amount0Delta));
+        // it's technically possible to not receive the full output amount,
+        // so if no price limit has been specified, require this possibility away
+        if (sqrtPriceLimitX96 == 0) require(amountOutReceived == amountOut);
+    }
+
+    /// @inheritdoc ISwapRouter
+    function exactOutputSingle(ExactOutputSingleParams calldata params)
+        external
+        payable
+        override
+        checkDeadline(params.deadline)
+        returns (uint256 amountIn)
+    {
+        // avoid an SLOAD by using the swap return data
+        amountIn = exactOutputInternal(
+            params.amountOut,
+            params.recipient,
+            params.sqrtPriceLimitX96,
+            SwapCallbackData({path: abi.encodePacked(params.tokenOut, params.fee, params.tokenIn), payer: msg.sender})
+        );
+
+        require(amountIn <= params.amountInMaximum, 'Too much requested');
+        // has to be reset even though we don't use it in the single hop case
+        amountInCached = DEFAULT_AMOUNT_IN_CACHED;
+    }
+
+    /// @inheritdoc ISwapRouter
+    function exactOutput(ExactOutputParams calldata params)
+        external
+        payable
+        override
+        checkDeadline(params.deadline)
+        returns (uint256 amountIn)
+    {
+        // it's okay that the payer is fixed to msg.sender here, as they're only paying for the "final" exact output
+        // swap, which happens first, and subsequent swaps are paid for within nested callback frames
+        exactOutputInternal(
+            params.amountOut,
+            params.recipient,
+            0,
+            SwapCallbackData({path: params.path, payer: msg.sender})
+        );
+
+        amountIn = amountInCached;
+        require(amountIn <= params.amountInMaximum, 'Too much requested');
+        amountInCached = DEFAULT_AMOUNT_IN_CACHED;
+    }
+}

package/lib/v3-periphery-main/contracts/V3Migrator.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+import '@uniswap/v3-core/contracts/libraries/LowGasSafeMath.sol';
+import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
+
+import './interfaces/INonfungiblePositionManager.sol';
+
+import './libraries/TransferHelper.sol';
+
+import './interfaces/IV3Migrator.sol';
+import './base/PeripheryImmutableState.sol';
+import './base/Multicall.sol';
+import './base/SelfPermit.sol';
+import './interfaces/external/IWETH9.sol';
+import './base/PoolInitializer.sol';
+
+/// @title Uniswap V3 Migrator
+contract V3Migrator is IV3Migrator, PeripheryImmutableState, PoolInitializer, Multicall, SelfPermit {
+    using LowGasSafeMath for uint256;
+
+    address public immutable nonfungiblePositionManager;
+
+    constructor(
+        address _factory,
+        address _WETH9,
+        address _nonfungiblePositionManager
+    ) PeripheryImmutableState(_factory, _WETH9) {
+        nonfungiblePositionManager = _nonfungiblePositionManager;
+    }
+
+    receive() external payable {
+        require(msg.sender == WETH9, 'Not WETH9');
+    }
+
+    function migrate(MigrateParams calldata params) external override {
+        require(params.percentageToMigrate > 0, 'Percentage too small');
+        require(params.percentageToMigrate <= 100, 'Percentage too large');
+
+        // burn v2 liquidity to this address
+        IUniswapV2Pair(params.pair).transferFrom(msg.sender, params.pair, params.liquidityToMigrate);
+        (uint256 amount0V2, uint256 amount1V2) = IUniswapV2Pair(params.pair).burn(address(this));
+
+        // calculate the amounts to migrate to v3
+        uint256 amount0V2ToMigrate = amount0V2.mul(params.percentageToMigrate) / 100;
+        uint256 amount1V2ToMigrate = amount1V2.mul(params.percentageToMigrate) / 100;
+
+        // approve the position manager up to the maximum token amounts
+        TransferHelper.safeApprove(params.token0, nonfungiblePositionManager, amount0V2ToMigrate);
+        TransferHelper.safeApprove(params.token1, nonfungiblePositionManager, amount1V2ToMigrate);
+
+        // mint v3 position
+        (, , uint256 amount0V3, uint256 amount1V3) =
+            INonfungiblePositionManager(nonfungiblePositionManager).mint(
+                INonfungiblePositionManager.MintParams({
+                    token0: params.token0,
+                    token1: params.token1,
+                    fee: params.fee,
+                    tickLower: params.tickLower,
+                    tickUpper: params.tickUpper,
+                    amount0Desired: amount0V2ToMigrate,
+                    amount1Desired: amount1V2ToMigrate,
+                    amount0Min: params.amount0Min,
+                    amount1Min: params.amount1Min,
+                    recipient: params.recipient,
+                    deadline: params.deadline
+                })
+            );
+
+        // if necessary, clear allowance and refund dust
+        if (amount0V3 < amount0V2) {
+            if (amount0V3 < amount0V2ToMigrate) {
+                TransferHelper.safeApprove(params.token0, nonfungiblePositionManager, 0);
+            }
+
+            uint256 refund0 = amount0V2 - amount0V3;
+            if (params.refundAsETH && params.token0 == WETH9) {
+                IWETH9(WETH9).withdraw(refund0);
+                TransferHelper.safeTransferETH(msg.sender, refund0);
+            } else {
+                TransferHelper.safeTransfer(params.token0, msg.sender, refund0);
+            }
+        }
+        if (amount1V3 < amount1V2) {
+            if (amount1V3 < amount1V2ToMigrate) {
+                TransferHelper.safeApprove(params.token1, nonfungiblePositionManager, 0);
+            }
+
+            uint256 refund1 = amount1V2 - amount1V3;
+            if (params.refundAsETH && params.token1 == WETH9) {
+                IWETH9(WETH9).withdraw(refund1);
+                TransferHelper.safeTransferETH(msg.sender, refund1);
+            } else {
+                TransferHelper.safeTransfer(params.token1, msg.sender, refund1);
+            }
+        }
+    }
+}

package/lib/v3-periphery-main/contracts/base/BlockTimestamp.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+
+/// @title Function for getting block timestamp
+/// @dev Base contract that is overridden for tests
+abstract contract BlockTimestamp {
+    /// @dev Method that exists purely to be overridden for tests
+    /// @return The current block timestamp
+    function _blockTimestamp() internal view virtual returns (uint256) {
+        return block.timestamp;
+    }
+}

package/lib/v3-periphery-main/contracts/base/ERC721Permit.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+
+import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
+import '@openzeppelin/contracts/utils/Address.sol';
+
+import '../libraries/ChainId.sol';
+import '../interfaces/external/IERC1271.sol';
+import '../interfaces/IERC721Permit.sol';
+import './BlockTimestamp.sol';
+
+/// @title ERC721 with permit
+/// @notice Nonfungible tokens that support an approve via signature, i.e. permit
+abstract contract ERC721Permit is BlockTimestamp, ERC721, IERC721Permit {
+    /// @dev Gets the current nonce for a token ID and then increments it, returning the original value
+    function _getAndIncrementNonce(uint256 tokenId) internal virtual returns (uint256);
+
+    /// @dev The hash of the name used in the permit signature verification
+    bytes32 private immutable nameHash;
+
+    /// @dev The hash of the version string used in the permit signature verification
+    bytes32 private immutable versionHash;
+
+    /// @notice Computes the nameHash and versionHash
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        string memory version_
+    ) ERC721(name_, symbol_) {
+        nameHash = keccak256(bytes(name_));
+        versionHash = keccak256(bytes(version_));
+    }
+
+    /// @inheritdoc IERC721Permit
+    function DOMAIN_SEPARATOR() public view override returns (bytes32) {
+        return
+            keccak256(
+                abi.encode(
+                    // keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)')
+                    0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f,
+                    nameHash,
+                    versionHash,
+                    ChainId.get(),
+                    address(this)
+                )
+            );
+    }
+
+    /// @inheritdoc IERC721Permit
+    /// @dev Value is equal to keccak256("Permit(address spender,uint256 tokenId,uint256 nonce,uint256 deadline)");
+    bytes32 public constant override PERMIT_TYPEHASH =
+        0x49ecf333e5b8c95c40fdafc95c1ad136e8914a8fb55e9dc8bb01eaa83a2df9ad;
+
+    /// @inheritdoc IERC721Permit
+    function permit(
+        address spender,
+        uint256 tokenId,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable override {
+        require(_blockTimestamp() <= deadline, 'Permit expired');
+
+        bytes32 digest =
+            keccak256(
+                abi.encodePacked(
+                    '\x19\x01',
+                    DOMAIN_SEPARATOR(),
+                    keccak256(abi.encode(PERMIT_TYPEHASH, spender, tokenId, _getAndIncrementNonce(tokenId), deadline))
+                )
+            );
+        address owner = ownerOf(tokenId);
+        require(spender != owner, 'ERC721Permit: approval to current owner');
+
+        if (Address.isContract(owner)) {
+            require(IERC1271(owner).isValidSignature(digest, abi.encodePacked(r, s, v)) == 0x1626ba7e, 'Unauthorized');
+        } else {
+            address recoveredAddress = ecrecover(digest, v, r, s);
+            require(recoveredAddress != address(0), 'Invalid signature');
+            require(recoveredAddress == owner, 'Unauthorized');
+        }
+
+        _approve(spender, tokenId);
+    }
+}

package/lib/v3-periphery-main/contracts/base/LiquidityManagement.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol';
+import '@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3MintCallback.sol';
+import '@uniswap/v3-core/contracts/libraries/TickMath.sol';
+
+import '../libraries/PoolAddress.sol';
+import '../libraries/CallbackValidation.sol';
+import '../libraries/LiquidityAmounts.sol';
+
+import './PeripheryPayments.sol';
+import './PeripheryImmutableState.sol';
+
+/// @title Liquidity management functions
+/// @notice Internal functions for safely managing liquidity in Uniswap V3
+abstract contract LiquidityManagement is IUniswapV3MintCallback, PeripheryImmutableState, PeripheryPayments {
+    struct MintCallbackData {
+        PoolAddress.PoolKey poolKey;
+        address payer;
+    }
+
+    /// @inheritdoc IUniswapV3MintCallback
+    function uniswapV3MintCallback(
+        uint256 amount0Owed,
+        uint256 amount1Owed,
+        bytes calldata data
+    ) external override {
+        MintCallbackData memory decoded = abi.decode(data, (MintCallbackData));
+        CallbackValidation.verifyCallback(factory, decoded.poolKey);
+
+        if (amount0Owed > 0) pay(decoded.poolKey.token0, decoded.payer, msg.sender, amount0Owed);
+        if (amount1Owed > 0) pay(decoded.poolKey.token1, decoded.payer, msg.sender, amount1Owed);
+    }
+
+    struct AddLiquidityParams {
+        address token0;
+        address token1;
+        uint24 fee;
+        address recipient;
+        int24 tickLower;
+        int24 tickUpper;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+    }
+
+    /// @notice Add liquidity to an initialized pool
+    function addLiquidity(AddLiquidityParams memory params)
+        internal
+        returns (
+            uint128 liquidity,
+            uint256 amount0,
+            uint256 amount1,
+            IUniswapV3Pool pool
+        )
+    {
+        PoolAddress.PoolKey memory poolKey =
+            PoolAddress.PoolKey({token0: params.token0, token1: params.token1, fee: params.fee});
+
+        pool = IUniswapV3Pool(PoolAddress.computeAddress(factory, poolKey));
+
+        // compute the liquidity amount
+        {
+            (uint160 sqrtPriceX96, , , , , , ) = pool.slot0();
+            uint160 sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(params.tickLower);
+            uint160 sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(params.tickUpper);
+
+            liquidity = LiquidityAmounts.getLiquidityForAmounts(
+                sqrtPriceX96,
+                sqrtRatioAX96,
+                sqrtRatioBX96,
+                params.amount0Desired,
+                params.amount1Desired
+            );
+        }
+
+        (amount0, amount1) = pool.mint(
+            params.recipient,
+            params.tickLower,
+            params.tickUpper,
+            liquidity,
+            abi.encode(MintCallbackData({poolKey: poolKey, payer: msg.sender}))
+        );
+
+        require(amount0 >= params.amount0Min && amount1 >= params.amount1Min, 'Price slippage check');
+    }
+}

package/lib/v3-periphery-main/contracts/base/Multicall.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+import '../interfaces/IMulticall.sol';
+
+/// @title Multicall
+/// @notice Enables calling multiple methods in a single call to the contract
+abstract contract Multicall is IMulticall {
+    /// @inheritdoc IMulticall
+    function multicall(bytes[] calldata data) public payable override returns (bytes[] memory results) {
+        results = new bytes[](data.length);
+        for (uint256 i = 0; i < data.length; i++) {
+            (bool success, bytes memory result) = address(this).delegatecall(data[i]);
+
+            if (!success) {
+                // Next 5 lines from https://ethereum.stackexchange.com/a/83577
+                if (result.length < 68) revert();
+                assembly {
+                    result := add(result, 0x04)
+                }
+                revert(abi.decode(result, (string)));
+            }
+
+            results[i] = result;
+        }
+    }
+}

package/lib/v3-periphery-main/contracts/base/PeripheryImmutableState.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+
+import '../interfaces/IPeripheryImmutableState.sol';
+
+/// @title Immutable state
+/// @notice Immutable state used by periphery contracts
+abstract contract PeripheryImmutableState is IPeripheryImmutableState {
+    /// @inheritdoc IPeripheryImmutableState
+    address public immutable override factory;
+    /// @inheritdoc IPeripheryImmutableState
+    address public immutable override WETH9;
+
+    constructor(address _factory, address _WETH9) {
+        factory = _factory;
+        WETH9 = _WETH9;
+    }
+}

package/lib/v3-periphery-main/contracts/base/PeripheryPayments.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+
+import '../interfaces/IPeripheryPayments.sol';
+import '../interfaces/external/IWETH9.sol';
+
+import '../libraries/TransferHelper.sol';
+
+import './PeripheryImmutableState.sol';
+
+abstract contract PeripheryPayments is IPeripheryPayments, PeripheryImmutableState {
+    receive() external payable {
+        require(msg.sender == WETH9, 'Not WETH9');
+    }
+
+    /// @inheritdoc IPeripheryPayments
+    function unwrapWETH9(uint256 amountMinimum, address recipient) public payable override {
+        uint256 balanceWETH9 = IWETH9(WETH9).balanceOf(address(this));
+        require(balanceWETH9 >= amountMinimum, 'Insufficient WETH9');
+
+        if (balanceWETH9 > 0) {
+            IWETH9(WETH9).withdraw(balanceWETH9);
+            TransferHelper.safeTransferETH(recipient, balanceWETH9);
+        }
+    }
+
+    /// @inheritdoc IPeripheryPayments
+    function sweepToken(
+        address token,
+        uint256 amountMinimum,
+        address recipient
+    ) public payable override {
+        uint256 balanceToken = IERC20(token).balanceOf(address(this));
+        require(balanceToken >= amountMinimum, 'Insufficient token');
+
+        if (balanceToken > 0) {
+            TransferHelper.safeTransfer(token, recipient, balanceToken);
+        }
+    }
+
+    /// @inheritdoc IPeripheryPayments
+    function refundETH() external payable override {
+        if (address(this).balance > 0) TransferHelper.safeTransferETH(msg.sender, address(this).balance);
+    }
+
+    /// @param token The token to pay
+    /// @param payer The entity that must pay
+    /// @param recipient The entity that will receive payment
+    /// @param value The amount to pay
+    function pay(
+        address token,
+        address payer,
+        address recipient,
+        uint256 value
+    ) internal {
+        if (token == WETH9 && address(this).balance >= value) {
+            // pay with WETH9
+            IWETH9(WETH9).deposit{value: value}(); // wrap only what is needed to pay
+            IWETH9(WETH9).transfer(recipient, value);
+        } else if (payer == address(this)) {
+            // pay with tokens already in the contract (for the exact input multihop case)
+            TransferHelper.safeTransfer(token, recipient, value);
+        } else {
+            // pull payment
+            TransferHelper.safeTransferFrom(token, payer, recipient, value);
+        }
+    }
+}