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

package/types/contracts/StakeVault.ts

@@ -28,211 +28,104 @@ 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 StakeVaultInterface extends utils.Interface {
   functions: {
     "MIN_CONTROLLER_CHANGE_DELAY()": FunctionFragment;
+    "NEVER_MATURES()": FunctionFragment;
     "acceptController()": FunctionFragment;
-    "activeIntentCount(address)": FunctionFragment;
-    "allowedStakeOwner(address)": FunctionFragment;
-    "authorizeDeferredPayout(bytes32,address,uint64)": FunctionFragment;
-    "baseExitDelay()": FunctionFragment;
-    "cancelExit()": FunctionFragment;
-    "cancelStakeWithdrawal()": FunctionFragment;
-    "claimableCompensation(address)": FunctionFragment;
+    "acceptOwnership()": 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;
-    "depositsPaused()": 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;
     "owner()": FunctionFragment;
     "pendingController()": FunctionFragment;
     "pendingControllerValidAt()": FunctionFragment;
+    "pendingOwner()": FunctionFragment;
     "proposeController(address)": FunctionFragment;
-    "recordDeferredPayout(bytes32,address,uint256,uint64)": FunctionFragment;
-    "releaseDeferredPayoutAuthorization(bytes32)": FunctionFragment;
-    "releaseIntentCapacity(bytes32)": FunctionFragment;
-    "releaseReservation(bytes32)": FunctionFragment;
     "renounceOwnership()": FunctionFragment;
-    "requestExit()": FunctionFragment;
-    "requestStakeWithdrawal(uint256)": FunctionFragment;
-    "reservationsPaused()": 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;
-    "totalClaimableCompensation()": FunctionFragment;
-    "totalDeferredPayouts()": FunctionFragment;
-    "totalLiabilities()": FunctionFragment;
+    "totalAccounted()": FunctionFragment;
+    "totalClaimable()": FunctionFragment;
     "totalStaked()": FunctionFragment;
     "transferOwnership(address)": FunctionFragment;
-    "updateReservation(bytes32,uint256,uint64)": FunctionFragment;
-    "withdrawCompensation(address)": FunctionFragment;
-    "withdrawDeferredPayout(bytes32,address)": FunctionFragment;
-    "withdrawDeferredPayouts(bytes32[],address)": FunctionFragment;
-    "withdrawRequestedStake(address)": FunctionFragment;
-    "withdrawStake(address)": FunctionFragment;
+    "unaccountedBalance()": FunctionFragment;
+    "unlockStake(bytes32)": FunctionFragment;
+    "withdrawStake(uint256)": FunctionFragment;
   };
 
   getFunction(
     nameOrSignatureOrTopic:
       | "MIN_CONTROLLER_CHANGE_DELAY"
+      | "NEVER_MATURES"
       | "acceptController"
-      | "activeIntentCount"
-      | "allowedStakeOwner"
-      | "authorizeDeferredPayout"
-      | "baseExitDelay"
-      | "cancelExit"
-      | "cancelStakeWithdrawal"
-      | "claimableCompensation"
+      | "acceptOwnership"
+      | "authorizedTakers"
+      | "cancelControllerProposal"
+      | "claim"
+      | "claimable"
       | "clearStakeOwner"
       | "controller"
       | "controllerChangeDelay"
       | "depositStake"
-      | "depositStakeFor"
-      | "depositsPaused"
-      | "eligibleStake"
       | "freeStake"
-      | "getDeferredPayout"
-      | "getExitRequest"
-      | "getIntentCapacity"
-      | "getReservation"
-      | "getStakeWithdrawalRequest"
+      | "fundLock"
+      | "increaseLock"
       | "initializeController"
-      | "isExiting"
+      | "isLockMature"
+      | "lockStake"
+      | "lockedStake"
+      | "locks"
       | "owner"
       | "pendingController"
       | "pendingControllerValidAt"
+      | "pendingOwner"
       | "proposeController"
-      | "recordDeferredPayout"
-      | "releaseDeferredPayoutAuthorization"
-      | "releaseIntentCapacity"
-      | "releaseReservation"
       | "renounceOwnership"
-      | "requestExit"
-      | "requestStakeWithdrawal"
-      | "reservationsPaused"
-      | "reserveIntentCapacity"
-      | "reserveStake"
-      | "reservedStake"
-      | "setAllowedStakeOwner"
-      | "setStakeDelegationEnabled"
-      | "setStakeOperationsPaused"
+      | "resizeLock"
+      | "resolveLock"
+      | "selectStakeOwner"
+      | "selectedStakeOwner"
       | "setTakerAuthorization"
-      | "setTakerAuthorizations"
-      | "slashDeferredPayout"
-      | "slashReservation"
       | "stakeBalance"
-      | "stakeDelegationEnabled"
       | "stakeOwnerOf"
       | "stakeToken"
-      | "totalClaimableCompensation"
-      | "totalDeferredPayouts"
-      | "totalLiabilities"
+      | "totalAccounted"
+      | "totalClaimable"
       | "totalStaked"
       | "transferOwnership"
-      | "updateReservation"
-      | "withdrawCompensation"
-      | "withdrawDeferredPayout"
-      | "withdrawDeferredPayouts"
-      | "withdrawRequestedStake"
+      | "unaccountedBalance"
+      | "unlockStake"
       | "withdrawStake"
   ): FunctionFragment;
 
@@ -241,39 +134,28 @@ export interface StakeVaultInterface extends utils.Interface {
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "acceptController",
+    functionFragment: "NEVER_MATURES",
     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>
-    ]
+    functionFragment: "acceptController",
+    values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "baseExitDelay",
+    functionFragment: "acceptOwnership",
     values?: undefined
   ): 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(
@@ -292,165 +174,97 @@ export interface StakeVaultInterface extends utils.Interface {
     functionFragment: "depositStake",
     values: [PromiseOrValue<BigNumberish>]
   ): string;
-  encodeFunctionData(
-    functionFragment: "depositStakeFor",
-    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "depositsPaused",
-    values?: undefined
-  ): string;
-  encodeFunctionData(
-    functionFragment: "eligibleStake",
-    values: [PromiseOrValue<string>]
-  ): 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: "owner", values?: undefined): string;
-  encodeFunctionData(
-    functionFragment: "pendingController",
-    values?: undefined
-  ): string;
-  encodeFunctionData(
-    functionFragment: "pendingControllerValidAt",
-    values?: undefined
-  ): 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>]
+    functionFragment: "lockedStake",
+    values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "releaseIntentCapacity",
+    functionFragment: "locks",
     values: [PromiseOrValue<BytesLike>]
   ): string;
