@pendle/core-v2 5.8.4-beta → 5.8.4-redeem

package/contracts/offchain-helpers/SwapNSeed.sol

@@ -0,0 +1,221 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.17;
+
+import "../interfaces/IPMarket.sol";
+import "../router/math/MarketApproxLibOnchain.sol";
+import "../router/base/ActionBase.sol";
+import "../interfaces/IPMarketSwapNSeed.sol";
+
+contract MarketSwapNSeed is ActionBase, IPMarketSwapNSeed {
+    using PMath for uint256;
+    using PMath for int256;
+    using PYIndexLib for PYIndex;
+    using MarketMathCore for MarketState;
+    using PYIndexLib for IPYieldToken;
+
+    address public immutable router;
+
+    uint256 public constant MAX_ITERATIONS = 30;
+
+    struct MarketTokens {
+        IStandardizedYield SY;
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+    }
+
+    constructor(address _router) {
+        router = _router;
+    }
+
+    function swapNSeed(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        SwapNSeedData calldata snsData
+    ) external payable returns (int256 amountPYToAccount, uint256 netLpOut, uint256 netYtOut) {
+        MarketTokens memory tokens;
+        (tokens.SY, tokens.PT, tokens.YT) = IPMarket(market).readTokens();
+
+        _mintSyFromToken(address(this), address(tokens.SY), 1, input);
+        amountPYToAccount = _swapBeforeSeeding(receiver, market, tokens, snsData);
+        (netLpOut, netYtOut, ) = _addLiquiditySingleSyKeepYt(
+            receiver,
+            market,
+            tokens.SY,
+            tokens.YT,
+            _selfBalance(tokens.SY),
+            minLpOut,
+            minYtOut
+        );
+    }
+
+    function _addLiquiditySingleSyKeepYt(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) internal returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy) {
+        MarketState memory state = _readMarket(market);
+
+        PYIndex pyIndex = YT.newIndex();
+
+        netSyMintPy =
+            (netSyIn * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
+
+        uint256 netSyAddLiquidity = netSyIn - netSyMintPy;
+
+        // transfer SY to mint PY
+        _transferOut(address(SY), address(YT), netSyMintPy);
+
+        // the rest of SY goes to market
+        _transferOut(address(SY), market, netSyAddLiquidity);
+
+        // PT goes to market, YT goes to receiver
+        netYtOut = YT.mintPY(market, receiver);
+
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
+
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+
+    function _swapBeforeSeeding(
+        address receiver,
+        address market,
+        MarketTokens memory tokens,
+        SwapNSeedData memory snsData
+    ) internal returns (int256 amountPYToAccount) {
+        PYIndex index = _getPYIndex(market);
+        MarketState memory state = _readMarket(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(index, block.timestamp);
+
+        if (state.lastLnImpliedRate > snsData.targetLnImpliedRate) {
+            // Normalize maxPtToSwap
+            snsData.maxPtToSwap = PMath.min(
+                snsData.maxPtToSwap,
+                MarketApproxPtInLibOnchain.calcSoftMaxPtIn(state, comp)
+            );
+
+            (int256 amountPtToBuy, int256 amountSyToAccount) = _calcAmountPtToBuy(state, comp, index, snsData);
+            amountPYToAccount = amountPtToBuy;
+
+            _transferOut(address(tokens.SY), market, amountSyToAccount.abs());
+            IPMarket(market).swapSyForExactPt(receiver, amountPtToBuy.abs(), EMPTY_BYTES);
+        } else {
+            // Normalize maxPtToSwap
+            snsData.maxPtToSwap = PMath.min(
+                snsData.maxPtToSwap,
+                MarketApproxPtOutLibOnchain.calcMaxPtOut(comp, state.totalPt)
+            );
+
+            amountPYToAccount = _calcAmountPtToSell(state, comp, index, snsData);
+            uint256 amountPtToSell = amountPYToAccount.abs();
+            uint256 netPyOut = _mintPyFromSy(
+                address(this),
+                address(tokens.SY),
+                address(tokens.YT),
+                index.assetToSyUp(amountPtToSell),
+                amountPtToSell,
+                false
+            );
+
+            _transferOut(address(tokens.PT), market, netPyOut);
+            _transferOut(address(tokens.YT), receiver, netPyOut);
+
+            // this amount of SY will be used to add liquidity in later step
+            IPMarket(market).swapExactPtForSy(address(this), amountPtToSell, EMPTY_BYTES);
+        }
+    }
+
+    function _calcAmountPtToBuy(
+        MarketState memory state,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        SwapNSeedData memory snsData
+    ) internal pure returns (int256 amountPtToSwapToAccount, int256 amountSyToAccount) {
+        int256 refAmt = snsData.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+
+        int256 lastGoodAmountSyToAccount = 0;
+        uint256 lastGoodRate = state.lastLnImpliedRate;
+
+        for (uint256 iter = 0; iter < MAX_ITERATIONS; ++iter) {
+            refAmt /= 2;
+            MarketState memory localState = _deepCopy(state);
+            int256 curPtToAccount = accPtToAccount + refAmt;
+
+            // Will not revert. maxPtToBuy should already be normalized
+            (int256 localAmountSyToAccount, , ) = localState.calcTrade(comp, index, curPtToAccount);
+
+            if (localState.lastLnImpliedRate > snsData.targetLnImpliedRate) {
+                accPtToAccount += refAmt;
+                lastGoodRate = localState.lastLnImpliedRate;
+                lastGoodAmountSyToAccount = localAmountSyToAccount;
+            }
+        }
+
+        if (PMath.isAApproxB(snsData.targetLnImpliedRate, lastGoodRate, snsData.eps)) {
+            amountPtToSwapToAccount = accPtToAccount;
+            amountSyToAccount = lastGoodAmountSyToAccount;
+        } else {
+            revert("_calcAmountPtToBuy: failed");
+        }
+    }
+
+    function _calcAmountPtToSell(
+        MarketState memory state,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        SwapNSeedData memory snsData
+    ) internal pure returns (int256 amountPtToSwapToAccount) {
+        int256 refAmt = snsData.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+        uint256 lastGoodRate = state.lastLnImpliedRate;
+
+        for (uint256 iter = 0; iter < MAX_ITERATIONS; ++iter) {
+            refAmt /= 2;
+            MarketState memory localState = _deepCopy(state);
+            int256 curPtToAccount = accPtToAccount - refAmt;
+
+            // Will not revert. maxPtToSell should already be normalized
+            localState.calcTrade(comp, index, curPtToAccount);
+
+            if (localState.lastLnImpliedRate < snsData.targetLnImpliedRate) {
+                accPtToAccount -= refAmt;
+                lastGoodRate = localState.lastLnImpliedRate;
+            }
+        }
+
+        if (PMath.isAApproxB(snsData.targetLnImpliedRate, lastGoodRate, snsData.eps)) {
+            amountPtToSwapToAccount = accPtToAccount;
+        } else {
+            revert("_calcAmountPtToSell: failed");
+        }
+    }
+
+    function _getPYIndex(address market) internal returns (PYIndex) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        return PYIndex.wrap(YT.pyIndexCurrent());
+    }
+
+    function _deepCopy(MarketState memory state) internal pure returns (MarketState memory copiedState) {
+        copiedState.totalPt = state.totalPt;
+        copiedState.totalSy = state.totalSy;
+        copiedState.totalLp = state.totalLp;
+        copiedState.treasury = state.treasury;
+
+        copiedState.scalarRoot = state.scalarRoot;
+        copiedState.expiry = state.expiry;
+
+        copiedState.lnFeeRateRoot = state.lnFeeRateRoot;
+        copiedState.reserveFeePercent = state.reserveFeePercent;
+        copiedState.lastLnImpliedRate = state.lastLnImpliedRate;
+    }
+}

package/contracts/offchain-helpers/deploy/PendleCommonSYFactory.sol

@@ -28,8 +28,6 @@ contract PendleCommonSYFactory is BoringOwnableUpgradeableV2 {
 
     uint256 public nonce;
 
-    mapping(bytes32 => address) public implementations;
-
     constructor(address _proxyAdmin) {
         proxyAdmin = _proxyAdmin;
         _disableInitializers();

package/contracts/offchain-helpers/deploy/PendlePoolDeployHelperV2.sol

@@ -95,7 +95,11 @@ contract PendlePoolDeployHelperV2 is TokenHelper {
     function _createPYIfNotExist(address SY, uint32 expiry) internal returns (address PT, address YT) {
         PT = IPYieldContractFactory(yieldContractFactory).getPT(SY, uint256(expiry));
         if (PT == address(0)) {
-            (PT, YT) = IPYieldContractFactory(yieldContractFactory).createYieldContract(SY, expiry, doCacheIndexSameBlock);
+            (PT, YT) = IPYieldContractFactory(yieldContractFactory).createYieldContract(
+                SY,
+                expiry,
+                doCacheIndexSameBlock
+            );
         } else {
             YT = IPYieldContractFactory(yieldContractFactory).getYT(SY, expiry);
         }

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

@@ -6,30 +6,27 @@ import "./IPSwapAggregator.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 abstract contract OKXScaleHelper {
-    address private immutable _tokenApprove = __getTokenApproveForChain(block.chainid);
-
-    function __getTokenApproveForChain(uint256 chainid) private pure returns (address) {
-        if (chainid == 1) {
+    function _okx_getTokenApprove() internal view returns (address) {
+        if (block.chainid == 1) {
             return 0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f;
         }
-        if (chainid == 10) {
+        if (block.chainid == 10) {
             return 0x68D6B739D2020067D1e2F713b999dA97E4d54812;
         }
-        if (chainid == 56) {
+        if (block.chainid == 56) {
             return 0x2c34A2Fb1d0b4f55de51E1d0bDEfaDDce6b7cDD6;
         }
-        if (chainid == 42161) {
+        if (block.chainid == 42161) {
             return 0x70cBb871E8f30Fc8Ce23609E9E0Ea87B6b222F58;
         }
-        if (chainid == 8453 || chainid == 5000 || chainid == 146) {
+        if (block.chainid == 8453) {
+            return 0x57df6092665eb6058DE53939612413ff4B09114E;
+        }
+        if (block.chainid == 5000) {
             return 0x57df6092665eb6058DE53939612413ff4B09114E;
         }
-        return address(0);
-    }
 
-    function _okx_getTokenApprove() internal view returns (address) {
-        require(_tokenApprove != address(0), "PendleSwap: OKX chain not supported");
-        return _tokenApprove;
+        revert("PendleSwap: OKX Chain not supported");
     }
 
     function _okxScaling(

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

@@ -7,30 +7,12 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "./OKXScaleHelper.sol";
 import "./ParaswapScaleHelper.sol";
 
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-
-contract PendleSwap is
-    IPSwapAggregator,
-    TokenHelper,
-    OKXScaleHelper,
-    ParaswapScaleHelper,
-    BoringOwnableUpgradeable,
-    UUPSUpgradeable
-{
+contract PendleSwap is IPSwapAggregator, TokenHelper, OKXScaleHelper, ParaswapScaleHelper {
     using Address for address;
     using SafeERC20 for IERC20;
 
     address private constant KYBER_SCALING_HELPER = 0x2f577A41BeC1BE1152AeEA12e73b7391d15f655D;
 
-    constructor() {
-        _disableInitializers();
-    }
-
-    function initialize() external initializer {
-        __BoringOwnable_init();
-    }
-
     function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
         _approveForExtRouter(tokenIn, data);
         data.extRouter.functionCallWithValue(
@@ -104,8 +86,6 @@ contract PendleSwap is
     }
 
     receive() external payable {}
-
-    function _authorizeUpgrade(address) internal virtual override onlyOwner {}
 }
 
 interface IKyberScalingHelper {

package/deployments/1-core.json

@@ -32,7 +32,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
-    "pendleSwap": "0xFE6228A3866426e96611ED7A3D0Dee918244fcB3",
+    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xdF3601014686674e53d1Fa52F7602525483F9122",
     "marketFactoryV3": "0x1A6fCc85557BC4fB7B534ed835a03EF056552D52",

package/deployments/146-core.json

@@ -28,7 +28,7 @@
         "ActionStorageV4": "0xdED51dca2ECED7a0BAab3D9711A87f214769Da0f"
     },
     "routerStatic": "0x0013ACc071f732fd6BF8210AB46A3794a7D8945e",
-    "pendleSwap": "0xFE6228A3866426e96611ED7A3D0Dee918244fcB3",
+    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
@@ -36,15 +36,16 @@
     "marketFactoryV5": "0xFeE31A6eC6eBefa0b5A594Bf5b1139e3c6fAA0fB",
     "poolDeployHelperV2": "0x0b692f06CA82e3075dC537224450885Fd138e655",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
+    "externalRewardsDistributor": "0xae898a7d07f8e27f25e13d0f351a7401f9a5bf9d",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
-    "receiverEndpoint": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
-    "vePendle": "0xE017CCC08505Ac8fbb5a364680e459d9fBaEE74d",
-    "gaugeController": "0xeE708FC793a02F1eDd5BB9DBD7fD13010D1F7136",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
-    "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
-    "externalRewardsDistributor": "0xae898a7d07f8e27f25e13d0f351a7401f9a5bf9d",
     "beta": {
         "PendleChainlinkOracleFactory": "0x0000000000000000000000000000000000000000"
-    }
+    },
+    "receiverEndpoint": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
+    "vePendle": "0xE017CCC08505Ac8fbb5a364680e459d9fBaEE74d",
+    "gaugeController": "0xeE708FC793a02F1eDd5BB9DBD7fD13010D1F7136",
+    "commonDeployTest": "0x8cbF9190b6EA4BeD4655888273e2A313a77400fD"
 }

package/deployments/42161-core.json

@@ -4,7 +4,7 @@
         "chainId": 42161,
         "treasury": "0xCbcb48e22622a3778b6F14C2f5d258Ba026b05e6",
         "governance": "0x7877AdFaDEd756f3248a0EBfe8Ac2E2eF87b75Ac",
-        "devMultisig": "0xE6F0489ED91dc27f40f9dbe8f81fccbFC16b9cb1",
+        "devMultisig": "0x3c0f8F070E6400C1C4eD10CfF85dE4c643b66bd3",
         "pendle": "0x0c880f6761F1af8d9Aa9C466984b80DAb9a8c9e8",
         "lzEndpoint": "0x3c2269811836af69497E5F486A85D7316753cf62",
         "wrappedNative": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -31,7 +31,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
-    "pendleSwap": "0xFE6228A3866426e96611ED7A3D0Dee918244fcB3",
+    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xEb38531db128EcA928aea1B1CE9E5609B15ba146",
     "marketFactoryV3": "0x2FCb47B58350cD377f94d3821e7373Df60bD9Ced",

package/deployments/5000-core.json

@@ -29,7 +29,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0xCAd502Bb55d1A3F79952F969BFF3f011CF30a94a",
-    "pendleSwap": "0xFE6228A3866426e96611ED7A3D0Dee918244fcB3",
+    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0x964840644B88C583500F473E4B829Ab629aF96A8",
     "marketFactoryV3": "0xD228EC1f7D4313fe321fab511A872475D07F5bA6",

package/deployments/56-core.json

@@ -31,7 +31,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0x2700ADB035F82a11899ce1D3f1BF8451c296eABb",
-    "pendleSwap": "0xFE6228A3866426e96611ED7A3D0Dee918244fcB3",
+    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0x40Ae6da2d92aa3DCb7f8d7a7209FD12BDfcb7C85",
     "marketFactoryV3": "0xC40fEbF5A33b8C92B187d9be0fD3fe0ac2E4B07c",

package/deployments/80094-core.json

@@ -28,7 +28,7 @@
         "ActionStorageV4": "0xdED51dca2ECED7a0BAab3D9711A87f214769Da0f"
     },
     "routerStatic": "0x6813d43782395A1F2AAb42f39aeEDE03ac655e09",
-    "pendleSwap": "0xFE6228A3866426e96611ED7A3D0Dee918244fcB3",
+    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV5": "0x2bEa6BfD8fbFF45aA2a893EB3B6d85D10EFcC70E",
     "marketFactoryV5": "0x8A09574b0401A856d89d1b583eE22E8cb0C5530B",

package/deployments/8453-core.json

@@ -28,7 +28,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0xB4205a645c7e920BD8504181B1D7f2c5C955C3e7",
-    "pendleSwap": "0xFE6228A3866426e96611ED7A3D0Dee918244fcB3",
+    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV5": "0x963ddBB35c1AE44e2a159E3b5fb5177E0B32660d",
     "marketFactoryV5": "0x59968008a703dC13E6beaECed644bdCe4ee45d13",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "5.8.4-beta",
+  "version": "5.8.4-redeem",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",