@pendle/core-v2 6.4.4-unichain → 6.5.0-swaphubtest

package/contracts/LiquidityMining/sPendle/StakedPendle.sol

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import {BoringOwnableUpgradeableV2} from "../../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
+import {PMath} from "../../core/libraries/math/PMath.sol";
+import {IPStakedPendle} from "../../interfaces/IPStakedPendle.sol";
+import {ERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+
+contract StakedPendle is IPStakedPendle, ERC20Upgradeable, BoringOwnableUpgradeableV2, TokenHelper {
+    using PMath for uint256;
+
+    address public feeReceiver;
+    address public immutable PENDLE;
+
+    mapping(address user => UserCooldown) public userCooldown;
+
+    uint24 public cooldownDuration;
+    uint64 public instantUnstakeFeeRate; // base 1e18. 5e16 means instant unstake will have to pay 5% of the amount.
+
+    constructor(address pendle) {
+        PENDLE = pendle;
+        _disableInitializers();
+    }
+
+    /// @dev reminder to also call setFeeReceiver & setCooldownDurationAndFee
+    function initialize(address _owner) external initializer {
+        __ERC20_init("StakedPendle", "sPENDLE");
+        __BoringOwnableV2_init(_owner);
+    }
+
+    function stake(uint256 amount) external {
+        require(amount > 0, "sPendle: invalid amount");
+
+        _transferIn(PENDLE, msg.sender, amount);
+        _mint(msg.sender, amount);
+
+        emit Staked(msg.sender, amount);
+    }
+
+    function cooldown(uint256 amount) external {
+        require(amount > 0, "sPendle: invalid amount");
+        require(userCooldown[msg.sender].amount == 0, "sPendle: already in cooldown");
+
+        userCooldown[msg.sender] = UserCooldown({cooldownStart: uint104(block.timestamp), amount: amount.Uint152()});
+        _burn(msg.sender, amount);
+
+        emit CooldownInitiated(msg.sender, amount, block.timestamp);
+    }
+
+    function cancelCooldown() external {
+        UserCooldown memory data = userCooldown[msg.sender];
+        require(data.amount > 0, "sPendle: no cooldown");
+
+        delete userCooldown[msg.sender];
+        _mint(msg.sender, data.amount);
+
+        emit CooldownCanceled(msg.sender, data.amount);
+    }
+
+    function finalizeCooldown() external returns (uint256 /*amount*/) {
+        UserCooldown memory data = userCooldown[msg.sender];
+        require(data.amount > 0, "sPendle: no cooldown");
+
+        uint256 cooldownEnd = data.cooldownStart + cooldownDuration;
+        require(block.timestamp >= cooldownEnd, "sPendle: redeem not ready");
+
+        delete userCooldown[msg.sender];
+        _transferOut(PENDLE, msg.sender, data.amount);
+
+        emit Unstaked(msg.sender, data.amount, 0);
+
+        return data.amount;
+    }
+
+    function instantUnstake(uint256 amount) external returns (uint256 amountAfterFee, uint256 fee) {
+        require(amount > 0, "sPendle: invalid amount");
+
+        fee = PMath.rawDivUp(amount * instantUnstakeFeeRate, PMath.ONE);
+        amountAfterFee = amount - fee;
+
+        _burn(msg.sender, amount);
+        _transferOut(PENDLE, msg.sender, amountAfterFee);
+        _transferOut(PENDLE, feeReceiver, fee);
+
+        emit Unstaked(msg.sender, amountAfterFee, fee);
+    }
+
+    // ======== Misc helper functions =======
+
+    function multicall(Call3[] calldata calls) external returns (Result[] memory res) {
+        uint256 length = calls.length;
+        res = new Result[](length);
+        for (uint256 i = 0; i < length; i++) {
+            (bool success, bytes memory result) = _delegateToSelf(calls[i].callData, calls[i].allowFailure);
+            res[i] = Result(success, result);
+        }
+    }
+
+    function _delegateToSelf(
+        bytes memory data,
+        bool allowFailure
+    ) internal returns (bool success, bytes memory result) {
+        (success, result) = address(this).delegatecall(data);
+
+        if (!success && !allowFailure) {
+            assembly {
+                // We use Yul's revert() to bubble up errors from the target contract.
+                revert(add(32, result), mload(result))
+            }
+        }
+    }
+
+    // ======== Admin functions ========
+
+    function setFeeReceiver(address newFeeReceiver) external onlyOwner {
+        require(newFeeReceiver != address(0), "sPendle: invalid fee receiver");
+
+        feeReceiver = newFeeReceiver;
+        emit FeeReceiverUpdated(newFeeReceiver);
+    }
+
+    function setCooldownDurationAndFee(uint24 newDuration, uint64 newInstantUnstakeFeeRate) external onlyOwner {
+        require(newInstantUnstakeFeeRate <= PMath.ONE, "sPendle: invalid fee factor");
+        cooldownDuration = newDuration;
+        instantUnstakeFeeRate = newInstantUnstakeFeeRate;
+        emit CooldownDurationAndFeeUpdated(newDuration, newInstantUnstakeFeeRate);
+    }
+}

package/contracts/core/Market/PendleGauge.sol

@@ -3,105 +3,34 @@ pragma solidity ^0.8.0;
 
 import "../../interfaces/IPGauge.sol";
 import "../../interfaces/IPGaugeController.sol";
-import "../../interfaces/IPVeToken.sol";
 import "../../interfaces/IStandardizedYield.sol";
 
 import "../RewardManager/RewardManager.sol";
 
-/**
- * Invariants to maintain:
- * - before any changes to active balance, updateAndDistributeRewards() must be called
- */
 abstract contract PendleGauge is RewardManager, IPGauge {
-    using PMath for uint256;
-    using SafeERC20 for IERC20;
     using ArrayLib for address[];
 
     address private immutable SY;
-
-    uint256 internal constant TOKENLESS_PRODUCTION = 40;
-
     address internal immutable PENDLE;
-    IPVeToken internal immutable vePENDLE;
     address internal immutable gaugeController;
 
-    uint256 public totalActiveSupply;
-    mapping(address => uint256) public activeBalance;
-
-    constructor(address _SY, address _vePendle, address _gaugeController) {
+    constructor(address _SY, address _gaugeController) {
         SY = _SY;
-        vePENDLE = IPVeToken(_vePendle);
         gaugeController = _gaugeController;
         PENDLE = IPGaugeController(gaugeController).pendle();
     }
 
-    /**
-     * @dev Since rewardShares is based on activeBalance, user's activeBalance must be updated AFTER
-     *     rewards is updated
-     * @dev It's intended to have user's activeBalance updated when rewards is redeemed
-     */
     function _redeemRewards(address user) internal virtual returns (uint256[] memory rewardsOut) {
         _updateAndDistributeRewards(user);
-        _updateUserActiveBalance(user);
         rewardsOut = _doTransferOutRewards(user, user);
         emit RedeemRewards(user, rewardsOut);
     }
 
-    function _updateUserActiveBalance(address user) internal virtual {
-        _updateUserActiveBalanceForTwo(user, address(0));
-    }
-
-    function _updateUserActiveBalanceForTwo(address user1, address user2) internal virtual {
-        if (user1 != address(0) && user1 != address(this)) _updateUserActiveBalancePrivate(user1);
-        if (user2 != address(0) && user2 != address(this)) _updateUserActiveBalancePrivate(user2);
-    }
-
-    /**
-     * @dev should only be callable from `_updateUserActiveBalanceForTwo` to guarantee user != address(0) && user !=
-     * address(this)
-     */
-    function _updateUserActiveBalancePrivate(address user) private {
-        assert(user != address(0) && user != address(this));
-
-        uint256 lpBalance = _stakedBalance(user);
-        uint256 veBoostedLpBalance = _calcVeBoostedLpBalance(user, lpBalance);
-
-        uint256 newActiveBalance = PMath.min(veBoostedLpBalance, lpBalance);
-
-        totalActiveSupply = totalActiveSupply - activeBalance[user] + newActiveBalance;
-        activeBalance[user] = newActiveBalance;
-
-        emit UpdateActiveBalance(user, newActiveBalance);
-    }
-
-    function _calcVeBoostedLpBalance(address user, uint256 lpBalance) internal virtual returns (uint256) {
-        (uint256 vePendleSupply, uint256 vePendleBalance) = vePENDLE.totalSupplyAndBalanceCurrent(user);
-        // Inspired by Curve's Gauge
-        uint256 veBoostedLpBalance = (lpBalance * TOKENLESS_PRODUCTION) / 100;
-        if (vePendleSupply > 0) {
-            veBoostedLpBalance += (((_totalStaked() * vePendleBalance) / vePendleSupply) * (100 - TOKENLESS_PRODUCTION))
-                / 100;
-        }
-        return veBoostedLpBalance;
-    }
-
     function _redeemExternalReward() internal virtual override {
         IStandardizedYield(SY).claimRewards(address(this));
         IPGaugeController(gaugeController).redeemMarketReward();
     }
 
-    function _stakedBalance(address user) internal view virtual returns (uint256);
-
-    function _totalStaked() internal view virtual returns (uint256);
-
-    function _rewardSharesTotal() internal view virtual override returns (uint256) {
-        return totalActiveSupply;
-    }
-
-    function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
-        return activeBalance[user];
-    }
-
     function _getRewardTokens() internal view virtual override returns (address[] memory) {
         address[] memory SYRewards = IStandardizedYield(SY).getRewardTokens();
         if (SYRewards.contains(PENDLE)) return SYRewards;
@@ -111,8 +40,4 @@ abstract contract PendleGauge is RewardManager, IPGauge {
     function _beforeTokenTransfer(address from, address to, uint256) internal virtual {
         _updateAndDistributeRewardsForTwo(from, to);
     }
-
-    function _afterTokenTransfer(address from, address to, uint256) internal virtual {
-        _updateUserActiveBalanceForTwo(from, to);
-    }
 }

package/contracts/core/Market/{PendleMarketFactoryV6Upg.sol → PendleMarketFactoryV7Upg.sol}

@@ -10,10 +10,10 @@ import "../libraries/BaseSplitCodeFactory.sol";
 import "../libraries/BoringOwnableUpgradeableV2.sol";
 import "../libraries/Errors.sol";
 
-contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory {
+contract PendleMarketFactoryV7Upg is BoringOwnableUpgradeableV2, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
 
-    uint256 public constant VERSION = 6;
+    uint256 public constant VERSION = 7;
 
     address public immutable marketCreationCodeContractA;
     uint256 public immutable marketCreationCodeSizeA;
@@ -21,7 +21,6 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
     uint256 public immutable marketCreationCodeSizeB;
 
     address public immutable yieldContractFactory;
-    address public immutable vePendle;
     address public immutable gaugeController;
 
     uint256 public immutable maxLnFeeRateRoot;
@@ -44,7 +43,6 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
         uint256 _marketCreationCodeSizeA,
         address _marketCreationCodeContractB,
         uint256 _marketCreationCodeSizeB,
-        address _vePendle,
         address _gaugeController
     ) {
         yieldContractFactory = _yieldContractFactory;
@@ -55,7 +53,6 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
         marketCreationCodeContractB = _marketCreationCodeContractB;
         marketCreationCodeSizeB = _marketCreationCodeSizeB;
 
-        vePendle = _vePendle;
         gaugeController = _gaugeController;
 
         _disableInitializers();
@@ -91,7 +88,7 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
         market = BaseSplitCodeFactory._create2(
             0,
             bytes32(block.chainid),
-            abi.encode(PT, scalarRoot, initialAnchor, lnFeeRateRoot, vePendle, gaugeController),
+            abi.encode(PT, scalarRoot, initialAnchor, lnFeeRateRoot, gaugeController),
             marketCreationCodeContractA,
             marketCreationCodeSizeA,
             marketCreationCodeContractB,

package/contracts/core/Market/{PendleMarketV6.sol → PendleMarketV7.sol}

@@ -16,7 +16,7 @@ import "./PendleGauge.sol";
  * - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
  *     guaranteed by address(0) & address(this) check in each updateForTwo function
  */
-contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
+contract PendleMarketV7 is PendleERC20, PendleGauge, IPMarket {
     using PMath for uint256;
     using PMath for int256;
     using MarketMathCore for MarketState;
@@ -44,7 +44,7 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
     string private constant LP_NAME_PREF = "PLP ";
     string private constant LP_SYMBOL_PREF = "PLP-";
 
-    uint256 public constant VERSION = 6;
+    uint256 public constant VERSION = 7;
 
     IPPrincipalToken internal immutable PT;
     IStandardizedYield internal immutable SY;
@@ -66,16 +66,9 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
         _;
     }
 
-    constructor(
-        address _PT,
-        int256 _scalarRoot,
-        int256 _initialAnchor,
-        uint80 _lnFeeRateRoot,
-        address _vePendle,
-        address _gaugeController
-    )
+    constructor(address _PT, int256 _scalarRoot, int256 _initialAnchor, uint80 _lnFeeRateRoot, address _gaugeController)
         PendleERC20(_getLPName(_PT), _getLPSymbol(_PT), 18)
-        PendleGauge(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController)
+        PendleGauge(IPPrincipalToken(_PT).SY(), _gaugeController)
     {
         PT = IPPrincipalToken(_PT);
         SY = IStandardizedYield(PT.SY());
@@ -370,11 +363,11 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
                     PENDLE GAUGE - RELATED
     //////////////////////////////////////////////////////////////*/
 
-    function _stakedBalance(address user) internal view override returns (uint256) {
+    function _rewardSharesUser(address user) internal view override returns (uint256) {
         return balanceOf(user);
     }
 
-    function _totalStaked() internal view override returns (uint256) {
+    function _rewardSharesTotal() internal view override returns (uint256) {
         return totalSupply();
     }
 
@@ -386,8 +379,15 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
         PendleGauge._beforeTokenTransfer(from, to, amount);
     }
 
-    // solhint-disable-next-line ordering
-    function _afterTokenTransfer(address from, address to, uint256 amount) internal override(PendleERC20, PendleGauge) {
-        PendleGauge._afterTokenTransfer(from, to, amount);
+    /*///////////////////////////////////////////////////////////////
+                            LEGACY FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function totalActiveSupply() external view returns (uint256) {
+        return totalSupply();
+    }
+
+    function activeBalance(address user) external view returns (uint256) {
+        return balanceOf(user);
     }
 }

package/contracts/core/libraries/Errors.sol

@@ -138,7 +138,7 @@ library Errors {
     error VEReceiveOldSupply(uint256 msgTime);
 
     error GCNotPendleMarket(address caller);
-    error GCNotVotingController(address caller);
+    error GCNotRewardDataUpdater(address caller);
 
     error InvalidWTime(uint256 wTime);
     error ExpiryInThePast(uint256 expiry);

package/contracts/core/libraries/TokenHelper.sol

@@ -21,7 +21,7 @@ abstract contract TokenHelper {
     }
 
     function _transferOut(address token, address to, uint256 amount) internal {
-        if (amount == 0) return;
+        if (amount == 0 || to == address(this)) return;
         if (token == NATIVE) {
             (bool success,) = to.call{value: amount}("");
             require(success, "eth send failed");
@@ -41,8 +41,12 @@ abstract contract TokenHelper {
         }
     }
 
+    function _balanceOf(address addr, address token) internal view returns (uint256) {
+        return (token == NATIVE) ? addr.balance : IERC20(token).balanceOf(addr);
+    }
+
     function _selfBalance(address token) internal view returns (uint256) {
-        return (token == NATIVE) ? address(this).balance : IERC20(token).balanceOf(address(this));
+        return _balanceOf(address(this), token);
     }
 
     function _selfBalance(IERC20 token) internal view returns (uint256) {

package/contracts/core/libraries/math/PMath.sol

@@ -211,6 +211,11 @@ library PMath {
         return uint80(x);
     }
 
+    function Uint152(uint256 x) internal pure returns (uint152) {
+        require(x <= type(uint152).max);
+        return uint152(x);
+    }
+
     function isAApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
         return mulDown(b, ONE - eps) <= a && a <= mulDown(b, ONE + eps);
     }

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/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;
+    }
+}