@pendle/core-v2 6.4.4-swaphubtest → 6.5.0-swaphubtest

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

@@ -1,274 +1,184 @@
 // 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("
+    bytes32 internal constant BOX_PERMIT_TYPEHASH = keccak256(
+        "BoxPermit("
             "address owner,"
             "uint32 boxId,"
             "uint256 expiry,"
-            "uint256 nonce,"
-            //
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant WITHDRAW_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "WithdrawTokenMessage("
+            "BoxPermit permit,"
             "address token,"
             "uint256 amountWithdraw,"
             "uint256 amountFee"
         ")"
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
     );
 
     // forgefmt: disable-next-item
     bytes32 internal constant BRIDGE_TOKEN_MESSAGE_TYPEHASH = keccak256(
         "BridgeTokenMessage("
-            "address owner,"
-            "uint32 boxId,"
-            "uint256 expiry,"
-            "uint256 nonce,"
-            //
+            "BoxPermit permit,"
             "address token,"
             "uint256 amountBridge,"
             "uint256 amountFee,"
-            "bool pullFromOwner,"
             //
             "address bridgeExtRouter,"
             "address bridgeApprove,"
             "bytes bridgeCalldata"
         ")"
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
     );
 
     // forgefmt: disable-next-item
     bytes32 internal constant SWAP_TOKEN_MESSAGE_TYPEHASH = keccak256(
         "SwapTokenMessage("
-            "address owner,"
-            "uint32 boxId,"
-            "uint256 expiry,"
-            "uint256 nonce,"
-            //
+            "BoxPermit permit,"
             "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("
+        "BoxPermit("
             "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 swapExtRouter,"
-            "address swapApprove,"
-            "bytes swapCalldata"
+            "uint256 requestId,"
+            "uint256 nonce"
         ")"
     );
 
     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;
+    address public executor;
+    address public proposer;
+    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() {
-        require(isExecutor[msg.sender], "SwapHub: caller is not executor");
+        require(msg.sender == executor, Unauthorized());
         _;
     }
 
-    function setExecutor(address executor, bool isExecutor_) external onlyOwner {
-        isExecutor[executor] = isExecutor_;
-        emit SetExecutor(executor, isExecutor_);
+    function setExecutor(address executor_) external onlyOwner {
+        executor = executor_;
+        emit SetExecutor(executor);
     }
 
-    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 setProposer(address proposer_) external onlyOwner {
+        proposer = proposer_;
+        emit SetProposer(proposer);
     }
 
-    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 hashBoxPermit(BoxPermit memory permit) public pure returns (bytes32) {
+        return keccak256(
+            abi.encode(BOX_PERMIT_TYPEHASH, permit.owner, permit.boxId, permit.expiry, permit.requestId, permit.nonce)
+        );
     }
 
-    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,
-                    //
-                    message.token,
-                    message.amountWithdraw,
-                    message.amountFee
+                    WITHDRAW_TOKEN_MESSAGE_TYPEHASH, hashBoxPermit(ms.permit), 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,
+                    hashBoxPermit(ms.permit),
+                    ms.token,
+                    ms.amountBridge,
+                    ms.amountFee,
                     //
-                    message.token,
-                    message.amountBridge,
-                    message.amountFee,
-                    message.pullFromOwner,
-                    //
-                    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,
-                    //
-                    message.tokenSpent,
-                    message.amountSpent,
-                    message.amountFee,
-                    message.tokenReceived,
-                    message.minReceived,
-                    message.pullFromOwner,
-                    message.sendToOwner,
+                    hashBoxPermit(ms.permit),
+                    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 _verifyProposerSig(
+        uint256 expiry,
+        uint256 requestId,
+        uint256 nonce,
+        bytes32 messageHash,
+        bytes memory signature
+    ) internal {
+        require(expiry > block.timestamp, MessageExpired());
+        require(SignatureChecker.isValidSignatureNow(proposer, messageHash, signature), InvalidSignature());
+        require(requestNonce[requestId] + 1 == nonce, InvalidNonce());
+        requestNonce[requestId] = nonce;
     }
 
-    function _verifyOwnerSig(address owner, uint256 expiry, uint256 nonce, bytes32 messageHash, bytes memory signature)
+    function _checkBoxPermit(BoxPermit memory permit, bytes32 messageHash, bytes memory signature)
         internal
+        returns (IPDepositBox)
     {
-        require(SignatureChecker.isValidSignatureNow(owner, messageHash, signature), InvalidSignature());
-        require(expiry > block.timestamp, MessageExpired());
-        require(ownerNonce[owner] < nonce, InvalidNonce());
-        ownerNonce[owner] = nonce;
-    }
-
-    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
-        });
-
-        uint256 preBalance = _selfBalance(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)));
+        _verifyProposerSig(permit.expiry, permit.requestId, permit.nonce, messageHash, signature);
+        return DEPOSIT_BOX_FACTORY.deployDepositBox(permit.owner, permit.boxId);
     }
 }

package/contracts/interfaces/IPCrossChainSwapHub.sol

