@pendle/core-v2 4.4.1 → 4.4.2

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

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../PendleERC20SYUpg.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleSUSDEMantleSY is PendleERC20SYUpg {
+    event SetNewExchangeRateOracle(address oracle);
+
+    event SupplyCapUpdated(uint256 newSupplyCap);
+
+    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
+
+    address public exchangeRateOracle;
+    uint256 public supplyCap;
+
+    constructor(address _susde) PendleERC20SYUpg(_susde) {
+        _disableInitializers();
+    }
+
+    function initialize(uint256 _initialSupplyCap, address _initialExchangeRateOracle) external initializer {
+        __SYBaseUpg_init("SY Ethena sUSDE", "SY-sUSDE");
+        _setExchangeRateOracle(_initialExchangeRateOracle);
+        _updateSupplyCap(_initialSupplyCap);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            EXCHANGE RATE ORACLE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    function setExchangeRateOracle(address _exchangeRateOracle) external onlyOwner {
+        _setExchangeRateOracle(_exchangeRateOracle);
+    }
+
+    function _setExchangeRateOracle(address _exchangeRateOracle) internal {
+        exchangeRateOracle = _exchangeRateOracle;
+        emit SetNewExchangeRateOracle(_exchangeRateOracle);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            SUPPLY CAP LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        uint256 _newSupply = totalSupply() + amountTokenToDeposit;
+        uint256 _supplyCap = supplyCap;
+
+        if (_newSupply > _supplyCap) {
+            revert SupplyCapExceeded(_newSupply, _supplyCap);
+        }
+
+        return amountTokenToDeposit;
+    }
+
+    function updateSupplyCap(uint256 newSupplyCap) external onlyOwner {
+        _updateSupplyCap(newSupplyCap);
+    }
+
+    function _updateSupplyCap(uint256 newSupplyCap) internal {
+        supplyCap = newSupplyCap;
+        emit SupplyCapUpdated(newSupplyCap);
+    }
+
+    // @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);
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../PendleERC20SYUpg.sol";
+
+contract PendleUSDEMantleSY is PendleERC20SYUpg {
+    uint256 public supplyCap;
+
+    event SupplyCapUpdated(uint256 newSupplyCap);
+
+    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
+
+    constructor(address _usde) PendleERC20SYUpg(_usde) {
+        _disableInitializers();
+    }
+
+    function initialize(uint256 _initialSupplyCap) external initializer {
+        __SYBaseUpg_init("SY Ethena USDe", "SY-USDe");
+        _updateSupplyCap(_initialSupplyCap);
+    }
+
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        uint256 _newSupply = totalSupply() + amountTokenToDeposit;
+        uint256 _supplyCap = supplyCap;
+
+        if (_newSupply > _supplyCap) {
+            revert SupplyCapExceeded(_newSupply, _supplyCap);
+        }
+
+        return amountTokenToDeposit;
+    }
+
+    function updateSupplyCap(uint256 newSupplyCap) external onlyOwner {
+        _updateSupplyCap(newSupplyCap);
+    }
+
+    function _updateSupplyCap(uint256 newSupplyCap) internal {
+        supplyCap = newSupplyCap;
+        emit SupplyCapUpdated(newSupplyCap);
+    }
+
+    // @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);
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../SYBaseUpg.sol";
+
+abstract contract PendleERC20SYUpg is SYBaseUpg {
+    using PMath for uint256;
+
+    uint256[100] private __gap;
+
+    constructor(address _erc20) SYBaseUpg(_erc20) {}
+
+    function _deposit(
+        address /*tokenIn*/,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        return amountDeposited;
+    }
+
+    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 res) {
+        return PMath.ONE;
+    }
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    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;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, yieldToken, IERC20Metadata(yieldToken).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Zircuit/PendleZtakeRsETHSY.sol

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "../../../../interfaces/Zircuit/IZircuitZtaking.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+import "../../../../interfaces/KelpDAO/IKelpDepositPool.sol";
+import "../../../../interfaces/KelpDAO/IKelpLRTConfig.sol";
+
+contract PendleZtakeRsETHSY is SYBaseUpg {
+    address public constant ETH_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+
+    // solhint-disable immutable-vars-naming
+    address public immutable zircuitStaking;
+    address public immutable rsETH;
+    address public immutable depositPool;
+    address public immutable exchangeRateOracle;
+
+    constructor(
+        address _zircuitStaking,
+        address _rsETH,
+        address _depositPool,
+        address _exchangeRateOracle
+    ) SYBaseUpg(_rsETH) {
+        _disableInitializers();
+        zircuitStaking = _zircuitStaking;
+        rsETH = _rsETH;
+        depositPool = _depositPool;
+        exchangeRateOracle = _exchangeRateOracle;
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY Zircuit Staking rsETH", "SY-zs-rsETH");
+        _safeApproveInf(rsETH, zircuitStaking);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE) {
+            IKelpDepositPool(depositPool).depositETH{value: amountDeposited}(
+                0,
+                "c05f6902ec7c7434ceb666010c16a63a2e3995aad11f1280855b26402194346b"
+            );
+            amountSharesOut = _selfBalance(rsETH);
+        } else {
+            amountSharesOut = amountDeposited;
+        }
+        IZircuitZtaking(zircuitStaking).depositFor(rsETH, address(this), amountSharesOut);
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        IZircuitZtaking(zircuitStaking).withdraw(rsETH, amountSharesToRedeem);
+        _transferOut(rsETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == rsETH) {
+            return amountTokenToDeposit;
+        }
+        return IKelpDepositPool(depositPool).getRsETHAmountToMint(ETH_TOKEN, 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(NATIVE, rsETH);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(rsETH);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == NATIVE || token == rsETH;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == rsETH;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        assetType = AssetType.TOKEN;
+        assetAddress = NATIVE;
+        assetDecimals = 18;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Zircuit/PendleZtakeWETHSY.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "../../../../interfaces/Zircuit/IZircuitZtaking.sol";
+
+contract PendleZtakeWETHSY is SYBaseUpg {
+    // solhint-disable immutable-vars-naming
+    address public immutable zircuitStaking;
+    address public immutable wETH;
+
+    constructor(address _zircuitStaking, address _wETH) SYBaseUpg(_wETH) {
+        _disableInitializers();
+        zircuitStaking = _zircuitStaking;
+        wETH = _wETH;
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY Zircuit Staking wETH", "SY-zs-wETH");
+        _safeApproveInf(wETH, zircuitStaking);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address /*tokenIn*/, uint256 amountDeposited) internal virtual override returns (uint256) {
+        IZircuitZtaking(zircuitStaking).depositFor(wETH, address(this), amountDeposited);
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        IZircuitZtaking(zircuitStaking).withdraw(wETH, amountSharesToRedeem);
+        _transferOut(wETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return 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(wETH);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(wETH);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == wETH;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == wETH;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        assetType = AssetType.TOKEN;
+        assetAddress = wETH;
+        assetDecimals = 18;
+    }
+}

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -7,11 +7,11 @@ import "../../interfaces/IPYieldToken.sol";
 import "../libraries/MiniHelpers.sol";
 import "../libraries/Errors.sol";
 
-import "../erc20/PendleERC20Permit.sol";
+import "../erc20/PendleERC20.sol";
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalToken {
+contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
     address public immutable SY;
     address public immutable factory;
     uint256 public immutable expiry;
@@ -33,7 +33,7 @@ contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalTo
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20Permit(_name, _symbol, __decimals) {
+    ) PendleERC20(_name, _symbol, __decimals) {
         SY = _SY;
         expiry = _expiry;
         factory = msg.sender;

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -15,7 +15,7 @@ import "../libraries/Errors.sol";
 import "../libraries/MiniHelpers.sol";
 
 import "../RewardManager/RewardManagerAbstract.sol";
-import "../erc20/PendleERC20Permit.sol";
+import "../erc20/PendleERC20.sol";
 import "./InterestManagerYT.sol";
 
 /**
@@ -23,7 +23,7 @@ Invariance to maintain:
 - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
     guaranteed by address(0) & address(this) check in each updateForTwo function
 */
-contract PendleYieldToken is IPYieldToken, PendleERC20Permit, RewardManagerAbstract, InterestManagerYT {
+contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, InterestManagerYT {
     using PMath for uint256;
     using SafeERC20 for IERC20;
     using ArrayLib for uint256[];
@@ -73,7 +73,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20Permit, RewardManagerAbstr
         uint8 __decimals,
         uint256 _expiry,
         bool _doCacheIndexSameBlock
-    ) PendleERC20Permit(_name, _symbol, __decimals) {
+    ) PendleERC20(_name, _symbol, __decimals) {
         SY = _SY;
         PT = _PT;
         expiry = _expiry;

package/contracts/core/YieldContractsV2/PendlePrincipalTokenV2.sol

@@ -7,11 +7,11 @@ import "../../interfaces/IPYieldToken.sol";
 import "../libraries/MiniHelpers.sol";
 import "../libraries/Errors.sol";
 
-import "../erc20/PendleERC20Permit.sol";
+import "../erc20/PendleERC20.sol";
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-contract PendlePrincipalTokenV2 is PendleERC20Permit, Initializable, IPPrincipalToken {
+contract PendlePrincipalTokenV2 is PendleERC20, Initializable, IPPrincipalToken {
     address public immutable SY;
     address public immutable factory;
     uint256 public immutable expiry;
@@ -33,7 +33,7 @@ contract PendlePrincipalTokenV2 is PendleERC20Permit, Initializable, IPPrincipal
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20Permit(_name, _symbol, __decimals) {
+    ) PendleERC20(_name, _symbol, __decimals) {
         SY = _SY;
         expiry = _expiry;
         factory = msg.sender;

package/contracts/core/YieldContractsV2/PendleYieldTokenV2.sol

@@ -15,7 +15,7 @@ import "../libraries/Errors.sol";
 import "../libraries/MiniHelpers.sol";
 
 import "../RewardManager/RewardManager.sol";
-import "../erc20/PendleERC20Permit.sol";
+import "../erc20/PendleERC20.sol";
 import "./InterestManagerYTV2.sol";
 
 /**
@@ -23,7 +23,7 @@ Invariance to maintain:
 - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
     guaranteed by address(0) & address(this) check in each updateForTwo function
 */
-contract PendleYieldTokenV2 is IPYieldTokenV2, PendleERC20Permit, RewardManager, InterestManagerYTV2 {
+contract PendleYieldTokenV2 is IPYieldTokenV2, PendleERC20, RewardManager, InterestManagerYTV2 {
     using PMath for uint256;
     using SafeERC20 for IERC20;
     using ArrayLib for uint256[];
@@ -72,7 +72,7 @@ contract PendleYieldTokenV2 is IPYieldTokenV2, PendleERC20Permit, RewardManager,
         uint8 __decimals,
         uint256 _expiry,
         bool _doCacheIndexSameBlock
-    ) PendleERC20Permit(_name, _symbol, __decimals) {
+    ) PendleERC20(_name, _symbol, __decimals) {
         SY = _SY;
         PT = _PT;
         expiry = _expiry;

package/contracts/interfaces/KelpDAO/IKelpDepositPool.sol

@@ -12,4 +12,6 @@ interface IKelpDepositPool {
     ) external;
 
     function getRsETHAmountToMint(address asset, uint256 amount) external view returns (uint256 rsethAmountToMint);
+
+    function depositETH(uint256 minRSETHAmountExpected, string calldata referralId) external payable;
 }

package/contracts/limit/LimitRouterBase.sol

@@ -320,8 +320,6 @@ abstract contract LimitRouterBase is
         FillOrderParams[] memory params,
         uint256[] memory netSyOuts
     ) internal returns (uint256[] memory toMakers) {
-        // netSyOuts all > 0, guarantee in LimitMath
-
         uint256 len = params.length;
         toMakers = new uint256[](len);
 
@@ -333,6 +331,8 @@ abstract contract LimitRouterBase is
                 totalSy += netSyOuts[r];
             }
 
+            if (totalSy == 0) continue;
+
             if (sharedToken == SY) {
                 for (uint256 i = l; i < r; i++) {
                     _transferOut(SY, params[i].order.receiver, netSyOuts[i]);

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

@@ -317,6 +317,39 @@ interface IExecutorHelper {
         address recipient;
     }
 
+    struct Renzo {
+        address pool;
+        uint256 amount;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct FrxETH {
+        address pool;
+        uint256 amount;
+        address tokenOut;
+    }
+
+    struct SfrxETH {
+        address pool;
+        uint256 amount;
+        address tokenOut;
+        address recipient;
+    }
+
+    struct SfrxETHConvertor {
+        address pool;
+        uint256 isDepositAndAmount; // 1 isDeposit + 127 empty + 128 amount token in
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+    }
+
+    struct OriginETH {
+        address pool;
+        uint256 amount;
+    }
+
     function executeUniswap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
     function executeStableSwap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
@@ -430,4 +463,35 @@ interface IExecutorHelper {
     function executeEthenaSusde(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
     function executeMakersDAI(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeRenzo(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeWBETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeMantleETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeFrxETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeSfrxETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeSfrxETHConvertor(
+        bytes memory data,
+        uint256 flagsAndPrevAmountOut
+    ) external payable returns (uint256);
+
+    function executeSwellETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeRswETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeStaderETHx(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeOriginETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executePrimeETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeMantleUsd(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeBedrockUniETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeMaiPSM(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 }

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

@@ -304,6 +304,12 @@ interface IExecutorHelperL2 {
         address recipient;
     }
 
+    struct FrxETH {
+        address pool;
+        uint256 amount;
+        address tokenOut;
+    }
+
     function executeUniswap(
         uint256 index,
         bytes memory data,
@@ -690,4 +696,13 @@ interface IExecutorHelperL2 {
         bool getPoolOnly,
         address nextPool
     ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeMaiPSM(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
 }