@collabland/staking-contracts/dist/types/MtgStaking.d.ts

Staking contracts supported by Collab.Land

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 MtgStakingInterface extends utils.Interface {
    functions: {
        "Arcada()": FunctionFragment;
        "ArcadaAddress()": FunctionFragment;
        "DAY()": FunctionFragment;
        "GAMER_RATE()": FunctionFragment;
        "LOCKIN_PERIODS()": FunctionFragment;
        "MTG()": FunctionFragment;
        "MTGAddress()": FunctionFragment;
        "ROYAL_GAMER_RATE()": FunctionFragment;
        "START()": FunctionFragment;
        "batchClaim(uint256[])": FunctionFragment;
        "batchStake(uint256[])": FunctionFragment;
        "batchUnstake(uint256[])": FunctionFragment;
        "emergencyUnstake(uint256)": FunctionFragment;
        "emergencyUnstakeByOwner(uint256[])": FunctionFragment;
        "emergencyUnstakePaused()": FunctionFragment;
        "getPendingRewards(uint256)": FunctionFragment;
        "getStakingRecords(address)": FunctionFragment;
        "numOfTokenStaked(address)": FunctionFragment;
        "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
        "owner()": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "setArcadaContract(address)": FunctionFragment;
        "setEmergencyUnstakePaused(bool)": FunctionFragment;
        "setGamerRewardRate(uint256)": FunctionFragment;
        "setMTGNFTContract(address)": FunctionFragment;
        "setRoyalGamerRewardRate(uint256)": FunctionFragment;
        "stakingRecords(uint256)": FunctionFragment;
        "transferOwnership(address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "Arcada" | "ArcadaAddress" | "DAY" | "GAMER_RATE" | "LOCKIN_PERIODS" | "MTG" | "MTGAddress" | "ROYAL_GAMER_RATE" | "START" | "batchClaim" | "batchStake" | "batchUnstake" | "emergencyUnstake" | "emergencyUnstakeByOwner" | "emergencyUnstakePaused" | "getPendingRewards" | "getStakingRecords" | "numOfTokenStaked" | "onERC721Received" | "owner" | "renounceOwnership" | "setArcadaContract" | "setEmergencyUnstakePaused" | "setGamerRewardRate" | "setMTGNFTContract" | "setRoyalGamerRewardRate" | "stakingRecords" | "transferOwnership"): FunctionFragment;
    encodeFunctionData(functionFragment: "Arcada", values?: undefined): string;
    encodeFunctionData(functionFragment: "ArcadaAddress", values?: undefined): string;
    encodeFunctionData(functionFragment: "DAY", values?: undefined): string;
    encodeFunctionData(functionFragment: "GAMER_RATE", values?: undefined): string;
    encodeFunctionData(functionFragment: "LOCKIN_PERIODS", values?: undefined): string;
    encodeFunctionData(functionFragment: "MTG", values?: undefined): string;
    encodeFunctionData(functionFragment: "MTGAddress", values?: undefined): string;
    encodeFunctionData(functionFragment: "ROYAL_GAMER_RATE", values?: undefined): string;
    encodeFunctionData(functionFragment: "START", values?: undefined): string;
    encodeFunctionData(functionFragment: "batchClaim", values: [BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "batchStake", values: [BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "batchUnstake", values: [BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "emergencyUnstake", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "emergencyUnstakeByOwner", values: [BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "emergencyUnstakePaused", values?: undefined): string;
    encodeFunctionData(functionFragment: "getPendingRewards", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "getStakingRecords", values: [string]): string;
    encodeFunctionData(functionFragment: "numOfTokenStaked", values: [string]): string;
    encodeFunctionData(functionFragment: "onERC721Received", values: [string, string, BigNumberish, BytesLike]): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "setArcadaContract", values: [string]): string;
    encodeFunctionData(functionFragment: "setEmergencyUnstakePaused", values: [boolean]): string;
    encodeFunctionData(functionFragment: "setGamerRewardRate", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setMTGNFTContract", values: [string]): string;
    encodeFunctionData(functionFragment: "setRoyalGamerRewardRate", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "stakingRecords", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
    decodeFunctionResult(functionFragment: "Arcada", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "ArcadaAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "DAY", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "GAMER_RATE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "LOCKIN_PERIODS", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MTG", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MTGAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "ROYAL_GAMER_RATE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "START", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "batchClaim", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "batchStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "batchUnstake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "emergencyUnstake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "emergencyUnstakeByOwner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "emergencyUnstakePaused", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getPendingRewards", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakingRecords", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "numOfTokenStaked", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "onERC721Received", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setArcadaContract", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setEmergencyUnstakePaused", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setGamerRewardRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setMTGNFTContract", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setRoyalGamerRewardRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakingRecords", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    events: {
        "Claimed(address,uint256)": EventFragment;
        "EmergencyUnstake(address,uint256)": EventFragment;
        "OwnershipTransferred(address,address)": EventFragment;
        "Staked(address,uint256)": EventFragment;
        "Unstaked(address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Claimed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "EmergencyUnstake"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Staked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Unstaked"): EventFragment;
}
export interface ClaimedEventObject {
    owner: string;
    rewards: BigNumber;
}
export type ClaimedEvent = TypedEvent<[string, BigNumber], ClaimedEventObject>;
export type ClaimedEventFilter = TypedEventFilter<ClaimedEvent>;
export interface EmergencyUnstakeEventObject {
    user: string;
    tokenId: BigNumber;
}
export type EmergencyUnstakeEvent = TypedEvent<[
    string,
    BigNumber
], EmergencyUnstakeEventObject>;
export type EmergencyUnstakeEventFilter = TypedEventFilter<EmergencyUnstakeEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface StakedEventObject {
    owner: string;
    amount: BigNumber;
}
export type StakedEvent = TypedEvent<[string, BigNumber], StakedEventObject>;
export type StakedEventFilter = TypedEventFilter<StakedEvent>;
export interface UnstakedEventObject {
    owner: string;
    amount: BigNumber;
}
export type UnstakedEvent = TypedEvent<[
    string,
    BigNumber
], UnstakedEventObject>;
export type UnstakedEventFilter = TypedEventFilter<UnstakedEvent>;
export interface MtgStaking extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: MtgStakingInterface;
    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: {
        Arcada(overrides?: CallOverrides): Promise<[string]>;
        ArcadaAddress(overrides?: CallOverrides): Promise<[string]>;
        DAY(overrides?: CallOverrides): Promise<[BigNumber]>;
        GAMER_RATE(overrides?: CallOverrides): Promise<[BigNumber]>;
        LOCKIN_PERIODS(overrides?: CallOverrides): Promise<[BigNumber]>;
        MTG(overrides?: CallOverrides): Promise<[string]>;
        MTGAddress(overrides?: CallOverrides): Promise<[string]>;
        ROYAL_GAMER_RATE(overrides?: CallOverrides): Promise<[BigNumber]>;
        START(overrides?: CallOverrides): Promise<[BigNumber]>;
        batchClaim(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        batchStake(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        batchUnstake(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        emergencyUnstake(tokenId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        emergencyUnstakeByOwner(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        emergencyUnstakePaused(overrides?: CallOverrides): Promise<[boolean]>;
        getPendingRewards(tokenId: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
        getStakingRecords(user: string, overrides?: CallOverrides): Promise<[BigNumber[], BigNumber[], BigNumber[]]>;
        numOfTokenStaked(arg0: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        onERC721Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<[string]>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setArcadaContract(operator: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setEmergencyUnstakePaused(paused: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setGamerRewardRate(rewardPerDay: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setMTGNFTContract(operator: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setRoyalGamerRewardRate(rewardPerDay: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        stakingRecords(arg0: BigNumberish, overrides?: CallOverrides): Promise<[
            string,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            tokenOwner: string;
            tokenId: BigNumber;
            lockInEndAt: BigNumber;
            stakedAt: BigNumber;
        }>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    Arcada(overrides?: CallOverrides): Promise<string>;
    ArcadaAddress(overrides?: CallOverrides): Promise<string>;
    DAY(overrides?: CallOverrides): Promise<BigNumber>;
    GAMER_RATE(overrides?: CallOverrides): Promise<BigNumber>;
    LOCKIN_PERIODS(overrides?: CallOverrides): Promise<BigNumber>;
    MTG(overrides?: CallOverrides): Promise<string>;
    MTGAddress(overrides?: CallOverrides): Promise<string>;
    ROYAL_GAMER_RATE(overrides?: CallOverrides): Promise<BigNumber>;
    START(overrides?: CallOverrides): Promise<BigNumber>;
    batchClaim(tokenIds: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    batchStake(tokenIds: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    batchUnstake(tokenIds: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    emergencyUnstake(tokenId: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    emergencyUnstakeByOwner(tokenIds: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    emergencyUnstakePaused(overrides?: CallOverrides): Promise<boolean>;
    getPendingRewards(tokenId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    getStakingRecords(user: string, overrides?: CallOverrides): Promise<[BigNumber[], BigNumber[], BigNumber[]]>;
    numOfTokenStaked(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    onERC721Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<string>;
    owner(overrides?: CallOverrides): Promise<string>;
    renounceOwnership(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setArcadaContract(operator: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setEmergencyUnstakePaused(paused: boolean, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setGamerRewardRate(rewardPerDay: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setMTGNFTContract(operator: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setRoyalGamerRewardRate(rewardPerDay: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    stakingRecords(arg0: BigNumberish, overrides?: CallOverrides): Promise<[
        string,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        tokenOwner: string;
        tokenId: BigNumber;
        lockInEndAt: BigNumber;
        stakedAt: BigNumber;
    }>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        Arcada(overrides?: CallOverrides): Promise<string>;
        ArcadaAddress(overrides?: CallOverrides): Promise<string>;
        DAY(overrides?: CallOverrides): Promise<BigNumber>;
        GAMER_RATE(overrides?: CallOverrides): Promise<BigNumber>;
        LOCKIN_PERIODS(overrides?: CallOverrides): Promise<BigNumber>;
        MTG(overrides?: CallOverrides): Promise<string>;
        MTGAddress(overrides?: CallOverrides): Promise<string>;
        ROYAL_GAMER_RATE(overrides?: CallOverrides): Promise<BigNumber>;
        START(overrides?: CallOverrides): Promise<BigNumber>;
        batchClaim(tokenIds: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        batchStake(tokenIds: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        batchUnstake(tokenIds: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        emergencyUnstake(tokenId: BigNumberish, overrides?: CallOverrides): Promise<void>;
        emergencyUnstakeByOwner(tokenIds: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        emergencyUnstakePaused(overrides?: CallOverrides): Promise<boolean>;
        getPendingRewards(tokenId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getStakingRecords(user: string, overrides?: CallOverrides): Promise<[BigNumber[], BigNumber[], BigNumber[]]>;
        numOfTokenStaked(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        onERC721Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<string>;
        owner(overrides?: CallOverrides): Promise<string>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        setArcadaContract(operator: string, overrides?: CallOverrides): Promise<void>;
        setEmergencyUnstakePaused(paused: boolean, overrides?: CallOverrides): Promise<void>;
        setGamerRewardRate(rewardPerDay: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setMTGNFTContract(operator: string, overrides?: CallOverrides): Promise<void>;
        setRoyalGamerRewardRate(rewardPerDay: BigNumberish, overrides?: CallOverrides): Promise<void>;
        stakingRecords(arg0: BigNumberish, overrides?: CallOverrides): Promise<[
            string,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            tokenOwner: string;
            tokenId: BigNumber;
            lockInEndAt: BigNumber;
            stakedAt: BigNumber;
        }>;
        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "Claimed(address,uint256)"(owner?: null, rewards?: null): ClaimedEventFilter;
        Claimed(owner?: null, rewards?: null): ClaimedEventFilter;
        "EmergencyUnstake(address,uint256)"(user?: string | null, tokenId?: null): EmergencyUnstakeEventFilter;
        EmergencyUnstake(user?: string | null, tokenId?: null): EmergencyUnstakeEventFilter;
        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        "Staked(address,uint256)"(owner?: null, amount?: null): StakedEventFilter;
        Staked(owner?: null, amount?: null): StakedEventFilter;
        "Unstaked(address,uint256)"(owner?: null, amount?: null): UnstakedEventFilter;
        Unstaked(owner?: null, amount?: null): UnstakedEventFilter;
    };
    estimateGas: {
        Arcada(overrides?: CallOverrides): Promise<BigNumber>;
        ArcadaAddress(overrides?: CallOverrides): Promise<BigNumber>;
        DAY(overrides?: CallOverrides): Promise<BigNumber>;
        GAMER_RATE(overrides?: CallOverrides): Promise<BigNumber>;
        LOCKIN_PERIODS(overrides?: CallOverrides): Promise<BigNumber>;
        MTG(overrides?: CallOverrides): Promise<BigNumber>;
        MTGAddress(overrides?: CallOverrides): Promise<BigNumber>;
        ROYAL_GAMER_RATE(overrides?: CallOverrides): Promise<BigNumber>;
        START(overrides?: CallOverrides): Promise<BigNumber>;
        batchClaim(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        batchStake(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        batchUnstake(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        emergencyUnstake(tokenId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        emergencyUnstakeByOwner(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        emergencyUnstakePaused(overrides?: CallOverrides): Promise<BigNumber>;
        getPendingRewards(tokenId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getStakingRecords(user: string, overrides?: CallOverrides): Promise<BigNumber>;
        numOfTokenStaked(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        onERC721Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setArcadaContract(operator: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setEmergencyUnstakePaused(paused: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setGamerRewardRate(rewardPerDay: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setMTGNFTContract(operator: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setRoyalGamerRewardRate(rewardPerDay: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        stakingRecords(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        Arcada(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        ArcadaAddress(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        DAY(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        GAMER_RATE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        LOCKIN_PERIODS(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MTG(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MTGAddress(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        ROYAL_GAMER_RATE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        START(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        batchClaim(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        batchStake(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        batchUnstake(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        emergencyUnstake(tokenId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        emergencyUnstakeByOwner(tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        emergencyUnstakePaused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getPendingRewards(tokenId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakingRecords(user: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        numOfTokenStaked(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        onERC721Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setArcadaContract(operator: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setEmergencyUnstakePaused(paused: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setGamerRewardRate(rewardPerDay: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setMTGNFTContract(operator: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setRoyalGamerRewardRate(rewardPerDay: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        stakingRecords(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}