@pendle/core-v2 5.0.7-beta → 5.0.7

package/contracts/core/StandardizedYield/implementations/Pump/PendlePumpHelperLib.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/Pump/IPumpStaking.sol";
+
+library PendlePumpHelperLib {
+    address internal constant PUMP_STAKING = 0x1fCca65fb6Ae3b2758b9b2B394CB227eAE404e1E;
+    address internal constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
+    address internal constant PUMP_BTC = 0xF469fBD2abcd6B9de8E169d128226C0Fc90a012e;
+    uint256 internal constant FEE_DENOM = 10_000;
+
+    function _mintPumpBTC(uint256 amount) internal {
+        IPumpStaking(PUMP_STAKING).stake(amount);
+    }
+
+    function _instantUnstake(uint256 amount) internal {
+        IPumpStaking(PUMP_STAKING).unstakeInstant(amount);
+    }
+
+    function _previewInstantUnstake(uint256 amount) internal view returns (uint256) {
+        bool onlyStakeAllowed = IPumpStaking(PUMP_STAKING).onlyAllowStake();
+        uint256 maxAmountRedeemable = IPumpStaking(PUMP_STAKING).pendingStakeAmount();
+
+        require(
+            !onlyStakeAllowed && amount <= maxAmountRedeemable,
+            "PumpStaking: redeem not allowed"
+        );
+
+        uint256 feeRate = IPumpStaking(PUMP_STAKING).instantUnstakeFee();
+        return amount - amount * feeRate / FEE_DENOM;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Solv/PendleSolvBTCBBNSYUpg.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "./PendleSolvHelper.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleSolvBTCBBNSYUpg is SYBaseUpg {
+    event SetNewExchangeRateOracle(address oracle);
+
+    address public constant WBTC = PendleSolvHelper.WBTC;
+    address public constant SOLV_BTC = PendleSolvHelper.SOLV_BTC_TOKEN;
+    address public constant SOLV_BTCBBN = PendleSolvHelper.SOLV_BTCBBN_TOKEN;
+
+    address public exchangeRateOracle;
+
+    constructor() SYBaseUpg(SOLV_BTCBBN) {}
+
+    function initialize(address _initialExchangeRateOracle) external initializer {
+        __SYBaseUpg_init("SY SolvBTC Babylon", "SY-SolvBTC.BBN");
+        _setExchangeRateOracle(_initialExchangeRateOracle);
+        _safeApproveInf(WBTC, PendleSolvHelper.SOLV_BTC_ROUTER);
+        _safeApproveInf(SOLV_BTC, PendleSolvHelper.SOLV_BTCBBN_ROUTER);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountDeposited;
+        }
+        return PendleSolvHelper._mintBTCBBN(tokenIn, amountDeposited);
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(SOLV_BTCBBN, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    function setExchangeRateOracle(address newOracle) external virtual onlyOwner {
+        _setExchangeRateOracle(newOracle);
+    }
+
+    function _setExchangeRateOracle(address newOracle) internal virtual {
+        exchangeRateOracle = newOracle;
+        emit SetNewExchangeRateOracle(newOracle);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountTokenToDeposit;
+        }
+        return PendleSolvHelper._previewMintBTCBBN(tokenIn, amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(WBTC, SOLV_BTC, SOLV_BTCBBN);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(SOLV_BTCBBN);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == WBTC || token == SOLV_BTC || token == SOLV_BTCBBN;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == SOLV_BTCBBN;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WBTC, IERC20Metadata(WBTC).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Solv/PendleSolvHelper.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/Solv/ISolvRouter.sol";
+import "../../../../interfaces/Solv/ISolvOpenFundMarket.sol";
+import "../../../../interfaces/Solv/ISolvOracle.sol";
+import "../../../../interfaces/Solv/ISolvERC3525.sol";
+
+library PendleSolvHelper {
+    address public constant SOLV_BTCBBN_ROUTER = 0x01024AaeD5561fa6237C0ad4073417576C591261;
+    address public constant SOLV_BTCBBN_TOKEN = 0xd9D920AA40f578ab794426F5C90F6C731D159DEf;
+    bytes32 public constant SOLV_BTCBBN_POOLID = 0xefcca1eb946cdc7b56509489a56b45b75aff74b8bb84dad5b893012157e0df93;
+
+    address public constant SOLV_BTC_ROUTER = 0x1fF7d7C0A7D8E94046708C611DeC5056A9d2B823;
+    address public constant SOLV_BTC_TOKEN = 0x7A56E1C57C7475CCf742a1832B028F0456652F97;
+    bytes32 public constant SOLV_BTC_POOLID = 0x716db7dc196abe78d5349c7166896f674ab978af26ada3e5b3ea74c5a1b48307;
+
+    address public constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
+
+    address public constant SOLV_OPEN_FUND_MARKET = 0x57bB6a8563a8e8478391C79F3F433C6BA077c567;
+
+    function _mintBTCBBN(address tokenIn, uint256 amountIn) internal returns (uint256) {
+        assert(tokenIn == WBTC || tokenIn == SOLV_BTC_TOKEN);
+
+        if (tokenIn == WBTC) {
+            amountIn = ISolvRouter(SOLV_BTC_ROUTER).createSubscription(SOLV_BTC_POOLID, amountIn);
+        }
+        return ISolvRouter(SOLV_BTCBBN_ROUTER).createSubscription(SOLV_BTCBBN_POOLID, amountIn);
+    }
+
+    function _previewMintBTCBBN(address tokenIn, uint256 amountIn) internal view returns (uint256) {
+        assert(tokenIn == WBTC || tokenIn == SOLV_BTC_TOKEN);
+
+        if (tokenIn == WBTC) {
+            amountIn = _convertToShare(WBTC, amountIn);
+        }
+        return _convertToShare(SOLV_BTC_TOKEN, amountIn);
+    }
+
+    function _convertToShare(address tokenIn, uint256 amountIn) internal view returns (uint256) {
+        bytes32 poolId = tokenIn == WBTC ? SOLV_BTC_POOLID : SOLV_BTCBBN_POOLID;
+        ISolvOpenFundMarket.PoolInfo memory info = ISolvOpenFundMarket(SOLV_OPEN_FUND_MARKET).poolInfos(poolId);
+        uint256 numerator = 10 ** ISolvERC3525(info.poolSFTInfo.openFundShare).valueDecimals();
+        (uint256 price, ) = ISolvOracle(info.navOracle).getSubscribeNav(poolId, block.timestamp);
+        return (amountIn * numerator) / price;
+    }
+}

package/contracts/interfaces/Corn/ICornSilo.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+interface ICornSilo {
+    function deposit(address token, uint256 assets) external returns (uint256 shares);
+
+    function redeemToken(address token, uint256 shares) external returns (uint256 assets);
+}

package/contracts/interfaces/IPActionMiscV3.sol

@@ -3,8 +3,6 @@ pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
 import "./IPAllActionTypeV3.sol";
-import "./IStandardizedYield.sol";
-import "./IPMarket.sol";
 
 /*
  *******************************************************************************************************************
@@ -28,14 +26,6 @@ interface IPActionMiscV3 {
         bytes returnData;
     }
 
-    struct RedeemYtIncomeToTokenStruct {
-        IPYieldToken yt;
-        bool doRedeemInterest;
-        bool doRedeemRewards;
-        address tokenRedeemSy;
-        uint256 minTokenRedeemOut;
-    }
-
     struct ExitPreExpReturnParams {
         uint256 netPtFromRemove;
         uint256 netSyFromRemove;
@@ -195,20 +185,6 @@ interface IPActionMiscV3 {
         address[] calldata markets
     ) external;
 
-    function redeemDueInterestAndRewardsV2(
-        IStandardizedYield[] calldata SYs,
-        RedeemYtIncomeToTokenStruct[] calldata YTs,
-        IPMarket[] calldata markets,
-        IPSwapAggregator pendleSwap,
-        SwapDataExtra[] calldata swaps
-    ) external returns (uint256[] memory netOutFromSwaps, uint256[] memory netInterests);
-
-    function swapTokensToTokens(
-        IPSwapAggregator pendleSwap,
-        SwapDataExtra[] calldata swaps,
-        uint256[] calldata netSwaps
-    ) external payable returns (uint256[] memory netOutFromSwaps);
-
     function swapTokenToToken(
         address receiver,
         uint256 minTokenOut,

package/contracts/interfaces/Pump/IPumpStaking.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+interface IPumpStaking {
+    function stake(uint256 amount) external;
+
+    function unstakeInstant(uint256 amount) external;
+
+    function onlyAllowStake() external view returns (bool);
+
+    function instantUnstakeFee() external view returns (uint256);
+
+    function pendingStakeAmount() external view returns (uint256);
+}

package/contracts/interfaces/Solv/ISolvERC3525.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISolvERC3525 {
+    /**
+     * @notice Get the number of decimals the token uses for value - e.g. 6, means the user
+     *  representation of the value of a token can be calculated by dividing it by 1,000,000.
+     *  Considering the compatibility with third-party wallets, this function is defined as
+     *  `valueDecimals()` instead of `decimals()` to avoid conflict with ERC20 tokens.
+     * @return The number of decimals for value
+     */
+    function valueDecimals() external view returns (uint8);
+}

package/contracts/interfaces/Solv/ISolvOpenFundMarket.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISolvOpenFundMarket {
+    struct SFTInfo {
+        address manager;
+        bool isValid;
+    }
+    struct SubscribeLimitInfo {
+        uint256 hardCap;
+        uint256 subscribeMin;
+        uint256 subscribeMax;
+        uint64 fundraisingStartTime;
+        uint64 fundraisingEndTime;
+    }
+    struct PoolSFTInfo {
+        address openFundShare;
+        address openFundRedemption;
+        uint256 openFundShareSlot;
+        uint256 latestRedeemSlot;
+    }
+    struct PoolFeeInfo {
+        uint16 carryRate;
+        address carryCollector;
+        uint64 latestProtocolFeeSettleTime;
+    }
+    struct ManagerInfo {
+        address poolManager;
+        address subscribeNavManager;
+        address redeemNavManager;
+    }
+    struct PoolInfo {
+        PoolSFTInfo poolSFTInfo;
+        PoolFeeInfo poolFeeInfo;
+        ManagerInfo managerInfo;
+        SubscribeLimitInfo subscribeLimitInfo;
+        address vault;
+        address currency;
+        address navOracle;
+        uint64 valueDate;
+        bool permissionless;
+        uint256 fundraisingAmount;
+    }
+
+    function poolInfos(bytes32) external view returns (PoolInfo memory);
+}

package/contracts/interfaces/Solv/ISolvOracle.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface ISolvOracle {
+    function setSubscribeNavOnlyMarket(bytes32 poolId_, uint256 time_, uint256 nav_) external;
+    function updateAllTimeHighRedeemNavOnlyMarket(bytes32 poolId_, uint256 nav_) external;
+    function getSubscribeNav(bytes32 poolId_, uint256 time_) external view returns (uint256 nav_, uint256 navTime_);
+    function getAllTimeHighRedeemNav(bytes32 poolId_) external view returns (uint256);
+}

package/contracts/interfaces/Solv/ISolvRouter.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISolvRouter {
+    function createSubscription(bytes32 poolId_, uint256 currencyAmount_) external returns (uint256 shareValue_);
+}

package/contracts/oracles/PendleBoringOneracle.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../core/libraries/math/PMath.sol";
+import "../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleBoringOneracle is IPExchangeRateOracle {
+    function getExchangeRate() external pure returns (uint256) {
+        return PMath.ONE;
+    }
+}

package/contracts/oracles/PendleBoringSolvBTCOneracle.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../core/libraries/math/PMath.sol";
+import "../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleBoringSolvBTCOneracle is IPExchangeRateOracle {
+    function getExchangeRate() external pure returns (uint256) {
+        return 10 ** 8;
+    }
+}

package/contracts/router/ActionMiscV3.sol

@@ -6,9 +6,6 @@ import "../interfaces/IPActionMiscV3.sol";
 import "../interfaces/IPReflector.sol";
 
 contract ActionMiscV3 is IPActionMiscV3, ActionBase {
-    uint256 private constant NOT_FOUND = type(uint256).max;
-    address private constant SKIP_REDEEM_SY = address(0x1);
-
     function mintSyFromToken(
         address receiver,
         address SY,
@@ -96,75 +93,6 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         }
     }
 
-    /// @dev The interface might change in the future, check with Pendle team before use
-    function redeemDueInterestAndRewardsV2(
-        IStandardizedYield[] calldata SYs,
-        RedeemYtIncomeToTokenStruct[] calldata YTs,
-        IPMarket[] calldata markets,
-        IPSwapAggregator pendleSwap,
-        SwapDataExtra[] calldata swaps
-    ) external returns (uint256[] memory netOutFromSwaps, uint256[] memory netInterests) {
-        netOutFromSwaps = new uint256[](swaps.length);
-        uint256[] memory netSwaps = new uint256[](swaps.length);
-
-        for (uint256 i = 0; i < SYs.length; ++i) {
-            _add(swaps, netSwaps, SYs[i].getRewardTokens(), SYs[i].claimRewards(msg.sender));
-        }
-
-        netInterests = new uint256[](YTs.length);
-        for (uint256 i = 0; i < YTs.length; ++i) {
-            uint256[] memory netRewards;
-            (netInterests[i], netRewards) = YTs[i].yt.redeemDueInterestAndRewards(
-                msg.sender,
-                YTs[i].doRedeemInterest,
-                YTs[i].doRedeemRewards
-            );
-
-            if (YTs[i].doRedeemRewards) _add(swaps, netSwaps, YTs[i].yt.getRewardTokens(), netRewards);
-        }
-
-        for (uint256 i = 0; i < markets.length; ++i) {
-            _add(swaps, netSwaps, markets[i].getRewardTokens(), markets[i].redeemRewards(msg.sender));
-        }
-
-        for (uint256 i = 0; i < swaps.length; ++i) {
-            _transferIn(swaps[i].tokenIn, msg.sender, netSwaps[i]);
-        }
-
-        for (uint256 i = 0; i < YTs.length; ++i) {
-            if (netInterests[i] == 0) continue;
-            IStandardizedYield SY = IStandardizedYield(YTs[i].yt.SY());
-            netInterests[i] = _redeemSyAndAdd(
-                swaps,
-                netSwaps,
-                SY,
-                netInterests[i],
-                YTs[i].tokenRedeemSy,
-                YTs[i].minTokenRedeemOut
-            );
-        }
-
-        for (uint256 i = 0; i < swaps.length; ++i) netOutFromSwaps[i] = _swap(swaps[i], netSwaps[i], pendleSwap, true);
-    }
-
-    /// @dev The interface might change in the future, check with Pendle team before use
-    function swapTokensToTokens(
-        IPSwapAggregator pendleSwap,
-        SwapDataExtra[] calldata swaps,
-        uint256[] calldata netSwaps
-    ) external payable returns (uint256[] memory netOutFromSwaps) {
-        netOutFromSwaps = new uint256[](swaps.length);
-
-        for (uint256 i = 0; i < swaps.length; ++i) {
-            _transferIn(swaps[i].tokenIn, msg.sender, netSwaps[i]);
-        }
-
-        for (uint256 i = 0; i < swaps.length; ++i) {
-            netOutFromSwaps[i] = _swap(swaps[i], netSwaps[i], pendleSwap, false);
-        }
-    }
-
-    /// @dev Deprecated, please use swapTokensToTokens which support unwrapping ETH too
     function swapTokenToToken(
         address receiver,
         uint256 minTokenOut,
@@ -178,7 +106,6 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         _transferOut(inp.tokenMintSy, receiver, netTokenOut);
     }
 
-    /// @dev The interface might change in the future, check with Pendle team before use
     function swapTokenToTokenViaSy(
         address receiver,
         address SY,
@@ -190,6 +117,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
     }
 
+    /// @dev The interface might change in the future, check with Pendle team before use
     function exitPreExpToToken(
         address receiver,
         address market,
@@ -207,6 +135,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         emit ExitPreExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
     }
 
+    /// @dev The interface might change in the future, check with Pendle team before use
     function exitPreExpToSy(
         address receiver,
         address market,
@@ -299,73 +228,6 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         emit ExitPostExpToSy(msg.sender, market, receiver, netLpIn, params);
     }
 
-    function _redeemSyAndAdd(
-        SwapDataExtra[] calldata swaps,
-        uint256[] memory netSwaps,
-        IStandardizedYield SY,
-        uint256 netSyToRedeem,
-        address tokenRedeemSy,
-        uint256 minTokenRedeemSy
-    ) internal returns (uint256 netTokenOut) {
-        _transferFrom(SY, msg.sender, address(SY), netSyToRedeem);
-
-        uint256 index = _find(swaps, tokenRedeemSy);
-        if (index == NOT_FOUND) {
-            return SY.redeem(msg.sender, netSyToRedeem, tokenRedeemSy, minTokenRedeemSy, true);
-        }
-
-        netTokenOut = SY.redeem(address(this), netSyToRedeem, tokenRedeemSy, minTokenRedeemSy, true);
-        netSwaps[index] += netTokenOut;
-    }
-
-    function _add(
-        SwapDataExtra[] calldata swaps,
-        uint256[] memory netSwaps,
-        address[] memory tokens,
-        uint256[] memory amounts
-    ) internal pure {
-        for (uint256 i = 0; i < tokens.length; ++i) {
-            uint256 index = _find(swaps, tokens[i]);
-            if (index == NOT_FOUND) continue;
-
-            netSwaps[index] += amounts[i];
-        }
-    }
-
-    function _swap(
-        SwapDataExtra calldata $,
-        uint256 netSwap,
-        IPSwapAggregator pendleSwap,
-        bool needScale
-    ) internal returns (uint256 netTokenOut) {
-        SwapType swapType = $.swapData.swapType;
-        assert(swapType != SwapType.NONE);
-
-        if (swapType == SwapType.ETH_WETH) {
-            _wrap_unwrap_ETH($.tokenIn, $.tokenOut, netSwap);
-
-            netTokenOut = netSwap;
-        } else {
-            assert($.swapData.needScale == needScale);
-
-            _transferOut($.tokenIn, address(pendleSwap), netSwap);
-
-            uint256 preBalance = _selfBalance($.tokenOut);
-            IPSwapAggregator(pendleSwap).swap($.tokenIn, netSwap, $.swapData);
-            netTokenOut = _selfBalance($.tokenOut) - preBalance;
-        }
-
-        require(netTokenOut >= $.minOut, "Slippage: INSUFFICIENT_TOKEN_OUT");
-        _transferOut($.tokenOut, msg.sender, netTokenOut);
-    }
-
-    function _find(SwapDataExtra[] calldata swaps, address token) internal pure returns (uint256 index) {
-        for (uint256 i = 0; i < swaps.length; ++i) {
-            if (swaps[i].tokenIn == token) return i;
-        }
-        return NOT_FOUND;
-    }
-
     function _exitPostExpToSy(
         bool setReceiverToSy,
         address receiver,

package/contracts/router/swap-aggregator/IPSwapAggregator.sol

@@ -8,13 +8,6 @@ struct SwapData {
     bool needScale;
 }
 
-struct SwapDataExtra {
-    address tokenIn;
-    address tokenOut;
-    uint256 minOut;
-    SwapData swapData;
-}
-
 enum SwapType {
     NONE,
     KYBERSWAP,

package/contracts/router/swap-aggregator/PendleSwap.sol

@@ -6,9 +6,11 @@ import "./IPSwapAggregator.sol";
 import "./kyberswap/l1-contracts/InputScalingHelper.sol";
 import "./kyberswap/l2-contracts/InputScalingHelperL2.sol";
 
-abstract contract PendleSwapBase is IPSwapAggregator, TokenHelper {
+contract PendleSwap is IPSwapAggregator, TokenHelper {
     using Address for address;
 
+    address public immutable KYBER_SCALING_HELPER = 0x2f577A41BeC1BE1152AeEA12e73b7391d15f655D;
+
     function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
         _safeApproveInf(tokenIn, data.extRouter);
         data.extRouter.functionCallWithValue(
@@ -21,36 +23,26 @@ abstract contract PendleSwapBase is IPSwapAggregator, TokenHelper {
         SwapType swapType,
         bytes calldata rawCallData,
         uint256 amountIn
-    ) internal pure returns (bytes memory scaledCallData) {
+    ) internal view returns (bytes memory scaledCallData) {
         if (swapType == SwapType.KYBERSWAP) {
-            scaledCallData = _getKyberScaledInputData(rawCallData, amountIn);
+            bool isSuccess;
+            (isSuccess, scaledCallData) = IKyberScalingHelper(KYBER_SCALING_HELPER).getScaledInputData(
+                rawCallData,
+                amountIn
+            );
+
+            require(isSuccess, "PendleSwap: Kyber scaling failed");
         } else {
             assert(false);
         }
     }
 
-    function _getKyberScaledInputData(
-        bytes calldata rawCallData,
-        uint256 amountIn
-    ) internal pure virtual returns (bytes memory scaledCallData);
-
     receive() external payable {}
 }
 
-contract PendleSwapL1 is PendleSwapBase {
-    function _getKyberScaledInputData(
-        bytes calldata rawCallData,
-        uint256 amountIn
-    ) internal pure override returns (bytes memory) {
-        return InputScalingHelper._getScaledInputData(rawCallData, amountIn);
-    }
-}
-
-contract PendleSwapL2 is PendleSwapBase {
-    function _getKyberScaledInputData(
-        bytes calldata rawCallData,
-        uint256 amountIn
-    ) internal pure override returns (bytes memory) {
-        return InputScalingHelperL2._getScaledInputData(rawCallData, amountIn);
-    }
+interface IKyberScalingHelper {
+    function getScaledInputData(
+        bytes calldata inputData,
+        uint256 newAmount
+    ) external view returns (bool isSuccess, bytes memory data);
 }

package/deployments/1-core.json

@@ -20,17 +20,17 @@
     "governanceProxy": "0x2aD631F72fB16d91c4953A7f4260A97C2fE2f31e",
     "yieldContractFactory": "0x70ee0A6DB4F5a2Dc4d9c0b57bE97B9987e75BAFD",
     "marketFactory": "0x27b1dAcd74688aF24a64BD3C9C1B143118740784",
-    "router": "0xD0715C2bf65a6EE65876F30BAEEc8d57664DAB26",
+    "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
     "routerFacets": {
         "ActionAddRemoveLiqV3": "0xb7631b93189900745Db51d960Ba64b8E6C658843",
         "ActionSwapPTV3": "0xbFA3aAD535e1b996396698f89FFeC7ada0df17E8",
         "ActionSwapYTV3": "0x8903dBFFcA66b3Fbc027aC81912ea64Fa61A5219",
-        "ActionMiscV3": "0xa57c944C85B6D00581A16df82B7356E2DdC5fD7a",
+        "ActionMiscV3": "0x9afd337e41f59e5c2e6f2be05f32e958a4dbcd9a",
         "ActionCallbackV3": "0x997FBC511a8Ad11F84a400feACD66E2A3fa805d2",
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
-    "pendleSwap": "0x0Cc097AC029A7541C4e894c789c7aaa2A9794A29",
+    "pendleSwap": "0x2E6ffA05cd6920dcc0d169efce2F4C96E774eCd2",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xdF3601014686674e53d1Fa52F7602525483F9122",
     "marketFactoryV3": "0x1A6fCc85557BC4fB7B534ed835a03EF056552D52",

package/deployments/1-markets/CORN-LBTC-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY Corn LBTC",
+    "SY": "0x9d6Ec7a7B051B32205F74B140A0fa6f09D7F223E",
+    "YT": "0x1caE47aA3e10A77C55Ee32f8623D6B5ACC947344",
+    "PT": "0x332A8ee60EdFf0a11CF3994b1b846BBC27d3DcD6",
+    "market": "0xCaE62858DB831272A03768f5844cbe1B40bB381f",
+    "expiry": 1735171200,
+    "scalarRoot": "16084248220000000000",
+    "initAnchor": "1041917834000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0x317f54b060e78eb9d2973dce74f2ff58f87f5569e49ee50bc66b944fd3e4c2fa",
+    "deployBlockNumber": 20712332,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/1-markets/CORN-PUMPBTC-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "Corn pumpBTC",
+    "SY": "0x56bb34A12b70046b0a03EE63392C09cdDDAaA430",
+    "YT": "0xABb4F186F67c6517A9caFc54a5B93cFF2Aa4c5Eb",
+    "PT": "0xa76f0C6e5f286bFF151b891d2A0245077F1Ad74c",
+    "market": "0xf8208fB52BA80075aF09840A683143C22DC5B4dd",
+    "expiry": 1735171200,
+    "scalarRoot": "30856137291000000000",
+    "initAnchor": "1019119040000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0xbb9e913006fe76901e1fdd9ac288c2d5a0ad11b0a4fb38c5ff095c0907f34626",
+    "deployBlockNumber": 20824952,
+    "reversedFee": 0.09999999999164011
+}