@price-oracle/v1-core-interfaces/ethers-v5/IPositionMinterJob.ts

Price Oracle v1 Core Interfaces and needed integration files

/* 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,
  PromiseOrValue,
} from "./common";

export interface IPositionMinterJobInterface extends utils.Interface {
  functions: {
    "POOL_MANAGER_FACTORY()": FunctionFragment;
    "acceptGovernance()": FunctionFragment;
    "governance()": FunctionFragment;
    "isPaused()": FunctionFragment;
    "isWorkable(address)": FunctionFragment;
    "isWorkable(address,address)": FunctionFragment;
    "keep3r()": FunctionFragment;
    "pendingGovernance()": FunctionFragment;
    "requiredAge()": FunctionFragment;
    "requiredBond()": FunctionFragment;
    "requiredEarnings()": FunctionFragment;
    "requiredMinBond()": FunctionFragment;
    "setGovernance(address)": FunctionFragment;
    "setKeep3r(address)": FunctionFragment;
    "setKeep3rRequirements(address,uint256,uint256,uint256)": FunctionFragment;
    "setPaused(bool)": FunctionFragment;
    "work(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "POOL_MANAGER_FACTORY"
      | "acceptGovernance"
      | "governance"
      | "isPaused"
      | "isWorkable(address)"
      | "isWorkable(address,address)"
      | "keep3r"
      | "pendingGovernance"
      | "requiredAge"
      | "requiredBond"
      | "requiredEarnings"
      | "requiredMinBond"
      | "setGovernance"
      | "setKeep3r"
      | "setKeep3rRequirements"
      | "setPaused"
      | "work"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "POOL_MANAGER_FACTORY",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "acceptGovernance",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "governance",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "isPaused", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "isWorkable(address)",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isWorkable(address,address)",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "keep3r", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pendingGovernance",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "requiredAge",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "requiredBond",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "requiredEarnings",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "requiredMinBond",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setGovernance",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setKeep3r",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setKeep3rRequirements",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setPaused",
    values: [PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "work",
    values: [PromiseOrValue<string>]
  ): string;

  decodeFunctionResult(
    functionFragment: "POOL_MANAGER_FACTORY",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "acceptGovernance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isPaused", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isWorkable(address)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isWorkable(address,address)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "keep3r", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pendingGovernance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requiredAge",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requiredBond",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requiredEarnings",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requiredMinBond",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setGovernance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setKeep3r", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setKeep3rRequirements",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setPaused", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "work", data: BytesLike): Result;

  events: {
    "GovernanceProposal(address)": EventFragment;
    "GovernanceSet(address)": EventFragment;
    "Keep3rRequirementsSet(address,uint256,uint256,uint256)": EventFragment;
    "Keep3rSet(address)": EventFragment;
    "PausedSet(bool)": EventFragment;
    "Worked(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "GovernanceProposal"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "GovernanceSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Keep3rRequirementsSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Keep3rSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PausedSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Worked"): EventFragment;
}

export interface GovernanceProposalEventObject {
  _pendingGovernance: string;
}
export type GovernanceProposalEvent = TypedEvent<
  [string],
  GovernanceProposalEventObject
>;

export type GovernanceProposalEventFilter =
  TypedEventFilter<GovernanceProposalEvent>;

export interface GovernanceSetEventObject {
  _governance: string;
}
export type GovernanceSetEvent = TypedEvent<[string], GovernanceSetEventObject>;

export type GovernanceSetEventFilter = TypedEventFilter<GovernanceSetEvent>;

export interface Keep3rRequirementsSetEventObject {
  _bond: string;
  _minBond: BigNumber;
  _earnings: BigNumber;
  _age: BigNumber;
}
export type Keep3rRequirementsSetEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  Keep3rRequirementsSetEventObject
>;

export type Keep3rRequirementsSetEventFilter =
  TypedEventFilter<Keep3rRequirementsSetEvent>;

export interface Keep3rSetEventObject {
  _keep3r: string;
}
export type Keep3rSetEvent = TypedEvent<[string], Keep3rSetEventObject>;

export type Keep3rSetEventFilter = TypedEventFilter<Keep3rSetEvent>;

export interface PausedSetEventObject {
  _paused: boolean;
}
export type PausedSetEvent = TypedEvent<[boolean], PausedSetEventObject>;

export type PausedSetEventFilter = TypedEventFilter<PausedSetEvent>;

export interface WorkedEventObject {
  _poolManager: string;
}
export type WorkedEvent = TypedEvent<[string], WorkedEventObject>;

export type WorkedEventFilter = TypedEventFilter<WorkedEvent>;

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

  interface: IPositionMinterJobInterface;

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

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

    governance(
      overrides?: CallOverrides
    ): Promise<[string] & { _governance: string }>;

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

    "isWorkable(address)"(
      _poolManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "isWorkable(address,address)"(
      _poolManager: PromiseOrValue<string>,
      _keeper: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    keep3r(overrides?: CallOverrides): Promise<[string] & { _keep3r: string }>;

    pendingGovernance(
      overrides?: CallOverrides
    ): Promise<[string] & { _pendingGovernance: string }>;

    requiredAge(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _requiredAge: BigNumber }>;

    requiredBond(
      overrides?: CallOverrides
    ): Promise<[string] & { _requiredBond: string }>;

    requiredEarnings(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _requiredEarnings: BigNumber }>;

    requiredMinBond(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _requiredMinBond: BigNumber }>;

    setGovernance(
      _governance: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setKeep3r(
      _keep3r: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setKeep3rRequirements(
      _bond: PromiseOrValue<string>,
      _minBond: PromiseOrValue<BigNumberish>,
      _earnings: PromiseOrValue<BigNumberish>,
      _age: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setPaused(
      _paused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    work(
      _poolManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;
  };

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

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

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

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

  "isWorkable(address)"(
    _poolManager: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "isWorkable(address,address)"(
    _poolManager: PromiseOrValue<string>,
    _keeper: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

  setGovernance(
    _governance: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setKeep3r(
    _keep3r: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setKeep3rRequirements(
    _bond: PromiseOrValue<string>,
    _minBond: PromiseOrValue<BigNumberish>,
    _earnings: PromiseOrValue<BigNumberish>,
    _age: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setPaused(
    _paused: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  work(
    _poolManager: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

    isPaused(overrides?: CallOverrides): Promise<boolean>;

    "isWorkable(address)"(
      _poolManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "isWorkable(address,address)"(
      _poolManager: PromiseOrValue<string>,
      _keeper: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

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

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

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

    setGovernance(
      _governance: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setKeep3r(
      _keep3r: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setKeep3rRequirements(
      _bond: PromiseOrValue<string>,
      _minBond: PromiseOrValue<BigNumberish>,
      _earnings: PromiseOrValue<BigNumberish>,
      _age: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setPaused(
      _paused: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    work(
      _poolManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "GovernanceProposal(address)"(
      _pendingGovernance?: null
    ): GovernanceProposalEventFilter;
    GovernanceProposal(
      _pendingGovernance?: null
    ): GovernanceProposalEventFilter;

    "GovernanceSet(address)"(_governance?: null): GovernanceSetEventFilter;
    GovernanceSet(_governance?: null): GovernanceSetEventFilter;

    "Keep3rRequirementsSet(address,uint256,uint256,uint256)"(
      _bond?: null,
      _minBond?: null,
      _earnings?: null,
      _age?: null
    ): Keep3rRequirementsSetEventFilter;
    Keep3rRequirementsSet(
      _bond?: null,
      _minBond?: null,
      _earnings?: null,
      _age?: null
    ): Keep3rRequirementsSetEventFilter;

    "Keep3rSet(address)"(_keep3r?: null): Keep3rSetEventFilter;
    Keep3rSet(_keep3r?: null): Keep3rSetEventFilter;

    "PausedSet(bool)"(_paused?: null): PausedSetEventFilter;
    PausedSet(_paused?: null): PausedSetEventFilter;

    "Worked(address)"(_poolManager?: null): WorkedEventFilter;
    Worked(_poolManager?: null): WorkedEventFilter;
  };

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

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

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

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

    "isWorkable(address)"(
      _poolManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "isWorkable(address,address)"(
      _poolManager: PromiseOrValue<string>,
      _keeper: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    setGovernance(
      _governance: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setKeep3r(
      _keep3r: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setKeep3rRequirements(
      _bond: PromiseOrValue<string>,
      _minBond: PromiseOrValue<BigNumberish>,
      _earnings: PromiseOrValue<BigNumberish>,
      _age: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setPaused(
      _paused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    work(
      _poolManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;
  };

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

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

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

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

    "isWorkable(address)"(
      _poolManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "isWorkable(address,address)"(
      _poolManager: PromiseOrValue<string>,
      _keeper: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    setGovernance(
      _governance: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setKeep3r(
      _keep3r: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setKeep3rRequirements(
      _bond: PromiseOrValue<string>,
      _minBond: PromiseOrValue<BigNumberish>,
      _earnings: PromiseOrValue<BigNumberish>,
      _age: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setPaused(
      _paused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    work(
      _poolManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;
  };
}