@pendle/core-v2 5.0.3 → 5.0.5

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

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/Bedrock/IBedrockUniBTCVault.sol";
+
+contract PendleUniBTCSY is SYBase {
+    address public constant VAULT = 0x047D41F2544B7F63A8e991aF2068a363d210d6Da;
+    address public constant UNIBTC = 0x004E9C3EF86bc1ca1f0bB5C7662861Ee93350568;
+    address public constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
+    address public constant FBTC = 0xC96dE26018A54D51c097160568752c4E3BD6C364;
+
+    constructor() SYBase("SY Bedrock uniBTC", "SY-uniBTC", UNIBTC) {
+        _safeApproveInf(WBTC, VAULT);
+        _safeApproveInf(FBTC, VAULT);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn != UNIBTC) {
+            uint256 preBalance = _selfBalance(UNIBTC);
+            IBedrockUniBTCVault(VAULT).mint(tokenIn, amountDeposited);
+            return _selfBalance(UNIBTC) - preBalance;
+        }
+        return amountDeposited; /// (WBTC & FBTC both have 8 decimals)
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256) {
+        _transferOut(UNIBTC, 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 pure override returns (address[] memory res) {
+        return ArrayLib.create(WBTC, FBTC, UNIBTC);
+    }
+
+    function getTokensOut() public pure override returns (address[] memory res) {
+        return ArrayLib.create(UNIBTC);
+    }
+
+    function isValidTokenIn(address token) public pure override returns (bool) {
+        return token == WBTC || token == FBTC || token == UNIBTC;
+    }
+
+    function isValidTokenOut(address token) public pure override returns (bool) {
+        return token == UNIBTC;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, UNIBTC, IERC20Metadata(UNIBTC).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/EtherFi/PendleEBTCSY.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.23;
+
+import "../PendleERC20SYUpg.sol";
+import "../../../../interfaces/EtherFi/IVedaTeller.sol";
+import "../../../../interfaces/EtherFi/IVedaAccountant.sol";
+
+contract PendleEBTCSY is PendleERC20SYUpg {
+    // solhint-disable immutable-vars-naming
+    // solhint-disable const-name-snakecase
+    // solhint-disable ordering
+
+    address public constant eBTC = 0x657e8C867D8B37dCC18fA4Caead9C45EB088C642;
+    address public constant tBTC = 0x18084fbA666a33d37592fA2633fD49a74DD93a88;
+    address public constant wBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
+    address public constant vedaTeller = 0xe19a43B1b8af6CeE71749Af2332627338B3242D1;
+
+    uint256 public constant ONE_SHARE = 10**8;
+
+    address public immutable vedaAccountant;
+
+    constructor() PendleERC20SYUpg(eBTC) {
+        vedaAccountant = IVedaTeller(vedaTeller).accountant();
+    }
+
+    function approveAllForTeller() external {
+        _safeApproveInf(tBTC, eBTC);
+        _safeApproveInf(wBTC, eBTC);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == eBTC) {
+            return amountDeposited;
+        }
+        return IVedaTeller(vedaTeller).bulkDeposit(tokenIn, amountDeposited, 0, address(this));
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == eBTC) {
+            return amountTokenToDeposit;
+        }
+        uint256 rate = IVedaAccountant(vedaAccountant).getRateInQuoteSafe(tokenIn);
+        amountSharesOut = amountTokenToDeposit * ONE_SHARE / rate;
+    }
+
+    function isValidTokenIn(address token) public pure override returns (bool) {
+        return token == eBTC || token == wBTC || token == tBTC;
+    }
+
+    function getTokensIn() public pure override returns (address[] memory res) {
+        return ArrayLib.create(wBTC, tBTC, eBTC);
+    }
+}

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

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+import "../../../../interfaces/IERC4626.sol";
+import "../../../../interfaces/KelpDAO/IKelpDepositPool.sol";
+import "../../../../interfaces/KelpDAO/IKelpLRTConfig.sol";
+
+contract PendleAgETHSY is SYBase {
+    event SetNewExchangeRateOracle(address oracle);
+
+    // solhint-disable immutable-vars-naming
+    // solhint-disable const-name-snakecase
+    address public constant ETH_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    address public constant agETH = 0xe1B4d34E8754600962Cd944B535180Bd758E6c2e;
+    address public constant rsETH = 0xA1290d69c65A6Fe4DF752f95823fae25cB99e5A7;
+    address public constant depositPool = 0x036676389e48133B63a802f8635AD39E752D375D;
+    address public exchangeRateOracle = 0x7A05D25E91C478EFFd37Baf86730bB4B84bE1E32;
+
+    constructor() SYBase("SY Kelp Gain", "SY-agETH", agETH) {
+        _safeApproveInf(rsETH, agETH);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == agETH) {
+            return amountDeposited;
+        } else {
+            if (tokenIn == NATIVE) {
+                IKelpDepositPool(depositPool).depositETH{value: amountDeposited}(
+                    0,
+                    "c05f6902ec7c7434ceb666010c16a63a2e3995aad11f1280855b26402194346b"
+                );
+                (amountDeposited, tokenIn) = (_selfBalance(rsETH), rsETH);
+            }
+            return IERC4626(agETH).deposit(amountDeposited, address(this));
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(agETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IERC4626(agETH).convertToAssets(IPExchangeRateOracle(exchangeRateOracle).getExchangeRate());
+    }
+
+    function setExchangeRateOracle(address newOracle) external onlyOwner {
+        exchangeRateOracle = newOracle;
+        emit SetNewExchangeRateOracle(newOracle);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            (tokenIn, amountTokenToDeposit) = (
+                rsETH,
+                IKelpDepositPool(depositPool).getRsETHAmountToMint(ETH_TOKEN, amountTokenToDeposit)
+            );
+        }
+        if (tokenIn == rsETH) {
+            return IERC4626(agETH).previewDeposit(amountTokenToDeposit);
+        }
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(rsETH, agETH, NATIVE);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(agETH);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == rsETH || token == agETH || token == NATIVE;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == agETH;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Sophon/PendleSophonPointManager.sol

@@ -19,7 +19,7 @@ contract PendleSophonPointManager is PendleERC20, BoringOwnableUpgradeable, IPSo
         address _sophonFarming,
         uint256 _pid,
         address _sy
-    ) PendleERC20("Sophon Point Receipt Token", __getSpointSymbol(_pid), 18) initializer {
+    ) PendleERC20("Pendle Sophon Point Receipt Token", __getSpointSymbol(_pid), 18) initializer {
         sophonFarming = _sophonFarming;
         pid = _pid;
         sy = _sy;

package/contracts/interfaces/Bedrock/IBedrockUniBTCVault.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IBedrockUniBTCVault {
+    function caps(address token) external view returns (uint256);
+
+    function mint(address _token, uint256 _amount) external;
+}

package/contracts/interfaces/IPActionMarketAuxStatic.sol

@@ -28,6 +28,14 @@ interface IPActionMarketAuxStatic {
 
     function getTradeExchangeRateIncludeFee(address market, int256 netPtOut) external view returns (uint256);
 
+    function getYieldTokenAndPtRate(
+        address market
+    ) external view returns (address yieldToken, uint256 netPtOut, uint256 netYieldTokenOut);
+
+    function getYieldTokenAndYtRate(
+        address market
+    ) external view returns (address yieldToken, uint256 netYtOut, uint256 netYieldTokenOut);
+
     function getLpToSyRate(address market) external view returns (uint256);
 
     function getPtToSyRate(address market) external view returns (uint256);

package/contracts/offchain-helpers/PendlePoolDeployHelper.sol

@@ -112,5 +112,24 @@ contract PendlePoolDeployHelper is TokenHelper {
         _transferOut(YT, msg.sender, amountPY);
     }
 
+    function redeployMarket(
+        address oldMarket,
+        uint256 amountLp,
+        uint80 lnFeeRateRoot,
+        int256 scalarRoot,
+        int256 initialRateAnchor
+    ) external returns (address newMarket) {
+        (, IPPrincipalToken PT, ) = IPMarket(oldMarket).readTokens();
+        newMarket = IPMarketFactoryV3(marketFactory).createNewMarket(
+            address(PT),
+            scalarRoot,
+            initialRateAnchor,
+            lnFeeRateRoot
+        );
+        _transferFrom(IERC20(oldMarket), msg.sender, oldMarket, amountLp);
+        (uint256 netSyOut, uint256 netPtOut) = IPMarketV3(oldMarket).burn(newMarket, newMarket, amountLp);
+        IPMarketV3(newMarket).mint(msg.sender, netSyOut, netPtOut);
+    }
+
     receive() external payable {}
 }

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

@@ -4,6 +4,7 @@ pragma solidity ^0.8.17;
 import "../../../interfaces/IPMarket.sol";
 import "../../../interfaces/IPRouterStatic.sol";
 import "./StorageLayout.sol";
+import "hardhat/console.sol";
 
 contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
     using MarketMathCore for MarketState;
@@ -101,6 +102,87 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         priceImpact = _calculateImpact(pyPreTradeRate, pyTradeRate);
     }
 
+    /**
+     * @notice get the rate of yieldToken & PT
+     * @return yieldToken the address of yieldToken
+     * @return netPtOut the amount of PT that can be swapped from 1 yieldToken (10**yieldToken.decimals()). If can't swap, return type(uint256).max
+     * @return netYieldTokenOut the amount of yieldToken that can be swapped from 1 PT (10**PT.decimals()). If can't swap, return type(uint256).max
+     */
+    function getYieldTokenAndPtRate(
+        address market
+    ) public view returns (address yieldToken, uint256 netPtOut, uint256 netYieldTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, ) = _readTokens(market);
+        yieldToken = SY.yieldToken();
+        uint256 yieldDecimals = IERC20Metadata(yieldToken).decimals();
+        uint256 ptDecimals = PT.decimals();
+
+        try IPRouterStatic(address(this)).swapExactTokenForPtStatic(market, yieldToken, 10 ** yieldDecimals) returns (
+            uint256 netPtOutRet,
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        ) {
+            netPtOut = netPtOutRet;
+        } catch {
+            netPtOut = type(uint256).max;
+        }
+
+        try IPRouterStatic(address(this)).swapExactPtForTokenStatic(market, 10 ** ptDecimals, yieldToken) returns (
+            uint256 netYieldTokenOutRet,
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        ) {
+            netYieldTokenOut = netYieldTokenOutRet;
+        } catch {
+            netYieldTokenOut = type(uint256).max;
+        }
+    }
+
+    /**
+     * @notice get the rate of yieldToken & YT
+     * @return yieldToken the address of yieldToken
+     * @return netYtOut the amount of YT that can be swapped from 1 yieldToken (10**yieldToken.decimals()). If can't swap, return type(uint256).max
+     * @return netYieldTokenOut the amount of yieldToken that can be swapped from 1 YT (10**YT.decimals()). If can't swap, return type(uint256).max
+     */
+    function getYieldTokenAndYtRate(
+        address market
+    ) public view returns (address yieldToken, uint256 netYtOut, uint256 netYieldTokenOut) {
+        (IStandardizedYield SY, , IPYieldToken YT) = _readTokens(market);
+        yieldToken = SY.yieldToken();
+        uint256 yieldDecimals = IERC20Metadata(yieldToken).decimals();
+        uint256 ytDecimals = YT.decimals();
+
+        try IPRouterStatic(address(this)).swapExactTokenForYtStatic(market, yieldToken, 10 ** yieldDecimals) returns (
+            uint256 netYtOutRet,
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        ) {
+            netYtOut = netYtOutRet;
+        } catch {
+            netYtOut = type(uint256).max;
+        }
+
+        try IPRouterStatic(address(this)).swapExactYtForTokenStatic(market, 10 ** ytDecimals, yieldToken) returns (
+            uint256 netYieldTokenOutRet,
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        ) {
+            netYieldTokenOut = netYieldTokenOutRet;
+        } catch {
+            netYieldTokenOut = type(uint256).max;
+        }
+    }
+
     function getLpToSyRate(address market) public view returns (uint256) {
         (IStandardizedYield SY, , ) = _readTokens(market);
         return getLpToAssetRate(market).divDown(SY.exchangeRate());

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

@@ -5,9 +5,8 @@ import "../../core/libraries/TokenHelper.sol";
 import "./IPSwapAggregator.sol";
 import "./kyberswap/l1-contracts/InputScalingHelper.sol";
 import "./kyberswap/l2-contracts/InputScalingHelperL2.sol";
-import "./oneinch/OneInchAggregationRouterHelper.sol";
 
-abstract contract PendleSwapBase is IPSwapAggregator, TokenHelper, OneInchAggregationRouterHelper {
+abstract contract PendleSwapBase is IPSwapAggregator, TokenHelper {
     using Address for address;
 
     function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
@@ -25,8 +24,6 @@ abstract contract PendleSwapBase is IPSwapAggregator, TokenHelper, OneInchAggreg
     ) internal pure returns (bytes memory scaledCallData) {
         if (swapType == SwapType.KYBERSWAP) {
             scaledCallData = _getKyberScaledInputData(rawCallData, amountIn);
-        } else if (swapType == SwapType.ONE_INCH) {
-            scaledCallData = _get1inchScaledInputData(rawCallData, amountIn);
         } else {
             assert(false);
         }

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

@@ -3,6 +3,20 @@
 pragma solidity >=0.6.12;
 
 interface IAggregationExecutor {
+    struct Swap {
+        bytes data;
+        bytes32 selectorAndFlags; // [selector (32 bits) + empty (192 bits) + flags (32 bits)]; selector is 4 most significant bytes; flags are stored in 4 least significant bytes.
+    }
+
+    struct SwapExecutorDescription {
+        Swap[][] swapSequences;
+        address tokenIn;
+        address tokenOut;
+        address to;
+        uint256 deadline;
+        bytes positiveSlippageData;
+    }
+
     function callBytes(bytes calldata data) external payable; // 0xd9c45357
 
     // callbytes per swap sequence