@collabland/staking-contracts/dist/types/DwebUniV2Staking.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 DwebUniV2StakingInterface extends utils.Interface {
    functions: {
        "DEFAULT_ADMIN_ROLE()": FunctionFragment;
        "currentTotalStake()": FunctionFragment;
        "deposit(uint256)": FunctionFragment;
        "distributeRewards()": FunctionFragment;
        "executeWithdrawal()": FunctionFragment;
        "getRoleAdmin(bytes32)": FunctionFragment;
        "getRoleMember(bytes32,uint256)": FunctionFragment;
        "getRoleMemberCount(bytes32)": FunctionFragment;
        "getStakeDetails(address)": FunctionFragment;
        "grantRole(bytes32,address)": FunctionFragment;
        "hasRole(bytes32,address)": FunctionFragment;
        "initialize(address,address,address,uint256,uint256)": FunctionFragment;
        "initiateWithdrawal(uint256)": FunctionFragment;
        "lpToken()": FunctionFragment;
        "maxStakingAmount()": FunctionFragment;
        "pause()": FunctionFragment;
        "paused()": FunctionFragment;
        "renounceRole(bytes32,address)": FunctionFragment;
        "revokeRole(bytes32,address)": FunctionFragment;
        "rewardToken()": FunctionFragment;
        "rewardsAddress()": FunctionFragment;
        "rewardsDistributed()": FunctionFragment;
        "rewardsWithdrawn()": FunctionFragment;
        "setDepositTokenAddress(address)": FunctionFragment;
        "setRewardAddress(address)": FunctionFragment;
        "setRewardTokenAddress(address)": FunctionFragment;
        "totalRewardsDistributed()": FunctionFragment;
        "unpause()": FunctionFragment;
        "unstakingPeriod()": FunctionFragment;
        "version()": FunctionFragment;
        "withdrawRewards()": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "DEFAULT_ADMIN_ROLE" | "currentTotalStake" | "deposit" | "distributeRewards" | "executeWithdrawal" | "getRoleAdmin" | "getRoleMember" | "getRoleMemberCount" | "getStakeDetails" | "grantRole" | "hasRole" | "initialize" | "initiateWithdrawal" | "lpToken" | "maxStakingAmount" | "pause" | "paused" | "renounceRole" | "revokeRole" | "rewardToken" | "rewardsAddress" | "rewardsDistributed" | "rewardsWithdrawn" | "setDepositTokenAddress" | "setRewardAddress" | "setRewardTokenAddress" | "totalRewardsDistributed" | "unpause" | "unstakingPeriod" | "version" | "withdrawRewards"): FunctionFragment;
    encodeFunctionData(functionFragment: "DEFAULT_ADMIN_ROLE", values?: undefined): string;
    encodeFunctionData(functionFragment: "currentTotalStake", values?: undefined): string;
    encodeFunctionData(functionFragment: "deposit", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "distributeRewards", values?: undefined): string;
    encodeFunctionData(functionFragment: "executeWithdrawal", values?: undefined): string;
    encodeFunctionData(functionFragment: "getRoleAdmin", values: [BytesLike]): string;
    encodeFunctionData(functionFragment: "getRoleMember", values: [BytesLike, BigNumberish]): string;
    encodeFunctionData(functionFragment: "getRoleMemberCount", values: [BytesLike]): string;
    encodeFunctionData(functionFragment: "getStakeDetails", values: [string]): string;
    encodeFunctionData(functionFragment: "grantRole", values: [BytesLike, string]): string;
    encodeFunctionData(functionFragment: "hasRole", values: [BytesLike, string]): string;
    encodeFunctionData(functionFragment: "initialize", values: [string, string, string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "initiateWithdrawal", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "lpToken", values?: undefined): string;
    encodeFunctionData(functionFragment: "maxStakingAmount", values?: undefined): string;
    encodeFunctionData(functionFragment: "pause", values?: undefined): string;
    encodeFunctionData(functionFragment: "paused", values?: undefined): string;
    encodeFunctionData(functionFragment: "renounceRole", values: [BytesLike, string]): string;
    encodeFunctionData(functionFragment: "revokeRole", values: [BytesLike, string]): string;
    encodeFunctionData(functionFragment: "rewardToken", values?: undefined): string;
    encodeFunctionData(functionFragment: "rewardsAddress", values?: undefined): string;
    encodeFunctionData(functionFragment: "rewardsDistributed", values?: undefined): string;
    encodeFunctionData(functionFragment: "rewardsWithdrawn", values?: undefined): string;
    encodeFunctionData(functionFragment: "setDepositTokenAddress", values: [string]): string;
    encodeFunctionData(functionFragment: "setRewardAddress", values: [string]): string;
    encodeFunctionData(functionFragment: "setRewardTokenAddress", values: [string]): string;
    encodeFunctionData(functionFragment: "totalRewardsDistributed", values?: undefined): string;
    encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
    encodeFunctionData(functionFragment: "unstakingPeriod", values?: undefined): string;
    encodeFunctionData(functionFragment: "version", values?: undefined): string;
    encodeFunctionData(functionFragment: "withdrawRewards", values?: undefined): string;
    decodeFunctionResult(functionFragment: "DEFAULT_ADMIN_ROLE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "currentTotalStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "distributeRewards", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "executeWithdrawal", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRoleAdmin", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRoleMember", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRoleMemberCount", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakeDetails", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "initiateWithdrawal", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lpToken", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "maxStakingAmount", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceRole", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rewardToken", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rewardsAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rewardsDistributed", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rewardsWithdrawn", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDepositTokenAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setRewardAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setRewardTokenAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalRewardsDistributed", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unstakingPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawRewards", data: BytesLike): Result;
    events: {
        "Paused(address)": EventFragment;
        "RewardsDistributed(uint256)": EventFragment;
        "RewardsWithdrawn(address,uint256)": EventFragment;
        "RoleGranted(bytes32,address,address)": EventFragment;
        "RoleRevoked(bytes32,address,address)": EventFragment;
        "StakeDeposited(address,uint256)": EventFragment;
        "Unpaused(address)": EventFragment;
        "WithdrawExecuted(address,uint256,uint256)": EventFragment;
        "WithdrawInitiated(address,uint256,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RewardsDistributed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RewardsWithdrawn"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RoleGranted"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RoleRevoked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StakeDeposited"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "WithdrawExecuted"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "WithdrawInitiated"): EventFragment;
}
export interface PausedEventObject {
    account: string;
}
export type PausedEvent = TypedEvent<[string], PausedEventObject>;
export type PausedEventFilter = TypedEventFilter<PausedEvent>;
export interface RewardsDistributedEventObject {
    amount: BigNumber;
}
export type RewardsDistributedEvent = TypedEvent<[
    BigNumber
], RewardsDistributedEventObject>;
export type RewardsDistributedEventFilter = TypedEventFilter<RewardsDistributedEvent>;
export interface RewardsWithdrawnEventObject {
    account: string;
    reward: BigNumber;
}
export type RewardsWithdrawnEvent = TypedEvent<[
    string,
    BigNumber
], RewardsWithdrawnEventObject>;
export type RewardsWithdrawnEventFilter = TypedEventFilter<RewardsWithdrawnEvent>;
export interface RoleGrantedEventObject {
    role: string;
    account: string;
    sender: string;
}
export type RoleGrantedEvent = TypedEvent<[
    string,
    string,
    string
], RoleGrantedEventObject>;
export type RoleGrantedEventFilter = TypedEventFilter<RoleGrantedEvent>;
export interface RoleRevokedEventObject {
    role: string;
    account: string;
    sender: string;
}
export type RoleRevokedEvent = TypedEvent<[
    string,
    string,
    string
], RoleRevokedEventObject>;
export type RoleRevokedEventFilter = TypedEventFilter<RoleRevokedEvent>;
export interface StakeDepositedEventObject {
    account: string;
    amount: BigNumber;
}
export type StakeDepositedEvent = TypedEvent<[
    string,
    BigNumber
], StakeDepositedEventObject>;
export type StakeDepositedEventFilter = TypedEventFilter<StakeDepositedEvent>;
export interface UnpausedEventObject {
    account: string;
}
export type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>;
export type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>;
export interface WithdrawExecutedEventObject {
    account: string;
    amount: BigNumber;
    reward: BigNumber;
}
export type WithdrawExecutedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], WithdrawExecutedEventObject>;
export type WithdrawExecutedEventFilter = TypedEventFilter<WithdrawExecutedEvent>;
export interface WithdrawInitiatedEventObject {
    account: string;
    amount: BigNumber;
    initiateDate: BigNumber;
}
export type WithdrawInitiatedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], WithdrawInitiatedEventObject>;
export type WithdrawInitiatedEventFilter = TypedEventFilter<WithdrawInitiatedEvent>;
export interface DwebUniV2Staking extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: DwebUniV2StakingInterface;
    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: {
        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;
        currentTotalStake(overrides?: CallOverrides): Promise<[BigNumber]>;
        deposit(amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        distributeRewards(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        executeWithdrawal(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<[string]>;
        getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
        getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<[BigNumber]>;
        getStakeDetails(account: string, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            initialDeposit: BigNumber;
            startDate: BigNumber;
            endDate: BigNumber;
            rewards: BigNumber;
        }>;
        grantRole(role: BytesLike, account: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<[boolean]>;
        initialize(_lpToken: string, _rewardToken: string, _rewardsAddress: string, _maxStakingAmount: BigNumberish, _unstakingPeriod: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        initiateWithdrawal(withdrawAmount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        lpToken(overrides?: CallOverrides): Promise<[string]>;
        maxStakingAmount(overrides?: CallOverrides): Promise<[BigNumber]>;
        pause(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        paused(overrides?: CallOverrides): Promise<[boolean]>;
        renounceRole(role: BytesLike, account: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        revokeRole(role: BytesLike, account: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        rewardToken(overrides?: CallOverrides): Promise<[string]>;
        rewardsAddress(overrides?: CallOverrides): Promise<[string]>;
        rewardsDistributed(overrides?: CallOverrides): Promise<[BigNumber]>;
        rewardsWithdrawn(overrides?: CallOverrides): Promise<[BigNumber]>;
        setDepositTokenAddress(_token: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setRewardAddress(_rewardsAddress: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setRewardTokenAddress(_token: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        totalRewardsDistributed(overrides?: CallOverrides): Promise<[BigNumber]>;
        unpause(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        unstakingPeriod(overrides?: CallOverrides): Promise<[BigNumber]>;
        version(overrides?: CallOverrides): Promise<[string]>;
        withdrawRewards(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
    currentTotalStake(overrides?: CallOverrides): Promise<BigNumber>;
    deposit(amount: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    distributeRewards(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    executeWithdrawal(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<string>;
    getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<string>;
    getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
    getStakeDetails(account: string, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        initialDeposit: BigNumber;
        startDate: BigNumber;
        endDate: BigNumber;
        rewards: BigNumber;
    }>;
    grantRole(role: BytesLike, account: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<boolean>;
    initialize(_lpToken: string, _rewardToken: string, _rewardsAddress: string, _maxStakingAmount: BigNumberish, _unstakingPeriod: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    initiateWithdrawal(withdrawAmount: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    lpToken(overrides?: CallOverrides): Promise<string>;
    maxStakingAmount(overrides?: CallOverrides): Promise<BigNumber>;
    pause(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    paused(overrides?: CallOverrides): Promise<boolean>;
    renounceRole(role: BytesLike, account: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    revokeRole(role: BytesLike, account: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    rewardToken(overrides?: CallOverrides): Promise<string>;
    rewardsAddress(overrides?: CallOverrides): Promise<string>;
    rewardsDistributed(overrides?: CallOverrides): Promise<BigNumber>;
    rewardsWithdrawn(overrides?: CallOverrides): Promise<BigNumber>;
    setDepositTokenAddress(_token: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setRewardAddress(_rewardsAddress: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setRewardTokenAddress(_token: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    totalRewardsDistributed(overrides?: CallOverrides): Promise<BigNumber>;
    unpause(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    unstakingPeriod(overrides?: CallOverrides): Promise<BigNumber>;
    version(overrides?: CallOverrides): Promise<string>;
    withdrawRewards(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
        currentTotalStake(overrides?: CallOverrides): Promise<BigNumber>;
        deposit(amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
        distributeRewards(overrides?: CallOverrides): Promise<void>;
        executeWithdrawal(overrides?: CallOverrides): Promise<void>;
        getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<string>;
        getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<string>;
        getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        getStakeDetails(account: string, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            initialDeposit: BigNumber;
            startDate: BigNumber;
            endDate: BigNumber;
            rewards: BigNumber;
        }>;
        grantRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<void>;
        hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<boolean>;
        initialize(_lpToken: string, _rewardToken: string, _rewardsAddress: string, _maxStakingAmount: BigNumberish, _unstakingPeriod: BigNumberish, overrides?: CallOverrides): Promise<void>;
        initiateWithdrawal(withdrawAmount: BigNumberish, overrides?: CallOverrides): Promise<void>;
        lpToken(overrides?: CallOverrides): Promise<string>;
        maxStakingAmount(overrides?: CallOverrides): Promise<BigNumber>;
        pause(overrides?: CallOverrides): Promise<void>;
        paused(overrides?: CallOverrides): Promise<boolean>;
        renounceRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<void>;
        revokeRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<void>;
        rewardToken(overrides?: CallOverrides): Promise<string>;
        rewardsAddress(overrides?: CallOverrides): Promise<string>;
        rewardsDistributed(overrides?: CallOverrides): Promise<BigNumber>;
        rewardsWithdrawn(overrides?: CallOverrides): Promise<BigNumber>;
        setDepositTokenAddress(_token: string, overrides?: CallOverrides): Promise<void>;
        setRewardAddress(_rewardsAddress: string, overrides?: CallOverrides): Promise<void>;
        setRewardTokenAddress(_token: string, overrides?: CallOverrides): Promise<void>;
        totalRewardsDistributed(overrides?: CallOverrides): Promise<BigNumber>;
        unpause(overrides?: CallOverrides): Promise<void>;
        unstakingPeriod(overrides?: CallOverrides): Promise<BigNumber>;
        version(overrides?: CallOverrides): Promise<string>;
        withdrawRewards(overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "Paused(address)"(account?: null): PausedEventFilter;
        Paused(account?: null): PausedEventFilter;
        "RewardsDistributed(uint256)"(amount?: null): RewardsDistributedEventFilter;
        RewardsDistributed(amount?: null): RewardsDistributedEventFilter;
        "RewardsWithdrawn(address,uint256)"(account?: string | null, reward?: null): RewardsWithdrawnEventFilter;
        RewardsWithdrawn(account?: string | null, reward?: null): RewardsWithdrawnEventFilter;
        "RoleGranted(bytes32,address,address)"(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleGrantedEventFilter;
        RoleGranted(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleGrantedEventFilter;
        "RoleRevoked(bytes32,address,address)"(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleRevokedEventFilter;
        RoleRevoked(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleRevokedEventFilter;
        "StakeDeposited(address,uint256)"(account?: string | null, amount?: null): StakeDepositedEventFilter;
        StakeDeposited(account?: string | null, amount?: null): StakeDepositedEventFilter;
        "Unpaused(address)"(account?: null): UnpausedEventFilter;
        Unpaused(account?: null): UnpausedEventFilter;
        "WithdrawExecuted(address,uint256,uint256)"(account?: string | null, amount?: null, reward?: null): WithdrawExecutedEventFilter;
        WithdrawExecuted(account?: string | null, amount?: null, reward?: null): WithdrawExecutedEventFilter;
        "WithdrawInitiated(address,uint256,uint256)"(account?: string | null, amount?: null, initiateDate?: null): WithdrawInitiatedEventFilter;
        WithdrawInitiated(account?: string | null, amount?: null, initiateDate?: null): WithdrawInitiatedEventFilter;
    };
    estimateGas: {
        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
        currentTotalStake(overrides?: CallOverrides): Promise<BigNumber>;
        deposit(amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        distributeRewards(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        executeWithdrawal(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        getStakeDetails(account: string, overrides?: CallOverrides): Promise<BigNumber>;
        grantRole(role: BytesLike, account: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<BigNumber>;
        initialize(_lpToken: string, _rewardToken: string, _rewardsAddress: string, _maxStakingAmount: BigNumberish, _unstakingPeriod: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        initiateWithdrawal(withdrawAmount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        lpToken(overrides?: CallOverrides): Promise<BigNumber>;
        maxStakingAmount(overrides?: CallOverrides): Promise<BigNumber>;
        pause(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        paused(overrides?: CallOverrides): Promise<BigNumber>;
        renounceRole(role: BytesLike, account: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        revokeRole(role: BytesLike, account: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        rewardToken(overrides?: CallOverrides): Promise<BigNumber>;
        rewardsAddress(overrides?: CallOverrides): Promise<BigNumber>;
        rewardsDistributed(overrides?: CallOverrides): Promise<BigNumber>;
        rewardsWithdrawn(overrides?: CallOverrides): Promise<BigNumber>;
        setDepositTokenAddress(_token: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setRewardAddress(_rewardsAddress: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setRewardTokenAddress(_token: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        totalRewardsDistributed(overrides?: CallOverrides): Promise<BigNumber>;
        unpause(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        unstakingPeriod(overrides?: CallOverrides): Promise<BigNumber>;
        version(overrides?: CallOverrides): Promise<BigNumber>;
        withdrawRewards(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        currentTotalStake(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        deposit(amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        distributeRewards(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        executeWithdrawal(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakeDetails(account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        grantRole(role: BytesLike, account: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        initialize(_lpToken: string, _rewardToken: string, _rewardsAddress: string, _maxStakingAmount: BigNumberish, _unstakingPeriod: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        initiateWithdrawal(withdrawAmount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        lpToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        maxStakingAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pause(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        paused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        renounceRole(role: BytesLike, account: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        revokeRole(role: BytesLike, account: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        rewardToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardsAddress(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardsDistributed(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardsWithdrawn(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        setDepositTokenAddress(_token: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setRewardAddress(_rewardsAddress: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setRewardTokenAddress(_token: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        totalRewardsDistributed(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        unpause(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        unstakingPeriod(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        version(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        withdrawRewards(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}