@pendle/core-v2 2.20.1 → 2.21.0-tradingbot

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

@@ -10,21 +10,19 @@ contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
     using Math for uint256;
     using BulkSellerMathCore for BulkSellerState;
 
-    function mintPyFromSyStatic(address YT, uint256 netSyToMint)
-        public
-        view
-        returns (uint256 netPYOut)
-    {
+    function mintPyFromSyStatic(
+        address YT,
+        uint256 netSyToMint
+    ) public returns (uint256 netPYOut) {
         if (IPYieldToken(YT).isExpired()) revert Errors.YCExpired();
-        return netSyToMint.mulDown(pyIndexCurrentViewYt(YT));
+        return netSyToMint.mulDown(IPYieldToken(YT).pyIndexCurrent());
     }
 
-    function redeemPyToSyStatic(address YT, uint256 netPYToRedeem)
-        public
-        view
-        returns (uint256 netSyOut)
-    {
-        return netPYToRedeem.divDown(pyIndexCurrentViewYt(YT));
+    function redeemPyToSyStatic(
+        address YT,
+        uint256 netPYToRedeem
+    ) public returns (uint256 netSyOut) {
+        return netPYToRedeem.divDown(IPYieldToken(YT).pyIndexCurrent());
     }
 
     function mintPyFromTokenStatic(
@@ -32,7 +30,7 @@ contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
         address tokenIn,
         uint256 netTokenIn,
         address bulk
-    ) external view returns (uint256 netPyOut) {
+    ) external returns (uint256 netPyOut) {
         address SY = IPYieldToken(YT).SY();
         uint256 netSyReceived = mintSyFromTokenStatic(SY, tokenIn, netTokenIn, bulk);
         netPyOut = mintPyFromSyStatic(YT, netSyReceived);
@@ -43,7 +41,7 @@ contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
         uint256 netPYToRedeem,
         address tokenOut,
         address bulk
-    ) external view returns (uint256 netTokenOut) {
+    ) external returns (uint256 netTokenOut) {
         address SY = IPYieldToken(YT).SY();
         uint256 netSyReceived = redeemPyToSyStatic(YT, netPYToRedeem);
         netTokenOut = redeemSyToTokenStatic(SY, tokenOut, netSyReceived, bulk);
@@ -86,7 +84,7 @@ contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
         uint256 pivotAmount;
 
         if (tokenIn == address(0)) pivotAmount = 1e18;
-        else pivotAmount = 10**IStandardizedYield(SY).decimals();
+        else pivotAmount = 10 ** IStandardizedYield(SY).decimals();
 
         uint256 low = pivotAmount;
         {
@@ -126,15 +124,7 @@ contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
         address SY,
         uint256 netTokenIn,
         uint256 netSyIn
-    )
-        external
-        view
-        returns (
-            address bulk,
-            uint256 totalToken,
-            uint256 totalSy
-        )
-    {
+    ) external view returns (address bulk, uint256 totalToken, uint256 totalSy) {
         if (address(bulkSellerFactory) == address(0)) return (address(0), 0, 0);
 
         bulk = bulkSellerFactory.get(token, SY);
@@ -162,25 +152,6 @@ contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
         totalSy = state.totalSy;
     }
 
-    function pyIndexCurrentViewMarket(address market) public view returns (uint256) {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
-        return pyIndexCurrentViewYt(address(YT));
-    }
-
-    function pyIndexCurrentViewYt(address yt) public view returns (uint256) {
-        IPYieldToken YT = IPYieldToken(yt);
-        IStandardizedYield SY = IStandardizedYield(YT.SY());
-
-        uint256 syIndex = SY.exchangeRate();
-        uint256 pyIndexStored = YT.pyIndexStored();
-
-        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
-            return pyIndexStored;
-        } else {
-            return Math.max(syIndex, pyIndexStored);
-        }
-    }
-
     function _readBulkSellerState(address bulk) internal view returns (BulkSellerState memory) {
         return IPBulkSeller(bulk).readState();
     }

package/contracts/oracles/PendleLpOracleLib.sol

@@ -55,7 +55,7 @@ library PendleLpOracleLib {
         return state.getMarketPreCompute(_getPYIndexCurrent(market), block.timestamp);
     }
 
-    function _getPYIndexCurrent(IPMarket market) private view returns (PYIndex) {
+    function _getPYIndexCurrent(IPMarket market) internal view returns (PYIndex) {
         (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
         uint256 ytIndex = YT.pyIndexStored();
         uint256 pyIndexCurrent;

package/deployments/core.ts

@@ -0,0 +1,29 @@
+import ethCoreJSON from './1-core.json';
+
+export interface PendleCore {
+    PENDLE: string;
+    yieldContractFactory: string;
+    marketFactory: string;
+    bulkSellerFactory: string;
+    bulkSellerOffchain: string;
+    router: string;
+    routerStatic: string;
+    vePendle: string;
+    gaugeController: string;
+}
+
+export interface PendleCoreMainchain extends PendleCore {
+    senderEndpoint: string;
+    votingController: string;
+    feeDistributor: string;
+}
+
+export interface PendleCoreSidechain extends PendleCore {
+    receiverEndpoint: string;
+}
+
+const ethCore: PendleCoreMainchain = ethCoreJSON;
+
+export const pendleCore = {
+    ethereum: ethCore,
+};

package/deployments/index.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './markets';
+export * from './misc';
+export * from '../typechain-types';

package/deployments/markets/ape-june-29-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketApeJune292022JSON from '../1-markets/APE-JUNE-29.json';
+export const apeJune292022: MarketDeployment = marketApeJune292022JSON;

package/deployments/markets/balancer-reth-dec-28-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketBalancerRethDec282023JSON from '../1-markets/BALANCER-LP-AURA-RETH-WETH-28DEC.json';
+export const balancerRethDec282023: MarketDeployment = marketBalancerRethDec282023JSON;

package/deployments/markets/balancer-wsteth-jun-27-2024.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketBalancerWstEthJun272024JSON from '../1-markets/BALANCER-LP-AURA-WSTETH-WETH-JUN272024.json';
+export const balancerWstEthJun272024: MarketDeployment = marketBalancerWstEthJun272024JSON;

package/deployments/markets/curve-fraxusdc-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketCurveFraxUsdcMarch302023JSON from '../1-markets/FRAXUSDC-CURVELP-MARCH30.json';
+export const curveFraxUsdcMarch302023: MarketDeployment = marketCurveFraxUsdcMarch302023JSON;

package/deployments/markets/index.ts

@@ -0,0 +1,17 @@
+import { apeJune292022 } from './ape-june-29-2023';
+import { balancerRethDec282023 } from './balancer-reth-dec-28-2023';
+import { balancerWstEthJun272024 } from './balancer-wsteth-jun-27-2024';
+import { curveFraxUsdcMarch302023 } from './curve-fraxusdc-march-30-2023';
+import { looksMarch302023 } from './looks-march-30-2023';
+import { stEthJune292023 } from './steth-june-29-2023';
+import { stEthMarch302023 } from './steth-march-30-2023';
+
+export const markets = {
+    apeJune292022,
+    balancerRethDec282023,
+    balancerWstEthJun272024,
+    curveFraxUsdcMarch302023,
+    looksMarch302023,
+    stEthJune292023,
+    stEthMarch302023,
+};

package/deployments/markets/looks-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketLooksMarch302023JSON from '../1-markets/LOOKS-STAKING-MARCH30.json';
+export const looksMarch302023: MarketDeployment = marketLooksMarch302023JSON;

package/deployments/markets/steth-june-29-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketStEthJune292023JSON from '../1-markets/STETH-JUNE29.json';
+export const stEthJune292023: MarketDeployment = marketStEthJune292023JSON;

package/deployments/markets/steth-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketStEthMarch302023JSON from '../1-markets/STETH-MARCH30.json';
+export const stEthMarch302023: MarketDeployment = marketStEthMarch302023JSON;

package/deployments/markets/types.ts

@@ -0,0 +1,9 @@
+export interface MarketDeployment {
+    name: string;
+    SY: string;
+    YT: string;
+    PT: string;
+    market: string;
+    expiry: number;
+    bulkSeller?: string;
+}

package/deployments/misc.ts

@@ -0,0 +1,23 @@
+import { BigNumber as BN, utils } from 'ethers';
+
+export const MISC_CONSTS = {
+    RONE: BN.from(2).pow(40),
+    ONE_E_12: BN.from(10).pow(12),
+    ONE_E_18: BN.from(10).pow(18),
+    INF: BN.from(2).pow(256).sub(1),
+    ZERO_BYTES: utils.formatBytes32String(''),
+    ZERO_ADDRESS: '0x0000000000000000000000000000000000000000',
+    DUMMY_ADDRESS: '0xDEADbeEfEEeEEEeEEEeEEeeeeeEeEEeeeeEEEEeE',
+    ONE_HOUR: BN.from(3600),
+    ONE_DAY: BN.from(86400),
+    ONE_WEEK: BN.from(86400 * 7),
+    FIFTEEN_DAY: BN.from(86400 * 15),
+    ONE_MONTH: BN.from(2592000),
+    THREE_MONTH: BN.from(2592000 * 3),
+    FIVE_MONTH: BN.from(2592000 * 5),
+    SIX_MONTH: BN.from(2592000 * 6),
+    ONE_QUARTER: BN.from(7884000),
+    ONE_YEAR: BN.from(31536000),
+    END_OF_2023: BN.from(1703721600),
+    JUNE_OF_2022: BN.from(1656547200),
+};

package/package.json

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

package/typechain-types/ActionMarketAuxStatic.ts

@@ -7,6 +7,8 @@ import {
   BigNumberish,
   BytesLike,
   CallOverrides,
+  ContractTransaction,
+  Overrides,
   PopulatedTransaction,
   Signer,
   utils,
@@ -60,11 +62,7 @@ export interface ActionMarketAuxStaticInterface extends utils.Interface {
     "calcPriceImpactPY(address,int256)": FunctionFragment;
     "calcPriceImpactPt(address,int256)": FunctionFragment;
     "calcPriceImpactYt(address,int256)": FunctionFragment;
-    "getLpToAssetRate(address)": FunctionFragment;
-    "getLpToSyRate(address)": FunctionFragment;
     "getMarketState(address)": FunctionFragment;
-    "getPtToAssetRate(address)": FunctionFragment;
-    "getPtToSyRate(address)": FunctionFragment;
     "getTradeExchangeRateExcludeFee(address,(int256,int256,int256,address,int256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "getTradeExchangeRateIncludeFee(address,int256)": FunctionFragment;
   };
@@ -81,26 +79,10 @@ export interface ActionMarketAuxStaticInterface extends utils.Interface {
     functionFragment: "calcPriceImpactYt",
     values: [string, BigNumberish]
   ): string;
-  encodeFunctionData(
-    functionFragment: "getLpToAssetRate",
-    values: [string]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "getLpToSyRate",
-    values: [string]
-  ): string;
   encodeFunctionData(
     functionFragment: "getMarketState",
     values: [string]
   ): string;
-  encodeFunctionData(
-    functionFragment: "getPtToAssetRate",
-    values: [string]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "getPtToSyRate",
-    values: [string]
-  ): string;
   encodeFunctionData(
     functionFragment: "getTradeExchangeRateExcludeFee",
     values: [string, MarketStateStruct]
@@ -122,26 +104,10 @@ export interface ActionMarketAuxStaticInterface extends utils.Interface {
     functionFragment: "calcPriceImpactYt",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(
-    functionFragment: "getLpToAssetRate",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "getLpToSyRate",
-    data: BytesLike
-  ): Result;
   decodeFunctionResult(
     functionFragment: "getMarketState",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(
-    functionFragment: "getPtToAssetRate",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "getPtToSyRate",
-    data: BytesLike
-  ): Result;
   decodeFunctionResult(
     functionFragment: "getTradeExchangeRateExcludeFee",
     data: BytesLike
@@ -185,132 +151,73 @@ export interface ActionMarketAuxStatic extends BaseContract {
     calcPriceImpactPY(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber] & { priceImpact: BigNumber }>;
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
 
     calcPriceImpactPt(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber] & { priceImpact: BigNumber }>;
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
 
     calcPriceImpactYt(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber] & { priceImpact: BigNumber }>;
-
-    getLpToAssetRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
-
-    getLpToSyRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
 
     getMarketState(
       market: string,
-      overrides?: CallOverrides
-    ): Promise<
-      [
-        string,
-        string,
-        string,
-        BigNumber,
-        BigNumber,
-        MarketStateStructOutput
-      ] & {
-        pt: string;
-        yt: string;
-        sy: string;
-        impliedYield: BigNumber;
-        marketExchangeRateExcludeFee: BigNumber;
-        state: MarketStateStructOutput;
-      }
-    >;
-
-    getPtToAssetRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
-
-    getPtToSyRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
 
     getTradeExchangeRateExcludeFee(
       market: string,
       state: MarketStateStruct,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
 
     getTradeExchangeRateIncludeFee(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
   };
 
   calcPriceImpactPY(
     market: string,
     netPtOut: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
   calcPriceImpactPt(
     market: string,
     netPtOut: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
   calcPriceImpactYt(
     market: string,
     netPtOut: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  getLpToAssetRate(
-    market: string,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  getLpToSyRate(market: string, overrides?: CallOverrides): Promise<BigNumber>;
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
   getMarketState(
     market: string,
-    overrides?: CallOverrides
-  ): Promise<
-    [string, string, string, BigNumber, BigNumber, MarketStateStructOutput] & {
-      pt: string;
-      yt: string;
-      sy: string;
-      impliedYield: BigNumber;
-      marketExchangeRateExcludeFee: BigNumber;
-      state: MarketStateStructOutput;
-    }
-  >;
-
-  getPtToAssetRate(
-    market: string,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  getPtToSyRate(market: string, overrides?: CallOverrides): Promise<BigNumber>;
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
   getTradeExchangeRateExcludeFee(
     market: string,
     state: MarketStateStruct,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
   getTradeExchangeRateIncludeFee(
     market: string,
     netPtOut: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
   callStatic: {
     calcPriceImpactPY(
@@ -331,16 +238,6 @@ export interface ActionMarketAuxStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getLpToAssetRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getLpToSyRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     getMarketState(
       market: string,
       overrides?: CallOverrides
@@ -362,16 +259,6 @@ export interface ActionMarketAuxStatic extends BaseContract {
       }
     >;
 
-    getPtToAssetRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getPtToSyRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     getTradeExchangeRateExcludeFee(
       market: string,
       state: MarketStateStruct,
@@ -391,56 +278,36 @@ export interface ActionMarketAuxStatic extends BaseContract {
     calcPriceImpactPY(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
     calcPriceImpactPt(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
     calcPriceImpactYt(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getLpToAssetRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getLpToSyRate(
-      market: string,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
     getMarketState(
       market: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getPtToAssetRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getPtToSyRate(
-      market: string,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
     getTradeExchangeRateExcludeFee(
       market: string,
       state: MarketStateStruct,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
     getTradeExchangeRateIncludeFee(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
   };
 
@@ -448,56 +315,36 @@ export interface ActionMarketAuxStatic extends BaseContract {
     calcPriceImpactPY(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
     calcPriceImpactPt(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
     calcPriceImpactYt(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getLpToAssetRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getLpToSyRate(
-      market: string,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
     getMarketState(
       market: string,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getPtToAssetRate(
-      market: string,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getPtToSyRate(
-      market: string,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
     getTradeExchangeRateExcludeFee(
       market: string,
       state: MarketStateStruct,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
     getTradeExchangeRateIncludeFee(
       market: string,
       netPtOut: BigNumberish,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
   };
 }