@@ -5,30 +5,29 @@ interface IPCrossChainSwapHub {
     error InsufficientTokenReceived();
     error InvalidNonce();
     error InvalidSignature();
-    error InvalidReceiver();
     error MessageExpired();
+    error Unauthorized();
 
-    struct WithdrawTokenMessage {
+    struct BoxPermit {
         address owner;
         uint32 boxId;
         uint256 expiry;
+        uint256 requestId;
         uint256 nonce;
-        //
+    }
+
+    struct WithdrawTokenMessage {
+        BoxPermit permit;
         address token;
         uint256 amountWithdraw;
         uint256 amountFee;
     }
 
     struct BridgeTokenMessage {
-        address owner;
-        uint32 boxId;
-        uint256 expiry;
-        uint256 nonce;
-        //
+        BoxPermit permit;
         address token;
         uint256 amountBridge;
         uint256 amountFee;
-        bool pullFromOwner;
         //
         address bridgeExtRouter;
         address bridgeApprove;
@@ -36,96 +35,64 @@ interface IPCrossChainSwapHub {
     }
 
     struct SwapTokenMessage {
-        address owner;
-        uint32 boxId;
-        uint256 expiry;
-        uint256 nonce;
-        //
+        BoxPermit permit;
         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 swapExtRouter;
         address swapApprove;
         bytes swapCalldata;
     }
 
-    event WithdrawToken(address indexed owner, uint32 boxId, address token, uint256 amountWithdraw, uint256 amountFee);
+    event WithdrawToken(
+        address owner,
+        uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
+        address token,
+        uint256 amountWithdraw,
+        uint256 amountFee
+    );
 
     event BridgeToken(
-        address indexed owner,
+        address owner,
         uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
         address bridgeExtRouter,
         address token,
         uint256 amountBridge,
-        uint256 amountFee,
-        bool pullFromOwner
+        uint256 amountFee
     );
 
     event SwapToken(
-        address indexed owner,
+        address owner,
         uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
         address tokenSpent,
         uint256 amountSpent,
-        uint256 amountFee,
         address tokenReceived,
-        uint256 netTokenReceived,
-        bool pullFromOwner,
-        bool sendToOwner
+        uint256 netTokenReceived
     );
 
-    event BuyCrossChainPt(
-        address indexed owner,
-        uint32 boxId,
-        address tokenSpent,
-        uint256 amountSpent,
-        uint256 amountFee,
-        address ptAdapter,
-        address pt,
-        uint256 netPtReceived,
-        bool pullFromOwner
-    );
+    event SetExecutor(address executor);
 
-    event SetExecutor(address indexed executor, bool isExecutor);
+    event SetProposer(address proposer);
 
-    function BEACON_PROXY_CODE_CONTRACT() external view returns (address);
+    function executor() external view returns (address);
 
-    function DEPOSIT_BOX_BEACON() external view returns (address);
+    function proposer() external view returns (address);
 
-    function DEPOSIT_BOX_CODE_HASH() external view returns (bytes32);
+    function setExecutor(address executor) external;
 
-    function ownerNonce(address owner) external view returns (uint256);
+    function setProposer(address proposer) external;
 
-    function isExecutor(address executor) external view returns (bool);
+    function requestNonce(uint256 requestId) external view returns (uint256);
 
-    function computeDepositBox(address owner, uint32 boxId)
-        external
-        view
-        returns (address box, bytes32 salt, bool deployed);
+    function hashBoxPermit(BoxPermit memory permit) external view returns (bytes32);
 
     function hashTypedData(WithdrawTokenMessage memory message) external view returns (bytes32);
 
@@ -133,15 +100,9 @@ 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;
 }

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/contracts/interfaces/IPGauge.sol

@@ -3,10 +3,4 @@ pragma solidity ^0.8.0;
 
 interface IPGauge {
     event RedeemRewards(address indexed user, uint256[] rewardsOut);
-
-    event UpdateActiveBalance(address indexed user, uint256 newActiveBalance);
-
-    function totalActiveSupply() external view returns (uint256);
-
-    function activeBalance(address user) external view returns (uint256);
 }

package/contracts/interfaces/IPGaugeController.sol

@@ -4,17 +4,34 @@ pragma solidity ^0.8.0;
 interface IPGaugeController {
     event MarketClaimReward(address indexed market, uint256 amount);
 
+    // deprecated from MarketV7 onwards
     event ReceiveVotingResults(uint128 indexed wTime, address[] markets, uint256[] pendleAmounts);
 
+    // deprecated from MarketV7 onwards
     event UpdateMarketReward(address indexed market, uint256 pendlePerSec, uint256 incentiveEndsAt);
 
-    function fundPendle(uint256 amount) external;
+    event UpdateMarketRewardV2(address indexed market, uint128 pendlePerSec, uint128 incentiveEndsAt);
+
+    event WhitelistMarketSet(address indexed market, bool isWhitelisted);
+
+    function setRewardDatas(
+        address[] calldata markets,
+        uint128[] calldata pendlePerSecs,
+        uint128[] calldata incentiveEndsAts
+    ) external;
 
     function withdrawPendle(uint256 amount) external;
 
-    function pendle() external returns (address);
+    function pendle() external view returns (address);
 
     function redeemMarketReward() external;
 
-    function rewardData(address pool) external view returns (uint128 pendlePerSec, uint128, uint128, uint128);
+    function rewardData(address market)
+        external
+        view
+        returns (uint128 pendlePerSec, uint128 accumulatedPendle, uint128 lastUpdated, uint128 incentiveEndsAt);
+
+    function isWhitelisted(address market) external view returns (bool);
+
+    function whitelistMarkets(address[] memory markets, bool _isWhitelisted) external;
 }

package/contracts/interfaces/IPMarket.sol

@@ -86,4 +86,16 @@ interface IPMarket is IPGauge, IERC20Metadata {
     function VERSION() external pure returns (uint256);
 
     function reentrancyGuardEntered() external view returns (bool);
+
+    /*///////////////////////////////////////////////////////////////
+                            LEGACY FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Kept for backward compatibility
+    /// @dev From version 7, this function returns `totalSupply()`.
+    function totalActiveSupply() external view returns (uint256);
+
+    /// @dev Kept for backward compatibility
+    /// @dev From version 7, this function returns `balanceOf(user)`.
+    function activeBalance(address user) external view returns (uint256);
 }