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

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

@@ -8,7 +8,6 @@ import {
     OFTReceipt,
     SendParam
 } from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
-import {PMath} from "../../core/libraries/math/PMath.sol";
 import {ApprovedCall, IPDepositBox} from "../../interfaces/IPDepositBox.sol";
 import {SwapData} from "./swap/IPSwapExecutor.sol";
 import {SwapHubBase} from "./SwapHubBase.sol";
@@ -26,78 +25,134 @@ contract PendleCrossChainSwapHub is SwapHubBase {
     }
 
     function withdrawToken(WithdrawTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _verifyOwnerSigAndNonce(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
+        _handleWithdrawToken({ms: ms, sig: sig, claimFailed: false});
+    }
 
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        box.withdrawTo(ms.receiver, ms.token, ms.withdrawAmount);
-        box.payTreasury(ms.token, ms.feeAmount);
+    function bridgeToken(BridgeTokenMessage memory ms, bytes memory sig) external payable onlyExecutor {
+        _handleBridgeToken({ms: ms, sig: sig, claimFailed: false});
+    }
 
-        emit WithdrawToken(ms.owner, ms.boxId, ms.receiver, ms.token, ms.withdrawAmount, ms.feeAmount);
+    function swapToken(SwapTokenMessage memory ms, bytes memory sig) external onlyExecutor {
+        _handleSwapToken({ms: ms, sig: sig, claimFailed: false});
     }
 
-    function bridgeToken(BridgeTokenMessage memory ms, bytes memory sig) external payable onlyExecutor {
-        _verifyOwnerSigAndNonce(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
+    function buyCrossChainPt(BuyCrossChainPtMessage memory ms, bytes memory sig) external payable onlyExecutor {
+        _handleBuyCrossChainPt({ms: ms, sig: sig, claimFailed: false});
+    }
 
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        _bridgeToken(ms, box, msg.value);
-        box.payTreasury(ms.token, ms.feeAmount);
+    function claimFee(WithdrawTokenMessage memory ms, bytes memory sig) external onlyExecutor {
+        _handleWithdrawToken({ms: ms, sig: sig, claimFailed: true});
+    }
 
-        emit BridgeToken(ms.owner, ms.boxId, ms.bridgeExtRouter, ms.token, ms.bridgeAmount, ms.feeAmount);
+    function claimFee(BridgeTokenMessage memory ms, bytes memory sig) external onlyExecutor {
+        _handleBridgeToken({ms: ms, sig: sig, claimFailed: true});
     }
 
-    function swapToken(SwapTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _verifyOwnerSigAndNonce(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
+    function claimFee(SwapTokenMessage memory ms, bytes memory sig) external onlyExecutor {
+        _handleSwapToken({ms: ms, sig: sig, claimFailed: true});
+    }
+
+    function claimFee(BuyCrossChainPtMessage memory ms, bytes memory sig) external onlyExecutor {
+        _handleBuyCrossChainPt({ms: ms, sig: sig, claimFailed: true});
+    }
+
+    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);
 
         IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        uint256 netTokenReceived = _swapToken(ms, box) - ms.feeAmount;
-        box.payTreasury(ms.tokenReceived, ms.feeAmount);
 
-        require(netTokenReceived >= ms.minReceived, InsufficientTokenReceived());
+        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);
 
-        emit SwapToken(ms.owner, ms.boxId, ms.tokenSpent, ms.amountSpent, ms.tokenReceived, netTokenReceived);
+            _markSucceededAndTakeFee(actionHash, box, ms.token, ms.amountFee);
+            emit WithdrawToken(ms.owner, ms.boxId, actionHash, ms.receiver, ms.token, ms.amountWithdraw, ms.amountFee);
+        }
     }
 
-    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);
+    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);
+
+        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
+
+        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);
+
+            _markSucceededAndTakeFee(actionHash, box, ms.token, ms.amountFee);
+            emit BridgeToken(
+                ms.owner, ms.boxId, actionHash, ms.bridgeExtRouter, ms.token, ms.amountBridge, ms.amountFee
+            );
+        }
+    }
 
-        bytes32 intentHash = keccak256(abi.encode(intent));
-        _verifyIntentHashAndMarkExecuted(execMsg.intentHash, intentHash);
+    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);
 
-        IPDepositBox box = _checkAndDeployBox(intent.owner, intent.boxId);
-        uint256 netPtReceived = _buyPt(intent, execMsg, box) - execMsg.feeAmount;
-        box.payTreasury(intent.pt, execMsg.feeAmount);
+        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
 
-        if (intent.ptAdapter == address(0)) {
-            require(msg.value == 0, ExcessiveNativeFee());
+        if (claimFailed) {
+            _markFailedAndTakeFee(actionHash, box, ms.tokenSpent, ms.amountFee);
+            emit ClaimFeeForFailedAction(ms.owner, ms.boxId, actionHash, ms.tokenSpent, ms.amountFee);
         } else {
-            netPtReceived = _bridgePt(intent, box, netPtReceived, msg.value);
+            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
+            );
         }
+    }
 
