@gearbox-protocol/sdk 14.12.0-next.33 → 14.12.0-next.35

package/dist/esm/sdk/accounts/withdrawal-compressor/AbstractWithdrawalCompressorContract.js

@@ -1,6 +1,7 @@
 import { isAddressEqual } from "viem";
 import { BaseContract } from "../../base/index.js";
-import { decodeDelayedIntent, encodeDelayedIntent } from "./intent-codec.js";
+import { AddressMap } from "../../utils/index.js";
+import { decodeDelayedIntent } from "./intent-codec.js";
 const iCreditAccountAbi = [
   {
     type: "function",
@@ -10,12 +11,23 @@ const iCreditAccountAbi = [
     stateMutability: "view"
   }
 ];
+const MAP_LABEL = "withdrawableAssets";
 class AbstractWithdrawalCompressorContract extends BaseContract {
   #sdk;
+  #withdrawableAssets;
   constructor(sdk, args) {
     super(sdk, args);
     this.#sdk = sdk;
   }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.hydrate}
+   **/
+  hydrate(state) {
+    this.#withdrawableAssets = new AddressMap(
+      Object.entries(state.withdrawableAssets),
+      MAP_LABEL
+    );
+  }
   /**
    * The contract is instantiated with the actual versioned ABI,
    * this cast is type-level only (see {@link CommonAbi}).
@@ -23,18 +35,35 @@ class AbstractWithdrawalCompressorContract extends BaseContract {
   get common() {
     return this.contract;
   }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.state}
+   **/
+  get state() {
+    return this.#withdrawableAssets ? { withdrawableAssets: this.#withdrawableAssets.asRecord() } : void 0;
+  }
   /**
    * {@inheritDoc IWithdrawalCompressorContract.getWithdrawableAssets}
    **/
-  async getWithdrawableAssets(creditManager) {
-    const resp = await this.common.read.getWithdrawableAssets([creditManager]);
-    return resp.map((a) => toWithdrawableAsset(a, creditManager));
+  getWithdrawableAssets(...creditManagers) {
+    const cache = this.#withdrawableAssets;
+    if (!cache) {
+      throw new Error(
+        "withdrawable assets are not loaded, call loadWithdrawableAssets first"
+      );
+    }
+    if (creditManagers.length === 0) {
+      return cache.values().flat();
+    }
+    return creditManagers.flatMap((cm) => cache.get(cm) ?? []);
   }
   /**
-   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawableAssetsBatch}
+   * {@inheritDoc IWithdrawalCompressorContract.loadWithdrawableAssets}
    **/
-  async getWithdrawableAssetsBatch(creditManagers) {
-    const cms = creditManagers ?? this.#sdk.marketRegister.creditManagers.map(
+  async loadWithdrawableAssets(force) {
+    if (this.#withdrawableAssets && !force) {
+      return this.getWithdrawableAssets();
+    }
+    const cms = this.#sdk.marketRegister.creditManagers.map(
       (cm) => cm.creditManager.address
     );
     const resp = await this.client.multicall({
@@ -49,22 +78,48 @@ class AbstractWithdrawalCompressorContract extends BaseContract {
       allowFailure: true,
       batchSize: 0
     });
-    return resp.flatMap((r, i) => {
+    const cache = new AddressMap(void 0, MAP_LABEL);
+    for (let i = 0; i < resp.length; i++) {
+      const r = resp[i];
       if (r.status !== "success") {
         this.logger?.warn(
           `failed to get withdrawable assets of credit manager ${cms[i]}: ${r.error}`
         );
-        return [];
+        continue;
       }
-      return r.result.map((a) => toWithdrawableAsset(a, cms[i]));
-    });
+      if (r.result.length > 0) {
+        cache.upsert(
+          cms[i],
+          r.result.map((a) => toWithdrawableAsset(a, cms[i]))
+        );
+      }
+    }
+    this.#withdrawableAssets = cache;
+    return this.getWithdrawableAssets();
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.findWithdrawableAssets}
+   **/
+  async findWithdrawableAssets(creditManager, token) {
+    await this.loadWithdrawableAssets();
+    return this.getWithdrawableAssets(creditManager).filter(
+      (a) => isAddressEqual(a.token, token)
+    );
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.findWithdrawableAssetsByPhantomToken}
+   **/
+  async findWithdrawableAssetsByPhantomToken(withdrawalPhantomToken) {
+    await this.loadWithdrawableAssets();
+    return this.getWithdrawableAssets().filter(
+      (a) => isAddressEqual(a.withdrawalPhantomToken, withdrawalPhantomToken)
+    );
   }
   /**
    * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalPhantomToken}
    **/
   async getWithdrawalPhantomToken(creditManager, token) {
-    const assets = await this.getWithdrawableAssets(creditManager);
-    const asset = assets.find((a) => isAddressEqual(a.token, token));
+    const [asset] = await this.findWithdrawableAssets(creditManager, token);
     if (!asset) {
       throw new Error(
         `token ${token} is not withdrawable from credit manager ${creditManager}`
@@ -72,6 +127,14 @@ class AbstractWithdrawalCompressorContract extends BaseContract {
     }
     return asset.withdrawalPhantomToken;
   }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalSourceToken}
+   **/
+  getWithdrawalSourceToken(withdrawalPhantomToken) {
+    return this.getWithdrawableAssets().find(
+      (a) => isAddressEqual(a.withdrawalPhantomToken, withdrawalPhantomToken)
+    )?.token;
+  }
   /**
    * {@inheritDoc IWithdrawalCompressorContract.getCurrentWithdrawals}
    **/
@@ -94,83 +157,80 @@ class AbstractWithdrawalCompressorContract extends BaseContract {
       batchSize: 0
     });
     return {
-      claimable: claimable.map(
-        (w) => toClaimableWithdrawal(w, creditManager, this.version >= 313)
-      ),
-      pending: pending.map((w) => toPendingWithdrawal(w, creditManager, this.version >= 313)).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
+      claimable: claimable.map((w) => toClaimableWithdrawal(w, creditManager)),
+      pending: pending.map((w) => toPendingWithdrawal(w, creditManager)).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
     };
   }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getExternalAccountCurrentWithdrawals}
