@gearbox-protocol/sdk 14.12.0-next.4 → 14.12.0-next.41

package/dist/types/sdk/accounts/liquidations/types.d.ts

@@ -0,0 +1,227 @@
+import type { Address } from "viem";
+import type { Asset } from "../../base/index.js";
+import type { NetworkType } from "../../chain/index.js";
+/**
+ * Filters for {@link ILiquidationsService.getLiquidatableAccounts}.
+ * All filters are optional and applied after liquidatable accounts are fetched.
+ **/
+export interface GetLiquidatableAccountsProps {
+    /**
+     * Networks to query. On {@link MultichainLiquidationsService} selects which
+     * chains to query; a single-chain service returns an empty list when its
+     * own network is excluded.
+     **/
+    networks?: NetworkType[];
+    /**
+     * Only return accounts whose main liquidated {@link LiquidatableAccount.asset}
+     * is one of these tokens.
+     **/
+    assets?: Address[];
+    /**
+     * When set, only return accounts with (`true`) or without (`false`)
+     * delayed (phantom-token) withdrawals.
+     **/
+    delayed?: boolean;
+}
+/**
+ * A credit account that can be liquidated, with amounts precomputed for
+ * manual liquidation via the frontend.
+ **/
+export interface LiquidatableAccount {
+    /**
+     * Credit account address.
+     **/
+    creditAccount: Address;
+    /**
+     * Credit manager the account is opened in.
+     **/
+    creditManager: Address;
+    /**
+     * Network the account lives on.
+     **/
+    network: NetworkType;
+    /**
+     * Main asset being liquidated: the most valuable enabled non-underlying
+     * collateral token. For delayed-withdrawal phantom tokens, the source
+     * asset (e.g. ACRED) is reported instead of the phantom token. Falls back
+     * to the underlying when the account holds no other collateral.
+     **/
+    asset: Address;
+    /**
+     * Account total value. The token is the unwrapped asset (e.g. USDC) for
+     * RWA credit managers (1:1 with the wrapped underlying), the credit
+     * manager underlying otherwise.
+     **/
+    totalValue: Asset;
+    /**
+     * Account total value in USD (8 decimals).
+     **/
+    totalValueUSD: bigint;
+    /**
+     * Estimated amount the liquidator pays to fully liquidate the account:
+     * `totalValue * liquidationDiscount`. Same token as {@link totalValue}.
+     **/
+    repaymentAmount: Asset;
+    /**
+     * Estimated liquidator profit: `totalValue * (1 - liquidationDiscount)`.
+     * Same token as {@link totalValue}.
+     **/
+    estimatedProfit: Asset;
+    /**
+     * `true` when the account holds a delayed-withdrawal phantom token above
+     * dust, i.e. the liquidation transfers withdrawal redeemers into the
+     * liquidator's ownership instead of instantly receivable tokens.
+     **/
+    isDelayed: boolean;
+}
+/**
+ * Props for {@link ILiquidationsService.getLiquidationDetails}.
+ **/
+export interface GetLiquidationDetailsProps {
+    /**
+     * Network the credit account lives on.
+     **/
+    network: NetworkType;
+    /**
+     * Credit account to get liquidation details for.
+     **/
+    creditAccount: Address;
+    /**
+     * Liquidator wallet address. Reserved for future RWA KYC gating;
+     * accepted but not checked yet.
+     **/
+    liquidator?: Address;
+}
+/**
+ * A token received directly from the credit account balance upon liquidation.
+ **/
+export interface InstantReceivedAsset {
+    isDelayed: false;
+    /**
+     * Token received by the liquidator.
+     **/
+    token: Address;
+    /**
+     * Amount of `token` received.
+     **/
+    amount: bigint;
+}
+/**
+ * A token produced by a delayed withdrawal whose redeemer is transferred to
+ * the liquidator upon liquidation.
+ **/
+export interface DelayedReceivedAsset {
+    isDelayed: true;
+    /**
+     * Receivable token (e.g. USDC).
+     **/
+    token: Address;
+    /**
+     * Amount of `token`: exact for claimable withdrawals, estimated for
+     * pending ones.
+     **/
+    amount: bigint;
+    /**
+     * Source asset spent by the delayed withdrawal (e.g. ACRED).
+     **/
+    sourceToken: Address;
+    /**
+     * Estimated unix timestamp (in seconds) when a pending withdrawal becomes
+     * claimable. `undefined` means the withdrawal is claimable now.
+     **/
+    claimableAt?: bigint;
+}
+/**
+ * A single asset the liquidator receives when fully liquidating an account.
+ **/
+export type ReceivedAsset = InstantReceivedAsset | DelayedReceivedAsset;
+/**
+ * Props for {@link ILiquidationsService.getLiquidatorWithdrawals}.
+ **/
+export interface GetLiquidatorWithdrawalsProps {
+    /**
+     * Networks to query. On {@link MultichainLiquidationsService} selects which
+     * chains to query; a single-chain service returns an empty list when its
+     * own network is excluded.
+     **/
+    networks?: NetworkType[];
+    /**
+     * Liquidator wallet that owns the redemption receipts (redeemer contracts
+     * received as a result of liquidations).
+     **/
+    liquidator: Address;
+}
+/**
+ * A single delayed-withdrawal position owned by the liquidator.
+ *
+ * The redeemer contract address is not included: it is not part of the
+ * on-chain withdrawal structs returned by the withdrawal compressor. It can
+ * be surfaced later if the compressor structs are extended.
+ **/
+export interface LiquidatorWithdrawal {
+    /**
+     * Network the withdrawal lives on.
+     **/
+    network: NetworkType;
+    /**
+     * Source asset spent by the delayed withdrawal (e.g. ACRED).
+     **/
+    sourceToken: Address;
+    /**
+     * Receivable asset (e.g. USDC).
+     **/
+    token: Address;
+    /**
+     * Amount of `token` receivable: exact for claimable withdrawals, estimated
+     * for pending ones.
+     **/
+    amount: bigint;
+    /**
+     * Estimated unix timestamp (in seconds) when a pending withdrawal becomes
+     * claimable. `undefined` means the withdrawal is claimable now.
+     **/
+    claimableAt?: bigint;
+}
+/**
+ * Detailed information about a liquidatable credit account, extending the
+ * list row with the full breakdown of assets the liquidator receives.
+ **/
+export interface LiquidationDetails extends LiquidatableAccount {
+    /**
+     * Assets the liquidator receives upon full liquidation: direct credit
+     * account balances plus outputs of delayed withdrawals (claimable and
+     * pending).
+     **/
+    receivedAssets: ReceivedAsset[];
+}
+/**
+ * Service for discovering liquidatable credit accounts and previewing manual
+ * liquidations. Implemented per-chain by {@link LiquidationsService} and
+ * across all configured chains by {@link MultichainLiquidationsService}.
+ **/
+export interface ILiquidationsService {
+    /**
+     * Returns all liquidatable credit accounts: accounts with health factor
+     * below 1 plus accounts of expired credit managers with outstanding debt.
+     * Accounts whose collateral computation failed are excluded.
+     *
+     * @param props - Optional filters, see {@link GetLiquidatableAccountsProps}
+     **/
+    getLiquidatableAccounts(props?: GetLiquidatableAccountsProps): Promise<LiquidatableAccount[]>;
+    /**
+     * Returns detailed information about a liquidatable credit account,
+     * including the full list of assets the liquidator receives.
+     *
+     * @param props - See {@link GetLiquidationDetailsProps}
+     * @throws When the account is not found or its collateral computation fails.
+     **/
+    getLiquidationDetails(props: GetLiquidationDetailsProps): Promise<LiquidationDetails>;
+    /**
+     * Returns the status of delayed-withdrawal positions (redemption receipts)
+     * owned by a liquidator wallet: what is receivable, how much, and when it
+     * becomes claimable.
+     *
+     * @param props - See {@link GetLiquidatorWithdrawalsProps}
+     **/
+    getLiquidatorWithdrawals(props: GetLiquidatorWithdrawalsProps): Promise<LiquidatorWithdrawal[]>;
+}

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

