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

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

@@ -8,7 +8,7 @@ import {
     OFTReceipt,
     SendParam
 } from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
-import {PMath} from "../../core/libraries/math/PMath.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";
@@ -26,78 +26,94 @@ contract PendleCrossChainSwapHub is SwapHubBase {
     }
 
     function withdrawToken(WithdrawTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _verifyOwnerSigAndNonce(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
+        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
 
         IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        box.withdrawTo(ms.receiver, ms.token, ms.withdrawAmount);
-        box.payTreasury(ms.token, ms.feeAmount);
+        _payTreasury(box, ms.token, ms.amountFee);
+        _withdrawToken(ms, box);
 
-        emit WithdrawToken(ms.owner, ms.boxId, ms.receiver, ms.token, ms.withdrawAmount, ms.feeAmount);
+        emit WithdrawToken(ms.owner, ms.boxId, ms.token, ms.amountWithdraw, ms.amountFee);
     }
 
     function bridgeToken(BridgeTokenMessage memory ms, bytes memory sig) external payable onlyExecutor {
-        _verifyOwnerSigAndNonce(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
+        _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);
-        box.payTreasury(ms.token, ms.feeAmount);
 
-        emit BridgeToken(ms.owner, ms.boxId, ms.bridgeExtRouter, ms.token, ms.bridgeAmount, ms.feeAmount);
+        emit BridgeToken(
+            ms.owner, ms.boxId, ms.bridgeExtRouter, ms.token, ms.amountBridge, ms.amountFee, ms.pullFromOwner
+        );
     }
 
     function swapToken(SwapTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _verifyOwnerSigAndNonce(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
+        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
 
         IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        uint256 netTokenReceived = _swapToken(ms, box) - ms.feeAmount;
-        box.payTreasury(ms.tokenReceived, ms.feeAmount);
+        _pullToken(ms.pullFromOwner, box, ms.owner, ms.tokenSpent, ms.amountSpent + ms.amountFee);
+        _payTreasury(box, ms.tokenSpent, ms.amountFee);
 
+        uint256 netTokenReceived = _swapToken(ms, box);
         require(netTokenReceived >= ms.minReceived, InsufficientTokenReceived());
 
-        emit SwapToken(ms.owner, ms.boxId, ms.tokenSpent, ms.amountSpent, ms.tokenReceived, netTokenReceived);
+        emit SwapToken(
+            ms.owner,
+            ms.boxId,
+            ms.tokenSpent,
+            ms.amountSpent,
+            ms.amountFee,
+            ms.tokenReceived,
+            netTokenReceived,
+            ms.pullFromOwner,
+            ms.sendToOwner
+        );
     }
 
-    function buyCrossChainPt(
-        BuyCrossChainPtIntent memory intent,
-        bytes memory intentSig,
-        ExecuteBuyCrossChainPtMessage memory execMsg,
-        bytes memory execSig
-    ) external payable onlyExecutor {
-        _verifyOwnerSig(intent.owner, intent.expiry, hashTypedData(intent), intentSig);
-        _verifyValidatorSig(execMsg.validator, execMsg.expiry, hashTypedData(execMsg), execSig);
-
-        bytes32 intentHash = keccak256(abi.encode(intent));
-        _verifyIntentHashAndMarkExecuted(execMsg.intentHash, intentHash);
-
-        IPDepositBox box = _checkAndDeployBox(intent.owner, intent.boxId);
-        uint256 netPtReceived = _buyPt(intent, execMsg, box) - execMsg.feeAmount;
-        box.payTreasury(intent.pt, execMsg.feeAmount);
-
-        if (intent.ptAdapter == address(0)) {
-            require(msg.value == 0, ExcessiveNativeFee());
-        } else {
-            netPtReceived = _bridgePt(intent, box, netPtReceived, msg.value);
-        }
+    function buyCrossChainPt(BuyCrossChainPtMessage memory ms, bytes memory sig) external payable onlyExecutor {
+        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
 
-        require(netPtReceived >= intent.minPtReceived, InsufficientTokenReceived());
+        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);
+        require(netPtReceived >= ms.minPtReceived, InsufficientTokenReceived());
 
         emit BuyCrossChainPt(
-            intent.owner,
-            intent.boxId,
-            intentHash,
-            intent.tokenSpent,
-            execMsg.amountSpent,
-            intent.pt,
-            intent.ptAdapter,
-            netPtReceived
+            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 _payTreasury(IPDepositBox box, address token, uint256 amount) internal {
+        box.payTreasury(token, amount);
+    }
+
+    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.bridgeAmount,
+            amount: ms.amountBridge,
             spender: ms.bridgeExtRouter,
             data: ms.bridgeCalldata
         });
@@ -112,36 +128,30 @@ contract PendleCrossChainSwapHub is SwapHubBase {
             extRouter: ms.swapExtRouter,
             extCalldata: ms.swapCalldata
         });
-        rawTokenReceived = _swapFromBox(box, ms.swapExecutor, swapData);
+
+        address receiver = ms.sendToOwner ? ms.owner : address(box);
+        rawTokenReceived = _swapFromBox(box, ms.swapExecutor, swapData, receiver);
     }
 
