@pendle/core-v2 6.3.1 → 6.3.2-swaphubtest

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

@@ -0,0 +1,303 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+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 {IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+import {IPSwapExecutor, SwapData} from "./swap/IPSwapExecutor.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 receiver,"
+            "address token,"
+            "uint256 withdrawAmount,"
+            "uint256 feeAmount"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant BRIDGE_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "BridgeTokenMessage("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 nonce,"
+            //
+            "address token,"
+            "uint256 bridgeAmount,"
+            "uint256 feeAmount,"
+            //
+            "address bridgeExtRouter,"
+            "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,"
+            "address tokenReceived,"
+            "uint256 minReceived,"
+            "uint256 feeAmount,"
+            //
+            "address swapExecutor,"
+            "address swapExtRouter,"
+            "bytes swapCalldata"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant BUY_CROSS_CHAIN_PT_INTENT_TYPEHASH = keccak256(
+        "BuyCrossChainPtIntent("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 salt,"
+            "uint256 expiry,"
+            //
+            "address tokenSpent,"
+            "uint256 maxAmountSpent,"
+            "address pt,"
+            "address ptAdapter,"
+            "uint256 minPtReceived,"
+            "uint32 dstLzEid,"
+            "bytes32 receiver"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant EXECUTE_BUY_CROSS_CHAIN_PT_MESSAGE_TYPEHASH = keccak256(
+        "ExecuteBuyCrossChainPtMessage("
+            "address validator,"
+            "bytes32 intentHash,"
+            "uint256 amountSpent,"
+            "uint256 feeAmount,"
+            "address swapExecutor,"
+            "address swapExtRouter,"
+            "bytes swapCalldata,"
+            "uint256 expiry"
+        ")"
+    );
+
+    /// @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(bytes32 intentHash => bool) public isIntentExecuted;
+    mapping(address executor => bool) public isExecutor;
+    mapping(address validator => bool) public isValidator;
+
+    constructor(address beaconProxyCodeContract_, address depositBoxBeacon_) {
+        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 setValidator(address validator, bool isValidator_) external onlyOwner {
+        isValidator[validator] = isValidator_;
+        emit SetValidator(validator, isValidator_);
+    }
+
+    function computeDepositBox(address owner, uint32 boxId) public view returns (address box, bytes32 salt) {
+        salt = keccak256(abi.encode(owner, boxId));
+        box = Create2.computeAddress(salt, DEPOSIT_BOX_CODE_HASH);
+    }
+
+    function _checkAndDeployBox(address owner, uint32 boxId) internal returns (IPDepositBox) {
+        (address box, bytes32 salt) = computeDepositBox(owner, boxId);
+        if (box.code.length > 0) {
+            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.receiver,
+                    message.token,
+                    message.withdrawAmount,
+                    message.feeAmount
+                )
+            )
+        );
+    }
+
+    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.bridgeAmount,
+                    message.feeAmount,
+                    //
+                    message.bridgeExtRouter,
+                    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.tokenReceived,
+                    message.minReceived,
+                    message.feeAmount,
+                    //
+                    message.swapExecutor,
+                    message.swapExtRouter,
+                    keccak256(message.swapCalldata)
+                )
+            )
+        );
+    }
+
+    function hashTypedData(BuyCrossChainPtIntent memory intent) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    BUY_CROSS_CHAIN_PT_INTENT_TYPEHASH,
+                    intent.owner,
+                    intent.boxId,
+                    intent.salt,
+                    intent.expiry,
+                    //
+                    intent.tokenSpent,
+                    intent.maxAmountSpent,
+                    intent.pt,
+                    intent.ptAdapter,
+                    intent.minPtReceived,
+                    intent.dstLzEid,
+                    intent.receiver
+                )
+            )
+        );
+    }
+
+    function hashTypedData(ExecuteBuyCrossChainPtMessage memory message) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    EXECUTE_BUY_CROSS_CHAIN_PT_MESSAGE_TYPEHASH,
+                    message.validator,
+                    message.intentHash,
+                    message.amountSpent,
+                    message.feeAmount,
+                    message.swapExecutor,
+                    message.swapExtRouter,
+                    keccak256(message.swapCalldata),
+                    message.expiry
+                )
+            )
+        );
+    }
+
+    function _verifyOwnerSigAndNonce(
+        address owner,
+        uint256 expiry,
+        uint256 nonce,
+        bytes32 messageHash,
+        bytes memory signature
+    ) internal {
+        _verifyOwnerSig(owner, expiry, messageHash, signature);
+        _verifyAndIncreaseNonce(owner, nonce);
+    }
+
+    function _verifyOwnerSig(address owner, uint256 expiry, bytes32 messageHash, bytes memory signature) internal view {
+        require(SignatureChecker.isValidSignatureNow(owner, messageHash, signature), InvalidSignature());
+        require(expiry > block.timestamp, MessageExpired());
+    }
+
+    function _verifyAndIncreaseNonce(address owner, uint256 nonce) internal {
+        require(ownerNonce[owner] < nonce, InvalidNonce());
+        ownerNonce[owner] = nonce;
+    }
+
+    function _verifyValidatorSig(address validator, uint256 expiry, bytes32 messageHash, bytes memory signature)
+        internal
+        view
+    {
+        require(SignatureChecker.isValidSignatureNow(validator, messageHash, signature), InvalidSignature());
+        require(isValidator[validator], InvalidValidator());
+        require(expiry > block.timestamp, MessageExpired());
+    }
+
+    function _verifyIntentHashAndMarkExecuted(bytes32 expectedHash, bytes32 actualHash) internal {
+        require(expectedHash == actualHash, IntentHashMismatch());
+        require(!isIntentExecuted[actualHash], IntentExecuted());
+        isIntentExecuted[actualHash] = true;
+    }
+
+    function _balanceOf(address addr, address token) internal view returns (uint256) {
+        return (token == NATIVE) ? addr.balance : IERC20(token).balanceOf(addr);
+    }
+
+    function _swapFromBox(IPDepositBox box, address swapExecutor, SwapData memory swapData)
+        internal
+        returns (uint256 rawTokenOut)
+    {
+        box.withdrawTo(swapExecutor, swapData.tokenIn, swapData.amountIn);
+
+        uint256 preBalance = _balanceOf(address(box), swapData.tokenOut);
+        IPSwapExecutor(swapExecutor).swap(address(box), swapData);
+        rawTokenOut = _balanceOf(address(box), swapData.tokenOut) - preBalance;
+    }
+}

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

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+struct SwapData {
+    address tokenIn;
+    uint256 amountIn;
+    address tokenOut;
+    address extRouter;
+    bytes extCalldata;
+}
+
+interface IPSwapExecutor {
+    function swap(address receiver, SwapData memory swapData) external payable;
+}

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

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {TokenHelper} from "../../../core/libraries/TokenHelper.sol";
+import {IPSwapExecutor, SwapData} from "./IPSwapExecutor.sol";
+
+contract SwapExecutor is IPSwapExecutor, TokenHelper {
+    using Address for address;
+    using SafeERC20 for IERC20;
+
+    function swap(address receiver, SwapData memory $) external payable {
+        _approveForExtRouter($.tokenIn, $.extRouter);
+        $.extRouter.functionCallWithValue($.extCalldata, $.tokenIn == NATIVE ? $.amountIn : 0);
+        _transferOut($.tokenOut, receiver, _selfBalance($.tokenOut));
+    }
+
+    function _approveForExtRouter(address token, address extRouter) internal {
+        if (token == NATIVE) return;
+
+        _safeApproveInfV2(IERC20(token), extRouter);
+    }
+
+    function _safeApproveInfV2(IERC20 token, address spender) internal {
+        if (token.allowance(address(this), spender) < type(uint256).max) {
+            token.forceApprove(spender, type(uint256).max);
+        }
+    }
+
+    receive() external payable {}
+}

