@zkp2p/contracts-v2 0.3.0 → 0.3.1-rc.1

package/types/contracts/StakeVault.d.ts

@@ -0,0 +1,838 @@
+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 IStakeVault {
+    type ClaimStruct = {
+        beneficiary: PromiseOrValue<string>;
+        amount: PromiseOrValue<BigNumberish>;
+    };
+    type ClaimStructOutput = [string, BigNumber] & {
+        beneficiary: string;
+        amount: BigNumber;
+    };
+}
+export interface StakeVaultInterface extends utils.Interface {
+    functions: {
+        "MIN_CONTROLLER_CHANGE_DELAY()": FunctionFragment;
+        "NEVER_MATURES()": FunctionFragment;
+        "acceptController()": FunctionFragment;
+        "acceptOwnership()": FunctionFragment;
+        "authorizedTakers(address,address)": FunctionFragment;
+        "cancelControllerProposal()": FunctionFragment;
+        "claim()": FunctionFragment;
+        "claimable(address)": FunctionFragment;
+        "clearStakeOwner()": FunctionFragment;
+        "controller()": FunctionFragment;
+        "controllerChangeDelay()": FunctionFragment;
+        "depositStake(uint256)": FunctionFragment;
+        "freeStake(address)": FunctionFragment;
+        "fundLock(address,bytes32,uint256,uint64)": FunctionFragment;
+        "increaseLock(bytes32,uint256)": FunctionFragment;
+        "initializeController(address)": FunctionFragment;
+        "isLockMature(bytes32)": FunctionFragment;
+        "lockStake(address,bytes32,uint256,uint64)": FunctionFragment;
+        "lockedStake(address)": FunctionFragment;
+        "locks(bytes32)": FunctionFragment;
+        "owner()": FunctionFragment;
+        "pendingController()": FunctionFragment;
+        "pendingControllerValidAt()": FunctionFragment;
+        "pendingOwner()": FunctionFragment;
+        "proposeController(address)": FunctionFragment;
+        "renounceOwnership()": FunctionFragment;
+        "resizeLock(bytes32,uint256,uint64)": FunctionFragment;
+        "resolveLock(bytes32,(address,uint256)[])": FunctionFragment;
+        "selectStakeOwner(address)": FunctionFragment;
+        "selectedStakeOwner(address)": FunctionFragment;
+        "setTakerAuthorization(address,bool)": FunctionFragment;
+        "stakeBalance(address)": FunctionFragment;
+        "stakeOwnerOf(address)": FunctionFragment;
+        "stakeToken()": FunctionFragment;
+        "totalAccounted()": FunctionFragment;
+        "totalClaimable()": FunctionFragment;
+        "totalStaked()": FunctionFragment;
+        "transferOwnership(address)": FunctionFragment;
+        "unaccountedBalance()": FunctionFragment;
+        "unlockStake(bytes32)": FunctionFragment;
+        "withdrawStake(uint256)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "MIN_CONTROLLER_CHANGE_DELAY" | "NEVER_MATURES" | "acceptController" | "acceptOwnership" | "authorizedTakers" | "cancelControllerProposal" | "claim" | "claimable" | "clearStakeOwner" | "controller" | "controllerChangeDelay" | "depositStake" | "freeStake" | "fundLock" | "increaseLock" | "initializeController" | "isLockMature" | "lockStake" | "lockedStake" | "locks" | "owner" | "pendingController" | "pendingControllerValidAt" | "pendingOwner" | "proposeController" | "renounceOwnership" | "resizeLock" | "resolveLock" | "selectStakeOwner" | "selectedStakeOwner" | "setTakerAuthorization" | "stakeBalance" | "stakeOwnerOf" | "stakeToken" | "totalAccounted" | "totalClaimable" | "totalStaked" | "transferOwnership" | "unaccountedBalance" | "unlockStake" | "withdrawStake"): FunctionFragment;
+    encodeFunctionData(functionFragment: "MIN_CONTROLLER_CHANGE_DELAY", values?: undefined): string;
+    encodeFunctionData(functionFragment: "NEVER_MATURES", values?: undefined): string;
+    encodeFunctionData(functionFragment: "acceptController", values?: undefined): string;
+    encodeFunctionData(functionFragment: "acceptOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "authorizedTakers", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "cancelControllerProposal", values?: undefined): string;
+    encodeFunctionData(functionFragment: "claim", values?: undefined): string;
+    encodeFunctionData(functionFragment: "claimable", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "clearStakeOwner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "controller", values?: undefined): string;
+    encodeFunctionData(functionFragment: "controllerChangeDelay", values?: undefined): string;
+    encodeFunctionData(functionFragment: "depositStake", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "freeStake", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "fundLock", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "increaseLock", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "initializeController", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "isLockMature", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "lockStake", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "lockedStake", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "locks", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pendingController", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pendingControllerValidAt", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pendingOwner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "proposeController", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "resizeLock", values: [
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "resolveLock", values: [PromiseOrValue<BytesLike>, IStakeVault.ClaimStruct[]]): string;
+    encodeFunctionData(functionFragment: "selectStakeOwner", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "selectedStakeOwner", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setTakerAuthorization", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "stakeBalance", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "stakeOwnerOf", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "stakeToken", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalAccounted", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalClaimable", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalStaked", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "unaccountedBalance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "unlockStake", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "withdrawStake", values: [PromiseOrValue<BigNumberish>]): string;
+    decodeFunctionResult(functionFragment: "MIN_CONTROLLER_CHANGE_DELAY", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "NEVER_MATURES", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "acceptController", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "acceptOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "authorizedTakers", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "cancelControllerProposal", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimable", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "clearStakeOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "controller", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "controllerChangeDelay", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "freeStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "fundLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initializeController", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isLockMature", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lockStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lockedStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "locks", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pendingController", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pendingControllerValidAt", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pendingOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "proposeController", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resizeLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resolveLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "selectStakeOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "selectedStakeOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTakerAuthorization", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeOwnerOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalAccounted", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalClaimable", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalStaked", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unaccountedBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unlockStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawStake", data: BytesLike): Result;
+    events: {
+        "ClaimCreated(bytes32,address,uint256,uint256)": EventFragment;
+        "ClaimWithdrawn(address,uint256)": EventFragment;
+        "ControllerAccepted(address,address)": EventFragment;
+        "ControllerInitialized(address)": EventFragment;
+        "ControllerProposalCancelled(address)": EventFragment;
+        "ControllerProposed(address,address,uint64)": EventFragment;
+        "LockFunded(bytes32,address,uint256,uint256)": EventFragment;
+        "OwnershipTransferStarted(address,address)": EventFragment;
+        "OwnershipTransferred(address,address)": EventFragment;
+        "StakeDeposited(address,uint256,uint256)": EventFragment;
+        "StakeLockIncreased(bytes32,address,uint256,uint256,uint256)": EventFragment;
+        "StakeLockResized(bytes32,address,uint256,uint256,uint64,uint64,uint256)": EventFragment;
+        "StakeLockResolved(bytes32,address,uint256,uint256,uint256,uint256)": EventFragment;
+        "StakeLocked(bytes32,address,uint256,uint64,uint256)": EventFragment;
+        "StakeOwnerSelected(address,address,address)": EventFragment;
+        "StakeUnlocked(bytes32,address,uint256,uint256)": EventFragment;
+        "StakeWithdrawn(address,uint256,uint256)": EventFragment;
+        "TakerAuthorizationUpdated(address,address,bool)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "ClaimCreated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ClaimWithdrawn"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ControllerAccepted"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ControllerInitialized"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ControllerProposalCancelled"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ControllerProposed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "LockFunded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferStarted"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeDeposited"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeLockIncreased"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeLockResized"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeLockResolved"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeLocked"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeOwnerSelected"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeUnlocked"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeWithdrawn"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TakerAuthorizationUpdated"): EventFragment;
+}
+export interface ClaimCreatedEventObject {
+    lockId: string;
+    beneficiary: string;
+    amount: BigNumber;
+    newClaimableBalance: BigNumber;
+}
+export type ClaimCreatedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber
+], ClaimCreatedEventObject>;
+export type ClaimCreatedEventFilter = TypedEventFilter<ClaimCreatedEvent>;
+export interface ClaimWithdrawnEventObject {
+    beneficiary: string;
+    amount: BigNumber;
+}
+export type ClaimWithdrawnEvent = TypedEvent<[
+    string,
+    BigNumber
+], ClaimWithdrawnEventObject>;
+export type ClaimWithdrawnEventFilter = TypedEventFilter<ClaimWithdrawnEvent>;
+export interface ControllerAcceptedEventObject {
+    previousController: string;
+    newController: string;
+}
+export type ControllerAcceptedEvent = TypedEvent<[
+    string,
+    string
+], ControllerAcceptedEventObject>;
+export type ControllerAcceptedEventFilter = TypedEventFilter<ControllerAcceptedEvent>;
+export interface ControllerInitializedEventObject {
+    controller: string;
+}
+export type ControllerInitializedEvent = TypedEvent<[
+    string
+], ControllerInitializedEventObject>;
+export type ControllerInitializedEventFilter = TypedEventFilter<ControllerInitializedEvent>;
+export interface ControllerProposalCancelledEventObject {
+    pendingController: string;
+}
+export type ControllerProposalCancelledEvent = TypedEvent<[
+    string
+], ControllerProposalCancelledEventObject>;
+export type ControllerProposalCancelledEventFilter = TypedEventFilter<ControllerProposalCancelledEvent>;
+export interface ControllerProposedEventObject {
+    currentController: string;
+    pendingController: string;
+    validAt: BigNumber;
+}
+export type ControllerProposedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], ControllerProposedEventObject>;
+export type ControllerProposedEventFilter = TypedEventFilter<ControllerProposedEvent>;
+export interface LockFundedEventObject {
+    lockId: string;
+    stakeOwner: string;
+    amount: BigNumber;
+    newStakeBalance: BigNumber;
+}
+export type LockFundedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber
+], LockFundedEventObject>;
+export type LockFundedEventFilter = TypedEventFilter<LockFundedEvent>;
+export interface OwnershipTransferStartedEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferStartedEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferStartedEventObject>;
+export type OwnershipTransferStartedEventFilter = TypedEventFilter<OwnershipTransferStartedEvent>;
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export interface StakeDepositedEventObject {
+    stakeOwner: string;
+    amount: BigNumber;
+    newStakeBalance: BigNumber;
+}
+export type StakeDepositedEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber
+], StakeDepositedEventObject>;
+export type StakeDepositedEventFilter = TypedEventFilter<StakeDepositedEvent>;
+export interface StakeLockIncreasedEventObject {
+    lockId: string;
+    stakeOwner: string;
+    previousAmount: BigNumber;
+    newAmount: BigNumber;
+    totalLockedStake: BigNumber;
+}
+export type StakeLockIncreasedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], StakeLockIncreasedEventObject>;
+export type StakeLockIncreasedEventFilter = TypedEventFilter<StakeLockIncreasedEvent>;
+export interface StakeLockResizedEventObject {
+    lockId: string;
+    stakeOwner: string;
+    previousAmount: BigNumber;
+    newAmount: BigNumber;
+    previousMaturity: BigNumber;
+    newMaturity: BigNumber;
+    totalLockedStake: BigNumber;
+}
+export type StakeLockResizedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], StakeLockResizedEventObject>;
+export type StakeLockResizedEventFilter = TypedEventFilter<StakeLockResizedEvent>;
+export interface StakeLockResolvedEventObject {
+    lockId: string;
+    stakeOwner: string;
+    lockAmount: BigNumber;
+    unlockedAmount: BigNumber;
+    claimedAmount: BigNumber;
+    totalLockedStake: BigNumber;
+}
+export type StakeLockResolvedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], StakeLockResolvedEventObject>;
+export type StakeLockResolvedEventFilter = TypedEventFilter<StakeLockResolvedEvent>;
+export interface StakeLockedEventObject {
+    lockId: string;
+    stakeOwner: string;
+    amount: BigNumber;
+    maturesAt: BigNumber;
+    totalLockedStake: BigNumber;
+}
+export type StakeLockedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], StakeLockedEventObject>;
+export type StakeLockedEventFilter = TypedEventFilter<StakeLockedEvent>;
+export interface StakeOwnerSelectedEventObject {
+    taker: string;
+    previousStakeOwner: string;
+    newStakeOwner: string;
+}
+export type StakeOwnerSelectedEvent = TypedEvent<[
+    string,
+    string,
+    string
+], StakeOwnerSelectedEventObject>;
+export type StakeOwnerSelectedEventFilter = TypedEventFilter<StakeOwnerSelectedEvent>;
+export interface StakeUnlockedEventObject {
+    lockId: string;
+    stakeOwner: string;
+    amount: BigNumber;
+    totalLockedStake: BigNumber;
+}
+export type StakeUnlockedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber
+], StakeUnlockedEventObject>;
+export type StakeUnlockedEventFilter = TypedEventFilter<StakeUnlockedEvent>;
+export interface StakeWithdrawnEventObject {
+    stakeOwner: string;
+    amount: BigNumber;
+    newStakeBalance: BigNumber;
+}
+export type StakeWithdrawnEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber
+], StakeWithdrawnEventObject>;
+export type StakeWithdrawnEventFilter = TypedEventFilter<StakeWithdrawnEvent>;
+export interface TakerAuthorizationUpdatedEventObject {
+    stakeOwner: string;
+    taker: string;
+    authorized: boolean;
+}
+export type TakerAuthorizationUpdatedEvent = TypedEvent<[
+    string,
+    string,
+    boolean
+], TakerAuthorizationUpdatedEventObject>;
+export type TakerAuthorizationUpdatedEventFilter = TypedEventFilter<TakerAuthorizationUpdatedEvent>;
+export interface StakeVault extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: StakeVaultInterface;
+    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: {
+        MIN_CONTROLLER_CHANGE_DELAY(overrides?: CallOverrides): Promise<[BigNumber]>;
+        NEVER_MATURES(overrides?: CallOverrides): Promise<[BigNumber]>;
+        acceptController(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        acceptOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        authorizedTakers(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        cancelControllerProposal(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        claim(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        claimable(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        clearStakeOwner(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        controller(overrides?: CallOverrides): Promise<[string]>;
+        controllerChangeDelay(overrides?: CallOverrides): Promise<[BigNumber]>;
+        depositStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        freeStake(_stakeOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        fundLock(_stakeOwner: PromiseOrValue<string>, _lockId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _maturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        increaseLock(_lockId: PromiseOrValue<BytesLike>, _additionalAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        initializeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        isLockMature(_lockId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
+        lockStake(_stakeOwner: PromiseOrValue<string>, _lockId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _maturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        lockedStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        locks(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+            string,
+            BigNumber,
+            BigNumber
+        ] & {
+            stakeOwner: string;
+            amount: BigNumber;
+            maturesAt: BigNumber;
+        }>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        pendingController(overrides?: CallOverrides): Promise<[string]>;
+        pendingControllerValidAt(overrides?: CallOverrides): Promise<[BigNumber]>;
+        pendingOwner(overrides?: CallOverrides): Promise<[string]>;
+        proposeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        renounceOwnership(overrides?: CallOverrides): Promise<[void]>;
+        resizeLock(_lockId: PromiseOrValue<BytesLike>, _newAmount: PromiseOrValue<BigNumberish>, _newMaturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        resolveLock(_lockId: PromiseOrValue<BytesLike>, _claims: IStakeVault.ClaimStruct[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        selectStakeOwner(_stakeOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        selectedStakeOwner(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>;
+        setTakerAuthorization(_taker: PromiseOrValue<string>, _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        stakeBalance(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        stakeOwnerOf(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>;
+        stakeToken(overrides?: CallOverrides): Promise<[string]>;
+        totalAccounted(overrides?: CallOverrides): Promise<[BigNumber]>;
+        totalClaimable(overrides?: CallOverrides): Promise<[BigNumber]>;
+        totalStaked(overrides?: CallOverrides): Promise<[BigNumber]>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        unaccountedBalance(overrides?: CallOverrides): Promise<[BigNumber]>;
+        unlockStake(_lockId: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        withdrawStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    MIN_CONTROLLER_CHANGE_DELAY(overrides?: CallOverrides): Promise<BigNumber>;
+    NEVER_MATURES(overrides?: CallOverrides): Promise<BigNumber>;
+    acceptController(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    acceptOwnership(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    authorizedTakers(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    cancelControllerProposal(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    claim(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    claimable(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    clearStakeOwner(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    controller(overrides?: CallOverrides): Promise<string>;
+    controllerChangeDelay(overrides?: CallOverrides): Promise<BigNumber>;
+    depositStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    freeStake(_stakeOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    fundLock(_stakeOwner: PromiseOrValue<string>, _lockId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _maturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    increaseLock(_lockId: PromiseOrValue<BytesLike>, _additionalAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    initializeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    isLockMature(_lockId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    lockStake(_stakeOwner: PromiseOrValue<string>, _lockId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _maturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    lockedStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    locks(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+        string,
+        BigNumber,
+        BigNumber
+    ] & {
+        stakeOwner: string;
+        amount: BigNumber;
+        maturesAt: BigNumber;
+    }>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    pendingController(overrides?: CallOverrides): Promise<string>;
+    pendingControllerValidAt(overrides?: CallOverrides): Promise<BigNumber>;
+    pendingOwner(overrides?: CallOverrides): Promise<string>;
+    proposeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    renounceOwnership(overrides?: CallOverrides): Promise<void>;
+    resizeLock(_lockId: PromiseOrValue<BytesLike>, _newAmount: PromiseOrValue<BigNumberish>, _newMaturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    resolveLock(_lockId: PromiseOrValue<BytesLike>, _claims: IStakeVault.ClaimStruct[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    selectStakeOwner(_stakeOwner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    selectedStakeOwner(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+    setTakerAuthorization(_taker: PromiseOrValue<string>, _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    stakeBalance(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    stakeOwnerOf(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+    stakeToken(overrides?: CallOverrides): Promise<string>;
+    totalAccounted(overrides?: CallOverrides): Promise<BigNumber>;
+    totalClaimable(overrides?: CallOverrides): Promise<BigNumber>;
+    totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
+    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    unaccountedBalance(overrides?: CallOverrides): Promise<BigNumber>;
+    unlockStake(_lockId: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    withdrawStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        MIN_CONTROLLER_CHANGE_DELAY(overrides?: CallOverrides): Promise<BigNumber>;
+        NEVER_MATURES(overrides?: CallOverrides): Promise<BigNumber>;
+        acceptController(overrides?: CallOverrides): Promise<void>;
+        acceptOwnership(overrides?: CallOverrides): Promise<void>;
+        authorizedTakers(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        cancelControllerProposal(overrides?: CallOverrides): Promise<void>;
+        claim(overrides?: CallOverrides): Promise<void>;
+        claimable(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        clearStakeOwner(overrides?: CallOverrides): Promise<void>;
+        controller(overrides?: CallOverrides): Promise<string>;
+        controllerChangeDelay(overrides?: CallOverrides): Promise<BigNumber>;
+        depositStake(_amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        freeStake(_stakeOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        fundLock(_stakeOwner: PromiseOrValue<string>, _lockId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _maturesAt: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        increaseLock(_lockId: PromiseOrValue<BytesLike>, _additionalAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        initializeController(_controller: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        isLockMature(_lockId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        lockStake(_stakeOwner: PromiseOrValue<string>, _lockId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _maturesAt: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        lockedStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        locks(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+            string,
+            BigNumber,
+            BigNumber
+        ] & {
+            stakeOwner: string;
+            amount: BigNumber;
+            maturesAt: BigNumber;
+        }>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        pendingController(overrides?: CallOverrides): Promise<string>;
+        pendingControllerValidAt(overrides?: CallOverrides): Promise<BigNumber>;
+        pendingOwner(overrides?: CallOverrides): Promise<string>;
+        proposeController(_controller: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        renounceOwnership(overrides?: CallOverrides): Promise<void>;
+        resizeLock(_lockId: PromiseOrValue<BytesLike>, _newAmount: PromiseOrValue<BigNumberish>, _newMaturesAt: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        resolveLock(_lockId: PromiseOrValue<BytesLike>, _claims: IStakeVault.ClaimStruct[], overrides?: CallOverrides): Promise<void>;
+        selectStakeOwner(_stakeOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        selectedStakeOwner(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+        setTakerAuthorization(_taker: PromiseOrValue<string>, _authorized: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        stakeBalance(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        stakeOwnerOf(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+        stakeToken(overrides?: CallOverrides): Promise<string>;
+        totalAccounted(overrides?: CallOverrides): Promise<BigNumber>;
+        totalClaimable(overrides?: CallOverrides): Promise<BigNumber>;
+        totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        unaccountedBalance(overrides?: CallOverrides): Promise<BigNumber>;
+        unlockStake(_lockId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        withdrawStake(_amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "ClaimCreated(bytes32,address,uint256,uint256)"(lockId?: PromiseOrValue<BytesLike> | null, beneficiary?: PromiseOrValue<string> | null, amount?: null, newClaimableBalance?: null): ClaimCreatedEventFilter;
+        ClaimCreated(lockId?: PromiseOrValue<BytesLike> | null, beneficiary?: PromiseOrValue<string> | null, amount?: null, newClaimableBalance?: null): ClaimCreatedEventFilter;
+        "ClaimWithdrawn(address,uint256)"(beneficiary?: PromiseOrValue<string> | null, amount?: null): ClaimWithdrawnEventFilter;
+        ClaimWithdrawn(beneficiary?: PromiseOrValue<string> | null, amount?: null): ClaimWithdrawnEventFilter;
+        "ControllerAccepted(address,address)"(previousController?: PromiseOrValue<string> | null, newController?: PromiseOrValue<string> | null): ControllerAcceptedEventFilter;
+        ControllerAccepted(previousController?: PromiseOrValue<string> | null, newController?: PromiseOrValue<string> | null): ControllerAcceptedEventFilter;
+        "ControllerInitialized(address)"(controller?: PromiseOrValue<string> | null): ControllerInitializedEventFilter;
+        ControllerInitialized(controller?: PromiseOrValue<string> | null): ControllerInitializedEventFilter;
+        "ControllerProposalCancelled(address)"(pendingController?: PromiseOrValue<string> | null): ControllerProposalCancelledEventFilter;
+        ControllerProposalCancelled(pendingController?: PromiseOrValue<string> | null): ControllerProposalCancelledEventFilter;
+        "ControllerProposed(address,address,uint64)"(currentController?: PromiseOrValue<string> | null, pendingController?: PromiseOrValue<string> | null, validAt?: null): ControllerProposedEventFilter;
+        ControllerProposed(currentController?: PromiseOrValue<string> | null, pendingController?: PromiseOrValue<string> | null, validAt?: null): ControllerProposedEventFilter;
+        "LockFunded(bytes32,address,uint256,uint256)"(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, amount?: null, newStakeBalance?: null): LockFundedEventFilter;
+        LockFunded(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, amount?: null, newStakeBalance?: null): LockFundedEventFilter;
+        "OwnershipTransferStarted(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferStartedEventFilter;
+        OwnershipTransferStarted(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferStartedEventFilter;
+        "OwnershipTransferred(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        "StakeDeposited(address,uint256,uint256)"(stakeOwner?: PromiseOrValue<string> | null, amount?: null, newStakeBalance?: null): StakeDepositedEventFilter;
+        StakeDeposited(stakeOwner?: PromiseOrValue<string> | null, amount?: null, newStakeBalance?: null): StakeDepositedEventFilter;
+        "StakeLockIncreased(bytes32,address,uint256,uint256,uint256)"(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, previousAmount?: null, newAmount?: null, totalLockedStake?: null): StakeLockIncreasedEventFilter;
+        StakeLockIncreased(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, previousAmount?: null, newAmount?: null, totalLockedStake?: null): StakeLockIncreasedEventFilter;
+        "StakeLockResized(bytes32,address,uint256,uint256,uint64,uint64,uint256)"(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, previousAmount?: null, newAmount?: null, previousMaturity?: null, newMaturity?: null, totalLockedStake?: null): StakeLockResizedEventFilter;
+        StakeLockResized(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, previousAmount?: null, newAmount?: null, previousMaturity?: null, newMaturity?: null, totalLockedStake?: null): StakeLockResizedEventFilter;
+        "StakeLockResolved(bytes32,address,uint256,uint256,uint256,uint256)"(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, lockAmount?: null, unlockedAmount?: null, claimedAmount?: null, totalLockedStake?: null): StakeLockResolvedEventFilter;
+        StakeLockResolved(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, lockAmount?: null, unlockedAmount?: null, claimedAmount?: null, totalLockedStake?: null): StakeLockResolvedEventFilter;
+        "StakeLocked(bytes32,address,uint256,uint64,uint256)"(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, amount?: null, maturesAt?: null, totalLockedStake?: null): StakeLockedEventFilter;
+        StakeLocked(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, amount?: null, maturesAt?: null, totalLockedStake?: null): StakeLockedEventFilter;
+        "StakeOwnerSelected(address,address,address)"(taker?: PromiseOrValue<string> | null, previousStakeOwner?: PromiseOrValue<string> | null, newStakeOwner?: PromiseOrValue<string> | null): StakeOwnerSelectedEventFilter;
+        StakeOwnerSelected(taker?: PromiseOrValue<string> | null, previousStakeOwner?: PromiseOrValue<string> | null, newStakeOwner?: PromiseOrValue<string> | null): StakeOwnerSelectedEventFilter;
+        "StakeUnlocked(bytes32,address,uint256,uint256)"(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, amount?: null, totalLockedStake?: null): StakeUnlockedEventFilter;
+        StakeUnlocked(lockId?: PromiseOrValue<BytesLike> | null, stakeOwner?: PromiseOrValue<string> | null, amount?: null, totalLockedStake?: null): StakeUnlockedEventFilter;
+        "StakeWithdrawn(address,uint256,uint256)"(stakeOwner?: PromiseOrValue<string> | null, amount?: null, newStakeBalance?: null): StakeWithdrawnEventFilter;
+        StakeWithdrawn(stakeOwner?: PromiseOrValue<string> | null, amount?: null, newStakeBalance?: null): StakeWithdrawnEventFilter;
+        "TakerAuthorizationUpdated(address,address,bool)"(stakeOwner?: PromiseOrValue<string> | null, taker?: PromiseOrValue<string> | null, authorized?: null): TakerAuthorizationUpdatedEventFilter;
+        TakerAuthorizationUpdated(stakeOwner?: PromiseOrValue<string> | null, taker?: PromiseOrValue<string> | null, authorized?: null): TakerAuthorizationUpdatedEventFilter;
+    };
+    estimateGas: {
+        MIN_CONTROLLER_CHANGE_DELAY(overrides?: CallOverrides): Promise<BigNumber>;
+        NEVER_MATURES(overrides?: CallOverrides): Promise<BigNumber>;
+        acceptController(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        acceptOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        authorizedTakers(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        cancelControllerProposal(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        claim(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        claimable(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        clearStakeOwner(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        controller(overrides?: CallOverrides): Promise<BigNumber>;
+        controllerChangeDelay(overrides?: CallOverrides): Promise<BigNumber>;
+        depositStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        freeStake(_stakeOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        fundLock(_stakeOwner: PromiseOrValue<string>, _lockId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _maturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        increaseLock(_lockId: PromiseOrValue<BytesLike>, _additionalAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        initializeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        isLockMature(_lockId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        lockStake(_stakeOwner: PromiseOrValue<string>, _lockId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _maturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        lockedStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        locks(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        pendingController(overrides?: CallOverrides): Promise<BigNumber>;
+        pendingControllerValidAt(overrides?: CallOverrides): Promise<BigNumber>;
+        pendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
+        proposeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        renounceOwnership(overrides?: CallOverrides): Promise<BigNumber>;
+        resizeLock(_lockId: PromiseOrValue<BytesLike>, _newAmount: PromiseOrValue<BigNumberish>, _newMaturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        resolveLock(_lockId: PromiseOrValue<BytesLike>, _claims: IStakeVault.ClaimStruct[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        selectStakeOwner(_stakeOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        selectedStakeOwner(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        setTakerAuthorization(_taker: PromiseOrValue<string>, _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        stakeBalance(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        stakeOwnerOf(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        stakeToken(overrides?: CallOverrides): Promise<BigNumber>;
+        totalAccounted(overrides?: CallOverrides): Promise<BigNumber>;
+        totalClaimable(overrides?: CallOverrides): Promise<BigNumber>;
+        totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        unaccountedBalance(overrides?: CallOverrides): Promise<BigNumber>;
+        unlockStake(_lockId: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        withdrawStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        MIN_CONTROLLER_CHANGE_DELAY(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        NEVER_MATURES(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        acceptController(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        acceptOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        authorizedTakers(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        cancelControllerProposal(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        claim(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        claimable(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        clearStakeOwner(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        controller(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        controllerChangeDelay(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        depositStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        freeStake(_stakeOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        fundLock(_stakeOwner: PromiseOrValue<string>, _lockId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _maturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        increaseLock(_lockId: PromiseOrValue<BytesLike>, _additionalAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        initializeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        isLockMature(_lockId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        lockStake(_stakeOwner: PromiseOrValue<string>, _lockId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _maturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        lockedStake(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        locks(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pendingController(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pendingControllerValidAt(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pendingOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        proposeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        resizeLock(_lockId: PromiseOrValue<BytesLike>, _newAmount: PromiseOrValue<BigNumberish>, _newMaturesAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        resolveLock(_lockId: PromiseOrValue<BytesLike>, _claims: IStakeVault.ClaimStruct[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        selectStakeOwner(_stakeOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        selectedStakeOwner(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setTakerAuthorization(_taker: PromiseOrValue<string>, _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        stakeBalance(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        stakeOwnerOf(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        stakeToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalAccounted(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalClaimable(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalStaked(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        unaccountedBalance(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        unlockStake(_lockId: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        withdrawStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}