@collabland/staking-contracts/src/types/SuperverseStaking.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 declare namespace ISuperVerseStaker {
  export type InputItemStruct = { itemId: BigNumberish; origin: BigNumberish };

  export type InputItemStructOutput = [BigNumber, number] & {
    itemId: BigNumber;
    origin: number;
  };
}

export declare namespace EscapeHatch {
  export type AssetStruct = {
    assetType: BigNumberish;
    asset: string;
    id: BigNumberish;
    amount: BigNumberish;
    to: string;
  };

  export type AssetStructOutput = [
    number,
    string,
    BigNumber,
    BigNumber,
    string
  ] & {
    assetType: number;
    asset: string;
    id: BigNumber;
    amount: BigNumber;
    to: string;
  };
}

export interface SuperverseStakingInterface extends utils.Interface {
  functions: {
    "ET_COLLECTION()": FunctionFragment;
    "REWARD_PERIOD()": FunctionFragment;
    "SF_COLLECTION()": FunctionFragment;
    "TOKEN()": FunctionFragment;
    "allProduced()": FunctionFragment;
    "availableReward(address)": FunctionFragment;
    "claim()": FunctionFragment;
    "configureItemValues(uint8,uint256[],uint128[])": FunctionFragment;
    "hasRightUntil(address,bytes32,bytes32)": FunctionFragment;
    "itemValues(uint8,uint256)": FunctionFragment;
    "nextRebaseTimestamp()": FunctionFragment;
    "onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)": FunctionFragment;
    "onERC1155Received(address,address,uint256,uint256,bytes)": FunctionFragment;
    "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
    "owner()": FunctionFragment;
    "pause()": FunctionFragment;
    "producedReward()": FunctionFragment;
    "producedTimestamp()": FunctionFragment;
    "rebase()": FunctionFragment;
    "rebaseCooldown()": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "rescueAssets((uint8,address,uint256,uint256,address)[])": FunctionFragment;
    "reward()": FunctionFragment;
    "rpp()": FunctionFragment;
    "setManagerRight(bytes32,bytes32)": FunctionFragment;
    "setPermit(address,bytes32,bytes32,uint256)": FunctionFragment;
    "setRebaseCooldown(uint256)": FunctionFragment;
    "stake(uint256,address,(uint256,uint8)[])": FunctionFragment;
    "stakeTimestamps(address)": FunctionFragment;
    "stakerInfo(address)": FunctionFragment;
    "totalPower()": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "unpause()": FunctionFragment;
    "withdraw(uint256,(uint256,uint8)[])": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "ET_COLLECTION"
      | "REWARD_PERIOD"
      | "SF_COLLECTION"
      | "TOKEN"
      | "allProduced"
      | "availableReward"
      | "claim"
      | "configureItemValues"
      | "hasRightUntil"
      | "itemValues"
      | "nextRebaseTimestamp"
      | "onERC1155BatchReceived"
      | "onERC1155Received"
      | "onERC721Received"
      | "owner"
      | "pause"
      | "producedReward"
      | "producedTimestamp"
      | "rebase"
      | "rebaseCooldown"
      | "renounceOwnership"
      | "rescueAssets"
      | "reward"
      | "rpp"
      | "setManagerRight"
      | "setPermit"
      | "setRebaseCooldown"
      | "stake"
      | "stakeTimestamps"
      | "stakerInfo"
      | "totalPower"
      | "transferOwnership"
      | "unpause"
      | "withdraw"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "ET_COLLECTION",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "REWARD_PERIOD",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "SF_COLLECTION",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "TOKEN", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "allProduced",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "availableReward",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "claim", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "configureItemValues",
    values: [BigNumberish, BigNumberish[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "hasRightUntil",
    values: [string, BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "itemValues",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "nextRebaseTimestamp",
    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: "owner", values?: undefined): string;
  encodeFunctionData(functionFragment: "pause", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "producedReward",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "producedTimestamp",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "rebase", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "rebaseCooldown",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rescueAssets",
    values: [EscapeHatch.AssetStruct[]]
  ): string;
  encodeFunctionData(functionFragment: "reward", values?: undefined): string;
  encodeFunctionData(functionFragment: "rpp", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "setManagerRight",
    values: [BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "setPermit",
    values: [string, BytesLike, BytesLike, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRebaseCooldown",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stake",
    values: [BigNumberish, string, ISuperVerseStaker.InputItemStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeTimestamps",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "stakerInfo", values: [string]): string;
  encodeFunctionData(
    functionFragment: "totalPower",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [BigNumberish, ISuperVerseStaker.InputItemStruct[]]
  ): string;

  decodeFunctionResult(
    functionFragment: "ET_COLLECTION",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "REWARD_PERIOD",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "SF_COLLECTION",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "TOKEN", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "allProduced",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "availableReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "configureItemValues",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "hasRightUntil",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "itemValues", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "nextRebaseTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onERC1155BatchReceived",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onERC1155Received",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onERC721Received",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "producedReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "producedTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "rebase", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "rebaseCooldown",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rescueAssets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "reward", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "rpp", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setManagerRight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setPermit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setRebaseCooldown",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakeTimestamps",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stakerInfo", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "totalPower", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {
    "Claim(address,uint256)": EventFragment;
    "Fund(address,uint256)": EventFragment;
    "ManagementUpdated(address,bytes32,bytes32)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "PermitUpdated(address,address,bytes32,bytes32,uint256)": EventFragment;
    "Stake(address,uint256,uint256,(uint256,uint8)[])": EventFragment;
    "Withdraw(address,uint256,uint256,(uint256,uint8)[])": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Claim"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Fund"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ManagementUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PermitUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
}

export interface ClaimEventObject {
  user: string;
  amount: BigNumber;
}
export type ClaimEvent = TypedEvent<[string, BigNumber], ClaimEventObject>;

export type ClaimEventFilter = TypedEventFilter<ClaimEvent>;

export interface FundEventObject {
  user: string;
  amount: BigNumber;
}
export type FundEvent = TypedEvent<[string, BigNumber], FundEventObject>;

export type FundEventFilter = TypedEventFilter<FundEvent>;

export interface ManagementUpdatedEventObject {
  manager: string;
  managedRight: string;
  managerRight: string;
}
export type ManagementUpdatedEvent = TypedEvent<
  [string, string, string],
  ManagementUpdatedEventObject
>;

export type ManagementUpdatedEventFilter =
  TypedEventFilter<ManagementUpdatedEvent>;

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface PermitUpdatedEventObject {
  updater: string;
  updatee: string;
  circumstance: string;
  role: string;
  expirationTime: BigNumber;
}
export type PermitUpdatedEvent = TypedEvent<
  [string, string, string, string, BigNumber],
  PermitUpdatedEventObject
>;

export type PermitUpdatedEventFilter = TypedEventFilter<PermitUpdatedEvent>;

export interface StakeEventObject {
  user: string;
  amount: BigNumber;
  power: BigNumber;
  items: ISuperVerseStaker.InputItemStructOutput[];
}
export type StakeEvent = TypedEvent<
  [string, BigNumber, BigNumber, ISuperVerseStaker.InputItemStructOutput[]],
  StakeEventObject
>;

export type StakeEventFilter = TypedEventFilter<StakeEvent>;

export interface WithdrawEventObject {
  user: string;
  amount: BigNumber;
  power: BigNumber;
  items: ISuperVerseStaker.InputItemStructOutput[];
}
export type WithdrawEvent = TypedEvent<
  [string, BigNumber, BigNumber, ISuperVerseStaker.InputItemStructOutput[]],
  WithdrawEventObject
>;

export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;

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

  interface: SuperverseStakingInterface;

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

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

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

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

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

    availableReward(
      _staker: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    configureItemValues(
      _assetType: BigNumberish,
      _groupIds: BigNumberish[],
      _values: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    hasRightUntil(
      _address: string,
      _circumstance: BytesLike,
      _right: BytesLike,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    itemValues(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    nextRebaseTimestamp(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,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

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

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

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

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

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

    rescueAssets(
      _assets: EscapeHatch.AssetStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

    setManagerRight(
      _managedRight: BytesLike,
      _managerRight: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    setPermit(
      _address: string,
      _circumstance: BytesLike,
      _right: BytesLike,
      _expirationTime: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    stake(
      _amount: BigNumberish,
      _user: string,
      _items: ISuperVerseStaker.InputItemStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    stakerInfo(
      _staker: string,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber[],
        BigNumber[]
      ] & {
        stakerPower: BigNumber;
        stakedTokens: BigNumber;
        claimedReward: BigNumber;
        missedReward: BigNumber;
        availableToClaim: BigNumber;
        idsET: BigNumber[];
        idsSFs: BigNumber[];
      }
    >;

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

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

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

    withdraw(
      _amount: BigNumberish,
      _items: ISuperVerseStaker.InputItemStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;
  };

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

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

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

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

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

  availableReward(
    _staker: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  configureItemValues(
    _assetType: BigNumberish,
    _groupIds: BigNumberish[],
    _values: BigNumberish[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  hasRightUntil(
    _address: string,
    _circumstance: BytesLike,
    _right: BytesLike,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  nextRebaseTimestamp(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,
    arg1: string,
    arg2: BigNumberish,
    arg3: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

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

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

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

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

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

  rescueAssets(
    _assets: EscapeHatch.AssetStruct[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

  setManagerRight(
    _managedRight: BytesLike,
    _managerRight: BytesLike,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  setPermit(
    _address: string,
    _circumstance: BytesLike,
    _right: BytesLike,
    _expirationTime: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  stake(
    _amount: BigNumberish,
    _user: string,
    _items: ISuperVerseStaker.InputItemStruct[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  stakerInfo(
    _staker: string,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber[],
      BigNumber[]
    ] & {
      stakerPower: BigNumber;
      stakedTokens: BigNumber;
      claimedReward: BigNumber;
      missedReward: BigNumber;
      availableToClaim: BigNumber;
      idsET: BigNumber[];
      idsSFs: BigNumber[];
    }
  >;

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

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

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

  withdraw(
    _amount: BigNumberish,
    _items: ISuperVerseStaker.InputItemStruct[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

    availableReward(
      _staker: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    configureItemValues(
      _assetType: BigNumberish,
      _groupIds: BigNumberish[],
      _values: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    hasRightUntil(
      _address: string,
      _circumstance: BytesLike,
      _right: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    nextRebaseTimestamp(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,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

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

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

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

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

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

    rescueAssets(
      _assets: EscapeHatch.AssetStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    setManagerRight(
      _managedRight: BytesLike,
      _managerRight: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    setPermit(
      _address: string,
      _circumstance: BytesLike,
      _right: BytesLike,
      _expirationTime: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRebaseCooldown(
      _rebaseCooldown: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    stake(
      _amount: BigNumberish,
      _user: string,
      _items: ISuperVerseStaker.InputItemStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

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

    stakerInfo(
      _staker: string,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber[],
        BigNumber[]
      ] & {
        stakerPower: BigNumber;
        stakedTokens: BigNumber;
        claimedReward: BigNumber;
        missedReward: BigNumber;
        availableToClaim: BigNumber;
        idsET: BigNumber[];
        idsSFs: BigNumber[];
      }
    >;

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

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

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

    withdraw(
      _amount: BigNumberish,
      _items: ISuperVerseStaker.InputItemStruct[],
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "Claim(address,uint256)"(
      user?: string | null,
      amount?: null
    ): ClaimEventFilter;
    Claim(user?: string | null, amount?: null): ClaimEventFilter;

    "Fund(address,uint256)"(
      user?: string | null,
      amount?: null
    ): FundEventFilter;
    Fund(user?: string | null, amount?: null): FundEventFilter;

    "ManagementUpdated(address,bytes32,bytes32)"(
      manager?: string | null,
      managedRight?: BytesLike | null,
      managerRight?: BytesLike | null
    ): ManagementUpdatedEventFilter;
    ManagementUpdated(
      manager?: string | null,
      managedRight?: BytesLike | null,
      managerRight?: BytesLike | null
    ): ManagementUpdatedEventFilter;

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

    "PermitUpdated(address,address,bytes32,bytes32,uint256)"(
      updater?: string | null,
      updatee?: string | null,
      circumstance?: null,
      role?: BytesLike | null,
      expirationTime?: null
    ): PermitUpdatedEventFilter;
    PermitUpdated(
      updater?: string | null,
      updatee?: string | null,
      circumstance?: null,
      role?: BytesLike | null,
      expirationTime?: null
    ): PermitUpdatedEventFilter;

    "Stake(address,uint256,uint256,(uint256,uint8)[])"(
      user?: string | null,
      amount?: null,
      power?: null,
      items?: null
    ): StakeEventFilter;
    Stake(
      user?: string | null,
      amount?: null,
      power?: null,
      items?: null
    ): StakeEventFilter;

    "Withdraw(address,uint256,uint256,(uint256,uint8)[])"(
      user?: string | null,
      amount?: null,
      power?: null,
      items?: null
    ): WithdrawEventFilter;
    Withdraw(
      user?: string | null,
      amount?: null,
      power?: null,
      items?: null
    ): WithdrawEventFilter;
  };

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

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

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

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

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

    availableReward(
      _staker: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    configureItemValues(
      _assetType: BigNumberish,
      _groupIds: BigNumberish[],
      _values: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    hasRightUntil(
      _address: string,
      _circumstance: BytesLike,
      _right: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    nextRebaseTimestamp(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,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    rescueAssets(
      _assets: EscapeHatch.AssetStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

    setManagerRight(
      _managedRight: BytesLike,
      _managerRight: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setPermit(
      _address: string,
      _circumstance: BytesLike,
      _right: BytesLike,
      _expirationTime: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    stake(
      _amount: BigNumberish,
      _user: string,
      _items: ISuperVerseStaker.InputItemStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    stakerInfo(_staker: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

    withdraw(
      _amount: BigNumberish,
      _items: ISuperVerseStaker.InputItemStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;
  };

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

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

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

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

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

    availableReward(
      _staker: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    configureItemValues(
      _assetType: BigNumberish,
      _groupIds: BigNumberish[],
      _values: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    hasRightUntil(
      _address: string,
      _circumstance: BytesLike,
      _right: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    nextRebaseTimestamp(
      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,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    rescueAssets(
      _assets: EscapeHatch.AssetStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

    setManagerRight(
      _managedRight: BytesLike,
      _managerRight: BytesLike,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    setPermit(
      _address: string,
      _circumstance: BytesLike,
      _right: BytesLike,
      _expirationTime: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    stake(
      _amount: BigNumberish,
      _user: string,
      _items: ISuperVerseStaker.InputItemStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    stakerInfo(
      _staker: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    withdraw(
      _amount: BigNumberish,
      _items: ISuperVerseStaker.InputItemStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;
  };
}