@@ -1,12 +1,12 @@
-import type { Address, ContractFunctionArgs, GetContractReturnType, Hex, PublicClient } from "viem";
+import type { Address, ContractFunctionArgs, Hex } from "viem";
 import type { creditAccountCompressorAbi } from "../../abi/compressors/creditAccountCompressor.js";
-import type { iWithdrawalCompressorV310Abi } from "../../abi/IWithdrawalCompressorV310.js";
-import type { ConnectedBotData, Construct, CreditAccountData } from "../base/index.js";
-import type { CreditSuite, PriceUpdate, RWAOperationParams } from "../market/index.js";
+import type { Asset, ConnectedBotData, Construct, CreditAccountData } from "../base/index.js";
+import type { CreditSuite, PriceUpdate, RWAOperationArgs } from "../market/index.js";
 import type { RWAOpenAccountRequirements } from "../market/rwa/index.js";
 import type { OnchainSDK } from "../OnchainSDK.js";
-import type { Asset, RouterCASlice, RouterCloseResult } from "../router/index.js";
+import type { RouterCASlice, RouterCloseResult } from "../router/index.js";
 import type { MultiCall, RawTx } from "../types/index.js";
+import type { ClaimableWithdrawal, DelayedIntent, PendingWithdrawal, RequestableWithdrawal } from "./withdrawal-compressor/index.js";
 /**
  * @internal
  * Arguments tuple for the credit account compressor's `getCreditAccounts` view method.
@@ -182,16 +182,27 @@ export interface CloseCreditAccountProps {
      */
     closePath?: RouterCloseResult;
 }
