@pendle/core-v2 0.10.5-testnet → 0.11.1-testnet

package/contracts/libraries/kyberswap/IMultihopRouter.sol

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.6;
+
+pragma abicoder v2;
+
+interface IMultihopRouter {
+    enum DexType {
+        UNI,
+        STABLESWAP,
+        CURVE,
+        KYBERDMM,
+        SADDLE,
+        UNIV3PROMM,
+        BALANCERV2,
+        KYBERRFQ,
+        DODO,
+        VELODROME,
+        PLATYPUS
+    }
+
+    event Exchange(address pair, uint256 amountOut, address output);
+    struct Swap {
+        bytes data;
+        //dexType:
+        //  0: uni
+        //  1: stable swap
+        //  2: curve
+        //  3: kyber dmm
+        //  4: saddle
+        //  5: univ3 or kyber ProMM
+        //  6: balancerv2
+        //  7: kyber RFQ
+        //  8: dodo
+        //  9: velodrome
+        //  10: platypus
+        //dexId:
+        //  0: firebird
+        uint16 dexOption; //dexType(8bit) + dexId(8bit)
+    }
+
+    struct UniSwap {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+        uint256 collectAmount; // amount that should be transferred to the pool
+        uint256 limitReturnAmount;
+    }
+
+    struct StableSwap {
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        uint8 tokenIndexFrom;
+        uint8 tokenIndexTo;
+        uint256 dx;
+        uint256 minDy;
+        uint256 poolLength;
+        address poolLp;
+    }
+
+    struct CurveSwap {
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        int128 tokenIndexFrom;
+        int128 tokenIndexTo;
+        uint256 dx;
+        uint256 minDy;
+        bool usePoolUnderlying;
+        bool useTriCrypto;
+    }
+
+    struct UniSwapV3ProMM {
+        address recipient;
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        uint256 swapAmount;
+        uint256 limitReturnAmount;
+        uint160 sqrtPriceLimitX96;
+        bool isUniV3; // true = UniV3, false = ProMM
+    }
+    struct SwapCallbackData {
+        bytes path;
+        address payer;
+    }
+    struct SwapCallbackDataPath {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct BalancerV2 {
+        address vault;
+        bytes32 poolId;
+        address assetIn;
+        address assetOut;
+        uint256 amount;
+        uint256 limit;
+    }
+
+    struct KyberRFQ {
+        address rfq;
+        bytes order;
+        bytes signature;
+        uint256 amount;
+        address payable target;
+    }
+
+    struct DODO {
+        address recipient;
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        uint256 amount;
+        uint256 minReceiveQuote;
+        address sellHelper;
+        bool isSellBase;
+        bool isVersion2;
+    }
+
+    function factory() external view returns (address);
+
+    function formula() external view returns (address);
+
+    function WETH() external view returns (address);
+
+    function multihopBatchSwapExactIn(
+        Swap[][] memory swapSequences,
+        address tokenIn,
+        address tokenOut,
+        uint256 minTotalAmountOut,
+        address to,
+        uint256 deadline,
+        bytes memory destTokenFeeData
+    ) external payable returns (uint256 totalAmountOut);
+}

package/contracts/libraries/kyberswap/KyberSwapHelper.sol

@@ -26,6 +26,7 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/utils/Address.sol";
 import "../helpers/TokenHelper.sol";
+import "./AggregationRouterHelper.sol";
 
 struct TokenInput {
     address tokenIn;
@@ -53,9 +54,14 @@ abstract contract KyberSwapHelper is TokenHelper {
     function _kyberswap(
         address tokenIn,
         uint256 amountIn,
-        bytes calldata kybercall
+        bytes calldata rawKybercall
     ) internal {
         _safeApproveInf(tokenIn, kyberSwapRouter);
+
+        bytes memory kybercall = AggregationRouterHelper.getScaledInputData(
+            rawKybercall,
+            amountIn
+        );
         kyberSwapRouter.functionCallWithValue(kybercall, tokenIn == NATIVE ? amountIn : 0);
     }
 }

package/contracts/libraries/math/WeekMath.sol

@@ -3,7 +3,7 @@
 pragma solidity 0.8.15;
 
 library WeekMath {
-    uint128 internal constant WEEK = 7 days;
+    uint128 internal constant WEEK = 2 hours;
 
     function getWeekStartTimestamp(uint128 timestamp) internal pure returns (uint128) {
         return (timestamp / WEEK) * WEEK;

package/contracts/offchain-helpers/RouterStatic.sol

@@ -4,12 +4,12 @@ pragma solidity 0.8.15;
 import "../interfaces/IPYieldContractFactory.sol";
 import "../interfaces/IPMarketFactory.sol";
 import "./MarketMathStatic.sol";
-import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
-import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../periphery/BoringOwnableUpgradeable.sol";
 
 /// EXCLUDED FROM ALL AUDITS, TO BE CALLED ONLY BY PENDLE's SDK
-contract RouterStatic is OwnableUpgradeable, UUPSUpgradeable {
+contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable {
     using Math for uint256;
 
     struct TokenAmount {
@@ -56,7 +56,7 @@ contract RouterStatic is OwnableUpgradeable, UUPSUpgradeable {
     }
 
     function initialize() external initializer {
-        __Ownable_init();
+        __BoringOwnable_init();
     }
 
     function getDefaultApproxParams() public pure returns (ApproxParams memory) {

package/contracts/offchain-helpers/SSTORE2DeployerContract.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "../libraries/helpers/SSTORE2Deployer.sol";
+import "../periphery/BoringOwnableUpgradeable.sol";
+
+contract SSTORE2DeployerContract is BoringOwnableUpgradeable {
+    event Deployed(string name, address addr);
+
+    constructor() {
+        __BoringOwnable_init();
+    }
+
+    function deploy(string memory name, bytes calldata creationCode)
+        external
+        onlyOwner
+        returns (address res)
+    {
+        res = SSTORE2Deployer.setCreationCode(creationCode);
+        emit Deployed(name, res);
+    }
+}

package/contracts/periphery/BoringOwnableUpgradeable.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.15;
 
-import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 
 contract BoringOwnableUpgradeableData {
     address public owner;
     address public pendingOwner;
 }
 
-contract BoringOwnableUpgradeable is BoringOwnableUpgradeableData, Initializable {
+abstract contract BoringOwnableUpgradeable is BoringOwnableUpgradeableData, Initializable {
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
 
     function __BoringOwnable_init() internal onlyInitializing {

package/deployments/43113-core.json

@@ -1,15 +1,16 @@
 {
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "sstore2": "0x00E8aAE633b426cb67614f432B4604C6fA2BF101",
     "network": 43113,
     "celerBus": "0xE9533976C590200E32d95C53f06AE12d292cFc47",
     "treasury": "0xB4E292AD98Ba0D5531Ca573757f7b7d6c0C205d8",
     "PENDLE": "0x83B694f9Ef84D22BECe87257f0cd4513737A505e",
-    "yieldContractFactory": "0x5742c40cF2005cC5D603305d43Ab5ca74A1928D5",
-    "marketFactory": "0x59A5849f292536B99A2cE14b4E8484A74894DBfb",
-    "router": "0xa4C21f51DE870a283f362A7331f0C4f8288c3e41",
-    "routerStatic": "0x7d8Cd904F0b7d06fB846110817bA3519bf76381a",
+    "yieldContractFactory": "0x2e5DF6e3DA5Ae730aC357Ca1b6a823A9B0EAFaC0",
+    "marketFactory": "0x3Ba006773B0cfd7f3549B2D4259524FCb3dCC8E2",
+    "router": "0x17C433893321F4457066045E1356e8E8B0C5F596",
+    "routerStatic": "0x8CC254DcaE3d01c4Aff79A396d94623E4D9dD2b1",
     "startTime": 1657756800,
-    "vePendle": "0x07791cc760e9483b0474625fEac0414cCeB30C63",
-    "votingController": "0x366c1084FBA02D9929f4d2521a92bDd4E4082B5A",
-    "gaugeController": "0xC0BC61112D9fD7bA5809047a86EC245593BA0e1E"
+    "vePendle": "0xdc6aFe3Aae143f73Abc84766E9c99f18fF3c5aAe",
+    "votingController": "0x7d9Bd862090337D572c50068b40E39F76b8dFE03",
+    "gaugeController": "0xcE19aEaBE9229F8070ADe311A2d3aAf4f6864B26"
 }

package/deployments/43113-markets/benqi-market-QI-USDC-FEB-2ND.json

@@ -0,0 +1,8 @@
+{
+    "symbol": "SCY-qiUSDC",
+    "SCY": "0xe41eebdC5124693cD9C18162D375590273a911Ed",
+    "expiry": 1675382400,
+    "PT": "0xF8F6ca86D40A8a9FFc0aC2D9F96a1A439b5535A8",
+    "YT": "0x924b41c12FE9b9DAA311E0e0B050C16538c70283",
+    "market": "0x485991210C8ec45644588EC1f4957d3d0aA0cE39"
+}

package/deployments/43113-markets/benqi-market-QI-USDC-SEP-22TH.json

@@ -0,0 +1,8 @@
+{
+    "symbol": "SCY-qiUSDC",
+    "SCY": "0xe41eebdC5124693cD9C18162D375590273a911Ed",
+    "expiry": 1663804800,
+    "PT": "0x549b110782B89bd40018c12BC1770Cc55e6a2267",
+    "YT": "0x80F8302a86775A810c2233e3AbE62990f7cc1051",
+    "market": "0x6b2CC53E2c08b9054D00a4a84bf22462a18A249f"
+}

package/deployments/43113-markets/benqi-market-QI-WETH-DEC-1ST.json

@@ -0,0 +1,8 @@
+{
+    "symbol": "SCY-qiWETH",
+    "SCY": "0x92A502318c1d77f3b2eFCb1BD8ee625Ad206A8d5",
+    "expiry": 1669852800,
+    "PT": "0x59E95f6f2191bc7dB730a3125cB76c3a4A35a835",
+    "YT": "0xf400888C27f134E8cd6313E33d10d2526dec8697",
+    "market": "0xbF23860F807Dbc7678Cf53be78D06A14A5c36D16"
+}

package/deployments/43113-testenv.json

@@ -1,7 +1,7 @@
 {
     "tokens": {
         "fundKeeper": "0x45e03eB183962884d50eC0Af39B03970333426cb",
-        "faucet": "0x1A2775c9bEe6e798De971c369849CF9130D3e25a",
+        "faucet": "0x6C881F2b27aB065c6b6fbDf1407f2895104D5856",
         "WAVAX": "0xe43a7aD7C09d8fAE3ADe7361f0b847b23adD5094",
         "DAI": "0xCd3748CE3Bf75A01D99Bf301668E0748558a592C",
         "USDC": "0xc2A6b8d7d0FAB3749A6Bda84cEdb58D2d58f045e",

package/deployments/80001-core.json

@@ -4,11 +4,11 @@
     "celerBus": "0x7d43AABC515C356145049227CeE54B608342c0ad",
     "treasury": "0x1fAd3Ce1c1aB563441d58b79e49cb0ebC12C1Bd5",
     "PENDLE": "0x563f1e87a6a3Cb4A84F7D438fCF4882133e59d6d",
-    "yieldContractFactory": "0x752D7B5Cfc84902b25a27Ee9A83Ac3E43aa6c604",
-    "marketFactory": "0xE7EA255aF935D10b59FCfcd704ED3E672044c9cd",
+    "yieldContractFactory": "0x7Ff62939e06412eE0B2b0CB0682E9B29dEd23931",
+    "marketFactory": "0xE05082B184a34668CD8A904D85FA815802BBb04c",
     "router": "0x124e2c48433aEe932B39D6aC897660be7A33B9D5",
     "routerStatic": "0xE1c4749b480baA22B070230Aa07a7fCEd4Fdbf0F",
     "startTime": 1657756800,
-    "vePendle": "0xd6c820F37d876dA4f39329c5D5c6a7dC932b38dE",
-    "gaugeController": "0x10CEaB79805F36fD0BD4E93bf98a7C7d6A99FD77"
+    "vePendle": "0xae3764a46934E2E32495bfA3B82d3E3Fdf51dF9F",
+    "gaugeController": "0xf10e6Ac14Bc19D944233C64434D158a0b318F1fB"
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.10.5-testnet",
+  "version": "0.11.1-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,7 +25,7 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.10.2",
+    "hardhat": "^2.11.0",
     "hardhat-contract-sizer": "^2.6.1",
     "hardhat-storage-layout-diff": "^0.0.4",
     "prettier": "^2.7.1",
@@ -34,7 +34,7 @@
     "solhint": "^3.3.7",
     "ts-node": "^10.9.1",
     "typechain": "^8.1.0",
-    "typescript": "^4.7.4"
+    "typescript": "^4.8.2"
   },
   "scripts": {
     "compile": "yarn hardhat compile",
@@ -44,7 +44,6 @@
   },
   "packageManager": "yarn@3.2.2",
   "dependencies": {
-    "@openzeppelin/contracts": "^4.5.0",
-    "@openzeppelin/contracts-upgradeable": "^4.5.2"
+    "@openzeppelin/contracts": "^4.5.0"
   }
 }

package/typechain-types/ActionAddRemoveLiq.ts

@@ -580,7 +580,7 @@ export interface ActionAddRemoveLiq extends BaseContract {
     ): Promise<
       [BigNumber, BigNumber, BigNumber] & {
         netLpOut: BigNumber;
-        scyUsed: BigNumber;
+        netScyUsed: BigNumber;
         netPtUsed: BigNumber;
       }
     >;

package/typechain-types/FeeDistributorAbstract.ts

@@ -0,0 +1,240 @@
+/* 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 FeeDistributorAbstractInterface extends utils.Interface {
+  contractName: "FeeDistributorAbstract";
+  functions: {
+    "claimReward(address,address)": FunctionFragment;
+    "deployedEpoch()": FunctionFragment;
+    "fund(address,uint256,uint256)": FunctionFragment;
+    "incentivesForEpoch(uint256,address)": FunctionFragment;
+    "updateUserShare(address)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "claimReward",
+    values: [string, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "deployedEpoch",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "fund",
+    values: [string, BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "incentivesForEpoch",
+    values: [BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "updateUserShare",
+    values: [string]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "claimReward",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "deployedEpoch",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "fund", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "incentivesForEpoch",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "updateUserShare",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface FeeDistributorAbstract extends BaseContract {
+  contractName: "FeeDistributorAbstract";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: FeeDistributorAbstractInterface;
+
+  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: {
+    claimReward(
+      user: string,
+      rewardToken: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    deployedEpoch(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    fund(
+      rewardToken: string,
+      amount: BigNumberish,
+      numEpoch: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    incentivesForEpoch(
+      arg0: BigNumberish,
+      arg1: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    updateUserShare(
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  claimReward(
+    user: string,
+    rewardToken: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  deployedEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+  fund(
+    rewardToken: string,
+    amount: BigNumberish,
+    numEpoch: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  incentivesForEpoch(
+    arg0: BigNumberish,
+    arg1: string,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  updateUserShare(
+    user: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    claimReward(
+      user: string,
+      rewardToken: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    deployedEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+    fund(
+      rewardToken: string,
+      amount: BigNumberish,
+      numEpoch: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    incentivesForEpoch(
+      arg0: BigNumberish,
+      arg1: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    updateUserShare(user: string, overrides?: CallOverrides): Promise<void>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    claimReward(
+      user: string,
+      rewardToken: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    deployedEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+    fund(
+      rewardToken: string,
+      amount: BigNumberish,
+      numEpoch: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    incentivesForEpoch(
+      arg0: BigNumberish,
+      arg1: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    updateUserShare(
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    claimReward(
+      user: string,
+      rewardToken: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    deployedEpoch(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    fund(
+      rewardToken: string,
+      amount: BigNumberish,
+      numEpoch: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    incentivesForEpoch(
+      arg0: BigNumberish,
+      arg1: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    updateUserShare(
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}