@pendle/core-v2 4.0.5 → 4.1.0

package/contracts/offchain-helpers/router-static/base/ActionMintRedeemStatic.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../interfaces/IPRouterStatic.sol";
+import "./StorageLayout.sol";
+
+contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
+    using PMath for uint256;
+
+    function mintPyFromSyStatic(address YT, uint256 netSyToMint) public view returns (uint256 netPYOut) {
+        if (IPYieldToken(YT).isExpired()) revert Errors.YCExpired();
+        return netSyToMint.mulDown(pyIndexCurrentViewYt(YT));
+    }
+
+    function redeemPyToSyStatic(address YT, uint256 netPYToRedeem) public view returns (uint256 netSyOut) {
+        return netPYToRedeem.divDown(pyIndexCurrentViewYt(YT));
+    }
+
+    function mintPyFromTokenStatic(
+        address YT,
+        address tokenIn,
+        uint256 netTokenIn
+    ) external view returns (uint256 netPyOut) {
+        address SY = IPYieldToken(YT).SY();
+        uint256 netSyReceived = mintSyFromTokenStatic(SY, tokenIn, netTokenIn);
+        netPyOut = mintPyFromSyStatic(YT, netSyReceived);
+    }
+
+    function redeemPyToTokenStatic(
+        address YT,
+        uint256 netPYToRedeem,
+        address tokenOut
+    ) external view returns (uint256 netTokenOut) {
+        address SY = IPYieldToken(YT).SY();
+        uint256 netSyReceived = redeemPyToSyStatic(YT, netPYToRedeem);
+        netTokenOut = redeemSyToTokenStatic(SY, tokenOut, netSyReceived);
+    }
+
+    function mintSyFromTokenStatic(
+        address SY,
+        address tokenIn,
+        uint256 netTokenIn
+    ) public view returns (uint256 netSyOut) {
+        return IStandardizedYield(SY).previewDeposit(tokenIn, netTokenIn);
+    }
+
+    function redeemSyToTokenStatic(
+        address SY,
+        address tokenOut,
+        uint256 netSyIn
+    ) public view returns (uint256 netTokenOut) {
+        return IStandardizedYield(SY).previewRedeem(tokenOut, netSyIn);
+    }
+
+    function getAmountTokenToMintSy(
+        address SY,
+        address tokenIn,
+        uint256 netSyOut
+    ) external view returns (uint256 netTokenIn) {
+        uint256 pivotAmount;
+
+        if (tokenIn == address(0)) pivotAmount = 1e18;
+        else pivotAmount = 10 ** IStandardizedYield(SY).decimals();
+
+        uint256 low = pivotAmount;
+        {
+            while (true) {
+                uint256 lowSyOut = mintSyFromTokenStatic(SY, tokenIn, low);
+                if (lowSyOut >= netSyOut) low /= 10;
+                else break;
+            }
+        }
+
+        uint256 high = pivotAmount;
+        {
+            while (true) {
+                uint256 highSyOut = mintSyFromTokenStatic(SY, tokenIn, high);
+                if (highSyOut < netSyOut) high *= 10;
+                else break;
+            }
+        }
+
+        while (low <= high) {
+            uint256 mid = (low + high) / 2;
+            uint256 syOut = mintSyFromTokenStatic(SY, tokenIn, mid);
+
+            if (syOut >= netSyOut) {
+                netTokenIn = mid;
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        assert(netTokenIn > 0);
+    }
+
+    function pyIndexCurrentViewMarket(address market) public view returns (uint256) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        return pyIndexCurrentViewYt(address(YT));
+    }
+
+    function pyIndexCurrentViewYt(address yt) public view returns (uint256) {
+        IPYieldToken YT = IPYieldToken(yt);
+        IStandardizedYield SY = IStandardizedYield(YT.SY());
+
+        uint256 syIndex = SY.exchangeRate();
+        uint256 pyIndexStored = YT.pyIndexStored();
+
+        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
+            return pyIndexStored;
+        } else {
+            return PMath.max(syIndex, pyIndexStored);
+        }
+    }
+}

