@pendle/core-v2 6.5.0 → 6.6.1

package/contracts/cross-chain/FixedPricePTAMMV2.sol

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.sol";
+import {IPFixedPricePTAMMSwapCallback, IPFixedPricePTAMMV2} from "../interfaces/IPFixedPricePTAMMV2.sol";
+
+import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import {ERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import {
+    IERC20MetadataUpgradeable
+} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {BoringOwnableUpgradeableV2} from "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {TokenHelper} from "../core/libraries/TokenHelper.sol";
+import {PMath} from "../core/libraries/math/PMath.sol";
+
+contract FixedPricePTAMMV2 is
+    IPFixedPricePTAMMV2,
+    BoringOwnableUpgradeableV2,
+    ERC20Upgradeable,
+    ReentrancyGuardUpgradeable,
+    TokenHelper
+{
+    // cast index-erc7201 "pendle.FixedPricePTAMM.storage"
+    uint256 internal constant STORAGE_SLOT = 0xbbf04d9aae855c6bd76c8f4ba7a918994ad0d002f537323e58c83cbfe5249000;
+
+    using PMath for uint256;
+    using PMath for int256;
+
+    address public immutable outputToken;
+
+    constructor(address _outputToken) {
+        _disableInitializers();
+        outputToken = _outputToken;
+    }
+
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
+        __ERC20_init(
+            string.concat(IERC20Metadata(outputToken).name(), " receipt"),
+            string.concat(IERC20Metadata(outputToken).symbol(), "-receipt")
+        );
+        __ReentrancyGuard_init();
+    }
+
+    function decimals() public view override(ERC20Upgradeable, IERC20MetadataUpgradeable) returns (uint8) {
+        return IERC20Metadata(outputToken).decimals();
+    }
+
+    struct OracleData {
+        bool isPaused;
+        address oracle;
+        // @notice This can be seen as the price at maturity.
+        // @notice This can help with decimals conversion.
+        uint256 multiplier;
+    }
+
+    struct Storage {
+        mapping(address PT => OracleData) priceOracle;
+        mapping(address PT => uint256) totalPT;
+        mapping(address user => bool) isWhitelisted;
+    }
+
+    function $() internal pure returns (Storage storage res) {
+        assembly ("memory-safe") {
+            res.slot := STORAGE_SLOT
+        }
+    }
+
+    function priceOracle(address PT)
+        public
+        view
+        returns (bool isPaused, IPChainlinkOracleEssential oracle, uint256 multiplier)
+    {
+        OracleData memory data = $().priceOracle[PT];
+        isPaused = data.isPaused;
+        oracle = IPChainlinkOracleEssential(data.oracle);
+        multiplier = data.multiplier;
+
+        require(address(oracle) != address(0), "FixedPricePTAMMV2: oracle not set");
+    }
+
+    function totalPt(address PT) external view returns (uint256) {
+        return $().totalPT[PT];
+    }
+
+    function isWhitelisted(address user) external view returns (bool) {
+        return $().isWhitelisted[user];
+    }
+
+    function previewSwapExactPtForToken(address PT, uint256 exactPtIn) public view returns (uint256 amountTokenOut) {
+        (bool isPaused, IPChainlinkOracleEssential oracle, uint256 multiplier) = priceOracle(PT);
+        require(!isPaused, "FixedPricePTAMMV2: trading paused");
+
+        (, int256 rawPrice,,,) = oracle.latestRoundData();
+
+        // exactPtIn * rawPrice * multiplier
+        return (exactPtIn * rawPrice.Uint() * multiplier) / (PMath.ONE * PMath.ONE);
+    }
+
+    function swapExactPtForToken(address receiver, address PT, uint256 exactPtIn, bytes calldata data)
+        external
+        nonReentrant
+        returns (uint256 netTokenOut)
+    {
+        netTokenOut = previewSwapExactPtForToken(PT, exactPtIn);
+
+        _transferOut(outputToken, receiver, netTokenOut);
+
+        if (data.length > 0) {
+            IPFixedPricePTAMMSwapCallback(msg.sender).swapCallback(netTokenOut, exactPtIn, data);
+        }
+
+        $().totalPT[PT] += exactPtIn;
+        require(_selfBalance(PT) >= $().totalPT[PT], "FixedPricePTAMMV2: insufficient PT received");
+
+        emit Swap(msg.sender, receiver, PT, exactPtIn, netTokenOut);
+    }
+
+    // Add/remove funds
+
+    modifier onlyWhitelisted() {
+        require($().isWhitelisted[msg.sender], "FixedPricePTAMMV2: Not whitelisted");
+        _;
+    }
+
+    function addFundWhitelisted(uint256 amount) external onlyWhitelisted nonReentrant {
+        _transferIn(outputToken, msg.sender, amount);
+        _mint(msg.sender, amount);
+        emit TokenFunded(msg.sender, amount);
+    }
+
+    function removeFund(uint256 amount) external nonReentrant {
+        _burn(msg.sender, amount);
+        _transferOut(outputToken, msg.sender, amount);
+        emit TokenWithdrawn(msg.sender, amount);
+    }
+
+    // Admin functions
+
+    function withdrawPt(address PT, uint256 amount) external onlyOwner {
+        _transferOut(PT, msg.sender, amount);
+        $().totalPT[PT] -= amount;
+    }
+
+    function setWhitelist(address user, bool isWhitelisted_) external onlyOwner {
+        $().isWhitelisted[user] = isWhitelisted_;
+        emit WhitelistUpdated(user, isWhitelisted_);
+    }
+
+    function setPriceOracle(address PT, address _priceOracle, uint256 _multiplier) external onlyOwner {
+        $().priceOracle[PT].oracle = _priceOracle;
+        $().priceOracle[PT].multiplier = _multiplier;
+        emit PriceOracleUpdated(PT, _priceOracle);
+    }
+
+    function setPausePtTrading(address PT, bool isPaused) external onlyOwner {
+        $().priceOracle[PT].isPaused = isPaused;
+        emit PauseStatusUpdated(PT, isPaused);
+    }
+}

