@cryptoalgebra/alm-sdk/dist/abis/types/FarmingRewardsDistributor.d.ts

Algebra ALM SDK

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, PromiseOrValue } from "./common";
export interface FarmingRewardsDistributorInterface extends utils.Interface {
    functions: {
        "addReward(address)": FunctionFragment;
        "algebraVaultFactory()": FunctionFragment;
        "claimable(address,address)": FunctionFragment;
        "claimableRewards(address)": FunctionFragment;
        "getAllRewards()": FunctionFragment;
        "getReward(address,address[])": FunctionFragment;
        "getUserData(address)": FunctionFragment;
        "getUserRewardPerToken(address,address)": FunctionFragment;
        "managers(address)": FunctionFragment;
        "pause()": FunctionFragment;
        "paused()": FunctionFragment;
        "recoverERC20(address,uint256)": FunctionFragment;
        "rewardData(address)": FunctionFragment;
        "rewardTokens(uint256)": FunctionFragment;
        "stake(uint256,address)": FunctionFragment;
        "stakingToken()": FunctionFragment;
        "totalBalance(address)": FunctionFragment;
        "totalStakes()": FunctionFragment;
        "unpause()": FunctionFragment;
        "unstake(uint256)": FunctionFragment;
        "updateReward()": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "addReward" | "algebraVaultFactory" | "claimable" | "claimableRewards" | "getAllRewards" | "getReward" | "getUserData" | "getUserRewardPerToken" | "managers" | "pause" | "paused" | "recoverERC20" | "rewardData" | "rewardTokens" | "stake" | "stakingToken" | "totalBalance" | "totalStakes" | "unpause" | "unstake" | "updateReward"): FunctionFragment;
    encodeFunctionData(functionFragment: "addReward", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "algebraVaultFactory", values?: undefined): string;
    encodeFunctionData(functionFragment: "claimable", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "claimableRewards", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getAllRewards", values?: undefined): string;
    encodeFunctionData(functionFragment: "getReward", values: [PromiseOrValue<string>, PromiseOrValue<string>[]]): string;
    encodeFunctionData(functionFragment: "getUserData", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getUserRewardPerToken", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "managers", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "pause", values?: undefined): string;
    encodeFunctionData(functionFragment: "paused", values?: undefined): string;
    encodeFunctionData(functionFragment: "recoverERC20", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "rewardData", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "rewardTokens", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "stake", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "stakingToken", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalBalance", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "totalStakes", values?: undefined): string;
    encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
    encodeFunctionData(functionFragment: "unstake", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "updateReward", values?: undefined): string;
    decodeFunctionResult(functionFragment: "addReward", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "algebraVaultFactory", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claimable", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claimableRewards", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getAllRewards", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getReward", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getUserData", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getUserRewardPerToken", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "managers", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "recoverERC20", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rewardData", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rewardTokens", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakingToken", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalStakes", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unstake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "updateReward", data: BytesLike): Result;
    events: {
        "Paused(address)": EventFragment;
        "Recovered(address,uint256)": EventFragment;
        "RewardPaid(address,address,uint256)": EventFragment;
        "RewardsUpdated()": EventFragment;
        "Stake(address,uint256)": EventFragment;
        "Unpaused(address)": EventFragment;
        "Unstake(address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Recovered"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RewardPaid"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RewardsUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Unstake"): EventFragment;
}
export interface PausedEventObject {
    account: string;
}
export type PausedEvent = TypedEvent<[string], PausedEventObject>;
export type PausedEventFilter = TypedEventFilter<PausedEvent>;
export interface RecoveredEventObject {
    token: string;
    amount: BigNumber;
}
export type RecoveredEvent = TypedEvent<[
    string,
    BigNumber
], RecoveredEventObject>;
export type RecoveredEventFilter = TypedEventFilter<RecoveredEvent>;
export interface RewardPaidEventObject {
    user: string;
    rewardToken: string;
    reward: BigNumber;
}
export type RewardPaidEvent = TypedEvent<[
    string,
    string,
    BigNumber
], RewardPaidEventObject>;
export type RewardPaidEventFilter = TypedEventFilter<RewardPaidEvent>;
export interface RewardsUpdatedEventObject {
}
export type RewardsUpdatedEvent = TypedEvent<[], RewardsUpdatedEventObject>;
export type RewardsUpdatedEventFilter = TypedEventFilter<RewardsUpdatedEvent>;
export interface StakeEventObject {
    user: string;
    amount: BigNumber;
}
export type StakeEvent = TypedEvent<[string, BigNumber], StakeEventObject>;
export type StakeEventFilter = TypedEventFilter<StakeEvent>;
export interface UnpausedEventObject {
    account: string;
}
export type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>;
export type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>;
export interface UnstakeEventObject {
    user: string;
    receivedAmount: BigNumber;
}
export type UnstakeEvent = TypedEvent<[string, BigNumber], UnstakeEventObject>;
export type UnstakeEventFilter = TypedEventFilter<UnstakeEvent>;
export interface FarmingRewardsDistributor extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: FarmingRewardsDistributorInterface;
    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: {
        addReward(_rewardToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        algebraVaultFactory(overrides?: CallOverrides): Promise<[string]>;
        claimable(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        claimableRewards(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string[], BigNumber[]]>;
        getAllRewards(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        getReward(_onBehalfOf: PromiseOrValue<string>, _rewardTokens: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        getUserData(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            tokenAmount: BigNumber;
            lastTimeUpdated: BigNumber;
            tokenClaimable: BigNumber;
        }>;
        getUserRewardPerToken(user: PromiseOrValue<string>, rewardToken: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        managers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        pause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        paused(overrides?: CallOverrides): Promise<[boolean]>;
        recoverERC20(tokenAddress: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        rewardData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            amount: BigNumber;
            lastTimeUpdated: BigNumber;
            rewardPerToken: BigNumber;
        }>;
        rewardTokens(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
        stake(amount: PromiseOrValue<BigNumberish>, onBehalfOf: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        stakingToken(overrides?: CallOverrides): Promise<[string]>;
        totalBalance(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        totalStakes(overrides?: CallOverrides): Promise<[BigNumber]>;
        unpause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        unstake(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        updateReward(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
    };
    addReward(_rewardToken: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    algebraVaultFactory(overrides?: CallOverrides): Promise<string>;
    claimable(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    claimableRewards(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string[], BigNumber[]]>;
    getAllRewards(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    getReward(_onBehalfOf: PromiseOrValue<string>, _rewardTokens: PromiseOrValue<string>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    getUserData(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        tokenAmount: BigNumber;
        lastTimeUpdated: BigNumber;
        tokenClaimable: BigNumber;
    }>;
    getUserRewardPerToken(user: PromiseOrValue<string>, rewardToken: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    managers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    pause(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    paused(overrides?: CallOverrides): Promise<boolean>;
    recoverERC20(tokenAddress: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    rewardData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        amount: BigNumber;
        lastTimeUpdated: BigNumber;
        rewardPerToken: BigNumber;
    }>;
    rewardTokens(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
    stake(amount: PromiseOrValue<BigNumberish>, onBehalfOf: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    stakingToken(overrides?: CallOverrides): Promise<string>;
    totalBalance(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    totalStakes(overrides?: CallOverrides): Promise<BigNumber>;
    unpause(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    unstake(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    updateReward(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        addReward(_rewardToken: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        algebraVaultFactory(overrides?: CallOverrides): Promise<string>;
        claimable(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        claimableRewards(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string[], BigNumber[]]>;
        getAllRewards(overrides?: CallOverrides): Promise<BigNumber[]>;
        getReward(_onBehalfOf: PromiseOrValue<string>, _rewardTokens: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<BigNumber[]>;
        getUserData(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            tokenAmount: BigNumber;
            lastTimeUpdated: BigNumber;
            tokenClaimable: BigNumber;
        }>;
        getUserRewardPerToken(user: PromiseOrValue<string>, rewardToken: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        managers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        pause(overrides?: CallOverrides): Promise<void>;
        paused(overrides?: CallOverrides): Promise<boolean>;
        recoverERC20(tokenAddress: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        rewardData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            amount: BigNumber;
            lastTimeUpdated: BigNumber;
            rewardPerToken: BigNumber;
        }>;
        rewardTokens(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        stake(amount: PromiseOrValue<BigNumberish>, onBehalfOf: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        stakingToken(overrides?: CallOverrides): Promise<string>;
        totalBalance(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        totalStakes(overrides?: CallOverrides): Promise<BigNumber>;
        unpause(overrides?: CallOverrides): Promise<void>;
        unstake(amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        updateReward(overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "Paused(address)"(account?: null): PausedEventFilter;
        Paused(account?: null): PausedEventFilter;
        "Recovered(address,uint256)"(token?: PromiseOrValue<string> | null, amount?: null): RecoveredEventFilter;
        Recovered(token?: PromiseOrValue<string> | null, amount?: null): RecoveredEventFilter;
        "RewardPaid(address,address,uint256)"(user?: PromiseOrValue<string> | null, rewardToken?: PromiseOrValue<string> | null, reward?: null): RewardPaidEventFilter;
        RewardPaid(user?: PromiseOrValue<string> | null, rewardToken?: PromiseOrValue<string> | null, reward?: null): RewardPaidEventFilter;
        "RewardsUpdated()"(): RewardsUpdatedEventFilter;
        RewardsUpdated(): RewardsUpdatedEventFilter;
        "Stake(address,uint256)"(user?: PromiseOrValue<string> | null, amount?: null): StakeEventFilter;
        Stake(user?: PromiseOrValue<string> | null, amount?: null): StakeEventFilter;
        "Unpaused(address)"(account?: null): UnpausedEventFilter;
        Unpaused(account?: null): UnpausedEventFilter;
        "Unstake(address,uint256)"(user?: PromiseOrValue<string> | null, receivedAmount?: null): UnstakeEventFilter;
        Unstake(user?: PromiseOrValue<string> | null, receivedAmount?: null): UnstakeEventFilter;
    };
    estimateGas: {
        addReward(_rewardToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        algebraVaultFactory(overrides?: CallOverrides): Promise<BigNumber>;
        claimable(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        claimableRewards(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getAllRewards(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        getReward(_onBehalfOf: PromiseOrValue<string>, _rewardTokens: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        getUserData(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getUserRewardPerToken(user: PromiseOrValue<string>, rewardToken: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        managers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        pause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        paused(overrides?: CallOverrides): Promise<BigNumber>;
        recoverERC20(tokenAddress: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        rewardData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        rewardTokens(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        stake(amount: PromiseOrValue<BigNumberish>, onBehalfOf: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        stakingToken(overrides?: CallOverrides): Promise<BigNumber>;
        totalBalance(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        totalStakes(overrides?: CallOverrides): Promise<BigNumber>;
        unpause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        unstake(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        updateReward(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        addReward(_rewardToken: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        algebraVaultFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        claimable(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        claimableRewards(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAllRewards(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        getReward(_onBehalfOf: PromiseOrValue<string>, _rewardTokens: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        getUserData(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getUserRewardPerToken(user: PromiseOrValue<string>, rewardToken: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        managers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        paused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        recoverERC20(tokenAddress: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        rewardData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardTokens(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        stake(amount: PromiseOrValue<BigNumberish>, onBehalfOf: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        stakingToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalBalance(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalStakes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        unpause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        unstake(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        updateReward(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
    };
}