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

package/dist/types/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV313Contract.d.ts

@@ -1,6 +1,7 @@
 import type { Address } from "viem";
 import type { OnchainSDK } from "../../OnchainSDK.js";
 import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
+import type { CurrentWithdrawals, GetWithdrawalRequestResultProps, RequestableWithdrawal, WithdrawalStatus } from "./types.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly name: "contractType";
@@ -110,6 +111,137 @@ declare const abi: 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";
@@ -218,6 +350,75 @@ declare const abi: 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";
@@ -297,8 +498,29 @@ declare const abi: readonly [{
 type abi = typeof abi;
 /**
  * V3.13 implementation of the {@link IWithdrawalCompressorContract} interface.
+ * Overrides the legacy fallbacks of the base class with features introduced
+ * in v313: withdrawal intents, withdrawal config selection, external account
+ * withdrawals and withdrawal statuses.
  **/
 export declare class WithdrawalCompressorV313Contract extends AbstractWithdrawalCompressorContract<abi> {
     constructor(sdk: OnchainSDK, address: Address);
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.getExternalAccountCurrentWithdrawals}
+     **/
+    getExternalAccountCurrentWithdrawals(withdrawalToken: Address, account: Address): Promise<CurrentWithdrawals>;
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalStatus}
+     **/
+    getWithdrawalStatus(...redeemers: Address[]): Promise<WithdrawalStatus[]>;
+    /**
+     * {@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.
+     **/
+    getWithdrawalRequestResult({ creditAccount, token, amount, withdrawalPhantomToken, intent, }: GetWithdrawalRequestResultProps): Promise<RequestableWithdrawal>;
 }
 export {};

package/dist/types/sdk/accounts/withdrawal-compressor/createWithdrawalCompressor.d.ts

@@ -1,9 +1,10 @@
 import type { OnchainSDK } from "../../OnchainSDK.js";
 import type { IWithdrawalCompressorContract } from "./types.js";
 /**
- * Returns a withdrawal compressor contract for the current chain,
- * reusing an instance from the contracts register when available.
+ * Creates a withdrawal compressor contract for the current chain,
+ * or returns `undefined` if no withdrawal compressor is supported on it.
+ * Called once from the SDK constructor; consumers should access the
+ * instance via `sdk.withdrawalCompressor`.
  * @param sdk
- * @throws if no withdrawal compressor is supported on the current chain.
  **/
-export declare function createWithdrawalCompressor(sdk: OnchainSDK): IWithdrawalCompressorContract;
+export declare function createWithdrawalCompressor(sdk: OnchainSDK): IWithdrawalCompressorContract | undefined;

package/dist/types/sdk/accounts/withdrawal-compressor/types.d.ts

@@ -260,30 +260,120 @@ export interface CurrentWithdrawals {
      **/
     pending: PendingWithdrawal[];
 }
