@collabland/staking-contracts/src/types/Cbzgrow.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,
  PayableOverrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import type { FunctionFragment, Result } from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
} from "./common.js";

export interface CbzgrowInterface extends utils.Interface {
  functions: {
    "Bucks()": FunctionFragment;
    "CornerBoyz()": FunctionFragment;
    "Flowers()": FunctionFragment;
    "MysteryBox()": FunctionFragment;
    "Seeds()": FunctionFragment;
    "StakerInfo(address,uint256)": FunctionFragment;
    "approveSpendERC20(address,address,uint256)": FunctionFragment;
    "buckStaker(address)": FunctionFragment;
    "bucksBURN(uint256)": FunctionFragment;
    "bucksEXCHANGE(uint256)": FunctionFragment;
    "bucksMOVE(address[],address[],uint256[])": FunctionFragment;
    "bucksWITHDRAW(address,uint256)": FunctionFragment;
    "burnMysteryBox(uint256)": FunctionFragment;
    "calculateGrowth(address,uint256)": FunctionFragment;
    "cbzStaked(uint256)": FunctionFragment;
    "claimMysteryBox()": FunctionFragment;
    "harvestFlowers(uint256,uint256,uint256,bytes)": FunctionFragment;
    "lastNonce()": FunctionFragment;
    "onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)": FunctionFragment;
    "onERC1155Received(address,address,uint256,uint256,bytes)": FunctionFragment;
    "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
    "seedStaked(uint256)": FunctionFragment;
    "setMaxCBZsPerSeed(uint256)": FunctionFragment;
    "setMaxSeedPerCBZ(uint256)": FunctionFragment;
    "setMinimumHarvest(uint256)": FunctionFragment;
    "setSeedInterval(uint256)": FunctionFragment;
    "setSeedReward(uint256)": FunctionFragment;
    "stake(uint256[])": FunctionFragment;
    "stakedCBZs(address)": FunctionFragment;
    "stakedSeeds(address)": FunctionFragment;
    "stakers(address)": FunctionFragment;
    "stakersArray(uint256)": FunctionFragment;
    "staking_parameters()": FunctionFragment;
    "startGrowing(uint256[])": FunctionFragment;
    "stopGrowing(uint256[])": FunctionFragment;
    "supportsInterface(bytes4)": FunctionFragment;
    "unstake(uint256[])": FunctionFragment;
    "withdraw(uint256)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "Bucks"
      | "CornerBoyz"
      | "Flowers"
      | "MysteryBox"
      | "Seeds"
      | "StakerInfo"
      | "approveSpendERC20"
      | "buckStaker"
      | "bucksBURN"
      | "bucksEXCHANGE"
      | "bucksMOVE"
      | "bucksWITHDRAW"
      | "burnMysteryBox"
      | "calculateGrowth"
      | "cbzStaked"
      | "claimMysteryBox"
      | "harvestFlowers"
      | "lastNonce"
      | "onERC1155BatchReceived"
      | "onERC1155Received"
      | "onERC721Received"
      | "seedStaked"
      | "setMaxCBZsPerSeed"
      | "setMaxSeedPerCBZ"
      | "setMinimumHarvest"
      | "setSeedInterval"
      | "setSeedReward"
      | "stake"
      | "stakedCBZs"
      | "stakedSeeds"
      | "stakers"
      | "stakersArray"
      | "staking_parameters"
      | "startGrowing"
      | "stopGrowing"
      | "supportsInterface"
      | "unstake"
      | "withdraw"
  ): FunctionFragment;

