@pendle/core-v2 4.0.4 → 4.0.6

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

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.23;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/EtherFi/IEtherFiLiquidityPool.sol";
+import "../../../../interfaces/EtherFi/IEtherFiWEEth.sol";
+
+contract PendleWEEthSY is SYBase {
+    using PMath for int256;
+
+    address public immutable weETH;
+    address public immutable liquidityPool;
+    address public immutable eETH;
+    address public immutable referee;
+
+    constructor(address _weETH, address _referee) SYBase("SY ether.fi weETH", "SY-weETH", _weETH) {
+        weETH = _weETH;
+        liquidityPool = IEtherFiWEEth(_weETH).liquidityPool();
+        eETH = IEtherFiWEEth(_weETH).eETH();
+        referee = _referee;
+
+        _safeApproveInf(eETH, weETH);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE) {
+            IEtherFiLiquidityPool(liquidityPool).deposit{value: amountDeposited}(referee);
+        }
+        if (tokenIn != weETH) {
+            amountSharesOut = IEtherFiWEEth(weETH).wrap(_selfBalance(eETH));
+        } else {
+            amountSharesOut = amountDeposited;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        if (tokenOut == weETH) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            amountTokenOut = IEtherFiWEEth(weETH).unwrap(amountSharesToRedeem);
+        }
+        _transferOut(tokenOut, receiver, amountTokenOut);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IEtherFiLiquidityPool(liquidityPool).amountForShare(1 ether);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
+        if (tokenIn == weETH) {
+            return amountTokenToDeposit;
+        } else {
+            return IEtherFiLiquidityPool(liquidityPool).sharesForAmount(amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view override returns (uint256) {
+        if (tokenOut == weETH) {
+            return amountSharesToRedeem;
+        } else {
+            return IEtherFiLiquidityPool(liquidityPool).amountForShare(amountSharesToRedeem);
+        }
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(weETH, eETH, NATIVE);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(weETH, eETH);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == NATIVE || token == eETH || token == weETH;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == eETH || token == weETH;
+    }
+
+    function assetInfo() external view override returns (AssetType, address, uint8) {
+        return (AssetType.TOKEN, eETH, 18);
+    }
+}

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

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+import "../../../../interfaces/KelpDAO/IKelpDepositPool.sol";
+import "../../../../interfaces/KelpDAO/IKelpLRTConfig.sol";
+import "../../../../interfaces/IStETH.sol";
+
+contract PendleRsETHSY is SYBase {
+    using ArrayLib for address[];
+
+    address public immutable rsETH;
+    address public immutable depositPool;
+    address public lrtConfig;
+
+    address public exchangeRateOracle;
+
+    address public immutable ETHx; // gas saving purpose only
+    address public immutable stETH; // gas saving purpose only
+
+    event SetNewExchangeRateOracle(address oracle);
+
+    constructor(
+        address _rsETH,
+        address _depositPool,
+        address _exchangeRateOracle,
+        address _ETHx,
+        address _stETH
+    ) SYBase("SY Kelp rsETH", "SY-rsETH", _rsETH) {
+        rsETH = _rsETH;
+        depositPool = _depositPool;
+        exchangeRateOracle = _exchangeRateOracle;
+        ETHx = _ETHx;
+        stETH = _stETH;
+
+        updateLrtConfigAddress();
+        safeApproveSupportedTokens();
+    }
+
+    function updateLrtConfigAddress() public {
+        lrtConfig = IKelpDepositPool(depositPool).lrtConfig();
+    }
+
+    function safeApproveSupportedTokens() public {
+        address[] memory assets = IKelpLRTConfig(lrtConfig).getSupportedAssetList();
+        for (uint256 i = 0; i < assets.length; ) {
+            _safeApproveInf(assets[i], depositPool);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == rsETH) {
+            amountSharesOut = amountDeposited;
+        } else {
+            if (tokenIn == NATIVE) {
+                (tokenIn, amountDeposited) = (stETH, _depositStETH(amountDeposited));
+            }
+            uint256 preBalance = _selfBalance(rsETH);
+            IKelpDepositPool(depositPool).depositAsset(tokenIn, amountDeposited, 0, "pendle"); // TODO: hardcode referral to save gas
+            amountSharesOut = _selfBalance(rsETH) - preBalance;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(rsETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    function _depositStETH(uint256 amountETH) internal returns (uint256 amountStETH) {
+        uint256 amountStEthSharesOut = IStETH(stETH).submit{value: amountETH}(address(0));
+        amountStETH = IStETH(stETH).getPooledEthByShares(amountStEthSharesOut);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return 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 == rsETH) {
+            return amountTokenToDeposit;
+        }
+        if (tokenIn == NATIVE) {
+            tokenIn = stETH;
+        }
+        return IKelpDepositPool(depositPool).getRsETHAmountToMint(tokenIn, 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, NATIVE).merge(IKelpLRTConfig(lrtConfig).getSupportedAssetList());
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(rsETH);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == rsETH || token == NATIVE || token == ETHx || token == stETH || _isSupportedToken(token);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == rsETH;
+    }
+
+    function _isSupportedToken(address token) internal view returns (bool) {
+        return IKelpLRTConfig(lrtConfig).isSupportedAsset(token);
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/libraries/ArrayLib.sol

@@ -37,7 +37,7 @@ library ArrayLib {
         out[length] = element;
     }
 
-    function appendHead(address[] memory inp, address element) internal pure returns (address[] memory out) { 
+    function appendHead(address[] memory inp, address element) internal pure returns (address[] memory out) {
         uint256 length = inp.length;
         out = new address[](length + 1);
         out[0] = element;
@@ -113,6 +113,13 @@ library ArrayLib {
         res[1] = b;
     }
 
+    function create(address a, address b, address c) internal pure returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = a;
+        res[1] = b;
+        res[2] = c;
+    }
+
     function create(uint256 a) internal pure returns (uint256[] memory res) {
         res = new uint256[](1);
         res[0] = a;

package/contracts/interfaces/EtherFi/IEtherFiLiquidityPool.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IEtherFiLiquidityPool {
+    function totalValueOutOfLp() external view returns (uint128);
+    function totalValueInLp() external view returns (uint128);
+    function getTotalEtherClaimOf(address _user) external view returns (uint256);
+    function getTotalPooledEther() external view returns (uint256);
+    function sharesForAmount(uint256 _amount) external view returns (uint256);
+    function sharesForWithdrawalAmount(uint256 _amount) external view returns (uint256);
+    function amountForShare(uint256 _share) external view returns (uint256);
+
+    // function deposit() external payable returns (uint256);
+    function deposit(address _referral) external payable returns (uint256);
+    // function deposit(address _user, address _referral) external payable returns (uint256);
+}

package/contracts/interfaces/EtherFi/IEtherFiWEEth.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IEtherFiWEEth {
+    function wrap(uint256 _eETHAmount) external returns (uint256);
+
+    function unwrap(uint256 _weETHAmount) external returns (uint256);
+
+    function eETH() external view returns (address);
+
+    function liquidityPool() external view returns (address);
+}

package/contracts/interfaces/IPActionAddRemoveLiqV3.sol

@@ -67,9 +67,9 @@ interface IPActionAddRemoveLiqV3 {
         address indexed token,
         address receiver,
         uint256 netTokenIn,
-        uint256 netSyMintPy,
         uint256 netLpOut,
         uint256 netYtOut,
+        uint256 netSyMintPy,
         uint256 netSyInterm
     );
 
@@ -202,6 +202,7 @@ interface IPActionAddRemoveLiqV3 {
         ApproxParams calldata guessPtReceivedFromSy,
         LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee);
+
     function removeLiquiditySingleToken(
         address receiver,
         address market,

package/contracts/interfaces/IPExchangeRateOracle.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPExchangeRateOracle {
+    function getExchangeRate() external view returns (uint256);
+}

package/contracts/interfaces/KelpDAO/IKelpDepositPool.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IKelpDepositPool {
+    function lrtConfig() external view returns (address);
+
+    function depositAsset(
+        address asset,
+        uint256 depositAmount,
+        uint256 minRSETHAmountToReceive,
+        string calldata referralId
+    ) external;
+
+    function getRsETHAmountToMint(address asset, uint256 amount) external view returns (uint256 rsethAmountToMint);
+}

package/contracts/interfaces/KelpDAO/IKelpLRTConfig.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IKelpLRTConfig {
+    function getSupportedAssetList() external view returns (address[] memory);
+
+    function isSupportedAsset(address token) external view returns (bool);
+}

package/contracts/offchain-helpers/BytesLib.sol

@@ -397,7 +397,8 @@ library BytesLib {
 
                 for {
                     let cc := add(_postBytes, 0x20)
-                } eq(add(lt(mc, end), cb), 2) { // while(uint256(mc < end) + cb == 2) // the next line is the loop condition:
+                } eq(add(lt(mc, end), cb), 2) {
+                    // while(uint256(mc < end) + cb == 2) // the next line is the loop condition:
                     mc := add(mc, 0x20)
                     cc := add(cc, 0x20)
                 } {
@@ -462,7 +463,8 @@ library BytesLib {
                     let ccRem := mload(cc)
                     for {
                         let i := 0
-                    } eq(add(lt(i, numTailBytes), cb), 2) { // while(uint256(i < numTailBytes) + cb == 2) // the next line is the loop condition:
+                    } eq(add(lt(i, numTailBytes), cb), 2) {
+                        // while(uint256(i < numTailBytes) + cb == 2) // the next line is the loop condition:
                         i := add(i, 1)
                     } {
                         if iszero(eq(byte(i, mcRem), byte(i, ccRem))) {

package/contracts/offchain-helpers/PendleExchangeRateOracle.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/math/PMath.sol";
+import "../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleExchangeRateOracle is BoringOwnableUpgradeable, IPExchangeRateOracle {
+    using PMath for uint256;
+    using PMath for uint128;
+
+    enum RateRejectReason {
+        RATE_TOO_SMALL,
+        RATE_TOO_LARGE
+    }
+
+    struct ExchangeRateData {
+        uint128 rate;
+        uint64 dataBlock; // the pin block which the data is sampled at
+        uint32 dataTimestamp; // block(dataBlock).timestamp
+        uint32 updatedAt;
+    }
+
+    error RateRejected(uint256 oldRate, uint256 newRate, RateRejectReason reason);
+    error InvalidMetadata(ExchangeRateData data);
+
+    event RateUpdated(ExchangeRateData data);
+
+    uint256 public constant MIN_UPDATE_TIME_GAP = 12 hours;
+
+    string public name;
+    ExchangeRateData public data;
+    uint256 public immutable maxRateDiff;
+
+    constructor(string memory _name, uint256 _maxRateDiff) initializer {
+        name = _name;
+        maxRateDiff = _maxRateDiff;
+
+        __BoringOwnable_init();
+    }
+
+    function getExchangeRate() external view returns (uint256) {
+        return data.rate;
+    }
+
+    function setExchangeRate(uint128 rate, uint64 dataBlock, uint32 dataTimestamp) external onlyOwner {
+        ExchangeRateData memory newData = ExchangeRateData({
+            rate: rate,
+            dataBlock: dataBlock,
+            dataTimestamp: dataTimestamp,
+            updatedAt: uint32(block.timestamp)
+        });
+        _setExchangeRate(newData);
+    }
+
+    function _setExchangeRate(ExchangeRateData memory newData) internal {
+        ExchangeRateData memory oldData = data;
+
+        _validateNewRate(oldData.rate, newData.rate);
+        _validateMetadata(oldData, newData);
+
+        data = newData;
+        emit RateUpdated(newData);
+    }
+
+    function _validateNewRate(uint256 oldRate, uint256 newRate) internal view {
+        if (oldRate > newRate) {
+            revert RateRejected(oldRate, newRate, RateRejectReason.RATE_TOO_SMALL);
+        }
+
+        if (oldRate != 0 && oldRate.mulDown(PMath.ONE + maxRateDiff) < newRate) {
+            revert RateRejected(oldRate, newRate, RateRejectReason.RATE_TOO_LARGE);
+        }
+    }
+
+    function _validateMetadata(ExchangeRateData memory oldData, ExchangeRateData memory newData) internal pure {
+        if (
+            oldData.dataBlock >= newData.dataBlock ||
+            oldData.dataTimestamp >= newData.dataTimestamp ||
+            oldData.updatedAt + MIN_UPDATE_TIME_GAP >= newData.updatedAt
+        ) {
+            revert InvalidMetadata(newData);
+        }
+    }
+}

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

@@ -212,9 +212,12 @@ interface IExecutorHelper {
 
     struct VelocoreV2 {
         address vault;
+        uint256 amount;
         address tokenIn;
         address tokenOut;
-        uint256 amount;
+        address stablePool; // if not empty then use stable pool
+        address wrapToken;
+        bool isConvertFirst;
     }
 
     struct MaticMigrate {
@@ -232,6 +235,46 @@ interface IExecutorHelper {
         address toToken;
     }
 
+    struct BalancerV1 {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+    }
+
+    struct SwaapV2 {
+        address router;
+        uint256 amount;
+        bytes data;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+    }
+
+    struct ArbswapStable {
+        address pool;
+        uint256 dx;
+        uint256 tokenIndexFrom;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct BancorV2 {
+        address pool;
+        address[] swapPath;
+        uint256 amount;
+        address recipient;
+    }
+
+    struct Ambient {
+        address pool;
+        uint128 qty;
+        address base;
+        address quote;
+        uint256 poolIdx;
+        uint8 settleFlags;
+    }
+
     function executeUniswap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
     function executeStableSwap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
@@ -311,4 +354,18 @@ interface IExecutorHelper {
     function executeSolidlyV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
     function executeKokonut(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeBalancerV1(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeSwaapV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeNomiswapStable(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeArbswapStable(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeBancorV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeBancorV3(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeAmbient(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 }

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

@@ -232,9 +232,12 @@ interface IExecutorHelperL2 {
 
     struct VelocoreV2 {
         address vault;
+        uint256 amount;
         address tokenIn;
         address tokenOut;
-        uint256 amount;
+        address stablePool; // if not empty then use stable pool
+        address wrapToken;
+        bool isConvertFirst;
     }
 
     struct MaticMigrate {
@@ -252,6 +255,46 @@ interface IExecutorHelperL2 {
         address toToken;
     }
 
+    struct BalancerV1 {
+        address pool;
+        uint256 amount;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct SwaapV2 {
+        address router;
+        uint256 amount;
+        bytes data;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+    }
+
+    struct ArbswapStable {
+        address pool;
+        uint256 dx;
+        uint256 tokenIndexFrom;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct BancorV2 {
+        address pool;
+        address[] swapPath;
+        uint256 amount;
+        address recipient;
+    }
+
+    struct Ambient {
+        address pool;
+        uint128 qty;
+        address base;
+        address quote;
+        uint256 poolIdx;
+        uint8 settleFlags;
+    }
+
     function executeUniswap(
         uint256 index,
         bytes memory data,
@@ -557,4 +600,67 @@ interface IExecutorHelperL2 {
         bool getPoolOnly,
         address nextPool
     ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeBalancerV1(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeSwaapV2(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeNomiswapStable(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeArbswapStable(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeBancorV2(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeBancorV3(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
+
+    function executeAmbient(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut,
+        address tokenIn,
+        bool getPoolOnly,
+        address nextPool
+    ) external payable returns (address tokenOut, uint256 tokenAmountOut, address pool);
 }