@pendle/core-v2 1.0.2-mainnet → 1.1.0-testnet

package/contracts/LiquidityMining/FeeDistributor/PendleFeeDistributor.sol

@@ -1,99 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../../core/libraries/math/Math.sol";
-import "../../core/libraries/ArrayLib.sol";
-import "../../core/libraries/MiniHelpers.sol";
-import "../../core/libraries/Errors.sol";
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
-
-import "../libraries/WeekMath.sol";
-import "../libraries/VeHistoryLib.sol";
-
-import "../../interfaces/IPFeeDistributor.sol";
-import "../../interfaces/IPFeeDistributorFactory.sol";
-
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-contract PendleFeeDistributor is IPFeeDistributor, BoringOwnableUpgradeable {
-    using Math for uint256;
-    using SafeERC20 for IERC20;
-    using ArrayLib for address[];
-    using VeBalanceLib for VeBalance;
-
-    address public immutable factory;
-    address public immutable pool;
-    address public immutable rewardToken;
-    uint256 public immutable startEpoch;
-
-    uint256 public lastFinishedEpoch;
-
-    // [user] => [epoch]
-    mapping(address => uint256) public userLastClaimedEpoch;
-
-    // [epoch] => [incentive]
-    mapping(uint256 => uint256) public incentivesForEpoch;
-
-    constructor(
-        address _pool,
-        address _rewardToken,
-        uint256 _startEpoch
-    ) initializer {
-        pool = _pool;
-        factory = msg.sender;
-        rewardToken = _rewardToken;
-        startEpoch = _startEpoch;
-        lastFinishedEpoch = _startEpoch;
-        __BoringOwnable_init();
-    }
-
-    function fund(uint256[] calldata rewardsForEpoch) external onlyOwner {
-        uint256 epoch = lastFinishedEpoch;
-        uint256 totalRewardFunding = 0;
-        for (uint256 i = 0; i < rewardsForEpoch.length; ++i) {
-            epoch += WeekMath.WEEK;
-            uint256 incentive = rewardsForEpoch[i];
-
-            incentivesForEpoch[epoch] += incentive;
-            totalRewardFunding += incentive;
-
-            emit Fund(epoch, incentive);
-        }
-
-        if (epoch > WeekMath.getCurrentWeekStart()) revert Errors.FDCantFundFutureEpoch();
-
-        IERC20(rewardToken).transferFrom(msg.sender, address(this), totalRewardFunding);
-        lastFinishedEpoch = epoch;
-    }
-
-    function claimReward(address user) external returns (uint256 amountRewardOut) {
-        IPFeeDistributorFactory(factory).updateUserShare(user, pool);
-
-        uint256 finishedEpoch = lastFinishedEpoch;
-        uint256 userEpoch = userLastClaimedEpoch[user];
-
-        if (userEpoch == finishedEpoch) return 0;
-        if (userEpoch == 0) userEpoch = startEpoch;
-
-        while (userEpoch < finishedEpoch) {
-            userEpoch += WeekMath.WEEK;
-
-            uint256 incentive = incentivesForEpoch[userEpoch];
-            if (incentive == 0) continue;
-
-            (uint256 userShare, uint256 totalShare) = IPFeeDistributorFactory(factory)
-                .getUserAndTotalSharesAt(user, pool, userEpoch);
-
-            if (userShare == 0) continue;
-
-            amountRewardOut += (userShare * incentive) / totalShare;
-        }
-
-        userLastClaimedEpoch[user] = finishedEpoch;
-        if (amountRewardOut > 0) {
-            IERC20(rewardToken).safeTransfer(user, amountRewardOut);
-        }
-
-        emit ClaimReward(user, rewardToken, finishedEpoch, amountRewardOut);
-    }
-}

package/contracts/LiquidityMining/FeeDistributor/PendleFeeDistributorFactory.sol

