@pendle/core-v2 6.4.2-swaphubtest → 6.4.2

package/build/artifacts/contracts/interfaces/IPDepositBox.sol/IPDepositBox.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/565a194b7261b538bfc5e04de28a6db1.json"
-}

package/build/artifacts/contracts/interfaces/IPDepositBox.sol/IPDepositBox.json

@@ -1,124 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "IPDepositBox",
-  "sourceName": "contracts/interfaces/IPDepositBox.sol",
-  "abi": [
-    {
-      "inputs": [],
-      "name": "BOX_ID",
-      "outputs": [
-        {
-          "internalType": "uint32",
-          "name": "",
-          "type": "uint32"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "MANAGER",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "OWNER",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "address",
-              "name": "token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "amount",
-              "type": "uint256"
-            },
-            {
-              "internalType": "address",
-              "name": "approveTo",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "callTo",
-              "type": "address"
-            },
-            {
-              "internalType": "bytes",
-              "name": "data",
-              "type": "bytes"
-            }
-          ],
-          "internalType": "struct ApprovedCall",
-          "name": "call",
-          "type": "tuple"
-        },
-        {
-          "internalType": "address",
-          "name": "nativeRefund",
-          "type": "address"
-        }
-      ],
-      "name": "approveAndCall",
-      "outputs": [
-        {
-          "internalType": "bytes",
-          "name": "",
-          "type": "bytes"
-        }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "withdrawTo",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    }
-  ],
-  "bytecode": "0x",
-  "deployedBytecode": "0x",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}

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

@@ -1,66 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.30;
-
-import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import {Address} from "@openzeppelin/contracts/utils/Address.sol";
-import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
-import {ApprovedCall, IPDepositBox} from "../../interfaces/IPDepositBox.sol";
-
-contract DepositBox is IPDepositBox, TokenHelper, Initializable {
-    using Address for address;
-    using SafeERC20 for IERC20;
-
-    address public immutable MANAGER;
-    address public OWNER;
-    uint32 public BOX_ID;
-
-    constructor(address manager_) {
-        _disableInitializers();
-        MANAGER = manager_;
-    }
-
-    modifier onlyManager() {
-        require(msg.sender == MANAGER, "DepositBox: caller is not manager");
-        _;
-    }
-
-    function initialize(address owner_, uint32 boxId_) external initializer {
-        OWNER = owner_;
-        BOX_ID = boxId_;
-    }
-
-    function withdrawTo(address to, address token, uint256 amount) external onlyManager {
-        _transferOut(token, to, amount);
-    }
-
-    function approveAndCall(ApprovedCall memory call, address nativeRefund)
-        external
-        payable
-        onlyManager
-        returns (bytes memory result)
-    {
-        uint256 nativeAmount = call.token == NATIVE ? call.amount : 0;
-        uint256 nativeFee = msg.value;
-
-        uint256 initialNativeBalance = _selfBalance(NATIVE) - nativeAmount - nativeFee;
-
-        _approveForExtRouter(call.token, call.approveTo, call.amount);
-        result = call.callTo.functionCallWithValue(call.data, nativeAmount + nativeFee);
-        _approveForExtRouter(call.token, call.approveTo, 0);
-
-        uint256 finalNativeBalance = _selfBalance(NATIVE);
-
-        if (finalNativeBalance > initialNativeBalance) {
-            _transferOut(NATIVE, nativeRefund, finalNativeBalance - initialNativeBalance);
-        }
-    }
-
-    function _approveForExtRouter(address token, address extRouter, uint256 amount) internal {
-        if (token == NATIVE) return;
-        IERC20(token).forceApprove(extRouter, amount);
-    }
-
-    receive() external payable {}
-}

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