  encodeFunctionData(functionFragment: "Bucks", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "CornerBoyz",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "Flowers", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "MysteryBox",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "Seeds", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "StakerInfo",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "approveSpendERC20",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "buckStaker", values: [string]): string;
  encodeFunctionData(
    functionFragment: "bucksBURN",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "bucksEXCHANGE",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "bucksMOVE",
    values: [string[], string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "bucksWITHDRAW",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "burnMysteryBox",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "calculateGrowth",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "cbzStaked",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "claimMysteryBox",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "harvestFlowers",
    values: [BigNumberish, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "lastNonce", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "onERC1155BatchReceived",
    values: [string, string, BigNumberish[], BigNumberish[], BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "onERC1155Received",
    values: [string, string, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "onERC721Received",
    values: [string, string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "seedStaked",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxCBZsPerSeed",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxSeedPerCBZ",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMinimumHarvest",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setSeedInterval",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setSeedReward",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stake",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(functionFragment: "stakedCBZs", values: [string]): string;
  encodeFunctionData(functionFragment: "stakedSeeds", values: [string]): string;
  encodeFunctionData(functionFragment: "stakers", values: [string]): string;
  encodeFunctionData(
    functionFragment: "stakersArray",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "staking_parameters",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "startGrowing",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "stopGrowing",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "supportsInterface",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "unstake",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [BigNumberish]
  ): string;

  decodeFunctionResult(functionFragment: "Bucks", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "CornerBoyz", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "Flowers", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "MysteryBox", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "Seeds", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "StakerInfo", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "approveSpendERC20",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "buckStaker", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "bucksBURN", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "bucksEXCHANGE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "bucksMOVE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "bucksWITHDRAW",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "burnMysteryBox",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calculateGrowth",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "cbzStaked", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimMysteryBox",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "harvestFlowers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lastNonce", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "onERC1155BatchReceived",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onERC1155Received",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onERC721Received",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "seedStaked", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setMaxCBZsPerSeed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxSeedPerCBZ",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMinimumHarvest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSeedInterval",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSeedReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakedCBZs", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakedSeeds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stakers", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakersArray",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "staking_parameters",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "startGrowing",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stopGrowing",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "supportsInterface",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unstake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {};
}

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

  interface: CbzgrowInterface;

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

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

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

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

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

    StakerInfo(
      _user: string,
      _score: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        _cbzStaked: BigNumber;
        _seedsStaked: BigNumber;
        _mysteryBox: BigNumber;
        _fowers: BigNumber;
      }
    >;

    approveSpendERC20(
      token: string,
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

    burnMysteryBox(
      amount: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;

    calculateGrowth(
      _staker: string,
      _score: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _rewards: BigNumber }>;

    cbzStaked(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber, BigNumber, BigNumber] & {
        owner: string;
        start: BigNumber;
        end: BigNumber;
        boxClaimed: BigNumber;
        flowersHarwested: BigNumber;
      }
    >;

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

    harvestFlowers(
      score: BigNumberish,
      at: BigNumberish,
      nonce: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    onERC1155BatchReceived(
      arg0: string,
      arg1: string,
      arg2: BigNumberish[],
      arg3: BigNumberish[],
      arg4: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

    onERC1155Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BigNumberish,
      arg4: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

    onERC721Received(
      arg0: string,
      from: string,
      tokenid: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    seedStaked(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber, BigNumber] & {
        owner: string;
        start: BigNumber;
        produced: BigNumber;
        end: BigNumber;
      }
    >;

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

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

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

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

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

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

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

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

    stakers(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        id: BigNumber;
        cbzStaked: BigNumber;
        seedStaked: BigNumber;
        timeOfRegistration: BigNumber;
        timeOfLastBoxUpdate: BigNumber;
        timeOfLastGrowthUpdate: BigNumber;
        unclaimedMysteryBoxes: BigNumber;
        unclaimedFlowers: BigNumber;
        claimedMysteryBoxes: BigNumber;
        claimedFlowers: BigNumber;
        web2score: BigNumber;
        web2oas: BigNumber;
      }
    >;

    stakersArray(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string] & { owner: string }>;

    staking_parameters(
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        _escrowBUCK$: boolean;
        _stakingBUCK$: boolean;
        _boxBurningCost: BigNumber;
        _boxInterval: BigNumber;
        _boxReward: BigNumber;
        _exchangeReward: BigNumber;
        _maxSeedPerCorner: BigNumber;
        _minimumHarvest: BigNumber;
        _seedInterval: BigNumber;
        _seedReward: BigNumber;
        _unclaimedReward: BigNumber;
      }
    >;

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

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

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

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

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

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

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

  StakerInfo(
    _user: string,
    _score: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber] & {
      _cbzStaked: BigNumber;
      _seedsStaked: BigNumber;
      _mysteryBox: BigNumber;
      _fowers: BigNumber;
    }
  >;

  approveSpendERC20(
    token: string,
    spender: string,
    value: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

  burnMysteryBox(
    amount: BigNumberish,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

  calculateGrowth(
    _staker: string,
    _score: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  cbzStaked(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, BigNumber, BigNumber, BigNumber] & {
      owner: string;
      start: BigNumber;
      end: BigNumber;
      boxClaimed: BigNumber;
      flowersHarwested: BigNumber;
    }
  >;

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

  harvestFlowers(
    score: BigNumberish,
    at: BigNumberish,
    nonce: BigNumberish,
    data: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  onERC1155BatchReceived(
    arg0: string,
    arg1: string,
    arg2: BigNumberish[],
    arg3: BigNumberish[],
    arg4: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

  onERC1155Received(
    arg0: string,
    arg1: string,
    arg2: BigNumberish,
    arg3: BigNumberish,
    arg4: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

  onERC721Received(
    arg0: string,
    from: string,
    tokenid: BigNumberish,
    arg3: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  seedStaked(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, BigNumber, BigNumber] & {
      owner: string;
      start: BigNumber;
      produced: BigNumber;
      end: BigNumber;
    }
  >;

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

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

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

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

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

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

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

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

  stakers(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      id: BigNumber;
      cbzStaked: BigNumber;
      seedStaked: BigNumber;
      timeOfRegistration: BigNumber;
      timeOfLastBoxUpdate: BigNumber;
      timeOfLastGrowthUpdate: BigNumber;
      unclaimedMysteryBoxes: BigNumber;
      unclaimedFlowers: BigNumber;
      claimedMysteryBoxes: BigNumber;
      claimedFlowers: BigNumber;
      web2score: BigNumber;
      web2oas: BigNumber;
    }
  >;

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

  staking_parameters(
    overrides?: CallOverrides
  ): Promise<
    [
      boolean,
      boolean,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      _escrowBUCK$: boolean;
      _stakingBUCK$: boolean;
      _boxBurningCost: BigNumber;
      _boxInterval: BigNumber;
      _boxReward: BigNumber;
      _exchangeReward: BigNumber;
      _maxSeedPerCorner: BigNumber;
      _minimumHarvest: BigNumber;
      _seedInterval: BigNumber;
      _seedReward: BigNumber;
      _unclaimedReward: BigNumber;
    }
  >;

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

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

  supportsInterface(
    interfaceId: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

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

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

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

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

    StakerInfo(
      _user: string,
      _score: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        _cbzStaked: BigNumber;
        _seedsStaked: BigNumber;
        _mysteryBox: BigNumber;
        _fowers: BigNumber;
      }
    >;

    approveSpendERC20(
      token: string,
      spender: string,
      value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

    bucksMOVE(
      from: string[],
      to: string[],
      amount: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    bucksWITHDRAW(
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    calculateGrowth(
      _staker: string,
      _score: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    cbzStaked(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber, BigNumber, BigNumber] & {
        owner: string;
        start: BigNumber;
        end: BigNumber;
        boxClaimed: BigNumber;
        flowersHarwested: BigNumber;
      }
    >;

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

    harvestFlowers(
      score: BigNumberish,
      at: BigNumberish,
      nonce: BigNumberish,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

    onERC1155BatchReceived(
      arg0: string,
      arg1: string,
      arg2: BigNumberish[],
      arg3: BigNumberish[],
      arg4: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    onERC1155Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BigNumberish,
      arg4: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    onERC721Received(
      arg0: string,
      from: string,
      tokenid: BigNumberish,
      arg3: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    seedStaked(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber, BigNumber] & {
        owner: string;
        start: BigNumber;
        produced: BigNumber;
        end: BigNumber;
      }
    >;

    setMaxCBZsPerSeed(
      _newValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMaxSeedPerCBZ(
      _newValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMinimumHarvest(
      _newValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setSeedInterval(
      _newValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setSeedReward(
      _newValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    stake(_tokenIds: BigNumberish[], overrides?: CallOverrides): Promise<void>;

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

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

    stakers(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        id: BigNumber;
        cbzStaked: BigNumber;
        seedStaked: BigNumber;
        timeOfRegistration: BigNumber;
        timeOfLastBoxUpdate: BigNumber;
        timeOfLastGrowthUpdate: BigNumber;
        unclaimedMysteryBoxes: BigNumber;
        unclaimedFlowers: BigNumber;
        claimedMysteryBoxes: BigNumber;
        claimedFlowers: BigNumber;
        web2score: BigNumber;
        web2oas: BigNumber;
      }
    >;

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

    staking_parameters(
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        _escrowBUCK$: boolean;
        _stakingBUCK$: boolean;
        _boxBurningCost: BigNumber;
        _boxInterval: BigNumber;
        _boxReward: BigNumber;
        _exchangeReward: BigNumber;
        _maxSeedPerCorner: BigNumber;
        _minimumHarvest: BigNumber;
        _seedInterval: BigNumber;
        _seedReward: BigNumber;
        _unclaimedReward: BigNumber;
      }
    >;

    startGrowing(
      _tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    stopGrowing(
      _tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    unstake(
      _tokenIds: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

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

  filters: {};

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

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

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

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

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

    StakerInfo(
      _user: string,
      _score: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approveSpendERC20(
      token: string,
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

    burnMysteryBox(
      amount: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;

    calculateGrowth(
      _staker: string,
      _score: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    harvestFlowers(
      score: BigNumberish,
      at: BigNumberish,
      nonce: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    onERC1155BatchReceived(
      arg0: string,
      arg1: string,
      arg2: BigNumberish[],
      arg3: BigNumberish[],
      arg4: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    onERC1155Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BigNumberish,
      arg4: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    onERC721Received(
      arg0: string,
      from: string,
      tokenid: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    StakerInfo(
      _user: string,
      _score: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    approveSpendERC20(
      token: string,
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    burnMysteryBox(
      amount: BigNumberish,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    calculateGrowth(
      _staker: string,
      _score: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    harvestFlowers(
      score: BigNumberish,
      at: BigNumberish,
      nonce: BigNumberish,
      data: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    onERC1155BatchReceived(
      arg0: string,
      arg1: string,
      arg2: BigNumberish[],
      arg3: BigNumberish[],
      arg4: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    onERC1155Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BigNumberish,
      arg4: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    onERC721Received(
      arg0: string,
      from: string,
      tokenid: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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