@pendle/core-v2 1.1.0-mainnet → 1.2.0-mainnet

package/contracts/offchain-helpers/Multicall2.sol

@@ -0,0 +1,103 @@
+pragma solidity >=0.5.0;
+pragma experimental ABIEncoderV2;
+
+/// @title Multicall2 - Aggregate results from multiple read-only function calls
+/// @author Michael Elliot <mike@makerdao.com>
+/// @author Joshua Levine <joshua@makerdao.com>
+/// @author Nick Johnson <arachnid@notdot.net>
+
+contract Multicall2 {
+    struct Call {
+        address target;
+        bytes callData;
+    }
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function aggregate(Call[] memory calls)
+        public
+        returns (uint256 blockNumber, bytes[] memory returnData)
+    {
+        blockNumber = block.number;
+        returnData = new bytes[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+            require(success, "Multicall aggregate: call failed");
+            returnData[i] = ret;
+        }
+    }
+
+    function blockAndAggregate(Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
+    }
+
+    function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash) {
+        blockHash = blockhash(blockNumber);
+    }
+
+    function getBlockNumber() public view returns (uint256 blockNumber) {
+        blockNumber = block.number;
+    }
+
+    function getCurrentBlockCoinbase() public view returns (address coinbase) {
+        coinbase = block.coinbase;
+    }
+
+    function getCurrentBlockDifficulty() public view returns (uint256 difficulty) {
+        difficulty = block.difficulty;
+    }
+
+    function getCurrentBlockGasLimit() public view returns (uint256 gaslimit) {
+        gaslimit = block.gaslimit;
+    }
+
+    function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
+        timestamp = block.timestamp;
+    }
+
+    function getEthBalance(address addr) public view returns (uint256 balance) {
+        balance = addr.balance;
+    }
+
+    function getLastBlockHash() public view returns (bytes32 blockHash) {
+        blockHash = blockhash(block.number - 1);
+    }
+
+    function tryAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (Result[] memory returnData)
+    {
+        returnData = new Result[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+
+            if (requireSuccess) {
+                require(success, "Multicall2 aggregate: call failed");
+            }
+
+            returnData[i] = Result(success, ret);
+        }
+    }
+
+    function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        blockNumber = block.number;
+        blockHash = blockhash(block.number);
+        returnData = tryAggregate(requireSuccess, calls);
+    }
+}

package/contracts/router/kyberswap/AggregationRouterHelper.sol

@@ -1,8 +1,8 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-License-Identifier: MIT
 
 pragma solidity 0.8.17;
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "./IMultihopRouter.sol";
+import "./IMultihopRouterEthereum.sol";
 import "./IAggregatorRouterHelper.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../../core/libraries/BoringOwnableUpgradeable.sol";
@@ -40,8 +40,7 @@ contract AggregationRouterHelper is
         BALANCERV2,
         KYBERRFQ,
         DODO,
-        VELODROME,
-        PLATYPUS
+        WSTETH
     }
 
     struct SwapDescription {
@@ -65,7 +64,7 @@ contract AggregationRouterHelper is
     }
 
     struct SwapExecutorDescription {
-        IMultihopRouter.Swap[][] swapSequences;
+        IMultihopRouterEthereum.Swap[][] swapSequences;
         address tokenIn;
         address tokenOut;
         uint256 minTotalAmountOut;
@@ -178,7 +177,7 @@ contract AggregationRouterHelper is
 
         uint256 newTotalSwapAmount;
         for (uint256 i = 0; i < swapExecutorDescription.swapSequences.length; i++) {
-            IMultihopRouter.Swap memory swap = swapExecutorDescription.swapSequences[i][0];
+            IMultihopRouterEthereum.Swap memory swap = swapExecutorDescription.swapSequences[i][0];
             uint8 dexType = uint8(swap.dexOption >> 8);
             uint256 value;
             if (i == swapExecutorDescription.swapSequences.length - 1)
@@ -200,8 +199,8 @@ contract AggregationRouterHelper is
                 revert("kyber: can't scale kyberrfq");
             } else if (dexType == uint8(DexType.DODO)) {
                 (swap.data, value) = _newDODOSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.VELODROME)) {
-                (swap.data, value) = _newVelodromeSwap(swap.data, value, oldAmount, newAmount);
+            } else if (dexType == uint8(DexType.WSTETH)) {
+                (swap.data, value) = _newWrappedstETHSwap(swap.data, value, oldAmount, newAmount);
             } else {
                 revert("AggregationExecutor: Dex type not supported");
             }
