@pendle/core-v2 0.2.1 → 0.2.2

package/contracts/libraries/math/MarketMathLib.sol

@@ -34,7 +34,7 @@ struct MarketStorage {
     uint32 lastTradeTime;
 }
 
-// solhint-disable reason-string, ordering
+// solhint-disable ordering
 library MarketMathLib {
     using FixedPoint for uint256;
     using FixedPoint for int256;
@@ -138,15 +138,18 @@ library MarketMathLib {
     function setInitialImpliedRate(
         MarketParameters memory market,
         SCYIndex index,
-        int256 anchorRoot,
+        int256 initialAnchor,
         uint256 blockTime
     ) internal pure {
+        require(blockTime < market.expiry, "market expired");
         int256 totalAsset = index.scyToAsset(market.totalScy);
+        uint256 timeToExpiry = market.expiry - blockTime;
+        int256 rateScalar = _getRateScalar(market, timeToExpiry);
         market.lastImpliedRate = _getImpliedRate(
             market.totalOt,
             totalAsset,
-            market.scalarRoot,
-            anchorRoot,
+            rateScalar,
+            initialAnchor,
             market.expiry - blockTime
         );
     }
@@ -211,19 +214,24 @@ library MarketMathLib {
             scyUsed = scyDesired;
             otUsed = otDesired;
         } else {
-            lpToAccount = FixedPoint.min(
-                (otDesired * market.totalLp) / market.totalOt,
-                (scyDesired * market.totalLp) / market.totalScy
-            );
-            scyUsed = (market.totalScy * lpToAccount) / market.totalLp;
-            otUsed = (market.totalOt * lpToAccount) / market.totalLp;
+            int256 netLpByOt = (otDesired * market.totalLp) / market.totalOt;
+            int256 netLpByScy = (scyDesired * market.totalLp) / market.totalScy;
+            if (netLpByOt < netLpByScy) {
+                lpToAccount = netLpByOt;
+                otUsed = otDesired;
+                scyUsed = (market.totalScy * lpToAccount) / market.totalLp;
+            } else {
+                lpToAccount = netLpByScy;
+                scyUsed = scyDesired;
+                otUsed = (market.totalOt * lpToAccount) / market.totalLp;
+            }
         }
 
+        require(lpToAccount > 0, "INSUFFICIENT_LIQUIDITY_MINTED");
+
         market.totalScy += scyUsed;
         market.totalOt += otUsed;
         market.totalLp += lpToAccount + lpToReserve;
-
-        require(lpToAccount > 0, "INSUFFICIENT_LIQUIDITY_MINTED");
     }
 
     function _removeLiquidity(MarketParameters memory market, int256 lpToRemove)
@@ -254,7 +262,7 @@ library MarketMathLib {
         int256 otToAccount,
         uint256 blockTime
     ) private pure returns (int256 netScyToAccount, int256 netScyToReserve) {
-        require(blockTime < market.expiry, "MARKET_EXPIRED");
+        require(blockTime < market.expiry, "market expired");
 
         ExecuteTradeSlot memory slot;
         slot.timeToExpiry = market.expiry - blockTime;
@@ -313,7 +321,7 @@ library MarketMathLib {
         // It's technically possible that the implied rate is actually exactly zero (or
         // more accurately the natural log rounds down to zero) but we will still fail
         // in this case. If this does happen we may assume that markets are not initialized.
-        require(market.lastImpliedRate != 0);
+        require(market.lastImpliedRate != 0, "zero impliedRate");
 
         (netScyToAccount, netScyToReserve) = _setNewMarketState(
             market,
@@ -345,7 +353,7 @@ library MarketMathLib {
         rateScalar = _getRateScalar(market, timeToExpiry);
         totalAsset = index.scyToAsset(market.totalScy);
 
-        require(market.totalOt != 0 && totalAsset != 0);
+        require(market.totalOt != 0 && totalAsset != 0, "invalid market state");
 
         // Get the rateAnchor given the market state, this will establish the baseline for where
         // the exchange rate is set.
@@ -545,7 +553,7 @@ library MarketMathLib {
         // removed). Over time, the yield from SCY will slightly decrease the proportion (the
         // amount of Asset in the market must be monotonically increasing). Therefore it is not
         // possible for the proportion to go over max market proportion unless borrowing occurs.
-        require(proportion <= MAX_MARKET_PROPORTION);
+        require(proportion <= MAX_MARKET_PROPORTION, "max proportion exceeded");
 
         int256 lnProportion = _logProportion(proportion);
 
@@ -558,7 +566,7 @@ library MarketMathLib {
 
     function _logProportion(int256 proportion) private pure returns (int256 res) {
         // This will result in divide by zero, short circuit
-        require(proportion != FixedPoint.ONE_INT);
+        require(proportion != FixedPoint.ONE_INT, "proportion must not be one");
 
         // Convert proportion to what is used inside the logit function (p / (1-p))
         int256 logitP = proportion.divDown(FixedPoint.ONE_INT - proportion);

package/package.json

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

package/typechain-types/IPRouterStatic.ts

@@ -0,0 +1,307 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface IPRouterStaticInterface extends utils.Interface {
+  contractName: "IPRouterStatic";
+  functions: {
+    "addLiquidityStatic(address,uint256,uint256)": FunctionFragment;
+    "getOtImpliedYield(address)": FunctionFragment;
+    "removeLiquidityStatic(address,uint256)": FunctionFragment;
+    "scyIndex(address)": FunctionFragment;
+    "swapOtForScyStatic(address,uint256)": FunctionFragment;
+    "swapScyForOtStatic(address,uint256)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "addLiquidityStatic",
+    values: [string, BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getOtImpliedYield",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeLiquidityStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(functionFragment: "scyIndex", values: [string]): string;
+  encodeFunctionData(
+    functionFragment: "swapOtForScyStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapScyForOtStatic",
+    values: [string, BigNumberish]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "addLiquidityStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getOtImpliedYield",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removeLiquidityStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "scyIndex", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "swapOtForScyStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapScyForOtStatic",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IPRouterStatic extends BaseContract {
+  contractName: "IPRouterStatic";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IPRouterStaticInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    addLiquidityStatic(
+      market: string,
+      scyDesired: BigNumberish,
+      otDesired: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    getOtImpliedYield(
+      market: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    removeLiquidityStatic(
+      market: string,
+      lpToRemove: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netScyOut: BigNumber; netOtOut: BigNumber }
+    >;
+
+    scyIndex(
+      market: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapOtForScyStatic(
+      market: string,
+      exactOtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapScyForOtStatic(
+      market: string,
+      exactOtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  addLiquidityStatic(
+    market: string,
+    scyDesired: BigNumberish,
+    otDesired: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  getOtImpliedYield(
+    market: string,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  removeLiquidityStatic(
+    market: string,
+    lpToRemove: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { netScyOut: BigNumber; netOtOut: BigNumber }
+  >;
+
+  scyIndex(
+    market: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapOtForScyStatic(
+    market: string,
+    exactOtIn: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapScyForOtStatic(
+    market: string,
+    exactOtOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    addLiquidityStatic(
+      market: string,
+      scyDesired: BigNumberish,
+      otDesired: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        netLpOut: BigNumber;
+        scyUsed: BigNumber;
+        otUsed: BigNumber;
+      }
+    >;
+
+    getOtImpliedYield(
+      market: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    removeLiquidityStatic(
+      market: string,
+      lpToRemove: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netScyOut: BigNumber; netOtOut: BigNumber }
+    >;
+
+    scyIndex(market: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    swapOtForScyStatic(
+      market: string,
+      exactOtIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netScyOut: BigNumber; netScyFee: BigNumber }
+    >;
+
+    swapScyForOtStatic(
+      market: string,
+      exactOtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+    >;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    addLiquidityStatic(
+      market: string,
+      scyDesired: BigNumberish,
+      otDesired: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    getOtImpliedYield(
+      market: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    removeLiquidityStatic(
+      market: string,
+      lpToRemove: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    scyIndex(
+      market: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    swapOtForScyStatic(
+      market: string,
+      exactOtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    swapScyForOtStatic(
+      market: string,
+      exactOtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    addLiquidityStatic(
+      market: string,
+      scyDesired: BigNumberish,
+      otDesired: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getOtImpliedYield(
+      market: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    removeLiquidityStatic(
+      market: string,
+      lpToRemove: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    scyIndex(
+      market: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapOtForScyStatic(
+      market: string,
+      exactOtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapScyForOtStatic(
+      market: string,
+      exactOtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}