@augmentedfinance/protocol-v1/dist/types/RewardConfigurator.d.ts

Augmented Protocol smart contracts

/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
} from "ethers";
import {
  Contract,
  ContractTransaction,
  Overrides,
  CallOverrides,
} from "@ethersproject/contracts";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";

interface RewardConfiguratorInterface extends ethers.utils.Interface {
  functions: {
    "REVISION()": FunctionFragment;
    "addNamedRewardPools(address[],string[],uint32[])": FunctionFragment;
    "batchInitRewardPools(tuple[])": FunctionFragment;
    "buildRewardPoolInitData(string,uint16)": FunctionFragment;
    "buildRewardTokenInitData(string,string,uint8)": FunctionFragment;
    "configureRewardBoost(address,bool,address,bool)": FunctionFragment;
    "configureTeamRewardPool(address,string,uint32,address[],uint16[])": FunctionFragment;
    "getDefaultController()": FunctionFragment;
    "getNamedRewardPools(string[])": FunctionFragment;
    "getPoolParams(address[])": FunctionFragment;
    "getPoolTotals(bool)": FunctionFragment;
    "getProxyAdmin()": FunctionFragment;
    "getRewardedTokenParams(address[])": FunctionFragment;
    "implementationOf(address)": FunctionFragment;
    "initialize(address)": FunctionFragment;
    "list()": FunctionFragment;
    "updateRewardPool(tuple)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "REVISION", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "addNamedRewardPools",
    values: [string[], string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "batchInitRewardPools",
    values: [
      {
        provider: string;
        impl: string;
        poolName: string;
        initialRate: BigNumberish;
        boostFactor: BigNumberish;
        baselinePercentage: BigNumberish;
      }[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "buildRewardPoolInitData",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "buildRewardTokenInitData",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "configureRewardBoost",
    values: [string, boolean, string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "configureTeamRewardPool",
    values: [string, string, BigNumberish, string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "getDefaultController",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getNamedRewardPools",
    values: [string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolParams",
    values: [string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolTotals",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "getProxyAdmin",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getRewardedTokenParams",
    values: [string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "implementationOf",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "initialize", values: [string]): string;
  encodeFunctionData(functionFragment: "list", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "updateRewardPool",
    values: [{ pool: string; impl: string }]
  ): string;

  decodeFunctionResult(functionFragment: "REVISION", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "addNamedRewardPools",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "batchInitRewardPools",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "buildRewardPoolInitData",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "buildRewardTokenInitData",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "configureRewardBoost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "configureTeamRewardPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDefaultController",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getNamedRewardPools",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPoolParams",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPoolTotals",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProxyAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRewardedTokenParams",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "implementationOf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "list", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "updateRewardPool",
    data: BytesLike
  ): Result;

  events: {
    "RewardPoolInitialized(address,address,tuple)": EventFragment;
    "RewardPoolUpgraded(address,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "RewardPoolInitialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardPoolUpgraded"): EventFragment;
}

export class RewardConfigurator extends Contract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  on(event: EventFilter | string, listener: Listener): this;
  once(event: EventFilter | string, listener: Listener): this;
  addListener(eventName: EventFilter | string, listener: Listener): this;
  removeAllListeners(eventName: EventFilter | string): this;
  removeListener(eventName: any, listener: Listener): this;

  interface: RewardConfiguratorInterface;

  functions: {
    REVISION(overrides?: CallOverrides): Promise<{
      0: BigNumber;
    }>;

    "REVISION()"(overrides?: CallOverrides): Promise<{
      0: BigNumber;
    }>;

    addNamedRewardPools(
      pools: string[],
      names: string[],
      boostFactors: BigNumberish[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "addNamedRewardPools(address[],string[],uint32[])"(
      pools: string[],
      names: string[],
      boostFactors: BigNumberish[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    batchInitRewardPools(
      entries: {
        provider: string;
        impl: string;
        poolName: string;
        initialRate: BigNumberish;
        boostFactor: BigNumberish;
        baselinePercentage: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "batchInitRewardPools(tuple[])"(
      entries: {
        provider: string;
        impl: string;
        poolName: string;
        initialRate: BigNumberish;
        boostFactor: BigNumberish;
        baselinePercentage: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    buildRewardPoolInitData(
      poolName: string,
      baselinePercentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: string;
    }>;

    "buildRewardPoolInitData(string,uint16)"(
      poolName: string,
      baselinePercentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: string;
    }>;

    buildRewardTokenInitData(
      name: string,
      symbol: string,
      decimals: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: string;
    }>;

    "buildRewardTokenInitData(string,string,uint8)"(
      name: string,
      symbol: string,
      decimals: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: string;
    }>;

    configureRewardBoost(
      boostPool: string,
      updateRate: boolean,
      excessTarget: string,
      mintExcess: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "configureRewardBoost(address,bool,address,bool)"(
      boostPool: string,
      updateRate: boolean,
      excessTarget: string,
      mintExcess: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    configureTeamRewardPool(
      pool: string,
      name: string,
      unlockedAt: BigNumberish,
      members: string[],
      memberShares: BigNumberish[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "configureTeamRewardPool(address,string,uint32,address[],uint16[])"(
      pool: string,
      name: string,
      unlockedAt: BigNumberish,
      members: string[],
      memberShares: BigNumberish[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    getDefaultController(overrides?: CallOverrides): Promise<{
      0: string;
    }>;

    "getDefaultController()"(overrides?: CallOverrides): Promise<{
      0: string;
    }>;

    getNamedRewardPools(
      names: string[],
      overrides?: CallOverrides
    ): Promise<{
      pools: string[];
      0: string[];
    }>;

    "getNamedRewardPools(string[])"(
      names: string[],
      overrides?: CallOverrides
    ): Promise<{
      pools: string[];
      0: string[];
    }>;

    getPoolParams(
      pools: string[],
      overrides?: CallOverrides
    ): Promise<{
      controllers: string[];
      rates: BigNumber[];
      baselinePcts: number[];
      0: string[];
      1: BigNumber[];
      2: number[];
    }>;

    "getPoolParams(address[])"(
      pools: string[],
      overrides?: CallOverrides
    ): Promise<{
      controllers: string[];
      rates: BigNumber[];
      baselinePcts: number[];
      0: string[];
      1: BigNumber[];
      2: number[];
    }>;

    getPoolTotals(
      excludeBoost: boolean,
      overrides?: CallOverrides
    ): Promise<{
      totalBaselinePercentage: BigNumber;
      totalRate: BigNumber;
      activePoolCount: BigNumber;
      poolCount: BigNumber;
      listCount: BigNumber;
      0: BigNumber;
      1: BigNumber;
      2: BigNumber;
      3: BigNumber;
      4: BigNumber;
    }>;

    "getPoolTotals(bool)"(
      excludeBoost: boolean,
      overrides?: CallOverrides
    ): Promise<{
      totalBaselinePercentage: BigNumber;
      totalRate: BigNumber;
      activePoolCount: BigNumber;
      poolCount: BigNumber;
      listCount: BigNumber;
      0: BigNumber;
      1: BigNumber;
      2: BigNumber;
      3: BigNumber;
      4: BigNumber;
    }>;

    getProxyAdmin(overrides?: CallOverrides): Promise<{
      0: string;
    }>;

    "getProxyAdmin()"(overrides?: CallOverrides): Promise<{
      0: string;
    }>;

    getRewardedTokenParams(
      tokens: string[],
      overrides?: CallOverrides
    ): Promise<{
      pools: string[];
      controllers: string[];
      rates: BigNumber[];
      baselinePcts: number[];
      0: string[];
      1: string[];
      2: BigNumber[];
      3: number[];
    }>;

    "getRewardedTokenParams(address[])"(
      tokens: string[],
      overrides?: CallOverrides
    ): Promise<{
      pools: string[];
      controllers: string[];
      rates: BigNumber[];
      baselinePcts: number[];
      0: string[];
      1: string[];
      2: BigNumber[];
      3: number[];
    }>;

    implementationOf(
      token: string,
      overrides?: CallOverrides
    ): Promise<{
      0: string;
    }>;

    "implementationOf(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<{
      0: string;
    }>;

    initialize(
      addressesProvider: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "initialize(address)"(
      addressesProvider: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    list(overrides?: CallOverrides): Promise<{
      pools: string[];
      0: string[];
    }>;

    "list()"(overrides?: CallOverrides): Promise<{
      pools: string[];
      0: string[];
    }>;

    updateRewardPool(
      input: { pool: string; impl: string },
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "updateRewardPool((address,address))"(
      input: { pool: string; impl: string },
      overrides?: Overrides
    ): Promise<ContractTransaction>;
  };

  REVISION(overrides?: CallOverrides): Promise<BigNumber>;

  "REVISION()"(overrides?: CallOverrides): Promise<BigNumber>;

  addNamedRewardPools(
    pools: string[],
    names: string[],
    boostFactors: BigNumberish[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "addNamedRewardPools(address[],string[],uint32[])"(
    pools: string[],
    names: string[],
    boostFactors: BigNumberish[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  batchInitRewardPools(
    entries: {
      provider: string;
      impl: string;
      poolName: string;
      initialRate: BigNumberish;
      boostFactor: BigNumberish;
      baselinePercentage: BigNumberish;
    }[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "batchInitRewardPools(tuple[])"(
    entries: {
      provider: string;
      impl: string;
      poolName: string;
      initialRate: BigNumberish;
      boostFactor: BigNumberish;
      baselinePercentage: BigNumberish;
    }[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  buildRewardPoolInitData(
    poolName: string,
    baselinePercentage: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  "buildRewardPoolInitData(string,uint16)"(
    poolName: string,
    baselinePercentage: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  buildRewardTokenInitData(
    name: string,
    symbol: string,
    decimals: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  "buildRewardTokenInitData(string,string,uint8)"(
    name: string,
    symbol: string,
    decimals: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  configureRewardBoost(
    boostPool: string,
    updateRate: boolean,
    excessTarget: string,
    mintExcess: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "configureRewardBoost(address,bool,address,bool)"(
    boostPool: string,
    updateRate: boolean,
    excessTarget: string,
    mintExcess: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  configureTeamRewardPool(
    pool: string,
    name: string,
    unlockedAt: BigNumberish,
    members: string[],
    memberShares: BigNumberish[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "configureTeamRewardPool(address,string,uint32,address[],uint16[])"(
    pool: string,
    name: string,
    unlockedAt: BigNumberish,
    members: string[],
    memberShares: BigNumberish[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  getDefaultController(overrides?: CallOverrides): Promise<string>;

  "getDefaultController()"(overrides?: CallOverrides): Promise<string>;

  getNamedRewardPools(
    names: string[],
    overrides?: CallOverrides
  ): Promise<string[]>;

  "getNamedRewardPools(string[])"(
    names: string[],
    overrides?: CallOverrides
  ): Promise<string[]>;

  getPoolParams(
    pools: string[],
    overrides?: CallOverrides
  ): Promise<{
    controllers: string[];
    rates: BigNumber[];
    baselinePcts: number[];
    0: string[];
    1: BigNumber[];
    2: number[];
  }>;

  "getPoolParams(address[])"(
    pools: string[],
    overrides?: CallOverrides
  ): Promise<{
    controllers: string[];
    rates: BigNumber[];
    baselinePcts: number[];
    0: string[];
    1: BigNumber[];
    2: number[];
  }>;

  getPoolTotals(
    excludeBoost: boolean,
    overrides?: CallOverrides
  ): Promise<{
    totalBaselinePercentage: BigNumber;
    totalRate: BigNumber;
    activePoolCount: BigNumber;
    poolCount: BigNumber;
    listCount: BigNumber;
    0: BigNumber;
    1: BigNumber;
    2: BigNumber;
    3: BigNumber;
    4: BigNumber;
  }>;

  "getPoolTotals(bool)"(
    excludeBoost: boolean,
    overrides?: CallOverrides
  ): Promise<{
    totalBaselinePercentage: BigNumber;
    totalRate: BigNumber;
    activePoolCount: BigNumber;
    poolCount: BigNumber;
    listCount: BigNumber;
    0: BigNumber;
    1: BigNumber;
    2: BigNumber;
    3: BigNumber;
    4: BigNumber;
  }>;

  getProxyAdmin(overrides?: CallOverrides): Promise<string>;

  "getProxyAdmin()"(overrides?: CallOverrides): Promise<string>;

  getRewardedTokenParams(
    tokens: string[],
    overrides?: CallOverrides
  ): Promise<{
    pools: string[];
    controllers: string[];
    rates: BigNumber[];
    baselinePcts: number[];
    0: string[];
    1: string[];
    2: BigNumber[];
    3: number[];
  }>;

  "getRewardedTokenParams(address[])"(
    tokens: string[],
    overrides?: CallOverrides
  ): Promise<{
    pools: string[];
    controllers: string[];
    rates: BigNumber[];
    baselinePcts: number[];
    0: string[];
    1: string[];
    2: BigNumber[];
    3: number[];
  }>;

  implementationOf(token: string, overrides?: CallOverrides): Promise<string>;

  "implementationOf(address)"(
    token: string,
    overrides?: CallOverrides
  ): Promise<string>;

  initialize(
    addressesProvider: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "initialize(address)"(
    addressesProvider: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  list(overrides?: CallOverrides): Promise<string[]>;

  "list()"(overrides?: CallOverrides): Promise<string[]>;

  updateRewardPool(
    input: { pool: string; impl: string },
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "updateRewardPool((address,address))"(
    input: { pool: string; impl: string },
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  callStatic: {
    REVISION(overrides?: CallOverrides): Promise<BigNumber>;

    "REVISION()"(overrides?: CallOverrides): Promise<BigNumber>;

    addNamedRewardPools(
      pools: string[],
      names: string[],
      boostFactors: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    "addNamedRewardPools(address[],string[],uint32[])"(
      pools: string[],
      names: string[],
      boostFactors: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    batchInitRewardPools(
      entries: {
        provider: string;
        impl: string;
        poolName: string;
        initialRate: BigNumberish;
        boostFactor: BigNumberish;
        baselinePercentage: BigNumberish;
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

    "batchInitRewardPools(tuple[])"(
      entries: {
        provider: string;
        impl: string;
        poolName: string;
        initialRate: BigNumberish;
        boostFactor: BigNumberish;
        baselinePercentage: BigNumberish;
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

    buildRewardPoolInitData(
      poolName: string,
      baselinePercentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    "buildRewardPoolInitData(string,uint16)"(
      poolName: string,
      baselinePercentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    buildRewardTokenInitData(
      name: string,
      symbol: string,
      decimals: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    "buildRewardTokenInitData(string,string,uint8)"(
      name: string,
      symbol: string,
      decimals: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    configureRewardBoost(
      boostPool: string,
      updateRate: boolean,
      excessTarget: string,
      mintExcess: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    "configureRewardBoost(address,bool,address,bool)"(
      boostPool: string,
      updateRate: boolean,
      excessTarget: string,
      mintExcess: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    configureTeamRewardPool(
      pool: string,
      name: string,
      unlockedAt: BigNumberish,
      members: string[],
      memberShares: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    "configureTeamRewardPool(address,string,uint32,address[],uint16[])"(
      pool: string,
      name: string,
      unlockedAt: BigNumberish,
      members: string[],
      memberShares: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    getDefaultController(overrides?: CallOverrides): Promise<string>;

    "getDefaultController()"(overrides?: CallOverrides): Promise<string>;

    getNamedRewardPools(
      names: string[],
      overrides?: CallOverrides
    ): Promise<string[]>;

    "getNamedRewardPools(string[])"(
      names: string[],
      overrides?: CallOverrides
    ): Promise<string[]>;

    getPoolParams(
      pools: string[],
      overrides?: CallOverrides
    ): Promise<{
      controllers: string[];
      rates: BigNumber[];
      baselinePcts: number[];
      0: string[];
      1: BigNumber[];
      2: number[];
    }>;

    "getPoolParams(address[])"(
      pools: string[],
      overrides?: CallOverrides
    ): Promise<{
      controllers: string[];
      rates: BigNumber[];
      baselinePcts: number[];
      0: string[];
      1: BigNumber[];
      2: number[];
    }>;

    getPoolTotals(
      excludeBoost: boolean,
      overrides?: CallOverrides
    ): Promise<{
      totalBaselinePercentage: BigNumber;
      totalRate: BigNumber;
      activePoolCount: BigNumber;
      poolCount: BigNumber;
      listCount: BigNumber;
      0: BigNumber;
      1: BigNumber;
      2: BigNumber;
      3: BigNumber;
      4: BigNumber;
    }>;

    "getPoolTotals(bool)"(
      excludeBoost: boolean,
      overrides?: CallOverrides
    ): Promise<{
      totalBaselinePercentage: BigNumber;
      totalRate: BigNumber;
      activePoolCount: BigNumber;
      poolCount: BigNumber;
      listCount: BigNumber;
      0: BigNumber;
      1: BigNumber;
      2: BigNumber;
      3: BigNumber;
      4: BigNumber;
    }>;

    getProxyAdmin(overrides?: CallOverrides): Promise<string>;

    "getProxyAdmin()"(overrides?: CallOverrides): Promise<string>;

    getRewardedTokenParams(
      tokens: string[],
      overrides?: CallOverrides
    ): Promise<{
      pools: string[];
      controllers: string[];
      rates: BigNumber[];
      baselinePcts: number[];
      0: string[];
      1: string[];
      2: BigNumber[];
      3: number[];
    }>;

    "getRewardedTokenParams(address[])"(
      tokens: string[],
      overrides?: CallOverrides
    ): Promise<{
      pools: string[];
      controllers: string[];
      rates: BigNumber[];
      baselinePcts: number[];
      0: string[];
      1: string[];
      2: BigNumber[];
      3: number[];
    }>;

    implementationOf(token: string, overrides?: CallOverrides): Promise<string>;

    "implementationOf(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<string>;

    initialize(
      addressesProvider: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "initialize(address)"(
      addressesProvider: string,
      overrides?: CallOverrides
    ): Promise<void>;

    list(overrides?: CallOverrides): Promise<string[]>;

    "list()"(overrides?: CallOverrides): Promise<string[]>;

    updateRewardPool(
      input: { pool: string; impl: string },
      overrides?: CallOverrides
    ): Promise<void>;

    "updateRewardPool((address,address))"(
      input: { pool: string; impl: string },
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    RewardPoolInitialized(
      pool: string | null,
      provider: string | null,
      data: null
    ): EventFilter;

    RewardPoolUpgraded(pool: string | null, impl: null): EventFilter;
  };

  estimateGas: {
    REVISION(overrides?: CallOverrides): Promise<BigNumber>;

    "REVISION()"(overrides?: CallOverrides): Promise<BigNumber>;

    addNamedRewardPools(
      pools: string[],
      names: string[],
      boostFactors: BigNumberish[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    "addNamedRewardPools(address[],string[],uint32[])"(
      pools: string[],
      names: string[],
      boostFactors: BigNumberish[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    batchInitRewardPools(
      entries: {
        provider: string;
        impl: string;
        poolName: string;
        initialRate: BigNumberish;
        boostFactor: BigNumberish;
        baselinePercentage: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    "batchInitRewardPools(tuple[])"(
      entries: {
        provider: string;
        impl: string;
        poolName: string;
        initialRate: BigNumberish;
        boostFactor: BigNumberish;
        baselinePercentage: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    buildRewardPoolInitData(
      poolName: string,
      baselinePercentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "buildRewardPoolInitData(string,uint16)"(
      poolName: string,
      baselinePercentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    buildRewardTokenInitData(
      name: string,
      symbol: string,
      decimals: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "buildRewardTokenInitData(string,string,uint8)"(
      name: string,
      symbol: string,
      decimals: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    configureRewardBoost(
      boostPool: string,
      updateRate: boolean,
      excessTarget: string,
      mintExcess: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "configureRewardBoost(address,bool,address,bool)"(
      boostPool: string,
      updateRate: boolean,
      excessTarget: string,
      mintExcess: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

    configureTeamRewardPool(
      pool: string,
      name: string,
      unlockedAt: BigNumberish,
      members: string[],
      memberShares: BigNumberish[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    "configureTeamRewardPool(address,string,uint32,address[],uint16[])"(
      pool: string,
      name: string,
      unlockedAt: BigNumberish,
      members: string[],
      memberShares: BigNumberish[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    getDefaultController(overrides?: CallOverrides): Promise<BigNumber>;

    "getDefaultController()"(overrides?: CallOverrides): Promise<BigNumber>;

    getNamedRewardPools(
      names: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getNamedRewardPools(string[])"(
      names: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPoolParams(
      pools: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getPoolParams(address[])"(
      pools: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPoolTotals(
      excludeBoost: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getPoolTotals(bool)"(
      excludeBoost: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getProxyAdmin(overrides?: CallOverrides): Promise<BigNumber>;

    "getProxyAdmin()"(overrides?: CallOverrides): Promise<BigNumber>;

    getRewardedTokenParams(
      tokens: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getRewardedTokenParams(address[])"(
      tokens: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    implementationOf(
      token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "implementationOf(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      addressesProvider: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "initialize(address)"(
      addressesProvider: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    list(overrides?: CallOverrides): Promise<BigNumber>;

    "list()"(overrides?: CallOverrides): Promise<BigNumber>;

    updateRewardPool(
      input: { pool: string; impl: string },
      overrides?: Overrides
    ): Promise<BigNumber>;

    "updateRewardPool((address,address))"(
      input: { pool: string; impl: string },
      overrides?: Overrides
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    REVISION(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "REVISION()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    addNamedRewardPools(
      pools: string[],
      names: string[],
      boostFactors: BigNumberish[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "addNamedRewardPools(address[],string[],uint32[])"(
      pools: string[],
      names: string[],
      boostFactors: BigNumberish[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    batchInitRewardPools(
      entries: {
        provider: string;
        impl: string;
        poolName: string;
        initialRate: BigNumberish;
        boostFactor: BigNumberish;
        baselinePercentage: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "batchInitRewardPools(tuple[])"(
      entries: {
        provider: string;
        impl: string;
        poolName: string;
        initialRate: BigNumberish;
        boostFactor: BigNumberish;
        baselinePercentage: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    buildRewardPoolInitData(
      poolName: string,
      baselinePercentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "buildRewardPoolInitData(string,uint16)"(
      poolName: string,
      baselinePercentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    buildRewardTokenInitData(
      name: string,
      symbol: string,
      decimals: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "buildRewardTokenInitData(string,string,uint8)"(
      name: string,
      symbol: string,
      decimals: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    configureRewardBoost(
      boostPool: string,
      updateRate: boolean,
      excessTarget: string,
      mintExcess: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "configureRewardBoost(address,bool,address,bool)"(
      boostPool: string,
      updateRate: boolean,
      excessTarget: string,
      mintExcess: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    configureTeamRewardPool(
      pool: string,
      name: string,
      unlockedAt: BigNumberish,
      members: string[],
      memberShares: BigNumberish[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "configureTeamRewardPool(address,string,uint32,address[],uint16[])"(
      pool: string,
      name: string,
      unlockedAt: BigNumberish,
      members: string[],
      memberShares: BigNumberish[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    getDefaultController(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getDefaultController()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getNamedRewardPools(
      names: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getNamedRewardPools(string[])"(
      names: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getPoolParams(
      pools: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getPoolParams(address[])"(
      pools: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getPoolTotals(
      excludeBoost: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getPoolTotals(bool)"(
      excludeBoost: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getProxyAdmin(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "getProxyAdmin()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getRewardedTokenParams(
      tokens: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getRewardedTokenParams(address[])"(
      tokens: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    implementationOf(
      token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "implementationOf(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      addressesProvider: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "initialize(address)"(
      addressesProvider: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    list(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "list()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    updateRewardPool(
      input: { pool: string; impl: string },
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "updateRewardPool((address,address))"(
      input: { pool: string; impl: string },
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;
  };
}