@collabland/staking-contracts/dist/types/RandomStaking.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 declare namespace RandomStaking {
    type StakeStruct = {
        nftId: BigNumberish;
        timestamp: BigNumberish;
        collection: string;
        owner: string;
        lockupPeriod: BigNumberish;
        staketime: BigNumberish;
    };
    type StakeStructOutput = [
        number,
        number,
        string,
        string,
        number,
        number
    ] & {
        nftId: number;
        timestamp: number;
        collection: string;
        owner: string;
        lockupPeriod: number;
        staketime: number;
    };
}
export interface RandomStakingInterface extends utils.Interface {
    functions: {
        "addCollections(address[])": FunctionFragment;
        "balanceOf(address,address)": FunctionFragment;
        "claim(uint256[],address)": FunctionFragment;
        "claimForAddress(address,address,uint256[])": FunctionFragment;
        "earningInfo(uint256[],address,uint256)": FunctionFragment;
        "getStakedNftForOwner(address,address)": FunctionFragment;
        "isPaused()": FunctionFragment;
        "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
        "owner()": FunctionFragment;
        "randomsStaked(uint256,address)": FunctionFragment;
        "removeCollections(address[])": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "setPaused(bool)": FunctionFragment;
        "stake(uint256[],address,uint8)": FunctionFragment;
        "stakeAllowedCollections(address)": FunctionFragment;
        "tokensOfOwner(address,address)": FunctionFragment;
        "totalStaked()": FunctionFragment;
        "transferOwnership(address)": FunctionFragment;
        "unstake(uint256[],address)": FunctionFragment;
        "unstakeForAddress(address,address,uint256[])": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "addCollections" | "balanceOf" | "claim" | "claimForAddress" | "earningInfo" | "getStakedNftForOwner" | "isPaused" | "onERC721Received" | "owner" | "randomsStaked" | "removeCollections" | "renounceOwnership" | "setPaused" | "stake" | "stakeAllowedCollections" | "tokensOfOwner" | "totalStaked" | "transferOwnership" | "unstake" | "unstakeForAddress"): FunctionFragment;
    encodeFunctionData(functionFragment: "addCollections", values: [string[]]): string;
    encodeFunctionData(functionFragment: "balanceOf", values: [string, string]): string;
    encodeFunctionData(functionFragment: "claim", values: [BigNumberish[], string]): string;
    encodeFunctionData(functionFragment: "claimForAddress", values: [string, string, BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "earningInfo", values: [BigNumberish[], string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "getStakedNftForOwner", values: [string, string]): string;
    encodeFunctionData(functionFragment: "isPaused", values?: undefined): string;
    encodeFunctionData(functionFragment: "onERC721Received", values: [string, string, BigNumberish, BytesLike]): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "randomsStaked", values: [BigNumberish, string]): string;
    encodeFunctionData(functionFragment: "removeCollections", values: [string[]]): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "setPaused", values: [boolean]): string;
    encodeFunctionData(functionFragment: "stake", values: [BigNumberish[], string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "stakeAllowedCollections", values: [string]): string;
    encodeFunctionData(functionFragment: "tokensOfOwner", values: [string, string]): string;
    encodeFunctionData(functionFragment: "totalStaked", values?: undefined): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
    encodeFunctionData(functionFragment: "unstake", values: [BigNumberish[], string]): string;
    encodeFunctionData(functionFragment: "unstakeForAddress", values: [string, string, BigNumberish[]]): string;
    decodeFunctionResult(functionFragment: "addCollections", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claimForAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "earningInfo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakedNftForOwner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isPaused", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "onERC721Received", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "randomsStaked", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "removeCollections", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setPaused", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakeAllowedCollections", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "tokensOfOwner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalStaked", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unstake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unstakeForAddress", data: BytesLike): Result;
    events: {
        "OwnershipTransferred(address,address)": EventFragment;
        "nftRemoved(address,uint256,uint256)": EventFragment;
        "randomStaked(address,uint256,uint256)": EventFragment;
        "retrieveTokens(address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "nftRemoved"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "randomStaked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "retrieveTokens"): EventFragment;
}
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface nftRemovedEventObject {
    owner: string;
    nftId: BigNumber;
    value: BigNumber;
}
export type nftRemovedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], nftRemovedEventObject>;
export type nftRemovedEventFilter = TypedEventFilter<nftRemovedEvent>;
export interface randomStakedEventObject {
    owner: string;
    nftId: BigNumber;
    value: BigNumber;
}
export type randomStakedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], randomStakedEventObject>;
export type randomStakedEventFilter = TypedEventFilter<randomStakedEvent>;
export interface retrieveTokensEventObject {
    owner: string;
    amount: BigNumber;
}
export type retrieveTokensEvent = TypedEvent<[
    string,
    BigNumber
], retrieveTokensEventObject>;
export type retrieveTokensEventFilter = TypedEventFilter<retrieveTokensEvent>;
export interface RandomStaking extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: RandomStakingInterface;
    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: {
        addCollections(collections: string[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        balanceOf(account: string, collection: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        claim(nftIds: BigNumberish[], collection: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        claimForAddress(account: string, collection: string, nftIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        earningInfo(nftIds: BigNumberish[], collection: string, date: BigNumberish, overrides?: CallOverrides): Promise<[[BigNumber, BigNumber]]>;
        getStakedNftForOwner(account: string, collection: string, overrides?: CallOverrides): Promise<[RandomStaking.StakeStructOutput[]]>;
        isPaused(overrides?: CallOverrides): Promise<[boolean]>;
        onERC721Received(arg0: string, from: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<[string]>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        randomsStaked(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<[
            number,
            number,
            string,
            string,
            number,
            number
        ] & {
            nftId: number;
            timestamp: number;
            collection: string;
            owner: string;
            lockupPeriod: number;
            staketime: number;
        }>;
        removeCollections(collections: string[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setPaused(_paused: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        stake(nftIds: BigNumberish[], collection: string, period: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        stakeAllowedCollections(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;
        tokensOfOwner(account: string, collection: string, overrides?: CallOverrides): Promise<[BigNumber[]] & {
            ownerTokens: BigNumber[];
        }>;
        totalStaked(overrides?: CallOverrides): Promise<[BigNumber]>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        unstake(nftIds: BigNumberish[], collection: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        unstakeForAddress(account: string, collection: string, nftIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    addCollections(collections: string[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    balanceOf(account: string, collection: string, overrides?: CallOverrides): Promise<BigNumber>;
    claim(nftIds: BigNumberish[], collection: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    claimForAddress(account: string, collection: string, nftIds: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    earningInfo(nftIds: BigNumberish[], collection: string, date: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>;
    getStakedNftForOwner(account: string, collection: string, overrides?: CallOverrides): Promise<RandomStaking.StakeStructOutput[]>;
    isPaused(overrides?: CallOverrides): Promise<boolean>;
    onERC721Received(arg0: string, from: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<string>;
    owner(overrides?: CallOverrides): Promise<string>;
    randomsStaked(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<[
        number,
        number,
        string,
        string,
        number,
        number
    ] & {
        nftId: number;
        timestamp: number;
        collection: string;
        owner: string;
        lockupPeriod: number;
        staketime: number;
    }>;
    removeCollections(collections: string[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    renounceOwnership(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setPaused(_paused: boolean, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    stake(nftIds: BigNumberish[], collection: string, period: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    stakeAllowedCollections(arg0: string, overrides?: CallOverrides): Promise<boolean>;
    tokensOfOwner(account: string, collection: string, overrides?: CallOverrides): Promise<BigNumber[]>;
    totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    unstake(nftIds: BigNumberish[], collection: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    unstakeForAddress(account: string, collection: string, nftIds: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        addCollections(collections: string[], overrides?: CallOverrides): Promise<void>;
        balanceOf(account: string, collection: string, overrides?: CallOverrides): Promise<BigNumber>;
        claim(nftIds: BigNumberish[], collection: string, overrides?: CallOverrides): Promise<void>;
        claimForAddress(account: string, collection: string, nftIds: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        earningInfo(nftIds: BigNumberish[], collection: string, date: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>;
        getStakedNftForOwner(account: string, collection: string, overrides?: CallOverrides): Promise<RandomStaking.StakeStructOutput[]>;
        isPaused(overrides?: CallOverrides): Promise<boolean>;
        onERC721Received(arg0: string, from: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<string>;
        owner(overrides?: CallOverrides): Promise<string>;
        randomsStaked(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<[
            number,
            number,
            string,
            string,
            number,
            number
        ] & {
            nftId: number;
            timestamp: number;
            collection: string;
            owner: string;
            lockupPeriod: number;
            staketime: number;
        }>;
        removeCollections(collections: string[], overrides?: CallOverrides): Promise<void>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        setPaused(_paused: boolean, overrides?: CallOverrides): Promise<void>;
        stake(nftIds: BigNumberish[], collection: string, period: BigNumberish, overrides?: CallOverrides): Promise<void>;
        stakeAllowedCollections(arg0: string, overrides?: CallOverrides): Promise<boolean>;
        tokensOfOwner(account: string, collection: string, overrides?: CallOverrides): Promise<BigNumber[]>;
        totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
        unstake(nftIds: BigNumberish[], collection: string, overrides?: CallOverrides): Promise<void>;
        unstakeForAddress(account: string, collection: string, nftIds: BigNumberish[], overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        "nftRemoved(address,uint256,uint256)"(owner?: null, nftId?: null, value?: null): nftRemovedEventFilter;
        nftRemoved(owner?: null, nftId?: null, value?: null): nftRemovedEventFilter;
        "randomStaked(address,uint256,uint256)"(owner?: null, nftId?: null, value?: null): randomStakedEventFilter;
        randomStaked(owner?: null, nftId?: null, value?: null): randomStakedEventFilter;
        "retrieveTokens(address,uint256)"(owner?: null, amount?: null): retrieveTokensEventFilter;
        retrieveTokens(owner?: null, amount?: null): retrieveTokensEventFilter;
    };
    estimateGas: {
        addCollections(collections: string[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        balanceOf(account: string, collection: string, overrides?: CallOverrides): Promise<BigNumber>;
        claim(nftIds: BigNumberish[], collection: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        claimForAddress(account: string, collection: string, nftIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        earningInfo(nftIds: BigNumberish[], collection: string, date: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getStakedNftForOwner(account: string, collection: string, overrides?: CallOverrides): Promise<BigNumber>;
        isPaused(overrides?: CallOverrides): Promise<BigNumber>;
        onERC721Received(arg0: string, from: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        randomsStaked(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<BigNumber>;
        removeCollections(collections: string[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setPaused(_paused: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        stake(nftIds: BigNumberish[], collection: string, period: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        stakeAllowedCollections(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        tokensOfOwner(account: string, collection: string, overrides?: CallOverrides): Promise<BigNumber>;
        totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        unstake(nftIds: BigNumberish[], collection: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        unstakeForAddress(account: string, collection: string, nftIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        addCollections(collections: string[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        balanceOf(account: string, collection: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        claim(nftIds: BigNumberish[], collection: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        claimForAddress(account: string, collection: string, nftIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        earningInfo(nftIds: BigNumberish[], collection: string, date: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakedNftForOwner(account: string, collection: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isPaused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        onERC721Received(arg0: string, from: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        randomsStaked(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        removeCollections(collections: string[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setPaused(_paused: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        stake(nftIds: BigNumberish[], collection: string, period: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        stakeAllowedCollections(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        tokensOfOwner(account: string, collection: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalStaked(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        unstake(nftIds: BigNumberish[], collection: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        unstakeForAddress(account: string, collection: string, nftIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}