@pendle/core-v2 6.4.4-swaphubtest → 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/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

@@ -1,21 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.30;
 
-import {
-    IOFT,
-    MessagingFee,
-    MessagingReceipt,
-    OFTReceipt,
-    SendParam
-} from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {ApprovedCall, IPDepositBox} from "../../interfaces/IPDepositBox.sol";
 import {SwapHubBase} from "./SwapHubBase.sol";
 
 contract PendleCrossChainSwapHub is SwapHubBase {
-    constructor(address treasury_, address beaconProxyCodeContract_, address depositBoxBeacon_)
-        SwapHubBase(treasury_, beaconProxyCodeContract_, depositBoxBeacon_)
-    {
+    constructor(address treasury_, address depositBoxFactory_) SwapHubBase(treasury_, depositBoxFactory_) {
         _disableInitializers();
     }
 
@@ -25,87 +15,63 @@ contract PendleCrossChainSwapHub is SwapHubBase {
     }
 
     function withdrawToken(WithdrawTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
-
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
+        IPDepositBox box = _checkBoxPermit(ms.permit, hashTypedData(ms), sig);
         _payTreasury(box, ms.token, ms.amountFee);
         _withdrawToken(ms, box);
 
-        emit WithdrawToken(ms.owner, ms.boxId, ms.token, ms.amountWithdraw, ms.amountFee);
+        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 {
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
-
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        _pullToken(ms.pullFromOwner, box, ms.owner, ms.token, ms.amountBridge + ms.amountFee);
+        IPDepositBox box = _checkBoxPermit(ms.permit, hashTypedData(ms), sig);
         _payTreasury(box, ms.token, ms.amountFee);
         _bridgeToken(ms, box, msg.value);
 
         emit BridgeToken(
-            ms.owner, ms.boxId, ms.bridgeExtRouter, ms.token, ms.amountBridge, ms.amountFee, ms.pullFromOwner
+            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 {
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
-
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        _pullToken(ms.pullFromOwner, box, ms.owner, ms.tokenSpent, ms.amountSpent + ms.amountFee);
-        _payTreasury(box, ms.tokenSpent, ms.amountFee);
+        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.owner,
-            ms.boxId,
+            ms.permit.owner,
+            ms.permit.boxId,
+            ms.permit.requestId,
+            ms.permit.nonce,
             ms.tokenSpent,
             ms.amountSpent,
-            ms.amountFee,
             ms.tokenReceived,
-            netTokenReceived,
-            ms.pullFromOwner,
-            ms.sendToOwner
-        );
-    }
-
-    function buyCrossChainPt(BuyCrossChainPtMessage memory ms, bytes memory sig) external payable onlyExecutor {
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
-
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        _pullToken(ms.pullFromOwner, box, ms.owner, ms.tokenSpent, ms.amountSpent + ms.amountFee);
-        _payTreasury(box, ms.tokenSpent, ms.amountFee);
-
-        address pt = IOFT(ms.ptAdapter).token();
-        uint256 netPtReceived = _buyPtAndBridge(ms, box, pt, msg.value, msg.sender);
-        require(netPtReceived >= ms.minPtReceived, InsufficientTokenReceived());
-
-        emit BuyCrossChainPt(
-            ms.owner,
-            ms.boxId,
-            ms.tokenSpent,
-            ms.amountSpent,
-            ms.amountFee,
-            ms.ptAdapter,
-            pt,
-            netPtReceived,
-            ms.pullFromOwner
+            netTokenReceived
         );
     }
 
-    function _pullToken(bool pullFromOwner, IPDepositBox box, address owner, address token, uint256 amount) internal {
-        if (pullFromOwner) {
-            _transferFrom(IERC20(token), owner, address(box), amount);
-        }
-    }
-
     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.owner, ms.token, ms.amountWithdraw);
+        box.withdrawTo(ms.permit.owner, ms.token, ms.amountWithdraw);
     }
 
     function _bridgeToken(BridgeTokenMessage memory ms, IPDepositBox box, uint256 nativeFee) internal {
@@ -120,59 +86,16 @@ contract PendleCrossChainSwapHub is SwapHubBase {
     }
 
     function _swapToken(SwapTokenMessage memory ms, IPDepositBox box) internal returns (uint256 rawTokenReceived) {
-        rawTokenReceived = _swapFromBox({
-            box: box,
-            tokenSpent: ms.tokenSpent,
-            amountSpent: ms.amountSpent,
-            tokenReceived: ms.tokenReceived,
-            swapExtRouter: ms.swapExtRouter,
-            swapApprove: ms.swapApprove,
-            swapCalldata: ms.swapCalldata,
-            receiver: ms.sendToOwner ? ms.owner : address(box)
-        });
-    }
-
-    function _buyPtAndBridge(
-        BuyCrossChainPtMessage memory ms,
-        IPDepositBox box,
-        address pt,
-        uint256 nativeFee,
-        address nativeRefund
-    ) internal returns (uint256 netPtReceived) {
-        require(ms.receiver == _addressToBytes32(ms.owner), InvalidReceiver());
-
-        uint256 rawPtReceived = _swapFromBox({
-            box: box,
-            tokenSpent: ms.tokenSpent,
-            amountSpent: ms.amountSpent,
-            tokenReceived: pt,
-            swapExtRouter: ms.swapExtRouter,
-            swapApprove: ms.swapApprove,
-            swapCalldata: ms.swapCalldata,
-            receiver: address(box)
-        });
-
-        SendParam memory sendParam = SendParam({
-            dstEid: ms.dstEid,
-            to: ms.receiver,
-            amountLD: rawPtReceived,
-            minAmountLD: 0,
-            extraOptions: "",
-            composeMsg: "",
-            oftCmd: ""
-        });
-        MessagingFee memory sendFee = MessagingFee({nativeFee: nativeFee, lzTokenFee: 0});
         ApprovedCall memory call = ApprovedCall({
-            token: pt,
-            amount: rawPtReceived,
-            approveTo: ms.ptAdapter,
-            callTo: ms.ptAdapter,
-            data: abi.encodeCall(IOFT.send, (sendParam, sendFee, nativeRefund))
+            token: ms.tokenSpent,
+            amount: ms.amountSpent,
+            approveTo: ms.swapApprove,
+            callTo: ms.swapExtRouter,
+            data: ms.swapCalldata
         });
-        (, OFTReceipt memory oftReceipt) =
-            abi.decode(box.approveAndCall{value: nativeFee}(call, nativeRefund), (MessagingReceipt, OFTReceipt));
-        netPtReceived = oftReceipt.amountReceivedLD;
-    }
 
-    receive() external payable {}
+        uint256 preBalance = _balanceOf(address(box), ms.tokenReceived);
+        box.approveAndCall(call, address(box));
+        rawTokenReceived = _balanceOf(address(box), ms.tokenReceived) - preBalance;
+    }
 }