package/contracts/interfaces/IMarketSweed.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./IPAllActionV3.sol";
+
+interface IMarketSweed {
+    struct ApproxSweedParams {
+        uint256 targetLnImpliedRate;
+        uint256 eps;
+        uint256 maxPtToSwap;
+        int256 guessOffchain;
+        uint256 maxIteration;
+    }
+
+    function seedAtImpliedRate(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        ApproxSweedParams calldata sweedParams
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, int256 guessedAmountPtToSwap);
+}

package/contracts/interfaces/IPCrossChainSwapHub.sol

@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPCrossChainSwapHub {
+    error ExcessiveNativeFee();
+    error InsufficientTokenReceived();
+    error InvalidAmountIn();
+    error InvalidNonce();
+    error InvalidSignature();
+    error InvalidValidator();
+    error IntentExecuted();
+    error IntentHashMismatch();
+    error MessageExpired();
+
+    struct WithdrawTokenMessage {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 nonce;
+        //
+        address receiver;
+        address token;
+        uint256 withdrawAmount;
+        uint256 feeAmount;
+    }
+
+    struct BridgeTokenMessage {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 nonce;
+        //
+        address token;
+        uint256 bridgeAmount;
+        uint256 feeAmount;
+        //
+        address bridgeExtRouter;
+        bytes bridgeCalldata;
+    }
+
+    struct SwapTokenMessage {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 nonce;
+        //
+        address tokenSpent;
+        uint256 amountSpent;
+        address tokenReceived;
+        uint256 minReceived;
+        uint256 feeAmount;
+        //
+        address swapExecutor;
+        address swapExtRouter;
+        bytes swapCalldata;
+    }
+
+    struct BuyCrossChainPtIntent {
+        address owner;
+        uint32 boxId;
+        uint256 salt;
+        uint256 expiry;
+        //
+        address tokenSpent;
+        uint256 maxAmountSpent;
+        address pt;
+        address ptAdapter;
+        uint256 minPtReceived;
+        uint32 dstLzEid;
+        bytes32 receiver;
+    }
+
+    struct ExecuteBuyCrossChainPtMessage {
+        address validator;
+        bytes32 intentHash;
+        uint256 amountSpent;
+        uint256 feeAmount;
+        address swapExecutor;
+        address swapExtRouter;
+        bytes swapCalldata;
+        uint256 expiry;
+    }
+
+    event WithdrawToken(
+        address indexed owner, uint32 boxId, address receiver, address token, uint256 withdrawAmount, uint256 feeAmount
+    );
+
+    event BridgeToken(
+        address indexed owner,
+        uint32 boxId,
+        address bridgeExtRouter,
+        address token,
+        uint256 bridgeAmount,
+        uint256 feeAmount
+    );
+
+    event SwapToken(
+        address indexed owner,
+        uint32 boxId,
+        address tokenSpent,
+        uint256 amountSpent,
+        address tokenReceived,
+        uint256 netTokenReceived
+    );
+
+    event BuyCrossChainPt(
+        address indexed owner,
+        uint32 boxId,
+        bytes32 intentHash,
+        address tokenSpent,
+        uint256 amountSpent,
+        address pt,
+        address ptAdapter,
+        uint256 netPtReceived
+    );
+
+    event SetExecutor(address indexed executor, bool isExecutor);
+
+    event SetValidator(address indexed validator, bool isValidator);
+
+    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);
+
+    function isIntentExecuted(bytes32 intentHash) external view returns (bool);
+
+    function isExecutor(address executor) external view returns (bool);
+
+    function isValidator(address validator) external view returns (bool);
+
+    function computeDepositBox(address owner, uint32 boxId) external view returns (address box, bytes32 salt);
+
+    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 hashTypedData(BuyCrossChainPtIntent memory intent) external view returns (bytes32);
+
+    function hashTypedData(ExecuteBuyCrossChainPtMessage 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(
+        BuyCrossChainPtIntent memory intent,
+        bytes memory intentSig,
+        ExecuteBuyCrossChainPtMessage memory execMsg,
+        bytes memory execSig
+    ) external payable;
+
+    function setExecutor(address executor, bool isExecutor) external;
+
+    function setValidator(address validator, bool isValidator) external;
+}

package/contracts/interfaces/IPDepositBox.sol

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