@pendle/core-v2 4.2.1 → 4.2.2

package/contracts/core/StandardizedYield/StEthNativeLib.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../interfaces/IStETH.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+library StETHNativeLib {
+    address internal constant STETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
+
+    function _depositStETH(uint256 amountNative) internal returns (uint256 amountStETHOut) {
+        uint256 preBal = IERC20(STETH).balanceOf(address(this));
+        IStETH(STETH).submit{value: amountNative}(address(0));
+        return IERC20(STETH).balanceOf(address(this)) - preBal;
+    }
+}

package/contracts/core/StandardizedYield/implementations/BedRock/PendleUniETHSY.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/Bedrock/IBedrockStaking.sol";
+
+contract PendleUniETHSY is SYBase {
+    using PMath for uint256;
+
+    address public immutable bedrockStaking;
+    address public immutable uniETH;
+
+    constructor(address _bedrockStaking, address _uniETH) SYBase("SY Bedrock UniETH", "SY-uniETH", _uniETH) {
+        bedrockStaking = _bedrockStaking;
+        uniETH = _uniETH;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE) {
+            amountSharesOut = IBedrockStaking(bedrockStaking).mint{value: amountDeposited}(0, type(uint256).max);
+        } else {
+            amountSharesOut = amountDeposited;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256) {
+        _transferOut(uniETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IBedrockStaking(bedrockStaking).exchangeRatio();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
+        if (tokenIn == NATIVE) {
+            uint256 reserve = IBedrockStaking(bedrockStaking).currentReserve();
+            uint256 supply = IERC20(uniETH).totalSupply();
+            return (amountTokenToDeposit * supply) / reserve;
+        }
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(uniETH, NATIVE);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(uniETH);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == NATIVE || token == uniETH;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == uniETH;
+    }
+
+    function assetInfo() external pure override returns (AssetType, address, uint8) {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Ethena/PendleSUSDESY.sol

@@ -4,7 +4,65 @@ pragma solidity ^0.8.17;
 import "../PendleERC4626SY.sol";
 
 contract PendleSUSDESY is PendleERC4626SY {
-    constructor(address _susde) PendleERC4626SY("SY Ethena sUSDE", "SY-sUSDE", _susde) {}
+    uint256 public supplyCap;
+
+    event SupplyCapUpdated(uint256 newSupplyCap);
+
+    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
+
+    constructor(address _susde, uint256 _initialSupplyCap) PendleERC4626SY("SY Ethena sUSDE", "SY-sUSDE", _susde) {
+        _updateSupplyCap(_initialSupplyCap);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            SUPPLY CAP UPDATE
+    //////////////////////////////////////////////////////////////*/
+
+    function updateSupplyCap(uint256 newSupplyCap) external onlyOwner {
+        _updateSupplyCap(newSupplyCap);
+    }
+
+    function _updateSupplyCap(uint256 newSupplyCap) internal {
+        supplyCap = newSupplyCap;
+        emit SupplyCapUpdated(newSupplyCap);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            SUPPLY CAP LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
+        uint256 _newSupply = totalSupply() + amountSharesOut;
+        uint256 _supplyCap = supplyCap;
+        
+        if (_newSupply > _supplyCap) {
+            revert SupplyCapExceeded(_newSupply, _supplyCap);
+        }
+    }
+
+    // @dev: whenNotPaused not needed as it has already been added to beforeTransfer
+    function _afterTokenTransfer(address from, address, uint256) internal virtual override {
+        // only check for minting case
+        // saving gas on user->user transfers
+        // skip supply cap checking on burn to allow lowering supply cap
+        if (from != address(0)) {
+            return;
+        }
+
+        uint256 _supply = totalSupply();
+        uint256 _supplyCap = supplyCap;
+        if (_supply > _supplyCap) {
+            revert SupplyCapExceeded(_supply, _supplyCap);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                OVERRIDEN 4626 TO GET YIELD TOKEN ONLY
+    //////////////////////////////////////////////////////////////*/
 
     function getTokensOut() public view override returns (address[] memory res) {
         return ArrayLib.create(yieldToken);

package/contracts/core/StandardizedYield/implementations/KelpDAO/PendleRsETHSY.sol

@@ -78,7 +78,7 @@ contract PendleRsETHSY is SYBase {
                 amountDeposited,
                 0,
                 "c05f6902ec7c7434ceb666010c16a63a2e3995aad11f1280855b26402194346b"
-            ); // TODO: hardcode referral to save gas
+            );
             amountSharesOut = _selfBalance(rsETH) - preBalance;
         }
     }

package/contracts/core/StandardizedYield/implementations/PendleERC4626SY.sol

@@ -46,7 +46,7 @@ contract PendleERC4626SY is SYBase {
     function _previewDeposit(
         address tokenIn,
         uint256 amountTokenToDeposit
-    ) internal view override returns (uint256 /*amountSharesOut*/) {
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
         if (tokenIn == yieldToken) return amountTokenToDeposit;
         else return IERC4626(yieldToken).previewDeposit(amountTokenToDeposit);
     }

package/contracts/core/StandardizedYield/implementations/PendleERC4626UpgSY.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../SYBaseUpg.sol";
+import "../../../interfaces/IERC4626.sol";
+
+contract PendleERC4626SYUpg is SYBaseUpg {
+    using PMath for uint256;
+    address public immutable asset;
+
+    constructor(address _erc4626) SYBaseUpg(_erc4626) {
+        asset = IERC4626(_erc4626).asset();
+        _safeApproveInf(asset, _erc4626);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) {
+            return amountDeposited;
+        } else {
+            return IERC4626(yieldToken).deposit(amountDeposited, address(this));
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        if (tokenOut == yieldToken) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(yieldToken, receiver, amountTokenOut);
+        } else {
+            amountTokenOut = IERC4626(yieldToken).redeem(amountSharesToRedeem, receiver, address(this));
+        }
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        uint256 totalAssets = IERC4626(yieldToken).totalAssets();
+        uint256 totalSupply = IERC4626(yieldToken).totalSupply();
+        return totalAssets.divDown(totalSupply);
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) return amountTokenToDeposit;
+        else return IERC4626(yieldToken).previewDeposit(amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        if (tokenOut == yieldToken) return amountSharesToRedeem;
+        else return IERC4626(yieldToken).previewRedeem(amountSharesToRedeem);
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = asset;
+        res[1] = yieldToken;
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = asset;
+        res[1] = yieldToken;
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken || token == asset;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken || token == asset;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Puffer/PendlePufStETHSY.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "../../StEthNativeLib.sol";
+import "../../../../interfaces/IERC4626.sol";
+
+contract PendlePufStETHSY is SYBaseUpg {
+    using PMath for uint256;
+    address public immutable asset;
+
+    constructor(address _erc4626) SYBaseUpg(_erc4626) {
+        asset = IERC4626(_erc4626).asset();
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY Puffer ETH", "SY pufETH");
+        approveAssetForDeposit();
+    }
+
+    function approveAssetForDeposit() public {
+        _safeApproveInf(asset, yieldToken);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) {
+            return amountDeposited;
+        } else {
+            if (tokenIn == NATIVE) {
+                amountDeposited = StETHNativeLib._depositStETH(amountDeposited);
+            }
+            return IERC4626(yieldToken).deposit(amountDeposited, address(this));
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256) {
+        _transferOut(yieldToken, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        uint256 totalAssets = IERC4626(yieldToken).totalAssets();
+        uint256 totalSupply = IERC4626(yieldToken).totalSupply();
+        return totalAssets.divDown(totalSupply);
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) return amountTokenToDeposit;
+        // tokenIn is either NATIVE or stETH, we treat 1 NATIVE == 1 stETH
+        else return IERC4626(yieldToken).previewDeposit(amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken, asset, NATIVE);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken || token == asset || token == NATIVE;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        // Puffer team clarified that their 4626 will be changed to WETH when they are fully launched
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Puffer/PendlePufWETHSY.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "../../StEthNativeLib.sol";
+import "../../../../interfaces/IERC4626.sol";
+
+// Still keeping StETHNativeLib dependency for consistency
+contract PendlePufWETHSY is SYBaseUpg {
+    using PMath for uint256;
+    address public immutable asset;
+
+    constructor(address _erc4626) SYBaseUpg(_erc4626) {
+        asset = IERC4626(_erc4626).asset();
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY Puffer ETH", "SY pufETH");
+        approveAssetForDeposit();
+    }
+
+    function approveAssetForDeposit() public {
+        _safeApproveInf(asset, yieldToken);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) {
+            return amountDeposited;
+        } else {
+            return IERC4626(yieldToken).deposit(amountDeposited, address(this));
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256) {
+        _transferOut(yieldToken, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        uint256 totalAssets = IERC4626(yieldToken).totalAssets();
+        uint256 totalSupply = IERC4626(yieldToken).totalSupply();
+        return totalAssets.divDown(totalSupply);
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) return amountTokenToDeposit;
+        else return IERC4626(yieldToken).previewDeposit(amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken, asset);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken || token == asset;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/interfaces/Bedrock/IBedrockStaking.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IBedrockStaking {
+    function mint(uint256 minToMint, uint256 deadline) external payable returns (uint256 minted);
+
+    function exchangeRatio() external view returns (uint256);
+
+    function currentReserve() external view returns (uint256);
+}

package/contracts/interfaces/IRedstonePriceFeed.sol

@@ -0,0 +1,15 @@
+import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
+
+interface IRedstonePriceFeed is AggregatorV3Interface {
+    /**
+     * @notice Old Chainlink function for getting the number of latest round
+     * @return latestRound The number of the latest update round
+     */
+    function latestRound() external view returns (uint80);
+
+    /**
+     * @notice Old Chainlink function for getting the latest successfully reported value
+     * @return latestAnswer The latest successfully reported value
+     */
+    function latestAnswer() external view returns (int256);
+}

package/contracts/oracles/PendleRedStoneRateOracleAdapter.sol

@@ -3,21 +3,23 @@ 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";
+import "../interfaces/IRedstonePriceFeed.sol";
 
 contract PendleRedStoneRateOracleAdapter is IPExchangeRateOracle {
     using PMath for int256;
 
     address public immutable oracle;
     uint8 public immutable decimals;
+    uint8 public immutable rawDecimals;
 
     constructor(address _redStoneOracle, uint8 _decimals) {
         oracle = _redStoneOracle;
         decimals = _decimals;
+        rawDecimals = IRedstonePriceFeed(_redStoneOracle).decimals();
     }
 
     function getExchangeRate() external view returns (uint256) {
-        (, int256 answer, , , ) = IChainlinkAggregator(oracle).latestRoundData();
-        return (answer.Uint() * 10 ** decimals) / 10 ** IChainlinkAggregator(oracle).decimals();
+        int256 answer = IRedstonePriceFeed(oracle).latestAnswer();
+        return (answer.Uint() * 10 ** decimals) / 10 ** rawDecimals;
     }
 }

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

@@ -275,6 +275,48 @@ interface IExecutorHelper {
         uint8 settleFlags;
     }
 
+    struct UniV1 {
+        address pool;
+        uint256 amount;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+    }
+
+    struct LighterV2 {
+        address orderBook;
+        uint256 amount;
+        bool isAsk; // isAsk = orderBook.isAskOrder(orderId);
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+    }
+
+    struct EtherFiWeETH {
+        uint256 amount;
+        bool isWrapping;
+    }
+
+    struct Kelp {
+        uint256 amount;
+        address tokenIn;
+    }
+
+    struct EthenaSusde {
+        uint256 amount;
+        address recipient;
+    }
+
+    struct RocketPool {
+        address pool;
+        uint256 isDepositAndAmount; // 1 isDeposit + 127 empty + 128 amount token in
+    }
+
+    struct MakersDAI {
+        uint256 isRedeemAndAmount; // 1 isRedeem + 127 empty + 128 amount token in
+        address recipient;
+    }
+
     function executeUniswap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
     function executeStableSwap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
@@ -368,4 +410,24 @@ interface IExecutorHelper {
     function executeBancorV3(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
     function executeAmbient(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeUniV1(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeNative(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeBebop(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeLighterV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeEtherFieETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeEtherFiWeETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeKelp(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeRocketPool(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeEthenaSusde(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeMakersDAI(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 }

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

@@ -295,6 +295,15 @@ interface IExecutorHelperL2 {
         uint8 settleFlags;
     }
 
+    struct LighterV2 {
+        address orderBook;
+        uint256 amount;
+        bool isAsk; // isAsk = orderBook.isAskOrder(orderId);
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+    }
+
     function executeUniswap(
         uint256 index,
         bytes memory data,
@@ -663,4 +672,22 @@ interface IExecutorHelperL2 {
         bool getPoolOnly,
         address nextPool
     ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeNative(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeLighterV2(
+        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

@@ -262,6 +262,26 @@ library InputScalingHelper {
                 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 if (functionSelector == IExecutorHelper.executeNative.selector) {
+                revert("InputScalingHelper: Can not scale Native swap");
+            } else if (functionSelector == IExecutorHelper.executeLighterV2.selector) {
+                swap.data = ScalingDataLib.newLighterV2(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeBebop.selector) {
+                revert("InputScalingHelper: Can not scale Bebop swap");
+            } else if (functionSelector == IExecutorHelper.executeUniV1.selector) {
+                swap.data = ScalingDataLib.newUniV1(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeEtherFieETH.selector) {
+                swap.data = ScalingDataLib.newEtherFieETH(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeEtherFiWeETH.selector) {
+                swap.data = ScalingDataLib.newEtherFiWeETH(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeKelp.selector) {
+                swap.data = ScalingDataLib.newKelp(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeEthenaSusde.selector) {
+                swap.data = ScalingDataLib.newEthenaSusde(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeRocketPool.selector) {
+                swap.data = ScalingDataLib.newRocketPool(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeMakersDAI.selector) {
+                swap.data = ScalingDataLib.newMakersDAI(swap.data, oldAmount, newAmount);
             } else {
                 revert("AggregationExecutor: Dex type not supported");
             }