@@ -1,178 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.30;
-
-import {
-    IOFT,
-    MessagingFee,
-    MessagingReceipt,
-    OFTReceipt,
-    SendParam
-} from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {ApprovedCall, IPDepositBox} from "../../interfaces/IPDepositBox.sol";
-import {SwapHubBase} from "./SwapHubBase.sol";
-
-contract PendleCrossChainSwapHub is SwapHubBase {
-    constructor(address treasury_, address beaconProxyCodeContract_, address depositBoxBeacon_)
-        SwapHubBase(treasury_, beaconProxyCodeContract_, depositBoxBeacon_)
-    {
-        _disableInitializers();
-    }
-
-    function initialize(address _owner) external initializer {
-        __EIP712_init("Pendle Cross Chain Swap Hub", "1");
-        __BoringOwnableV2_init(_owner);
-    }
-
-    function withdrawToken(WithdrawTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
-
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        _payTreasury(box, ms.token, ms.amountFee);
-        _withdrawToken(ms, box);
-
-        emit WithdrawToken(ms.owner, ms.boxId, ms.token, ms.amountWithdraw, ms.amountFee);
-    }
-
-    function bridgeToken(BridgeTokenMessage memory ms, bytes memory sig) external payable onlyExecutor {
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
-
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        _pullToken(ms.pullFromOwner, box, ms.owner, ms.token, ms.amountBridge + ms.amountFee);
-        _payTreasury(box, ms.token, ms.amountFee);
-        _bridgeToken(ms, box, msg.value);
-
-        emit BridgeToken(
-            ms.owner, ms.boxId, ms.bridgeExtRouter, ms.token, ms.amountBridge, ms.amountFee, ms.pullFromOwner
-        );
-    }
-
-    function swapToken(SwapTokenMessage memory ms, bytes memory sig) external onlyExecutor {
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
-
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        _pullToken(ms.pullFromOwner, box, ms.owner, ms.tokenSpent, ms.amountSpent + ms.amountFee);
-        _payTreasury(box, ms.tokenSpent, ms.amountFee);
-
-        uint256 netTokenReceived = _swapToken(ms, box);
-        require(netTokenReceived >= ms.minReceived, InsufficientTokenReceived());
-
-        emit SwapToken(
-            ms.owner,
-            ms.boxId,
-            ms.tokenSpent,
-            ms.amountSpent,
-            ms.amountFee,
-            ms.tokenReceived,
-            netTokenReceived,
-            ms.pullFromOwner,
-            ms.sendToOwner
-        );
-    }
-
-    function buyCrossChainPt(BuyCrossChainPtMessage memory ms, bytes memory sig) external payable onlyExecutor {
-        _verifyOwnerSig(ms.owner, ms.expiry, ms.nonce, hashTypedData(ms), sig);
-
-        IPDepositBox box = _checkAndDeployBox(ms.owner, ms.boxId);
-        _pullToken(ms.pullFromOwner, box, ms.owner, ms.tokenSpent, ms.amountSpent + ms.amountFee);
-        _payTreasury(box, ms.tokenSpent, ms.amountFee);
-
-        address pt = IOFT(ms.ptAdapter).token();
-        uint256 netPtReceived = _buyPtAndBridge(ms, box, pt, msg.value, msg.sender);
-        require(netPtReceived >= ms.minPtReceived, InsufficientTokenReceived());
-
-        emit BuyCrossChainPt(
-            ms.owner,
-            ms.boxId,
-            ms.tokenSpent,
-            ms.amountSpent,
-            ms.amountFee,
-            ms.ptAdapter,
-            pt,
-            netPtReceived,
-            ms.pullFromOwner
-        );
-    }
-
-    function _pullToken(bool pullFromOwner, IPDepositBox box, address owner, address token, uint256 amount) internal {
-        if (pullFromOwner) {
-            _transferFrom(IERC20(token), owner, address(box), amount);
-        }
-    }
-
-    function _payTreasury(IPDepositBox box, address token, uint256 amount) internal {
-        box.withdrawTo(TREASURY, token, amount);
-    }
-
-    function _withdrawToken(WithdrawTokenMessage memory ms, IPDepositBox box) internal {
-        box.withdrawTo(ms.owner, ms.token, ms.amountWithdraw);
-    }
-
-    function _bridgeToken(BridgeTokenMessage memory ms, IPDepositBox box, uint256 nativeFee) internal {
-        ApprovedCall memory call = ApprovedCall({
-            token: ms.token,
-            amount: ms.amountBridge,
-            approveTo: ms.bridgeApprove,
-            callTo: ms.bridgeExtRouter,
-            data: ms.bridgeCalldata
-        });
-        box.approveAndCall{value: nativeFee}(call, msg.sender);
-    }
-
-    function _swapToken(SwapTokenMessage memory ms, IPDepositBox box) internal returns (uint256 rawTokenReceived) {
-        rawTokenReceived = _swapFromBox({
-            box: box,
-            tokenSpent: ms.tokenSpent,
-            amountSpent: ms.amountSpent,
-            tokenReceived: ms.tokenReceived,
-            swapExtRouter: ms.swapExtRouter,
-            swapApprove: ms.swapApprove,
-            swapCalldata: ms.swapCalldata,
-            receiver: ms.sendToOwner ? ms.owner : address(box)
-        });
-    }
-
-    function _buyPtAndBridge(
-        BuyCrossChainPtMessage memory ms,
-        IPDepositBox box,
-        address pt,
-        uint256 nativeFee,
-        address nativeRefund
-    ) internal returns (uint256 netPtReceived) {
-        require(ms.receiver == _addressToBytes32(ms.owner), InvalidReceiver());
-
-        uint256 rawPtReceived = _swapFromBox({
-            box: box,
-            tokenSpent: ms.tokenSpent,
-            amountSpent: ms.amountSpent,
-            tokenReceived: pt,
-            swapExtRouter: ms.swapExtRouter,
-            swapApprove: ms.swapApprove,
-            swapCalldata: ms.swapCalldata,
-            receiver: address(box)
-        });
-
-        SendParam memory sendParam = SendParam({
-            dstEid: ms.dstEid,
-            to: ms.receiver,
-            amountLD: rawPtReceived,
-            minAmountLD: 0,
-            extraOptions: "",
-            composeMsg: "",
-            oftCmd: ""
-        });
-        MessagingFee memory sendFee = MessagingFee({nativeFee: nativeFee, lzTokenFee: 0});
-        ApprovedCall memory call = ApprovedCall({
-            token: pt,
-            amount: rawPtReceived,
-            approveTo: ms.ptAdapter,
-            callTo: ms.ptAdapter,
-            data: abi.encodeCall(IOFT.send, (sendParam, sendFee, nativeRefund))
-        });
-        (, OFTReceipt memory oftReceipt) =
-            abi.decode(box.approveAndCall{value: nativeFee}(call, nativeRefund), (MessagingReceipt, OFTReceipt));
-        netPtReceived = oftReceipt.amountReceivedLD;
-    }
-
-    receive() external payable {}
-}

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

