@pendle/core-v2 6.3.2-swaphubtest2 → 6.3.2-swaphubtest4

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

@@ -8,13 +8,13 @@ import {
     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 {SwapData} from "./swap/IPSwapExecutor.sol";
 import {SwapHubBase} from "./SwapHubBase.sol";
 
 contract PendleCrossChainSwapHub is SwapHubBase {
-    constructor(address beaconProxyCodeContract_, address depositBoxBeacon_)
-        SwapHubBase(beaconProxyCodeContract_, depositBoxBeacon_)
+    constructor(address treasury_, address beaconProxyCodeContract_, address depositBoxBeacon_)
+        SwapHubBase(treasury_, beaconProxyCodeContract_, depositBoxBeacon_)
     {
         _disableInitializers();
     }
@@ -25,163 +25,132 @@ contract PendleCrossChainSwapHub is SwapHubBase {
     }
 
     function withdrawToken(WithdrawTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _handleWithdrawToken({ms: ms, sig: sig, claimFailed: false});
-    }
-
-    function bridgeToken(BridgeTokenMessage memory ms, bytes memory sig) external payable onlyExecutor {
-        _handleBridgeToken({ms: ms, sig: sig, claimFailed: false});
-    }
+        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
 
-    function swapToken(SwapTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _handleSwapToken({ms: ms, sig: sig, claimFailed: false});
-    }
-
-    function buyCrossChainPt(BuyCrossChainPtMessage memory ms, bytes memory sig) external payable onlyExecutor {
-        _handleBuyCrossChainPt({ms: ms, sig: sig, claimFailed: false});
-    }
-
-    function claimFee(WithdrawTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _handleWithdrawToken({ms: ms, sig: sig, claimFailed: true});
-    }
-
-    function claimFee(BridgeTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _handleBridgeToken({ms: ms, sig: sig, claimFailed: true});
-    }
-
-    function claimFee(SwapTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _handleSwapToken({ms: ms, sig: sig, claimFailed: true});
-    }
+        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
+        _payTreasury(box, ms.token, ms.amountFee);
+        _withdrawToken(ms, box);
 
-    function claimFee(BuyCrossChainPtMessage memory ms, bytes memory sig) external onlyExecutor {
-        _handleBuyCrossChainPt({ms: ms, sig: sig, claimFailed: true});
+        emit WithdrawToken(ms.owner, ms.boxId, ms.token, ms.amountWithdraw, ms.amountFee);
     }
 
-    function _handleWithdrawToken(WithdrawTokenMessage memory ms, bytes memory sig, bool claimFailed) internal {
-        bytes32 actionHash = hashTypedData(ms);
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, actionHash, sig, !claimFailed);
+    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);
+        _payTreasury(box, ms.token, ms.amountFee);
+        _bridgeToken(ms, box, msg.value);
 
-        if (claimFailed) {
-            _markFailedAndTakeFee(actionHash, box, ms.token, ms.amountFee);
-            emit ClaimFeeForFailedAction(ms.owner, ms.boxId, actionHash, ms.token, ms.amountFee);
-        } else {
-            box.withdrawTo(ms.receiver, ms.token, ms.amountWithdraw);
-
-            _markSucceededAndTakeFee(actionHash, box, ms.token, ms.amountFee);
-            emit WithdrawToken(ms.owner, ms.boxId, actionHash, ms.receiver, ms.token, ms.amountWithdraw, ms.amountFee);
-        }
+        emit BridgeToken(
+            ms.owner, ms.boxId, ms.bridgeExtRouter, ms.token, ms.amountBridge, ms.amountFee, ms.pullFromOwner
+        );
     }
 
-    function _handleBridgeToken(BridgeTokenMessage memory ms, bytes memory sig, bool claimFailed) internal {
-        bytes32 actionHash = hashTypedData(ms);
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, actionHash, sig, !claimFailed);
+    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);
 
-        if (claimFailed) {
-            _markFailedAndTakeFee(actionHash, box, ms.token, ms.amountFee);
-            emit ClaimFeeForFailedAction(ms.owner, ms.boxId, actionHash, ms.token, ms.amountFee);
-        } else {
-            _bridgeToken(ms, box, msg.value);
+        uint256 netTokenReceived = _swapToken(ms, box);
+        require(netTokenReceived >= ms.minReceived, InsufficientTokenReceived());
 
-            _markSucceededAndTakeFee(actionHash, box, ms.token, ms.amountFee);
-            emit BridgeToken(
-                ms.owner, ms.boxId, actionHash, ms.bridgeExtRouter, ms.token, ms.amountBridge, ms.amountFee
-            );
-        }
+        emit SwapToken(
+            ms.owner,
+            ms.boxId,
+            ms.tokenSpent,
+            ms.amountSpent,
+            ms.amountFee,
+            ms.tokenReceived,
+            netTokenReceived,
+            ms.pullFromOwner,
+            ms.sendToOwner
+        );
     }
 
