@orionprotocol/contracts/lib/ethers-v5/StakingReward.d.ts

Orion Protocol contracts typings

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 declare namespace ITWBalance {
    type TWItemStruct = {
        timestamp: PromiseOrValue<BigNumberish>;
        amountTW: PromiseOrValue<BigNumberish>;
    };
    type TWItemStructOutput = [number, BigNumber] & {
        timestamp: number;
        amountTW: BigNumber;
    };
}
export interface StakingRewardInterface extends utils.Interface {
    functions: {
        "MAX_BOOSTED_REWARD()": FunctionFragment;
        "MAX_LOCK_MULTIPLIER()": FunctionFragment;
        "MAX_VEORN_MULTIPLIER()": FunctionFragment;
        "allStake()": FunctionFragment;
        "calcNewRate()": FunctionFragment;
        "claimReward(address)": FunctionFragment;
        "getBoost(address)": FunctionFragment;
        "getReward(address)": FunctionFragment;
        "getRewardCumulative(address)": FunctionFragment;
        "getRewardCumulativeAll()": FunctionFragment;
        "getRewardWithdraw(address)": FunctionFragment;
        "getStake(address)": FunctionFragment;
        "init(address)": FunctionFragment;
        "lockTimePeriod(address)": FunctionFragment;
        "lockTimeStart(address)": FunctionFragment;
        "parentSmart()": FunctionFragment;
        "poolStake(address)": FunctionFragment;
        "poolTimeStake(address)": FunctionFragment;
        "rateCumulative()": FunctionFragment;
        "rateTime()": FunctionFragment;
        "rewardRate()": FunctionFragment;
        "smartVote()": FunctionFragment;
        "stake(address,uint256,uint256)": FunctionFragment;
        "tokenStake()": FunctionFragment;
        "usedRewardForRate()": FunctionFragment;
        "veORN()": FunctionFragment;
        "withdraw(address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "MAX_BOOSTED_REWARD" | "MAX_LOCK_MULTIPLIER" | "MAX_VEORN_MULTIPLIER" | "allStake" | "calcNewRate" | "claimReward" | "getBoost" | "getReward" | "getRewardCumulative" | "getRewardCumulativeAll" | "getRewardWithdraw" | "getStake" | "init" | "lockTimePeriod" | "lockTimeStart" | "parentSmart" | "poolStake" | "poolTimeStake" | "rateCumulative" | "rateTime" | "rewardRate" | "smartVote" | "stake" | "tokenStake" | "usedRewardForRate" | "veORN" | "withdraw"): FunctionFragment;
    encodeFunctionData(functionFragment: "MAX_BOOSTED_REWARD", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_LOCK_MULTIPLIER", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_VEORN_MULTIPLIER", values?: undefined): string;
    encodeFunctionData(functionFragment: "allStake", values?: undefined): string;
    encodeFunctionData(functionFragment: "calcNewRate", values?: undefined): string;
    encodeFunctionData(functionFragment: "claimReward", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getBoost", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getReward", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getRewardCumulative", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getRewardCumulativeAll", values?: undefined): string;
    encodeFunctionData(functionFragment: "getRewardWithdraw", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getStake", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "init", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "lockTimePeriod", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "lockTimeStart", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "parentSmart", values?: undefined): string;
    encodeFunctionData(functionFragment: "poolStake", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "poolTimeStake", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "rateCumulative", values?: undefined): string;
    encodeFunctionData(functionFragment: "rateTime", values?: undefined): string;
    encodeFunctionData(functionFragment: "rewardRate", values?: undefined): string;
    encodeFunctionData(functionFragment: "smartVote", values?: undefined): string;
    encodeFunctionData(functionFragment: "stake", values: [
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "tokenStake", values?: undefined): string;
    encodeFunctionData(functionFragment: "usedRewardForRate", values?: undefined): string;
    encodeFunctionData(functionFragment: "veORN", values?: undefined): string;
    encodeFunctionData(functionFragment: "withdraw", values: [PromiseOrValue<string>]): string;
    decodeFunctionResult(functionFragment: "MAX_BOOSTED_REWARD", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_LOCK_MULTIPLIER", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_VEORN_MULTIPLIER", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "allStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calcNewRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claimReward", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getBoost", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getReward", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRewardCumulative", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRewardCumulativeAll", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRewardWithdraw", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "init", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockTimePeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockTimeStart", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "parentSmart", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "poolStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "poolTimeStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rateCumulative", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rateTime", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rewardRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "smartVote", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "tokenStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "usedRewardForRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "veORN", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
    events: {
        "ClaimReward(address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
        "ClaimReward2(address,uint256,uint256,uint256)": EventFragment;
        "Deposit(address,uint256,uint256,uint256)": EventFragment;
        "SetRewards(uint64,uint64,uint256,uint256,uint256)": EventFragment;
        "Stake(address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
        "Unstake(address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
        "Withdraw(address,uint256,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "ClaimReward"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ClaimReward2"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetRewards"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Unstake"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
}
export interface ClaimRewardEventObject {
    account: string;
    amount: BigNumber;
    rewardCumulativeTotal: BigNumber;
    rateCumulative: BigNumber;
    reward: BigNumber;
    timestamp: BigNumber;
}
export type ClaimRewardEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], ClaimRewardEventObject>;
export type ClaimRewardEventFilter = TypedEventFilter<ClaimRewardEvent>;
export interface ClaimReward2EventObject {
    provider: string;
    value: BigNumber;
    originValue: BigNumber;
    ts: BigNumber;
}
export type ClaimReward2Event = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    BigNumber
], ClaimReward2EventObject>;
export type ClaimReward2EventFilter = TypedEventFilter<ClaimReward2Event>;
export interface DepositEventObject {
    provider: string;
    value: BigNumber;
    lock_period: BigNumber;
    ts: BigNumber;
}
export type DepositEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    BigNumber
], DepositEventObject>;
export type DepositEventFilter = TypedEventFilter<DepositEvent>;
export interface SetRewardsEventObject {
    rewards: BigNumber;
    duration: BigNumber;
    rewardCumulativeTotal: BigNumber;
    rateCumulative: BigNumber;
    timestamp: BigNumber;
}
export type SetRewardsEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], SetRewardsEventObject>;
export type SetRewardsEventFilter = TypedEventFilter<SetRewardsEvent>;
export interface StakeEventObject {
    account: string;
    amount: BigNumber;
    rewardCumulativeTotal: BigNumber;
    rateCumulative: BigNumber;
    reward: BigNumber;
    timestamp: BigNumber;
}
export type StakeEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], StakeEventObject>;
export type StakeEventFilter = TypedEventFilter<StakeEvent>;
export interface UnstakeEventObject {
    account: string;
    amount: BigNumber;
    rewardCumulativeTotal: BigNumber;
    rateCumulative: BigNumber;
    reward: BigNumber;
    timestamp: BigNumber;
}
export type UnstakeEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], UnstakeEventObject>;
export type UnstakeEventFilter = TypedEventFilter<UnstakeEvent>;
export interface WithdrawEventObject {
    provider: string;
    value: BigNumber;
    ts: BigNumber;
}
export type WithdrawEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], WithdrawEventObject>;
export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
export interface StakingReward extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: StakingRewardInterface;
    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: {
        MAX_BOOSTED_REWARD(overrides?: CallOverrides): Promise<[BigNumber]>;
        MAX_LOCK_MULTIPLIER(overrides?: CallOverrides): Promise<[BigNumber]>;
        MAX_VEORN_MULTIPLIER(overrides?: CallOverrides): Promise<[BigNumber]>;
        allStake(overrides?: CallOverrides): Promise<[BigNumber]>;
        calcNewRate(overrides?: CallOverrides): Promise<[BigNumber]>;
        claimReward(account: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        getBoost(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        getReward(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        getRewardCumulative(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        getRewardCumulativeAll(overrides?: CallOverrides): Promise<[BigNumber]>;
        getRewardWithdraw(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        getStake(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        init(_token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        lockTimePeriod(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[number]>;
        lockTimeStart(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[number]>;
        parentSmart(overrides?: CallOverrides): Promise<[string]>;
        poolStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            stake: BigNumber;
            rateCumulative: BigNumber;
            reward: BigNumber;
            rewardWithdraw: BigNumber;
        }>;
        poolTimeStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            number,
            number,
            boolean,
            ITWBalance.TWItemStructOutput,
            ITWBalance.TWItemStructOutput
        ] & {
            lock_start: number;
            lock_period: number;
            staking: boolean;
            balanceTW: ITWBalance.TWItemStructOutput;
            totalTW: ITWBalance.TWItemStructOutput;
        }>;
        rateCumulative(overrides?: CallOverrides): Promise<[BigNumber]>;
        rateTime(overrides?: CallOverrides): Promise<[BigNumber]>;
        rewardRate(overrides?: CallOverrides): Promise<[BigNumber]>;
        smartVote(overrides?: CallOverrides): Promise<[string]>;
        stake(account: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, lock_period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        tokenStake(overrides?: CallOverrides): Promise<[string]>;
        usedRewardForRate(overrides?: CallOverrides): Promise<[BigNumber]>;
        veORN(overrides?: CallOverrides): Promise<[string]>;
        withdraw(account: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
    };
    MAX_BOOSTED_REWARD(overrides?: CallOverrides): Promise<BigNumber>;
    MAX_LOCK_MULTIPLIER(overrides?: CallOverrides): Promise<BigNumber>;
    MAX_VEORN_MULTIPLIER(overrides?: CallOverrides): Promise<BigNumber>;
    allStake(overrides?: CallOverrides): Promise<BigNumber>;
    calcNewRate(overrides?: CallOverrides): Promise<BigNumber>;
    claimReward(account: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    getBoost(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    getReward(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    getRewardCumulative(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    getRewardCumulativeAll(overrides?: CallOverrides): Promise<BigNumber>;
    getRewardWithdraw(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    getStake(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    init(_token: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    lockTimePeriod(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
    lockTimeStart(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
    parentSmart(overrides?: CallOverrides): Promise<string>;
    poolStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        stake: BigNumber;
        rateCumulative: BigNumber;
        reward: BigNumber;
        rewardWithdraw: BigNumber;
    }>;
    poolTimeStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        number,
        number,
        boolean,
        ITWBalance.TWItemStructOutput,
        ITWBalance.TWItemStructOutput
    ] & {
        lock_start: number;
        lock_period: number;
        staking: boolean;
        balanceTW: ITWBalance.TWItemStructOutput;
        totalTW: ITWBalance.TWItemStructOutput;
    }>;
    rateCumulative(overrides?: CallOverrides): Promise<BigNumber>;
    rateTime(overrides?: CallOverrides): Promise<BigNumber>;
    rewardRate(overrides?: CallOverrides): Promise<BigNumber>;
    smartVote(overrides?: CallOverrides): Promise<string>;
    stake(account: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, lock_period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    tokenStake(overrides?: CallOverrides): Promise<string>;
    usedRewardForRate(overrides?: CallOverrides): Promise<BigNumber>;
    veORN(overrides?: CallOverrides): Promise<string>;
    withdraw(account: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        MAX_BOOSTED_REWARD(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_LOCK_MULTIPLIER(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_VEORN_MULTIPLIER(overrides?: CallOverrides): Promise<BigNumber>;
        allStake(overrides?: CallOverrides): Promise<BigNumber>;
        calcNewRate(overrides?: CallOverrides): Promise<BigNumber>;
        claimReward(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getBoost(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getReward(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getRewardCumulative(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getRewardCumulativeAll(overrides?: CallOverrides): Promise<BigNumber>;
        getRewardWithdraw(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getStake(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        init(_token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        lockTimePeriod(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
        lockTimeStart(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
        parentSmart(overrides?: CallOverrides): Promise<string>;
        poolStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            stake: BigNumber;
            rateCumulative: BigNumber;
            reward: BigNumber;
            rewardWithdraw: BigNumber;
        }>;
        poolTimeStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            number,
            number,
            boolean,
            ITWBalance.TWItemStructOutput,
            ITWBalance.TWItemStructOutput
        ] & {
            lock_start: number;
            lock_period: number;
            staking: boolean;
            balanceTW: ITWBalance.TWItemStructOutput;
            totalTW: ITWBalance.TWItemStructOutput;
        }>;
        rateCumulative(overrides?: CallOverrides): Promise<BigNumber>;
        rateTime(overrides?: CallOverrides): Promise<BigNumber>;
        rewardRate(overrides?: CallOverrides): Promise<BigNumber>;
        smartVote(overrides?: CallOverrides): Promise<string>;
        stake(account: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, lock_period: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        tokenStake(overrides?: CallOverrides): Promise<string>;
        usedRewardForRate(overrides?: CallOverrides): Promise<BigNumber>;
        veORN(overrides?: CallOverrides): Promise<string>;
        withdraw(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            reward: BigNumber;
            amount: BigNumber;
        }>;
    };
    filters: {
        "ClaimReward(address,uint256,uint256,uint256,uint256,uint256)"(account?: PromiseOrValue<string> | null, amount?: null, rewardCumulativeTotal?: null, rateCumulative?: null, reward?: null, timestamp?: null): ClaimRewardEventFilter;
        ClaimReward(account?: PromiseOrValue<string> | null, amount?: null, rewardCumulativeTotal?: null, rateCumulative?: null, reward?: null, timestamp?: null): ClaimRewardEventFilter;
        "ClaimReward2(address,uint256,uint256,uint256)"(provider?: PromiseOrValue<string> | null, value?: null, originValue?: null, ts?: null): ClaimReward2EventFilter;
        ClaimReward2(provider?: PromiseOrValue<string> | null, value?: null, originValue?: null, ts?: null): ClaimReward2EventFilter;
        "Deposit(address,uint256,uint256,uint256)"(provider?: PromiseOrValue<string> | null, value?: null, lock_period?: PromiseOrValue<BigNumberish> | null, ts?: null): DepositEventFilter;
        Deposit(provider?: PromiseOrValue<string> | null, value?: null, lock_period?: PromiseOrValue<BigNumberish> | null, ts?: null): DepositEventFilter;
        "SetRewards(uint64,uint64,uint256,uint256,uint256)"(rewards?: null, duration?: null, rewardCumulativeTotal?: null, rateCumulative?: null, timestamp?: null): SetRewardsEventFilter;
        SetRewards(rewards?: null, duration?: null, rewardCumulativeTotal?: null, rateCumulative?: null, timestamp?: null): SetRewardsEventFilter;
        "Stake(address,uint256,uint256,uint256,uint256,uint256)"(account?: PromiseOrValue<string> | null, amount?: null, rewardCumulativeTotal?: null, rateCumulative?: null, reward?: null, timestamp?: null): StakeEventFilter;
        Stake(account?: PromiseOrValue<string> | null, amount?: null, rewardCumulativeTotal?: null, rateCumulative?: null, reward?: null, timestamp?: null): StakeEventFilter;
        "Unstake(address,uint256,uint256,uint256,uint256,uint256)"(account?: PromiseOrValue<string> | null, amount?: null, rewardCumulativeTotal?: null, rateCumulative?: null, reward?: null, timestamp?: null): UnstakeEventFilter;
        Unstake(account?: PromiseOrValue<string> | null, amount?: null, rewardCumulativeTotal?: null, rateCumulative?: null, reward?: null, timestamp?: null): UnstakeEventFilter;
        "Withdraw(address,uint256,uint256)"(provider?: PromiseOrValue<string> | null, value?: null, ts?: null): WithdrawEventFilter;
        Withdraw(provider?: PromiseOrValue<string> | null, value?: null, ts?: null): WithdrawEventFilter;
    };
    estimateGas: {
        MAX_BOOSTED_REWARD(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_LOCK_MULTIPLIER(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_VEORN_MULTIPLIER(overrides?: CallOverrides): Promise<BigNumber>;
        allStake(overrides?: CallOverrides): Promise<BigNumber>;
        calcNewRate(overrides?: CallOverrides): Promise<BigNumber>;
        claimReward(account: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        getBoost(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getReward(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getRewardCumulative(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getRewardCumulativeAll(overrides?: CallOverrides): Promise<BigNumber>;
        getRewardWithdraw(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getStake(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        init(_token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        lockTimePeriod(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        lockTimeStart(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        parentSmart(overrides?: CallOverrides): Promise<BigNumber>;
        poolStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        poolTimeStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        rateCumulative(overrides?: CallOverrides): Promise<BigNumber>;
        rateTime(overrides?: CallOverrides): Promise<BigNumber>;
        rewardRate(overrides?: CallOverrides): Promise<BigNumber>;
        smartVote(overrides?: CallOverrides): Promise<BigNumber>;
        stake(account: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, lock_period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        tokenStake(overrides?: CallOverrides): Promise<BigNumber>;
        usedRewardForRate(overrides?: CallOverrides): Promise<BigNumber>;
        veORN(overrides?: CallOverrides): Promise<BigNumber>;
        withdraw(account: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        MAX_BOOSTED_REWARD(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_LOCK_MULTIPLIER(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_VEORN_MULTIPLIER(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        allStake(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcNewRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        claimReward(account: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        getBoost(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getReward(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRewardCumulative(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRewardCumulativeAll(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRewardWithdraw(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStake(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        init(_token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        lockTimePeriod(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lockTimeStart(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        parentSmart(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        poolStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        poolTimeStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rateCumulative(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rateTime(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        smartVote(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        stake(account: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, lock_period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        tokenStake(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        usedRewardForRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        veORN(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        withdraw(account: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
    };
}