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

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

@@ -8,6 +8,7 @@ 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";
@@ -25,127 +26,87 @@ 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});
-    }
-
-    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});
-    }
+        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
 
-    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);
+        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.payTreasury(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 {
@@ -167,13 +128,17 @@ contract PendleCrossChainSwapHub is SwapHubBase {
             extRouter: ms.swapExtRouter,
             extCalldata: ms.swapCalldata
         });
-        rawTokenReceived = _swapFromBox(box, ms.swapExecutor, swapData, ms.receiver);
+
+        address receiver = ms.sendToOwner ? ms.owner : address(box);
+        rawTokenReceived = _swapFromBox(box, ms.swapExecutor, swapData, receiver);
     }
 
     function _buyPtAndBridge(BuyCrossChainPtMessage memory ms, IPDepositBox box, address pt, uint256 nativeFee)
         internal
         returns (uint256 netPtReceived)
     {
+        require(ms.receiver == _addressToBytes32(ms.owner), InvalidReceiver());
+
         SwapData memory swapData = SwapData({
             tokenIn: ms.tokenSpent,
             amountIn: ms.amountSpent,
@@ -203,4 +168,8 @@ contract PendleCrossChainSwapHub is SwapHubBase {
             abi.decode(box.approveAndCall{value: nativeFee}(call, msg.sender), (MessagingReceipt, OFTReceipt));
         netPtReceived = oftReceipt.amountReceivedLD;
     }
+
+    function _addressToBytes32(address addr) internal pure returns (bytes32) {
+        return bytes32(uint256(uint160(addr)));
+    }
 }

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

@@ -21,7 +21,6 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "uint256 expiry,"
             "uint256 nonce,"
             //
-            "address receiver,"
             "address token,"
             "uint256 amountWithdraw,"
             "uint256 amountFee"
@@ -39,6 +38,7 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "address token,"
             "uint256 amountBridge,"
             "uint256 amountFee,"
+            "bool pullFromOwner,"
             //
             "address bridgeExtRouter,"
             "bytes bridgeCalldata"
@@ -58,7 +58,8 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "uint256 amountFee,"
             "address tokenReceived,"
             "uint256 minReceived,"
-            "address receiver,"
+            "bool pullFromOwner,"
+            "bool sendToOwner,"
             //
             "address swapExecutor,"
             "address swapExtRouter,"
@@ -81,6 +82,7 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "uint256 minPtReceived,"
             "uint32 dstEid,"
             "bytes32 receiver,"
+            "bool pullFromOwner,"
             //
             "address swapExecutor,"
             "address swapExtRouter,"
@@ -94,7 +96,6 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
     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_) {
@@ -114,14 +115,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 +147,6 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.expiry,
                     message.nonce,
                     //
-                    message.receiver,
                     message.token,
                     message.amountWithdraw,
                     message.amountFee
@@ -163,6 +168,7 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.token,
                     message.amountBridge,
                     message.amountFee,
+                    message.pullFromOwner,
                     //
                     message.bridgeExtRouter,
                     keccak256(message.bridgeCalldata)
@@ -186,7 +192,8 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.amountFee,
                     message.tokenReceived,
                     message.minReceived,
-                    message.receiver,
+                    message.pullFromOwner,
+                    message.sendToOwner,
                     //
                     message.swapExecutor,
                     message.swapExtRouter,
@@ -213,6 +220,7 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.minPtReceived,
                     message.dstEid,
                     message.receiver,
+                    message.pullFromOwner,
                     //
                     message.swapExecutor,
                     message.swapExtRouter,
@@ -222,16 +230,11 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
         );
     }
 
-    function _verifyOwnerSig(
-        address owner,
-        uint256 expiry,
-        uint256 nonce,
-        bytes32 messageHash,
-        bytes memory signature,
-        bool verifyNonce
-    ) internal {
+    function _verifyOwnerSig(address owner, uint256 expiry, uint256 nonce, bytes32 messageHash, bytes memory signature)
+        internal
+    {
         _verifyOwnerSig(owner, expiry, messageHash, signature);
-        if (verifyNonce) _verifyAndIncreaseNonce(owner, nonce);
+        _verifyAndIncreaseNonce(owner, nonce);
     }
 
     function _verifyOwnerSig(address owner, uint256 expiry, bytes32 messageHash, bytes memory signature) internal view {
@@ -248,18 +251,6 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
         return (token == NATIVE) ? addr.balance : IERC20(token).balanceOf(addr);
     }
 
-    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);
-    }
-
-    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);
-    }
-
     function _swapFromBox(IPDepositBox box, address swapExecutor, SwapData memory swapData, address receiver)
         internal
         returns (uint256 rawTokenOut)

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

@@ -19,13 +19,8 @@ contract SwapExecutor is IPSwapExecutor, TokenHelper {
 
     function _approveForExtRouter(address token, address extRouter) internal {
         if (token == NATIVE) return;
-
-        _safeApproveInfV2(IERC20(token), extRouter);
-    }
-
-    function _safeApproveInfV2(IERC20 token, address spender) internal {
-        if (token.allowance(address(this), spender) < type(uint256).max) {
-            token.forceApprove(spender, type(uint256).max);
+        if (IERC20(token).allowance(address(this), extRouter) < type(uint256).max) {
+            IERC20(token).forceApprove(extRouter, type(uint256).max);
         }
     }
 

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,6 +28,7 @@ interface IPCrossChainSwapHub {
         address token;
         uint256 amountBridge;
         uint256 amountFee;
+        bool pullFromOwner;
         //
         address bridgeExtRouter;
         bytes bridgeCalldata;
@@ -51,7 +45,8 @@ interface IPCrossChainSwapHub {
         uint256 amountFee;
         address tokenReceived;
         uint256 minReceived;
-        address receiver;
+        bool pullFromOwner;
+        bool sendToOwner;
         //
         address swapExecutor;
         address swapExtRouter;
@@ -71,57 +66,47 @@ interface IPCrossChainSwapHub {
         uint256 minPtReceived;
         uint32 dstEid;
         bytes32 receiver;
+        bool pullFromOwner;
         //
         address swapExecutor;
         address swapExtRouter;
         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 +119,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 +142,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;
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "6.3.2-swaphubtest2",
+  "version": "6.3.2-swaphubtest3",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",