@pendle/core-v2 2.29.0 → 2.29.2

package/contracts/interfaces/Silo/ISilo.sol

@@ -0,0 +1,317 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+interface ISilo {
+    enum AssetStatus {
+        Undefined,
+        Active,
+        Removed
+    }
+
+    /// @dev Storage struct that holds all required data for a single token market
+    struct AssetStorage {
+        /// @dev Token that represents a share in totalDeposits of Silo
+        address collateralToken;
+        /// @dev Token that represents a share in collateralOnlyDeposits of Silo
+        address collateralOnlyToken;
+        /// @dev Token that represents a share in totalBorrowAmount of Silo
+        address debtToken;
+        /// @dev COLLATERAL: Amount of asset token that has been deposited to Silo with interest earned by depositors.
+        /// It also includes token amount that has been borrowed.
+        uint256 totalDeposits;
+        /// @dev COLLATERAL ONLY: Amount of asset token that has been deposited to Silo that can be ONLY used
+        /// as collateral. These deposits do NOT earn interest and CANNOT be borrowed.
+        uint256 collateralOnlyDeposits;
+        /// @dev DEBT: Amount of asset token that has been borrowed with accrued interest.
+        uint256 totalBorrowAmount;
+    }
+
+    /// @dev Storage struct that holds data related to fees and interest
+    struct AssetInterestData {
+        /// @dev Total amount of already harvested protocol fees
+        uint256 harvestedProtocolFees;
+        /// @dev Total amount (ever growing) of asset token that has been earned by the protocol from
+        /// generated interest.
+        uint256 protocolFees;
+        /// @dev Timestamp of the last time `interestRate` has been updated in storage.
+        uint64 interestRateTimestamp;
+        /// @dev True if asset was removed from the protocol. If so, deposit and borrow functions are disabled
+        /// for that asset
+        AssetStatus status;
+    }
+
+    /// @notice data that InterestModel needs for calculations
+    struct UtilizationData {
+        uint256 totalDeposits;
+        uint256 totalBorrowAmount;
+        /// @dev timestamp of last interest accrual
+        uint64 interestRateTimestamp;
+    }
+
+    /// @dev Shares names and symbols that are generated while asset initialization
+    struct AssetSharesMetadata {
+        /// @dev Name for the collateral shares token
+        string collateralName;
+        /// @dev Symbol for the collateral shares token
+        string collateralSymbol;
+        /// @dev Name for the collateral only (protected collateral) shares token
+        string protectedName;
+        /// @dev Symbol for the collateral only (protected collateral) shares token
+        string protectedSymbol;
+        /// @dev Name for the debt shares token
+        string debtName;
+        /// @dev Symbol for the debt shares token
+        string debtSymbol;
+    }
+
+    /// @notice Emitted when deposit is made
+    /// @param asset asset address that was deposited
+    /// @param depositor wallet address that deposited asset
+    /// @param amount amount of asset that was deposited
+    /// @param collateralOnly type of deposit, true if collateralOnly deposit was used
+    event Deposit(
+        address indexed asset,
+        address indexed depositor,
+        uint256 amount,
+        bool collateralOnly
+    );
+
+    /// @notice Emitted when withdraw is made
+    /// @param asset asset address that was withdrawn
+    /// @param depositor wallet address that deposited asset
+    /// @param receiver wallet address that received asset
+    /// @param amount amount of asset that was withdrew
+    /// @param collateralOnly type of withdraw, true if collateralOnly deposit was used
+    event Withdraw(
+        address indexed asset,
+        address indexed depositor,
+        address indexed receiver,
+        uint256 amount,
+        bool collateralOnly
+    );
+
+    /// @notice Emitted on asset borrow
+    /// @param asset asset address that was borrowed
+    /// @param user wallet address that borrowed asset
+    /// @param amount amount of asset that was borrowed
+    event Borrow(address indexed asset, address indexed user, uint256 amount);
+
+    /// @notice Emitted on asset repay
+    /// @param asset asset address that was repaid
+    /// @param user wallet address that repaid asset
+    /// @param amount amount of asset that was repaid
+    event Repay(address indexed asset, address indexed user, uint256 amount);
+
+    /// @notice Emitted on user liquidation
+    /// @param asset asset address that was liquidated
+    /// @param user wallet address that was liquidated
+    /// @param shareAmountRepaid amount of collateral-share token that was repaid. This is collateral token representing
+    /// ownership of underlying deposit.
+    /// @param seizedCollateral amount of underlying token that was seized by liquidator
+    event Liquidate(
+        address indexed asset,
+        address indexed user,
+        uint256 shareAmountRepaid,
+        uint256 seizedCollateral
+    );
+
+    /// @notice Emitted when the status for an asset is updated
+    /// @param asset asset address that was updated
+    /// @param status new asset status
+    event AssetStatusUpdate(address indexed asset, AssetStatus indexed status);
+
+    /// @return version of the silo contract
+    function VERSION() external returns (uint128); // solhint-disable-line func-name-mixedcase
+
+    /// @notice Synchronize current bridge assets with Silo
+    /// @dev This function needs to be called on Silo deployment to setup all assets for Silo. It needs to be
+    /// called every time a bridged asset is added or removed. When bridge asset is removed, depositing and borrowing
+    /// should be disabled during asset sync.
+    function syncBridgeAssets() external;
+
+    /// @notice Get Silo Repository contract address
+    /// @return Silo Repository contract address
+    function siloRepository() external view returns (address);
+
+    /// @notice Get asset storage data
+    /// @param _asset asset address
+    /// @return AssetStorage struct
+    function assetStorage(address _asset) external view returns (AssetStorage memory);
+
+    /// @notice Get asset interest data
+    /// @param _asset asset address
+    /// @return AssetInterestData struct
+    function interestData(address _asset) external view returns (AssetInterestData memory);
+
+    /// @dev helper method for InterestRateModel calculations
+    function utilizationData(address _asset) external view returns (UtilizationData memory data);
+
+    /// @notice Calculates solvency of an account
+    /// @param _user wallet address for which solvency is calculated
+    /// @return true if solvent, false otherwise
+    function isSolvent(address _user) external view returns (bool);
+
+    /// @notice Returns all initialized (synced) assets of Silo including current and removed bridge assets
+    /// @return assets array of initialized assets of Silo
+    function getAssets() external view returns (address[] memory assets);
+
+    /// @notice Returns all initialized (synced) assets of Silo including current and removed bridge assets
+    /// with corresponding state
+    /// @return assets array of initialized assets of Silo
+    /// @return assetsStorage array of assets state corresponding to `assets` array
+    function getAssetsWithState()
+        external
+        view
+        returns (address[] memory assets, AssetStorage[] memory assetsStorage);
+
+    /// @notice Check if depositing an asset for given account is possible
+    /// @dev Depositing an asset that has been already borrowed (and vice versa) is disallowed
+    /// @param _asset asset we want to deposit
+    /// @param _depositor depositor address
+    /// @return true if asset can be deposited by depositor
+    function depositPossible(address _asset, address _depositor) external view returns (bool);
+
+    /// @notice Check if borrowing an asset for given account is possible
+    /// @dev Borrowing an asset that has been already deposited (and vice versa) is disallowed
+    /// @param _asset asset we want to deposit
+    /// @param _borrower borrower address
+    /// @return true if asset can be borrowed by borrower
+    function borrowPossible(address _asset, address _borrower) external view returns (bool);
+
+    /// @dev Amount of token that is available for borrowing
+    /// @param _asset asset to get liquidity for
+    /// @return Silo liquidity
+    function liquidity(address _asset) external view returns (uint256);
+
+    /// @notice Deposit `_amount` of `_asset` tokens from `msg.sender` to the Silo
+    /// @param _asset The address of the token to deposit
+    /// @param _amount The amount of the token to deposit
+    /// @param _collateralOnly True if depositing collateral only
+    /// @return collateralAmount deposited amount
+    /// @return collateralShare user collateral shares based on deposited amount
+    function deposit(
+        address _asset,
+        uint256 _amount,
+        bool _collateralOnly
+    ) external returns (uint256 collateralAmount, uint256 collateralShare);
+
+    /// @notice Router function to deposit `_amount` of `_asset` tokens to the Silo for the `_depositor`
+    /// @param _asset The address of the token to deposit
+    /// @param _depositor The address of the recipient of collateral tokens
+    /// @param _amount The amount of the token to deposit
+    /// @param _collateralOnly True if depositing collateral only
+    /// @return collateralAmount deposited amount
+    /// @return collateralShare `_depositor` collateral shares based on deposited amount
+    function depositFor(
+        address _asset,
+        address _depositor,
+        uint256 _amount,
+        bool _collateralOnly
+    ) external returns (uint256 collateralAmount, uint256 collateralShare);
+
+    /// @notice Withdraw `_amount` of `_asset` tokens from the Silo to `msg.sender`
+    /// @param _asset The address of the token to withdraw
+    /// @param _amount The amount of the token to withdraw
+    /// @param _collateralOnly True if withdrawing collateral only deposit
+    /// @return withdrawnAmount withdrawn amount that was transferred to user
+    /// @return withdrawnShare burned share based on `withdrawnAmount`
+    function withdraw(
+        address _asset,
+        uint256 _amount,
+        bool _collateralOnly
+    ) external returns (uint256 withdrawnAmount, uint256 withdrawnShare);
+
+    /// @notice Router function to withdraw `_amount` of `_asset` tokens from the Silo for the `_depositor`
+    /// @param _asset The address of the token to withdraw
+    /// @param _depositor The address that originally deposited the collateral tokens being withdrawn,
+    /// it should be the one initiating the withdrawal through the router
+    /// @param _receiver The address that will receive the withdrawn tokens
+    /// @param _amount The amount of the token to withdraw
+    /// @param _collateralOnly True if withdrawing collateral only deposit
+    /// @return withdrawnAmount withdrawn amount that was transferred to `_receiver`
+    /// @return withdrawnShare burned share based on `withdrawnAmount`
+    function withdrawFor(
+        address _asset,
+        address _depositor,
+        address _receiver,
+        uint256 _amount,
+        bool _collateralOnly
+    ) external returns (uint256 withdrawnAmount, uint256 withdrawnShare);
+
+    /// @notice Borrow `_amount` of `_asset` tokens from the Silo to `msg.sender`
+    /// @param _asset The address of the token to borrow
+    /// @param _amount The amount of the token to borrow
+    /// @return debtAmount borrowed amount
+    /// @return debtShare user debt share based on borrowed amount
+    function borrow(
+        address _asset,
+        uint256 _amount
+    ) external returns (uint256 debtAmount, uint256 debtShare);
+
+    /// @notice Router function to borrow `_amount` of `_asset` tokens from the Silo for the `_receiver`
+    /// @param _asset The address of the token to borrow
+    /// @param _borrower The address that will take the loan,
+    /// it should be the one initiating the borrowing through the router
+    /// @param _receiver The address of the asset receiver
+    /// @param _amount The amount of the token to borrow
+    /// @return debtAmount borrowed amount
+    /// @return debtShare `_receiver` debt share based on borrowed amount
+    function borrowFor(
+        address _asset,
+        address _borrower,
+        address _receiver,
+        uint256 _amount
+    ) external returns (uint256 debtAmount, uint256 debtShare);
+
+    /// @notice Repay `_amount` of `_asset` tokens from `msg.sender` to the Silo
+    /// @param _asset The address of the token to repay
+    /// @param _amount amount of asset to repay, includes interests
+    /// @return repaidAmount amount repaid
+    /// @return burnedShare burned debt share
+    function repay(
+        address _asset,
+        uint256 _amount
+    ) external returns (uint256 repaidAmount, uint256 burnedShare);
+
+    /// @notice Allows to repay in behalf of borrower to execute liquidation
+    /// @param _asset The address of the token to repay
+    /// @param _borrower The address of the user to have debt tokens burned
+    /// @param _amount amount of asset to repay, includes interests
+    /// @return repaidAmount amount repaid
+    /// @return burnedShare burned debt share
+    function repayFor(
+        address _asset,
+        address _borrower,
+        uint256 _amount
+    ) external returns (uint256 repaidAmount, uint256 burnedShare);
+
+    /// @dev harvest protocol fees from an array of assets
+    /// @return harvestedAmounts amount harvested during tx execution for each of silo asset
+    function harvestProtocolFees() external returns (uint256[] memory harvestedAmounts);
+
+    /// @notice Function to update interests for `_asset` token since the last saved state
+    /// @param _asset The address of the token to be updated
+    /// @return interest accrued interest
+    function accrueInterest(address _asset) external returns (uint256 interest);
+
+    /// @notice this methods does not requires to have tokens in order to liquidate user
+    /// @dev during liquidation process, msg.sender will be notified once all collateral will be send to him
+    /// msg.sender needs to be `IFlashLiquidationReceiver`
+    /// @param _users array of users to liquidate
+    /// @param _flashReceiverData this data will be forward to msg.sender on notification
+    /// @return assets array of all processed assets (collateral + debt, including removed)
+    /// @return receivedCollaterals receivedCollaterals[userId][assetId] => amount
+    /// amounts of collaterals send to `_flashReceiver`
+    /// @return shareAmountsToRepaid shareAmountsToRepaid[userId][assetId] => amount
+    /// required amounts of debt to be repaid
+    function flashLiquidate(
+        address[] memory _users,
+        bytes memory _flashReceiverData
+    )
+        external
+        returns (
+            address[] memory assets,
+            uint256[][] memory receivedCollaterals,
+            uint256[][] memory shareAmountsToRepaid
+        );
+}