-    function _buyPt(BuyCrossChainPtIntent memory intent, ExecuteBuyCrossChainPtMessage memory execMsg, IPDepositBox box)
+    function _buyPtAndBridge(BuyCrossChainPtMessage memory ms, IPDepositBox box, address pt, uint256 nativeFee)
         internal
-        returns (uint256 rawPtReceived)
+        returns (uint256 netPtReceived)
     {
-        require(
-            execMsg.amountSpent <= PMath.min(intent.maxAmountSpent, _balanceOf(address(box), intent.tokenSpent)),
-            InvalidAmountIn()
-        );
+        require(ms.receiver == _addressToBytes32(ms.owner), InvalidReceiver());
 
         SwapData memory swapData = SwapData({
-            tokenIn: intent.tokenSpent,
-            amountIn: execMsg.amountSpent,
-            tokenOut: intent.pt,
-            extRouter: execMsg.swapExtRouter,
-            extCalldata: execMsg.swapCalldata
+            tokenIn: ms.tokenSpent,
+            amountIn: ms.amountSpent,
+            tokenOut: pt,
+            extRouter: ms.swapExtRouter,
+            extCalldata: ms.swapCalldata
         });
-        rawPtReceived = _swapFromBox(box, execMsg.swapExecutor, swapData);
-    }
+        uint256 rawPtReceived = _swapFromBox(box, ms.swapExecutor, swapData, address(box));
 
-    function _bridgePt(BuyCrossChainPtIntent memory intent, IPDepositBox box, uint256 amount, uint256 nativeFee)
-        internal
-        returns (uint256 netPtReceived)
-    {
         SendParam memory sendParam = SendParam({
-            dstEid: intent.dstLzEid,
-            to: intent.receiver,
-            amountLD: amount,
+            dstEid: ms.dstEid,
+            to: ms.receiver,
+            amountLD: rawPtReceived,
             minAmountLD: 0,
             extraOptions: "",
             composeMsg: "",
@@ -149,14 +159,17 @@ contract PendleCrossChainSwapHub is SwapHubBase {
         });
         MessagingFee memory sendFee = MessagingFee({nativeFee: nativeFee, lzTokenFee: 0});
         ApprovedCall memory call = ApprovedCall({
-            token: intent.pt,
-            amount: amount,
-            spender: intent.ptAdapter,
+            token: pt,
+            amount: rawPtReceived,
+            spender: ms.ptAdapter,
             data: abi.encodeCall(IOFT.send, (sendParam, sendFee, msg.sender))
         });
-
         (, OFTReceipt memory oftReceipt) =
             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,10 +21,9 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "uint256 expiry,"
             "uint256 nonce,"
             //
-            "address receiver,"
             "address token,"
-            "uint256 withdrawAmount,"
-            "uint256 feeAmount"
+            "uint256 amountWithdraw,"
+            "uint256 amountFee"
         ")"
     );
 
@@ -37,8 +36,9 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "uint256 nonce,"
             //
             "address token,"
-            "uint256 bridgeAmount,"
-            "uint256 feeAmount,"
+            "uint256 amountBridge,"
+            "uint256 amountFee,"
+            "bool pullFromOwner,"
             //
             "address bridgeExtRouter,"
             "bytes bridgeCalldata"
@@ -55,9 +55,11 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             //
             "address tokenSpent,"
             "uint256 amountSpent,"
+            "uint256 amountFee,"
             "address tokenReceived,"
             "uint256 minReceived,"
-            "uint256 feeAmount,"
+            "bool pullFromOwner,"
+            "bool sendToOwner,"
             //
             "address swapExecutor,"
             "address swapExtRouter,"
@@ -66,34 +68,25 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
     );
 
     // forgefmt: disable-next-item
