@pendle/core-v2 6.4.1 → 6.4.2-swaphubtest

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

@@ -0,0 +1,66 @@
+// 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

@@ -0,0 +1,178 @@
+// 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

@@ -0,0 +1,274 @@
+// 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)));
+    }
+}

package/contracts/interfaces/IPCrossChainSwapHub.sol

@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPCrossChainSwapHub {
+    error InsufficientTokenReceived();
+    error InvalidNonce();
+    error InvalidSignature();
+    error InvalidReceiver();
+    error MessageExpired();
+
+    struct WithdrawTokenMessage {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 nonce;
+        //
+        address token;
+        uint256 amountWithdraw;
+        uint256 amountFee;
+    }
+
+    struct BridgeTokenMessage {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 nonce;
+        //
+        address token;
+        uint256 amountBridge;
+        uint256 amountFee;
+        bool pullFromOwner;
+        //
+        address bridgeExtRouter;
+        address bridgeApprove;
+        bytes bridgeCalldata;
+    }
+
+    struct 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;
+    }
+
+    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 BridgeToken(
+        address indexed owner,
+        uint32 boxId,
+        address bridgeExtRouter,
+        address token,
+        uint256 amountBridge,
+        uint256 amountFee,
+        bool pullFromOwner
+    );
+
+    event SwapToken(
+        address indexed owner,
+        uint32 boxId,
+        address tokenSpent,
+        uint256 amountSpent,
+        uint256 amountFee,
+        address tokenReceived,
+        uint256 netTokenReceived,
+        bool pullFromOwner,
+        bool sendToOwner
+    );
+
+    event BuyCrossChainPt(
+        address indexed owner,
+        uint32 boxId,
+        address tokenSpent,
+        uint256 amountSpent,
+        uint256 amountFee,
+        address ptAdapter,
+        address pt,
+        uint256 netPtReceived,
+        bool pullFromOwner
+    );
+
+    event SetExecutor(address indexed executor, bool isExecutor);
+
+    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 isExecutor(address executor) external view returns (bool);
+
+    function computeDepositBox(address owner, uint32 boxId)
+        external
+        view
+        returns (address box, bytes32 salt, bool deployed);
+
+    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(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/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);
+}