package/contracts/interfaces/Silo/ISiloIncentiveController.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity ^0.8.0;
+
+interface ISiloIncentiveController {
+    /**
+     * @dev Claims reward for msg.sender, on all the assets of the lending pool, accumulating the pending rewards
+     * @param amount Amount of rewards to claim
+     * @return Rewards claimed
+     */
+    function claimRewardsToSelf(
+        address[] calldata assets,
+        uint256 amount
+    ) external returns (uint256);
+
+    /**
+     * @dev for backward compatibility with previous implementation of the Incentives controller
+     */
+    function REWARD_TOKEN() external view returns (address); // solhint-disable-line func-name-mixedcase
+}

package/contracts/interfaces/Silo/ISiloLens.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity ^0.8.0;
+
+interface ISiloLens {
+    function totalDepositsWithInterest(
+        address _silo,
+        address _asset
+    ) external view returns (uint256 _totalDeposits);
+}

package/contracts/interfaces/Stader/IStaderStakeManager.sol

@@ -0,0 +1,57 @@
+pragma solidity 0.8.17;
+
+interface IStaderStakeManager {
+    // Errors
+    error InvalidDepositAmount();
+    error UnsupportedOperation();
+    error InsufficientBalance();
+    error TransferFailed();
+    error PoolIdDoesNotExit();
+    error CooldownNotComplete();
+    error UnsupportedOperationInSafeMode();
+
+    // Events
+    event UpdatedStaderConfig(address staderConfig);
+    event Deposited(address indexed caller, address indexed owner, uint256 assets, uint256 shares);
+    event ExecutionLayerRewardsReceived(uint256 amount);
+    event AuctionedEthReceived(uint256 amount);
+    event ReceivedExcessEthFromPool(uint8 indexed poolId);
+    event TransferredETHToUserWithdrawManager(uint256 amount);
+    event ETHTransferredToPool(uint256 indexed poolId, address poolAddress, uint256 validatorCount);
+    event WithdrawVaultUserShareReceived(uint256 amount);
+    event UpdatedExcessETHDepositCoolDown(uint256 excessETHDepositCoolDown);
+
+    function deposit(address _receiver) external payable returns (uint256);
+
+    function previewDeposit(uint256 _assets) external view returns (uint256);
+
+    function previewWithdraw(uint256 _shares) external view returns (uint256);
+
+    function getExchangeRate() external view returns (uint256);
+
+    function totalAssets() external view returns (uint256);
+
+    function convertToShares(uint256 _assets) external view returns (uint256);
+
+    function convertToAssets(uint256 _shares) external view returns (uint256);
+
+    function maxDeposit() external view returns (uint256);
+
+    function minDeposit() external view returns (uint256);
+
+    function receiveExecutionLayerRewards() external payable;
+
+    function receiveWithdrawVaultUserShare() external payable;
+
+    function receiveEthFromAuction() external payable;
+
+    function receiveExcessEthFromPool(uint8 _poolId) external payable;
+
+    function transferETHToUserWithdrawManager(uint256 _amount) external;
+
+    function validatorBatchDeposit(uint8 _poolId) external;
+
+    function depositETHOverTargetWeight() external;
+
+    function isVaultHealthy() external view returns (bool);
+}

