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

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

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+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 {IPDepositBoxFactory} from "../../interfaces/IPDepositBoxFactory.sol";
+
+abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringOwnableUpgradeableV2, TokenHelper {
+    // forgefmt: disable-next-item
+    bytes32 internal constant BOX_PERMIT_TYPEHASH = keccak256(
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "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("
+            "BoxPermit permit,"
+            "address token,"
+            "uint256 amountBridge,"
+            "uint256 amountFee,"
+            //
+            "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("
+            "BoxPermit permit,"
+            "address tokenSpent,"
+            "uint256 amountSpent,"
+            "address tokenReceived,"
+            "uint256 minReceived,"
+            //
+            "address swapExtRouter,"
+            "address swapApprove,"
+            "bytes swapCalldata"
+        ")"
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
+    );
+
+    address public immutable TREASURY;
+    IPDepositBoxFactory public immutable DEPOSIT_BOX_FACTORY;
+
+    address public executor;
+    address public proposer;
+    mapping(uint256 requestId => uint256 nonce) public requestNonce;
+
+    constructor(address treasury_, address depositBoxFactory_) {
+        TREASURY = treasury_;
+        DEPOSIT_BOX_FACTORY = IPDepositBoxFactory(depositBoxFactory_);
+    }
+
+    modifier onlyExecutor() {
+        require(msg.sender == executor, Unauthorized());
+        _;
+    }
+
+    function setExecutor(address executor_) external onlyOwner {
+        executor = executor_;
+        emit SetExecutor(executor);
+    }
+
+    function setProposer(address proposer_) external onlyOwner {
+        proposer = proposer_;
+        emit SetProposer(proposer);
+    }
+
+    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 ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    WITHDRAW_TOKEN_MESSAGE_TYPEHASH, hashBoxPermit(ms.permit), ms.token, ms.amountWithdraw, ms.amountFee
+                )
+            )
+        );
+    }
+
+    function hashTypedData(BridgeTokenMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    BRIDGE_TOKEN_MESSAGE_TYPEHASH,
+                    hashBoxPermit(ms.permit),
+                    ms.token,
+                    ms.amountBridge,
+                    ms.amountFee,
+                    //
+                    ms.bridgeExtRouter,
+                    ms.bridgeApprove,
+                    keccak256(ms.bridgeCalldata)
+                )
+            )
+        );
+    }
+
+    function hashTypedData(SwapTokenMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    SWAP_TOKEN_MESSAGE_TYPEHASH,
+                    hashBoxPermit(ms.permit),
+                    ms.tokenSpent,
+                    ms.amountSpent,
+                    ms.tokenReceived,
+                    ms.minReceived,
+                    //
+                    ms.swapExtRouter,
+                    ms.swapApprove,
+                    keccak256(ms.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 _checkBoxPermit(BoxPermit memory permit, bytes32 messageHash, bytes memory signature)
+        internal
+        returns (IPDepositBox)
+    {
+        _verifyProposerSig(permit.expiry, permit.requestId, permit.nonce, messageHash, signature);
+        return DEPOSIT_BOX_FACTORY.deployDepositBox(permit.owner, permit.boxId);
+    }
+}

package/contracts/interfaces/IPCrossChainSwapHub.sol

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPCrossChainSwapHub {
+    error InsufficientTokenReceived();
+    error InvalidNonce();
+    error InvalidSignature();
+    error MessageExpired();
+    error Unauthorized();
+
+    struct BoxPermit {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 requestId;
+        uint256 nonce;
+    }
+
+    struct WithdrawTokenMessage {
+        BoxPermit permit;
+        address token;
+        uint256 amountWithdraw;
+        uint256 amountFee;
+    }
+
+    struct BridgeTokenMessage {
+        BoxPermit permit;
+        address token;
+        uint256 amountBridge;
+        uint256 amountFee;
+        //
+        address bridgeExtRouter;
+        address bridgeApprove;
+        bytes bridgeCalldata;
+    }
+
+    struct SwapTokenMessage {
+        BoxPermit permit;
+        address tokenSpent;
+        uint256 amountSpent;
+        address tokenReceived;
+        uint256 minReceived;
+        //
+        address swapExtRouter;
+        address swapApprove;
+        bytes swapCalldata;
+    }
+
+    event WithdrawToken(
+        address owner,
+        uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
+        address token,
+        uint256 amountWithdraw,
+        uint256 amountFee
+    );
+
+    event BridgeToken(
+        address owner,
+        uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
+        address bridgeExtRouter,
+        address token,
+        uint256 amountBridge,
+        uint256 amountFee
+    );
+
+    event SwapToken(
+        address owner,
+        uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
+        address tokenSpent,
+        uint256 amountSpent,
+        address tokenReceived,
+        uint256 netTokenReceived
+    );
+
+    event SetExecutor(address executor);
+
+    event SetProposer(address proposer);
+
+    function executor() external view returns (address);
+
+    function proposer() external view returns (address);
+
+    function setExecutor(address executor) external;
+
+    function setProposer(address proposer) external;
+
+    function requestNonce(uint256 requestId) external view returns (uint256);
+
+    function hashBoxPermit(BoxPermit memory permit) external view returns (bytes32);
+
+    function hashTypedData(WithdrawTokenMessage memory message) external view returns (bytes32);
+
+    function hashTypedData(BridgeTokenMessage memory message) external view returns (bytes32);
+
+    function hashTypedData(SwapTokenMessage 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;
+}

package/contracts/interfaces/IPDepositBox.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+struct ApprovedCall {
+    address token;
+    uint256 amount;
+    address approveTo;
+    address callTo;
+    bytes data;
+}
+
+interface IPDepositBox {
+    function MANAGER() external view returns (address);
+
+    function OWNER() external view returns (address);
+
+    function BOX_ID() external view returns (uint32);
+
+    function withdrawTo(address to, address token, uint256 amount) external;
+
+    function approveAndCall(ApprovedCall memory call, address nativeRefund) external payable returns (bytes memory);
+}

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

package/contracts/interfaces/IPStakedPendle.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+interface IPStakedPendle {
+    struct Call3 {
+        bool allowFailure;
+        bytes callData;
+    }
+
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    struct UserCooldown {
+        uint104 cooldownStart;
+        uint152 amount;
+    }
+
+    event CooldownDurationAndFeeUpdated(uint24 newDuration, uint64 instantUnstakeFeeRate);
+
+    event Staked(address indexed user, uint256 amount);
+
+    event Unstaked(address indexed user, uint256 amountAfterFee, uint256 fee);
+
+    event CooldownCanceled(address indexed user, uint256 amount);
+
+    event CooldownInitiated(address indexed user, uint256 amount, uint256 cooldownStart);
+
+    event FeeReceiverUpdated(address indexed feeReceiver);
+
+    // ======== Getters ========
+
+    function PENDLE() external view returns (address);
+
+    function cooldownDuration() external view returns (uint24);
+
+    function instantUnstakeFeeRate() external view returns (uint64);
+
+    function feeReceiver() external view returns (address);
+
+    // ======== Staking functions ========
+
+    function userCooldown(address user) external view returns (uint104 cooldownStart, uint152 amount);
+
+    function stake(uint256 amount) external;
+
+    function cooldown(uint256 amount) external;
+
+    function cancelCooldown() external;
+
+    // fee-free, after cooldown
+    function finalizeCooldown() external returns (uint256 amount);
+
+    // instant, but with fee
+    function instantUnstake(uint256 amount) external returns (uint256 amountAfterFee, uint256 fee);
+
+    // ======== Misc helper functions =======
+
+    function multicall(Call3[] calldata calls) external returns (Result[] memory res);
+
+    // ======== Admin functions ========
+
+    function setCooldownDurationAndFee(uint24 newDuration, uint64 newInstantUnstakeFeeRate) external;
+
+    function setFeeReceiver(address newFeeReceiver) external;
+}

package/contracts/offchain-helpers/BalanceReader.sol

@@ -6,6 +6,10 @@ import "../interfaces/IPMarket.sol";
 import "../interfaces/IStandardizedYield.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
+interface ILegacyMarket {
+    function activeBalance(address user) external view returns (uint256);
+}
+
 contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
     struct UserMarketInfo {
         uint256 lpBalance;
@@ -44,7 +48,13 @@ contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
             (, IPPrincipalToken PT, IPYieldToken YT) = market.readTokens();
 
             info.lpBalance = market.balanceOf(user);
-            info.lpActiveBalance = market.activeBalance(user);
+
+            try ILegacyMarket(address(market)).activeBalance(user) returns (uint256 activeBalance) {
+                info.lpActiveBalance = activeBalance;
+            } catch {
+                info.lpActiveBalance = 0;
+            }
+
             info.lpRewardsOut = _redeemRewards(market, user);
 
             info.ytBalance = YT.balanceOf(user);