@pendle/core-v2 6.4.1 → 6.4.2-swaphubtest2

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

@@ -0,0 +1,197 @@
+// 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 WITHDRAW_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "WithdrawTokenMessage("
+            "address proposer,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce,"
+            //
+            "address owner,"
+            "uint32 boxId,"
+            "address token,"
+            "uint256 amountWithdraw,"
+            "uint256 amountFee"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant BRIDGE_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "BridgeTokenMessage("
+            "address proposer,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce,"
+            //
+            "address owner,"
+            "uint32 boxId,"
+            "address token,"
+            "uint256 amountBridge,"
+            "uint256 amountFee,"
+            //
+            "address bridgeExtRouter,"
+            "address bridgeApprove,"
+            "bytes bridgeCalldata"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant SWAP_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "SwapTokenMessage("
+            "address proposer,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce,"
+            //
+            "address owner,"
+            "uint32 boxId,"
+            "address tokenSpent,"
+            "uint256 amountSpent,"
+            "address tokenReceived,"
+            "uint256 minReceived,"
+            //
+            "address swapExtRouter,"
+            "address swapApprove,"
+            "bytes swapCalldata"
+        ")"
+    );
+
+    address public immutable TREASURY;
+    IPDepositBoxFactory public immutable DEPOSIT_BOX_FACTORY;
+
+    mapping(address executor => bool) public isExecutor;
+    mapping(address proposer => bool) public isProposer;
+    mapping(uint256 requestId => uint256 nonce) public requestNonce;
+
+    constructor(address treasury_, address depositBoxFactory_) {
+        TREASURY = treasury_;
+        DEPOSIT_BOX_FACTORY = IPDepositBoxFactory(depositBoxFactory_);
+    }
+
+    modifier onlyExecutor() {
+        require(isExecutor[msg.sender], "SwapHub: caller is not executor");
+        _;
+    }
+
+    function setExecutor(address executor, bool isExecutor_) external onlyOwner {
+        isExecutor[executor] = isExecutor_;
+        emit SetExecutor(executor, isExecutor_);
+    }
+
+    function setProposer(address proposer, bool isProposer_) external onlyOwner {
+        isProposer[proposer] = isProposer_;
+        emit SetProposer(proposer, isProposer_);
+    }
+
+    function hashTypedData(WithdrawTokenMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    WITHDRAW_TOKEN_MESSAGE_TYPEHASH,
+                    ms.proposer,
+                    ms.expiry,
+                    ms.requestId,
+                    ms.nonce,
+                    //
+                    ms.owner,
+                    ms.boxId,
+                    ms.token,
+                    ms.amountWithdraw,
+                    ms.amountFee
+                )
+            )
+        );
+    }
+
+    function hashTypedData(BridgeTokenMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    BRIDGE_TOKEN_MESSAGE_TYPEHASH,
+                    ms.proposer,
+                    ms.expiry,
+                    ms.requestId,
+                    ms.nonce,
+                    //
+                    ms.owner,
+                    ms.boxId,
+                    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,
+                    ms.proposer,
+                    ms.expiry,
+                    ms.requestId,
+                    ms.nonce,
+                    //
+                    ms.owner,
+                    ms.boxId,
+                    ms.tokenSpent,
+                    ms.amountSpent,
+                    ms.tokenReceived,
+                    ms.minReceived,
+                    //
+                    ms.swapExtRouter,
+                    ms.swapApprove,
+                    keccak256(ms.swapCalldata)
+                )
+            )
+        );
+    }
+
+    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(requestNonce[requestId] + 1 == nonce, InvalidNonce());
+        requestNonce[requestId] = nonce;
+    }
+
+    function _swapFromBox(
+        IPDepositBox box,
+        address tokenSpent,
+        uint256 amountSpent,
+        address tokenReceived,
+        address swapExtRouter,
+        address swapApprove,
+        bytes memory swapCalldata
+    ) internal returns (uint256 rawTokenReceived) {
+        ApprovedCall memory call = ApprovedCall({
+            token: tokenSpent, amount: amountSpent, approveTo: swapApprove, callTo: swapExtRouter, data: swapCalldata
+        });
+
+        uint256 preBalance = _balanceOf(address(box), tokenReceived);
+        box.approveAndCall(call, address(box));
+        rawTokenReceived = _balanceOf(address(box), tokenReceived) - preBalance;
+    }
+}