package/contracts/offchain-helpers/ChainlinkRelayerAutomation.sol

@@ -3,7 +3,7 @@ pragma solidity 0.8.17;
 
 import "../core/libraries/BoringOwnableUpgradeable.sol";
 import "../core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol";
-import "@chainlink/contracts/src/v0.8/AutomationCompatible.sol";
+import "@chainlink/contracts/src/v0.8/automation/AutomationCompatible.sol";
 
 contract ChainlinkRelayerAutomation is AutomationCompatible, BoringOwnableUpgradeable {
     PendleChainlinkRelayer internal immutable relayer;

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

@@ -13,7 +13,9 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
     using PYIndexLib for PYIndex;
     using PYIndexLib for IPYieldToken;
 
-    function getMarketState(address market)
+    function getMarketState(
+        address market
+    )
         public
         view
         returns (
@@ -34,11 +36,10 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         marketExchangeRateExcludeFee = getTradeExchangeRateExcludeFee(market, state);
     }
 
-    function getTradeExchangeRateExcludeFee(address market, MarketState memory state)
-        public
-        view
-        returns (uint256)
-    {
+    function getTradeExchangeRateExcludeFee(
+        address market,
+        MarketState memory state
+    ) public view returns (uint256) {
         if (IPMarket(market).isExpired()) return PMath.ONE;
 
         MarketPreCompute memory comp = state.getMarketPreCompute(
@@ -55,11 +56,10 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return preFeeExchangeRate.Uint();
     }
 
-    function getTradeExchangeRateIncludeFee(address market, int256 netPtOut)
-        public
-        view
-        returns (uint256)
-    {
+    function getTradeExchangeRateIncludeFee(
+        address market,
+        int256 netPtOut
+    ) public view returns (uint256) {
         if (IPMarket(market).isExpired()) return PMath.ONE;
 
         int256 netPtToAccount = netPtOut;
@@ -87,21 +87,19 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         }
     }
 
-    function calcPriceImpactPt(address market, int256 netPtOut)
-        public
-        view
-        returns (uint256 priceImpact)
-    {
+    function calcPriceImpactPt(
+        address market,
+        int256 netPtOut
+    ) public view returns (uint256 priceImpact) {
         uint256 preTradeRate = getTradeExchangeRateIncludeFee(market, _getSign(netPtOut));
         uint256 tradedRate = getTradeExchangeRateIncludeFee(market, netPtOut);
         priceImpact = _calculateImpact(preTradeRate, tradedRate);
     }
 
-    function calcPriceImpactYt(address market, int256 netPtOut)
-        public
-        view
-        returns (uint256 priceImpact)
-    {
+    function calcPriceImpactYt(
+        address market,
+        int256 netPtOut
+    ) public view returns (uint256 priceImpact) {
         uint256 ytPreTradeRate = _calcVirtualYTPrice(
             getTradeExchangeRateIncludeFee(market, _getSign(netPtOut))
         );
@@ -111,18 +109,21 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         priceImpact = _calculateImpact(ytPreTradeRate, ytTradedRate);
     }
 
-    function calcPriceImpactPY(address market, int256 netPtOut)
-        public
-        view
-        returns (uint256 priceImpact)
-    {
+    function calcPriceImpactPY(
+        address market,
+        int256 netPtOut
+    ) public view returns (uint256 priceImpact) {
         uint256 ptPreTradeRate = getTradeExchangeRateIncludeFee(market, _getSign(netPtOut));
-        uint256 ytPreTradeRate = _calcVirtualYTPrice(ptPreTradeRate);
         uint256 ptTradeRate = getTradeExchangeRateIncludeFee(market, netPtOut);
-        uint256 ytTradeRate = _calcVirtualYTPrice(ptTradeRate);
 
-        uint256 pyPreTradeRate = ytPreTradeRate.divDown(ptPreTradeRate);
-        uint256 pyTradeRate = ytTradeRate.divDown(ptTradeRate);
+        uint256 ptPreTradePrice = PMath.ONE.divDown(ptPreTradeRate);
+        uint256 ptTradePrice = PMath.ONE.divDown(ptTradeRate);
+
+        uint256 ytPreTradePrice = _calcVirtualYTPrice(ptPreTradeRate);
+        uint256 ytTradePrice = _calcVirtualYTPrice(ptTradeRate);
+
+        uint256 pyPreTradeRate = ytPreTradePrice.divDown(ptPreTradePrice);
+        uint256 pyTradeRate = ytTradePrice.divDown(ptTradePrice);
         priceImpact = _calculateImpact(pyPreTradeRate, pyTradeRate);
     }
 
@@ -177,11 +178,9 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return lnImpliedRate.exp();
     }
 
-    function _calcVirtualYTPrice(uint256 ptAssetExchangeRate)
-        private
-        pure
-        returns (uint256 ytAssetExchangeRate)
-    {
+    function _calcVirtualYTPrice(
+        uint256 ptAssetExchangeRate
+    ) private pure returns (uint256 ytAssetExchangeRate) {
         // 1 asset = EX pt
         // 1 pt = 1/EX Asset
         // 1 yt + 1/EX Asset = 1 Asset
@@ -194,15 +193,9 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return IPMarket(market).readState(address(this));
     }
 
-    function _readTokens(address market)
-        internal
-        view
-        returns (
-            IStandardizedYield _SY,
-            IPPrincipalToken _PT,
-            IPYieldToken _YT
-        )
-    {
+    function _readTokens(
+        address market
+    ) internal view returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) {
         return IPMarket(market).readTokens();
     }
 
@@ -210,11 +203,10 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return netPtOut > 0 ? int256(1) : int256(-1);
     }
 
-    function _calculateImpact(uint256 rateBefore, uint256 rateTraded)
-        private
-        pure
-        returns (uint256 impact)
-    {
+    function _calculateImpact(
+        uint256 rateBefore,
+        uint256 rateTraded
+    ) private pure returns (uint256 impact) {
         impact = (rateBefore.Int() - rateTraded.Int()).abs().divDown(rateBefore);
     }
 

package/contracts/router/PendleRouterHelper2.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../interfaces/IPAllAction.sol";
+import "../interfaces/IPMarket.sol";
+import "../interfaces/IPRouterHelper.sol";
+import "./base/ActionBaseMintRedeem.sol";
+import "./base/MarketApproxLib.sol";
+import "../interfaces/IAddressProvider.sol";
+
+contract PendleRouterHelper2 is TokenHelper {
+    IPAllAction public immutable ROUTER;
+    address public immutable WETH;
+
+    constructor(address _ROUTER, address _WETH) {
+        ROUTER = IPAllAction(_ROUTER);
+        WETH = _WETH;
+        _safeApproveInf(WETH, address(ROUTER));
+    }
+
+    receive() external payable {}
+
+    /**
+     * @dev all the parameters for this function should be generated in the same way as they are
+     *  generated for the main Router, except that input.tokenIn & swapData should be generated
+     *  for tokenIn == WETH instead of ETH
+     */
+    function mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata input)
+        external
+        payable
+        returns (uint256 netSyOut)
+    {
+        require(input.tokenIn == WETH);
+
+        _transferIn(NATIVE, msg.sender, input.netTokenIn);
+
+        _wrap_unwrap_ETH(NATIVE, WETH, input.netTokenIn);
+        netSyOut = ROUTER.mintSyFromToken(receiver, SY, minSyOut, input);
+    }
+}

package/contracts/router/swap-aggregator/oneinch/OneInchAggregationRouterHelper.sol

@@ -5,11 +5,11 @@ import "./I1inchAggregationRouterV5.sol";
 import "../../../core/libraries/Errors.sol";
 
 abstract contract OneInchAggregationRouterHelper {
-    function _rescaleMinAmount(
-        uint256 minAmount,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (uint256) {
+    function _rescaleMinAmount(uint256 minAmount, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (uint256)
+    {
         return (minAmount * newAmount) / oldAmount;
     }
 
@@ -22,12 +22,8 @@ abstract contract OneInchAggregationRouterHelper {
         bytes memory args = rawCallData[4:];
 
         if (selector == I1inchAggregationRouterV5.uniswapV3SwapTo.selector) {
-            (
-                address payable recipient,
-                uint256 amount,
-                uint256 minReturn,
-                uint256[] memory pools
-            ) = abi.decode(args, (address, uint256, uint256, uint256[]));
+            (address payable recipient, uint256 amount, uint256 minReturn, uint256[] memory pools) =
+                abi.decode(args, (address, uint256, uint256, uint256[]));
 
             amount = newAmount;
             return abi.encodeWithSelector(selector, recipient, amount, minReturn, pools);
@@ -39,28 +35,20 @@ abstract contract OneInchAggregationRouterHelper {
                 I1inchAggregationRouterV5.SwapDescription memory desc,
                 bytes memory permit,
                 bytes memory data
-            ) = abi.decode(
-                    args,
-                    (address, I1inchAggregationRouterV5.SwapDescription, bytes, bytes)
-                );
+            ) = abi.decode(args, (address, I1inchAggregationRouterV5.SwapDescription, bytes, bytes));
 
             desc.amount = newAmount;
             return abi.encodeWithSelector(selector, executor, desc, permit, data);
         }
 
         if (selector == I1inchAggregationRouterV5.unoswapTo.selector) {
-            (
-                address payable recipient,
-                address srcToken,
-                uint256 amount,
-                uint256 minReturn,
-                uint256[] memory pools
-            ) = abi.decode(args, (address, address, uint256, uint256, uint256[]));
+            (address payable recipient, address srcToken, uint256 amount, uint256 minReturn, uint256[] memory pools) =
+                abi.decode(args, (address, address, uint256, uint256, uint256[]));
 
             amount = newAmount;
             return abi.encodeWithSelector(selector, recipient, srcToken, amount, minReturn, pools);
         }
 
-        revert Errors.UnsupportedSelector(1, selector);
+        revert Errors.UnsupportedSelector(2, selector);
     }
 }