-    function _handleSwapToken(SwapTokenMessage memory ms, bytes memory sig, bool claimFailed) internal {
-        bytes32 actionHash = hashTypedData(ms);
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, actionHash, sig, !claimFailed);
+    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);
-
-        if (claimFailed) {
-            _markFailedAndTakeFee(actionHash, box, ms.tokenSpent, ms.amountFee);
-            emit ClaimFeeForFailedAction(ms.owner, ms.boxId, actionHash, ms.tokenSpent, ms.amountFee);
-        } else {
-            uint256 netTokenReceived = _swapToken(ms, box);
-            require(netTokenReceived >= ms.minReceived, InsufficientTokenReceived());
-
-            _markSucceededAndTakeFee(actionHash, box, ms.tokenSpent, ms.amountFee);
-            emit SwapToken(
-                ms.owner,
-                ms.boxId,
-                actionHash,
-                ms.tokenSpent,
-                ms.amountSpent,
-                ms.amountFee,
-                ms.tokenReceived,
-                netTokenReceived
-            );
+        _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
+        );
+    }
+
+    function _pullToken(bool pullFromOwner, IPDepositBox box, address owner, address token, uint256 amount) internal {
+        if (pullFromOwner) {
+            _transferFrom(IERC20(token), owner, address(box), amount);
         }
     }
 
-    function _handleBuyCrossChainPt(BuyCrossChainPtMessage memory ms, bytes memory sig, bool claimFailed) internal {
-        bytes32 actionHash = hashTypedData(ms);
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, actionHash, sig, !claimFailed);
-
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
+    function _payTreasury(IPDepositBox box, address token, uint256 amount) internal {
+        box.withdrawTo(TREASURY, token, amount);
+    }
 