-        require(netPtReceived >= intent.minPtReceived, InsufficientTokenReceived());
+    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);
 
-        emit BuyCrossChainPt(
-            intent.owner,
-            intent.boxId,
-            intentHash,
-            intent.tokenSpent,
-            execMsg.amountSpent,
-            intent.pt,
-            intent.ptAdapter,
-            netPtReceived
-        );
+        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 {
+            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 _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 +167,26 @@ contract PendleCrossChainSwapHub is SwapHubBase {
             extRouter: ms.swapExtRouter,
             extCalldata: ms.swapCalldata
         });
-        rawTokenReceived = _swapFromBox(box, ms.swapExecutor, swapData);
+        rawTokenReceived = _swapFromBox(box, ms.swapExecutor, swapData, ms.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()
-        );
-
         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,12 +194,11 @@ 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;

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

@@ -23,8 +23,8 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             //
             "address receiver,"
             "address token,"
-            "uint256 withdrawAmount,"
-            "uint256 feeAmount"
+            "uint256 amountWithdraw,"
+            "uint256 amountFee"
         ")"
     );
 
@@ -37,8 +37,8 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             "uint256 nonce,"
             //
             "address token,"
-            "uint256 bridgeAmount,"
-            "uint256 feeAmount,"
+            "uint256 amountBridge,"
+            "uint256 amountFee,"
             //
             "address bridgeExtRouter,"
             "bytes bridgeCalldata"
@@ -55,9 +55,10 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
             //
             "address tokenSpent,"
             "uint256 amountSpent,"
+            "uint256 amountFee,"
             "address tokenReceived,"
             "uint256 minReceived,"
-            "uint256 feeAmount,"
+            "address receiver,"
             //
             "address swapExecutor,"
             "address swapExtRouter,"
@@ -66,34 +67,24 @@ 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,"
+            //
             "address swapExecutor,"
             "address swapExtRouter,"
-            "bytes swapCalldata,"
-            "uint256 expiry"
+            "bytes swapCalldata"
         ")"
     );
 
@@ -103,9 +94,8 @@ 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(bytes32 actionStatus => ActionStatus) public actionStatus;
     mapping(address executor => bool) public isExecutor;
-    mapping(address validator => bool) public isValidator;
 
     constructor(address beaconProxyCodeContract_, address depositBoxBeacon_) {
         BEACON_PROXY_CODE_CONTRACT = beaconProxyCodeContract_;
@@ -124,11 +114,6 @@ 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) {
         salt = keccak256(abi.encode(owner, boxId));
         box = Create2.computeAddress(salt, DEPOSIT_BOX_CODE_HASH);
@@ -158,8 +143,8 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     //
                     message.receiver,
                     message.token,
-                    message.withdrawAmount,
-                    message.feeAmount
+                    message.amountWithdraw,
+                    message.amountFee
                 )
             )
         );
@@ -176,8 +161,8 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     message.nonce,
                     //
                     message.token,
-                    message.bridgeAmount,
-                    message.feeAmount,
+                    message.amountBridge,
+                    message.amountFee,
                     //
                     message.bridgeExtRouter,
                     keccak256(message.bridgeCalldata)
@@ -198,9 +183,10 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
                     //
                     message.tokenSpent,
                     message.amountSpent,
+                    message.amountFee,
                     message.tokenReceived,
                     message.minReceived,
-                    message.feeAmount,
+                    message.receiver,
                     //
                     message.swapExecutor,
                     message.swapExtRouter,
@@ -210,55 +196,42 @@ 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.swapExecutor,
                     message.swapExtRouter,
-                    keccak256(message.swapCalldata),
-                    message.expiry
+                    keccak256(message.swapCalldata)
                 )
             )
         );
     }
 
-    function _verifyOwnerSigAndNonce(
+    function _verifyOwnerSig(
         address owner,
         uint256 expiry,
         uint256 nonce,
         bytes32 messageHash,
-        bytes memory signature
+        bytes memory signature,
+        bool verifyNonce
     ) internal {
         _verifyOwnerSig(owner, expiry, messageHash, signature);
-        _verifyAndIncreaseNonce(owner, nonce);
+        if (verifyNonce) _verifyAndIncreaseNonce(owner, nonce);
     }
 
     function _verifyOwnerSig(address owner, uint256 expiry, bytes32 messageHash, bytes memory signature) internal view {
@@ -271,33 +244,30 @@ 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 _balanceOf(address addr, address token) internal view returns (uint256) {
+        return (token == NATIVE) ? addr.balance : IERC20(token).balanceOf(addr);
     }
 
-    function _verifyIntentHashAndMarkExecuted(bytes32 expectedHash, bytes32 actualHash) internal {
-        require(expectedHash == actualHash, IntentHashMismatch());
-        require(!isIntentExecuted[actualHash], IntentExecuted());
-        isIntentExecuted[actualHash] = true;
+    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 _balanceOf(address addr, address token) internal view returns (uint256) {
-        return (token == NATIVE) ? addr.balance : IERC20(token).balanceOf(addr);
+    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)
+    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;
     }
 }