@collabland/staking-contracts/src/types/LifestoryPlanetStaking.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 LifestoryPlanetStakingInterface extends utils.Interface {
  functions: {
    "allowStaking()": FunctionFragment;
    "owner()": FunctionFragment;
    "planetContract()": FunctionFragment;
    "planetOwner(uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "rewardTokenContract()": FunctionFragment;
    "totalRewardSupply()": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "getRewarding(uint8)": FunctionFragment;
    "getStakedPlanets(address)": FunctionFragment;
    "getPlanetStakedPeriod(address,uint256)": FunctionFragment;
    "getStakedPlanetReleaseDate(address,uint256)": FunctionFragment;
    "stake(uint256,uint8)": FunctionFragment;
    "stakeBatch(uint256[],uint8)": FunctionFragment;
    "unstake(uint256)": FunctionFragment;
    "unstakeBatch(uint256[])": FunctionFragment;
    "unstakeLost(uint256)": FunctionFragment;
    "setAllowStaking(bool)": FunctionFragment;
    "setRewardContract(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "allowStaking"
      | "owner"
      | "planetContract"
      | "planetOwner"
      | "renounceOwnership"
      | "rewardTokenContract"
      | "totalRewardSupply"
      | "transferOwnership"
      | "getRewarding"
      | "getStakedPlanets"
      | "getPlanetStakedPeriod"
      | "getStakedPlanetReleaseDate"
      | "stake"
      | "stakeBatch"
      | "unstake"
      | "unstakeBatch"
      | "unstakeLost"
      | "setAllowStaking"
      | "setRewardContract"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "allowStaking",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "planetContract",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "planetOwner",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rewardTokenContract",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalRewardSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getRewarding",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakedPlanets",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getPlanetStakedPeriod",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakedPlanetReleaseDate",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stake",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeBatch",
    values: [BigNumberish[], BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "unstake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "unstakeBatch",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "unstakeLost",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setAllowStaking",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewardContract",
    values: [string]
  ): string;

  decodeFunctionResult(
    functionFragment: "allowStaking",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "planetContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "planetOwner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rewardTokenContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalRewardSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRewarding",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakedPlanets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPlanetStakedPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakedPlanetReleaseDate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakeBatch", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "unstake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "unstakeBatch",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unstakeLost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAllowStaking",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRewardContract",
    data: BytesLike
  ): Result;

  events: {
    "OwnershipTransferred(address,address)": EventFragment;
    "Staked(address,uint256)": EventFragment;
    "Unstaked(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Staked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unstaked"): EventFragment;
}

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface StakedEventObject {
  user: string;
  planetId: BigNumber;
}
export type StakedEvent = TypedEvent<[string, BigNumber], StakedEventObject>;

export type StakedEventFilter = TypedEventFilter<StakedEvent>;

export interface UnstakedEventObject {
  user: string;
  planetId: BigNumber;
}
export type UnstakedEvent = TypedEvent<
  [string, BigNumber],
  UnstakedEventObject
>;

export type UnstakedEventFilter = TypedEventFilter<UnstakedEvent>;

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

  interface: LifestoryPlanetStakingInterface;

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

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

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

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

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

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

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

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

    getRewarding(
      _nbYears: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    getStakedPlanets(
      _user: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]] & { planetIds: BigNumber[] }>;

    getPlanetStakedPeriod(
      _user: string,
      _planetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getStakedPlanetReleaseDate(
      _user: string,
      _planetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    stake(
      _planetId: BigNumberish,
      _nbYears: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    stakeBatch(
      _planetIds: BigNumberish[],
      _nbYears: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    unstakeBatch(
      _planetIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    setAllowStaking(
      _allow: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

  getRewarding(
    _nbYears: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  getStakedPlanets(
    _user: string,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  getPlanetStakedPeriod(
    _user: string,
    _planetId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getStakedPlanetReleaseDate(
    _user: string,
    _planetId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  stake(
    _planetId: BigNumberish,
    _nbYears: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  stakeBatch(
    _planetIds: BigNumberish[],
    _nbYears: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  unstakeBatch(
    _planetIds: BigNumberish[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  setAllowStaking(
    _allow: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  callStatic: {
    allowStaking(overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

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

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

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

    getRewarding(
      _nbYears: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    getStakedPlanets(
      _user: string,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    getPlanetStakedPeriod(
      _user: string,
      _planetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakedPlanetReleaseDate(
      _user: string,
      _planetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    stake(
      _planetId: BigNumberish,
      _nbYears: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    stakeBatch(
      _planetIds: BigNumberish[],
      _nbYears: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    unstake(_planetId: BigNumberish, overrides?: CallOverrides): Promise<void>;

    unstakeBatch(
      _planetIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    unstakeLost(
      _planetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setAllowStaking(_allow: boolean, overrides?: CallOverrides): Promise<void>;

    setRewardContract(
      _rewardContractAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;
  };

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

    "Staked(address,uint256)"(user?: null, planetId?: null): StakedEventFilter;
    Staked(user?: null, planetId?: null): StakedEventFilter;

    "Unstaked(address,uint256)"(
      user?: null,
      planetId?: null
    ): UnstakedEventFilter;
    Unstaked(user?: null, planetId?: null): UnstakedEventFilter;
  };

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

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

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

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

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

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

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

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

    getRewarding(
      _nbYears: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakedPlanets(
      _user: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPlanetStakedPeriod(
      _user: string,
      _planetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStakedPlanetReleaseDate(
      _user: string,
      _planetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    stake(
      _planetId: BigNumberish,
      _nbYears: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    stakeBatch(
      _planetIds: BigNumberish[],
      _nbYears: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    unstakeBatch(
      _planetIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    setAllowStaking(
      _allow: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

    getRewarding(
      _nbYears: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakedPlanets(
      _user: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getPlanetStakedPeriod(
      _user: string,
      _planetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStakedPlanetReleaseDate(
      _user: string,
      _planetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    stake(
      _planetId: BigNumberish,
      _nbYears: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    stakeBatch(
      _planetIds: BigNumberish[],
      _nbYears: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    unstakeBatch(
      _planetIds: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    setAllowStaking(
      _allow: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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