@pendle/core-v2 0.8.0-beta-3 → 0.8.0-beta-6

package/build/artifacts/contracts/periphery/PermissionsV2Upg.sol/PermissionsV2Upg.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/e7b3e6f2a5d6184a47ffed58494b1475.json"
+  "buildInfo": "../../../build-info/7033d6fa08f4d79f81b857af32174eb3.json"
 }

package/contracts/SuperComposableYield/SCY-implementations/BenQi/PendleQiTokenSCY.sol

@@ -20,6 +20,7 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
         string memory _name,
         string memory _symbol,
         address _qiToken,
+        bool isUnderlyingNative,
         address _WAVAX,
         uint256 _initialExchangeRateMantissa
     )
@@ -30,7 +31,7 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
 
         qiToken = _qiToken;
 
-        underlying = _getUnderlyingOfQiToken();
+        underlying = isUnderlyingNative ? NATIVE : IQiErc20(qiToken).underlying();
         comptroller = IQiToken(qiToken).comptroller();
 
         QI = IBenQiComptroller(comptroller).qiAddress();
@@ -41,14 +42,6 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
         }
     }
 
-    function _getUnderlyingOfQiToken() internal view returns (address) {
-        try IQiErc20(qiToken).underlying() returns (address res) {
-            return res;
-        } catch {
-            return NATIVE;
-        }
-    }
-
     /*///////////////////////////////////////////////////////////////
                     DEPOSIT/REDEEM USING BASE TOKENS
     //////////////////////////////////////////////////////////////*/

package/contracts/core/PendleERC20Permit.sol