-export interface RepayCreditAccountProps extends RepayAndLiquidateCreditAccountProps {
+/**
+ * Input for {@link ICreditAccountsService.assembleCloseCreditAccountCalls}.
+ */
+export type AssembleCloseCreditAccountCallsProps = {
     /**
-     * Swap calls for repay
+     * Minimal credit account data on which operation is performed.
      */
-    calls?: Array<MultiCall>;
+    creditAccount: RouterCASlice;
     /**
-     * close or zeroDebt
+     * Pathfinder close router calls (`closePath.calls`).
      */
-    operation: CloseOptions;
-}
+    routerCalls: Array<MultiCall>;
+    /**
+     * Tokens to withdraw from credit account after close path swaps.
+     */
+    assetsToWithdraw: Array<Address>;
+    /**
+     * Wallet address to withdraw tokens to.
+     */
+    to: Address;
+};
 export interface RepayAndLiquidateCreditAccountProps {
     /**
      * Tokens to repay debt.
@@ -220,6 +231,31 @@ export interface RepayAndLiquidateCreditAccountProps {
     permits: Record<string, PermitResult>;
     tokensToClaim: Asset[];
 }
+/**
+ * Input for {@link ICreditAccountsService.assembleRepayCreditAccountCalls}.
+ */
+export type AssembleRepayCreditAccountCallsProps = {
+    collateralAssets: Array<Asset>;
+    assetsToWithdraw: Array<Asset>;
+    creditAccount: RouterCASlice;
+    to: Address;
+    permits: Record<string, PermitResult>;
+    tokensToClaim: Asset[];
+    /**
+     * RWA wrap multicall entries (from getRWAWrapCalls).
+     */
+    calls?: Array<MultiCall>;
+};
+export interface RepayCreditAccountProps extends RepayAndLiquidateCreditAccountProps {
+    /**
+     * RWA wrap multicall entries (from getRWAWrapCalls).
+     */
+    calls?: Array<MultiCall>;
+    /**
+     * close or zeroDebt
+     */
+    operation: CloseOptions;
+}
 export interface PrepareUpdateQuotasProps {
     /**
      * average quota for desired token
@@ -304,6 +340,13 @@ export interface PreviewDelayedWithdrawalProps {
      * Minimal credit account data on which operation is performed
      */
     creditAccount: Address;
+    /**
+     * Withdrawal phantom token that selects a specific withdrawal config when
+     * the source token has more than one. When omitted, the first matching
+     * config is used
+     */
+    withdrawalPhantomToken?: Address;
+    intent?: DelayedIntent;
 }
 export interface GetPendingWithdrawalsProps {
     /**
@@ -311,20 +354,6 @@ export interface GetPendingWithdrawalsProps {
      */
     creditAccount: Address;
 }
-type WithdrawalCompressorV310InstanceType = GetContractReturnType<typeof iWithdrawalCompressorV310Abi, PublicClient>;
-/**
- * Result of previewing a delayed withdrawal request, as returned by the withdrawal compressor.
- **/
-export type PreviewDelayedWithdrawalResult = Awaited<ReturnType<WithdrawalCompressorV310InstanceType["read"]["getWithdrawalRequestResult"]>>;
-type PendingWithdrawalResult = Awaited<ReturnType<WithdrawalCompressorV310InstanceType["read"]["getCurrentWithdrawals"]>>;
-/**
- * A single pending delayed withdrawal that is not yet claimable.
- **/
-export type PendingWithdrawal = PendingWithdrawalResult[1][number];
-/**
- * A single delayed withdrawal that is ready to be claimed.
- **/
-export type ClaimableWithdrawal = PendingWithdrawalResult[0][number];
 /**
  * Aggregated delayed withdrawal status, split into immediately claimable and still-pending entries.
  **/
@@ -338,11 +367,40 @@ export interface GetPendingWithdrawalsResult {
      **/
     pending: Array<PendingWithdrawal>;
 }
+/**
+ * Input for {@link ICreditAccountsService.assembleStartDelayedWithdrawalCalls}.
+ */
+export type AssembleStartDelayedWithdrawalCallsProps = {
+    /**
+     * Credit facade that receives `storeExpectedBalances` / `compareBalances`.
+     */
+    creditFacade: Address;
+    /**
+     * Withdrawal preview: `outputs` for expected balances, `token`/`amountIn`
+     * for the negative source-token delta, `requestCalls` for the body.
+     */
+    preview: Pick<RequestableWithdrawal, "outputs" | "requestCalls" | "token" | "amountIn">;
+};
+/**
+ * Input for {@link ICreditAccountsService.assembleClaimDelayedCalls}.
+ */
+export type AssembleClaimDelayedCallsProps = {
+    /**
+     * Credit facade that receives `storeExpectedBalances` / `compareBalances`.
+     */
+    creditFacade: Address;
+    /**
+     * Claimable withdrawal: `outputs` for expected balances,
+     * `withdrawalPhantomToken`/`withdrawalTokenSpent` for the negative
+     * phantom-burn delta, `claimCalls` for the body.
+     */
+    claimableNow: Pick<ClaimableWithdrawal, "outputs" | "claimCalls" | "withdrawalPhantomToken" | "withdrawalTokenSpent">;
+};
 export interface StartDelayedWithdrawalProps extends PrepareUpdateQuotasProps {
     /**
      * Withdrawal preview
      */
-    preview: PreviewDelayedWithdrawalResult;
+    preview: RequestableWithdrawal;
     /**
      * Minimal credit account data on which operation is performed
      */
@@ -431,11 +489,11 @@ export interface OpenCAProps extends PrepareUpdateQuotasProps {
      * RWA options to open credit account with, required for RWA factories
      * First we ask for getOpenAccountRequirements,
      * then perform necessary actions (e.g. for Securitize, convert requiredSignatures to signaturesToCache)
-     * to produce RWAOperationParams
+     * to produce RWAOperationArgs
      * If getOpenAccountRequirements returned undefined, we need to pass undefined here too;
      * It means that no RWA actions are required (e.g. when we open second credit account)
      */
-    rwaOptions?: RWAOperationParams;
+    rwaOptions?: RWAOperationArgs;
 }
 export interface ChangeDeptProps {
     /**
@@ -673,12 +731,14 @@ export type GetApprovalAddressProps = {
     creditAccount: Address;
 };
 /**
- * A single step in a generic credit account update operation chain.
+ * An enriched credit-account operation ready for encoding.
+ * Each op carries everything needed to build facade / adapter multicalls —
+ * swap / wrap / unwrap attach concrete `calls` (no external routerCallGroups).
  *
- * Used by {@link ICreditAccountsService.assembleCaUpdateCalls} to build the
- * underlying credit facade multicall calls.
+ * Used by {@link ICreditAccountsService.assembleCaOperations}. Does not include
+ * close / repay (use dedicated assemblers).
  */
-export type CreditAccountUpdateOperation = {
+export type EncodableCreditAccountOperation = {
     type: "increaseDebt";
     amount: bigint;
 } | {
@@ -692,32 +752,27 @@ export type CreditAccountUpdateOperation = {
     type: "withdrawCollateral";
     token: Address;
     amount: bigint;
+    to: Address;
 } | {
     type: "swap";
+    calls: Array<MultiCall>;
+} | {
+    type: "wrapRwaCollateral";
+    calls: Array<MultiCall>;
+} | {
+    type: "unwrapRwaCollateral";
+    calls: Array<MultiCall>;
 } | {
     type: "changeQuota";
     quotaIncrease: Array<Asset>;
     quotaDecrease: Array<Asset>;
-} | {
-    type: "closeCreditAccount";
 };
 /**
- * Input for {@link ICreditAccountsService.assembleCaUpdateCalls}.
+ * Input for {@link ICreditAccountsService.assembleCaOperations}.
  */
-export type AssembleCaUpdateCallsProps = {
-    operations: Array<CreditAccountUpdateOperation>;
-    /** One group per swap leg (in order), or a single group for the close path. */
-    routerCallGroups: Array<Array<MultiCall>>;
+export type AssembleCaOperationsProps = {
+    operations: Array<EncodableCreditAccountOperation>;
     creditFacade: Address;
-    withdrawTo: Address;
-    creditAccount: {
-        debt: bigint;
-        assets: Array<Asset>;
-        initialQuotas: Record<Address, {
-            quota: bigint;
-        }>;
-    };
-    underlyingToken: Address;
 };
 export interface ICreditAccountsService extends Construct {
     sdk: OnchainSDK;
@@ -798,6 +853,17 @@ export interface ICreditAccountsService extends Construct {
      * @returns Raw transaction ready to be signed and sent
      */
     partiallyLiquidate(props: PartiallyLiquidateProps): Promise<RawTx>;
+    /**
+     * Builds close multicall calls without price feed updates.
+     *
+     * Same operation sequence as {@link closeCreditAccount} (close path swaps,
+     * disable quotas, decrease debt, withdraw assets), but does not prepend
+     * price updates and does not build the facade transaction.
+     *
+     * @param props - {@link AssembleCloseCreditAccountCallsProps}
+     * @returns Raw facade multicall payload for close (before price feed updates)
+     */
+    assembleCloseCreditAccountCalls(props: AssembleCloseCreditAccountCallsProps): Promise<Array<MultiCall>>;
     /**
      * Closes credit account or closes credit account and keeps it open with zero debt.
      * - Ca is closed in the following order: price update -> close path to swap all tokens into underlying ->
@@ -841,12 +907,51 @@ export interface ICreditAccountsService extends Construct {
      * @returns All necessary data to execute the transaction (call, credit facade)
      */
     startDelayedWithdrawal(props: StartDelayedWithdrawalProps): Promise<CreditAccountOperationResult>;
+    /**
+     * Builds start-delayed-withdrawal multicall calls without price feed updates
+     * or quota updates.
+     *
+     * Same balance bracket as {@link startDelayedWithdrawal}:
+     * `storeExpectedBalances` → `preview.requestCalls` → `compareBalances`.
+     *
+     * Besides the positive output deltas, the bracket carries a negative delta
+     * of the spent source token (`preview.token` / `-preview.amountIn`). It
+     * makes the input-side balance decrease previewable from the calldata alone and lets
+     * `compareBalances` assert the balance doesn't drop by more than predicted.
+     *
+     * Does not prepend price updates and does not build the facade transaction.
+     *
+     * @param props - {@link AssembleStartDelayedWithdrawalCallsProps}
+     * @returns Raw facade multicall payload for the delayed-withdrawal request
+     */
+    assembleStartDelayedWithdrawalCalls(props: AssembleStartDelayedWithdrawalCallsProps): Array<MultiCall>;
+    /**
+     * Builds claim-delayed-withdrawal multicall calls without price feed updates
+     * or quota updates.
+     *
+     * Same balance bracket as {@link claimDelayed}:
+     * `storeExpectedBalances` → `claimableNow.claimCalls` → `compareBalances`.
+     *
+     * Besides the positive output deltas, the bracket carries a negative delta
+     * of the burned withdrawal phantom token (`claimableNow.withdrawalPhantomToken`
+     * / `-claimableNow.withdrawalTokenSpent`). It makes the phantom burn
+     * previewable from the calldata alone and lets `compareBalances` assert the
+     * balance doesn't drop by more than predicted.
+     *
+     * Does not prepend price updates, does not update quotas, and does not build
+     * the facade transaction. Use for resume / intent assembly where claim is
+     * followed by other ops and quotas/prices are applied separately.
+     *
+     * @param props - {@link AssembleClaimDelayedCallsProps}
+     * @returns Raw facade multicall payload for the claim
+     */
+    assembleClaimDelayedCalls(props: AssembleClaimDelayedCallsProps): Array<MultiCall>;
     /**
      * Preview delayed withdrawal for given token
      * @param props - {@link PreviewDelayedWithdrawalProps}
      * @returns
      */
-    previewDelayedWithdrawal(props: PreviewDelayedWithdrawalProps): Promise<PreviewDelayedWithdrawalResult>;
+    previewDelayedWithdrawal(props: PreviewDelayedWithdrawalProps): Promise<RequestableWithdrawal>;
     /**
      * Get claimable and pending withdrawals of an account
      * @param props - {@link GetPendingWithdrawalsProps}
@@ -943,12 +1048,20 @@ export interface ICreditAccountsService extends Construct {
         ignoreReservePrices?: boolean;
     }): Promise<Array<MultiCall>>;
     /**
-     * Builds the credit facade multicall calls for a chain of update operations.
+     * Builds credit facade multicall calls from an enriched operation list.
+     * Each operation must already carry concrete encoding data (e.g. swap/wrap
+     * `calls`). Unknown operation types throw.
      *
-     * @param props - Operation chain, router call groups and account context
-     * @returns Array of facade multicall calls (without price feed updates)
+     * Does not handle close, repay, start delayed withdrawal, or claim delayed —
+     * use {@link ICreditAccountsService.assembleCloseCreditAccountCalls} /
+     * {@link ICreditAccountsService.assembleRepayCreditAccountCalls} /
+     * {@link ICreditAccountsService.assembleStartDelayedWithdrawalCalls} /
+     * {@link ICreditAccountsService.assembleClaimDelayedCalls}.
+     *
+     * @param props - Encodable operations and account context
+     * @returns Array of facade / adapter multicall calls (without price feed updates)
      */
-    assembleCaUpdateCalls(props: AssembleCaUpdateCallsProps): Array<MultiCall>;
+    assembleCaOperations(props: AssembleCaOperationsProps): Array<MultiCall>;
     /**
      * Executes a credit account update: prepends price feed updates and builds the raw
      * multicall transaction. Uses the RWA factory when applicable.
@@ -1009,6 +1122,17 @@ export interface ICreditAccountsService extends Construct {
      * @return All necessary data to execute the transaction (call, credit facade)
      */
     withdrawCollateral(props: WithdrawCollateralProps): Promise<CreditAccountOperationResult>;
+    /**
+     * Builds repay multicall calls without price feed updates.
+     *
+     * Same operation sequence as {@link repayCreditAccount} (add collateral, wrap calls,
+     * disable quotas, decrease debt, redeem/unwrap, claim rewards, withdraw assets),
+     * but does not prepend price updates and does not build the facade transaction.
+     *
+     * @param props - {@link AssembleRepayCreditAccountCallsProps}
+     * @returns Raw facade multicall payload for repay (before price feed updates)
+     */
+    assembleRepayCreditAccountCalls(props: AssembleRepayCreditAccountCallsProps): Promise<Array<MultiCall>>;
     /**
      * Fully repays credit account or repays credit account and keeps it open with zero debt
      * - Repays in the following order: price update -> add collateral to cover the debt ->

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

@@ -0,0 +1,112 @@
+import type { Abi, Address, ContractFunctionReturnType } from "viem";
+import type { iWithdrawalCompressorV313Abi } from "../../../abi/IWithdrawalCompressorV313.js";
+import type { BaseContractArgs } from "../../base/index.js";
+import { BaseContract } from "../../base/index.js";
+import type { OnchainSDK } from "../../OnchainSDK.js";
+import type { ClaimableWithdrawal, CurrentWithdrawals, GetWithdrawalRequestResultProps, IWithdrawalCompressorContract, PendingWithdrawal, RequestableWithdrawal, WithdrawableAsset, WithdrawalStatus, WithdrawalsState } from "./types.js";
+export declare const iCreditAccountAbi: readonly [{
+    readonly type: "function";
+    readonly name: "creditManager";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}];
+/**
+ * v313 ABI is a type-level superset of v310/v311 for the read methods used
+ * here. Fields missing in older versions (`maxWithdrawals`, `extraData`) are
+ * required in the inferred types but absent at runtime on v310/v311, so the
+ * normalization helpers must not assume their presence.
+ **/
+type CommonAbi = typeof iWithdrawalCompressorV313Abi;
+type OnchainCurrentWithdrawals = ContractFunctionReturnType<CommonAbi, "view", "getCurrentWithdrawals">;
+type OnchainClaimableWithdrawal = OnchainCurrentWithdrawals[0][number];
+type OnchainPendingWithdrawal = OnchainCurrentWithdrawals[1][number];
+/**
+ * Base class for WithdrawalCompressor contracts of different versions.
+ * Implements version-agnostic reads, normalizing results to common types.
+ * Withdrawable assets are cached for the lifetime of the instance (which is
+ * reused across calls via the SDK's contracts register).
+ **/
+export declare abstract class AbstractWithdrawalCompressorContract<abi extends Abi> extends BaseContract<abi> implements IWithdrawalCompressorContract {
+    #private;
+    constructor(sdk: OnchainSDK, args: BaseContractArgs<abi>);
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.hydrate}
+     **/
+    hydrate(state: WithdrawalsState): void;
+    /**
+     * The contract is instantiated with the actual versioned ABI,
+     * this cast is type-level only (see {@link CommonAbi}).
+     **/
+    private get common();
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.state}
+     **/
+    get state(): WithdrawalsState | undefined;
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.getWithdrawableAssets}
+     **/
+    getWithdrawableAssets(...creditManagers: Address[]): WithdrawableAsset[];
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.loadWithdrawableAssets}
+     **/
+    loadWithdrawableAssets(force?: boolean): Promise<WithdrawableAsset[]>;
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.findWithdrawableAssets}
+     **/
+    findWithdrawableAssets(creditManager: Address, token: Address): Promise<WithdrawableAsset[]>;
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.findWithdrawableAssetsByPhantomToken}
+     **/
+    findWithdrawableAssetsByPhantomToken(withdrawalPhantomToken: Address): Promise<WithdrawableAsset[]>;
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalPhantomToken}
+     **/
+    getWithdrawalPhantomToken(creditManager: Address, token: Address): Promise<Address>;
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalSourceToken}
+     **/
+    getWithdrawalSourceToken(withdrawalPhantomToken: Address): Address | undefined;
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.getCurrentWithdrawals}
+     **/
+    getCurrentWithdrawals(creditAccount: Address): Promise<CurrentWithdrawals>;
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.getExternalAccountCurrentWithdrawals}
+     **/
+    getExternalAccountCurrentWithdrawals(_account: Address, ..._withdrawalTokens: Address[]): Promise<CurrentWithdrawals>;
+    /**
+     * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalStatus}
+     **/
+    getWithdrawalStatus(...redeemers: Address[]): Promise<WithdrawalStatus[]>;
+    /**
+     * {@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).
+     **/
+    getWithdrawalRequestResult({ creditAccount, token, amount, withdrawalPhantomToken, intent, }: GetWithdrawalRequestResultProps): Promise<RequestableWithdrawal>;
+}
+export type OnchainRequestableWithdrawal = ContractFunctionReturnType<CommonAbi, "view", "getWithdrawalRequestResult", readonly [Address, Address, bigint]>;
+/**
+ * Normalizes a previewed withdrawal request.
+ **/
+export declare function toRequestableWithdrawal(resp: OnchainRequestableWithdrawal): RequestableWithdrawal;
+/**
+ * Normalizes a claimable withdrawal. The intent is decoded from `extraData`
+ * only when `creditManager` is provided (it is required to build
+ * {@link DelayedIntentExtended} and is only meaningful for credit account
+ * withdrawals on v313+ compressors).
+ **/
+export declare function toClaimableWithdrawal(w: OnchainClaimableWithdrawal, creditManager: Address | undefined): ClaimableWithdrawal;
+/**
+ * Normalizes a pending withdrawal, see {@link toClaimableWithdrawal} for
+ * intent decoding rules.
+ **/
+export declare function toPendingWithdrawal(w: OnchainPendingWithdrawal, creditManager: Address | undefined): PendingWithdrawal;
+export {};