@@ -1,70 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "./PendleFeeDistributor.sol";
-import "./EpochResultManager.sol";
-
-import "../../core/libraries/BaseSplitCodeFactory.sol";
-
-import "../../interfaces/IBoringOwnableUpgradeable.sol";
-import "../../interfaces/IPFeeDistributorFactory.sol";
-
-contract PendleFeeDistributorFactory is BoringOwnableUpgradeable, EpochResultManager {
-    using Math for uint256;
-
-    struct PoolInfo {
-        address distributor;
-        uint64 startTime;
-    }
-
-    address public immutable feeDistributorCreationCodeContractA;
-    uint256 public immutable feeDistributorCreationCodeSizeA;
-    address public immutable feeDistributorCreationCodeContractB;
-    uint256 public immutable feeDistributorCreationCodeSizeB;
-
-    address public immutable rewardToken;
-    uint256 public lastFinishedEpoch;
-    mapping(address => PoolInfo) public poolInfos;
-
-    constructor(
-        address _rewardToken,
-        address _votingController,
-        address _vePendle,
-        address _feeDistributorCreationCodeContractA,
-        uint256 _feeDistributorCreationCodeSizeA,
-        address _feeDistributorCreationCodeContractB,
-        uint256 _feeDistributorCreationCodeSizeB
-    ) EpochResultManager(_votingController, _vePendle) initializer {
-        __BoringOwnable_init();
-        rewardToken = _rewardToken;
-        feeDistributorCreationCodeContractA = _feeDistributorCreationCodeContractA;
-        feeDistributorCreationCodeSizeA = _feeDistributorCreationCodeSizeA;
-        feeDistributorCreationCodeContractB = _feeDistributorCreationCodeContractB;
-        feeDistributorCreationCodeSizeB = _feeDistributorCreationCodeSizeB;
-    }
-
-    function createFeeDistributor(address pool, uint64 startTime)
-        external
-        onlyOwner
-        returns (address distributor)
-    {
-        if (poolInfos[pool].distributor != address(0))
-            revert Errors.FDFactoryDistributorAlreadyExisted(pool, poolInfos[pool].distributor);
-
-        distributor = BaseSplitCodeFactory._create2(
-            0,
-            bytes32(""),
-            abi.encode(pool, rewardToken, uint256(startTime)),
-            feeDistributorCreationCodeContractA,
-            feeDistributorCreationCodeSizeA,
-            feeDistributorCreationCodeContractB,
-            feeDistributorCreationCodeSizeB
-        );
-        IBoringOwnableUpgradeable(distributor).transferOwnership(msg.sender, true, false);
-        poolInfos[pool] = PoolInfo({ distributor: distributor, startTime: startTime });
-    }
-
-    function _getPoolStartTime(address pool) internal view virtual override returns (uint64) {
-        return poolInfos[pool].startTime;
-    }
-}

package/contracts/interfaces/IPActionSwapPTYT.sol

@@ -1,31 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../router/base/MarketApproxLib.sol";
-import "../router/kyberswap/KyberSwapHelper.sol";
-
-interface IPActionSwapPTYT {
-    event SwapPtAndYt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        int256 netPtToAccount,
-        int256 netYtToAccount
-    );
-
-    function swapExactPtForYt(
-        address receiver,
-        address market,
-        uint256 exactPtIn,
-        uint256 minYtOut,
-        ApproxParams calldata guessTotalPtToSwap
-    ) external returns (uint256 netYtOut, uint256 netSyFee);
-
-    function swapExactYtForPt(
-        address receiver,
-        address market,
-        uint256 exactYtIn,
-        uint256 minPtOut,
-        ApproxParams calldata guessTotalPtSwapped
-    ) external returns (uint256 netPtOut, uint256 netSyFee);
-}

package/contracts/interfaces/IPFeeDistributorFactory.sol

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-interface IPFeeDistributorFactory {
-    function lastFinishedEpoch() external returns (uint256);
-
-    function updateUserShare(address user, address pool) external;
-
-    function getUserAndTotalSharesAt(
-        address user,
-        address pool,
-        uint256 epoch
-    ) external view returns (uint256 userShare, uint256 totalShare);
-}

package/contracts/router/ActionSwapPTYT.sol

