@pendle/core-v2 6.4.4-swaphubtest → 6.5.0

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

package/contracts/deprecated/VeDistributor/PendleFeeDistributor.sol

@@ -1,204 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../LiquidityMining/libraries/VeHistoryLib.sol";
-import "../../LiquidityMining/libraries/WeekMath.sol";
-import "../../core/libraries/ArrayLib.sol";
-import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
-import "../../core/libraries/Errors.sol";
-import "../../interfaces/IPFeeDistributor.sol";
-import "../../interfaces/IPVotingController.sol";
-import "../../interfaces/IPVotingEscrowMainchain.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeableV2, IPFeeDistributor {
-    using SafeERC20 for IERC20;
-    using VeBalanceLib for VeBalance;
-    using ArrayLib for uint256[];
-
-    address public immutable votingController;
-    address public immutable vePendle;
-    address public immutable token;
-
-    address[] public allPools;
-
-    // [pool] => lastFundedWeek
-    mapping(address => uint256) public lastFundedWeek;
-
-    // [pool, user] => UserInfo
-    mapping(address => mapping(address => UserInfo)) public userInfo;
-
-    // [pool, epoch] => [fee]
-    mapping(address => mapping(uint256 => uint256)) public fees;
-
-    modifier ensureValidPool(address pool) {
-        if (lastFundedWeek[pool] == 0) revert Errors.FDInvalidPool(pool);
-        _;
-    }
-
-    constructor(address _votingController, address _vePendle, address _rewardToken) initializer {
-        votingController = _votingController;
-        vePendle = _vePendle;
-        token = _rewardToken;
-    }
-
-    function addPool(address pool, uint256 _startWeek) external onlyOwner {
-        if (!WeekMath.isValidWTime(_startWeek) || _startWeek == 0) revert Errors.FDInvalidStartEpoch(_startWeek);
-
-        if (lastFundedWeek[pool] != 0) revert Errors.FDPoolAlreadyExists(pool);
-
-        lastFundedWeek[pool] = _startWeek - WeekMath.WEEK;
-        allPools.push(pool);
-
-        emit PoolAdded(pool, _startWeek);
-    }
-
-    function getAllPools() external view returns (address[] memory) {
-        return allPools;
-    }
-
-    function fund(
-        address[] calldata pools,
-        uint256[][] calldata wTimes,
-        uint256[][] calldata amounts,
-        uint256 totalAmountToFund
-    ) external onlyOwner {
-        uint256 length = pools.length;
-        if (wTimes.length != length || amounts.length != length) revert Errors.ArrayLengthMismatch();
-
-        uint256 totalFunded = 0;
-        for (uint256 i = 0; i < length; ++i) {
-            _fund(pools[i], wTimes[i], amounts[i]);
-            totalFunded += amounts[i].sum();
-        }
-
-        if (totalFunded != totalAmountToFund) {
-            revert Errors.FDTotalAmountFundedNotMatch(totalFunded, totalAmountToFund);
-        }
-
-        IERC20(token).transferFrom(msg.sender, address(this), totalFunded);
-    }
-
-    function _fund(address pool, uint256[] calldata wTimes, uint256[] calldata amounts) internal ensureValidPool(pool) {
-        if (wTimes.length != amounts.length) revert Errors.FDEpochLengthMismatch();
-
-        uint256 lastFunded = lastFundedWeek[pool];
-
-        uint256 curWeek = WeekMath.getCurrentWeekStart();
-
-        for (uint256 i = 0; i < amounts.length; ++i) {
-            uint256 wTime = wTimes[i];
-            uint256 amount = amounts[i];
-
-            if (wTime != lastFunded + WeekMath.WEEK) revert Errors.FDInvalidWTimeFund(lastFunded, wTime);
-
-            fees[pool][wTime] += amount;
-            lastFunded += WeekMath.WEEK;
-
-            emit UpdateFee(pool, wTime, amount);
-        }
-
-        if (lastFunded >= curWeek) revert Errors.FDInvalidWTimeFund(lastFunded, curWeek);
-
-        lastFundedWeek[pool] = lastFunded;
-    }
-
-    function claimReward(address user, address[] calldata pools) external returns (uint256[] memory amountRewardOut) {
-        amountRewardOut = new uint256[](pools.length);
-        for (uint256 i = 0; i < pools.length;) {
-            amountRewardOut[i] = _accumulateUserReward(pools[i], user);
-            unchecked {
-                i++;
-            }
-        }
-        IERC20(token).safeTransfer(user, amountRewardOut.sum());
-    }
-
-    function getAllActivePools() external view returns (address[] memory) {
-        return allPools;
-    }
-
-    function _accumulateUserReward(address pool, address user)
-        internal
-        ensureValidPool(pool)
-        returns (uint256 totalReward)
-    {
-        uint256 length = _getUserCheckpointLength(pool, user);
-        if (length == 0) return 0;
-
-        uint256 lastWeek = lastFundedWeek[pool];
-        uint256 curWeek = userInfo[pool][user].firstUnclaimedWeek;
-        uint256 iter = userInfo[pool][user].iter;
-
-        if (curWeek > lastWeek) return 0; // nothing to account
-
-        Checkpoint memory checkpoint = _getUserCheckpointAt(pool, user, iter);
-        Checkpoint memory nextCheckpoint = checkpoint;
-
-        if (curWeek == 0) curWeek = checkpoint.timestamp + WeekMath.WEEK;
-
-        while (curWeek <= lastWeek) {
-            // we have at most one checkpoint per week
-            if (iter + 1 < length) {
-                if (nextCheckpoint.timestamp == checkpoint.timestamp) {
-                    // next have been assigned to current checkpoint, so we need to get the next one
-                    nextCheckpoint = _getUserCheckpointAt(pool, user, iter + 1);
-                }
-
-                if (nextCheckpoint.timestamp < curWeek) {
-                    iter++;
-                    checkpoint = nextCheckpoint;
-                }
-                // Important invariant: checkpoint[iter] < curWeek <= checkpoint[iter+1]
-            }
-
-            // assert(checkpoint.timestamp < curWeek); should always hold
-
-            uint256 userShare = checkpoint.value.getValueAt(uint128(curWeek));
-            if (userShare != 0) {
-                uint256 totalShare = _getPoolTotalSharesAt(pool, uint128(curWeek));
-                // userShare != 0 => totalShare != 0
-                uint256 amountRewardOut = (userShare * fees[pool][curWeek]) / totalShare;
-                totalReward += amountRewardOut;
-                emit ClaimReward(pool, user, curWeek, amountRewardOut);
-            }
-
-            curWeek += WeekMath.WEEK;
-        }
-
-        userInfo[pool][user] = UserInfo({firstUnclaimedWeek: uint128(curWeek), iter: uint128(iter)});
-    }
-
-    function _getPoolTotalSharesAt(address pool, uint128 wTime) internal view returns (uint256) {
-        if (pool == vePendle) {
-            return IPVotingEscrowMainchain(vePendle).totalSupplyAt(wTime);
-        } else {
-            return IPVotingController(votingController).getPoolTotalVoteAt(pool, wTime);
-        }
-    }
-
-    function _getUserCheckpointAt(address pool, address user, uint256 index) internal view returns (Checkpoint memory) {
-        if (pool == vePendle) {
-            return IPVotingEscrowMainchain(vePendle).getUserHistoryAt(user, index);
-        } else {
-            return IPVotingController(votingController).getUserPoolHistoryAt(user, pool, index);
-        }
-    }
-
-    function _getUserCheckpointLength(address pool, address user) internal view returns (uint256) {
-        if (pool == vePendle) {
-            return IPVotingEscrowMainchain(vePendle).getUserHistoryLength(user);
-        } else {
-            return IPVotingController(votingController).getUserPoolHistoryLength(user, pool);
-        }
-    }
-
-    function initialize(address _owner) external initializer {
-        __BoringOwnableV2_init(_owner);
-    }
-
-    // ----------------- upgrade-related -----------------
-
-    function _authorizeUpgrade(address) internal override onlyOwner {}
-}