@@ -216,7 +215,10 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory uniSwap = abi.decode(data, (IMultihopRouter.UniSwap));
+        IMultihopRouterEthereum.UniSwap memory uniSwap = abi.decode(
+            data,
+            (IMultihopRouterEthereum.UniSwap)
+        );
         if (value > 0) uniSwap.collectAmount = value;
         else uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
         return (abi.encode(uniSwap), uniSwap.collectAmount);
@@ -228,9 +230,9 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.StableSwap memory stableSwap = abi.decode(
+        IMultihopRouterEthereum.StableSwap memory stableSwap = abi.decode(
             data,
-            (IMultihopRouter.StableSwap)
+            (IMultihopRouterEthereum.StableSwap)
         );
         if (value > 0) stableSwap.dx = value;
         else stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
@@ -243,7 +245,10 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.CurveSwap memory curveSwap = abi.decode(data, (IMultihopRouter.CurveSwap));
+        IMultihopRouterEthereum.CurveSwap memory curveSwap = abi.decode(
+            data,
+            (IMultihopRouterEthereum.CurveSwap)
+        );
         if (value > 0) curveSwap.dx = value;
         else curveSwap.dx = (curveSwap.dx * newAmount) / oldAmount;
         return (abi.encode(curveSwap), curveSwap.dx);
@@ -255,7 +260,10 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory kyberDMMSwap = abi.decode(data, (IMultihopRouter.UniSwap));
+        IMultihopRouterEthereum.UniSwap memory kyberDMMSwap = abi.decode(
+            data,
+            (IMultihopRouterEthereum.UniSwap)
+        );
         if (value > 0) kyberDMMSwap.collectAmount = value;
         else kyberDMMSwap.collectAmount = (kyberDMMSwap.collectAmount * newAmount) / oldAmount;
         return (abi.encode(kyberDMMSwap), kyberDMMSwap.collectAmount);
@@ -267,9 +275,9 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
+        IMultihopRouterEthereum.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
             data,
-            (IMultihopRouter.UniSwapV3ProMM)
+            (IMultihopRouterEthereum.UniSwapV3ProMM)
         );
         if (value > 0) uniSwapV3ProMM.swapAmount = value;
         else uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
@@ -282,9 +290,9 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.BalancerV2 memory balancerV2 = abi.decode(
+        IMultihopRouterEthereum.BalancerV2 memory balancerV2 = abi.decode(
             data,
-            (IMultihopRouter.BalancerV2)
+            (IMultihopRouterEthereum.BalancerV2)
         );
         if (value > 0) balancerV2.amount = value;
         else balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
@@ -297,21 +305,27 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.DODO memory dodo = abi.decode(data, (IMultihopRouter.DODO));
+        IMultihopRouterEthereum.DODO memory dodo = abi.decode(
+            data,
+            (IMultihopRouterEthereum.DODO)
+        );
         if (value > 0) dodo.amount = value;
         else dodo.amount = (dodo.amount * newAmount) / oldAmount;
         return (abi.encode(dodo), dodo.amount);
     }
 