-        if (claimFailed) {
-            _markFailedAndTakeFee(actionHash, box, ms.tokenSpent, ms.amountFee);
-            emit ClaimFeeForFailedAction(ms.owner, ms.boxId, actionHash, ms.tokenSpent, ms.amountFee);
-        } else {
-            address pt = IOFT(ms.ptAdapter).token();
-            uint256 netPtReceived = _buyPtAndBridge(ms, box, pt, msg.value);
-            require(netPtReceived >= ms.minPtReceived, InsufficientTokenReceived());
-
-            _markSucceededAndTakeFee(actionHash, box, ms.tokenSpent, ms.amountFee);
-            emit BuyCrossChainPt(
-                ms.owner,
-                ms.boxId,
-                actionHash,
-                ms.tokenSpent,
-                ms.amountSpent,
-                ms.amountFee,
-                ms.ptAdapter,
-                pt,
-                netPtReceived
-            );
-        }
+    function _withdrawToken(WithdrawTokenMessage memory ms, IPDepositBox box) internal {
+        box.withdrawTo(ms.owner, ms.token, ms.amountWithdraw);
     }
 
     function _bridgeToken(BridgeTokenMessage memory ms, IPDepositBox box, uint256 nativeFee) internal {
-        // forgefmt: disable-next-item
         ApprovedCall memory call = ApprovedCall({
             token: ms.token,
             amount: ms.amountBridge,
-            spender: ms.bridgeExtRouter,
+            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) {
-        SwapData memory swapData = SwapData({
-            tokenIn: ms.tokenSpent,
-            amountIn: ms.amountSpent,
-            tokenOut: ms.tokenReceived,
-            extRouter: ms.swapExtRouter,
-            extCalldata: ms.swapCalldata
+        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)
         });
-        rawTokenReceived = _swapFromBox(box, ms.swapExecutor, swapData, ms.receiver);
     }
 
-    function _buyPtAndBridge(BuyCrossChainPtMessage memory ms, IPDepositBox box, address pt, uint256 nativeFee)
-        internal
-        returns (uint256 netPtReceived)
-    {
-        SwapData memory swapData = SwapData({
-            tokenIn: ms.tokenSpent,
-            amountIn: ms.amountSpent,
-            tokenOut: pt,
-            extRouter: ms.swapExtRouter,
-            extCalldata: ms.swapCalldata
+    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)
         });
-        uint256 rawPtReceived = _swapFromBox(box, ms.swapExecutor, swapData, address(box));
 
         SendParam memory sendParam = SendParam({
             dstEid: ms.dstEid,
@@ -196,11 +165,14 @@ contract PendleCrossChainSwapHub is SwapHubBase {
         ApprovedCall memory call = ApprovedCall({
             token: pt,
             amount: rawPtReceived,
-            spender: ms.ptAdapter,
-            data: abi.encodeCall(IOFT.send, (sendParam, sendFee, msg.sender))
+            approveTo: ms.ptAdapter,
+            callTo: ms.ptAdapter,
+            data: abi.encodeCall(IOFT.send, (sendParam, sendFee, nativeRefund))
         });
         (, OFTReceipt memory oftReceipt) =
-            abi.decode(box.approveAndCall{value: nativeFee}(call, msg.sender), (MessagingReceipt, OFTReceipt));
+            abi.decode(box.approveAndCall{value: nativeFee}(call, nativeRefund), (MessagingReceipt, OFTReceipt));
         netPtReceived = oftReceipt.amountReceivedLD;
     }
+
+    receive() external payable {}
 }

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

@@ -8,8 +8,7 @@ import {EIP712Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/crypt
 import {BoringOwnableUpgradeableV2} from "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
 import {IPCrossChainSwapHub} from "../../interfaces/IPCrossChainSwapHub.sol";
-import {IPDepositBox} from "../../interfaces/IPDepositBox.sol";
-import {IPSwapExecutor, SwapData} from "./swap/IPSwapExecutor.sol";
+import {ApprovedCall, IPDepositBox} from "../../interfaces/IPDepositBox.sol";
 import {DepositBox} from "./DepositBox.sol";
 
 abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringOwnableUpgradeableV2, TokenHelper {
@@ -21,7 +20,6 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "uint256 expiry,"
             "uint256 nonce,"
             //
-            "address receiver,"
             "address token,"
             "uint256 amountWithdraw,"
             "uint256 amountFee"
@@ -39,8 +37,10 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "address token,"
             "uint256 amountBridge,"
             "uint256 amountFee,"
+            "bool pullFromOwner,"
             //
             "address bridgeExtRouter,"
+            "address bridgeApprove,"
             "bytes bridgeCalldata"
         ")"
     );
@@ -58,10 +58,11 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "uint256 amountFee,"
             "address tokenReceived,"
             "uint256 minReceived,"
-            "address receiver,"
+            "bool pullFromOwner,"
+            "bool sendToOwner,"
             //
-            "address swapExecutor,"
             "address swapExtRouter,"
+            "address swapApprove,"
             "bytes swapCalldata"
         ")"
     );
@@ -81,23 +82,26 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "uint256 minPtReceived,"
             "uint32 dstEid,"
             "bytes32 receiver,"
+            "bool pullFromOwner,"
             //
-            "address swapExecutor,"
             "address swapExtRouter,"
+            "address swapApprove,"
             "bytes swapCalldata"
         ")"
     );
 
+    address public immutable TREASURY;
+
     /// @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;
 
     mapping(address owner => uint256 nonce) public ownerNonce;
-    mapping(bytes32 actionStatus => ActionStatus) public actionStatus;
     mapping(address executor => bool) public isExecutor;
 
-    constructor(address beaconProxyCodeContract_, address depositBoxBeacon_) {
+    constructor(address treasury_, address beaconProxyCodeContract_, address depositBoxBeacon_) {
+        TREASURY = treasury_;
         BEACON_PROXY_CODE_CONTRACT = beaconProxyCodeContract_;
         DEPOSIT_BOX_BEACON = depositBoxBeacon_;
         DEPOSIT_BOX_CODE_HASH =
@@ -114,14 +118,19 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
         emit SetExecutor(executor, isExecutor_);
     }
 
-    function computeDepositBox(address owner, uint32 boxId) public view returns (address box, bytes32 salt) {
+    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 _checkAndDeployBox(address owner, uint32 boxId) internal returns (IPDepositBox) {
-        (address box, bytes32 salt) = computeDepositBox(owner, boxId);
-        if (box.code.length > 0) {
+        (address box, bytes32 salt, bool deployed) = computeDepositBox(owner, boxId);
+        if (deployed) {
             return IPDepositBox(box);
         }
 
@@ -141,7 +150,6 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.expiry,
                     message.nonce,
                     //
-                    message.receiver,
                     message.token,
                     message.amountWithdraw,
                     message.amountFee
@@ -163,8 +171,10 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.token,
                     message.amountBridge,
                     message.amountFee,
+                    message.pullFromOwner,
                     //
                     message.bridgeExtRouter,
+                    message.bridgeApprove,
                     keccak256(message.bridgeCalldata)
                 )
             )
@@ -186,10 +196,11 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.amountFee,
                     message.tokenReceived,
                     message.minReceived,
-                    message.receiver,
+                    message.pullFromOwner,
+                    message.sendToOwner,
                     //
-                    message.swapExecutor,
                     message.swapExtRouter,
+                    message.swapApprove,
                     keccak256(message.swapCalldata)
                 )
             )
@@ -213,61 +224,52 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.minPtReceived,
                     message.dstEid,
                     message.receiver,
+                    message.pullFromOwner,
                     //
-                    message.swapExecutor,
                     message.swapExtRouter,
+                    message.swapApprove,
                     keccak256(message.swapCalldata)
                 )
             )
         );
     }
 