@@ -28,7 +28,7 @@ contract PendleERC20Permit is PendleERC20, IERC20Permit, EIP712 {
         string memory name_,
         string memory symbol_,
         uint8 decimals_
-    ) PendleERC20(name_, symbol_, decimals) EIP712(name_, "1") {}
+    ) PendleERC20(name_, symbol_, decimals_) EIP712(name_, "1") {}
 
     /**
      * @dev See {IERC20Permit-permit}.

package/contracts/offchain-helpers/RouterStatic.sol

@@ -13,7 +13,7 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
 /// EXCLUDED FROM ALL AUDITS, TO BE CALLED ONLY BY PENDLE's SDK
-contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, OwnableUpgradeable {
+contract RouterStatic is IPRouterStatic {
     using MarketMathCore for MarketState;
     using MarketApproxLib for MarketState;
     using Math for uint256;
@@ -21,9 +21,9 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
     using LogExpMath for int256;
     using SCYIndexLib for SCYIndex;
 
-    IPYieldContractFactory public immutable yieldContractFactory;
-    IPMarketFactory public immutable marketFactory;
-    ApproxParams public approxParams =
+    IPYieldContractFactory internal immutable yieldContractFactory;
+    IPMarketFactory internal immutable marketFactory;
+    ApproxParams internal approxParams =
         ApproxParams({
             guessMin: 0,
             guessMax: type(uint256).max,
@@ -32,18 +32,11 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
             eps: 1e15
         });
 
-    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory)
-        initializer
-    {
+    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory) {
         yieldContractFactory = _yieldContractFactory;
         marketFactory = _marketFactory;
     }
 
-    function initialize() external initializer {
-        __UUPSUpgradeable_init();
-        __Ownable_init();
-    }
-
     // ============= SYSTEM INFO =============
 
     function getPYInfo(address py)
@@ -176,7 +169,7 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
     }
 
     function swapExactPtForScyStatic(address market, uint256 exactPtIn)
-        external
+        public
         view
         returns (uint256 netScyOut, uint256 netScyFee)
     {
@@ -202,7 +195,7 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
     }
 
     function swapExactScyForPtStatic(address market, uint256 exactScyIn)
-        external
+        public
         view
         returns (uint256 netPtOut, uint256 netScyFee)
     {
@@ -215,6 +208,43 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
         );
     }
 
+    function swapPtForExactScyStatic(address market, uint256 exactScyOut)
+        public
+        view
+        returns (uint256 netPtIn, uint256 netScyFee)
+    {
+        MarketState memory state = IPMarket(market).readState(false);
+
+        (netPtIn, , netScyFee) = state.approxSwapPtForExactScy(
+            scyIndex(market),
+            exactScyOut,
+            block.timestamp,
+            approxParams
+        );
+    }
+
+    function swapExactBaseTokenForPtStatic(
+        address market,
+        address baseToken,
+        uint256 amountBaseToken
+    ) external view returns (uint256 netPtOut, uint256 netScyFee) {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+
+        return swapExactScyForPtStatic(market, SCY.previewDeposit(baseToken, amountBaseToken));
+    }
+
+    function swapExactPtForBaseTokenStatic(
+        address market,
+        uint256 exactYtIn,
+        address baseToken
+    ) external view returns (uint256 netBaseTokenOut, uint256 netScyFee) {
+        uint256 netScyOut;
+        (netScyOut, netScyFee) = swapExactPtForScyStatic(market, exactYtIn);
+
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+        netBaseTokenOut = SCY.previewRedeem(baseToken, netScyOut);
+    }
+
     function swapScyForExactYtStatic(address market, uint256 exactYtOut)
         external
         view
@@ -236,7 +266,7 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
     }
 
     function swapExactScyForYtStatic(address market, uint256 exactScyIn)
-        external
+        public
         view
         returns (uint256 netYtOut, uint256 netScyFee)
     {
@@ -252,7 +282,7 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
     }
 
     function swapExactYtForScyStatic(address market, uint256 exactYtIn)
-        external
+        public
         view
         returns (uint256 netScyOut, uint256 netScyFee)
     {
@@ -286,10 +316,32 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
         );
     }
 
+    function swapExactYtForBaseTokenStatic(
+        address market,
+        uint256 exactYtIn,
+        address baseToken
+    ) external view returns (uint256 netBaseTokenOut, uint256 netScyFee) {
+        uint256 netScyOut;
+        (netScyOut, netScyFee) = swapExactYtForScyStatic(market, exactYtIn);
+
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+        netBaseTokenOut = SCY.previewRedeem(baseToken, netScyOut);
+    }
+
+    function swapExactBaseTokenForYtStatic(
+        address market,
+        address baseToken,
+        uint256 amountBaseToken
+    ) external view returns (uint256 netPtOut, uint256 netScyFee) {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+
+        return swapExactScyForYtStatic(market, SCY.previewDeposit(baseToken, amountBaseToken));
+    }
+
     // ============= OTHER HELPERS =============
 
-    function previewMintPY(address YT, uint256 amountScyToMint)
-        external
+    function mintPYFromScyStatic(address YT, uint256 amountScyToMint)
+        public
         returns (uint256 amountPY)
     {
         IPYieldToken _YT = IPYieldToken(YT);
@@ -297,14 +349,32 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
         return amountScyToMint.mulDown(_YT.scyIndexCurrent());
     }
 
-    function previewRedeemPY(address YT, uint256 amountPYToRedeem)
-        external
+    function redeemPYToScyStatic(address YT, uint256 amountPYToRedeem)
+        public
         returns (uint256 amountPY)
     {
         IPYieldToken _YT = IPYieldToken(YT);
         return amountPYToRedeem.divDown(_YT.scyIndexCurrent());
     }
 
+    function mintPYFromBaseStatic(
+        address YT,
+        address baseToken,
+        uint256 amountBaseToken
+    ) external returns (uint256 amountPY) {
+        ISuperComposableYield SCY = ISuperComposableYield(IPYieldToken(YT).SCY());
+        return mintPYFromScyStatic(YT, SCY.previewDeposit(baseToken, amountBaseToken));
+    }
+
+    function redeemPYToBaseStatic(
+        address YT,
+        uint256 amountPYToRedeem,
+        address baseToken
+    ) external returns (uint256 amountBaseToken) {
+        ISuperComposableYield SCY = ISuperComposableYield(IPYieldToken(YT).SCY());
+        return SCY.previewRedeem(baseToken, redeemPYToScyStatic(YT, amountPYToRedeem));
+    }
+
     function scyIndex(address market) public view returns (SCYIndex index) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
@@ -406,9 +476,4 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
             userPYInfo.unclaimedInterest.amount > 0 ||
             userPYInfo.unclaimedRewards.length > 0);
     }
-
-    // ============= UPGRADES =============
-
-    // solhint-disable-next-line no-empty-blocks
-    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 }

package/package.json

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

package/typechain-types/ActionRedeem.ts

@@ -0,0 +1,125 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  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 ActionRedeemInterface extends utils.Interface {
+  contractName: "ActionRedeem";
+  functions: {
+    "redeemDueIncome(address,address[],address[],address[])": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "redeemDueIncome",
+    values: [string, string[], string[], string[]]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "redeemDueIncome",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface ActionRedeem extends BaseContract {
+  contractName: "ActionRedeem";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ActionRedeemInterface;
+
+  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: {
+    redeemDueIncome(
+      user: string,
+      scys: string[],
+      yieldTokens: string[],
+      arg3: string[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  redeemDueIncome(
+    user: string,
+    scys: string[],
+    yieldTokens: string[],
+    arg3: string[],
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    redeemDueIncome(
+      user: string,
+      scys: string[],
+      yieldTokens: string[],
+      arg3: string[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[][], BigNumber[], BigNumber[][]] & {
+        scyRewards: BigNumber[][];
+        ytInterests: BigNumber[];
+        ytRewards: BigNumber[][];
+      }
+    >;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    redeemDueIncome(
+      user: string,
+      scys: string[],
+      yieldTokens: string[],
+      arg3: string[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    redeemDueIncome(
+      user: string,
+      scys: string[],
+      yieldTokens: string[],
+      arg3: string[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

package/typechain-types/ActionSCYAndYOBase.ts

@@ -0,0 +1,223 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface ActionSCYAndYOBaseInterface extends utils.Interface {
+  contractName: "ActionSCYAndYOBase";
+  functions: {
+    "joeFactory()": FunctionFragment;
+    "joeRouter()": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "joeFactory",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "joeRouter", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "joeFactory", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "joeRouter", data: BytesLike): Result;
+
+  events: {
+    "MintScyFromRawToken(address,address,uint256,address,uint256)": EventFragment;
+    "MintYoFromRawToken(address,address,uint256,address,uint256)": EventFragment;
+    "RedeemScyToRawToken(address,address,uint256,address,uint256)": EventFragment;
+    "RedeemYoToRawToken(address,address,uint256,address,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "MintScyFromRawToken"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "MintYoFromRawToken"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RedeemScyToRawToken"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RedeemYoToRawToken"): EventFragment;
+}
+
+export type MintScyFromRawTokenEvent = TypedEvent<
+  [string, string, BigNumber, string, BigNumber],
+  {
+    user: string;
+    rawTokenIn: string;
+    netRawTokenIn: BigNumber;
+    SCY: string;
+    netScyOut: BigNumber;
+  }
+>;
+
+export type MintScyFromRawTokenEventFilter =
+  TypedEventFilter<MintScyFromRawTokenEvent>;
+
+export type MintYoFromRawTokenEvent = TypedEvent<
+  [string, string, BigNumber, string, BigNumber],
+  {
+    user: string;
+    rawTokenIn: string;
+    netRawTokenIn: BigNumber;
+    YT: string;
+    netYoOut: BigNumber;
+  }
+>;
+
+export type MintYoFromRawTokenEventFilter =
+  TypedEventFilter<MintYoFromRawTokenEvent>;
+
+export type RedeemScyToRawTokenEvent = TypedEvent<
+  [string, string, BigNumber, string, BigNumber],
+  {
+    user: string;
+    SCY: string;
+    netScyIn: BigNumber;
+    rawTokenOut: string;
+    netRawTokenOut: BigNumber;
+  }
+>;
+
+export type RedeemScyToRawTokenEventFilter =
+  TypedEventFilter<RedeemScyToRawTokenEvent>;
+
+export type RedeemYoToRawTokenEvent = TypedEvent<
+  [string, string, BigNumber, string, BigNumber],
+  {
+    user: string;
+    YT: string;
+    netYoIn: BigNumber;
+    rawTokenOut: string;
+    netRawTokenOut: BigNumber;
+  }
+>;
+
+export type RedeemYoToRawTokenEventFilter =
+  TypedEventFilter<RedeemYoToRawTokenEvent>;
+
+export interface ActionSCYAndYOBase extends BaseContract {
+  contractName: "ActionSCYAndYOBase";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ActionSCYAndYOBaseInterface;
+
+  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: {
+    joeFactory(overrides?: CallOverrides): Promise<[string]>;
+
+    joeRouter(overrides?: CallOverrides): Promise<[string]>;
+  };
+
+  joeFactory(overrides?: CallOverrides): Promise<string>;
+
+  joeRouter(overrides?: CallOverrides): Promise<string>;
+
+  callStatic: {
+    joeFactory(overrides?: CallOverrides): Promise<string>;
+
+    joeRouter(overrides?: CallOverrides): Promise<string>;
+  };
+
+  filters: {
+    "MintScyFromRawToken(address,address,uint256,address,uint256)"(
+      user?: string | null,
+      rawTokenIn?: string | null,
+      netRawTokenIn?: null,
+      SCY?: string | null,
+      netScyOut?: null
+    ): MintScyFromRawTokenEventFilter;
+    MintScyFromRawToken(
+      user?: string | null,
+      rawTokenIn?: string | null,
+      netRawTokenIn?: null,
+      SCY?: string | null,
+      netScyOut?: null
+    ): MintScyFromRawTokenEventFilter;
+
+    "MintYoFromRawToken(address,address,uint256,address,uint256)"(
+      user?: string | null,
+      rawTokenIn?: string | null,
+      netRawTokenIn?: null,
+      YT?: string | null,
+      netYoOut?: null
+    ): MintYoFromRawTokenEventFilter;
+    MintYoFromRawToken(
+      user?: string | null,
+      rawTokenIn?: string | null,
+      netRawTokenIn?: null,
+      YT?: string | null,
+      netYoOut?: null
+    ): MintYoFromRawTokenEventFilter;
+
+    "RedeemScyToRawToken(address,address,uint256,address,uint256)"(
+      user?: string | null,
+      SCY?: string | null,
+      netScyIn?: null,
+      rawTokenOut?: string | null,
+      netRawTokenOut?: null
+    ): RedeemScyToRawTokenEventFilter;
+    RedeemScyToRawToken(
+      user?: string | null,
+      SCY?: string | null,
+      netScyIn?: null,
+      rawTokenOut?: string | null,
+      netRawTokenOut?: null
+    ): RedeemScyToRawTokenEventFilter;
+
+    "RedeemYoToRawToken(address,address,uint256,address,uint256)"(
+      user?: string | null,
+      YT?: string | null,
+      netYoIn?: null,
+      rawTokenOut?: string | null,
+      netRawTokenOut?: null
+    ): RedeemYoToRawTokenEventFilter;
+    RedeemYoToRawToken(
+      user?: string | null,
+      YT?: string | null,
+      netYoIn?: null,
+      rawTokenOut?: string | null,
+      netRawTokenOut?: null
+    ): RedeemYoToRawTokenEventFilter;
+  };
+
+  estimateGas: {
+    joeFactory(overrides?: CallOverrides): Promise<BigNumber>;
+
+    joeRouter(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    joeFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    joeRouter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}