package/contracts/{router/ActionCrossChain.sol → cross-chain/PendleSwapHelper.sol}

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import {IPActionCrossChain, TokenOutput} from "../interfaces/IPActionCrossChain.sol";
-import {IPFixedPricePTAMM} from "../interfaces/IPFixedPricePTAMM.sol";
-import {ActionBase} from "./base/ActionBase.sol";
-import {IPSwapAggregator, SwapType} from "./swap-aggregator/IPSwapAggregator.sol";
+import {TokenHelper} from "../core/libraries/TokenHelper.sol";
+import {IPFixedPricePTAMMV2} from "../interfaces/IPFixedPricePTAMMV2.sol";
+import {IPSwapHelper, TokenOutput} from "../interfaces/IPSwapHelper.sol";
+import {IPSwapAggregator, SwapType} from "../router/swap-aggregator/IPSwapAggregator.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
-contract ActionCrossChain is ActionBase, IPActionCrossChain {
+contract PendleSwapHelper is IPSwapHelper, TokenHelper {
     function swapWithFixedPricePTAMM(
         address receiver,
         address fixedPricePTAMM,
@@ -15,9 +15,13 @@ contract ActionCrossChain is ActionBase, IPActionCrossChain {
         uint256 exactPtIn,
         TokenOutput calldata out
     ) external returns (uint256 netTokenOut) {
+        require(
+            out.tokenRedeemSy == IPFixedPricePTAMMV2(fixedPricePTAMM).outputToken(), "SwapHelper: INVALID_TOKEN_REDEEM"
+        );
+
         _transferFrom(IERC20(PT), msg.sender, fixedPricePTAMM, exactPtIn);
-        uint256 tokenOut = IPFixedPricePTAMM(fixedPricePTAMM)
-            .swapExactPtForToken(__swapDestination(receiver, out), PT, exactPtIn, out.tokenRedeemSy, EMPTY_BYTES);
+        uint256 tokenOut = IPFixedPricePTAMMV2(fixedPricePTAMM)
+            .swapExactPtForToken(__swapDestination(receiver, out), PT, exactPtIn, "");
         return __handleTokenOutput(receiver, tokenOut, out);
     }
 

package/contracts/cross-chain/deposit-box/DepositBox.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
+import {ApprovedCall, IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+
+contract DepositBox is IPDepositBox, TokenHelper, Initializable {
+    using Address for address;
+    using SafeERC20 for IERC20;
+
+    address public immutable MANAGER;
+    address public OWNER;
+    uint32 public BOX_ID;
+
+    constructor(address manager_) {
+        _disableInitializers();
+        MANAGER = manager_;
+    }
+
+    modifier onlyManager() {
+        require(msg.sender == MANAGER, "DepositBox: caller is not manager");
+        _;
+    }
+
+    function initialize(address owner_, uint32 boxId_) external initializer {
+        OWNER = owner_;
+        BOX_ID = boxId_;
+    }
+
+    function withdrawTo(address to, address token, uint256 amount) external onlyManager {
+        _transferOut(token, to, amount);
+    }
+
+    function approveAndCall(ApprovedCall memory call, address nativeRefund)
+        external
+        payable
+        onlyManager
+        returns (bytes memory result)
+    {
+        uint256 nativeAmount = call.token == NATIVE ? call.amount : 0;
+        uint256 nativeFee = msg.value;
+
+        uint256 initialNativeBalance = _selfBalance(NATIVE) - nativeAmount - nativeFee;
+
+        _approveForExtRouter(call.token, call.approveTo, call.amount);
+        result = call.callTo.functionCallWithValue(call.data, nativeAmount + nativeFee);
+        _approveForExtRouter(call.token, call.approveTo, 0);
+
+        uint256 finalNativeBalance = _selfBalance(NATIVE);
+
+        if (finalNativeBalance > initialNativeBalance) {
+            _transferOut(NATIVE, nativeRefund, finalNativeBalance - initialNativeBalance);
+        }
+    }
+
+    function _approveForExtRouter(address token, address extRouter, uint256 amount) internal {
+        if (token == NATIVE) return;
+        IERC20(token).forceApprove(extRouter, amount);
+    }
+
+    receive() external payable {}
+}

package/contracts/cross-chain/deposit-box/DepositBoxFactory.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+
+import {IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+import {IPDepositBoxFactory} from "../../interfaces/IPDepositBoxFactory.sol";
+import {DepositBox} from "./DepositBox.sol";
+
+contract DepositBoxFactory is IPDepositBoxFactory {
+    /// @dev creation code of OpenZeppelin's BeaconProxy
+    address public immutable BEACON_PROXY_CODE_CONTRACT;
+    address public immutable DEPOSIT_BOX_BEACON;
+    bytes32 public immutable DEPOSIT_BOX_CODE_HASH;
+
+    constructor(address beaconProxyCodeContract_, address depositBoxBeacon_) {
+        BEACON_PROXY_CODE_CONTRACT = beaconProxyCodeContract_;
+        DEPOSIT_BOX_BEACON = depositBoxBeacon_;
+        DEPOSIT_BOX_CODE_HASH =
+            keccak256(abi.encodePacked(beaconProxyCodeContract_.code, abi.encode(depositBoxBeacon_, "")));
+    }
+
+    function computeDepositBox(address owner, uint32 boxId)
+        public
+        view
+        returns (address box, bytes32 salt, bool deployed)
+    {
+        salt = keccak256(abi.encode(owner, boxId));
+        box = Create2.computeAddress(salt, DEPOSIT_BOX_CODE_HASH);
+        deployed = box.code.length > 0;
+    }
+
+    function deployDepositBox(address owner, uint32 boxId) external returns (IPDepositBox) {
+        (address box, bytes32 salt, bool deployed) = computeDepositBox(owner, boxId);
+        if (deployed) {
+            return IPDepositBox(box);
+        }
+
+        bytes memory bytecode = abi.encodePacked(BEACON_PROXY_CODE_CONTRACT.code, abi.encode(DEPOSIT_BOX_BEACON, ""));
+        assert(Create2.deploy(0, salt, bytecode) == box);
+        DepositBox(payable(box)).initialize(owner, boxId);
+        return IPDepositBox(box);
+    }
+}

package/contracts/cross-chain/funder/BridgeFunder.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {BoringOwnableUpgradeableV2} from "../../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
+import {BridgeData, IPBridgeFunder} from "../../interfaces/IPBridgeFunder.sol";
+import {IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+import {IPDepositBoxFactory} from "../../interfaces/IPDepositBoxFactory.sol";
+
+contract BridgeFunder is IPBridgeFunder, BoringOwnableUpgradeableV2, TokenHelper {
+    using Address for address;
+    using SafeERC20 for IERC20;
+
+    IPDepositBoxFactory public immutable DEPOSIT_BOX_FACTORY;
+
+    constructor(address depositBoxFactory_) {
+        _disableInitializers();
+        DEPOSIT_BOX_FACTORY = IPDepositBoxFactory(depositBoxFactory_);
+    }
+
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
+    }
+
+    modifier onlyDepositBox() {
+        IPDepositBox box = IPDepositBox(msg.sender);
+        address owner = box.OWNER();
+        uint32 boxId = box.BOX_ID();
+
+        (address computedBox,,) = DEPOSIT_BOX_FACTORY.computeDepositBox(owner, boxId);
+        require(computedBox == address(box), "BridgeFunder: caller is not deposit box");
+        _;
+    }
+
+    function bridge(BridgeData memory $) external onlyDepositBox returns (bytes memory result) {
+        require(
+            $.bridgeToken != $.feeToken && $.bridgeToken != NATIVE && $.feeToken != NATIVE,
+            "BridgeFunder: unsupported token"
+        );
+
+        _transferIn($.bridgeToken, msg.sender, $.bridgeAmount);
+        _approveForExtRouter($.bridgeToken, $.bridgeExtRouter, $.bridgeAmount);
+        _approveForExtRouter($.feeToken, $.bridgeExtRouter, $.feeAmount);
+
+        result = $.bridgeExtRouter.functionCall($.bridgeCalldata);
+
+        _approveForExtRouter($.bridgeToken, $.bridgeExtRouter, 0);
+        _approveForExtRouter($.feeToken, $.bridgeExtRouter, 0);
+    }
+
+    function withdraw(address receiver, address token, uint256 amount) external onlyOwner {
+        _transferOut(token, receiver, amount);
+    }
+
+    function _approveForExtRouter(address token, address extRouter, uint256 amount) internal {
+        IERC20(token).forceApprove(extRouter, amount);
+    }
+}

package/contracts/cross-chain/oftImpl/hub/OFTAdapterAltImpl.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import {OFTAdapterImpl} from "./OFTAdapterImpl.sol";
+import {
+    MessagingParams,
+    MessagingFee,
+    MessagingReceipt
+} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+// @notice Base OFT contract, without any additional functionality (like RateLimiter).
+// @dev This contract inherits Ownable from OpenZeppelin v4.
+// @dev Sender is set as the contract owner at deployment.
+contract OFTAdapterAltImpl is OFTAdapterImpl {
+    using SafeERC20 for IERC20;
+
+    error MsgValueNotZero(uint256 msgValue);
+    error NativeTokenUnavailable();
+
+    address public immutable nativeToken;
+
+    constructor(address _token, address _endpoint, address _delegate) OFTAdapterImpl(_token, _endpoint, _delegate) {
+        nativeToken = endpoint.nativeToken();
+    }
+
+    function _lzSend(
+        uint32 _dstEid,
+        bytes memory _message,
+        bytes memory _options,
+        MessagingFee memory _fee,
+        address _refundAddress
+    ) internal override returns (MessagingReceipt memory receipt) {
+        // In Alt implementation, msg.value should always be 0 since we use ERC20 tokens for fees
+        if (msg.value > 0) revert MsgValueNotZero(msg.value);
+
+        // Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
+        _payNative(_fee.nativeFee);
+        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);
+
+        return endpoint.send(
+            MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _fee.lzTokenFee > 0), _refundAddress
+        );
+    }
+
+    function _payNative(uint256 _nativeFee) internal override returns (uint256 nativeFee) {
+        if (nativeToken == address(0)) revert NativeTokenUnavailable();
+
+        // Pay Native token fee by sending tokens to the endpoint.
+        IERC20(nativeToken).safeTransferFrom(msg.sender, address(endpoint), _nativeFee);
+
+        return _nativeFee;
+    }
+}

package/contracts/cross-chain/oftImpl/spoke/PendleBridgedPrincipalTokenAlt.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.19;
+
+import {PendleBridgedPrincipalToken} from "./PendleBridgedPrincipalToken.sol";
+import {
+    MessagingParams,
+    MessagingFee,
+    MessagingReceipt
+} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+contract PendleBridgedPrincipalTokenAlt is PendleBridgedPrincipalToken {
+    using SafeERC20 for IERC20;
+
+    error MsgValueNotZero(uint256 msgValue);
+    error NativeTokenUnavailable();
+
+    address public immutable nativeToken;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _lzEndpoint,
+        address _delegate,
+        uint256 _expiry,
+        uint8 _localDecimals,
+        uint8 _sharedDecimals,
+        address initialOwner
+    )
+        PendleBridgedPrincipalToken(
+            _name, _symbol, _lzEndpoint, _delegate, _expiry, _localDecimals, _sharedDecimals, initialOwner
+        )
+    {
+        nativeToken = endpoint.nativeToken();
+    }
+
+    function _lzSend(
+        uint32 _dstEid,
+        bytes memory _message,
+        bytes memory _options,
+        MessagingFee memory _fee,
+        address _refundAddress
+    ) internal override returns (MessagingReceipt memory receipt) {
+        // In Alt implementation, msg.value should always be 0 since we use ERC20 tokens for fees
+        if (msg.value > 0) revert MsgValueNotZero(msg.value);
+
+        // Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
+        _payNative(_fee.nativeFee);
+        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);
+
+        return endpoint.send(
+            MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _fee.lzTokenFee > 0), _refundAddress
+        );
+    }
+
+    function _payNative(uint256 _nativeFee) internal override returns (uint256 nativeFee) {
+        if (nativeToken == address(0)) revert NativeTokenUnavailable();
+
+        // Pay Native token fee by sending tokens to the endpoint.
+        IERC20(nativeToken).safeTransferFrom(msg.sender, address(endpoint), _nativeFee);
+
+        return _nativeFee;
+    }
+}