-    bytes32 internal constant BUY_CROSS_CHAIN_PT_INTENT_TYPEHASH = keccak256(
-        "BuyCrossChainPtIntent("
+    bytes32 internal constant BUY_CROSS_CHAIN_PT_MESSAGE_TYPEHASH = keccak256(
+        "BuyCrossChainPtMessage("
             "address owner,"
             "uint32 boxId,"
-            "uint256 salt,"
             "uint256 expiry,"
+            "uint256 nonce,"
             //
             "address tokenSpent,"
-            "uint256 maxAmountSpent,"
-            "address pt,"
+            "uint256 amountSpent,"
+            "uint256 amountFee,"
             "address ptAdapter,"
             "uint256 minPtReceived,"
-            "uint32 dstLzEid,"
-            "bytes32 receiver"
-        ")"
-    );
-
-    // forgefmt: disable-next-item
-    bytes32 internal constant EXECUTE_BUY_CROSS_CHAIN_PT_MESSAGE_TYPEHASH = keccak256(
-        "ExecuteBuyCrossChainPtMessage("
-            "address validator,"
-            "bytes32 intentHash,"
-            "uint256 amountSpent,"
-            "uint256 feeAmount,"
+            "uint32 dstEid,"
+            "bytes32 receiver,"
+            "bool pullFromOwner,"
+            //
             "address swapExecutor,"
             "address swapExtRouter,"
-            "bytes swapCalldata,"
-            "uint256 expiry"
+            "bytes swapCalldata"
         ")"
     );
 
@@ -103,9 +96,7 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
     bytes32 public immutable DEPOSIT_BOX_CODE_HASH;
 
     mapping(address owner => uint256 nonce) public ownerNonce;
-    mapping(bytes32 intentHash => bool) public isIntentExecuted;
     mapping(address executor => bool) public isExecutor;
-    mapping(address validator => bool) public isValidator;
 
     constructor(address beaconProxyCodeContract_, address depositBoxBeacon_) {
         BEACON_PROXY_CODE_CONTRACT = beaconProxyCodeContract_;
@@ -124,19 +115,19 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
         emit SetExecutor(executor, isExecutor_);
     }
 
-    function setValidator(address validator, bool isValidator_) external onlyOwner {
-        isValidator[validator] = isValidator_;
-        emit SetValidator(validator, isValidator_);
-    }
-
-    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);
         }
 
@@ -156,10 +147,9 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.expiry,
                     message.nonce,
                     //
-                    message.receiver,
                     message.token,
-                    message.withdrawAmount,
-                    message.feeAmount
+                    message.amountWithdraw,
+                    message.amountFee
                 )
             )
         );
@@ -176,8 +166,9 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.nonce,
                     //
                     message.token,
-                    message.bridgeAmount,
-                    message.feeAmount,
+                    message.amountBridge,
+                    message.amountFee,
+                    message.pullFromOwner,
                     //
                     message.bridgeExtRouter,
                     keccak256(message.bridgeCalldata)
@@ -198,9 +189,11 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     //
                     message.tokenSpent,
                     message.amountSpent,
+                    message.amountFee,
                     message.tokenReceived,
                     message.minReceived,