+  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
   encodeFunctionData(
-    functionFragment: "releaseReservation",
-    values: [PromiseOrValue<BytesLike>]
+    functionFragment: "pendingController",
+    values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "renounceOwnership",
+    functionFragment: "pendingControllerValidAt",
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "requestExit",
+    functionFragment: "pendingOwner",
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "requestStakeWithdrawal",
-    values: [PromiseOrValue<BigNumberish>]
+    functionFragment: "proposeController",
+    values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "reservationsPaused",
+    functionFragment: "renounceOwnership",
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "reserveIntentCapacity",
-    values: [
-      PromiseOrValue<string>,
-      PromiseOrValue<BytesLike>,
-      PromiseOrValue<BigNumberish>
-    ]
-  ): 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>]
@@ -460,15 +274,11 @@ export interface StakeVaultInterface extends utils.Interface {
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "totalClaimableCompensation",
-    values?: undefined
-  ): string;
-  encodeFunctionData(
-    functionFragment: "totalDeferredPayouts",
+    functionFragment: "totalAccounted",
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "totalLiabilities",
+    functionFragment: "totalClaimable",
     values?: undefined
   ): string;
   encodeFunctionData(
@@ -480,32 +290,16 @@ export interface StakeVaultInterface extends utils.Interface {
     values: [PromiseOrValue<string>]
   ): string;
   encodeFunctionData(
-    functionFragment: "updateReservation",
-    values: [
-      PromiseOrValue<BytesLike>,
-      PromiseOrValue<BigNumberish>,
-      PromiseOrValue<BigNumberish>
-    ]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "withdrawCompensation",
-    values: [PromiseOrValue<string>]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "withdrawDeferredPayout",
-    values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]
-  ): 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(
@@ -513,34 +307,27 @@ export interface StakeVaultInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "acceptController",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "activeIntentCount",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "allowedStakeOwner",
+    functionFragment: "NEVER_MATURES",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "authorizeDeferredPayout",
+    functionFragment: "acceptController",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "baseExitDelay",
+    functionFragment: "acceptOwnership",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "cancelExit", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "cancelStakeWithdrawal",
+    functionFragment: "authorizedTakers",
     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
@@ -554,44 +341,26 @@ export interface StakeVaultInterface extends utils.Interface {
     functionFragment: "depositStake",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(
-    functionFragment: "depositStakeFor",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "depositsPaused",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "eligibleStake",
-    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",
+    functionFragment: "increaseLock",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getReservation",
+    functionFragment: "initializeController",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getStakeWithdrawalRequest",
+    functionFragment: "isLockMature",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "lockStake", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "initializeController",
+    functionFragment: "lockedStake",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "isExiting", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "locks", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "pendingController",
@@ -602,104 +371,49 @@ export interface StakeVaultInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "proposeController",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "recordDeferredPayout",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "releaseDeferredPayoutAuthorization",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "releaseIntentCapacity",
+    functionFragment: "pendingOwner",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "releaseReservation",
+    functionFragment: "proposeController",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
     functionFragment: "renounceOwnership",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "resizeLock", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "requestExit",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "requestStakeWithdrawal",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "reservationsPaused",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "reserveIntentCapacity",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "reserveStake",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "reservedStake",
-    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: "totalClaimableCompensation",
+    functionFragment: "totalAccounted",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "totalDeferredPayouts",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "totalLiabilities",
+    functionFragment: "totalClaimable",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -711,23 +425,11 @@ export interface StakeVaultInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "updateReservation",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "withdrawCompensation",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "withdrawDeferredPayout",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "withdrawDeferredPayouts",
+    functionFragment: "unaccountedBalance",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "withdrawRequestedStake",
+    functionFragment: "unlockStake",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -736,108 +438,71 @@ export interface StakeVaultInterface 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;
+    "LockFunded(bytes32,address,uint256,uint256)": EventFragment;
+    "OwnershipTransferStarted(address,address)": EventFragment;
     "OwnershipTransferred(address,address)": EventFragment;
-    "StakeDelegationEnabledUpdated(address,bool)": 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"
+    nameOrSignatureOrTopic: "ControllerProposalCancelled"
   ): 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: "ControllerProposed"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "LockFunded"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "OwnershipTransferStarted"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
-  getEvent(
-    nameOrSignatureOrTopic: "StakeDelegationEnabledUpdated"
-  ): 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;
@@ -862,6 +527,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;
@@ -875,126 +551,34 @@ export type ControllerProposedEvent = TypedEvent<
 export type ControllerProposedEventFilter =
   TypedEventFilter<ControllerProposedEvent>;
 
-export interface DeferredPayoutAuthorizationReleasedEventObject {
-  intentHash: string;
-  beneficiary: string;
-  controller: string;
+export interface LockFundedEventObject {
+  lockId: string;
+  stakeOwner: string;
+  amount: BigNumber;
+  newStakeBalance: BigNumber;
 }
-export type DeferredPayoutAuthorizationReleasedEvent = TypedEvent<
-  [string, string, string],
-  DeferredPayoutAuthorizationReleasedEventObject
+export type LockFundedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  LockFundedEventObject
 >;
 
-export type DeferredPayoutAuthorizationReleasedEventFilter =
-  TypedEventFilter<DeferredPayoutAuthorizationReleasedEvent>;
+export type LockFundedEventFilter = TypedEventFilter<LockFundedEvent>;
 
-export interface DeferredPayoutAuthorizedEventObject {
-  intentHash: string;
-  beneficiary: string;
-  controller: string;
-  releaseTime: BigNumber;
+export interface OwnershipTransferStartedEventObject {
+  previousOwner: string;
+  newOwner: string;
 }
-export type DeferredPayoutAuthorizedEvent = TypedEvent<
-  [string, string, string, BigNumber],
-  DeferredPayoutAuthorizedEventObject
+export type OwnershipTransferStartedEvent = TypedEvent<
+  [string, string],
+  OwnershipTransferStartedEventObject
 >;
 
-export type DeferredPayoutAuthorizedEventFilter =
-  TypedEventFilter<DeferredPayoutAuthorizedEvent>;
+export type OwnershipTransferStartedEventFilter =
+  TypedEventFilter<OwnershipTransferStartedEvent>;
 
-export interface DeferredPayoutRecordedEventObject {
-  intentHash: string;
-  beneficiary: string;
-  amount: BigNumber;
-  releaseTime: BigNumber;
-}
-export type DeferredPayoutRecordedEvent = TypedEvent<
-  [string, string, BigNumber, BigNumber],
-  DeferredPayoutRecordedEventObject
->;
-
-export type DeferredPayoutRecordedEventFilter =
-  TypedEventFilter<DeferredPayoutRecordedEvent>;
-
-export interface DeferredPayoutSlashedEventObject {
-  intentHash: string;
-  beneficiary: string;
-  maker: string;
-  amount: BigNumber;
-  remainingAmount: BigNumber;
-}
-export type DeferredPayoutSlashedEvent = TypedEvent<
-  [string, string, string, BigNumber, BigNumber],
-  DeferredPayoutSlashedEventObject
->;
-
-export type DeferredPayoutSlashedEventFilter =
-  TypedEventFilter<DeferredPayoutSlashedEvent>;
-
-export interface DeferredPayoutWithdrawnEventObject {
-  intentHash: string;
-  beneficiary: string;
-  recipient: string;
-  amount: BigNumber;
-}
-export type DeferredPayoutWithdrawnEvent = TypedEvent<
-  [string, string, string, BigNumber],
-  DeferredPayoutWithdrawnEventObject
->;
-
-export type DeferredPayoutWithdrawnEventFilter =
-  TypedEventFilter<DeferredPayoutWithdrawnEvent>;
-
-export interface ExitCancelledEventObject {
-  staker: string;
-}
-export type ExitCancelledEvent = TypedEvent<[string], ExitCancelledEventObject>;
-
-export type ExitCancelledEventFilter = TypedEventFilter<ExitCancelledEvent>;
-
-export interface ExitRequestedEventObject {
-  staker: string;
-  requestedAt: BigNumber;
-  availableAt: BigNumber;
-}
-export type ExitRequestedEvent = TypedEvent<
-  [string, BigNumber, BigNumber],
-  ExitRequestedEventObject
->;
-
-export type ExitRequestedEventFilter = TypedEventFilter<ExitRequestedEvent>;
-
-export interface IntentCapacityReleasedEventObject {
-  intentHash: string;
-  stakeOwner: string;
-  controller: string;
-  activeIntents: BigNumber;
-}
-export type IntentCapacityReleasedEvent = TypedEvent<
-  [string, string, string, BigNumber],
-  IntentCapacityReleasedEventObject
->;
-
-export type IntentCapacityReleasedEventFilter =
-  TypedEventFilter<IntentCapacityReleasedEvent>;
-
-export interface IntentCapacityReservedEventObject {
-  intentHash: string;
-  stakeOwner: string;
-  controller: string;
-  activeIntents: BigNumber;
-}
-export type IntentCapacityReservedEvent = TypedEvent<
-  [string, string, string, BigNumber],
-  IntentCapacityReservedEventObject
->;
-
-export type IntentCapacityReservedEventFilter =
-  TypedEventFilter<IntentCapacityReservedEvent>;
-
-export interface OwnershipTransferredEventObject {
-  previousOwner: string;
-  newOwner: string;
+export interface OwnershipTransferredEventObject {
+  previousOwner: string;
+  newOwner: string;
 }
 export type OwnershipTransferredEvent = TypedEvent<
   [string, string],
@@ -1004,20 +588,8 @@ export type OwnershipTransferredEvent = TypedEvent<
 export type OwnershipTransferredEventFilter =
   TypedEventFilter<OwnershipTransferredEvent>;
 
-export interface StakeDelegationEnabledUpdatedEventObject {
-  taker: string;
-  enabled: boolean;
-}
-export type StakeDelegationEnabledUpdatedEvent = TypedEvent<
-  [string, boolean],
-  StakeDelegationEnabledUpdatedEventObject
->;
-
-export type StakeDelegationEnabledUpdatedEventFilter =
-  TypedEventFilter<StakeDelegationEnabledUpdatedEvent>;
-
 export interface StakeDepositedEventObject {
-  staker: string;
+  stakeOwner: string;
   amount: BigNumber;
   newStakeBalance: BigNumber;
 }
@@ -1028,111 +600,101 @@ export type StakeDepositedEvent = TypedEvent<
 
 export type StakeDepositedEventFilter = TypedEventFilter<StakeDepositedEvent>;
 
-export interface StakeOperationsPausedUpdatedEventObject {
-  depositsPaused: boolean;
-  reservationsPaused: boolean;
-}
-export type StakeOperationsPausedUpdatedEvent = TypedEvent<
-  [boolean, boolean],
-  StakeOperationsPausedUpdatedEventObject
->;
-
-export type StakeOperationsPausedUpdatedEventFilter =
-  TypedEventFilter<StakeOperationsPausedUpdatedEvent>;
-
-export interface StakeReservationReleasedEventObject {
-  intentHash: string;
-  staker: string;
-  amount: BigNumber;
-  totalReserved: BigNumber;
+export interface StakeLockIncreasedEventObject {
+  lockId: string;
+  stakeOwner: string;
+  previousAmount: BigNumber;
+  newAmount: BigNumber;
+  totalLockedStake: BigNumber;
 }
-export type StakeReservationReleasedEvent = TypedEvent<
-  [string, string, BigNumber, BigNumber],
-  StakeReservationReleasedEventObject
+export type StakeLockIncreasedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber, BigNumber],
+  StakeLockIncreasedEventObject
 >;
 
-export type StakeReservationReleasedEventFilter =
-  TypedEventFilter<StakeReservationReleasedEvent>;
+export type StakeLockIncreasedEventFilter =
+  TypedEventFilter<StakeLockIncreasedEvent>;
 
-export interface StakeReservationUpdatedEventObject {
-  intentHash: string;
-  staker: string;
+export interface StakeLockResizedEventObject {
+  lockId: string;
+  stakeOwner: string;
   previousAmount: BigNumber;
   newAmount: BigNumber;
-  totalReserved: BigNumber;
-  releaseTime: BigNumber;
+  previousMaturity: BigNumber;
+  newMaturity: BigNumber;
+  totalLockedStake: BigNumber;
 }
-export type StakeReservationUpdatedEvent = TypedEvent<
-  [string, string, BigNumber, BigNumber, BigNumber, BigNumber],
-  StakeReservationUpdatedEventObject
+export type StakeLockResizedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
+  StakeLockResizedEventObject
 >;
 
-export type StakeReservationUpdatedEventFilter =
-  TypedEventFilter<StakeReservationUpdatedEvent>;
+export type StakeLockResizedEventFilter =
+  TypedEventFilter<StakeLockResizedEvent>;
 
-export interface StakeReservedEventObject {
-  intentHash: string;
-  staker: string;
-  controller: string;
-  amount: BigNumber;
-  totalReserved: BigNumber;
-  releaseTime: BigNumber;
+export interface StakeLockResolvedEventObject {
+  lockId: string;
+  stakeOwner: string;
+  lockAmount: BigNumber;
+  unlockedAmount: BigNumber;
+  claimedAmount: BigNumber;
+  totalLockedStake: BigNumber;
 }
-export type StakeReservedEvent = TypedEvent<
-  [string, string, string, BigNumber, BigNumber, BigNumber],
-  StakeReservedEventObject
+export type StakeLockResolvedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber, BigNumber, BigNumber],
+  StakeLockResolvedEventObject
 >;
 
-export type StakeReservedEventFilter = TypedEventFilter<StakeReservedEvent>;
+export type StakeLockResolvedEventFilter =
+  TypedEventFilter<StakeLockResolvedEvent>;
 
-export interface StakeSlashedEventObject {
-  intentHash: string;
-  staker: string;
-  maker: string;
+export interface StakeLockedEventObject {
+  lockId: string;
+  stakeOwner: string;
   amount: BigNumber;
-  remainingStake: BigNumber;
-  remainingReservation: BigNumber;
+  maturesAt: BigNumber;
+  totalLockedStake: BigNumber;
 }
-export type StakeSlashedEvent = TypedEvent<
-  [string, string, string, BigNumber, BigNumber, BigNumber],
-  StakeSlashedEventObject
+export type StakeLockedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber, BigNumber],
+  StakeLockedEventObject
 >;
 
-export type StakeSlashedEventFilter = TypedEventFilter<StakeSlashedEvent>;
+export type StakeLockedEventFilter = TypedEventFilter<StakeLockedEvent>;
 
-export interface StakeWithdrawalCancelledEventObject {
-  stakeOwner: string;
-  amount: BigNumber;
+export interface StakeOwnerSelectedEventObject {
+  taker: string;
+  previousStakeOwner: string;
+  newStakeOwner: string;
 }
-export type StakeWithdrawalCancelledEvent = TypedEvent<
-  [string, BigNumber],
-  StakeWithdrawalCancelledEventObject
+export type StakeOwnerSelectedEvent = TypedEvent<
+  [string, string, string],
+  StakeOwnerSelectedEventObject
 >;
 
-export type StakeWithdrawalCancelledEventFilter =
-  TypedEventFilter<StakeWithdrawalCancelledEvent>;
+export type StakeOwnerSelectedEventFilter =
+  TypedEventFilter<StakeOwnerSelectedEvent>;
 
-export interface StakeWithdrawalRequestedEventObject {
+export interface StakeUnlockedEventObject {
+  lockId: string;
   stakeOwner: string;
   amount: BigNumber;
-  requestedAt: BigNumber;
-  availableAt: BigNumber;
+  totalLockedStake: BigNumber;
 }
-export type StakeWithdrawalRequestedEvent = TypedEvent<
-  [string, BigNumber, BigNumber, BigNumber],
-  StakeWithdrawalRequestedEventObject
+export type StakeUnlockedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  StakeUnlockedEventObject
 >;
 
-export type StakeWithdrawalRequestedEventFilter =
-  TypedEventFilter<StakeWithdrawalRequestedEvent>;
+export type StakeUnlockedEventFilter = TypedEventFilter<StakeUnlockedEvent>;
 
 export interface StakeWithdrawnEventObject {
-  staker: string;
-  recipient: string;
+  stakeOwner: string;
   amount: BigNumber;
+  newStakeBalance: BigNumber;
 }
 export type StakeWithdrawnEvent = TypedEvent<
-  [string, string, BigNumber],
+  [string, BigNumber, BigNumber],
   StakeWithdrawnEventObject
 >;
 
@@ -1182,38 +744,31 @@ export interface StakeVault extends BaseContract {
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
 
+    NEVER_MATURES(overrides?: CallOverrides): Promise<[BigNumber]>;
+
     acceptController(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    activeIntentCount(
-      arg0: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
-
-    allowedStakeOwner(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<[string]>;
-
-    authorizeDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
+    acceptOwnership(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    baseExitDelay(overrides?: CallOverrides): Promise<[BigNumber]>;
+    authorizedTakers(
+      arg0: PromiseOrValue<string>,
+      arg1: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
 
-    cancelExit(
+    cancelControllerProposal(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    cancelStakeWithdrawal(
+    claim(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    claimableCompensation(
+    claimable(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
@@ -1231,143 +786,96 @@ export interface StakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    depositStakeFor(
-      _taker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    depositsPaused(overrides?: CallOverrides): Promise<[boolean]>;
-
-    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]>;
 
+    lockStake(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
+      _amount: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    lockedStake(
+      arg0: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    locks(
+      arg0: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, BigNumber, BigNumber] & {
+        stakeOwner: string;
+        amount: BigNumber;
+        maturesAt: BigNumber;
+      }
+    >;
+
     owner(overrides?: CallOverrides): Promise<[string]>;
 
     pendingController(overrides?: CallOverrides): Promise<[string]>;
 
     pendingControllerValidAt(overrides?: CallOverrides): Promise<[BigNumber]>;
 
+    pendingOwner(overrides?: CallOverrides): Promise<[string]>;
+
     proposeController(
       _controller: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    recordDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    renounceOwnership(overrides?: CallOverrides): Promise<[void]>;
 
-    releaseDeferredPayoutAuthorization(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    releaseIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    releaseReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    renounceOwnership(
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    requestExit(
+    resizeLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _newAmount: PromiseOrValue<BigNumberish>,
+      _newMaturesAt: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    requestStakeWithdrawal(
-      _amount: PromiseOrValue<BigNumberish>,
+    resolveLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _claims: IStakeVault.ClaimStruct[],
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    reservationsPaused(overrides?: CallOverrides): Promise<[boolean]>;
-
-    reserveIntentCapacity(
+    selectStakeOwner(
       _stakeOwner: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _limit: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    reserveStake(
-      _staker: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    reservedStake(
+    selectedStakeOwner(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
-    ): Promise<[BigNumber]>;
-
-    setAllowedStakeOwner(
-      _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>;
+    ): Promise<[string]>;
 
     setTakerAuthorization(
       _taker: PromiseOrValue<string>,
@@ -1375,36 +883,11 @@ export interface StakeVault 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(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
 
-    stakeDelegationEnabled(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<[boolean]>;
-
     stakeOwnerOf(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
@@ -1412,11 +895,9 @@ export interface StakeVault extends BaseContract {
 
     stakeToken(overrides?: CallOverrides): Promise<[string]>;
 
-    totalClaimableCompensation(overrides?: CallOverrides): Promise<[BigNumber]>;
+    totalAccounted(overrides?: CallOverrides): Promise<[BigNumber]>;
 
-    totalDeferredPayouts(overrides?: CallOverrides): Promise<[BigNumber]>;
-
-    totalLiabilities(overrides?: CallOverrides): Promise<[BigNumber]>;
+    totalClaimable(overrides?: CallOverrides): Promise<[BigNumber]>;
 
     totalStaked(overrides?: CallOverrides): Promise<[BigNumber]>;
 
@@ -1425,75 +906,46 @@ export interface StakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<ContractTransaction>;
 
-    updateReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _newAmount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
-
-    withdrawCompensation(
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<ContractTransaction>;
+    unaccountedBalance(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>;
-
-    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>;
   };
 
   MIN_CONTROLLER_CHANGE_DELAY(overrides?: CallOverrides): Promise<BigNumber>;
 
+  NEVER_MATURES(overrides?: CallOverrides): Promise<BigNumber>;
+
   acceptController(
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  activeIntentCount(
-    arg0: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  allowedStakeOwner(
-    _taker: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<string>;
-
-  authorizeDeferredPayout(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _beneficiary: PromiseOrValue<string>,
-    _releaseTime: PromiseOrValue<BigNumberish>,
+  acceptOwnership(
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  baseExitDelay(overrides?: CallOverrides): Promise<BigNumber>;
+  authorizedTakers(
+    arg0: PromiseOrValue<string>,
+    arg1: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
 
-  cancelExit(
+  cancelControllerProposal(
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  cancelStakeWithdrawal(
+  claim(
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  claimableCompensation(
+  claimable(
     arg0: PromiseOrValue<string>,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
@@ -1511,143 +963,96 @@ export interface StakeVault extends BaseContract {
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  depositStakeFor(
-    _taker: PromiseOrValue<string>,
-    _amount: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  depositsPaused(overrides?: CallOverrides): Promise<boolean>;
-
-  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>;
 
+  lockStake(
+    _stakeOwner: PromiseOrValue<string>,
+    _lockId: PromiseOrValue<BytesLike>,
+    _amount: PromiseOrValue<BigNumberish>,
+    _maturesAt: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  lockedStake(
+    arg0: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  locks(
+    arg0: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<
+    [string, BigNumber, BigNumber] & {
+      stakeOwner: string;
+      amount: BigNumber;
+      maturesAt: BigNumber;
+    }
+  >;
+
   owner(overrides?: CallOverrides): Promise<string>;
 
   pendingController(overrides?: CallOverrides): Promise<string>;
 
   pendingControllerValidAt(overrides?: CallOverrides): Promise<BigNumber>;
 
+  pendingOwner(overrides?: CallOverrides): Promise<string>;
+
   proposeController(
     _controller: PromiseOrValue<string>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  recordDeferredPayout(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _beneficiary: PromiseOrValue<string>,
-    _amount: PromiseOrValue<BigNumberish>,
-    _releaseTime: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  releaseDeferredPayoutAuthorization(
-    _intentHash: PromiseOrValue<BytesLike>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  releaseIntentCapacity(
-    _intentHash: PromiseOrValue<BytesLike>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  releaseReservation(
-    _intentHash: PromiseOrValue<BytesLike>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  renounceOwnership(
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  renounceOwnership(overrides?: CallOverrides): Promise<void>;
 
-  requestExit(
+  resizeLock(
+    _lockId: PromiseOrValue<BytesLike>,
+    _newAmount: PromiseOrValue<BigNumberish>,
+    _newMaturesAt: PromiseOrValue<BigNumberish>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  requestStakeWithdrawal(
-    _amount: PromiseOrValue<BigNumberish>,
+  resolveLock(
+    _lockId: PromiseOrValue<BytesLike>,
+    _claims: IStakeVault.ClaimStruct[],
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  reservationsPaused(overrides?: CallOverrides): Promise<boolean>;
-
-  reserveIntentCapacity(
+  selectStakeOwner(
     _stakeOwner: PromiseOrValue<string>,
-    _intentHash: PromiseOrValue<BytesLike>,
-    _limit: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  reserveStake(
-    _staker: PromiseOrValue<string>,
-    _intentHash: PromiseOrValue<BytesLike>,
-    _amount: PromiseOrValue<BigNumberish>,
-    _releaseTime: PromiseOrValue<BigNumberish>,
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  reservedStake(
+  selectedStakeOwner(
     arg0: PromiseOrValue<string>,
     overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  setAllowedStakeOwner(
-    _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>;
+  ): Promise<string>;
 
   setTakerAuthorization(
     _taker: PromiseOrValue<string>,
@@ -1655,36 +1060,11 @@ export interface StakeVault 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(
     arg0: PromiseOrValue<string>,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
-  stakeDelegationEnabled(
-    _taker: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<boolean>;
-
   stakeOwnerOf(
     _taker: PromiseOrValue<string>,
     overrides?: CallOverrides
@@ -1692,11 +1072,9 @@ export interface StakeVault extends BaseContract {
 
   stakeToken(overrides?: CallOverrides): Promise<string>;
 
-  totalClaimableCompensation(overrides?: CallOverrides): Promise<BigNumber>;
+  totalAccounted(overrides?: CallOverrides): Promise<BigNumber>;
 
-  totalDeferredPayouts(overrides?: CallOverrides): Promise<BigNumber>;
-
-  totalLiabilities(overrides?: CallOverrides): Promise<BigNumber>;
+  totalClaimable(overrides?: CallOverrides): Promise<BigNumber>;
 
   totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
 
@@ -1705,69 +1083,38 @@ export interface StakeVault extends BaseContract {
     overrides?: Overrides & { from?: PromiseOrValue<string> }
   ): Promise<ContractTransaction>;
 
-  updateReservation(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _newAmount: PromiseOrValue<BigNumberish>,
-    _releaseTime: PromiseOrValue<BigNumberish>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  withdrawCompensation(
-    _recipient: PromiseOrValue<string>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  withdrawDeferredPayout(
-    _intentHash: PromiseOrValue<BytesLike>,
-    _recipient: PromiseOrValue<string>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
+  unaccountedBalance(overrides?: CallOverrides): Promise<BigNumber>;
 
-  withdrawDeferredPayouts(
-    _intentHashes: PromiseOrValue<BytesLike>[],
-    _recipient: PromiseOrValue<string>,
-    overrides?: Overrides & { from?: PromiseOrValue<string> }
-  ): Promise<ContractTransaction>;
-
-  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: {
     MIN_CONTROLLER_CHANGE_DELAY(overrides?: CallOverrides): Promise<BigNumber>;
 
-    acceptController(overrides?: CallOverrides): Promise<void>;
+    NEVER_MATURES(overrides?: CallOverrides): Promise<BigNumber>;
 
-    activeIntentCount(
-      arg0: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
+    acceptController(overrides?: CallOverrides): Promise<void>;
 
-    allowedStakeOwner(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<string>;
+    acceptOwnership(overrides?: CallOverrides): Promise<void>;
 
-    authorizeDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
+    authorizedTakers(
+      arg0: PromiseOrValue<string>,
+      arg1: PromiseOrValue<string>,
       overrides?: CallOverrides
-    ): Promise<void>;
-
-    baseExitDelay(overrides?: CallOverrides): Promise<BigNumber>;
+    ): Promise<boolean>;
 
-    cancelExit(overrides?: CallOverrides): Promise<void>;
+    cancelControllerProposal(overrides?: CallOverrides): Promise<void>;
 
-    cancelStakeWithdrawal(overrides?: CallOverrides): Promise<void>;
+    claim(overrides?: CallOverrides): Promise<void>;
 
-    claimableCompensation(
+    claimable(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
@@ -1783,139 +1130,96 @@ export interface StakeVault extends BaseContract {
       overrides?: CallOverrides
     ): Promise<void>;
 
-    depositStakeFor(
-      _taker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    depositsPaused(overrides?: CallOverrides): Promise<boolean>;
-
-    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>;
 
-    owner(overrides?: CallOverrides): Promise<string>;
-
-    pendingController(overrides?: CallOverrides): Promise<string>;
-
-    pendingControllerValidAt(overrides?: CallOverrides): Promise<BigNumber>;
-
-    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(
+      arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<BigNumber>;
 
-    releaseIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
+    locks(
+      arg0: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<
+      [string, BigNumber, BigNumber] & {
+        stakeOwner: string;
+        amount: BigNumber;
+        maturesAt: BigNumber;
+      }
+    >;
 
-    releaseReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
-    ): Promise<void>;
+    owner(overrides?: CallOverrides): Promise<string>;
 
-    renounceOwnership(overrides?: CallOverrides): Promise<void>;
+    pendingController(overrides?: CallOverrides): Promise<string>;
 
-    requestExit(overrides?: CallOverrides): Promise<void>;
+    pendingControllerValidAt(overrides?: CallOverrides): Promise<BigNumber>;
 
-    requestStakeWithdrawal(
-      _amount: PromiseOrValue<BigNumberish>,
+    pendingOwner(overrides?: CallOverrides): Promise<string>;
+
+    proposeController(
+      _controller: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<void>;
 
-    reservationsPaused(overrides?: CallOverrides): Promise<boolean>;
+    renounceOwnership(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(
-      arg0: 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(
+      arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<string>;
 
     setTakerAuthorization(
       _taker: PromiseOrValue<string>,
@@ -1923,36 +1227,11 @@ export interface StakeVault 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(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    stakeDelegationEnabled(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<boolean>;
-
     stakeOwnerOf(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
@@ -1960,11 +1239,9 @@ export interface StakeVault extends BaseContract {
 
     stakeToken(overrides?: CallOverrides): Promise<string>;
 
-    totalClaimableCompensation(overrides?: CallOverrides): Promise<BigNumber>;
-
-    totalDeferredPayouts(overrides?: CallOverrides): Promise<BigNumber>;
+    totalAccounted(overrides?: CallOverrides): Promise<BigNumber>;
 
-    totalLiabilities(overrides?: CallOverrides): Promise<BigNumber>;
+    totalClaimable(overrides?: CallOverrides): Promise<BigNumber>;
 
     totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
 
@@ -1973,74 +1250,41 @@ export interface StakeVault extends BaseContract {
       overrides?: CallOverrides
     ): Promise<void>;
 
-    updateReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _newAmount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    withdrawCompensation(
-      _recipient: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<void>;
+    unaccountedBalance(overrides?: CallOverrides): Promise<BigNumber>;
 
-    withdrawDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _recipient: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    withdrawDeferredPayouts(
-      _intentHashes: PromiseOrValue<BytesLike>[],
-      _recipient: PromiseOrValue<string>,
-      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,
+    "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,
@@ -2058,6 +1302,13 @@ export interface StakeVault 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,
@@ -2067,116 +1318,29 @@ export interface StakeVault extends BaseContract {
       currentController?: PromiseOrValue<string> | null,
       pendingController?: PromiseOrValue<string> | null,
       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;
+    ): ControllerProposedEventFilter;
 
-    "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;
+      amount?: null,
+      newStakeBalance?: null
+    ): LockFundedEventFilter;
+
+    "OwnershipTransferStarted(address,address)"(
+      previousOwner?: PromiseOrValue<string> | null,
+      newOwner?: PromiseOrValue<string> | null
+    ): OwnershipTransferStartedEventFilter;
+    OwnershipTransferStarted(
+      previousOwner?: PromiseOrValue<string> | null,
+      newOwner?: PromiseOrValue<string> | null
+    ): OwnershipTransferStartedEventFilter;
 
     "OwnershipTransferred(address,address)"(
       previousOwner?: PromiseOrValue<string> | null,
@@ -2187,130 +1351,116 @@ export interface StakeVault extends BaseContract {
       newOwner?: PromiseOrValue<string> | null
     ): OwnershipTransferredEventFilter;
 
-    "StakeDelegationEnabledUpdated(address,bool)"(
-      taker?: PromiseOrValue<string> | null,
-      enabled?: null
-    ): StakeDelegationEnabledUpdatedEventFilter;
-    StakeDelegationEnabledUpdated(
-      taker?: PromiseOrValue<string> | null,
-      enabled?: null
-    ): StakeDelegationEnabledUpdatedEventFilter;
-
     "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)"(
@@ -2328,38 +1478,31 @@ export interface StakeVault extends BaseContract {
   estimateGas: {
     MIN_CONTROLLER_CHANGE_DELAY(overrides?: CallOverrides): Promise<BigNumber>;
 
+    NEVER_MATURES(overrides?: CallOverrides): Promise<BigNumber>;
+
     acceptController(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    activeIntentCount(
-      arg0: PromiseOrValue<string>,
-      overrides?: CallOverrides
+    acceptOwnership(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    allowedStakeOwner(
-      _taker: PromiseOrValue<string>,
+    authorizedTakers(
+      arg0: PromiseOrValue<string>,
+      arg1: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    authorizeDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    baseExitDelay(overrides?: CallOverrides): Promise<BigNumber>;
-
-    cancelExit(
+    cancelControllerProposal(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    cancelStakeWithdrawal(
+    claim(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    claimableCompensation(
+    claimable(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
@@ -2377,56 +1520,50 @@ export interface StakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    depositStakeFor(
-      _taker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    depositsPaused(overrides?: CallOverrides): Promise<BigNumber>;
-
-    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
+    fundLock(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
+      _amount: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    getExitRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
+    increaseLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _additionalAmount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    getIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
+    initializeController(
+      _controller: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    getReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
+    isLockMature(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getStakeWithdrawalRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
+    lockStake(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
+      _amount: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    initializeController(
-      _controller: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    lockedStake(
+      arg0: PromiseOrValue<string>,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    isExiting(
-      _staker: PromiseOrValue<string>,
+    locks(
+      arg0: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
@@ -2436,121 +1573,49 @@ export interface StakeVault extends BaseContract {
 
     pendingControllerValidAt(overrides?: CallOverrides): Promise<BigNumber>;
 
+    pendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
+
     proposeController(
       _controller: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    recordDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    releaseDeferredPayoutAuthorization(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    releaseIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    releaseReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    renounceOwnership(
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
+    renounceOwnership(overrides?: CallOverrides): Promise<BigNumber>;
 
-    requestExit(
+    resizeLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _newAmount: PromiseOrValue<BigNumberish>,
+      _newMaturesAt: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    requestStakeWithdrawal(
-      _amount: PromiseOrValue<BigNumberish>,
+    resolveLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _claims: IStakeVault.ClaimStruct[],
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    reservationsPaused(overrides?: CallOverrides): Promise<BigNumber>;
-
-    reserveIntentCapacity(
+    selectStakeOwner(
       _stakeOwner: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _limit: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    reserveStake(
-      _staker: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    reservedStake(
+    selectedStakeOwner(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    setAllowedStakeOwner(
-      _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> }
-    ): Promise<BigNumber>;
-
     setTakerAuthorization(
       _taker: PromiseOrValue<string>,
       _authorized: PromiseOrValue<boolean>,
       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(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    stakeDelegationEnabled(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     stakeOwnerOf(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
@@ -2558,11 +1623,9 @@ export interface StakeVault extends BaseContract {
 
     stakeToken(overrides?: CallOverrides): Promise<BigNumber>;
 
-    totalClaimableCompensation(overrides?: CallOverrides): Promise<BigNumber>;
+    totalAccounted(overrides?: CallOverrides): Promise<BigNumber>;
 
-    totalDeferredPayouts(overrides?: CallOverrides): Promise<BigNumber>;
-
-    totalLiabilities(overrides?: CallOverrides): Promise<BigNumber>;
+    totalClaimable(overrides?: CallOverrides): Promise<BigNumber>;
 
     totalStaked(overrides?: CallOverrides): Promise<BigNumber>;
 
@@ -2571,37 +1634,15 @@ export interface StakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<BigNumber>;
 
-    updateReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _newAmount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    withdrawCompensation(
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<BigNumber>;
-
-    withdrawDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): 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>;
   };
@@ -2611,38 +1652,31 @@ export interface StakeVault extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    NEVER_MATURES(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     acceptController(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    activeIntentCount(
-      arg0: PromiseOrValue<string>,
-      overrides?: CallOverrides
+    acceptOwnership(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    allowedStakeOwner(
-      _taker: PromiseOrValue<string>,
+    authorizedTakers(
+      arg0: PromiseOrValue<string>,
+      arg1: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    authorizeDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    baseExitDelay(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    cancelExit(
+    cancelControllerProposal(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    cancelStakeWithdrawal(
+    claim(
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    claimableCompensation(
+    claimable(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
@@ -2662,56 +1696,50 @@ export interface StakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    depositStakeFor(
-      _taker: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    depositsPaused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    eligibleStake(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     freeStake(
-      _staker: PromiseOrValue<string>,
+      _stakeOwner: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getDeferredPayout(
-      _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>;
 
-    getExitRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
+    increaseLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _additionalAmount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    getIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: CallOverrides
+    initializeController(
+      _controller: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    getReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
+    isLockMature(
+      _lockId: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getStakeWithdrawalRequest(
-      _staker: PromiseOrValue<string>,
-      overrides?: CallOverrides
+    lockStake(
+      _stakeOwner: PromiseOrValue<string>,
+      _lockId: PromiseOrValue<BytesLike>,
+      _amount: PromiseOrValue<BigNumberish>,
+      _maturesAt: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    initializeController(
-      _controller: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    lockedStake(
+      arg0: PromiseOrValue<string>,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    isExiting(
-      _staker: PromiseOrValue<string>,
+    locks(
+      arg0: PromiseOrValue<BytesLike>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
@@ -2723,123 +1751,49 @@ export interface StakeVault extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    pendingOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     proposeController(
       _controller: PromiseOrValue<string>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    recordDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _beneficiary: PromiseOrValue<string>,
-      _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    releaseDeferredPayoutAuthorization(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    releaseIntentCapacity(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    releaseReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
+    renounceOwnership(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    renounceOwnership(
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    requestExit(
+    resizeLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _newAmount: PromiseOrValue<BigNumberish>,
+      _newMaturesAt: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    requestStakeWithdrawal(
-      _amount: PromiseOrValue<BigNumberish>,
+    resolveLock(
+      _lockId: PromiseOrValue<BytesLike>,
+      _claims: IStakeVault.ClaimStruct[],
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    reservationsPaused(
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    reserveIntentCapacity(
+    selectStakeOwner(
       _stakeOwner: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _limit: PromiseOrValue<BigNumberish>,
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    reserveStake(
-      _staker: PromiseOrValue<string>,
-      _intentHash: PromiseOrValue<BytesLike>,
-      _amount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    reservedStake(
+    selectedStakeOwner(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    setAllowedStakeOwner(
-      _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> }
-    ): Promise<PopulatedTransaction>;
-
     setTakerAuthorization(
       _taker: PromiseOrValue<string>,
       _authorized: PromiseOrValue<boolean>,
       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(
       arg0: PromiseOrValue<string>,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    stakeDelegationEnabled(
-      _taker: PromiseOrValue<string>,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     stakeOwnerOf(
       _taker: PromiseOrValue<string>,
       overrides?: CallOverrides
@@ -2847,15 +1801,9 @@ export interface StakeVault extends BaseContract {
 
     stakeToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    totalClaimableCompensation(
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    totalDeferredPayouts(
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
+    totalAccounted(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    totalLiabilities(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    totalClaimable(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     totalStaked(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
@@ -2864,37 +1812,17 @@ export interface StakeVault extends BaseContract {
       overrides?: Overrides & { from?: PromiseOrValue<string> }
     ): Promise<PopulatedTransaction>;
 
-    updateReservation(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _newAmount: PromiseOrValue<BigNumberish>,
-      _releaseTime: PromiseOrValue<BigNumberish>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    withdrawCompensation(
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): Promise<PopulatedTransaction>;
-
-    withdrawDeferredPayout(
-      _intentHash: PromiseOrValue<BytesLike>,
-      _recipient: PromiseOrValue<string>,
-      overrides?: Overrides & { from?: PromiseOrValue<string> }
-    ): 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>;
   };