-    function _verifyOwnerSig(
-        address owner,
-        uint256 expiry,
-        uint256 nonce,
-        bytes32 messageHash,
-        bytes memory signature,
-        bool verifyNonce
-    ) internal {
-        _verifyOwnerSig(owner, expiry, messageHash, signature);
-        if (verifyNonce) _verifyAndIncreaseNonce(owner, nonce);
-    }
-
-    function _verifyOwnerSig(address owner, uint256 expiry, bytes32 messageHash, bytes memory signature) internal view {
+    function _verifyOwnerSig(address owner, uint256 expiry, uint256 nonce, bytes32 messageHash, bytes memory signature)
+        internal
+    {
         require(SignatureChecker.isValidSignatureNow(owner, messageHash, signature), InvalidSignature());
         require(expiry > block.timestamp, MessageExpired());
-    }
-
-    function _verifyAndIncreaseNonce(address owner, uint256 nonce) internal {
         require(ownerNonce[owner] < nonce, InvalidNonce());
         ownerNonce[owner] = nonce;
     }
 
-    function _balanceOf(address addr, address token) internal view returns (uint256) {
-        return (token == NATIVE) ? addr.balance : IERC20(token).balanceOf(addr);
-    }
+    function _swapFromBox(
+        IPDepositBox box,
+        address tokenSpent,
+        uint256 amountSpent,
+        address tokenReceived,
+        address swapExtRouter,
+        address swapApprove,
+        bytes memory swapCalldata,
+        address receiver
+    ) internal returns (uint256 rawTokenReceived) {
+        // forgefmt: disable-next-item
+        ApprovedCall memory call = ApprovedCall({
+            token: tokenSpent,
+            amount: amountSpent,
+            approveTo: swapApprove,
+            callTo: swapExtRouter,
+            data: swapCalldata
+        });
 
-    function _markSucceededAndTakeFee(bytes32 actionHash, IPDepositBox box, address token, uint256 amount) internal {
-        require(actionStatus[actionHash] == ActionStatus.NOT_EXECUTED, ActionExecuted());
-        actionStatus[actionHash] = ActionStatus.SUCCEEDED;
-        box.payTreasury(token, amount);
-    }
+        uint256 preBalance = _selfBalance(tokenReceived);
+        box.approveAndCall(call, address(box));
+        rawTokenReceived = _selfBalance(tokenReceived) - preBalance;
 
-    function _markFailedAndTakeFee(bytes32 actionHash, IPDepositBox box, address token, uint256 amount) internal {
-        require(actionStatus[actionHash] == ActionStatus.NOT_EXECUTED, ActionExecuted());
-        actionStatus[actionHash] = ActionStatus.FAILED;
-        box.payTreasury(token, amount);
+        _transferOut(tokenReceived, receiver, rawTokenReceived);
     }
 
-    function _swapFromBox(IPDepositBox box, address swapExecutor, SwapData memory swapData, address receiver)
-        internal
-        returns (uint256 rawTokenOut)
-    {
-        box.withdrawTo(swapExecutor, swapData.tokenIn, swapData.amountIn);
-
-        uint256 preBalance = _balanceOf(receiver, swapData.tokenOut);
-        IPSwapExecutor(swapExecutor).swap(receiver, swapData);
-        rawTokenOut = _balanceOf(receiver, swapData.tokenOut) - preBalance;
+    function _addressToBytes32(address addr) internal pure returns (bytes32) {
+        return bytes32(uint256(uint160(addr)));
     }
 }

package/contracts/interfaces/IPCrossChainSwapHub.sol

@@ -2,25 +2,18 @@
 pragma solidity ^0.8.0;
 
 interface IPCrossChainSwapHub {
-    error ActionExecuted();
     error InsufficientTokenReceived();
     error InvalidNonce();
     error InvalidSignature();
+    error InvalidReceiver();
     error MessageExpired();
 
-    enum ActionStatus {
-        NOT_EXECUTED,
-        SUCCEEDED,
-        FAILED
-    }
-
     struct WithdrawTokenMessage {
         address owner;
         uint32 boxId;
         uint256 expiry;
         uint256 nonce;
         //
-        address receiver;
         address token;
         uint256 amountWithdraw;
         uint256 amountFee;
@@ -35,8 +28,10 @@ interface IPCrossChainSwapHub {
         address token;
         uint256 amountBridge;
         uint256 amountFee;
+        bool pullFromOwner;
         //
         address bridgeExtRouter;
+        address bridgeApprove;
         bytes bridgeCalldata;
     }
 
@@ -51,10 +46,11 @@ interface IPCrossChainSwapHub {
         uint256 amountFee;
         address tokenReceived;
         uint256 minReceived;
-        address receiver;
+        bool pullFromOwner;
+        bool sendToOwner;
         //
-        address swapExecutor;
         address swapExtRouter;
+        address swapApprove;
         bytes swapCalldata;
     }
 
@@ -71,57 +67,47 @@ interface IPCrossChainSwapHub {
         uint256 minPtReceived;
         uint32 dstEid;
         bytes32 receiver;
+        bool pullFromOwner;
         //
-        address swapExecutor;
         address swapExtRouter;
+        address swapApprove;
         bytes swapCalldata;
     }
 
-    event WithdrawToken(
-        address indexed owner,
-        uint32 boxId,
-        bytes32 actionHash,
-        address receiver,
-        address token,
-        uint256 amountWithdraw,
-        uint256 amountFee
-    );
+    event WithdrawToken(address indexed owner, uint32 boxId, address token, uint256 amountWithdraw, uint256 amountFee);
 
     event BridgeToken(
         address indexed owner,
         uint32 boxId,
-        bytes32 actionHash,
         address bridgeExtRouter,
         address token,
         uint256 amountBridge,
-        uint256 amountFee
+        uint256 amountFee,
+        bool pullFromOwner
     );
 
     event SwapToken(
         address indexed owner,
         uint32 boxId,
-        bytes32 actionHash,
         address tokenSpent,
         uint256 amountSpent,
         uint256 amountFee,
         address tokenReceived,
-        uint256 netTokenReceived
+        uint256 netTokenReceived,
+        bool pullFromOwner,
+        bool sendToOwner
     );
 
     event BuyCrossChainPt(
         address indexed owner,
         uint32 boxId,
-        bytes32 actionHash,
         address tokenSpent,
         uint256 amountSpent,
         uint256 amountFee,
         address ptAdapter,
         address pt,
-        uint256 netPtReceived
-    );
-
-    event ClaimFeeForFailedAction(
-        address indexed owner, uint32 boxId, bytes32 actionHash, address token, uint256 amount
+        uint256 netPtReceived,
+        bool pullFromOwner
     );
 
     event SetExecutor(address indexed executor, bool isExecutor);
@@ -134,11 +120,12 @@ interface IPCrossChainSwapHub {
 
     function ownerNonce(address owner) external view returns (uint256);
 
-    function actionStatus(bytes32 actionHash) external view returns (ActionStatus);
-
     function isExecutor(address executor) external view returns (bool);
 
-    function computeDepositBox(address owner, uint32 boxId) external view returns (address box, bytes32 salt);
+    function computeDepositBox(address owner, uint32 boxId)
+        external
+        view
+        returns (address box, bytes32 salt, bool deployed);
 
     function hashTypedData(WithdrawTokenMessage memory message) external view returns (bytes32);
 
@@ -156,13 +143,5 @@ interface IPCrossChainSwapHub {
 
     function buyCrossChainPt(BuyCrossChainPtMessage memory message, bytes memory signature) external payable;
 
-    function claimFee(WithdrawTokenMessage memory message, bytes memory signature) external;
-
-    function claimFee(BridgeTokenMessage memory message, bytes memory signature) external;
-
-    function claimFee(SwapTokenMessage memory message, bytes memory signature) external;
-
-    function claimFee(BuyCrossChainPtMessage memory message, bytes memory signature) external;
-
     function setExecutor(address executor, bool isExecutor) external;
 }