-                    message.feeAmount,
+                    message.pullFromOwner,
+                    message.sendToOwner,
                     //
                     message.swapExecutor,
                     message.swapExtRouter,
@@ -210,53 +203,36 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
         );
     }
 
-    function hashTypedData(BuyCrossChainPtIntent memory intent) public view returns (bytes32) {
+    function hashTypedData(BuyCrossChainPtMessage memory message) public view returns (bytes32) {
         return _hashTypedDataV4(
             keccak256(
                 abi.encode(
-                    BUY_CROSS_CHAIN_PT_INTENT_TYPEHASH,
-                    intent.owner,
-                    intent.boxId,
-                    intent.salt,
-                    intent.expiry,
+                    BUY_CROSS_CHAIN_PT_MESSAGE_TYPEHASH,
+                    message.owner,
+                    message.boxId,
+                    message.expiry,
+                    message.nonce,
                     //
-                    intent.tokenSpent,
-                    intent.maxAmountSpent,
-                    intent.pt,
-                    intent.ptAdapter,
-                    intent.minPtReceived,
-                    intent.dstLzEid,
-                    intent.receiver
-                )
-            )
-        );
-    }
-
-    function hashTypedData(ExecuteBuyCrossChainPtMessage memory message) public view returns (bytes32) {
-        return _hashTypedDataV4(
-            keccak256(
-                abi.encode(
-                    EXECUTE_BUY_CROSS_CHAIN_PT_MESSAGE_TYPEHASH,
-                    message.validator,
-                    message.intentHash,
+                    message.tokenSpent,
                     message.amountSpent,
-                    message.feeAmount,
+                    message.amountFee,
+                    message.ptAdapter,
+                    message.minPtReceived,
+                    message.dstEid,
+                    message.receiver,
+                    message.pullFromOwner,
+                    //
                     message.swapExecutor,
                     message.swapExtRouter,
-                    keccak256(message.swapCalldata),
-                    message.expiry
+                    keccak256(message.swapCalldata)
                 )
             )
         );
     }
 
-    function _verifyOwnerSigAndNonce(
-        address owner,
-        uint256 expiry,
-        uint256 nonce,
-        bytes32 messageHash,
-        bytes memory signature
-    ) internal {
+    function _verifyOwnerSig(address owner, uint256 expiry, uint256 nonce, bytes32 messageHash, bytes memory signature)
+        internal
+    {
         _verifyOwnerSig(owner, expiry, messageHash, signature);
         _verifyAndIncreaseNonce(owner, nonce);
     }
@@ -271,33 +247,18 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
         ownerNonce[owner] = nonce;
     }
 
-    function _verifyValidatorSig(address validator, uint256 expiry, bytes32 messageHash, bytes memory signature)
-        internal
-        view
-    {
-        require(SignatureChecker.isValidSignatureNow(validator, messageHash, signature), InvalidSignature());
-        require(isValidator[validator], InvalidValidator());
-        require(expiry > block.timestamp, MessageExpired());
-    }
-
-    function _verifyIntentHashAndMarkExecuted(bytes32 expectedHash, bytes32 actualHash) internal {
-        require(expectedHash == actualHash, IntentHashMismatch());
-        require(!isIntentExecuted[actualHash], IntentExecuted());
-        isIntentExecuted[actualHash] = true;
-    }
-
     function _balanceOf(address addr, address token) internal view returns (uint256) {
         return (token == NATIVE) ? addr.balance : IERC20(token).balanceOf(addr);
     }
 
-    function _swapFromBox(IPDepositBox box, address swapExecutor, SwapData memory swapData)
+    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(address(box), swapData.tokenOut);
-        IPSwapExecutor(swapExecutor).swap(address(box), swapData);
-        rawTokenOut = _balanceOf(address(box), swapData.tokenOut) - preBalance;
+        uint256 preBalance = _balanceOf(receiver, swapData.tokenOut);
+        IPSwapExecutor(swapExecutor).swap(receiver, swapData);
+        rawTokenOut = _balanceOf(receiver, swapData.tokenOut) - preBalance;
     }
 }

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);
         }
     }