+   **/
+  async getExternalAccountCurrentWithdrawals(_withdrawalToken, _account) {
+    this.#reportUnsupported("external account withdrawals");
+    return { claimable: [], pending: [] };
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalStatus}
+   **/
+  async getWithdrawalStatus(...redeemers) {
+    if (redeemers.length === 0) {
+      return [];
+    }
+    this.#reportUnsupported("withdrawal status");
+    return redeemers.map(() => "NULL");
+  }
   /**
    * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalRequestResult}
+   *
+   * Legacy compressors only support the 3-arg overload: `intent` and
+   * `withdrawalPhantomToken` are reported as unsupported (in non-strict mode
+   * the request is previewed without them).
    **/
-  async getWithdrawalRequestResult(creditAccount, token, amount, intent) {
-    const resp = intent ? await this.#getWithdrawalRequestResultWithIntent(
-      creditAccount,
-      token,
-      amount,
-      intent
-    ) : await this.common.read.getWithdrawalRequestResult([
+  async getWithdrawalRequestResult({
+    creditAccount,
+    token,
+    amount,
+    withdrawalPhantomToken,
+    intent
+  }) {
+    if (intent) {
+      this.#reportUnsupported("withdrawal intents");
+    } else if (withdrawalPhantomToken) {
+      this.#reportUnsupported("withdrawal config selection");
+    }
+    const resp = await this.common.read.getWithdrawalRequestResult([
       creditAccount,
       token,
       amount
     ]);
-    return {
-      token: resp.token,
-      amountIn: resp.amountIn,
-      outputs: [...resp.outputs],
-      requestCalls: [...resp.requestCalls],
-      claimableAt: resp.claimableAt
-    };
+    return toRequestableWithdrawal(resp);
   }
   /**
-   * Previews a delayed withdrawal request with an intent attached as
-   * `extraData`. Only supported on v313+ compressors; on older versions,
-   * throws if `sdk.strictContractTypes` is `true`, otherwise logs a warning
-   * and previews the request without the intent.
-   *
-   * The contract overload accepting `extraData` also requires the withdrawal
-   * phantom token, which is resolved here the same way the 3-arg overload
-   * does it internally: via `getWithdrawableAssets` of the account's credit
-   * manager.
+   * Reports that a feature is not supported by this compressor version:
+   * throws if `sdk.strictContractTypes` is `true`, otherwise logs a warning.
    **/
-  async #getWithdrawalRequestResultWithIntent(creditAccount, token, amount, intent) {
-    if (this.version < 313) {
-      const message = `withdrawal intents are not supported by ${this.name} v${this.version}`;
-      if (this.#sdk.strictContractTypes) {
-        throw new Error(message);
-      }
-      this.logger?.warn(`${message}, requesting withdrawal without intent`);
-      return this.common.read.getWithdrawalRequestResult([
-        creditAccount,
-        token,
-        amount
-      ]);
+  #reportUnsupported(feature) {
+    const message = `${feature} is not supported by ${this.name} v${this.version}`;
+    if (this.#sdk.strictContractTypes) {
+      throw new Error(message);
     }
-    const extraData = encodeDelayedIntent(intent);
-    const creditManager = await this.client.readContract({
-      address: creditAccount,
-      abi: iCreditAccountAbi,
-      functionName: "creditManager"
-    });
-    const withdrawalPhantomToken = await this.getWithdrawalPhantomToken(
-      creditManager,
-      token
-    );
-    return this.common.read.getWithdrawalRequestResult([
-      creditAccount,
-      token,
-      withdrawalPhantomToken,
-      amount,
-      extraData
-    ]);
+    this.logger?.warn(message);
   }
 }
 function toWithdrawableAsset(a, creditManager) {
   return { creditManager, ...a };
 }
-function toClaimableWithdrawal(w, creditManager, decodeIntent) {
+function toRequestableWithdrawal(resp) {
+  return {
+    token: resp.token,
+    amountIn: resp.amountIn,
+    outputs: [...resp.outputs],
+    requestCalls: [...resp.requestCalls],
+    claimableAt: resp.claimableAt
+  };
+}
+function toClaimableWithdrawal(w, creditManager) {
   let intent;
-  if (decodeIntent && w.extraData && w.extraData !== "0x") {
+  if (creditManager && w.extraData && w.extraData !== "0x") {
     intent = { ...decodeDelayedIntent(w.extraData), creditManager };
   }
   return {
@@ -182,9 +242,9 @@ function toClaimableWithdrawal(w, creditManager, decodeIntent) {
     intent
   };
 }
-function toPendingWithdrawal(w, creditManager, decodeIntent) {
+function toPendingWithdrawal(w, creditManager) {
   let intent;
-  if (decodeIntent && w.extraData && w.extraData !== "0x") {
+  if (creditManager && w.extraData && w.extraData !== "0x") {
     intent = { ...decodeDelayedIntent(w.extraData), creditManager };
   }
   return {
@@ -196,5 +256,9 @@ function toPendingWithdrawal(w, creditManager, decodeIntent) {
   };
 }
 export {
-  AbstractWithdrawalCompressorContract
+  AbstractWithdrawalCompressorContract,
+  iCreditAccountAbi,
+  toClaimableWithdrawal,
+  toPendingWithdrawal,
+  toRequestableWithdrawal
 };

package/dist/esm/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV313Contract.js

@@ -1,6 +1,27 @@
 import { iWithdrawalCompressorV313Abi } from "../../../abi/IWithdrawalCompressorV313.js";
-import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
+import {
+  AbstractWithdrawalCompressorContract,
+  iCreditAccountAbi,
+  toClaimableWithdrawal,
+  toPendingWithdrawal,
+  toRequestableWithdrawal
+} from "./AbstractWithdrawalCompressorContract.js";
+import { encodeDelayedIntent } from "./intent-codec.js";
+import { toWithdrawalStatus } from "./types.js";
 const abi = iWithdrawalCompressorV313Abi;
+const iWithdrawalStatusBatchAbi = [
+  {
+    type: "function",
+    name: "getWithdrawalStatus",
+    inputs: [
+      { name: "redeemers", type: "address[]", internalType: "address[]" }
+    ],
+    outputs: [
+      { name: "", type: "uint8[]", internalType: "enum WithdrawalStatus[]" }
+    ],
+    stateMutability: "view"
+  }
+];
 class WithdrawalCompressorV313Contract extends AbstractWithdrawalCompressorContract {
   constructor(sdk, address) {
     super(sdk, {
@@ -10,6 +31,88 @@ class WithdrawalCompressorV313Contract extends AbstractWithdrawalCompressorContr
       version: 313
     });
   }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getExternalAccountCurrentWithdrawals}
+   **/
+  async getExternalAccountCurrentWithdrawals(withdrawalToken, account) {
+    const [claimable, pending] = await this.contract.read.getExternalAccountCurrentWithdrawals([
+      withdrawalToken,
+      account
+    ]);
+    return {
+      claimable: claimable.map((w) => toClaimableWithdrawal(w, void 0)),
+      pending: pending.map((w) => toPendingWithdrawal(w, void 0)).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
+    };
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalStatus}
+   **/
+  async getWithdrawalStatus(...redeemers) {
+    if (redeemers.length === 0) {
+      return [];
+    }
+    const resp = await this.client.readContract({
+      address: this.address,
+      abi: iWithdrawalStatusBatchAbi,
+      functionName: "getWithdrawalStatus",
+      args: [redeemers]
+    });
+    return resp.map((s) => toWithdrawalStatus(s));
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalRequestResult}
+   *
+   * When an intent is provided, it is abi-encoded and attached to the request
+   * as `extraData`. The contract overload accepting `extraData` also requires
+   * the withdrawal phantom token; when not provided by the caller, it is
+   * resolved the same way the 3-arg overload does it internally: via the
+   * withdrawable assets of the account's credit manager.
+   **/
+  async getWithdrawalRequestResult({
+    creditAccount,
+    token,
+    amount,
+    withdrawalPhantomToken,
+    intent
+  }) {
+    let resp;
+    if (intent) {
+      const extraData = encodeDelayedIntent(intent);
+      let phantomToken = withdrawalPhantomToken;
+      if (!phantomToken) {
+        const creditManager = await this.client.readContract({
+          address: creditAccount,
+          abi: iCreditAccountAbi,
+          functionName: "creditManager"
+        });
+        phantomToken = await this.getWithdrawalPhantomToken(
+          creditManager,
+          token
+        );
+      }
+      resp = await this.contract.read.getWithdrawalRequestResult([
+        creditAccount,
+        token,
+        phantomToken,
+        amount,
+        extraData
+      ]);
+    } else if (withdrawalPhantomToken) {
+      resp = await this.contract.read.getWithdrawalRequestResult([
+        creditAccount,
+        token,
+        withdrawalPhantomToken,
+        amount
+      ]);
+    } else {
+      resp = await this.contract.read.getWithdrawalRequestResult([
+        creditAccount,
+        token,
+        amount
+      ]);
+    }
+    return toRequestableWithdrawal(resp);
+  }
 }
 export {
   WithdrawalCompressorV313Contract

package/dist/esm/sdk/accounts/withdrawal-compressor/createWithdrawalCompressor.js

@@ -5,13 +5,7 @@ import { WithdrawalCompressorV313Contract } from "./WithdrawalCompressorV313Cont
 function createWithdrawalCompressor(sdk) {
   const location = getWithdrawalCompressorAddress(sdk.networkType);
   if (!location) {
-    throw new Error(`no withdrawal compressor on ${sdk.networkType}`);
-  }
-  const cached = sdk.getContract(
-    location.address
-  );
-  if (cached) {
-    return cached;
+    return void 0;
   }
   switch (location.version) {
     case 310:

package/dist/esm/sdk/accounts/withdrawal-compressor/types.js

@@ -0,0 +1,12 @@
+const WITHDRAWAL_STATUSES = [
+  "NULL",
+  "PENDING",
+  "CLAIMABLE",
+  "CLAIMED"
+];
+function toWithdrawalStatus(status) {
+  return WITHDRAWAL_STATUSES[status] ?? "NULL";
+}
+export {
+  toWithdrawalStatus
+};

package/dist/types/abi/IWithdrawalCompressorV313.d.ts

@@ -107,6 +107,137 @@ export declare const iWithdrawalCompressorV313Abi: readonly [{
         }];
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getExternalAccountCurrentWithdrawals";
+    readonly inputs: readonly [{
+        readonly name: "withdrawalToken";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "account";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple[]";
+        readonly internalType: "struct ClaimableWithdrawal[]";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "withdrawalPhantomToken";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "withdrawalTokenSpent";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "outputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct WithdrawalOutput[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "isDelayed";
+                readonly type: "bool";
+                readonly internalType: "bool";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "claimCalls";
+            readonly type: "tuple[]";
+            readonly internalType: "struct MultiCall[]";
+            readonly components: readonly [{
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "callData";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }, {
+            readonly name: "extraData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }, {
+        readonly name: "";
+        readonly type: "tuple[]";
+        readonly internalType: "struct PendingWithdrawal[]";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "withdrawalPhantomToken";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "expectedOutputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct WithdrawalOutput[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "isDelayed";
+                readonly type: "bool";
+                readonly internalType: "bool";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "claimableAt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "extraData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getWithdrawalStatus";
+    readonly inputs: readonly [{
+        readonly name: "redeemer";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+        readonly internalType: "enum WithdrawalStatus";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getWithdrawalStatus";
+    readonly inputs: readonly [{
+        readonly name: "redeemers";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8[]";
+        readonly internalType: "enum WithdrawalStatus[]";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "getWithdrawableAssets";
@@ -215,6 +346,75 @@ export declare const iWithdrawalCompressorV313Abi: readonly [{
         }];
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getWithdrawalRequestResult";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "withdrawalToken";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct RequestableWithdrawal";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "amountIn";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "outputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct WithdrawalOutput[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "isDelayed";
+                readonly type: "bool";
+                readonly internalType: "bool";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "requestCalls";
+            readonly type: "tuple[]";
+            readonly internalType: "struct MultiCall[]";
+            readonly components: readonly [{
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "callData";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }, {
+            readonly name: "claimableAt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "getWithdrawalRequestResult";

package/dist/types/plugins/delayed-withdrawal/DelayedWithdrawalPlugin.d.ts

@@ -1,20 +1,20 @@
-import type { Address } from "viem";
 import type { IOnchainSDKPlugin } from "../../sdk/index.js";
 import { AddressMap, BasePlugin } from "../../sdk/index.js";
 import type { WithdrawableAsset, WithdrawableAssetStateHuman } from "./types.js";
-export interface DelayedWithdrawalPluginState {
-    withdrawableAssets: Record<Address, Array<WithdrawableAsset>>;
-}
+/**
+ * The plugin holds no state of its own: withdrawable assets are cached
+ * (and serialized/hydrated) by the withdrawal compressor contract in the
+ * core SDK state (`GearboxState.withdrawals`).
+ **/
+export type DelayedWithdrawalPluginState = Record<string, never>;
 export declare class DelayedWithdrawalPlugin extends BasePlugin<DelayedWithdrawalPluginState> implements IOnchainSDKPlugin<DelayedWithdrawalPluginState> {
-    #private;
     load(force?: boolean): Promise<DelayedWithdrawalPluginState>;
     get loaded(): boolean;
     /**
      * Returns a map of cmAddress -> array of delayed assets
-     * @throws if plugin is not attached
+     * @throws if withdrawable assets have not been loaded
      */
     get withdrawableAssets(): AddressMap<Array<WithdrawableAsset>>;
     stateHuman(_?: boolean): WithdrawableAssetStateHuman[];
     get state(): DelayedWithdrawalPluginState;
-    hydrate(state: DelayedWithdrawalPluginState): void;
 }