-    function _newVelodromeSwap(
+    function _newWrappedstETHSwap(
         bytes memory data,
         uint256 value,
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory velodrome = abi.decode(data, (IMultihopRouter.UniSwap));
-        if (value > 0) velodrome.collectAmount = value;
-        else velodrome.collectAmount = (velodrome.collectAmount * newAmount) / oldAmount;
-        return (abi.encode(velodrome), velodrome.collectAmount);
+        IMultihopRouterEthereum.WSTETH memory wstEthData = abi.decode(
+            data,
+            (IMultihopRouterEthereum.WSTETH)
+        );
+        if (value > 0) wstEthData.amount = value;
+        else wstEthData.amount = (wstEthData.amount * newAmount) / oldAmount;
+        return (abi.encode(wstEthData), wstEthData.amount);
     }
 }

package/contracts/router/kyberswap/{IMultihopRouter.sol → IMultihopRouterEthereum.sol}

@@ -1,10 +1,8 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-License-Identifier: MIT
 
-pragma solidity >=0.7.6;
+pragma solidity 0.8.17;
 
-pragma abicoder v2;
-
-interface IMultihopRouter {
+interface IMultihopRouterEthereum {
     enum DexType {
         UNI,
         STABLESWAP,
@@ -15,8 +13,7 @@ interface IMultihopRouter {
         BALANCERV2,
         KYBERRFQ,
         DODO,
-        VELODROME,
-        PLATYPUS
+        WSTETH
     }
 
     event Exchange(address pair, uint256 amountOut, address output);
@@ -32,13 +29,18 @@ interface IMultihopRouter {
         //  6: balancerv2
         //  7: kyber RFQ
         //  8: dodo
-        //  9: velodrome
-        //  10: platypus
+        //  9: wstETH: Lido wrapped stETH
         //dexId:
         //  0: firebird
         uint16 dexOption; //dexType(8bit) + dexId(8bit)
     }
 
+    struct WSTETH {
+        address pool;
+        uint256 amount;
+        bool isWrapping;
+    }
+
     struct UniSwap {
         address pool;
         address tokenIn;

package/deployments/1-core.json

@@ -25,5 +25,6 @@
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
-    "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57"
+    "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
+    "feedistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2"
 }

package/package.json

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

package/typechain-types/BribeDistributor.ts

@@ -0,0 +1,363 @@
+/* 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, EventFragment } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface BribeDistributorInterface extends utils.Interface {
+  contractName: "BribeDistributor";
+  functions: {
+    "claimReward(address)": FunctionFragment;
+    "factory()": FunctionFragment;
+    "fund(uint256[],uint256[])": FunctionFragment;
+    "incentivesForEpoch(uint256)": FunctionFragment;
+    "initialize(address,address,uint256,address)": FunctionFragment;
+    "pool()": FunctionFragment;
+    "rewardToken()": FunctionFragment;
+    "startEpoch()": FunctionFragment;
+    "userUnclaimedEpoch(address)": FunctionFragment;
+  };
+
+  encodeFunctionData(functionFragment: "claimReward", values: [string]): string;
+  encodeFunctionData(functionFragment: "factory", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "fund",
+    values: [BigNumberish[], BigNumberish[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "incentivesForEpoch",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "initialize",
+    values: [string, string, BigNumberish, string]
+  ): string;
+  encodeFunctionData(functionFragment: "pool", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "rewardToken",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "startEpoch",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "userUnclaimedEpoch",
+    values: [string]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "claimReward",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "fund", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "incentivesForEpoch",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "pool", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "rewardToken",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "startEpoch", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "userUnclaimedEpoch",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "ClaimReward(address,address,uint256,uint256)": EventFragment;
+    "Fund(uint256,uint256)": EventFragment;
+    "Initialized(uint8)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "ClaimReward"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Fund"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+
+export type ClaimRewardEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  {
+    user: string;
+    rewardToken: string;
+    lastEpochClaimed: BigNumber;
+    totalReward: BigNumber;
+  }
+>;
+
+export type ClaimRewardEventFilter = TypedEventFilter<ClaimRewardEvent>;
+
+export type FundEvent = TypedEvent<
+  [BigNumber, BigNumber],
+  { epoch: BigNumber; incentive: BigNumber }
+>;
+
+export type FundEventFilter = TypedEventFilter<FundEvent>;
+
+export type InitializedEvent = TypedEvent<[number], { version: number }>;
+
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+
+export interface BribeDistributor extends BaseContract {
+  contractName: "BribeDistributor";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: BribeDistributorInterface;
+
+  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,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    factory(overrides?: CallOverrides): Promise<[string]>;
+
+    fund(
+      epochs: BigNumberish[],
+      rewardsForEpoch: BigNumberish[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    incentivesForEpoch(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    initialize(
+      _pool: string,
+      _rewardToken: string,
+      _startEpoch: BigNumberish,
+      _factory: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    pool(overrides?: CallOverrides): Promise<[string]>;
+
+    rewardToken(overrides?: CallOverrides): Promise<[string]>;
+
+    startEpoch(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    userUnclaimedEpoch(
+      arg0: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+  };
+
+  claimReward(
+    user: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  factory(overrides?: CallOverrides): Promise<string>;
+
+  fund(
+    epochs: BigNumberish[],
+    rewardsForEpoch: BigNumberish[],
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  incentivesForEpoch(
+    arg0: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  initialize(
+    _pool: string,
+    _rewardToken: string,
+    _startEpoch: BigNumberish,
+    _factory: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  pool(overrides?: CallOverrides): Promise<string>;
+
+  rewardToken(overrides?: CallOverrides): Promise<string>;
+
+  startEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+  userUnclaimedEpoch(
+    arg0: string,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  callStatic: {
+    claimReward(user: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    factory(overrides?: CallOverrides): Promise<string>;
+
+    fund(
+      epochs: BigNumberish[],
+      rewardsForEpoch: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    incentivesForEpoch(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    initialize(
+      _pool: string,
+      _rewardToken: string,
+      _startEpoch: BigNumberish,
+      _factory: string,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    pool(overrides?: CallOverrides): Promise<string>;
+
+    rewardToken(overrides?: CallOverrides): Promise<string>;
+
+    startEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+    userUnclaimedEpoch(
+      arg0: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    "ClaimReward(address,address,uint256,uint256)"(
+      user?: string | null,
+      rewardToken?: string | null,
+      lastEpochClaimed?: null,
+      totalReward?: null
+    ): ClaimRewardEventFilter;
+    ClaimReward(
+      user?: string | null,
+      rewardToken?: string | null,
+      lastEpochClaimed?: null,
+      totalReward?: null
+    ): ClaimRewardEventFilter;
+
+    "Fund(uint256,uint256)"(
+      epoch?: BigNumberish | null,
+      incentive?: null
+    ): FundEventFilter;
+    Fund(epoch?: BigNumberish | null, incentive?: null): FundEventFilter;
+
+    "Initialized(uint8)"(version?: null): InitializedEventFilter;
+    Initialized(version?: null): InitializedEventFilter;
+  };
+
+  estimateGas: {
+    claimReward(
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    factory(overrides?: CallOverrides): Promise<BigNumber>;
+
+    fund(
+      epochs: BigNumberish[],
+      rewardsForEpoch: BigNumberish[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    incentivesForEpoch(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    initialize(
+      _pool: string,
+      _rewardToken: string,
+      _startEpoch: BigNumberish,
+      _factory: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    pool(overrides?: CallOverrides): Promise<BigNumber>;
+
+    rewardToken(overrides?: CallOverrides): Promise<BigNumber>;
+
+    startEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+    userUnclaimedEpoch(
+      arg0: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    claimReward(
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    factory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    fund(
+      epochs: BigNumberish[],
+      rewardsForEpoch: BigNumberish[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    incentivesForEpoch(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    initialize(
+      _pool: string,
+      _rewardToken: string,
+      _startEpoch: BigNumberish,
+      _factory: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    pool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    rewardToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    startEpoch(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    userUnclaimedEpoch(
+      arg0: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}