@pendle/core-v2 1.3.0-mainnet → 2.0.0-mainnet

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/interfaces/IMetaAggregationRouterV2.sol/IMetaAggregationRouterV2.json

@@ -0,0 +1,215 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "IMetaAggregationRouterV2",
+  "sourceName": "contracts/router/swap-aggregator/kyberswap/interfaces/IMetaAggregationRouterV2.sol",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "address",
+              "name": "callTarget",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "approveTarget",
+              "type": "address"
+            },
+            {
+              "internalType": "bytes",
+              "name": "targetData",
+              "type": "bytes"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IERC20",
+                  "name": "srcToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "contract IERC20",
+                  "name": "dstToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address[]",
+                  "name": "srcReceivers",
+                  "type": "address[]"
+                },
+                {
+                  "internalType": "uint256[]",
+                  "name": "srcAmounts",
+                  "type": "uint256[]"
+                },
+                {
+                  "internalType": "address[]",
+                  "name": "feeReceivers",
+                  "type": "address[]"
+                },
+                {
+                  "internalType": "uint256[]",
+                  "name": "feeAmounts",
+                  "type": "uint256[]"
+                },
+                {
+                  "internalType": "address",
+                  "name": "dstReceiver",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minReturnAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "flags",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "permit",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct IMetaAggregationRouterV2.SwapDescriptionV2",
+              "name": "desc",
+              "type": "tuple"
+            },
+            {
+              "internalType": "bytes",
+              "name": "clientData",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IMetaAggregationRouterV2.SwapExecutionParams",
+          "name": "execution",
+          "type": "tuple"
+        }
+      ],
+      "name": "swap",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IAggregationExecutor",
+          "name": "caller",
+          "type": "address"
+        },
+        {
+          "components": [
+            {
+              "internalType": "contract IERC20",
+              "name": "srcToken",
+              "type": "address"
+            },
+            {
+              "internalType": "contract IERC20",
+              "name": "dstToken",
+              "type": "address"
+            },
+            {
+              "internalType": "address[]",
+              "name": "srcReceivers",
+              "type": "address[]"
+            },
+            {
+              "internalType": "uint256[]",
+              "name": "srcAmounts",
+              "type": "uint256[]"
+            },
+            {
+              "internalType": "address[]",
+              "name": "feeReceivers",
+              "type": "address[]"
+            },
+            {
+              "internalType": "uint256[]",
+              "name": "feeAmounts",
+              "type": "uint256[]"
+            },
+            {
+              "internalType": "address",
+              "name": "dstReceiver",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "amount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "minReturnAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "flags",
+              "type": "uint256"
+            },
+            {
+              "internalType": "bytes",
+              "name": "permit",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IMetaAggregationRouterV2.SwapDescriptionV2",
+          "name": "desc",
+          "type": "tuple"
+        },
+        {
+          "internalType": "bytes",
+          "name": "executorData",
+          "type": "bytes"
+        },
+        {
+          "internalType": "bytes",
+          "name": "clientData",
+          "type": "bytes"
+        }
+      ],
+      "name": "swapSimpleMode",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgReceiverAppUpg.sol

@@ -24,7 +24,6 @@ abstract contract PendleMsgReceiverAppUpg is IPMsgReceiverApp {
 
     function executeMessage(bytes calldata message)
         external
-        payable
         virtual
         onlyFromPendleMsgReceiveEndpoint
     {

package/contracts/LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol

@@ -5,20 +5,18 @@ library LayerZeroHelper {
     uint256 constant EVM_ADDRESS_SIZE = 20;
 
     function _getLayerZeroChainIds(uint256 chainId) internal pure returns (uint16) {
-        if (chainId == 43113) return 10106;
-        // fuji testnet
-        else if (chainId == 80001) return 10109;
-        // mumbai testnet
-        else if (chainId == 43114) return 106; // avax mainnet
+        if (chainId == 43113) return 10106; // fuji testnet
+        else if (chainId == 80001) return 10109; // mumbai testnet
+        else if (chainId == 43114) return 106;  // avax mainnet
+        else if (chainId == 42161) return 110; // arbitrum one
         assert(false);
     }
 
     function _getOriginalChainIds(uint16 chainId) internal pure returns (uint256) {
-        if (chainId == 10106) return 43113;
-        // fuji testnet
-        else if (chainId == 10109) return 80001;
-        // mumbai testnet
+        if (chainId == 10106) return 43113; // fuji testnet
+        else if (chainId == 10109) return 80001; // mumbai testnet
         else if (chainId == 106) return 43114; // avax mainnet
+        else if (chainId == 110) return 42161; // arbitrum one
         assert(false);
     }
 

package/contracts/core/StandardizedYield/StEthHelper.sol

@@ -7,9 +7,9 @@ import "../../interfaces/IStETH.sol";
 import "../libraries/TokenHelper.sol";
 
 abstract contract StEthHelper is TokenHelper {
-    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
-    address public constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
-    address public constant STETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
+    address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+    address internal constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
+    address internal constant STETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
 
     constructor() {
         _safeApproveInf(STETH, WSTETH);
@@ -39,7 +39,7 @@ abstract contract StEthHelper is TokenHelper {
         returns (uint256 amountTokenOut)
     {
         amountTokenOut = IWstETH(WSTETH).unwrap(amountRedeem);
-        _transferOut(STETH, receiver, amountTokenOut);
+        if (receiver != address(this)) _transferOut(STETH, receiver, amountTokenOut);
     }
 
     /// @dev tokenIn must be either ETH, WETH or STETH

package/contracts/core/StandardizedYield/implementations/GLP/GLPPreviewHelper.sol

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "../../../../interfaces/GMX/IGMXVault.sol";
+import "../../../../interfaces/GMX/IVaultPriceFeed.sol";
+
+abstract contract GLPPreviewHelper {
+    // Based on Vault functions
+
+    IGMXVault public immutable vault;
+    address internal immutable usdg;
+    uint256 public constant PRICE_PRECISION = 10**30;
+    uint256 public constant BASIS_POINTS_DIVISOR = 10000;
+
+    constructor(address _vaultAddress) {
+        vault = IGMXVault(_vaultAddress);
+        usdg = vault.usdg();
+    }
+
+    function _buyUSDG(address _token, uint256 tokenAmount) internal view returns (uint256) {
+        tokenAmount = __transferIn(_token, tokenAmount);
+        assert(tokenAmount > 0);
+
+        uint256 price = vault.getMinPrice(_token);
+
+        uint256 usdgAmount = (tokenAmount * price) / PRICE_PRECISION;
+        usdgAmount = vault.adjustForDecimals(usdgAmount, _token, usdg);
+        require(usdgAmount > 0, "preview buyUSDG: usdgAmount must be > 0");
+
+        uint256 feeBasisPoints = __getFeeBasisPoints(
+            _token,
+            usdgAmount,
+            0,
+            vault.mintBurnFeeBasisPoints(),
+            vault.taxBasisPoints(),
+            true
+        );
+        uint256 amountAfterFees = __collectSwapFees(_token, tokenAmount, feeBasisPoints);
+        uint256 mintAmount = (amountAfterFees * price) / PRICE_PRECISION;
+        mintAmount = vault.adjustForDecimals(mintAmount, _token, usdg);
+
+        return mintAmount;
+    }
+
+    function _sellUSDG(address _token, uint256 usdgAmount) internal view returns (uint256) {
+        usdgAmount = __transferIn(usdg, usdgAmount);
+        assert(usdgAmount > 0);
+
+        uint256 redemptionAmount = vault.getRedemptionAmount(_token, usdgAmount);
+        require(redemptionAmount > 0, "preview sellUSDG: redemptionAmount must be > 0");
+
+        uint256 feeBasisPoints = __getFeeBasisPoints(
+            _token,
+            usdgAmount,
+            usdgAmount,
+            vault.mintBurnFeeBasisPoints(),
+            vault.taxBasisPoints(),
+            false
+        );
+        uint256 amountOut = __collectSwapFees(_token, redemptionAmount, feeBasisPoints);
+        require(amountOut > 0, "preview sellUSDG: amountOut must be > 0");
+
+        return amountOut;
+    }
+
+    function __transferIn(address _token, uint256 _amount) private view returns (uint256) {
+        uint256 prevBalance = vault.tokenBalances(_token);
+        uint256 nextBalance = IERC20(_token).balanceOf(address(vault)) + _amount;
+
+        return nextBalance - prevBalance;
+    }
+
+    function __collectSwapFees(
+        address, /*_token*/
+        uint256 _amount,
+        uint256 _feeBasisPoints
+    ) private pure returns (uint256) {
+        uint256 afterFeeAmount = (_amount * (BASIS_POINTS_DIVISOR - _feeBasisPoints)) /
+            (BASIS_POINTS_DIVISOR);
+        return afterFeeAmount;
+    }
+
+    function __getFeeBasisPoints(
+        address _token,
+        uint256 _usdgDelta,
+        uint256 _burnedUsdg,
+        uint256 _feeBasisPoints,
+        uint256 _taxBasisPoints,
+        bool _increment
+    ) private view returns (uint256) {
+        if (!vault.hasDynamicFees()) {
+            return _feeBasisPoints;
+        }
+
+        uint256 initialAmount = vault.usdgAmounts(_token);
+        initialAmount = (initialAmount >= _burnedUsdg) ? initialAmount - _burnedUsdg : 0;
+
+        uint256 nextAmount = initialAmount + _usdgDelta;
+        if (!_increment) {
+            nextAmount = _usdgDelta > initialAmount ? 0 : initialAmount - _usdgDelta;
+        }
+
+        uint256 targetAmount = __getTargetUsdgAmount(_token, _burnedUsdg);
+        if (targetAmount == 0) {
+            return _feeBasisPoints;
+        }
+
+        uint256 initialDiff = initialAmount > targetAmount
+            ? initialAmount - targetAmount
+            : targetAmount - initialAmount;
+        uint256 nextDiff = nextAmount > targetAmount
+            ? nextAmount - targetAmount
+            : targetAmount - nextAmount;
+
+        // action improves relative asset balance
+        if (nextDiff < initialDiff) {
+            uint256 rebateBps = (_taxBasisPoints * initialDiff) / targetAmount;
+            return rebateBps > _feeBasisPoints ? 0 : _feeBasisPoints - rebateBps;
+        }
+
+        uint256 averageDiff = (initialDiff + nextDiff) / 2;
+        if (averageDiff > targetAmount) {
+            averageDiff = targetAmount;
+        }
+        uint256 taxBps = (_taxBasisPoints * averageDiff) / targetAmount;
+        return _feeBasisPoints + taxBps;
+    }
+
+    function __getTargetUsdgAmount(address _token, uint256 _burnedUsdg)
+        private
+        view
+        returns (uint256)
+    {
+        uint256 supply = IERC20(usdg).totalSupply() - _burnedUsdg;
+        if (supply == 0) {
+            return 0;
+        }
+        uint256 weight = vault.tokenWeights(_token);
+        return (weight * supply) / vault.totalTokenWeights();
+    }
+}

package/contracts/core/StandardizedYield/implementations/GLP/PendleGlpSY.sol

@@ -0,0 +1,222 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "./GLPPreviewHelper.sol";
+import "../../../libraries/ArrayLib.sol";
+import "../../../../interfaces/GMX/IRewardRouterV2.sol";
+import "../../../../interfaces/GMX/IGlpManager.sol";
+import "../../../../interfaces/GMX/IGMXVault.sol";
+
+contract PendleGlpSY is SYBaseWithRewards, GLPPreviewHelper {
+    using ArrayLib for address[];
+
+    address public immutable glp;
+    address public immutable stakedGlp;
+    address public immutable rewardRouter;
+    address public immutable glpRouter;
+    address public immutable glpManager;
+    address public immutable weth;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _glp,
+        address _fsGlp,
+        address _stakedGlp,
+        address _rewardRouter,
+        address _glpRouter,
+        address _vault
+    ) SYBaseWithRewards(_name, _symbol, _fsGlp) GLPPreviewHelper(_vault) {
+        glp = _glp;
+        stakedGlp = _stakedGlp;
+        rewardRouter = _rewardRouter;
+        glpRouter = _glpRouter;
+        glpManager = IRewardRouterV2(glpRouter).glpManager();
+        weth = IRewardRouterV2(glpRouter).weth();
+
+        approveAllWhitelisted();
+    }
+
+    function approveAllWhitelisted() public {
+        uint256 length = vault.allWhitelistedTokensLength();
+        for (uint256 i = 0; i < length; ++i) {
+            address token = vault.allWhitelistedTokens(i);
+            if (vault.whitelistedTokens(token)) {
+                _safeApproveInf(token, glpManager);
+            }
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SYBase-_deposit}
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == stakedGlp) {
+            // GLP is already staked in stakedGlp's transferFrom, called in _transferIn()
+            amountSharesOut = amountDeposited;
+        } else if (tokenIn == NATIVE) {
+            amountSharesOut = IRewardRouterV2(glpRouter).mintAndStakeGlpETH{ value: msg.value }(
+                0,
+                0
+            );
+        } else {
+            amountSharesOut = IRewardRouterV2(glpRouter).mintAndStakeGlp(
+                tokenIn,
+                amountDeposited,
+                0,
+                0
+            );
+        }
+    }
+
+    /**
+     * @dev See {SYBase-_redeem}
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == stakedGlp) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(tokenOut, receiver, amountTokenOut);
+        } else if (tokenOut == NATIVE) {
+            amountTokenOut = IRewardRouterV2(glpRouter).unstakeAndRedeemGlpETH(
+                amountSharesToRedeem,
+                0,
+                payable(receiver)
+            );
+        } else {
+            amountTokenOut = IRewardRouterV2(glpRouter).unstakeAndRedeemGlp(
+                tokenOut,
+                amountSharesToRedeem,
+                0,
+                receiver
+            );
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev 1 SY = 1 GLP
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return Math.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = weth;
+    }
+
+    function _redeemExternalReward() internal override {
+        IRewardRouterV2(rewardRouter).handleRewards(false, false, true, true, false, true, false);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == stakedGlp) amountSharesOut = amountTokenToDeposit;
+        else {
+            if (tokenIn == NATIVE) tokenIn = weth;
+
+            // Based on GlpManager's _addLiquidity
+            uint256 aumInUsdg = IGlpManager(glpManager).getAumInUsdg(true);
+            uint256 glpSupply = IERC20(glp).totalSupply();
+            uint256 usdgAmount = super._buyUSDG(tokenIn, amountTokenToDeposit);
+
+            uint256 mintAmount = aumInUsdg == 0
+                ? usdgAmount
+                : (usdgAmount * glpSupply) / aumInUsdg;
+            amountSharesOut = mintAmount;
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == stakedGlp) amountTokenOut = amountSharesToRedeem;
+        else {
+            if (tokenOut == NATIVE) tokenOut = weth;
+
+            // Based on GlpManager's _removeLiquidity
+            uint256 aumInUsdg = IGlpManager(glpManager).getAumInUsdg(false);
+            uint256 glpSupply = IERC20(glp).totalSupply();
+
+            uint256 usdgAmount = (amountSharesToRedeem * aumInUsdg) / glpSupply;
+            uint256 amountOut = super._sellUSDG(tokenOut, usdgAmount);
+
+            amountTokenOut = amountOut;
+        }
+    }
+
+    function _getGlpWhitelistedTokens() internal view returns (address[] memory res) {
+        res = new address[](0);
+        uint256 length = vault.allWhitelistedTokensLength();
+        for(uint256 i = 0; i < length; ++i) {
+            address token = vault.allWhitelistedTokens(i);
+            if (vault.whitelistedTokens(token) && !res.contains(token)) {
+                res = res.append(token);
+            }
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return _getGlpWhitelistedTokens();
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        return _getGlpWhitelistedTokens();
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == stakedGlp || token == NATIVE || vault.whitelistedTokens(token);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == stakedGlp || token == NATIVE || vault.whitelistedTokens(token);
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.LIQUIDITY, glp, IERC20Metadata(glp).decimals());
+    }
+}