package/contracts/interfaces/IPCrossChainSwapHub.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPCrossChainSwapHub {
+    error InsufficientTokenReceived();
+    error InvalidNonce();
+    error InvalidSignature();
+    error InvalidReceiver();
+    error MessageExpired();
+
+    struct WithdrawTokenMessage {
+        address proposer;
+        uint256 expiry;
+        uint256 requestId;
+        uint256 nonce;
+        //
+        address owner;
+        uint32 boxId;
+        address token;
+        uint256 amountWithdraw;
+        uint256 amountFee;
+    }
+
+    struct BridgeTokenMessage {
+        address proposer;
+        uint256 expiry;
+        uint256 requestId;
+        uint256 nonce;
+        //
+        address owner;
+        uint32 boxId;
+        address token;
+        uint256 amountBridge;
+        uint256 amountFee;
+        //
+        address bridgeExtRouter;
+        address bridgeApprove;
+        bytes bridgeCalldata;
+    }
+
+    struct SwapTokenMessage {
+        address proposer;
+        uint256 expiry;
+        uint256 requestId;
+        uint256 nonce;
+        //
+        address owner;
+        uint32 boxId;
+        address tokenSpent;
+        uint256 amountSpent;
+        address tokenReceived;
+        uint256 minReceived;
+        //
+        address swapExtRouter;
+        address swapApprove;
+        bytes swapCalldata;
+    }
+
+    event WithdrawToken(
+        uint256 requestId,
+        uint256 nonce,
+        address owner,
+        uint32 boxId,
+        address token,
+        uint256 amountWithdraw,
+        uint256 amountFee
+    );
+
+    event BridgeToken(
+        uint256 requestId,
+        uint256 nonce,
+        address owner,
+        uint32 boxId,
+        address bridgeExtRouter,
+        address token,
+        uint256 amountBridge,
+        uint256 amountFee
+    );
+
+    event SwapToken(
+        uint256 requestId,
+        uint256 nonce,
+        address owner,
+        uint32 boxId,
+        address tokenSpent,
+        uint256 amountSpent,
+        address tokenReceived,
+        uint256 netTokenReceived
+    );
+
+    event SetExecutor(address indexed executor, bool isExecutor);
+
+    event SetProposer(address indexed proposer, bool isProposer);
+
+    function isExecutor(address executor) external view returns (bool);
+
+    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);
+
+    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;
+
+    function setExecutor(address executor, bool isExecutor) external;
+
+    function setProposer(address proposer, bool isProposer) 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/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/deployments/999-core.json

@@ -2,9 +2,9 @@
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
     "network": {
         "chainId": 999,
-        "treasury": "0x17A191644E750AA24a5ec13A253b9446f4eF178b",
-        "governance": "0x34Ac848b6eC31BE87f99ddf7ED15Fa5662E7430a",
-        "devMultisig": "0x2e7542c7BB887269474995fa8b9cB7F7e6fAC895",
+        "treasury": "0xCbcb48e22622a3778b6F14C2f5d258Ba026b05e6",
+        "governance": "0x7877AdFaDEd756f3248a0EBfe8Ac2E2eF87b75Ac",
+        "devMultisig": "0xE6F0489ED91dc27f40f9dbe8f81fccbFC16b9cb1",
         "pendle": "0xD6Eb81136884713E843936843E286FD2a85A205A",
         "lzEndpoint": "0x2D61DCDD36F10b22176E0433B86F74567d529aAa",
         "wrappedNative": "0x5555555555555555555555555555555555555555",
@@ -49,7 +49,7 @@
     "vePendle": "0x1fBaCedf510dAA79dfD9B41227A7ba192d5D548D",
     "receiverEndpoint": "0xaD511b12F73c145Cf158EB92E4fa256937d952A4",
     "gaugeController": "0x7e500c6efbb00fd3227888256e477171a1304721",
-    "vePendleAirdropDistributor": "0x42c706eab26aA8FAcFa4B3f32902bA872AaA10aC",
+    "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
     "externalRewardsDistributor": "0x1Cb446fAE25Ae19878f9f71189902e2a6A6A749c",
     "lpWrapperFactory": "0xcb645C93820B92E5F21781C5c3c18C29BCb6126B",
     "decimalsFactory": "0xF2a26C2eb3c4098e03807442196FbA7f78b125a2",
@@ -59,4 +59,4 @@
         "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870"
     },
     "merkleDepositor": "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.1",
