@collabland/staking-contracts/dist/types/RailgunGovernance.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 Staking {
    type AccountSnapshotStruct = {
        interval: BigNumberish;
        votingPower: BigNumberish;
    };
    type AccountSnapshotStructOutput = [BigNumber, BigNumber] & {
        interval: BigNumber;
        votingPower: BigNumber;
    };
    type GlobalsSnapshotStruct = {
        interval: BigNumberish;
        totalVotingPower: BigNumberish;
        totalStaked: BigNumberish;
    };
    type GlobalsSnapshotStructOutput = [
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        interval: BigNumber;
        totalVotingPower: BigNumber;
        totalStaked: BigNumber;
    };
}
export interface RailgunGovernanceInterface extends utils.Interface {
    functions: {
        "DEPLOY_TIME()": FunctionFragment;
        "SNAPSHOT_INTERVAL()": FunctionFragment;
        "STAKE_LOCKTIME()": FunctionFragment;
        "accountSnapshot(address,uint256)": FunctionFragment;
        "accountSnapshotAt(address,uint256,uint256)": FunctionFragment;
        "accountSnapshotLength(address)": FunctionFragment;
        "claim(uint256)": FunctionFragment;
        "currentInterval()": FunctionFragment;
        "delegate(uint256,address)": FunctionFragment;
        "globalsSnapshot(uint256)": FunctionFragment;
        "globalsSnapshotAt(uint256,uint256)": FunctionFragment;
        "globalsSnapshotLength()": FunctionFragment;
        "intervalAtTime(uint256)": FunctionFragment;
        "latestAccountSnapshotInterval(address)": FunctionFragment;
        "latestGlobalsSnapshotInterval()": FunctionFragment;
        "stake(uint256)": FunctionFragment;
        "stakes(address,uint256)": FunctionFragment;
        "stakesLength(address)": FunctionFragment;
        "stakingToken()": FunctionFragment;
        "totalStaked()": FunctionFragment;
        "totalVotingPower()": FunctionFragment;
        "undelegate(uint256)": FunctionFragment;
        "unlock(uint256)": FunctionFragment;
        "votingPower(address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "DEPLOY_TIME" | "SNAPSHOT_INTERVAL" | "STAKE_LOCKTIME" | "accountSnapshot" | "accountSnapshotAt" | "accountSnapshotLength" | "claim" | "currentInterval" | "delegate" | "globalsSnapshot" | "globalsSnapshotAt" | "globalsSnapshotLength" | "intervalAtTime" | "latestAccountSnapshotInterval" | "latestGlobalsSnapshotInterval" | "stake" | "stakes" | "stakesLength" | "stakingToken" | "totalStaked" | "totalVotingPower" | "undelegate" | "unlock" | "votingPower"): FunctionFragment;
    encodeFunctionData(functionFragment: "DEPLOY_TIME", values?: undefined): string;
    encodeFunctionData(functionFragment: "SNAPSHOT_INTERVAL", values?: undefined): string;
    encodeFunctionData(functionFragment: "STAKE_LOCKTIME", values?: undefined): string;
    encodeFunctionData(functionFragment: "accountSnapshot", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "accountSnapshotAt", values: [string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "accountSnapshotLength", values: [string]): string;
    encodeFunctionData(functionFragment: "claim", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "currentInterval", values?: undefined): string;
    encodeFunctionData(functionFragment: "delegate", values: [BigNumberish, string]): string;
    encodeFunctionData(functionFragment: "globalsSnapshot", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "globalsSnapshotAt", values: [BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "globalsSnapshotLength", values?: undefined): string;
    encodeFunctionData(functionFragment: "intervalAtTime", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "latestAccountSnapshotInterval", values: [string]): string;
    encodeFunctionData(functionFragment: "latestGlobalsSnapshotInterval", values?: undefined): string;
    encodeFunctionData(functionFragment: "stake", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "stakes", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "stakesLength", values: [string]): string;
    encodeFunctionData(functionFragment: "stakingToken", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalStaked", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalVotingPower", values?: undefined): string;
    encodeFunctionData(functionFragment: "undelegate", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "unlock", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "votingPower", values: [string]): string;
    decodeFunctionResult(functionFragment: "DEPLOY_TIME", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "SNAPSHOT_INTERVAL", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "STAKE_LOCKTIME", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "accountSnapshot", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "accountSnapshotAt", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "accountSnapshotLength", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "currentInterval", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "delegate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "globalsSnapshot", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "globalsSnapshotAt", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "globalsSnapshotLength", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "intervalAtTime", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "latestAccountSnapshotInterval", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "latestGlobalsSnapshotInterval", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakes", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakesLength", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakingToken", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalStaked", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalVotingPower", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "undelegate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unlock", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "votingPower", data: BytesLike): Result;
    events: {
        "Claim(address,uint256)": EventFragment;
        "Delegate(address,address,address,uint256,uint256)": EventFragment;
        "Stake(address,uint256,uint256)": EventFragment;
        "Unlock(address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Claim"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Delegate"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Unlock"): EventFragment;
}
export interface ClaimEventObject {
    account: string;
    stakeID: BigNumber;
}
export type ClaimEvent = TypedEvent<[string, BigNumber], ClaimEventObject>;
export type ClaimEventFilter = TypedEventFilter<ClaimEvent>;
export interface DelegateEventObject {
    owner: string;
    _from: string;
    to: string;
    stakeID: BigNumber;
    amount: BigNumber;
}
export type DelegateEvent = TypedEvent<[
    string,
    string,
    string,
    BigNumber,
    BigNumber
], DelegateEventObject>;
export type DelegateEventFilter = TypedEventFilter<DelegateEvent>;
export interface StakeEventObject {
    account: string;
    stakeID: BigNumber;
    amount: BigNumber;
}
export type StakeEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], StakeEventObject>;
export type StakeEventFilter = TypedEventFilter<StakeEvent>;
export interface UnlockEventObject {
    account: string;
    stakeID: BigNumber;
}
export type UnlockEvent = TypedEvent<[string, BigNumber], UnlockEventObject>;
export type UnlockEventFilter = TypedEventFilter<UnlockEvent>;
export interface RailgunGovernance extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: RailgunGovernanceInterface;
    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: {
        DEPLOY_TIME(overrides?: CallOverrides): Promise<[BigNumber]>;
        SNAPSHOT_INTERVAL(overrides?: CallOverrides): Promise<[BigNumber]>;
        STAKE_LOCKTIME(overrides?: CallOverrides): Promise<[BigNumber]>;
        accountSnapshot(_account: string, _index: BigNumberish, overrides?: CallOverrides): Promise<[Staking.AccountSnapshotStructOutput]>;
        accountSnapshotAt(_account: string, _interval: BigNumberish, _hint: BigNumberish, overrides?: CallOverrides): Promise<[Staking.AccountSnapshotStructOutput]>;
        accountSnapshotLength(_account: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        claim(_stakeID: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        currentInterval(overrides?: CallOverrides): Promise<[BigNumber]>;
        delegate(_stakeID: BigNumberish, _to: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        globalsSnapshot(_index: BigNumberish, overrides?: CallOverrides): Promise<[Staking.GlobalsSnapshotStructOutput]>;
        globalsSnapshotAt(_interval: BigNumberish, _hint: BigNumberish, overrides?: CallOverrides): Promise<[Staking.GlobalsSnapshotStructOutput]>;
        globalsSnapshotLength(overrides?: CallOverrides): Promise<[BigNumber]>;
        intervalAtTime(_time: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
        latestAccountSnapshotInterval(_account: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        latestGlobalsSnapshotInterval(overrides?: CallOverrides): Promise<[BigNumber]>;
        stake(_amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        stakes(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<[
            string,
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            delegate: string;
            amount: BigNumber;
            staketime: BigNumber;
            locktime: BigNumber;
            claimedTime: BigNumber;
        }>;
        stakesLength(_account: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        stakingToken(overrides?: CallOverrides): Promise<[string]>;
        totalStaked(overrides?: CallOverrides): Promise<[BigNumber]>;
        totalVotingPower(overrides?: CallOverrides): Promise<[BigNumber]>;
        undelegate(_stakeID: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        unlock(_stakeID: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        votingPower(arg0: string, overrides?: CallOverrides): Promise<[BigNumber]>;
    };
    DEPLOY_TIME(overrides?: CallOverrides): Promise<BigNumber>;
    SNAPSHOT_INTERVAL(overrides?: CallOverrides): Promise<BigNumber>;
    STAKE_LOCKTIME(overrides?: CallOverrides): Promise<BigNumber>;
    accountSnapshot(_account: string, _index: BigNumberish, overrides?: CallOverrides): Promise<Staking.AccountSnapshotStructOutput>;
    accountSnapshotAt(_account: string, _interval: BigNumberish, _hint: BigNumberish, overrides?: CallOverrides): Promise<Staking.AccountSnapshotStructOutput>;
    accountSnapshotLength(_account: string, overrides?: CallOverrides): Promise<BigNumber>;
    claim(_stakeID: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    currentInterval(overrides?: CallOverrides): Promise<BigNumber>;
    delegate(_stakeID: BigNumberish, _to: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    globalsSnapshot(_index: BigNumberish, overrides?: CallOverrides): Promise<Staking.GlobalsSnapshotStructOutput>;
    globalsSnapshotAt(_interval: BigNumberish, _hint: BigNumberish, overrides?: CallOverrides): Promise<Staking.GlobalsSnapshotStructOutput>;
    globalsSnapshotLength(overrides?: CallOverrides): Promise<BigNumber>;
    intervalAtTime(_time: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    latestAccountSnapshotInterval(_account: string, overrides?: CallOverrides): Promise<BigNumber>;
    latestGlobalsSnapshotInterval(overrides?: CallOverrides): Promise<BigNumber>;
    stake(_amount: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    stakes(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<[
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        delegate: string;
        amount: BigNumber;
        staketime: BigNumber;
        locktime: BigNumber;
        claimedTime: BigNumber;
    }>;
    stakesLength(_account: string, overrides?: CallOverrides): Promise<BigNumber>;
    stakingToken(overrides?: CallOverrides): Promise<string>;
    totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
    totalVotingPower(overrides?: CallOverrides): Promise<BigNumber>;
    undelegate(_stakeID: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    unlock(_stakeID: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    votingPower(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    callStatic: {
        DEPLOY_TIME(overrides?: CallOverrides): Promise<BigNumber>;
        SNAPSHOT_INTERVAL(overrides?: CallOverrides): Promise<BigNumber>;
        STAKE_LOCKTIME(overrides?: CallOverrides): Promise<BigNumber>;
        accountSnapshot(_account: string, _index: BigNumberish, overrides?: CallOverrides): Promise<Staking.AccountSnapshotStructOutput>;
        accountSnapshotAt(_account: string, _interval: BigNumberish, _hint: BigNumberish, overrides?: CallOverrides): Promise<Staking.AccountSnapshotStructOutput>;
        accountSnapshotLength(_account: string, overrides?: CallOverrides): Promise<BigNumber>;
        claim(_stakeID: BigNumberish, overrides?: CallOverrides): Promise<void>;
        currentInterval(overrides?: CallOverrides): Promise<BigNumber>;
        delegate(_stakeID: BigNumberish, _to: string, overrides?: CallOverrides): Promise<void>;
        globalsSnapshot(_index: BigNumberish, overrides?: CallOverrides): Promise<Staking.GlobalsSnapshotStructOutput>;
        globalsSnapshotAt(_interval: BigNumberish, _hint: BigNumberish, overrides?: CallOverrides): Promise<Staking.GlobalsSnapshotStructOutput>;
        globalsSnapshotLength(overrides?: CallOverrides): Promise<BigNumber>;
        intervalAtTime(_time: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        latestAccountSnapshotInterval(_account: string, overrides?: CallOverrides): Promise<BigNumber>;
        latestGlobalsSnapshotInterval(overrides?: CallOverrides): Promise<BigNumber>;
        stake(_amount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        stakes(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<[
            string,
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            delegate: string;
            amount: BigNumber;
            staketime: BigNumber;
            locktime: BigNumber;
            claimedTime: BigNumber;
        }>;
        stakesLength(_account: string, overrides?: CallOverrides): Promise<BigNumber>;
        stakingToken(overrides?: CallOverrides): Promise<string>;
        totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
        totalVotingPower(overrides?: CallOverrides): Promise<BigNumber>;
        undelegate(_stakeID: BigNumberish, overrides?: CallOverrides): Promise<void>;
        unlock(_stakeID: BigNumberish, overrides?: CallOverrides): Promise<void>;
        votingPower(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    };
    filters: {
        "Claim(address,uint256)"(account?: string | null, stakeID?: BigNumberish | null): ClaimEventFilter;
        Claim(account?: string | null, stakeID?: BigNumberish | null): ClaimEventFilter;
        "Delegate(address,address,address,uint256,uint256)"(owner?: string | null, _from?: string | null, to?: string | null, stakeID?: null, amount?: null): DelegateEventFilter;
        Delegate(owner?: string | null, _from?: string | null, to?: string | null, stakeID?: null, amount?: null): DelegateEventFilter;
        "Stake(address,uint256,uint256)"(account?: string | null, stakeID?: BigNumberish | null, amount?: null): StakeEventFilter;
        Stake(account?: string | null, stakeID?: BigNumberish | null, amount?: null): StakeEventFilter;
        "Unlock(address,uint256)"(account?: string | null, stakeID?: BigNumberish | null): UnlockEventFilter;
        Unlock(account?: string | null, stakeID?: BigNumberish | null): UnlockEventFilter;
    };
    estimateGas: {
        DEPLOY_TIME(overrides?: CallOverrides): Promise<BigNumber>;
        SNAPSHOT_INTERVAL(overrides?: CallOverrides): Promise<BigNumber>;
        STAKE_LOCKTIME(overrides?: CallOverrides): Promise<BigNumber>;
        accountSnapshot(_account: string, _index: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        accountSnapshotAt(_account: string, _interval: BigNumberish, _hint: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        accountSnapshotLength(_account: string, overrides?: CallOverrides): Promise<BigNumber>;
        claim(_stakeID: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        currentInterval(overrides?: CallOverrides): Promise<BigNumber>;
        delegate(_stakeID: BigNumberish, _to: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        globalsSnapshot(_index: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        globalsSnapshotAt(_interval: BigNumberish, _hint: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        globalsSnapshotLength(overrides?: CallOverrides): Promise<BigNumber>;
        intervalAtTime(_time: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        latestAccountSnapshotInterval(_account: string, overrides?: CallOverrides): Promise<BigNumber>;
        latestGlobalsSnapshotInterval(overrides?: CallOverrides): Promise<BigNumber>;
        stake(_amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        stakes(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        stakesLength(_account: string, overrides?: CallOverrides): Promise<BigNumber>;
        stakingToken(overrides?: CallOverrides): Promise<BigNumber>;
        totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
        totalVotingPower(overrides?: CallOverrides): Promise<BigNumber>;
        undelegate(_stakeID: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        unlock(_stakeID: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        votingPower(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        DEPLOY_TIME(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        SNAPSHOT_INTERVAL(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        STAKE_LOCKTIME(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        accountSnapshot(_account: string, _index: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        accountSnapshotAt(_account: string, _interval: BigNumberish, _hint: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        accountSnapshotLength(_account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        claim(_stakeID: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        currentInterval(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        delegate(_stakeID: BigNumberish, _to: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        globalsSnapshot(_index: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        globalsSnapshotAt(_interval: BigNumberish, _hint: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        globalsSnapshotLength(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        intervalAtTime(_time: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        latestAccountSnapshotInterval(_account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        latestGlobalsSnapshotInterval(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        stake(_amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        stakes(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        stakesLength(_account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        stakingToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalStaked(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalVotingPower(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        undelegate(_stakeID: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        unlock(_stakeID: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        votingPower(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}