@collabland/staking-contracts/src/types/Revenue.ts

Staking contracts supported by Collab.Land

/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import type {
  FunctionFragment,
  Result,
  EventFragment,
} from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
} from "./common.js";

export interface RevenueInterface extends utils.Interface {
  functions: {
    "ADMIN_ROLE()": FunctionFragment;
    "MAINTAINER_ROLE()": FunctionFragment;
    "claim(uint256)": FunctionFragment;
    "claim(uint256,address)": FunctionFragment;
    "claimFromDealer(uint256,address)": FunctionFragment;
    "closeBlock()": FunctionFragment;
    "dealerInfo(address)": FunctionFragment;
    "dealers(uint256)": FunctionFragment;
    "delegate()": FunctionFragment;
    "delistedDealers(uint256)": FunctionFragment;
    "deposit(uint256,address,uint256)": FunctionFragment;
    "deposit(uint256,uint256)": FunctionFragment;
    "maxPid()": FunctionFragment;
    "owner()": FunctionFragment;
    "pendingRewards(uint256,address,address)": FunctionFragment;
    "poolInfo(uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "setCloseBlock(uint256)": FunctionFragment;
    "setDelegateAddress(address)": FunctionFragment;
    "setStartBlock(uint256)": FunctionFragment;
    "setTokenAddress(address)": FunctionFragment;
    "setTokenPerBlock(address,uint256,uint256)": FunctionFragment;
    "setTokenPerBlock(address,uint256)": FunctionFragment;
    "setTokenPerBlock(address,uint256,uint256,uint256)": FunctionFragment;
    "startBlock()": FunctionFragment;
    "token()": FunctionFragment;
    "tokenPerBlock()": FunctionFragment;
    "totalPoolShare()": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "updateDealers()": FunctionFragment;
    "userInfo(uint256,address)": FunctionFragment;
    "withdraw(uint256,uint256)": FunctionFragment;
    "withdrawRemaining()": FunctionFragment;
    "withdrawRemaining(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "ADMIN_ROLE"
      | "MAINTAINER_ROLE"
      | "claim(uint256)"
      | "claim(uint256,address)"
      | "claimFromDealer"
      | "closeBlock"
      | "dealerInfo"
      | "dealers"
      | "delegate"
      | "delistedDealers"
      | "deposit(uint256,address,uint256)"
      | "deposit(uint256,uint256)"
      | "maxPid"
      | "owner"
      | "pendingRewards"
      | "poolInfo"
      | "renounceOwnership"
      | "setCloseBlock"
      | "setDelegateAddress"
      | "setStartBlock"
      | "setTokenAddress"
      | "setTokenPerBlock(address,uint256,uint256)"
      | "setTokenPerBlock(address,uint256)"
      | "setTokenPerBlock(address,uint256,uint256,uint256)"
      | "startBlock"
      | "token"
      | "tokenPerBlock"
      | "totalPoolShare"
      | "transferOwnership"
      | "updateDealers"
      | "userInfo"
      | "withdraw"
      | "withdrawRemaining()"
      | "withdrawRemaining(address)"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "ADMIN_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAINTAINER_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "claim(uint256)",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "claim(uint256,address)",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "claimFromDealer",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "closeBlock",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "dealerInfo", values: [string]): string;
  encodeFunctionData(
    functionFragment: "dealers",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "delegate", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "delistedDealers",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "deposit(uint256,address,uint256)",
    values: [BigNumberish, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "deposit(uint256,uint256)",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "maxPid", values?: undefined): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pendingRewards",
    values: [BigNumberish, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "poolInfo",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setCloseBlock",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setDelegateAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setStartBlock",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setTokenAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setTokenPerBlock(address,uint256,uint256)",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setTokenPerBlock(address,uint256)",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setTokenPerBlock(address,uint256,uint256,uint256)",
    values: [string, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "startBlock",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "token", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "tokenPerBlock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalPoolShare",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateDealers",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "userInfo",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawRemaining()",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawRemaining(address)",
    values: [string]
  ): string;

  decodeFunctionResult(functionFragment: "ADMIN_ROLE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "MAINTAINER_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claim(uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claim(uint256,address)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimFromDealer",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "closeBlock", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "dealerInfo", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "dealers", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "delegate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "delistedDealers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "deposit(uint256,address,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "deposit(uint256,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "maxPid", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pendingRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "poolInfo", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCloseBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegateAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStartBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTokenAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTokenPerBlock(address,uint256,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTokenPerBlock(address,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTokenPerBlock(address,uint256,uint256,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "startBlock", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "tokenPerBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalPoolShare",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateDealers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "userInfo", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawRemaining()",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawRemaining(address)",
    data: BytesLike
  ): Result;

  events: {
    "CloseBlockChanged(uint256)": EventFragment;
    "DelegateAddressChanged(address)": EventFragment;
    "Deposited(address,uint256,address,uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "PoolAdded(uint256,uint256,uint256)": EventFragment;
    "StartBlockChanged(uint256)": EventFragment;
    "TokenAddressChanged(address)": EventFragment;
    "TokenDealerChanged(address,address)": EventFragment;
    "Withdrawn(address,uint256,address,uint256)": EventFragment;
    "WithdrawnRemain(address,uint256,address,uint256)": EventFragment;
    "WithdrawnReward(address,uint256,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "CloseBlockChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegateAddressChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Deposited"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StartBlockChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenAddressChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenDealerChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WithdrawnRemain"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WithdrawnReward"): EventFragment;
}

export interface CloseBlockChangedEventObject {
  block: BigNumber;
}
export type CloseBlockChangedEvent = TypedEvent<
  [BigNumber],
  CloseBlockChangedEventObject
>;

export type CloseBlockChangedEventFilter =
  TypedEventFilter<CloseBlockChangedEvent>;

export interface DelegateAddressChangedEventObject {
  addr: string;
}
export type DelegateAddressChangedEvent = TypedEvent<
  [string],
  DelegateAddressChangedEventObject
>;

export type DelegateAddressChangedEventFilter =
  TypedEventFilter<DelegateAddressChangedEvent>;

export interface DepositedEventObject {
  user: string;
  pid: BigNumber;
  token: string;
  amount: BigNumber;
}
export type DepositedEvent = TypedEvent<
  [string, BigNumber, string, BigNumber],
  DepositedEventObject
>;

export type DepositedEventFilter = TypedEventFilter<DepositedEvent>;

export interface OwnershipTransferredEventObject {
  previousOwner: string;
  newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<
  [string, string],
  OwnershipTransferredEventObject
>;

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface PoolAddedEventObject {
  share: BigNumber;
  timer: BigNumber;
  limit: BigNumber;
}
export type PoolAddedEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber],
  PoolAddedEventObject
>;

export type PoolAddedEventFilter = TypedEventFilter<PoolAddedEvent>;

export interface StartBlockChangedEventObject {
  block: BigNumber;
}
export type StartBlockChangedEvent = TypedEvent<
  [BigNumber],
  StartBlockChangedEventObject
>;

export type StartBlockChangedEventFilter =
  TypedEventFilter<StartBlockChangedEvent>;

export interface TokenAddressChangedEventObject {
  token: string;
}
export type TokenAddressChangedEvent = TypedEvent<
  [string],
  TokenAddressChangedEventObject
>;

export type TokenAddressChangedEventFilter =
  TypedEventFilter<TokenAddressChangedEvent>;

export interface TokenDealerChangedEventObject {
  token: string;
  dealer: string;
}
export type TokenDealerChangedEvent = TypedEvent<
  [string, string],
  TokenDealerChangedEventObject
>;

export type TokenDealerChangedEventFilter =
  TypedEventFilter<TokenDealerChangedEvent>;

export interface WithdrawnEventObject {
  user: string;
  pid: BigNumber;
  token: string;
  amount: BigNumber;
}
export type WithdrawnEvent = TypedEvent<
  [string, BigNumber, string, BigNumber],
  WithdrawnEventObject
>;

export type WithdrawnEventFilter = TypedEventFilter<WithdrawnEvent>;

export interface WithdrawnRemainEventObject {
  user: string;
  pid: BigNumber;
  token: string;
  amount: BigNumber;
}
export type WithdrawnRemainEvent = TypedEvent<
  [string, BigNumber, string, BigNumber],
  WithdrawnRemainEventObject
>;

export type WithdrawnRemainEventFilter = TypedEventFilter<WithdrawnRemainEvent>;

export interface WithdrawnRewardEventObject {
  user: string;
  pid: BigNumber;
  token: string;
  amount: BigNumber;
}
export type WithdrawnRewardEvent = TypedEvent<
  [string, BigNumber, string, BigNumber],
  WithdrawnRewardEventObject
>;

export type WithdrawnRewardEventFilter = TypedEventFilter<WithdrawnRewardEvent>;

export interface Revenue extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: RevenueInterface;

  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: {
    ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;

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

    "claim(uint256)"(
      pid: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    "claim(uint256,address)"(
      pid: BigNumberish,
      asset: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    claimFromDealer(
      pid: BigNumberish,
      addr: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    closeBlock(overrides?: CallOverrides): Promise<[BigNumber]>;

    dealerInfo(arg0: string, overrides?: CallOverrides): Promise<[string]>;

    dealers(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;

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

    delistedDealers(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    "deposit(uint256,address,uint256)"(
      pid: BigNumberish,
      addr: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    "deposit(uint256,uint256)"(
      pid: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    maxPid(overrides?: CallOverrides): Promise<[BigNumber]>;

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

    pendingRewards(
      pid: BigNumberish,
      addr: string,
      asset: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    poolInfo(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        poolShare: BigNumber;
        lastBlock: BigNumber;
        tokenPerShare: BigNumber;
        tokenRealStaked: BigNumber;
        tokenReceived: BigNumber;
        tokenRewarded: BigNumber;
        tokenTotalLimit: BigNumber;
        lockupTimerange: BigNumber;
      }
    >;

    renounceOwnership(
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setCloseBlock(
      _closeBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setDelegateAddress(
      _delegate: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setStartBlock(
      _startBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setTokenAddress(
      _token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    "setTokenPerBlock(address,uint256,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      _blockRange: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    "setTokenPerBlock(address,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    "setTokenPerBlock(address,uint256,uint256,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      _startBlock: BigNumberish,
      _closeBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    startBlock(overrides?: CallOverrides): Promise<[BigNumber]>;

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

    tokenPerBlock(overrides?: CallOverrides): Promise<[BigNumber]>;

    totalPoolShare(overrides?: CallOverrides): Promise<[BigNumber]>;

    transferOwnership(
      newOwner: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    updateDealers(
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    userInfo(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        amount: BigNumber;
        rewardDebt: BigNumber;
        pendingRewards: BigNumber;
        lockedTimestamp: BigNumber;
        lockupTimestamp: BigNumber;
      }
    >;

    withdraw(
      pid: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    "withdrawRemaining()"(
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    "withdrawRemaining(address)"(
      asset: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;
  };

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

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

  "claim(uint256)"(
    pid: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  "claim(uint256,address)"(
    pid: BigNumberish,
    asset: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  claimFromDealer(
    pid: BigNumberish,
    addr: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  dealerInfo(arg0: string, overrides?: CallOverrides): Promise<string>;

  dealers(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

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

  delistedDealers(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  "deposit(uint256,address,uint256)"(
    pid: BigNumberish,
    addr: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  "deposit(uint256,uint256)"(
    pid: BigNumberish,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

  pendingRewards(
    pid: BigNumberish,
    addr: string,
    asset: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  poolInfo(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      poolShare: BigNumber;
      lastBlock: BigNumber;
      tokenPerShare: BigNumber;
      tokenRealStaked: BigNumber;
      tokenReceived: BigNumber;
      tokenRewarded: BigNumber;
      tokenTotalLimit: BigNumber;
      lockupTimerange: BigNumber;
    }
  >;

  renounceOwnership(
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setCloseBlock(
    _closeBlock: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setDelegateAddress(
    _delegate: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setStartBlock(
    _startBlock: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setTokenAddress(
    _token: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  "setTokenPerBlock(address,uint256,uint256)"(
    _token: string,
    _tokenPerBlock: BigNumberish,
    _blockRange: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  "setTokenPerBlock(address,uint256)"(
    _token: string,
    _tokenPerBlock: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  "setTokenPerBlock(address,uint256,uint256,uint256)"(
    _token: string,
    _tokenPerBlock: BigNumberish,
    _startBlock: BigNumberish,
    _closeBlock: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

  transferOwnership(
    newOwner: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  updateDealers(
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  userInfo(
    arg0: BigNumberish,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
      amount: BigNumber;
      rewardDebt: BigNumber;
      pendingRewards: BigNumber;
      lockedTimestamp: BigNumber;
      lockupTimestamp: BigNumber;
    }
  >;

  withdraw(
    pid: BigNumberish,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  "withdrawRemaining()"(
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  "withdrawRemaining(address)"(
    asset: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  callStatic: {
    ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;

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

    "claim(uint256)"(
      pid: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "claim(uint256,address)"(
      pid: BigNumberish,
      asset: string,
      overrides?: CallOverrides
    ): Promise<void>;

    claimFromDealer(
      pid: BigNumberish,
      addr: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    dealerInfo(arg0: string, overrides?: CallOverrides): Promise<string>;

    dealers(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

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

    delistedDealers(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    "deposit(uint256,address,uint256)"(
      pid: BigNumberish,
      addr: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "deposit(uint256,uint256)"(
      pid: BigNumberish,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    pendingRewards(
      pid: BigNumberish,
      addr: string,
      asset: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    poolInfo(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        poolShare: BigNumber;
        lastBlock: BigNumber;
        tokenPerShare: BigNumber;
        tokenRealStaked: BigNumber;
        tokenReceived: BigNumber;
        tokenRewarded: BigNumber;
        tokenTotalLimit: BigNumber;
        lockupTimerange: BigNumber;
      }
    >;

    renounceOwnership(overrides?: CallOverrides): Promise<void>;

    setCloseBlock(
      _closeBlock: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setDelegateAddress(
      _delegate: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setStartBlock(
      _startBlock: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setTokenAddress(_token: string, overrides?: CallOverrides): Promise<void>;

    "setTokenPerBlock(address,uint256,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      _blockRange: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setTokenPerBlock(address,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setTokenPerBlock(address,uint256,uint256,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      _startBlock: BigNumberish,
      _closeBlock: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    transferOwnership(
      newOwner: string,
      overrides?: CallOverrides
    ): Promise<void>;

    updateDealers(overrides?: CallOverrides): Promise<void>;

    userInfo(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        amount: BigNumber;
        rewardDebt: BigNumber;
        pendingRewards: BigNumber;
        lockedTimestamp: BigNumber;
        lockupTimestamp: BigNumber;
      }
    >;

    withdraw(
      pid: BigNumberish,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "withdrawRemaining()"(overrides?: CallOverrides): Promise<void>;

    "withdrawRemaining(address)"(
      asset: string,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "CloseBlockChanged(uint256)"(block?: null): CloseBlockChangedEventFilter;
    CloseBlockChanged(block?: null): CloseBlockChangedEventFilter;

    "DelegateAddressChanged(address)"(
      addr?: string | null
    ): DelegateAddressChangedEventFilter;
    DelegateAddressChanged(
      addr?: string | null
    ): DelegateAddressChangedEventFilter;

    "Deposited(address,uint256,address,uint256)"(
      user?: string | null,
      pid?: BigNumberish | null,
      token?: string | null,
      amount?: null
    ): DepositedEventFilter;
    Deposited(
      user?: string | null,
      pid?: BigNumberish | null,
      token?: string | null,
      amount?: null
    ): DepositedEventFilter;

    "OwnershipTransferred(address,address)"(
      previousOwner?: string | null,
      newOwner?: string | null
    ): OwnershipTransferredEventFilter;
    OwnershipTransferred(
      previousOwner?: string | null,
      newOwner?: string | null
    ): OwnershipTransferredEventFilter;

    "PoolAdded(uint256,uint256,uint256)"(
      share?: null,
      timer?: null,
      limit?: null
    ): PoolAddedEventFilter;
    PoolAdded(share?: null, timer?: null, limit?: null): PoolAddedEventFilter;

    "StartBlockChanged(uint256)"(block?: null): StartBlockChangedEventFilter;
    StartBlockChanged(block?: null): StartBlockChangedEventFilter;

    "TokenAddressChanged(address)"(
      token?: string | null
    ): TokenAddressChangedEventFilter;
    TokenAddressChanged(token?: string | null): TokenAddressChangedEventFilter;

    "TokenDealerChanged(address,address)"(
      token?: string | null,
      dealer?: string | null
    ): TokenDealerChangedEventFilter;
    TokenDealerChanged(
      token?: string | null,
      dealer?: string | null
    ): TokenDealerChangedEventFilter;

    "Withdrawn(address,uint256,address,uint256)"(
      user?: string | null,
      pid?: BigNumberish | null,
      token?: string | null,
      amount?: null
    ): WithdrawnEventFilter;
    Withdrawn(
      user?: string | null,
      pid?: BigNumberish | null,
      token?: string | null,
      amount?: null
    ): WithdrawnEventFilter;

    "WithdrawnRemain(address,uint256,address,uint256)"(
      user?: string | null,
      pid?: BigNumberish | null,
      token?: string | null,
      amount?: null
    ): WithdrawnRemainEventFilter;
    WithdrawnRemain(
      user?: string | null,
      pid?: BigNumberish | null,
      token?: string | null,
      amount?: null
    ): WithdrawnRemainEventFilter;

    "WithdrawnReward(address,uint256,address,uint256)"(
      user?: string | null,
      pid?: BigNumberish | null,
      token?: string | null,
      amount?: null
    ): WithdrawnRewardEventFilter;
    WithdrawnReward(
      user?: string | null,
      pid?: BigNumberish | null,
      token?: string | null,
      amount?: null
    ): WithdrawnRewardEventFilter;
  };

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

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

    "claim(uint256)"(
      pid: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    "claim(uint256,address)"(
      pid: BigNumberish,
      asset: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    claimFromDealer(
      pid: BigNumberish,
      addr: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    dealerInfo(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

    dealers(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

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

    delistedDealers(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "deposit(uint256,address,uint256)"(
      pid: BigNumberish,
      addr: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    "deposit(uint256,uint256)"(
      pid: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

    pendingRewards(
      pid: BigNumberish,
      addr: string,
      asset: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    poolInfo(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    renounceOwnership(
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setCloseBlock(
      _closeBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setDelegateAddress(
      _delegate: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setStartBlock(
      _startBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setTokenAddress(
      _token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    "setTokenPerBlock(address,uint256,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      _blockRange: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    "setTokenPerBlock(address,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    "setTokenPerBlock(address,uint256,uint256,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      _startBlock: BigNumberish,
      _closeBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

    transferOwnership(
      newOwner: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    updateDealers(
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    userInfo(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    withdraw(
      pid: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    "withdrawRemaining()"(
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    "withdrawRemaining(address)"(
      asset: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;
  };

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

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

    "claim(uint256)"(
      pid: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    "claim(uint256,address)"(
      pid: BigNumberish,
      asset: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    claimFromDealer(
      pid: BigNumberish,
      addr: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    dealerInfo(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    dealers(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    delistedDealers(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "deposit(uint256,address,uint256)"(
      pid: BigNumberish,
      addr: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    "deposit(uint256,uint256)"(
      pid: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

    pendingRewards(
      pid: BigNumberish,
      addr: string,
      asset: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    poolInfo(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    renounceOwnership(
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setCloseBlock(
      _closeBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setDelegateAddress(
      _delegate: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setStartBlock(
      _startBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setTokenAddress(
      _token: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    "setTokenPerBlock(address,uint256,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      _blockRange: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    "setTokenPerBlock(address,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    "setTokenPerBlock(address,uint256,uint256,uint256)"(
      _token: string,
      _tokenPerBlock: BigNumberish,
      _startBlock: BigNumberish,
      _closeBlock: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    transferOwnership(
      newOwner: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    updateDealers(
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    userInfo(
      arg0: BigNumberish,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    withdraw(
      pid: BigNumberish,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    "withdrawRemaining()"(
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    "withdrawRemaining(address)"(
      asset: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;
  };
}