package/contracts/cross-chain/swap-hub/PendleCrossChainSwapHub.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {ApprovedCall, IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+import {SwapHubBase} from "./SwapHubBase.sol";
+
+contract PendleCrossChainSwapHub is SwapHubBase {
+    constructor(address treasury_, address depositBoxFactory_) SwapHubBase(treasury_, depositBoxFactory_) {
+        _disableInitializers();
+    }
+
+    function initialize(address _owner) external initializer {
+        __EIP712_init("Pendle Cross Chain Swap Hub", "1");
+        __BoringOwnableV2_init(_owner);
+    }
+
+    function withdrawToken(WithdrawTokenMessage memory ms, bytes memory sig) external onlyExecutor {
+        IPDepositBox box = _checkBoxPermit(ms.permit, hashTypedData(ms), sig);
+        _payTreasury(box, ms.token, ms.amountFee);
+        _withdrawToken(ms, box);
+
+        emit WithdrawToken(
+            ms.permit.owner,
+            ms.permit.boxId,
+            ms.permit.requestId,
+            ms.permit.nonce,
+            ms.token,
+            ms.amountWithdraw,
+            ms.amountFee
+        );
+    }
+
+    function bridgeToken(BridgeTokenMessage memory ms, bytes memory sig) external payable onlyExecutor {
+        IPDepositBox box = _checkBoxPermit(ms.permit, hashTypedData(ms), sig);
+        _payTreasury(box, ms.token, ms.amountFee);
+        _bridgeToken(ms, box, msg.value);
+
+        emit BridgeToken(
+            ms.permit.owner,
+            ms.permit.boxId,
+            ms.permit.requestId,
+            ms.permit.nonce,
+            ms.bridgeExtRouter,
+            ms.token,
+            ms.amountBridge,
+            ms.amountFee
+        );
+    }
+
+    function swapToken(SwapTokenMessage memory ms, bytes memory sig) external onlyExecutor {
+        IPDepositBox box = _checkBoxPermit(ms.permit, hashTypedData(ms), sig);
+        // swapToken does not pay treasury
+
+        uint256 netTokenReceived = _swapToken(ms, box);
+        require(netTokenReceived >= ms.minReceived, InsufficientTokenReceived());
+
+        emit SwapToken(
+            ms.permit.owner,
+            ms.permit.boxId,
+            ms.permit.requestId,
+            ms.permit.nonce,
+            ms.tokenSpent,
+            ms.amountSpent,
+            ms.tokenReceived,
+            netTokenReceived
+        );
+    }
+
+    function _payTreasury(IPDepositBox box, address token, uint256 amount) internal {
+        box.withdrawTo(TREASURY, token, amount);
+    }
+
+    function _withdrawToken(WithdrawTokenMessage memory ms, IPDepositBox box) internal {
+        box.withdrawTo(ms.permit.owner, ms.token, ms.amountWithdraw);
+    }
+
+    function _bridgeToken(BridgeTokenMessage memory ms, IPDepositBox box, uint256 nativeFee) internal {
+        ApprovedCall memory call = ApprovedCall({
+            token: ms.token,
+            amount: ms.amountBridge,
+            approveTo: ms.bridgeApprove,
+            callTo: ms.bridgeExtRouter,
+            data: ms.bridgeCalldata
+        });
+        box.approveAndCall{value: nativeFee}(call, msg.sender);
+    }
+
+    function _swapToken(SwapTokenMessage memory ms, IPDepositBox box) internal returns (uint256 rawTokenReceived) {
+        ApprovedCall memory call = ApprovedCall({
+            token: ms.tokenSpent,
+            amount: ms.amountSpent,
+            approveTo: ms.swapApprove,
+            callTo: ms.swapExtRouter,
+            data: ms.swapCalldata
+        });
+
+        uint256 preBalance = _balanceOf(address(box), ms.tokenReceived);
+        box.approveAndCall(call, address(box));
+        rawTokenReceived = _balanceOf(address(box), ms.tokenReceived) - preBalance;
+    }
+}