+  "version": "6.4.2-swaphubtest2",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -55,4 +55,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/typechain-types/DepositBox.ts

@@ -0,0 +1,260 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export type ApprovedCallStruct = {
+  token: string;
+  amount: BigNumberish;
+  approveTo: string;
+  callTo: string;
+  data: BytesLike;
+};
+
+export type ApprovedCallStructOutput = [
+  string,
+  BigNumber,
+  string,
+  string,
+  string
+] & {
+  token: string;
+  amount: BigNumber;
+  approveTo: string;
+  callTo: string;
+  data: string;
+};
+
+export interface DepositBoxInterface extends utils.Interface {
+  contractName: "DepositBox";
+  functions: {
+    "BOX_ID()": FunctionFragment;
+    "MANAGER()": FunctionFragment;
+    "OWNER()": FunctionFragment;
+    "approveAndCall((address,uint256,address,address,bytes),address)": FunctionFragment;
+    "initialize(address,uint32)": FunctionFragment;
+    "withdrawTo(address,address,uint256)": FunctionFragment;
+  };
+
+  encodeFunctionData(functionFragment: "BOX_ID", values?: undefined): string;
+  encodeFunctionData(functionFragment: "MANAGER", values?: undefined): string;
+  encodeFunctionData(functionFragment: "OWNER", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "approveAndCall",
+    values: [ApprovedCallStruct, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "initialize",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "withdrawTo",
+    values: [string, string, BigNumberish]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "BOX_ID", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "MANAGER", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "OWNER", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "approveAndCall",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "withdrawTo", data: BytesLike): Result;
+
+  events: {
+    "Initialized(uint8)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+
+export type InitializedEvent = TypedEvent<[number], { version: number }>;
+
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+
+export interface DepositBox extends BaseContract {
+  contractName: "DepositBox";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: DepositBoxInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    BOX_ID(overrides?: CallOverrides): Promise<[number]>;
+
+    MANAGER(overrides?: CallOverrides): Promise<[string]>;
+
+    OWNER(overrides?: CallOverrides): Promise<[string]>;
+
+    approveAndCall(
+      call: ApprovedCallStruct,
+      nativeRefund: string,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    initialize(
+      owner_: string,
+      boxId_: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    withdrawTo(
+      to: string,
+      token: string,
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  BOX_ID(overrides?: CallOverrides): Promise<number>;
+
+  MANAGER(overrides?: CallOverrides): Promise<string>;
+
+  OWNER(overrides?: CallOverrides): Promise<string>;
+
+  approveAndCall(
+    call: ApprovedCallStruct,
+    nativeRefund: string,
+    overrides?: PayableOverrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  initialize(
+    owner_: string,
+    boxId_: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  withdrawTo(
+    to: string,
+    token: string,
+    amount: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    BOX_ID(overrides?: CallOverrides): Promise<number>;
+
+    MANAGER(overrides?: CallOverrides): Promise<string>;
+
+    OWNER(overrides?: CallOverrides): Promise<string>;
+
+    approveAndCall(
+      call: ApprovedCallStruct,
+      nativeRefund: string,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    initialize(
+      owner_: string,
+      boxId_: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    withdrawTo(
+      to: string,
+      token: string,
+      amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "Initialized(uint8)"(version?: null): InitializedEventFilter;
+    Initialized(version?: null): InitializedEventFilter;
+  };
+
+  estimateGas: {
+    BOX_ID(overrides?: CallOverrides): Promise<BigNumber>;
+
+    MANAGER(overrides?: CallOverrides): Promise<BigNumber>;
+
+    OWNER(overrides?: CallOverrides): Promise<BigNumber>;
+
+    approveAndCall(
+      call: ApprovedCallStruct,
+      nativeRefund: string,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    initialize(
+      owner_: string,
+      boxId_: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    withdrawTo(
+      to: string,
+      token: string,
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    BOX_ID(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    MANAGER(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    OWNER(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    approveAndCall(
+      call: ApprovedCallStruct,
+      nativeRefund: string,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    initialize(
+      owner_: string,
+      boxId_: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    withdrawTo(
+      to: string,
+      token: string,
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}