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

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

@@ -1,24 +1,25 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.30;
 
-import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
 import {EIP712Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
 import {BoringOwnableUpgradeableV2} from "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
 import {IPCrossChainSwapHub} from "../../interfaces/IPCrossChainSwapHub.sol";
 import {ApprovedCall, IPDepositBox} from "../../interfaces/IPDepositBox.sol";
-import {DepositBox} from "./DepositBox.sol";
+import {IPDepositBoxFactory} from "../../interfaces/IPDepositBoxFactory.sol";
 
 abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringOwnableUpgradeableV2, TokenHelper {
     // forgefmt: disable-next-item
     bytes32 internal constant WITHDRAW_TOKEN_MESSAGE_TYPEHASH = keccak256(
         "WithdrawTokenMessage("
-            "address owner,"
-            "uint32 boxId,"
+            "address proposer,"
             "uint256 expiry,"
+            "uint256 requestId,"
             "uint256 nonce,"
             //
+            "address owner,"
+            "uint32 boxId,"
             "address token,"
             "uint256 amountWithdraw,"
             "uint256 amountFee"
@@ -28,15 +29,16 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
     // forgefmt: disable-next-item
     bytes32 internal constant BRIDGE_TOKEN_MESSAGE_TYPEHASH = keccak256(
         "BridgeTokenMessage("
-            "address owner,"
-            "uint32 boxId,"
+            "address proposer,"
             "uint256 expiry,"
+            "uint256 requestId,"
             "uint256 nonce,"
             //
+            "address owner,"
+            "uint32 boxId,"
             "address token,"
             "uint256 amountBridge,"
             "uint256 amountFee,"
-            "bool pullFromOwner,"
             //
             "address bridgeExtRouter,"
             "address bridgeApprove,"
@@ -47,41 +49,17 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
     // forgefmt: disable-next-item
     bytes32 internal constant SWAP_TOKEN_MESSAGE_TYPEHASH = keccak256(
         "SwapTokenMessage("
-            "address owner,"
-            "uint32 boxId,"
+            "address proposer,"
             "uint256 expiry,"
+            "uint256 requestId,"
             "uint256 nonce,"
             //
-            "address tokenSpent,"
-            "uint256 amountSpent,"
-            "uint256 amountFee,"
-            "address tokenReceived,"
-            "uint256 minReceived,"
-            "bool pullFromOwner,"
-            "bool sendToOwner,"
-            //
-            "address swapExtRouter,"
-            "address swapApprove,"
-            "bytes swapCalldata"
-        ")"
-    );
-
-    // forgefmt: disable-next-item
-    bytes32 internal constant BUY_CROSS_CHAIN_PT_MESSAGE_TYPEHASH = keccak256(
-        "BuyCrossChainPtMessage("
             "address owner,"
             "uint32 boxId,"
-            "uint256 expiry,"
-            "uint256 nonce,"
-            //
             "address tokenSpent,"
             "uint256 amountSpent,"
-            "uint256 amountFee,"
-            "address ptAdapter,"
-            "uint256 minPtReceived,"
-            "uint32 dstEid,"
-            "bytes32 receiver,"
-            "bool pullFromOwner,"
+            "address tokenReceived,"
+            "uint256 minReceived,"
             //
             "address swapExtRouter,"
             "address swapApprove,"
@@ -90,21 +68,15 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
     );
 
     address public immutable TREASURY;
+    IPDepositBoxFactory public immutable DEPOSIT_BOX_FACTORY;
 
-    /// @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(address executor => bool) public isExecutor;
+    mapping(address proposer => bool) public isProposer;
+    mapping(uint256 requestId => uint256 nonce) public requestNonce;
 
-    constructor(address treasury_, address beaconProxyCodeContract_, address depositBoxBeacon_) {
+    constructor(address treasury_, address depositBoxFactory_) {
         TREASURY = treasury_;
-        BEACON_PROXY_CODE_CONTRACT = beaconProxyCodeContract_;
-        DEPOSIT_BOX_BEACON = depositBoxBeacon_;
-        DEPOSIT_BOX_CODE_HASH =
-            keccak256(abi.encodePacked(beaconProxyCodeContract_.code, abi.encode(depositBoxBeacon_, "")));
+        DEPOSIT_BOX_FACTORY = IPDepositBoxFactory(depositBoxFactory_);
     }
 
     modifier onlyExecutor() {
@@ -117,129 +89,92 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
         emit SetExecutor(executor, isExecutor_);
     }
 
-    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, 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);
+    function setProposer(address proposer, bool isProposer_) external onlyOwner {
+        isProposer[proposer] = isProposer_;
+        emit SetProposer(proposer, isProposer_);
     }
 
-    function hashTypedData(WithdrawTokenMessage memory message) public view returns (bytes32) {
+    function hashTypedData(WithdrawTokenMessage memory ms) public view returns (bytes32) {
         return _hashTypedDataV4(
             keccak256(
                 abi.encode(
                     WITHDRAW_TOKEN_MESSAGE_TYPEHASH,
-                    message.owner,
-                    message.boxId,
-                    message.expiry,
-                    message.nonce,
+                    ms.proposer,
+                    ms.expiry,
+                    ms.requestId,
+                    ms.nonce,
                     //
-                    message.token,
-                    message.amountWithdraw,
-                    message.amountFee
+                    ms.owner,
+                    ms.boxId,
+                    ms.token,
+                    ms.amountWithdraw,
+                    ms.amountFee
                 )
             )
         );
     }
 
-    function hashTypedData(BridgeTokenMessage memory message) public view returns (bytes32) {
+    function hashTypedData(BridgeTokenMessage memory ms) public view returns (bytes32) {
         return _hashTypedDataV4(
             keccak256(
                 abi.encode(
                     BRIDGE_TOKEN_MESSAGE_TYPEHASH,
-                    message.owner,
-                    message.boxId,
-                    message.expiry,
-                    message.nonce,
+                    ms.proposer,
+                    ms.expiry,
+                    ms.requestId,
+                    ms.nonce,
                     //
-                    message.token,
-                    message.amountBridge,
-                    message.amountFee,
-                    message.pullFromOwner,
+                    ms.owner,
+                    ms.boxId,
+                    ms.token,
+                    ms.amountBridge,
+                    ms.amountFee,
                     //
-                    message.bridgeExtRouter,
-                    message.bridgeApprove,
-                    keccak256(message.bridgeCalldata)
+                    ms.bridgeExtRouter,
+                    ms.bridgeApprove,
+                    keccak256(ms.bridgeCalldata)
                 )
             )
         );
     }
 
-    function hashTypedData(SwapTokenMessage memory message) public view returns (bytes32) {
+    function hashTypedData(SwapTokenMessage memory ms) public view returns (bytes32) {
         return _hashTypedDataV4(
             keccak256(
                 abi.encode(
                     SWAP_TOKEN_MESSAGE_TYPEHASH,
-                    message.owner,
-                    message.boxId,
-                    message.expiry,
-                    message.nonce,
+                    ms.proposer,
+                    ms.expiry,
+                    ms.requestId,
+                    ms.nonce,
                     //
-                    message.tokenSpent,
-                    message.amountSpent,
-                    message.amountFee,
-                    message.tokenReceived,
-                    message.minReceived,
-                    message.pullFromOwner,
-                    message.sendToOwner,
+                    ms.owner,
+                    ms.boxId,
+                    ms.tokenSpent,
+                    ms.amountSpent,
+                    ms.tokenReceived,
+                    ms.minReceived,
                     //
-                    message.swapExtRouter,
-                    message.swapApprove,
-                    keccak256(message.swapCalldata)
+                    ms.swapExtRouter,
+                    ms.swapApprove,
+                    keccak256(ms.swapCalldata)
                 )
             )
         );
     }
 
-    function hashTypedData(BuyCrossChainPtMessage memory message) public view returns (bytes32) {
-        return _hashTypedDataV4(
-            keccak256(
-                abi.encode(
-                    BUY_CROSS_CHAIN_PT_MESSAGE_TYPEHASH,
-                    message.owner,
-                    message.boxId,
-                    message.expiry,
-                    message.nonce,
-                    //
-                    message.tokenSpent,
-                    message.amountSpent,
-                    message.amountFee,
-                    message.ptAdapter,
-                    message.minPtReceived,
-                    message.dstEid,
-                    message.receiver,
-                    message.pullFromOwner,
-                    //
-                    message.swapExtRouter,
-                    message.swapApprove,
-                    keccak256(message.swapCalldata)
-                )
-            )
-        );
-    }
-
-    function _verifyOwnerSig(address owner, uint256 expiry, uint256 nonce, bytes32 messageHash, bytes memory signature)
-        internal
-    {
-        require(SignatureChecker.isValidSignatureNow(owner, messageHash, signature), InvalidSignature());
+    function _verifyProposerSig(
+        address proposer,
+        uint256 expiry,
+        uint256 requestId,
+        uint256 nonce,
+        bytes32 messageHash,
+        bytes memory signature
+    ) internal {
+        require(SignatureChecker.isValidSignatureNow(proposer, messageHash, signature), InvalidSignature());
         require(expiry > block.timestamp, MessageExpired());
-        require(ownerNonce[owner] < nonce, InvalidNonce());
-        ownerNonce[owner] = nonce;
+        require(requestNonce[requestId] + 1 == nonce, InvalidNonce());
+        requestNonce[requestId] = nonce;
     }
 
     function _swapFromBox(
@@ -249,26 +184,14 @@ abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringO
         address tokenReceived,
         address swapExtRouter,
         address swapApprove,
-        bytes memory swapCalldata,
-        address receiver
+        bytes memory swapCalldata
     ) internal returns (uint256 rawTokenReceived) {
-        // forgefmt: disable-next-item
         ApprovedCall memory call = ApprovedCall({
-            token: tokenSpent,
-            amount: amountSpent,
-            approveTo: swapApprove,
-            callTo: swapExtRouter,
-            data: swapCalldata
+            token: tokenSpent, amount: amountSpent, approveTo: swapApprove, callTo: swapExtRouter, data: swapCalldata
         });
 
-        uint256 preBalance = _selfBalance(tokenReceived);
+        uint256 preBalance = _balanceOf(address(box), tokenReceived);
         box.approveAndCall(call, address(box));
-        rawTokenReceived = _selfBalance(tokenReceived) - preBalance;
-
-        _transferOut(tokenReceived, receiver, rawTokenReceived);
-    }
-
-    function _addressToBytes32(address addr) internal pure returns (bytes32) {
-        return bytes32(uint256(uint160(addr)));
+        rawTokenReceived = _balanceOf(address(box), tokenReceived) - preBalance;
     }
 }

package/contracts/interfaces/IPCrossChainSwapHub.sol

@@ -9,26 +9,29 @@ interface IPCrossChainSwapHub {
     error MessageExpired();
 
     struct WithdrawTokenMessage {
-        address owner;
-        uint32 boxId;
+        address proposer;
         uint256 expiry;
+        uint256 requestId;
         uint256 nonce;
         //
+        address owner;
+        uint32 boxId;
         address token;
         uint256 amountWithdraw;
         uint256 amountFee;
     }
 
     struct BridgeTokenMessage {
-        address owner;
-        uint32 boxId;
+        address proposer;
         uint256 expiry;
+        uint256 requestId;
         uint256 nonce;
         //
+        address owner;
+        uint32 boxId;
         address token;
         uint256 amountBridge;
         uint256 amountFee;
-        bool pullFromOwner;
         //
         address bridgeExtRouter;
         address bridgeApprove;
@@ -36,96 +39,64 @@ interface IPCrossChainSwapHub {
     }
 
     struct SwapTokenMessage {
-        address owner;
-        uint32 boxId;
+        address proposer;
         uint256 expiry;
+        uint256 requestId;
         uint256 nonce;
         //
-        address tokenSpent;
-        uint256 amountSpent;
-        uint256 amountFee;
-        address tokenReceived;
-        uint256 minReceived;
-        bool pullFromOwner;
-        bool sendToOwner;
-        //
-        address swapExtRouter;
-        address swapApprove;
-        bytes swapCalldata;
-    }
-
-    struct BuyCrossChainPtMessage {
         address owner;
         uint32 boxId;
-        uint256 expiry;
-        uint256 nonce;
-        //
         address tokenSpent;
         uint256 amountSpent;
-        uint256 amountFee;
-        address ptAdapter;
-        uint256 minPtReceived;
-        uint32 dstEid;
-        bytes32 receiver;
-        bool pullFromOwner;
+        address tokenReceived;
+        uint256 minReceived;
         //
         address swapExtRouter;
         address swapApprove;
         bytes swapCalldata;
     }
 
-    event WithdrawToken(address indexed owner, uint32 boxId, address token, uint256 amountWithdraw, uint256 amountFee);
+    event WithdrawToken(
+        uint256 requestId,
+        uint256 nonce,
+        address owner,
+        uint32 boxId,
+        address token,
+        uint256 amountWithdraw,
+        uint256 amountFee
+    );
 
     event BridgeToken(
-        address indexed owner,
+        uint256 requestId,
+        uint256 nonce,
+        address owner,
         uint32 boxId,
         address bridgeExtRouter,
         address token,
         uint256 amountBridge,
-        uint256 amountFee,
-        bool pullFromOwner
+        uint256 amountFee
     );
 
     event SwapToken(
-        address indexed owner,
+        uint256 requestId,
+        uint256 nonce,
+        address owner,
         uint32 boxId,
         address tokenSpent,
         uint256 amountSpent,
-        uint256 amountFee,
         address tokenReceived,
-        uint256 netTokenReceived,
-        bool pullFromOwner,
-        bool sendToOwner
-    );
-
-    event BuyCrossChainPt(
-        address indexed owner,
-        uint32 boxId,
-        address tokenSpent,
-        uint256 amountSpent,
-        uint256 amountFee,
-        address ptAdapter,
-        address pt,
-        uint256 netPtReceived,
-        bool pullFromOwner
+        uint256 netTokenReceived
     );
 
     event SetExecutor(address indexed executor, bool isExecutor);
 
-    function BEACON_PROXY_CODE_CONTRACT() external view returns (address);
-
-    function DEPOSIT_BOX_BEACON() external view returns (address);
-
-    function DEPOSIT_BOX_CODE_HASH() external view returns (bytes32);
-
-    function ownerNonce(address owner) external view returns (uint256);
+    event SetProposer(address indexed proposer, bool isProposer);
 
     function isExecutor(address executor) external view returns (bool);
 
-    function computeDepositBox(address owner, uint32 boxId)
-        external
-        view
-        returns (address box, bytes32 salt, bool deployed);
+    function isProposer(address proposer) external view returns (bool);
+
+    function requestNonce(uint256 requestId) external view returns (uint256);
 
     function hashTypedData(WithdrawTokenMessage memory message) external view returns (bytes32);
 
@@ -133,15 +104,13 @@ interface IPCrossChainSwapHub {
 
     function hashTypedData(SwapTokenMessage memory message) external view returns (bytes32);
 
-    function hashTypedData(BuyCrossChainPtMessage memory message) external view returns (bytes32);
-
     function withdrawToken(WithdrawTokenMessage memory message, bytes memory signature) external;
 
     function bridgeToken(BridgeTokenMessage memory message, bytes memory signature) external payable;
 
     function swapToken(SwapTokenMessage memory message, bytes memory signature) external;
 
-    function buyCrossChainPt(BuyCrossChainPtMessage memory message, bytes memory signature) external payable;
-
     function setExecutor(address executor, bool isExecutor) external;
+
+    function setProposer(address proposer, bool isProposer) external;
 }

package/contracts/interfaces/IPDepositBoxFactory.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPDepositBox} from "./IPDepositBox.sol";
+
+interface IPDepositBoxFactory {
+    function computeDepositBox(address owner, uint32 boxId)
+        external
+        view
+        returns (address box, bytes32 salt, bool deployed);
+
+    function deployDepositBox(address owner, uint32 boxId) external returns (IPDepositBox box);
+
+    function BEACON_PROXY_CODE_CONTRACT() external view returns (address);
+
+    function DEPOSIT_BOX_BEACON() external view returns (address);
+
+    function DEPOSIT_BOX_CODE_HASH() external view returns (bytes32);
+}

package/deployments/130-core.json

@@ -2,7 +2,8 @@
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
     "network": {
         "chainId": 130,
-        "wrappedNative": "0x4200000000000000000000000000000000000006"
+        "wrappedNative": "0x4200000000000000000000000000000000000006",
+        "governance": "0x7877AdFaDEd756f3248a0EBfe8Ac2E2eF87b75Ac"
     },
     "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
     "routerFacets": {

package/deployments/9745-core.json

@@ -55,7 +55,8 @@
     "decimalsFactory": "0x992EC6A490A4B7f256bd59E63746951D98B29Be9",
     "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5",
     "cross-chain": {
-        "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870"
+        "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870",
+        "ptOftAdapterFactory": "0x41FAD93F225b5C1C95f2445A5d7fcB85bA46713f"
     },
     "merkleDistributor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4"
-}
+}

package/package.json

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