@@ -1,274 +0,0 @@
-// 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";
-
-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,"
-            "uint256 expiry,"
-            "uint256 nonce,"
-            //
-            "address token,"
-            "uint256 amountWithdraw,"
-            "uint256 amountFee"
-        ")"
-    );
-
-    // forgefmt: disable-next-item
-    bytes32 internal constant BRIDGE_TOKEN_MESSAGE_TYPEHASH = keccak256(
-        "BridgeTokenMessage("
-            "address owner,"
-            "uint32 boxId,"
-            "uint256 expiry,"
-            "uint256 nonce,"
-            //
-            "address token,"
-            "uint256 amountBridge,"
-            "uint256 amountFee,"
-            "bool pullFromOwner,"
-            //
-            "address bridgeExtRouter,"
-            "address bridgeApprove,"
-            "bytes bridgeCalldata"
-        ")"
-    );
-
-    // forgefmt: disable-next-item
-    bytes32 internal constant SWAP_TOKEN_MESSAGE_TYPEHASH = keccak256(
-        "SwapTokenMessage("
-            "address owner,"
-            "uint32 boxId,"
-            "uint256 expiry,"
-            "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 swapExtRouter,"
-            "address swapApprove,"
-            "bytes swapCalldata"
-        ")"
-    );
-
-    address public immutable TREASURY;
-
-    /// @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;
-
-    constructor(address treasury_, address beaconProxyCodeContract_, address depositBoxBeacon_) {
-        TREASURY = treasury_;
-        BEACON_PROXY_CODE_CONTRACT = beaconProxyCodeContract_;
-        DEPOSIT_BOX_BEACON = depositBoxBeacon_;
-        DEPOSIT_BOX_CODE_HASH =
-            keccak256(abi.encodePacked(beaconProxyCodeContract_.code, abi.encode(depositBoxBeacon_, "")));
-    }
-
-    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 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 hashTypedData(WithdrawTokenMessage memory message) 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
-                )
-            )
-        );
-    }
-
-    function hashTypedData(BridgeTokenMessage memory message) public view returns (bytes32) {
-        return _hashTypedDataV4(
-            keccak256(
-                abi.encode(
-                    BRIDGE_TOKEN_MESSAGE_TYPEHASH,
-                    message.owner,
-                    message.boxId,
-                    message.expiry,
-                    message.nonce,
-                    //
-                    message.token,
-                    message.amountBridge,
-                    message.amountFee,
-                    message.pullFromOwner,
-                    //
-                    message.bridgeExtRouter,
-                    message.bridgeApprove,
-                    keccak256(message.bridgeCalldata)
-                )
-            )
-        );
-    }
-
-    function hashTypedData(SwapTokenMessage memory message) 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,
-                    //
-                    message.swapExtRouter,
-                    message.swapApprove,
-                    keccak256(message.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());
-        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)));
-    }
-}