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

package/types/contracts/interfaces/IStakeVault.ts

@@ -28,185 +28,90 @@ import type {
 } from "../../common";
 
 export declare namespace IStakeVault {
-  export type DeferredPayoutStruct = {
+  export type ClaimStruct = {
     beneficiary: PromiseOrValue<string>;
-    controller: PromiseOrValue<string>;
     amount: PromiseOrValue<BigNumberish>;
-    releaseTime: PromiseOrValue<BigNumberish>;
   };
 
-  export type DeferredPayoutStructOutput = [
-    string,
-    string,
-    BigNumber,
-    BigNumber
-  ] & {
+  export type ClaimStructOutput = [string, BigNumber] & {
     beneficiary: string;
-    controller: string;
     amount: BigNumber;
-    releaseTime: BigNumber;
   };
-
-  export type ExitRequestStruct = {
-    exiting: PromiseOrValue<boolean>;
-    requestedAt: PromiseOrValue<BigNumberish>;
-    availableAt: PromiseOrValue<BigNumberish>;
-  };
-
-  export type ExitRequestStructOutput = [boolean, BigNumber, BigNumber] & {
-    exiting: boolean;
-    requestedAt: BigNumber;
-    availableAt: BigNumber;
-  };
-
-  export type IntentCapacityStruct = {
-    stakeOwner: PromiseOrValue<string>;
-    controller: PromiseOrValue<string>;
-    active: PromiseOrValue<boolean>;
-  };
-
-  export type IntentCapacityStructOutput = [string, string, boolean] & {
-    stakeOwner: string;
-    controller: string;
-    active: boolean;
-  };
-
-  export type ReservationStruct = {
-    staker: PromiseOrValue<string>;
-    controller: PromiseOrValue<string>;
-    amount: PromiseOrValue<BigNumberish>;
-    releaseTime: PromiseOrValue<BigNumberish>;
-    active: PromiseOrValue<boolean>;
-  };
-
-  export type ReservationStructOutput = [
-    string,
-    string,
-    BigNumber,
-    BigNumber,
-    boolean
-  ] & {
-    staker: string;
-    controller: string;
-    amount: BigNumber;
-    releaseTime: BigNumber;
-    active: boolean;
-  };
-
-  export type StakeWithdrawalRequestStruct = {
-    amount: PromiseOrValue<BigNumberish>;
-    requestedAt: PromiseOrValue<BigNumberish>;
-    availableAt: PromiseOrValue<BigNumberish>;
-  };
-
-  export type StakeWithdrawalRequestStructOutput = [
-    BigNumber,
-    BigNumber,
-    BigNumber
-  ] & { amount: BigNumber; requestedAt: BigNumber; availableAt: BigNumber };
 }
 
 export interface IStakeVaultInterface extends utils.Interface {
   functions: {
     "acceptController()": FunctionFragment;
-    "activeIntentCount(address)": FunctionFragment;
-    "allowedStakeOwner(address)": FunctionFragment;
-    "authorizeDeferredPayout(bytes32,address,uint64)": FunctionFragment;
-    "cancelExit()": FunctionFragment;
-    "cancelStakeWithdrawal()": FunctionFragment;
-    "claimableCompensation(address)": FunctionFragment;
+    "authorizedTakers(address,address)": FunctionFragment;
+    "cancelControllerProposal()": FunctionFragment;
+    "claim()": FunctionFragment;
+    "claimable(address)": FunctionFragment;
     "clearStakeOwner()": FunctionFragment;
     "controller()": FunctionFragment;
+    "controllerChangeDelay()": FunctionFragment;
     "depositStake(uint256)": FunctionFragment;
-    "depositStakeFor(address,uint256)": FunctionFragment;
-    "eligibleStake(address)": FunctionFragment;
     "freeStake(address)": FunctionFragment;
-    "getDeferredPayout(bytes32)": FunctionFragment;
-    "getExitRequest(address)": FunctionFragment;
-    "getIntentCapacity(bytes32)": FunctionFragment;
-    "getReservation(bytes32)": FunctionFragment;
-    "getStakeWithdrawalRequest(address)": FunctionFragment;
+    "fundLock(address,bytes32,uint256,uint64)": FunctionFragment;
+    "increaseLock(bytes32,uint256)": FunctionFragment;
     "initializeController(address)": FunctionFragment;
-    "isExiting(address)": FunctionFragment;
+    "isLockMature(bytes32)": FunctionFragment;
+    "lockStake(address,bytes32,uint256,uint64)": FunctionFragment;
+    "lockedStake(address)": FunctionFragment;
+    "locks(bytes32)": FunctionFragment;
+    "pendingController()": FunctionFragment;
+    "pendingControllerValidAt()": FunctionFragment;
     "proposeController(address)": FunctionFragment;
-    "recordDeferredPayout(bytes32,address,uint256,uint64)": FunctionFragment;
-    "releaseDeferredPayoutAuthorization(bytes32)": FunctionFragment;
-    "releaseIntentCapacity(bytes32)": FunctionFragment;
-    "releaseReservation(bytes32)": FunctionFragment;
-    "requestExit()": FunctionFragment;
-    "requestStakeWithdrawal(uint256)": FunctionFragment;
-    "reserveIntentCapacity(address,bytes32,uint256)": FunctionFragment;
-    "reserveStake(address,bytes32,uint256,uint64)": FunctionFragment;
-    "reservedStake(address)": FunctionFragment;
-    "setAllowedStakeOwner(address)": FunctionFragment;
-    "setStakeDelegationEnabled(bool)": FunctionFragment;
-    "setStakeOperationsPaused(bool,bool)": FunctionFragment;
+    "resizeLock(bytes32,uint256,uint64)": FunctionFragment;
+    "resolveLock(bytes32,(address,uint256)[])": FunctionFragment;
+    "selectStakeOwner(address)": FunctionFragment;
+    "selectedStakeOwner(address)": FunctionFragment;
     "setTakerAuthorization(address,bool)": FunctionFragment;
-    "setTakerAuthorizations(address[],bool)": FunctionFragment;
-    "slashDeferredPayout(bytes32,address,uint256)": FunctionFragment;
-    "slashReservation(bytes32,address,uint256)": FunctionFragment;
     "stakeBalance(address)": FunctionFragment;
-    "stakeDelegationEnabled(address)": FunctionFragment;
     "stakeOwnerOf(address)": FunctionFragment;
     "stakeToken()": FunctionFragment;
-    "totalLiabilities()": FunctionFragment;
-    "updateReservation(bytes32,uint256,uint64)": FunctionFragment;
-    "withdrawCompensation(address)": FunctionFragment;
-    "withdrawDeferredPayout(bytes32,address)": FunctionFragment;
-    "withdrawDeferredPayouts(bytes32[],address)": FunctionFragment;
-    "withdrawRequestedStake(address)": FunctionFragment;
-    "withdrawStake(address)": FunctionFragment;
+    "totalAccounted()": FunctionFragment;
+    "totalClaimable()": FunctionFragment;
+    "totalStaked()": FunctionFragment;
+    "unaccountedBalance()": FunctionFragment;
+    "unlockStake(bytes32)": FunctionFragment;
+    "withdrawStake(uint256)": FunctionFragment;
   };
 
   getFunction(
     nameOrSignatureOrTopic:
       | "acceptController"
-      | "activeIntentCount"
-      | "allowedStakeOwner"
-      | "authorizeDeferredPayout"
-      | "cancelExit"
-      | "cancelStakeWithdrawal"
-      | "claimableCompensation"
+      | "authorizedTakers"
+      | "cancelControllerProposal"
+      | "claim"
+      | "claimable"
       | "clearStakeOwner"
       | "controller"
+      | "controllerChangeDelay"
       | "depositStake"
-      | "depositStakeFor"
-      | "eligibleStake"
       | "freeStake"
-      | "getDeferredPayout"
-      | "getExitRequest"
-      | "getIntentCapacity"
-      | "getReservation"
-      | "getStakeWithdrawalRequest"
+      | "fundLock"
+      | "increaseLock"
       | "initializeController"
-      | "isExiting"
+      | "isLockMature"
+      | "lockStake"
+      | "lockedStake"
+      | "locks"
+      | "pendingController"
+      | "pendingControllerValidAt"
       | "proposeController"
-      | "recordDeferredPayout"
-      | "releaseDeferredPayoutAuthorization"
-      | "releaseIntentCapacity"
-      | "releaseReservation"
-      | "requestExit"
-      | "requestStakeWithdrawal"
-      | "reserveIntentCapacity"
-      | "reserveStake"
-      | "reservedStake"
-      | "setAllowedStakeOwner"
-      | "setStakeDelegationEnabled"
-      | "setStakeOperationsPaused"
+      | "resizeLock"
+      | "resolveLock"
+      | "selectStakeOwner"
+      | "selectedStakeOwner"
       | "setTakerAuthorization"
-      | "setTakerAuthorizations"
-      | "slashDeferredPayout"
-      | "slashReservation"
       | "stakeBalance"
-      | "stakeDelegationEnabled"
       | "stakeOwnerOf"
       | "stakeToken"
-      | "totalLiabilities"
-      | "updateReservation"
-      | "withdrawCompensation"
-      | "withdrawDeferredPayout"
-      | "withdrawDeferredPayouts"
-      | "withdrawRequestedStake"
+      | "totalAccounted"
+      | "totalClaimable"
+      | "totalStaked"
+      | "unaccountedBalance"
+      | "unlockStake"
       | "withdrawStake"
   ): FunctionFragment;
 
@@ -215,31 +120,16 @@ export interface IStakeVaultInterface extends utils.Interface {
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "activeIntentCount",
-    values: [PromiseOrValue<string>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "allowedStakeOwner",
-    values: [PromiseOrValue<string>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "authorizeDeferredPayout",
-    values: [
-      PromiseOrValue<BytesLike>,
-      PromiseOrValue<string>,
-      PromiseOrValue<BigNumberish>
-    ]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "cancelExit",
-    values?: undefined
+    functionFragment: "authorizedTakers",
+    values: [PromiseOrValue<string>, PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "cancelStakeWithdrawal",
+    functionFragment: "cancelControllerProposal",
     values?: undefined
   ): string;
+  encodeFunctionData(functionFragment: "claim", values?: undefined): string;
   encodeFunctionData(
-    functionFragment: "claimableCompensation",
+    functionFragment: "claimable",
     values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
@@ -251,147 +141,95 @@ export interface IStakeVaultInterface extends utils.Interface {
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "depositStake",
-    values: [PromiseOrValue<BigNumberish>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "depositStakeFor",
-    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+    functionFragment: "controllerChangeDelay",
+    values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "eligibleStake",
-    values: [PromiseOrValue<string>]
+    functionFragment: "depositStake",
+    values: [PromiseOrValue<BigNumberish>]
   ): string;
   encodeFunctionData(
     functionFragment: "freeStake",
     values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "getDeferredPayout",
-    values: [PromiseOrValue<BytesLike>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "getExitRequest",
-    values: [PromiseOrValue<string>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "getIntentCapacity",
-    values: [PromiseOrValue<BytesLike>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "getReservation",
-    values: [PromiseOrValue<BytesLike>]
+    functionFragment: "fundLock",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>
+    ]
   ): string;
   encodeFunctionData(
-    functionFragment: "getStakeWithdrawalRequest",
-    values: [PromiseOrValue<string>]
+    functionFragment: "increaseLock",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
   ): string;
   encodeFunctionData(
     functionFragment: "initializeController",
     values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "isExiting",
-    values: [PromiseOrValue<string>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "proposeController",
-    values: [PromiseOrValue<string>]
+    functionFragment: "isLockMature",
+    values: [PromiseOrValue<BytesLike>]
   ): string;
   encodeFunctionData(
-    functionFragment: "recordDeferredPayout",
+    functionFragment: "lockStake",
     values: [
-      PromiseOrValue<BytesLike>,
       PromiseOrValue<string>,
+      PromiseOrValue<BytesLike>,
       PromiseOrValue<BigNumberish>,
       PromiseOrValue<BigNumberish>
     ]
   ): string;
   encodeFunctionData(
-    functionFragment: "releaseDeferredPayoutAuthorization",
-    values: [PromiseOrValue<BytesLike>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "releaseIntentCapacity",
-    values: [PromiseOrValue<BytesLike>]
+    functionFragment: "lockedStake",
+    values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "releaseReservation",
+    functionFragment: "locks",
     values: [PromiseOrValue<BytesLike>]
   ): string;
   encodeFunctionData(
-    functionFragment: "requestExit",
+    functionFragment: "pendingController",
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "requestStakeWithdrawal",
-    values: [PromiseOrValue<BigNumberish>]
+    functionFragment: "pendingControllerValidAt",
+    values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "reserveIntentCapacity",
-    values: [
-      PromiseOrValue<string>,
-      PromiseOrValue<BytesLike>,
-      PromiseOrValue<BigNumberish>
-    ]
+    functionFragment: "proposeController",
+    values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "reserveStake",
+    functionFragment: "resizeLock",
     values: [
-      PromiseOrValue<string>,
       PromiseOrValue<BytesLike>,
       PromiseOrValue<BigNumberish>,
       PromiseOrValue<BigNumberish>
     ]
   ): string;
   encodeFunctionData(
-    functionFragment: "reservedStake",
-    values: [PromiseOrValue<string>]
+    functionFragment: "resolveLock",
+    values: [PromiseOrValue<BytesLike>, IStakeVault.ClaimStruct[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "setAllowedStakeOwner",
+    functionFragment: "selectStakeOwner",
     values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "setStakeDelegationEnabled",
-    values: [PromiseOrValue<boolean>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "setStakeOperationsPaused",
-    values: [PromiseOrValue<boolean>, PromiseOrValue<boolean>]
+    functionFragment: "selectedStakeOwner",
+    values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
     functionFragment: "setTakerAuthorization",
     values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
   ): string;
-  encodeFunctionData(
-    functionFragment: "setTakerAuthorizations",
-    values: [PromiseOrValue<string>[], PromiseOrValue<boolean>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "slashDeferredPayout",
-    values: [
-      PromiseOrValue<BytesLike>,
-      PromiseOrValue<string>,
-      PromiseOrValue<BigNumberish>
-    ]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "slashReservation",
-    values: [
-      PromiseOrValue<BytesLike>,
-      PromiseOrValue<string>,
-      PromiseOrValue<BigNumberish>
-    ]
-  ): string;
   encodeFunctionData(
     functionFragment: "stakeBalance",
     values: [PromiseOrValue<string>]
   ): string;
-  encodeFunctionData(
-    functionFragment: "stakeDelegationEnabled",
-    values: [PromiseOrValue<string>]
-  ): string;
   encodeFunctionData(
     functionFragment: "stakeOwnerOf",
     values: [PromiseOrValue<string>]
@@ -401,36 +239,28 @@ export interface IStakeVaultInterface extends utils.Interface {
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "totalLiabilities",
+    functionFragment: "totalAccounted",
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "updateReservation",
-    values: [
-      PromiseOrValue<BytesLike>,
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>
-    ]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "withdrawCompensation",
-    values: [PromiseOrValue<string>]
+    functionFragment: "totalClaimable",
+    values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "withdrawDeferredPayout",
-    values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]
+    functionFragment: "totalStaked",
+    values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "withdrawDeferredPayouts",
-    values: [PromiseOrValue<BytesLike>[], PromiseOrValue<string>]
+    functionFragment: "unaccountedBalance",
+    values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "withdrawRequestedStake",
-    values: [PromiseOrValue<string>]
+    functionFragment: "unlockStake",
+    values: [PromiseOrValue<BytesLike>]
   ): string;
   encodeFunctionData(
     functionFragment: "withdrawStake",
-    values: [PromiseOrValue<string>]
+    values: [PromiseOrValue<BigNumberish>]
   ): string;
 
   decodeFunctionResult(
@@ -438,172 +268,104 @@ export interface IStakeVaultInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "activeIntentCount",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "allowedStakeOwner",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "authorizeDeferredPayout",
+    functionFragment: "authorizedTakers",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "cancelExit", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "cancelStakeWithdrawal",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "claimableCompensation",
+    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: "depositStake",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "depositStakeFor",
+    functionFragment: "controllerChangeDelay",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "eligibleStake",
+    functionFragment: "depositStake",
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "freeStake", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "fundLock", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "getDeferredPayout",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "getExitRequest",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "getIntentCapacity",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "getReservation",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "getStakeWithdrawalRequest",
+    functionFragment: "increaseLock",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
     functionFragment: "initializeController",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "isExiting", data: BytesLike): Result;
-  decodeFunctionResult(
-    functionFragment: "proposeController",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "recordDeferredPayout",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "releaseDeferredPayoutAuthorization",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "releaseIntentCapacity",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "releaseReservation",
-    data: BytesLike
-  ): Result;
   decodeFunctionResult(
-    functionFragment: "requestExit",
+    functionFragment: "isLockMature",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "lockStake", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "requestStakeWithdrawal",
+    functionFragment: "lockedStake",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "locks", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "reserveIntentCapacity",
+    functionFragment: "pendingController",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "reserveStake",
+    functionFragment: "pendingControllerValidAt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "reservedStake",
+    functionFragment: "proposeController",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "resizeLock", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "setAllowedStakeOwner",
+    functionFragment: "resolveLock",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "setStakeDelegationEnabled",
+    functionFragment: "selectStakeOwner",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "setStakeOperationsPaused",
+    functionFragment: "selectedStakeOwner",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
     functionFragment: "setTakerAuthorization",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(
-    functionFragment: "setTakerAuthorizations",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "slashDeferredPayout",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "slashReservation",
-    data: BytesLike
-  ): Result;
   decodeFunctionResult(
     functionFragment: "stakeBalance",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(
-    functionFragment: "stakeDelegationEnabled",
-    data: BytesLike
-  ): Result;
   decodeFunctionResult(
     functionFragment: "stakeOwnerOf",
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "stakeToken", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "totalLiabilities",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "updateReservation",
+    functionFragment: "totalAccounted",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "withdrawCompensation",
+    functionFragment: "totalClaimable",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "withdrawDeferredPayout",
+    functionFragment: "totalStaked",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "withdrawDeferredPayouts",
+    functionFragment: "unaccountedBalance",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "withdrawRequestedStake",
+    functionFragment: "unlockStake",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -612,106 +374,67 @@ export interface IStakeVaultInterface extends utils.Interface {
   ): Result;
 
   events: {
-    "AllowedStakeOwnerUpdated(address,address)": EventFragment;
-    "CompensationCredited(bytes32,address,uint256,uint256)": EventFragment;
-    "CompensationWithdrawn(address,address,uint256)": EventFragment;
+    "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;
-    "DeferredPayoutAuthorizationReleased(bytes32,address,address)": EventFragment;
-    "DeferredPayoutAuthorized(bytes32,address,address,uint64)": EventFragment;
-    "DeferredPayoutRecorded(bytes32,address,uint256,uint64)": EventFragment;
-    "DeferredPayoutSlashed(bytes32,address,address,uint256,uint256)": EventFragment;
-    "DeferredPayoutWithdrawn(bytes32,address,address,uint256)": EventFragment;
-    "ExitCancelled(address)": EventFragment;
-    "ExitRequested(address,uint64,uint64)": EventFragment;
-    "IntentCapacityReleased(bytes32,address,address,uint256)": EventFragment;
-    "IntentCapacityReserved(bytes32,address,address,uint256)": EventFragment;
-    "StakeDelegationEnabledUpdated(address,bool)": EventFragment;
+    "LockFunded(bytes32,address,uint256,uint256)": EventFragment;
     "StakeDeposited(address,uint256,uint256)": EventFragment;
-    "StakeOperationsPausedUpdated(bool,bool)": EventFragment;
-    "StakeReservationReleased(bytes32,address,uint256,uint256)": EventFragment;
-    "StakeReservationUpdated(bytes32,address,uint256,uint256,uint256,uint64)": EventFragment;
-    "StakeReserved(bytes32,address,address,uint256,uint256,uint64)": EventFragment;
-    "StakeSlashed(bytes32,address,address,uint256,uint256,uint256)": EventFragment;
-    "StakeWithdrawalCancelled(address,uint256)": EventFragment;
-    "StakeWithdrawalRequested(address,uint256,uint64,uint64)": EventFragment;
-    "StakeWithdrawn(address,address,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: "AllowedStakeOwnerUpdated"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "CompensationCredited"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "CompensationWithdrawn"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ClaimCreated"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ClaimWithdrawn"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "ControllerAccepted"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "ControllerInitialized"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "ControllerProposed"): EventFragment;
-  getEvent(
-    nameOrSignatureOrTopic: "DeferredPayoutAuthorizationReleased"
-  ): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "DeferredPayoutAuthorized"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "DeferredPayoutRecorded"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "DeferredPayoutSlashed"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "DeferredPayoutWithdrawn"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "ExitCancelled"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "ExitRequested"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "IntentCapacityReleased"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "IntentCapacityReserved"): EventFragment;
   getEvent(
-    nameOrSignatureOrTopic: "StakeDelegationEnabledUpdated"
+    nameOrSignatureOrTopic: "ControllerProposalCancelled"
   ): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ControllerProposed"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "LockFunded"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "StakeDeposited"): EventFragment;
-  getEvent(
-    nameOrSignatureOrTopic: "StakeOperationsPausedUpdated"
-  ): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "StakeReservationReleased"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "StakeReservationUpdated"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "StakeReserved"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "StakeSlashed"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "StakeWithdrawalCancelled"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "StakeWithdrawalRequested"): 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 AllowedStakeOwnerUpdatedEventObject {
-  taker: string;
-  allowedStakeOwner: string;
-}
-export type AllowedStakeOwnerUpdatedEvent = TypedEvent<
-  [string, string],
-  AllowedStakeOwnerUpdatedEventObject
->;
-
-export type AllowedStakeOwnerUpdatedEventFilter =
-  TypedEventFilter<AllowedStakeOwnerUpdatedEvent>;
-
-export interface CompensationCreditedEventObject {
-  intentHash: string;
-  maker: string;
+export interface ClaimCreatedEventObject {
+  lockId: string;
+  beneficiary: string;
   amount: BigNumber;
   newClaimableBalance: BigNumber;
 }
-export type CompensationCreditedEvent = TypedEvent<
+export type ClaimCreatedEvent = TypedEvent<
   [string, string, BigNumber, BigNumber],
-  CompensationCreditedEventObject
+  ClaimCreatedEventObject
 >;
 
-export type CompensationCreditedEventFilter =
-  TypedEventFilter<CompensationCreditedEvent>;
+export type ClaimCreatedEventFilter = TypedEventFilter<ClaimCreatedEvent>;
 
-export interface CompensationWithdrawnEventObject {
-  maker: string;
-  recipient: string;
+export interface ClaimWithdrawnEventObject {
+  beneficiary: string;
   amount: BigNumber;
 }
-export type CompensationWithdrawnEvent = TypedEvent<
-  [string, string, BigNumber],
-  CompensationWithdrawnEventObject
+export type ClaimWithdrawnEvent = TypedEvent<
+  [string, BigNumber],
+  ClaimWithdrawnEventObject
 >;
 
-export type CompensationWithdrawnEventFilter =
-  TypedEventFilter<CompensationWithdrawnEvent>;
+export type ClaimWithdrawnEventFilter = TypedEventFilter<ClaimWithdrawnEvent>;
 
 export interface ControllerAcceptedEventObject {
   previousController: string;
@@ -736,6 +459,17 @@ export type ControllerInitializedEvent = TypedEvent<
 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;
@@ -749,256 +483,130 @@ export type ControllerProposedEvent = TypedEvent<
 export type ControllerProposedEventFilter =
   TypedEventFilter<ControllerProposedEvent>;
 
-export interface DeferredPayoutAuthorizationReleasedEventObject {
-  intentHash: string;
-  beneficiary: string;
-  controller: string;
-}
-export type DeferredPayoutAuthorizationReleasedEvent = TypedEvent<
-  [string, string, string],
-  DeferredPayoutAuthorizationReleasedEventObject
->;
-
-export type DeferredPayoutAuthorizationReleasedEventFilter =
-  TypedEventFilter<DeferredPayoutAuthorizationReleasedEvent>;
-
-export interface DeferredPayoutAuthorizedEventObject {
-  intentHash: string;
-  beneficiary: string;
-  controller: string;
-  releaseTime: BigNumber;
-}
-export type DeferredPayoutAuthorizedEvent = TypedEvent<
-  [string, string, string, BigNumber],
-  DeferredPayoutAuthorizedEventObject
->;
-
-export type DeferredPayoutAuthorizedEventFilter =
-  TypedEventFilter<DeferredPayoutAuthorizedEvent>;
-
-export interface DeferredPayoutRecordedEventObject {
-  intentHash: string;
-  beneficiary: string;
+export interface LockFundedEventObject {
+  lockId: string;
+  stakeOwner: string;
   amount: BigNumber;
-  releaseTime: BigNumber;
+  newStakeBalance: BigNumber;
 }
-export type DeferredPayoutRecordedEvent = TypedEvent<
+export type LockFundedEvent = TypedEvent<
   [string, string, BigNumber, BigNumber],
-  DeferredPayoutRecordedEventObject
+  LockFundedEventObject
 >;
 
-export type DeferredPayoutRecordedEventFilter =
-  TypedEventFilter<DeferredPayoutRecordedEvent>;
+export type LockFundedEventFilter = TypedEventFilter<LockFundedEvent>;
 
-export interface DeferredPayoutSlashedEventObject {
-  intentHash: string;
-  beneficiary: string;
-  maker: string;
+export interface StakeDepositedEventObject {
+  stakeOwner: string;
   amount: BigNumber;
-  remainingAmount: BigNumber;
+  newStakeBalance: BigNumber;
 }
-export type DeferredPayoutSlashedEvent = TypedEvent<
-  [string, string, string, BigNumber, BigNumber],
-  DeferredPayoutSlashedEventObject
+export type StakeDepositedEvent = TypedEvent<
+  [string, BigNumber, BigNumber],
+  StakeDepositedEventObject
 >;
 
-export type DeferredPayoutSlashedEventFilter =
-  TypedEventFilter<DeferredPayoutSlashedEvent>;
+export type StakeDepositedEventFilter = TypedEventFilter<StakeDepositedEvent>;
 
-export interface DeferredPayoutWithdrawnEventObject {
-  intentHash: string;
-  beneficiary: string;
-  recipient: string;
-  amount: BigNumber;
+export interface StakeLockIncreasedEventObject {
+  lockId: string;
+  stakeOwner: string;
+  previousAmount: BigNumber;
+  newAmount: BigNumber;
+  totalLockedStake: BigNumber;
 }
-export type DeferredPayoutWithdrawnEvent = TypedEvent<
-  [string, string, string, BigNumber],
-  DeferredPayoutWithdrawnEventObject
+export type StakeLockIncreasedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber, BigNumber],
+  StakeLockIncreasedEventObject
 >;
 
-export type DeferredPayoutWithdrawnEventFilter =
-  TypedEventFilter<DeferredPayoutWithdrawnEvent>;
-
-export interface ExitCancelledEventObject {
-  staker: string;
-}
-export type ExitCancelledEvent = TypedEvent<[string], ExitCancelledEventObject>;
-
-export type ExitCancelledEventFilter = TypedEventFilter<ExitCancelledEvent>;
+export type StakeLockIncreasedEventFilter =
+  TypedEventFilter<StakeLockIncreasedEvent>;
 
-export interface ExitRequestedEventObject {
-  staker: string;
-  requestedAt: BigNumber;
-  availableAt: BigNumber;
+export interface StakeLockResizedEventObject {
+  lockId: string;
+  stakeOwner: string;
+  previousAmount: BigNumber;
+  newAmount: BigNumber;
+  previousMaturity: BigNumber;
+  newMaturity: BigNumber;
+  totalLockedStake: BigNumber;
 }
-export type ExitRequestedEvent = TypedEvent<
-  [string, BigNumber, BigNumber],
-  ExitRequestedEventObject
+export type StakeLockResizedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
+  StakeLockResizedEventObject
 >;
 
-export type ExitRequestedEventFilter = TypedEventFilter<ExitRequestedEvent>;
+export type StakeLockResizedEventFilter =
+  TypedEventFilter<StakeLockResizedEvent>;
 
-export interface IntentCapacityReleasedEventObject {
-  intentHash: string;
+export interface StakeLockResolvedEventObject {
+  lockId: string;
   stakeOwner: string;
-  controller: string;
-  activeIntents: BigNumber;
+  lockAmount: BigNumber;
+  unlockedAmount: BigNumber;
+  claimedAmount: BigNumber;
+  totalLockedStake: BigNumber;
 }
-export type IntentCapacityReleasedEvent = TypedEvent<
-  [string, string, string, BigNumber],
-  IntentCapacityReleasedEventObject
+export type StakeLockResolvedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber, BigNumber, BigNumber],
+  StakeLockResolvedEventObject
 >;
 
-export type IntentCapacityReleasedEventFilter =
-  TypedEventFilter<IntentCapacityReleasedEvent>;
+export type StakeLockResolvedEventFilter =
+  TypedEventFilter<StakeLockResolvedEvent>;
 
-export interface IntentCapacityReservedEventObject {
-  intentHash: string;
+export interface StakeLockedEventObject {
+  lockId: string;
   stakeOwner: string;
-  controller: string;
-  activeIntents: BigNumber;
+  amount: BigNumber;
+  maturesAt: BigNumber;
+  totalLockedStake: BigNumber;
 }
-export type IntentCapacityReservedEvent = TypedEvent<
-  [string, string, string, BigNumber],
-  IntentCapacityReservedEventObject
+export type StakeLockedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber, BigNumber],
+  StakeLockedEventObject
 >;
 
-export type IntentCapacityReservedEventFilter =
-  TypedEventFilter<IntentCapacityReservedEvent>;
+export type StakeLockedEventFilter = TypedEventFilter<StakeLockedEvent>;
 
-export interface StakeDelegationEnabledUpdatedEventObject {
+export interface StakeOwnerSelectedEventObject {
   taker: string;
-  enabled: boolean;
+  previousStakeOwner: string;
+  newStakeOwner: string;
 }
-export type StakeDelegationEnabledUpdatedEvent = TypedEvent<
-  [string, boolean],
-  StakeDelegationEnabledUpdatedEventObject
+export type StakeOwnerSelectedEvent = TypedEvent<
+  [string, string, string],
+  StakeOwnerSelectedEventObject
 >;
 
-export type StakeDelegationEnabledUpdatedEventFilter =
-  TypedEventFilter<StakeDelegationEnabledUpdatedEvent>;
+export type StakeOwnerSelectedEventFilter =
+  TypedEventFilter<StakeOwnerSelectedEvent>;
 
-export interface StakeDepositedEventObject {
-  staker: string;
+export interface StakeUnlockedEventObject {
+  lockId: string;
+  stakeOwner: string;
   amount: BigNumber;
-  newStakeBalance: BigNumber;
+  totalLockedStake: BigNumber;
 }
-export type StakeDepositedEvent = TypedEvent<
-  [string, BigNumber, BigNumber],
-  StakeDepositedEventObject
+export type StakeUnlockedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  StakeUnlockedEventObject
 >;
 
-export type StakeDepositedEventFilter = TypedEventFilter<StakeDepositedEvent>;
+export type StakeUnlockedEventFilter = TypedEventFilter<StakeUnlockedEvent>;
 
-export interface StakeOperationsPausedUpdatedEventObject {
-  depositsPaused: boolean;
-  reservationsPaused: boolean;
+export interface StakeWithdrawnEventObject {
+  stakeOwner: string;
+  amount: BigNumber;
+  newStakeBalance: BigNumber;
 }
-export type StakeOperationsPausedUpdatedEvent = TypedEvent<
-  [boolean, boolean],
-  StakeOperationsPausedUpdatedEventObject
+export type StakeWithdrawnEvent = TypedEvent<
+  [string, BigNumber, BigNumber],
+  StakeWithdrawnEventObject
 >;
 
-export type StakeOperationsPausedUpdatedEventFilter =
-  TypedEventFilter<StakeOperationsPausedUpdatedEvent>;
-
-export interface StakeReservationReleasedEventObject {
-  intentHash: string;
-  staker: string;
-  amount: BigNumber;
-  totalReserved: BigNumber;
-}
-export type StakeReservationReleasedEvent = TypedEvent<
-  [string, string, BigNumber, BigNumber],
-  StakeReservationReleasedEventObject
->;
-
-export type StakeReservationReleasedEventFilter =
-  TypedEventFilter<StakeReservationReleasedEvent>;
-
-export interface StakeReservationUpdatedEventObject {
-  intentHash: string;
-  staker: string;
-  previousAmount: BigNumber;
-  newAmount: BigNumber;
-  totalReserved: BigNumber;
-  releaseTime: BigNumber;
-}
-export type StakeReservationUpdatedEvent = TypedEvent<
-  [string, string, BigNumber, BigNumber, BigNumber, BigNumber],
-  StakeReservationUpdatedEventObject
->;
-
-export type StakeReservationUpdatedEventFilter =
-  TypedEventFilter<StakeReservationUpdatedEvent>;
-
-export interface StakeReservedEventObject {
-  intentHash: string;
-  staker: string;
-  controller: string;
-  amount: BigNumber;
-  totalReserved: BigNumber;
-  releaseTime: BigNumber;
-}
-export type StakeReservedEvent = TypedEvent<
-  [string, string, string, BigNumber, BigNumber, BigNumber],
-  StakeReservedEventObject
->;
-
-export type StakeReservedEventFilter = TypedEventFilter<StakeReservedEvent>;
-
-export interface StakeSlashedEventObject {
-  intentHash: string;
-  staker: string;
-  maker: string;
-  amount: BigNumber;
-  remainingStake: BigNumber;
-  remainingReservation: BigNumber;
-}
-export type StakeSlashedEvent = TypedEvent<
-  [string, string, string, BigNumber, BigNumber, BigNumber],
-  StakeSlashedEventObject
->;
-
-export type StakeSlashedEventFilter = TypedEventFilter<StakeSlashedEvent>;
-
-export interface StakeWithdrawalCancelledEventObject {
-  stakeOwner: string;
-  amount: BigNumber;
-}
-export type StakeWithdrawalCancelledEvent = TypedEvent<
-  [string, BigNumber],
-  StakeWithdrawalCancelledEventObject
->;
-
-export type StakeWithdrawalCancelledEventFilter =
-  TypedEventFilter<StakeWithdrawalCancelledEvent>;
-
-export interface StakeWithdrawalRequestedEventObject {
-  stakeOwner: string;
-  amount: BigNumber;
-  requestedAt: BigNumber;
-  availableAt: BigNumber;
-}
-export type StakeWithdrawalRequestedEvent = TypedEvent<
-  [string, BigNumber, BigNumber, BigNumber],
-  StakeWithdrawalRequestedEventObject
->;
-
-export type StakeWithdrawalRequestedEventFilter =
-  TypedEventFilter<StakeWithdrawalRequestedEvent>;
-
-export interface StakeWithdrawnEventObject {
-  staker: string;
-  recipient: string;
-  amount: BigNumber;
-}
-export type StakeWithdrawnEvent = TypedEvent<
-  [string, string, BigNumber],
-  StakeWithdrawnEventObject
->;
-
-export type StakeWithdrawnEventFilter = TypedEventFilter<StakeWithdrawnEvent>;
+export type StakeWithdrawnEventFilter = TypedEventFilter<StakeWithdrawnEvent>;
 
 export interface TakerAuthorizationUpdatedEventObject {
   stakeOwner: string;
@@ -1044,33 +652,22 @@ export interface IStakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    activeIntentCount(
+    authorizedTakers(
       _stakeOwner: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
-
-    allowedStakeOwner(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
-    ): Promise<[string]>;
-
-    authorizeDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    ): Promise<[boolean]>;
 
-    cancelExit(
+    cancelControllerProposal(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    cancelStakeWithdrawal(
+    claim(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    claimableCompensation(
-      _maker: PromiseOrValue<string>,
+    claimable(
+      _beneficiary: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
 
@@ -1080,134 +677,97 @@ export interface IStakeVault extends BaseContract {
 
     controller(overrides?: CallOverrides): Promise<[string]>;
 
-    depositStake(
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    controllerChangeDelay(overrides?: CallOverrides): Promise<[BigNumber]>;
 
-    depositStakeFor(
-      _taker: PromiseOrValue<string>,
+    depositStake(
       _amount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    eligibleStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
-
     freeStake(
-      _staker: PromiseOrValue<string>,
+      _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
 
-    getDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
-    ): Promise<[IStakeVault.DeferredPayoutStructOutput]>;
-
-    getExitRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<[IStakeVault.ExitRequestStructOutput]>;
-
-    getIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
-    ): Promise<[IStakeVault.IntentCapacityStructOutput]>;
-
-    getReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
-    ): Promise<[IStakeVault.ReservationStructOutput]>;
+    fundLock(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
+      _amount: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
 
-    getStakeWithdrawalRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<[IStakeVault.StakeWithdrawalRequestStructOutput]>;
+    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>;
 
-    isExiting(
-      _staker: PromiseOrValue<string>,
+    isLockMature(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<[boolean]>;
 
-    proposeController(
-      _controller: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    recordDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
+    lockStake(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
       _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    releaseDeferredPayoutAuthorization(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    lockedStake(
+      _stakeOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
 
-    releaseIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    locks(
+      _lockId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, BigNumber, BigNumber] & {
+        stakeOwner: string;
+        amount: BigNumber;
+        maturesAt: BigNumber;
+      }
+    >;
 
-    releaseReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    pendingController(overrides?: CallOverrides): Promise<[string]>;
 
-    requestExit(
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    pendingControllerValidAt(overrides?: CallOverrides): Promise<[BigNumber]>;
 
-    requestStakeWithdrawal(
-      _amount: PromiseOrValue<BigNumberish>,
+    proposeController(
+      _controller: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    reserveIntentCapacity(
-      _stakeOwner: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _limit: PromiseOrValue<BigNumberish>,
+    resizeLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _newAmount: PromiseOrValue<BigNumberish>,
+      _newMaturesAt: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    reserveStake(
-      _staker: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
+    resolveLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _claims: IStakeVault.ClaimStruct[],
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    reservedStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
-
-    setAllowedStakeOwner(
+    selectStakeOwner(
       _stakeOwner: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    setStakeDelegationEnabled(
-      _enabled: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    setStakeOperationsPaused(
-      _depositsPaused: PromiseOrValue<boolean>,
-      _reservationsPaused: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    selectedStakeOwner(
+      _taker: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
 
     setTakerAuthorization(
       _taker: PromiseOrValue<string>,
@@ -1215,36 +775,11 @@ export interface IStakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    setTakerAuthorizations(
-      _takers: PromiseOrValue<string>[],
-      _authorized: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    slashDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _maker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    slashReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _maker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
     stakeBalance(
-      _staker: PromiseOrValue<string>,
+      _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
 
-    stakeDelegationEnabled(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<[boolean]>;
-
     stakeOwnerOf(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
@@ -1252,39 +787,21 @@ export interface IStakeVault extends BaseContract {
 
     stakeToken(overrides?: CallOverrides): Promise<[string]>;
 
-    totalLiabilities(overrides?: CallOverrides): Promise<[BigNumber]>;
+    totalAccounted(overrides?: CallOverrides): Promise<[BigNumber]>;
 
-    updateReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _newAmount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    totalClaimable(overrides?: CallOverrides): Promise<[BigNumber]>;
 
-    withdrawCompensation(
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    totalStaked(overrides?: CallOverrides): Promise<[BigNumber]>;
 
-    withdrawDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    withdrawDeferredPayouts(
-      _intentHashes: PromiseOrValue<BytesLike>[],
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    unaccountedBalance(overrides?: CallOverrides): Promise<[BigNumber]>;
 
-    withdrawRequestedStake(
-      _recipient: PromiseOrValue<string>,
+    unlockStake(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
     withdrawStake(
-      _recipient: PromiseOrValue<string>,
+      _amount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
   };
@@ -1293,33 +810,22 @@ export interface IStakeVault extends BaseContract {
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  activeIntentCount(
+  authorizedTakers(
     _stakeOwner: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  allowedStakeOwner(
     _taker: PromiseOrValue<string>,
     overrides?: CallOverrides
-  ): Promise<string>;
-
-  authorizeDeferredPayout(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _beneficiary: PromiseOrValue<string>,
-    _releaseTime: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  ): Promise<boolean>;
 
-  cancelExit(
+  cancelControllerProposal(
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  cancelStakeWithdrawal(
+  claim(
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  claimableCompensation(
-    _maker: PromiseOrValue<string>,
+  claimable(
+    _beneficiary: PromiseOrValue<string>,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
@@ -1329,134 +835,97 @@ export interface IStakeVault extends BaseContract {
 
   controller(overrides?: CallOverrides): Promise<string>;
 
-  depositStake(
-    _amount: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  controllerChangeDelay(overrides?: CallOverrides): Promise<BigNumber>;
 
-  depositStakeFor(
-    _taker: PromiseOrValue<string>,
+  depositStake(
     _amount: PromiseOrValue<BigNumberish>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  eligibleStake(
-    _staker: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
   freeStake(
-    _staker: PromiseOrValue<string>,
+    _stakeOwner: PromiseOrValue<string>,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
-  getDeferredPayout(
-    _intentHash: PromiseOrValue<BytesLike>,
-    overrides?: CallOverrides
-  ): Promise<IStakeVault.DeferredPayoutStructOutput>;
-
-  getExitRequest(
-    _staker: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<IStakeVault.ExitRequestStructOutput>;
-
-  getIntentCapacity(
-    _intentHash: PromiseOrValue<BytesLike>,
-    overrides?: CallOverrides
-  ): Promise<IStakeVault.IntentCapacityStructOutput>;
-
-  getReservation(
-    _intentHash: PromiseOrValue<BytesLike>,
-    overrides?: CallOverrides
-  ): Promise<IStakeVault.ReservationStructOutput>;
+  fundLock(
+    _stakeOwner: PromiseOrValue<string>,
+    _lockId: PromiseOrValue<BytesLike>,
+    _amount: PromiseOrValue<BigNumberish>,
+    _maturesAt: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
 
-  getStakeWithdrawalRequest(
-    _staker: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<IStakeVault.StakeWithdrawalRequestStructOutput>;
+  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>;
 
-  isExiting(
-    _staker: PromiseOrValue<string>,
+  isLockMature(
+    _lockId: PromiseOrValue<BytesLike>,
     overrides?: CallOverrides
   ): Promise<boolean>;
 
-  proposeController(
-    _controller: PromiseOrValue<string>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  recordDeferredPayout(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _beneficiary: PromiseOrValue<string>,
+  lockStake(
+    _stakeOwner: PromiseOrValue<string>,
+    _lockId: PromiseOrValue<BytesLike>,
     _amount: PromiseOrValue<BigNumberish>,
-    _releaseTime: PromiseOrValue<BigNumberish>,
+    _maturesAt: PromiseOrValue<BigNumberish>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  releaseDeferredPayoutAuthorization(
-    _intentHash: PromiseOrValue<BytesLike>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  lockedStake(
+    _stakeOwner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
 
-  releaseIntentCapacity(
-    _intentHash: PromiseOrValue<BytesLike>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  locks(
+    _lockId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<
+    [string, BigNumber, BigNumber] & {
+      stakeOwner: string;
+      amount: BigNumber;
+      maturesAt: BigNumber;
+    }
+  >;
 
-  releaseReservation(
-    _intentHash: PromiseOrValue<BytesLike>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  pendingController(overrides?: CallOverrides): Promise<string>;
 
-  requestExit(
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  pendingControllerValidAt(overrides?: CallOverrides): Promise<BigNumber>;
 
-  requestStakeWithdrawal(
-    _amount: PromiseOrValue<BigNumberish>,
+  proposeController(
+    _controller: PromiseOrValue<string>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  reserveIntentCapacity(
-    _stakeOwner: PromiseOrValue<string>,
-    _intentHash: PromiseOrValue<BytesLike>,
-    _limit: PromiseOrValue<BigNumberish>,
+  resizeLock(
+    _lockId: PromiseOrValue<BytesLike>,
+    _newAmount: PromiseOrValue<BigNumberish>,
+    _newMaturesAt: PromiseOrValue<BigNumberish>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  reserveStake(
-    _staker: PromiseOrValue<string>,
-    _intentHash: PromiseOrValue<BytesLike>,
-    _amount: PromiseOrValue<BigNumberish>,
-    _releaseTime: PromiseOrValue<BigNumberish>,
+  resolveLock(
+    _lockId: PromiseOrValue<BytesLike>,
+    _claims: IStakeVault.ClaimStruct[],
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  reservedStake(
-    _staker: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  setAllowedStakeOwner(
+  selectStakeOwner(
     _stakeOwner: PromiseOrValue<string>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  setStakeDelegationEnabled(
-    _enabled: PromiseOrValue<boolean>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  setStakeOperationsPaused(
-    _depositsPaused: PromiseOrValue<boolean>,
-    _reservationsPaused: PromiseOrValue<boolean>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  selectedStakeOwner(
+    _taker: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string>;
 
   setTakerAuthorization(
     _taker: PromiseOrValue<string>,
@@ -1464,36 +933,11 @@ export interface IStakeVault extends BaseContract {
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  setTakerAuthorizations(
-    _takers: PromiseOrValue<string>[],
-    _authorized: PromiseOrValue<boolean>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  slashDeferredPayout(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _maker: PromiseOrValue<string>,
-    _amount: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  slashReservation(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _maker: PromiseOrValue<string>,
-    _amount: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
   stakeBalance(
-    _staker: PromiseOrValue<string>,
+    _stakeOwner: PromiseOrValue<string>,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
-  stakeDelegationEnabled(
-    _taker: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<boolean>;
-
   stakeOwnerOf(
     _taker: PromiseOrValue<string>,
     overrides?: CallOverrides
@@ -1501,68 +945,39 @@ export interface IStakeVault extends BaseContract {
 
   stakeToken(overrides?: CallOverrides): Promise<string>;
 
-  totalLiabilities(overrides?: CallOverrides): Promise<BigNumber>;
-
-  updateReservation(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _newAmount: PromiseOrValue<BigNumberish>,
-    _releaseTime: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  totalAccounted(overrides?: CallOverrides): Promise<BigNumber>;
 
-  withdrawCompensation(
-    _recipient: PromiseOrValue<string>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  totalClaimable(overrides?: CallOverrides): Promise<BigNumber>;
 
-  withdrawDeferredPayout(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _recipient: PromiseOrValue<string>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
 
-  withdrawDeferredPayouts(
-    _intentHashes: PromiseOrValue<BytesLike>[],
-    _recipient: PromiseOrValue<string>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  unaccountedBalance(overrides?: CallOverrides): Promise<BigNumber>;
 
-  withdrawRequestedStake(
-    _recipient: PromiseOrValue<string>,
+  unlockStake(
+    _lockId: PromiseOrValue<BytesLike>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
   withdrawStake(
-    _recipient: PromiseOrValue<string>,
+    _amount: PromiseOrValue<BigNumberish>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
   callStatic: {
     acceptController(overrides?: CallOverrides): Promise<void>;
 
-    activeIntentCount(
+    authorizedTakers(
       _stakeOwner: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    allowedStakeOwner(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
-    ): Promise<string>;
-
-    authorizeDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<boolean>;
 
-    cancelExit(overrides?: CallOverrides): Promise<void>;
+    cancelControllerProposal(overrides?: CallOverrides): Promise<void>;
 
-    cancelStakeWithdrawal(overrides?: CallOverrides): Promise<void>;
+    claim(overrides?: CallOverrides): Promise<void>;
 
-    claimableCompensation(
-      _maker: PromiseOrValue<string>,
+    claimable(
+      _beneficiary: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
@@ -1570,132 +985,97 @@ export interface IStakeVault extends BaseContract {
 
     controller(overrides?: CallOverrides): Promise<string>;
 
-    depositStake(
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<void>;
+    controllerChangeDelay(overrides?: CallOverrides): Promise<BigNumber>;
 
-    depositStakeFor(
-      _taker: PromiseOrValue<string>,
+    depositStake(
       _amount: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    eligibleStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     freeStake(
-      _staker: PromiseOrValue<string>,
+      _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
-    ): Promise<IStakeVault.DeferredPayoutStructOutput>;
-
-    getExitRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<IStakeVault.ExitRequestStructOutput>;
-
-    getIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
-    ): Promise<IStakeVault.IntentCapacityStructOutput>;
-
-    getReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
+    fundLock(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
+      _amount: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
-    ): Promise<IStakeVault.ReservationStructOutput>;
+    ): Promise<void>;
 
-    getStakeWithdrawalRequest(
-      _staker: PromiseOrValue<string>,
+    increaseLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _additionalAmount: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
-    ): Promise<IStakeVault.StakeWithdrawalRequestStructOutput>;
+    ): Promise<void>;
 
     initializeController(
       _controller: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    isExiting(
-      _staker: PromiseOrValue<string>,
+    isLockMature(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<boolean>;
 
-    proposeController(
-      _controller: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    recordDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
+    lockStake(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
       _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    releaseDeferredPayoutAuthorization(
-      _intentHash: PromiseOrValue<BytesLike>,
+    lockedStake(
+      _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<BigNumber>;
 
-    releaseIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
+    locks(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<
+      [string, BigNumber, BigNumber] & {
+        stakeOwner: string;
+        amount: BigNumber;
+        maturesAt: BigNumber;
+      }
+    >;
 
-    releaseReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
-    ): Promise<void>;
+    pendingController(overrides?: CallOverrides): Promise<string>;
 
-    requestExit(overrides?: CallOverrides): Promise<void>;
+    pendingControllerValidAt(overrides?: CallOverrides): Promise<BigNumber>;
 
-    requestStakeWithdrawal(
-      _amount: PromiseOrValue<BigNumberish>,
+    proposeController(
+      _controller: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    reserveIntentCapacity(
-      _stakeOwner: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _limit: PromiseOrValue<BigNumberish>,
+    resizeLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _newAmount: PromiseOrValue<BigNumberish>,
+      _newMaturesAt: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    reserveStake(
-      _staker: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
+    resolveLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _claims: IStakeVault.ClaimStruct[],
       overrides?: CallOverrides
     ): Promise<void>;
 
-    reservedStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    setAllowedStakeOwner(
+    selectStakeOwner(
       _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    setStakeDelegationEnabled(
-      _enabled: PromiseOrValue<boolean>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    setStakeOperationsPaused(
-      _depositsPaused: PromiseOrValue<boolean>,
-      _reservationsPaused: PromiseOrValue<boolean>,
+    selectedStakeOwner(
+      _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<string>;
 
     setTakerAuthorization(
       _taker: PromiseOrValue<string>,
@@ -1703,36 +1083,11 @@ export interface IStakeVault extends BaseContract {
       overrides?: CallOverrides
     ): Promise<void>;
 
-    setTakerAuthorizations(
-      _takers: PromiseOrValue<string>[],
-      _authorized: PromiseOrValue<boolean>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    slashDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _maker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    slashReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _maker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
     stakeBalance(
-      _staker: PromiseOrValue<string>,
+      _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    stakeDelegationEnabled(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<boolean>;
-
     stakeOwnerOf(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
@@ -1740,76 +1095,47 @@ export interface IStakeVault extends BaseContract {
 
     stakeToken(overrides?: CallOverrides): Promise<string>;
 
-    totalLiabilities(overrides?: CallOverrides): Promise<BigNumber>;
-
-    updateReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _newAmount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<void>;
+    totalAccounted(overrides?: CallOverrides): Promise<BigNumber>;
 
-    withdrawCompensation(
-      _recipient: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<void>;
+    totalClaimable(overrides?: CallOverrides): Promise<BigNumber>;
 
-    withdrawDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _recipient: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<void>;
+    totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
 
-    withdrawDeferredPayouts(
-      _intentHashes: PromiseOrValue<BytesLike>[],
-      _recipient: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
+    unaccountedBalance(overrides?: CallOverrides): Promise<BigNumber>;
 
-    withdrawRequestedStake(
-      _recipient: PromiseOrValue<string>,
+    unlockStake(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<void>;
 
     withdrawStake(
-      _recipient: PromiseOrValue<string>,
+      _amount: PromiseOrValue<BigNumberish>,
       overrides?: CallOverrides
     ): Promise<void>;
-  };
-
-  filters: {
-    "AllowedStakeOwnerUpdated(address,address)"(
-      taker?: PromiseOrValue<string> | null,
-      allowedStakeOwner?: PromiseOrValue<string> | null
-    ): AllowedStakeOwnerUpdatedEventFilter;
-    AllowedStakeOwnerUpdated(
-      taker?: PromiseOrValue<string> | null,
-      allowedStakeOwner?: PromiseOrValue<string> | null
-    ): AllowedStakeOwnerUpdatedEventFilter;
+  };
 
-    "CompensationCredited(bytes32,address,uint256,uint256)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      maker?: PromiseOrValue<string> | null,
+  filters: {
+    "ClaimCreated(bytes32,address,uint256,uint256)"(
+      lockId?: PromiseOrValue<BytesLike> | null,
+      beneficiary?: PromiseOrValue<string> | null,
       amount?: null,
       newClaimableBalance?: null
-    ): CompensationCreditedEventFilter;
-    CompensationCredited(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      maker?: PromiseOrValue<string> | null,
+    ): ClaimCreatedEventFilter;
+    ClaimCreated(
+      lockId?: PromiseOrValue<BytesLike> | null,
+      beneficiary?: PromiseOrValue<string> | null,
       amount?: null,
       newClaimableBalance?: null
-    ): CompensationCreditedEventFilter;
+    ): ClaimCreatedEventFilter;
 
-    "CompensationWithdrawn(address,address,uint256)"(
-      maker?: PromiseOrValue<string> | null,
-      recipient?: PromiseOrValue<string> | null,
+    "ClaimWithdrawn(address,uint256)"(
+      beneficiary?: PromiseOrValue<string> | null,
       amount?: null
-    ): CompensationWithdrawnEventFilter;
-    CompensationWithdrawn(
-      maker?: PromiseOrValue<string> | null,
-      recipient?: PromiseOrValue<string> | null,
+    ): ClaimWithdrawnEventFilter;
+    ClaimWithdrawn(
+      beneficiary?: PromiseOrValue<string> | null,
       amount?: null
-    ): CompensationWithdrawnEventFilter;
+    ): ClaimWithdrawnEventFilter;
 
     "ControllerAccepted(address,address)"(
       previousController?: PromiseOrValue<string> | null,
@@ -1827,6 +1153,13 @@ export interface IStakeVault extends BaseContract {
       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,
@@ -1838,239 +1171,129 @@ export interface IStakeVault extends BaseContract {
       validAt?: null
     ): ControllerProposedEventFilter;
 
-    "DeferredPayoutAuthorizationReleased(bytes32,address,address)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      controller?: PromiseOrValue<string> | null
-    ): DeferredPayoutAuthorizationReleasedEventFilter;
-    DeferredPayoutAuthorizationReleased(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      controller?: PromiseOrValue<string> | null
-    ): DeferredPayoutAuthorizationReleasedEventFilter;
-
-    "DeferredPayoutAuthorized(bytes32,address,address,uint64)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      controller?: PromiseOrValue<string> | null,
-      releaseTime?: null
-    ): DeferredPayoutAuthorizedEventFilter;
-    DeferredPayoutAuthorized(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      controller?: PromiseOrValue<string> | null,
-      releaseTime?: null
-    ): DeferredPayoutAuthorizedEventFilter;
-
-    "DeferredPayoutRecorded(bytes32,address,uint256,uint64)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      amount?: null,
-      releaseTime?: null
-    ): DeferredPayoutRecordedEventFilter;
-    DeferredPayoutRecorded(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      amount?: null,
-      releaseTime?: null
-    ): DeferredPayoutRecordedEventFilter;
-
-    "DeferredPayoutSlashed(bytes32,address,address,uint256,uint256)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      maker?: PromiseOrValue<string> | null,
-      amount?: null,
-      remainingAmount?: null
-    ): DeferredPayoutSlashedEventFilter;
-    DeferredPayoutSlashed(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      maker?: PromiseOrValue<string> | null,
-      amount?: null,
-      remainingAmount?: null
-    ): DeferredPayoutSlashedEventFilter;
-
-    "DeferredPayoutWithdrawn(bytes32,address,address,uint256)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      recipient?: PromiseOrValue<string> | null,
-      amount?: null
-    ): DeferredPayoutWithdrawnEventFilter;
-    DeferredPayoutWithdrawn(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      beneficiary?: PromiseOrValue<string> | null,
-      recipient?: PromiseOrValue<string> | null,
-      amount?: null
-    ): DeferredPayoutWithdrawnEventFilter;
-
-    "ExitCancelled(address)"(
-      staker?: PromiseOrValue<string> | null
-    ): ExitCancelledEventFilter;
-    ExitCancelled(
-      staker?: PromiseOrValue<string> | null
-    ): ExitCancelledEventFilter;
-
-    "ExitRequested(address,uint64,uint64)"(
-      staker?: PromiseOrValue<string> | null,
-      requestedAt?: null,
-      availableAt?: null
-    ): ExitRequestedEventFilter;
-    ExitRequested(
-      staker?: PromiseOrValue<string> | null,
-      requestedAt?: null,
-      availableAt?: null
-    ): ExitRequestedEventFilter;
-
-    "IntentCapacityReleased(bytes32,address,address,uint256)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      stakeOwner?: PromiseOrValue<string> | null,
-      controller?: PromiseOrValue<string> | null,
-      activeIntents?: null
-    ): IntentCapacityReleasedEventFilter;
-    IntentCapacityReleased(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      stakeOwner?: PromiseOrValue<string> | null,
-      controller?: PromiseOrValue<string> | null,
-      activeIntents?: null
-    ): IntentCapacityReleasedEventFilter;
-
-    "IntentCapacityReserved(bytes32,address,address,uint256)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
+    "LockFunded(bytes32,address,uint256,uint256)"(
+      lockId?: PromiseOrValue<BytesLike> | null,
       stakeOwner?: PromiseOrValue<string> | null,
-      controller?: PromiseOrValue<string> | null,
-      activeIntents?: null
-    ): IntentCapacityReservedEventFilter;
-    IntentCapacityReserved(
-      intentHash?: PromiseOrValue<BytesLike> | null,
+      amount?: null,
+      newStakeBalance?: null
+    ): LockFundedEventFilter;
+    LockFunded(
+      lockId?: PromiseOrValue<BytesLike> | null,
       stakeOwner?: PromiseOrValue<string> | null,
-      controller?: PromiseOrValue<string> | null,
-      activeIntents?: null
-    ): IntentCapacityReservedEventFilter;
-
-    "StakeDelegationEnabledUpdated(address,bool)"(
-      taker?: PromiseOrValue<string> | null,
-      enabled?: null
-    ): StakeDelegationEnabledUpdatedEventFilter;
-    StakeDelegationEnabledUpdated(
-      taker?: PromiseOrValue<string> | null,
-      enabled?: null
-    ): StakeDelegationEnabledUpdatedEventFilter;
+      amount?: null,
+      newStakeBalance?: null
+    ): LockFundedEventFilter;
 
     "StakeDeposited(address,uint256,uint256)"(
-      staker?: PromiseOrValue<string> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
       amount?: null,
       newStakeBalance?: null
     ): StakeDepositedEventFilter;
     StakeDeposited(
-      staker?: PromiseOrValue<string> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
       amount?: null,
       newStakeBalance?: null
     ): StakeDepositedEventFilter;
 
-    "StakeOperationsPausedUpdated(bool,bool)"(
-      depositsPaused?: null,
-      reservationsPaused?: null
-    ): StakeOperationsPausedUpdatedEventFilter;
-    StakeOperationsPausedUpdated(
-      depositsPaused?: null,
-      reservationsPaused?: null
-    ): StakeOperationsPausedUpdatedEventFilter;
-
-    "StakeReservationReleased(bytes32,address,uint256,uint256)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      staker?: PromiseOrValue<string> | null,
-      amount?: null,
-      totalReserved?: null
-    ): StakeReservationReleasedEventFilter;
-    StakeReservationReleased(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      staker?: PromiseOrValue<string> | null,
-      amount?: null,
-      totalReserved?: null
-    ): StakeReservationReleasedEventFilter;
+    "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;
 
-    "StakeReservationUpdated(bytes32,address,uint256,uint256,uint256,uint64)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      staker?: PromiseOrValue<string> | null,
+    "StakeLockResized(bytes32,address,uint256,uint256,uint64,uint64,uint256)"(
+      lockId?: PromiseOrValue<BytesLike> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
       previousAmount?: null,
       newAmount?: null,
-      totalReserved?: null,
-      releaseTime?: null
-    ): StakeReservationUpdatedEventFilter;
-    StakeReservationUpdated(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      staker?: PromiseOrValue<string> | null,
+      previousMaturity?: null,
+      newMaturity?: null,
+      totalLockedStake?: null
+    ): StakeLockResizedEventFilter;
+    StakeLockResized(
+      lockId?: PromiseOrValue<BytesLike> | null,
+      stakeOwner?: PromiseOrValue<string> | null,
       previousAmount?: null,
       newAmount?: null,
-      totalReserved?: null,
-      releaseTime?: null
-    ): StakeReservationUpdatedEventFilter;
-
-    "StakeReserved(bytes32,address,address,uint256,uint256,uint64)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      staker?: PromiseOrValue<string> | null,
-      controller?: PromiseOrValue<string> | null,
-      amount?: null,
-      totalReserved?: null,
-      releaseTime?: null
-    ): StakeReservedEventFilter;
-    StakeReserved(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      staker?: PromiseOrValue<string> | null,
-      controller?: PromiseOrValue<string> | null,
-      amount?: null,
-      totalReserved?: null,
-      releaseTime?: null
-    ): StakeReservedEventFilter;
-
-    "StakeSlashed(bytes32,address,address,uint256,uint256,uint256)"(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      staker?: PromiseOrValue<string> | null,
-      maker?: PromiseOrValue<string> | null,
-      amount?: null,
-      remainingStake?: null,
-      remainingReservation?: null
-    ): StakeSlashedEventFilter;
-    StakeSlashed(
-      intentHash?: PromiseOrValue<BytesLike> | null,
-      staker?: PromiseOrValue<string> | null,
-      maker?: PromiseOrValue<string> | null,
-      amount?: null,
-      remainingStake?: null,
-      remainingReservation?: null
-    ): StakeSlashedEventFilter;
+      previousMaturity?: null,
+      newMaturity?: null,
+      totalLockedStake?: null
+    ): StakeLockResizedEventFilter;
 
-    "StakeWithdrawalCancelled(address,uint256)"(
+    "StakeLockResolved(bytes32,address,uint256,uint256,uint256,uint256)"(
+      lockId?: PromiseOrValue<BytesLike> | null,
       stakeOwner?: PromiseOrValue<string> | null,
-      amount?: null
-    ): StakeWithdrawalCancelledEventFilter;
-    StakeWithdrawalCancelled(
+      lockAmount?: null,
+      unlockedAmount?: null,
+      claimedAmount?: null,
+      totalLockedStake?: null
+    ): StakeLockResolvedEventFilter;
+    StakeLockResolved(
+      lockId?: PromiseOrValue<BytesLike> | null,
       stakeOwner?: PromiseOrValue<string> | null,
-      amount?: null
-    ): StakeWithdrawalCancelledEventFilter;
+      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;
 
-    "StakeWithdrawalRequested(address,uint256,uint64,uint64)"(
+    "StakeUnlocked(bytes32,address,uint256,uint256)"(
+      lockId?: PromiseOrValue<BytesLike> | null,
       stakeOwner?: PromiseOrValue<string> | null,
       amount?: null,
-      requestedAt?: null,
-      availableAt?: null
-    ): StakeWithdrawalRequestedEventFilter;
-    StakeWithdrawalRequested(
+      totalLockedStake?: null
+    ): StakeUnlockedEventFilter;
+    StakeUnlocked(
+      lockId?: PromiseOrValue<BytesLike> | null,
       stakeOwner?: PromiseOrValue<string> | null,
       amount?: null,
-      requestedAt?: null,
-      availableAt?: null
-    ): StakeWithdrawalRequestedEventFilter;
+      totalLockedStake?: null
+    ): StakeUnlockedEventFilter;
 
-    "StakeWithdrawn(address,address,uint256)"(
-      staker?: PromiseOrValue<string> | null,
-      recipient?: PromiseOrValue<string> | null,
-      amount?: null
+    "StakeWithdrawn(address,uint256,uint256)"(
+      stakeOwner?: PromiseOrValue<string> | null,
+      amount?: null,
+      newStakeBalance?: null
     ): StakeWithdrawnEventFilter;
     StakeWithdrawn(
-      staker?: PromiseOrValue<string> | null,
-      recipient?: PromiseOrValue<string> | null,
-      amount?: null
+      stakeOwner?: PromiseOrValue<string> | null,
+      amount?: null,
+      newStakeBalance?: null
     ): StakeWithdrawnEventFilter;
 
     "TakerAuthorizationUpdated(address,address,bool)"(
@@ -2090,33 +1313,22 @@ export interface IStakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    activeIntentCount(
+    authorizedTakers(
       _stakeOwner: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    allowedStakeOwner(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    authorizeDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    cancelExit(
+    cancelControllerProposal(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    cancelStakeWithdrawal(
+    claim(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    claimableCompensation(
-      _maker: PromiseOrValue<string>,
+    claimable(
+      _beneficiary: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
@@ -2126,50 +1338,30 @@ export interface IStakeVault extends BaseContract {
 
     controller(overrides?: CallOverrides): Promise<BigNumber>;
 
-    depositStake(
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
+    controllerChangeDelay(overrides?: CallOverrides): Promise<BigNumber>;
 
-    depositStakeFor(
-      _taker: PromiseOrValue<string>,
+    depositStake(
       _amount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    eligibleStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     freeStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getExitRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
+      _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
+    fundLock(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
+      _amount: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    getStakeWithdrawalRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
+    increaseLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _additionalAmount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
     initializeController(
@@ -2177,82 +1369,59 @@ export interface IStakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    isExiting(
-      _staker: PromiseOrValue<string>,
+    isLockMature(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    proposeController(
-      _controller: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    recordDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
+    lockStake(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
       _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    releaseDeferredPayoutAuthorization(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    lockedStake(
+      _stakeOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    releaseIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    locks(
+      _lockId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    releaseReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
+    pendingController(overrides?: CallOverrides): Promise<BigNumber>;
 
-    requestExit(
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
+    pendingControllerValidAt(overrides?: CallOverrides): Promise<BigNumber>;
 
-    requestStakeWithdrawal(
-      _amount: PromiseOrValue<BigNumberish>,
+    proposeController(
+      _controller: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    reserveIntentCapacity(
-      _stakeOwner: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _limit: PromiseOrValue<BigNumberish>,
+    resizeLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _newAmount: PromiseOrValue<BigNumberish>,
+      _newMaturesAt: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    reserveStake(
-      _staker: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
+    resolveLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _claims: IStakeVault.ClaimStruct[],
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    reservedStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    setAllowedStakeOwner(
+    selectStakeOwner(
       _stakeOwner: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    setStakeDelegationEnabled(
-      _enabled: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    setStakeOperationsPaused(
-      _depositsPaused: PromiseOrValue<boolean>,
-      _reservationsPaused: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    selectedStakeOwner(
+      _taker: PromiseOrValue<string>,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
     setTakerAuthorization(
@@ -2261,33 +1430,8 @@ export interface IStakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    setTakerAuthorizations(
-      _takers: PromiseOrValue<string>[],
-      _authorized: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    slashDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _maker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    slashReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _maker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
     stakeBalance(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    stakeDelegationEnabled(
-      _taker: PromiseOrValue<string>,
+      _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
@@ -2298,39 +1442,21 @@ export interface IStakeVault extends BaseContract {
 
     stakeToken(overrides?: CallOverrides): Promise<BigNumber>;
 
-    totalLiabilities(overrides?: CallOverrides): Promise<BigNumber>;
-
-    updateReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _newAmount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
+    totalAccounted(overrides?: CallOverrides): Promise<BigNumber>;
 
-    withdrawCompensation(
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
+    totalClaimable(overrides?: CallOverrides): Promise<BigNumber>;
 
-    withdrawDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
+    totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
 
-    withdrawDeferredPayouts(
-      _intentHashes: PromiseOrValue<BytesLike>[],
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
+    unaccountedBalance(overrides?: CallOverrides): Promise<BigNumber>;
 
-    withdrawRequestedStake(
-      _recipient: PromiseOrValue<string>,
+    unlockStake(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
     withdrawStake(
-      _recipient: PromiseOrValue<string>,
+      _amount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
   };
@@ -2340,33 +1466,22 @@ export interface IStakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    activeIntentCount(
+    authorizedTakers(
       _stakeOwner: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    allowedStakeOwner(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    authorizeDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    cancelExit(
+    cancelControllerProposal(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    cancelStakeWithdrawal(
+    claim(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    claimableCompensation(
-      _maker: PromiseOrValue<string>,
+    claimable(
+      _beneficiary: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
@@ -2376,50 +1491,32 @@ export interface IStakeVault extends BaseContract {
 
     controller(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    depositStake(
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    controllerChangeDelay(
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    depositStakeFor(
-      _taker: PromiseOrValue<string>,
+    depositStake(
       _amount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    eligibleStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     freeStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getExitRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
+      _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
+    fundLock(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
+      _amount: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    getStakeWithdrawalRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
+    increaseLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _additionalAmount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
     initializeController(
@@ -2427,82 +1524,61 @@ export interface IStakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    isExiting(
-      _staker: PromiseOrValue<string>,
+    isLockMature(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    proposeController(
-      _controller: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    recordDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
+    lockStake(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
       _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    releaseDeferredPayoutAuthorization(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    lockedStake(
+      _stakeOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    releaseIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    locks(
+      _lockId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    releaseReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
+    pendingController(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    requestExit(
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    pendingControllerValidAt(
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    requestStakeWithdrawal(
-      _amount: PromiseOrValue<BigNumberish>,
+    proposeController(
+      _controller: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    reserveIntentCapacity(
-      _stakeOwner: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _limit: PromiseOrValue<BigNumberish>,
+    resizeLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _newAmount: PromiseOrValue<BigNumberish>,
+      _newMaturesAt: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    reserveStake(
-      _staker: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
+    resolveLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _claims: IStakeVault.ClaimStruct[],
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    reservedStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    setAllowedStakeOwner(
+    selectStakeOwner(
       _stakeOwner: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    setStakeDelegationEnabled(
-      _enabled: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    setStakeOperationsPaused(
-      _depositsPaused: PromiseOrValue<boolean>,
-      _reservationsPaused: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    selectedStakeOwner(
+      _taker: PromiseOrValue<string>,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
     setTakerAuthorization(
@@ -2511,33 +1587,8 @@ export interface IStakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    setTakerAuthorizations(
-      _takers: PromiseOrValue<string>[],
-      _authorized: PromiseOrValue<boolean>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    slashDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _maker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    slashReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _maker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
     stakeBalance(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    stakeDelegationEnabled(
-      _taker: PromiseOrValue<string>,
+      _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
@@ -2548,39 +1599,23 @@ export interface IStakeVault extends BaseContract {
 
     stakeToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    totalLiabilities(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    updateReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _newAmount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
+    totalAccounted(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    withdrawCompensation(
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
+    totalClaimable(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    withdrawDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
+    totalStaked(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    withdrawDeferredPayouts(
-      _intentHashes: PromiseOrValue<BytesLike>[],
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    unaccountedBalance(
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    withdrawRequestedStake(
-      _recipient: PromiseOrValue<string>,
+    unlockStake(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
     withdrawStake(
-      _recipient: PromiseOrValue<string>,
+      _amount: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
   };