@@ -1,108 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../interfaces/IPActionSwapPTYT.sol";
-import "../interfaces/IPMarket.sol";
-import "./base/CallbackHelper.sol";
-
-/// @dev All swap actions will revert if market is expired
-contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper, TokenHelper {
-    using MarketMathCore for MarketState;
-    using MarketApproxPtInLib for MarketState;
-    using MarketApproxPtOutLib for MarketState;
-    using Math for uint256;
-    using Math for int256;
-    using PYIndexLib for IPYieldToken;
-
-    /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor() //solhint-disable-next-line no-empty-blocks
-    {
-
-    }
-
-    /**
-     * @notice swap exact PT to YT with the help of flashswaps & YT tokenization / redemption
-     * @dev inner working of this function:
-     - `exactPtIn` PT is transferred to market contract
-     - `market.swapExactPtForSy` is called, which will transfer SY directly to YT contract & callback is invoked.
-        Note that we will owe PT, the amount before is not sufficient
-     - in callback, all SY in YT contract is used to mint PT + YT, with PT used to pay the rest of the loan, and YT
-        transferred to the receiver
-     * @param exactPtIn will always consume this amount of PT for as much YT as possible
-     * @param guessTotalPtToSwap approximation data for PT used for the PT-to-SY flashswap
-     * @dev this function works in conjunction with ActionCallback
-     */
-    function swapExactPtForYt(
-        address receiver,
-        address market,
-        uint256 exactPtIn,
-        uint256 minYtOut,
-        ApproxParams calldata guessTotalPtToSwap
-    ) external returns (uint256 netYtOut, uint256 netSyFee) {
-        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
-        MarketState memory state = IPMarket(market).readState(address(this));
-
-        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
-
-        uint256 totalPtToSwap;
-        (netYtOut, totalPtToSwap, netSyFee) = state.approxSwapExactPtForYt(
-            YT.newIndex(),
-            exactPtIn,
-            block.timestamp,
-            guessTotalPtToSwap
-        );
-
-        if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
-
-        IPMarket(market).swapExactPtForSy(
-            address(YT),
-            totalPtToSwap,
-            _encodeSwapExactPtForYt(receiver, exactPtIn, minYtOut)
-        );
-
-        emit SwapPtAndYt(msg.sender, market, receiver, exactPtIn.neg(), netYtOut.Int());
-    }
-
-    /**
-     * @notice swap exact YT to PT with the help of flashswaps & YT tokenization / redemption
-     * @dev inner working of this function:
-     - `exactYtIn` YT is transferred to yield contract
-     - `market.swapSyForExactPt` is called, which will transfer PT directly to this contract & callback is invoked.
-        Note that we now owe SY
-     - in callback, a portion of PT + YT is used to redeem SY, which is then used to payback the loan. The rest of
-       of the PT is transferred to `receiver`
-     * @param exactYtIn will always consume this amount of YT for as much PT as possible
-     * @param guessTotalPtFromSwap approximation data for PT output of the SY-to-PT flashswap
-     * @dev this function works in conjunction with ActionCallback
-     */
-    function swapExactYtForPt(
-        address receiver,
-        address market,
-        uint256 exactYtIn,
-        uint256 minPtOut,
-        ApproxParams calldata guessTotalPtFromSwap
-    ) external returns (uint256 netPtOut, uint256 netSyFee) {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
-        MarketState memory state = IPMarket(market).readState(address(this));
-
-        _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
-
-        uint256 totalPtFromSwap;
-        (netPtOut, totalPtFromSwap, netSyFee) = state.approxSwapExactYtForPt(
-            YT.newIndex(),
-            exactYtIn,
-            block.timestamp,
-            guessTotalPtFromSwap
-        );
-
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
-
-        IPMarket(market).swapSyForExactPt(
-            address(this),
-            totalPtFromSwap,
-            _encodeSwapExactYtForPt(receiver, exactYtIn, minPtOut)
-        );
-
-        emit SwapPtAndYt(msg.sender, market, receiver, netPtOut.Int(), exactYtIn.neg());
-    }
-}

package/contracts/router/kyberswap/AggregationRouterHelper.sol

@@ -1,317 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-pragma solidity 0.8.17;
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "./IMultihopRouter.sol";
-import "./IAggregatorRouterHelper.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
-
-contract AggregationRouterHelper is
-    IAggregationRouterHelper,
-    Initializable,
-    UUPSUpgradeable,
-    BoringOwnableUpgradeable
-{
-    uint256 private constant _PARTIAL_FILL = 0x01;
-    uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
-    uint256 private constant _SHOULD_CLAIM = 0x04;
-    uint256 private constant _BURN_FROM_MSG_SENDER = 0x08;
-    uint256 private constant _BURN_FROM_TX_ORIGIN = 0x10;
-    uint256 private constant _SIMPLE_SWAP = 0x20;
-
-    uint256 private constant SLIPPAGE_RANGE = 10; // over 100
-
-    constructor() initializer {}
-
-    function initialize() external initializer {
-        __BoringOwnable_init();
-    }
-
-    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
-
-    enum DexType {
-        UNI,
-        STABLESWAP,
-        CURVE,
-        KYBERDMM,
-        SADDLE,
-        UNIV3PROMM,
-        BALANCERV2,
-        KYBERRFQ,
-        DODO,
-        VELODROME,
-        PLATYPUS
-    }
-
-    struct SwapDescription {
-        IERC20 srcToken;
-        IERC20 dstToken;
-        address[] srcReceivers;
-        uint256[] srcAmounts;
-        address dstReceiver;
-        uint256 amount;
-        uint256 minReturnAmount;
-        uint256 flags;
-        bytes permit;
-    }
-
-    struct SimpleSwapData {
-        address[] firstPools;
-        uint256[] firstSwapAmounts;
-        bytes[] swapDatas;
-        uint256 deadline;
-        bytes destTokenFeeData;
-    }
-
-    struct SwapExecutorDescription {
-        IMultihopRouter.Swap[][] swapSequences;
-        address tokenIn;
-        address tokenOut;
-        uint256 minTotalAmountOut;
-        address to;
-        uint256 deadline;
-        bytes destTokenFeeData;
-    }
-
-    function getScaledInputData(bytes calldata kybercall, uint256 newAmount)
-        external
-        pure
-        returns (bytes memory)
-    {
-        bytes4 selector = bytes4(kybercall[:4]);
-        (
-            address caller,
-            SwapDescription memory desc,
-            bytes memory executorData,
-            bytes memory clientData
-        ) = abi.decode(kybercall[4:], (address, SwapDescription, bytes, bytes));
-
-        (desc, executorData) = _getScaledInputData(desc, executorData, newAmount);
-        return abi.encodeWithSelector(selector, caller, desc, executorData, clientData);
-    }
-
-    function _getScaledInputData(
-        SwapDescription memory desc,
-        bytes memory executorData,
-        uint256 newAmount
-    ) internal pure returns (SwapDescription memory, bytes memory) {
-        uint256 flags = desc.flags;
-        uint256 oldAmount = desc.amount;
-        if (oldAmount == newAmount) {
-            return (desc, executorData);
-        }
-
-        // simple mode swap
-        if (flags & _SIMPLE_SWAP != 0) {
-            require(desc.srcReceivers.length == 0, "kyber: can't scale if take fee");
-            return (
-                _getNewDescription(desc, oldAmount, newAmount),
-                _getNewSimpleSwapData(executorData, oldAmount, newAmount)
-            );
-        }
-
-        //normal mode swap
-        bytes memory newExecutorData = _getNewExecutorData(executorData, oldAmount, newAmount);
-        return (_getNewDescription(desc, oldAmount, newAmount), newExecutorData);
-    }
-
-    function _getNewDescription(
-        SwapDescription memory desc,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (SwapDescription memory) {
-        uint256 oldMinReturnAmount = desc.minReturnAmount;
-        desc.minReturnAmount = (desc.minReturnAmount * newAmount) / oldAmount;
-        //newMinReturnAmount should no be 0 if oldMinReturnAmount > 0
-        if (oldMinReturnAmount > 0 && desc.minReturnAmount == 0) desc.minReturnAmount = 1;
-        desc.amount = newAmount;
-        if (desc.srcReceivers.length == 0) {
-            return desc;
-        }
-
-        uint256 newTotal;
-        for (uint256 i = 0; i < desc.srcReceivers.length; i++) {
-            if (i == desc.srcReceivers.length - 1) {
-                desc.srcAmounts[i] = newAmount - newTotal;
-            } else {
-                desc.srcAmounts[i] = (desc.srcAmounts[i] * newAmount) / oldAmount;
-            }
-            newTotal += desc.srcAmounts[i];
-        }
-        return desc;
-    }
-
-    function _getNewSimpleSwapData(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
-        SimpleSwapData memory swapData = abi.decode(data, (SimpleSwapData));
-        uint256 numberSeq = swapData.firstPools.length;
-        uint256 newTotalSwapAmount;
-        for (uint256 i = 0; i < numberSeq; i++) {
-            if (i == numberSeq - 1) {
-                swapData.firstSwapAmounts[i] = newAmount - newTotalSwapAmount;
-            } else {
-                swapData.firstSwapAmounts[i] =
-                    (swapData.firstSwapAmounts[i] * newAmount) /
-                    oldAmount;
-            }
-            newTotalSwapAmount += swapData.firstSwapAmounts[i];
-        }
-        return abi.encode(swapData);
-    }
-
-    function _getNewExecutorData(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
-        SwapExecutorDescription memory swapExecutorDescription = abi.decode(
-            data,
-            (SwapExecutorDescription)
-        );
-        swapExecutorDescription.minTotalAmountOut =
-            (swapExecutorDescription.minTotalAmountOut * newAmount) /
-            oldAmount;
-
-        uint256 newTotalSwapAmount;
-        for (uint256 i = 0; i < swapExecutorDescription.swapSequences.length; i++) {
-            IMultihopRouter.Swap memory swap = swapExecutorDescription.swapSequences[i][0];
-            uint8 dexType = uint8(swap.dexOption >> 8);
-            uint256 value;
-            if (i == swapExecutorDescription.swapSequences.length - 1)
-                value = newAmount - newTotalSwapAmount;
-
-            if (dexType == uint8(DexType.UNI)) {
-                (swap.data, value) = _newUniSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.STABLESWAP) || dexType == uint8(DexType.SADDLE)) {
-                (swap.data, value) = _newStableSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.CURVE)) {
-                (swap.data, value) = _newCurveSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.KYBERDMM)) {
-                (swap.data, value) = _newKyberDMMSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.UNIV3PROMM)) {
-                (swap.data, value) = _newUniV3ProMMSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.BALANCERV2)) {
-                (swap.data, value) = _newBalancerV2Swap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.KYBERRFQ)) {
-                revert("kyber: can't scale kyberrfq");
-            } else if (dexType == uint8(DexType.DODO)) {
-                (swap.data, value) = _newDODOSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.VELODROME)) {
-                (swap.data, value) = _newVelodromeSwap(swap.data, value, oldAmount, newAmount);
-            } else {
-                revert("AggregationExecutor: Dex type not supported");
-            }
-            newTotalSwapAmount += value;
-        }
-        return abi.encode(swapExecutorDescription);
-    }
-
-    function _newUniSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory uniSwap = abi.decode(data, (IMultihopRouter.UniSwap));
-        if (value > 0) uniSwap.collectAmount = value;
-        else uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
-        return (abi.encode(uniSwap), uniSwap.collectAmount);
-    }
-
-    function _newStableSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.StableSwap memory stableSwap = abi.decode(
-            data,
-            (IMultihopRouter.StableSwap)
-        );
-        if (value > 0) stableSwap.dx = value;
-        else stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
-        return (abi.encode(stableSwap), stableSwap.dx);
-    }
-
-    function _newCurveSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.CurveSwap memory curveSwap = abi.decode(data, (IMultihopRouter.CurveSwap));
-        if (value > 0) curveSwap.dx = value;
-        else curveSwap.dx = (curveSwap.dx * newAmount) / oldAmount;
-        return (abi.encode(curveSwap), curveSwap.dx);
-    }
-
-    function _newKyberDMMSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory kyberDMMSwap = abi.decode(data, (IMultihopRouter.UniSwap));
-        if (value > 0) kyberDMMSwap.collectAmount = value;
-        else kyberDMMSwap.collectAmount = (kyberDMMSwap.collectAmount * newAmount) / oldAmount;
-        return (abi.encode(kyberDMMSwap), kyberDMMSwap.collectAmount);
-    }
-
-    function _newUniV3ProMMSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
-            data,
-            (IMultihopRouter.UniSwapV3ProMM)
-        );
-        if (value > 0) uniSwapV3ProMM.swapAmount = value;
-        else uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
-        return (abi.encode(uniSwapV3ProMM), uniSwapV3ProMM.swapAmount);
-    }
-
-    function _newBalancerV2Swap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.BalancerV2 memory balancerV2 = abi.decode(
-            data,
-            (IMultihopRouter.BalancerV2)
-        );
-        if (value > 0) balancerV2.amount = value;
-        else balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
-        return (abi.encode(balancerV2, balancerV2.amount), balancerV2.amount);
-    }
-
-    function _newDODOSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.DODO memory dodo = abi.decode(data, (IMultihopRouter.DODO));
-        if (value > 0) dodo.amount = value;
-        else dodo.amount = (dodo.amount * newAmount) / oldAmount;
-        return (abi.encode(dodo), dodo.amount);
-    }
-
-    function _newVelodromeSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory velodrome = abi.decode(data, (IMultihopRouter.UniSwap));
-        if (value > 0) velodrome.collectAmount = value;
-        else velodrome.collectAmount = (velodrome.collectAmount * newAmount) / oldAmount;
-        return (abi.encode(velodrome), velodrome.collectAmount);
-    }
-}

package/contracts/router/kyberswap/IAggregatorRouterHelper.sol

@@ -1,10 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-pragma solidity 0.8.17;
-
-interface IAggregationRouterHelper {
-    function getScaledInputData(bytes calldata kybercall, uint256 newAmount)
-        external
-        pure
-        returns (bytes memory);
-}