package/contracts/offchain-helpers/router-static/base/ActionStorageStatic.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./StorageLayout.sol";
+import "../../../interfaces/IPActionStorageStatic.sol";
+import "../../../interfaces/IPMiniDiamond.sol";
+
+contract ActionStorageStatic is StorageLayout, IPActionStorageStatic, IPMiniDiamond {
+    function setDefaultApproxParams(ApproxParams memory params) external onlyOwner {
+        defaultApproxParams = params;
+    }
+
+    function getDefaultApproxParams() external view returns (ApproxParams memory) {
+        return defaultApproxParams;
+    }
+
+    function getOwnerAndPendingOwner() external view returns (address _owner, address _pendingOwner) {
+        _owner = owner;
+        _pendingOwner = pendingOwner;
+    }
+
+    function setFacetForSelectors(SelectorsToFacet[] calldata arr) external onlyOwner {
+        for (uint256 i = 0; i < arr.length; ) {
+            SelectorsToFacet memory s = arr[i];
+            for (uint256 j = 0; j < s.selectors.length; ) {
+                selectorToFacet[s.selectors[j]] = s.facet;
+                unchecked {
+                    j++;
+                }
+            }
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function facetAddress(bytes4 selector) external view returns (address res) {
+        res = selectorToFacet[selector];
+        require(res != address(0), "selector not found");
+    }
+
+    // Ownable
+    function transferOwnership(address newOwner, bool direct, bool renounce) external onlyOwner {
+        if (direct) {
+            require(newOwner != address(0) || renounce, "Ownable: zero address");
+
+            emit OwnershipTransferred(owner, newOwner);
+            owner = newOwner;
+            pendingOwner = address(0);
+        } else {
+            pendingOwner = newOwner;
+        }
+    }
+
+    function claimOwnership() external {
+        address _pendingOwner = pendingOwner;
+
+        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
+
+        emit OwnershipTransferred(owner, _pendingOwner);
+        owner = _pendingOwner;
+        pendingOwner = address(0);
+    }
+}

package/contracts/offchain-helpers/router-static/base/ActionVePendleStatic.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../core/libraries/MiniHelpers.sol";
+import "../../../interfaces/IPRouterStatic.sol";
+import "../../../interfaces/IPVotingEscrowMainchain.sol";
+import "../../../LiquidityMining/libraries/VeBalanceLib.sol";
+
+contract ActionVePendleStatic is IPActionVePendleStatic {
+    using VeBalanceLib for VeBalance;
+    using VeBalanceLib for LockedPosition;
+
+    uint128 private constant MAX_LOCK_TIME = 104 weeks;
+    uint128 private constant MIN_LOCK_TIME = 1 weeks;
+
+    IPVotingEscrowMainchain private immutable vePENDLE;
+
+    constructor(IPVotingEscrowMainchain _vePENDLE) {
+        vePENDLE = _vePENDLE;
+    }
+
+    function increaseLockPositionStatic(
+        address user,
+        uint128 additionalAmountToLock,
+        uint128 newExpiry
+    ) external view returns (uint128 newVeBalance) {
+        if (!WeekMath.isValidWTime(newExpiry)) revert Errors.InvalidWTime(newExpiry);
+        if (MiniHelpers.isTimeInThePast(newExpiry)) revert Errors.ExpiryInThePast(newExpiry);
+
+        if (newExpiry > block.timestamp + MAX_LOCK_TIME) revert Errors.VEExceededMaxLockTime();
+        if (newExpiry < block.timestamp + MIN_LOCK_TIME) revert Errors.VEInsufficientLockTime();
+
+        LockedPosition memory oldPosition;
+
+        {
+            (uint128 amount, uint128 expiry) = vePENDLE.positionData(user);
+            oldPosition = LockedPosition(amount, expiry);
+        }
+
+        if (newExpiry < oldPosition.expiry) revert Errors.VENotAllowedReduceExpiry();
+
+        uint128 newTotalAmountLocked = additionalAmountToLock + oldPosition.amount;
+        if (newTotalAmountLocked == 0) revert Errors.VEZeroAmountLocked();
+
+        uint128 additionalDurationToLock = newExpiry - oldPosition.expiry;
+
+        LockedPosition memory newPosition = LockedPosition(
+            oldPosition.amount + additionalAmountToLock,
+            oldPosition.expiry + additionalDurationToLock
+        );
+
+        VeBalance memory newBalance = newPosition.convertToVeBalance();
+        return newBalance.getCurrentValue();
+    }
+}

package/contracts/offchain-helpers/router-static/base/StorageLayout.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../router/base/MarketApproxLib.sol";
+
+abstract contract StorageLayout {
+    address internal owner;
+    address internal pendingOwner;
+
+    mapping(bytes4 => address) internal selectorToFacet;
+
+    ApproxParams internal defaultApproxParams;
+
+    address internal _deprecated_bulkSellerFactory;
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Ownable: caller is not the owner");
+        _;
+    }
+}

package/contracts/oracles/PendleRedStoneRateOracle.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../core/libraries/math/PMath.sol";
+import "../interfaces/IPExchangeRateOracle.sol";
+import {AggregatorV3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+contract PendleRedStoneRateOracle is IPExchangeRateOracle {
+    using PMath for int256;
+
+    address public immutable oracle;
+    uint8 public immutable decimals;
+
+    constructor(address _redStoneOracle, uint8 _decimals) {
+        oracle = _redStoneOracle;
+        decimals = _decimals;
+    }
+
+    function getExchangeRate() external view returns (uint256) {
+        (, int256 answer, , , ) = IChainlinkAggregator(oracle).latestRoundData();
+        return (answer.Uint() * 10 ** decimals) / 10 ** IChainlinkAggregator(oracle).decimals();
+    }
+}

package/contracts/router/swap-aggregator/kyberswap/interfaces/IExecutorHelper.sol

@@ -212,9 +212,12 @@ interface IExecutorHelper {
 
     struct VelocoreV2 {
         address vault;
+        uint256 amount;
         address tokenIn;
         address tokenOut;
-        uint256 amount;
+        address stablePool; // if not empty then use stable pool
+        address wrapToken;
+        bool isConvertFirst;
     }
 
     struct MaticMigrate {
@@ -232,6 +235,46 @@ interface IExecutorHelper {
         address toToken;
     }
 
+    struct BalancerV1 {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+    }
+
+    struct SwaapV2 {
+        address router;
+        uint256 amount;
+        bytes data;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+    }
+
+    struct ArbswapStable {
+        address pool;
+        uint256 dx;
+        uint256 tokenIndexFrom;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct BancorV2 {
+        address pool;
+        address[] swapPath;
+        uint256 amount;
+        address recipient;
+    }
+
+    struct Ambient {
+        address pool;
+        uint128 qty;
+        address base;
+        address quote;
+        uint256 poolIdx;
+        uint8 settleFlags;
+    }
+
     function executeUniswap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
     function executeStableSwap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
@@ -311,4 +354,18 @@ interface IExecutorHelper {
     function executeSolidlyV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
     function executeKokonut(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeBalancerV1(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeSwaapV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeNomiswapStable(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeArbswapStable(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeBancorV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeBancorV3(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeAmbient(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 }

package/contracts/router/swap-aggregator/kyberswap/interfaces/IExecutorHelperL2.sol

@@ -232,9 +232,12 @@ interface IExecutorHelperL2 {
 
     struct VelocoreV2 {
         address vault;
+        uint256 amount;
         address tokenIn;
         address tokenOut;
-        uint256 amount;
+        address stablePool; // if not empty then use stable pool
+        address wrapToken;
+        bool isConvertFirst;
     }
 
     struct MaticMigrate {
@@ -252,6 +255,46 @@ interface IExecutorHelperL2 {
         address toToken;
     }
 
+    struct BalancerV1 {
+        address pool;
+        uint256 amount;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct SwaapV2 {
+        address router;
+        uint256 amount;
+        bytes data;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+    }
+
+    struct ArbswapStable {
+        address pool;
+        uint256 dx;
+        uint256 tokenIndexFrom;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct BancorV2 {
+        address pool;
+        address[] swapPath;
+        uint256 amount;
+        address recipient;
+    }
+
+    struct Ambient {
+        address pool;
+        uint128 qty;
+        address base;
+        address quote;
+        uint256 poolIdx;
+        uint8 settleFlags;
+    }
+
     function executeUniswap(
         uint256 index,
         bytes memory data,
@@ -557,4 +600,67 @@ interface IExecutorHelperL2 {
         bool getPoolOnly,
         address nextPool
     ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeBalancerV1(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeSwaapV2(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeNomiswapStable(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeArbswapStable(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeBancorV2(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeBancorV3(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeAmbient(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
 }

package/contracts/router/swap-aggregator/kyberswap/l1-contracts/InputScalingHelper.sol

@@ -248,6 +248,20 @@ library InputScalingHelper {
                 swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount); // @dev using Mantis struct because Solidly V2 and Mantis have same fields
             } else if (functionSelector == IExecutorHelper.executeKokonut.selector) {
                 swap.data = ScalingDataLib.newKokonut(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeBalancerV1.selector) {
+                swap.data = ScalingDataLib.newBalancerV1(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeSwaapV2.selector) {
+                revert("InputScalingHelper: Can not scale SwaapV2 swap");
+            } else if (functionSelector == IExecutorHelper.executeNomiswapStable.selector) {
+                swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount); // @dev using Mantis struct because NomiswapV2 and Mantis have same fields
+            } else if (functionSelector == IExecutorHelper.executeArbswapStable.selector) {
+                swap.data = ScalingDataLib.newArbswapStable(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeBancorV2.selector) {
+                swap.data = ScalingDataLib.newBancorV2(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeBancorV3.selector) {
+                swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount); // @dev using Mantis struct because Bancor V3 and Mantis have same fields
+            } else if (functionSelector == IExecutorHelper.executeAmbient.selector) {
+                swap.data = ScalingDataLib.newAmbient(swap.data, oldAmount, newAmount);
             } else {
                 revert("AggregationExecutor: Dex type not supported");
             }

package/contracts/router/swap-aggregator/kyberswap/l1-contracts/ScalingDataLib.sol

@@ -241,4 +241,36 @@ library ScalingDataLib {
         kokonut.dx = (kokonut.dx * newAmount) / oldAmount;
         return abi.encode(kokonut);
     }
+
+    function newBalancerV1(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper.BalancerV1 memory balancerV1 = abi.decode(data, (IExecutorHelper.BalancerV1));
+        balancerV1.amount = (balancerV1.amount * newAmount) / oldAmount;
+        return abi.encode(balancerV1);
+    }
+
+    function newArbswapStable(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper.ArbswapStable memory arbswapStable = abi.decode(data, (IExecutorHelper.ArbswapStable));
+        arbswapStable.dx = (arbswapStable.dx * newAmount) / oldAmount;
+        return abi.encode(arbswapStable);
+    }
+
+    function newBancorV2(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelper.BancorV2 memory bancorV2 = abi.decode(data, (IExecutorHelper.BancorV2));
+        bancorV2.amount = (bancorV2.amount * newAmount) / oldAmount;
+        return abi.encode(bancorV2);
+    }
+
+    function newAmbient(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelper.Ambient memory ambient = abi.decode(data, (IExecutorHelper.Ambient));
+        ambient.qty = uint128((uint256(ambient.qty) * newAmount) / oldAmount);
+        return abi.encode(ambient);
+    }
 }

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/CalldataReader.sol

@@ -55,6 +55,12 @@ library CalldataReader {
         return (uint32(bytes4(ret)), startByte);
     }
 
+    function _readUint128(bytes memory data, uint256 startByte) internal pure returns (uint128, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 16);
+        return (uint128(bytes16(ret)), startByte);
+    }
+
     function _readUint160(bytes memory data, uint256 startByte) internal pure returns (uint160, uint256) {
         bytes memory ret;
         (ret, startByte) = _calldataVal(data, startByte, 20);

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/DexScaler.sol

@@ -361,9 +361,8 @@ library DexScaler {
 
         (, startByte) = data._readPool(startByte); // pool
 
-        (, startByte) = data._readAddress(startByte); // tokenOut
-
         (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
+
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleVelocoreV2");
     }
 
@@ -379,4 +378,62 @@ library DexScaler {
         (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleKokonut");
     }
+
+    function scaleBalancerV1(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
+
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleBalancerV1");
+    }
+
+    function scaleArbswapStable(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (uint256 dx, ) = data._readUint128AsUint256(startByte); // dx
+
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (dx * newAmount) / oldAmount, "scaleArbswapStable");
+    }
+
+    function scaleBancorV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (, startByte) = data._readAddressArray(startByte); // swapPath
+
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
+
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleBancorV2");
+    }
+
+    function scaleAmbient(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (uint128 qty, ) = data._readUint128(startByte); // amount
+
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (qty * newAmount) / oldAmount, "scaleAmbient");
+    }
 }

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/InputScalingHelperL2.sol

@@ -62,7 +62,14 @@ library InputScalingHelperL2 {
         VelocoreV2,
         Smardex,
         SolidlyV2,
-        Kokonut
+        Kokonut,
+        BalancerV1,
+        SwaapV2,
+        NomiswapStable,
+        ArbswapStable,
+        BancorV2,
+        BancorV3,
+        Ambient
     }
 
     function _getScaledInputData(bytes calldata inputData, uint256 newAmount) internal pure returns (bytes memory) {
@@ -317,6 +324,20 @@ library InputScalingHelperL2 {
             swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Kokonut) {
             swap.data = swap.data.newKokonut(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.BalancerV1) {
+            swap.data = swap.data.newBalancerV1(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.SwaapV2) {
+            revert("InputScalingHelper: Can not scale SwaapV2 swap");
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.NomiswapStable) {
+            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.ArbswapStable) {
+            swap.data = swap.data.newArbswapStable(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.BancorV2) {
+            swap.data = swap.data.newBancorV2(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.BancorV3) {
+            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Ambient) {
+            swap.data = swap.data.newAmbient(oldAmount, newAmount);
         } else {
             revert("InputScaleHelper: Dex type not supported");
         }