+/**
+ * Status of a single delayed withdrawal (redeemer contract).
+ * Mirrors the on-chain `WithdrawalStatus` enum.
+ **/
+export type WithdrawalStatus = "NULL" | "PENDING" | "CLAIMABLE" | "CLAIMED";
+/**
+ * Maps the on-chain `WithdrawalStatus` enum value to its string representation.
+ **/
+export declare function toWithdrawalStatus(status: number): WithdrawalStatus;
+/**
+ * Serializable snapshot of the withdrawal compressor's assets cache,
+ * stored in the core SDK state (`GearboxState.withdrawals`).
+ **/
+export interface WithdrawalsState {
+    /**
+     * Cached withdrawable assets, keyed by credit manager
+     **/
+    withdrawableAssets: Record<Address, WithdrawableAsset[]>;
+}
+/**
+ * Props for {@link IWithdrawalCompressorContract.getWithdrawalRequestResult}.
+ **/
+export interface GetWithdrawalRequestResultProps {
+    /**
+     * Credit account to withdraw from
+     **/
+    creditAccount: Address;
+    /**
+     * Source token to withdraw (e.g. a Mellow multivault share, a Securitize
+     * dsToken or a Midas mToken)
+     **/
+    token: Address;
+    /**
+     * Amount of `token` to withdraw; capped at the credit account's balance
+     * by the contract
+     **/
+    amount: bigint;
+    /**
+     * Withdrawal phantom token that selects a specific withdrawal config when
+     * the source token has more than one. When omitted, the contract resolves
+     * it from the first matching withdrawable asset of the account's credit
+     * manager
+     **/
+    withdrawalPhantomToken?: Address;
+    /**
+     * Delayed intent to attach to the request as `extraData` (v313+ only)
+     **/
+    intent?: DelayedIntent;
+}
 /**
  * Version-agnostic interface of the WithdrawalCompressor contract.
  **/
 export interface IWithdrawalCompressorContract extends IBaseContract {
     /**
-     * Returns assets that can be withdrawn from the given credit manager via delayed withdrawal.
+     * Returns cached assets that can be withdrawn via delayed withdrawal.
+     * With no arguments, returns assets of all credit managers; with arguments,
+     * only assets of the given credit managers.
+     * @throws When the cache was never loaded (via {@link loadWithdrawableAssets}
+     * or state hydration).
+     **/
+    getWithdrawableAssets(...creditManagers: Address[]): WithdrawableAsset[];
+    /**
+     * Loads withdrawable assets of all credit managers known to the SDK's
+     * market register into the cache (a single multicall, only once per SDK
+     * lifetime) and returns them. Failed per-manager calls are logged and
+     * skipped.
+     * @param force - Invalidate the cache and refetch even if already loaded.
      **/
-    getWithdrawableAssets(creditManager: Address): Promise<WithdrawableAsset[]>;
+    loadWithdrawableAssets(force?: boolean): Promise<WithdrawableAsset[]>;
     /**
-     * Same as {@link getWithdrawableAssets}, but for multiple credit managers in a single multicall.
-     * Defaults to all credit managers known to the SDK's market register.
-     * Failed per-manager calls are logged and skipped.
+     * Returns all withdrawal configs of a withdrawable source token
+     * (e.g. a Mellow multivault share) of the given credit manager.
+     * Loads the cache if necessary.
      **/
-    getWithdrawableAssetsBatch(creditManagers?: Address[]): Promise<WithdrawableAsset[]>;
+    findWithdrawableAssets(creditManager: Address, token: Address): Promise<WithdrawableAsset[]>;
+    /**
+     * Returns withdrawal configs with the given withdrawal phantom token
+     * across all credit managers. Loads the cache if necessary.
+     **/
+    findWithdrawableAssetsByPhantomToken(withdrawalPhantomToken: Address): Promise<WithdrawableAsset[]>;
     /**
      * Resolves the withdrawal phantom token for a withdrawable source token
      * (e.g. a Mellow multivault share) of the given credit manager.
      * @throws When the token is not withdrawable from the credit manager.
      **/
     getWithdrawalPhantomToken(creditManager: Address, token: Address): Promise<Address>;
+    /**
+     * Resolves the source token of a withdrawal phantom token (e.g. `ACRED` for
+     * `srpACRED_USDC`), or `undefined` when the token is not a known withdrawal
+     * phantom token. The phantom-to-source binding is fixed at phantom token
+     * deployment, so no credit manager is needed.
+     * @throws When the cache was never loaded (via {@link loadWithdrawableAssets}
+     * or state hydration).
+     **/
+    getWithdrawalSourceToken(withdrawalPhantomToken: Address): Address | undefined;
     /**
      * Returns claimable and pending delayed withdrawals of the given credit account.
      **/
     getCurrentWithdrawals(creditAccount: Address): Promise<CurrentWithdrawals>;
+    /**
+     * Returns claimable and pending delayed withdrawals of an external address
+     * (non-credit-account, e.g. liquidator EOA) in the given withdrawal phantom token.
+     * Only supported on v313+ compressors; on older versions throws if
+     * `sdk.strictContractTypes` is `true`, otherwise logs a warning and
+     * returns empty lists.
+     **/
+    getExternalAccountCurrentWithdrawals(withdrawalToken: Address, account: Address): Promise<CurrentWithdrawals>;
+    /**
+     * Returns statuses of the given redeemer contracts.
+     * Only supported on v313+ compressors; on older versions throws if
+     * `sdk.strictContractTypes` is `true`, otherwise logs a warning and
+     * returns `"NULL"` statuses.
+     **/
+    getWithdrawalStatus(...redeemers: Address[]): Promise<WithdrawalStatus[]>;
     /**
      * Previews a delayed withdrawal request.
      *
@@ -292,5 +382,14 @@ export interface IWithdrawalCompressorContract extends IBaseContract {
      * throws if `sdk.strictContractTypes` is `true`, otherwise a warning is
      * logged and the intent is ignored.
      **/
-    getWithdrawalRequestResult(creditAccount: Address, token: Address, amount: bigint, intent?: DelayedIntent): Promise<RequestableWithdrawal>;
+    getWithdrawalRequestResult(props: GetWithdrawalRequestResultProps): Promise<RequestableWithdrawal>;
+    /**
+     * Seeds the assets cache from a previously serialized snapshot.
+     **/
+    hydrate(state: WithdrawalsState): void;
+    /**
+     * Serializable snapshot of the assets cache, or `undefined` if the cache
+     * was never loaded.
+     **/
+    readonly state: WithdrawalsState | undefined;
 }

package/dist/types/sdk/types/state.d.ts

@@ -1,3 +1,4 @@
+import type { WithdrawalsState } from "../accounts/withdrawal-compressor/types.js";
 import type { MarketData } from "../base/index.js";
 import type { NetworkType } from "../chain/chains.js";
 import type { AddressProviderState } from "../core/index.js";
@@ -52,6 +53,13 @@ export interface GearboxState<Plugins extends PluginsMap = {}> {
      * Present only when zappers were loaded (they are optional)
      **/
     zappers?: ZapperData[];
+    /**
+     * Withdrawal compressor's withdrawable assets cache.
+     *
+     * Present only when the compressor exists on the chain and its assets
+     * were loaded
+     **/
+    withdrawals?: WithdrawalsState;
     /**
      * Per-plugin serialised state.
      **/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "14.12.0-next.34",
+  "version": "14.12.0-next.35",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {