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

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

@@ -0,0 +1,11 @@
+export * from "./AbstractWithdrawalCompressorContract.js";
+export * from "./addresses.js";
+export * from "./createRedemptionLogger.js";
+export * from "./createWithdrawalCompressor.js";
+export * from "./errors.js";
+export * from "./intent-codec.js";
+export * from "./RedemptionLoggerV310Contract.js";
+export * from "./types.js";
+export * from "./WithdrawalCompressorV310Contract.js";
+export * from "./WithdrawalCompressorV311Contract.js";
+export * from "./WithdrawalCompressorV313Contract.js";

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

@@ -0,0 +1,26 @@
+import type { Hex } from "viem";
+import type { DelayedIntent } from "./types.js";
+/**
+ * Current version of the delayed intent encoding schema.
+ * Bump when the layout of any intent type changes.
+ **/
+export declare const DELAYED_INTENT_VERSION = 1;
+/**
+ * Stable uint8 discriminants for intent types.
+ * Starts at 1 so that all-zero data cannot decode as a valid intent.
+ * Never reuse or renumber existing values.
+ **/
+export declare const DELAYED_INTENT_TYPES: Record<DelayedIntent["type"], number>;
+/**
+ * ABI-encodes a delayed intent as
+ * `(uint8 version, uint8 intentType, ...intent-specific fields)`.
+ * @throws if the intent has an unknown type or fields that cannot be
+ * abi-encoded (e.g. an invalid address)
+ **/
+export declare function encodeDelayedIntent(intent: DelayedIntent): Hex;
+/**
+ * Decodes a delayed intent from abi-encoded `extraData`.
+ * @throws if data is empty, malformed, has an unsupported version,
+ * or an unknown intent type
+ **/
+export declare function decodeDelayedIntent(data: Hex): DelayedIntent;

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

@@ -0,0 +1,438 @@
+import type { Address, Hex } from "viem";
+import type { IBaseContract } from "../../base/index.js";
+import type { MultiCall } from "../../types/index.js";
+/**
+ * App: 1.1 Deposit and 4.1 Adjust leverage — raise leverage at fixed TVL.
+ * Borrow `underlying` -> swap `underlying` into `targetToken` -> [withdraw to wallet].
+ **/
+export interface DelayedIncreaseLeverageIntent {
+    type: "INCREASE_LEVERAGE";
+    /**
+     * Wallet address that receives tokens withdrawn from the credit account
+     * when the flow is resumed after the claim
+     **/
+    to: Address;
+}
+/**
+ * App: 1.2 Deposit — `amount > 0`, leverage = current (grow net value at same L).
+ * Add collateral -> borrow `underlying` -> swap collateral and `underlying`
+ * into the target token.
+ **/
+export interface DelayedDepositIntent {
+    type: "DEPOSIT";
+}
+/**
+ * App: 1.3 Deposit and Adjust leverage — `amount > 0`, leverage > current.
+ * Add collateral -> borrow `underlying` -> swap collateral and `underlying`
+ * into the target token.
+ **/
+export interface DelayedDepositAndIncreaseLeverageIntent {
+    type: "DEPOSIT_AND_INCREASE_LEVERAGE";
+}
+/**
+ * App: 2.1 Withdraw — withdraw selected token at fixed leverage.
+ * Swap token into `underlying` -> [decrease debt with `underlying` ->
+ * withdraw token to wallet].
+ **/
+export interface DelayedWithdrawCollateralIntent {
+    type: "WITHDRAW_COLLATERAL";
+    /**
+     * Wallet address that receives the withdrawn token
+     * when the flow is resumed after the claim
+     **/
+    to: Address;
+    /**
+     * Token to withdraw from the credit account to the wallet after the claim
+     **/
+    withdrawToken: Address;
+    /**
+     * Amount of `withdrawToken` to withdraw to the wallet after the claim
+     **/
+    withdrawAmount: bigint;
+}
+/**
+ * App: 2.2 Withdraw — close account (receive leftover to wallet).
+ **/
+export interface DelayedCloseAccountIntent {
+    type: "CLOSE_ACCOUNT";
+    /**
+     * Wallet address that receives leftover tokens when the account is closed
+     * after the claim
+     **/
+    to: Address;
+}
+/**
+ * App: 3.1 Add collateral — fixed debt.
+ * Add collateral -> swap collateral into the target token.
+ **/
+export interface DelayedAddCollateralIntent {
+    type: "ADD_COLLATERAL";
+}
+/**
+ * App: 4.2 Adjust leverage — lower leverage at fixed TVL.
+ * Swap collateral into `underlying` -> [decrease debt with `underlying`].
+ **/
+export interface DelayedDecreaseLeverageIntent {
+    type: "DECREASE_LEVERAGE";
+}
+/**
+ * Lean intent that is abi-encoded into `extraData` of a delayed withdrawal
+ * request and decoded back when reading claimable withdrawals.
+ *
+ * It allows the app to resume a multi-step operation that was interrupted by
+ * a delayed withdrawal: the intent records which operation was in progress
+ * (and the minimal set of parameters that cannot be re-derived at claim time),
+ * so that after the withdrawal is claimed, the remaining steps can be
+ * previewed and executed.
+ **/
+export type DelayedIntent = DelayedIncreaseLeverageIntent | DelayedDepositIntent | DelayedDepositAndIncreaseLeverageIntent | DelayedWithdrawCollateralIntent | DelayedCloseAccountIntent | DelayedAddCollateralIntent | DelayedDecreaseLeverageIntent;
+/**
+ * Delayed intent decoded from `extraData`, enriched with data known at read time.
+ **/
+export type DelayedIntentExtended = DelayedIntent & {
+    /**
+     * Credit manager of the credit account the withdrawal belongs to
+     **/
+    creditManager: Address;
+};
+/**
+ * A single output of a (delayed) withdrawal: one token amount produced by
+ * requesting or claiming a withdrawal.
+ **/
+export interface WithdrawalOutput {
+    /**
+     * Output token. For a delayed output, this is the withdrawal phantom token;
+     * otherwise the actual token received (usually the withdrawable asset's
+     * `underlying`)
+     **/
+    token: Address;
+    /**
+     * When `false`, the amount lands on the credit account immediately.
+     * When `true`, the amount is only represented by the withdrawal phantom
+     * token and becomes claimable after the withdrawal delay. A request can
+     * produce both kinds at once, e.g. Mellow serves the liquid part of a
+     * withdrawal instantly and queues the remainder
+     **/
+    isDelayed: boolean;
+    /**
+     * Amount of `token` produced (or expected to be produced) by the withdrawal
+     **/
+    amount: bigint;
+}
+/**
+ * An asset that can be withdrawn from a credit manager via delayed withdrawal.
+ **/
+export interface WithdrawableAsset {
+    /**
+     * Credit manager the asset is withdrawable from
+     **/
+    creditManager: Address;
+    /**
+     * Source token: the collateral that is spent when the
+     * withdrawal is requested, e.g. a Mellow multivault share, a Securitize
+     * dsToken or a Midas mToken
+     **/
+    token: Address;
+    /**
+     * Withdrawal phantom token: a non-transferable collateral
+     * token that represents the in-flight withdrawal position on the credit
+     * account while the withdrawal is pending
+     **/
+    withdrawalPhantomToken: Address;
+    /**
+     * Target token: the token ultimately received when the
+     * withdrawal is claimed
+     **/
+    underlying: Address;
+    /**
+     * Expected delay between requesting and claiming a withdrawal, in seconds
+     **/
+    withdrawalLength: bigint;
+    /**
+     * Maximum number of simultaneously open withdrawal requests per credit
+     * account.
+     * Not available on v310 compressors
+     **/
+    maxWithdrawals?: bigint;
+}
+/**
+ * A single delayed withdrawal that is ready to be claimed.
+ **/
+export interface ClaimableWithdrawal {
+    /**
+     * Source token the withdrawal was requested from
+     **/
+    token: Address;
+    /**
+     * Withdrawal phantom token that represents this withdrawal position
+     **/
+    withdrawalPhantomToken: Address;
+    /**
+     * Amount of the withdrawal phantom token that will be burned when the
+     * withdrawal is claimed
+     **/
+    withdrawalTokenSpent: bigint;
+    /**
+     * Tokens received by the credit account upon claiming
+     **/
+    outputs: WithdrawalOutput[];
+    /**
+     * Credit facade multicall (adapter calls) that executes the claim
+     **/
+    claimCalls: MultiCall[];
+    /**
+     * Delayed intent decoded from the withdrawal's `extraData`, enriched with
+     * the credit manager of the credit account. `undefined` on compressor
+     * versions below 313, and on v313+ when the withdrawal was requested
+     * without an intent (empty `extraData`).
+     **/
+    intent?: DelayedIntentExtended;
+}
+/**
+ * A single pending delayed withdrawal that is not yet claimable.
+ **/
+export interface PendingWithdrawal {
+    /**
+     * Source token the withdrawal was requested from
+     **/
+    token: Address;
+    /**
+     * Withdrawal phantom token that represents this withdrawal position
+     **/
+    withdrawalPhantomToken: Address;
+    /**
+     * Estimated tokens the credit account will receive once the withdrawal
+     * matures and is claimed
+     **/
+    expectedOutputs: WithdrawalOutput[];
+    /**
+     * Unix timestamp (in seconds) when the withdrawal becomes claimable
+     **/
+    claimableAt: bigint;
+    /**
+     * Delayed intent decoded from the withdrawal's `extraData`, enriched with
+     * the credit manager of the credit account. `undefined` on compressor
+     * versions below 313, and on v313+ when the withdrawal was requested
+     * without an intent (empty `extraData`).
+     **/
+    intent?: DelayedIntentExtended;
+}
+/**
+ * Result of previewing a delayed withdrawal request.
+ **/
+export interface RequestableWithdrawal {
+    /**
+     * Source token that will be spent by the request
+     **/
+    token: Address;
+    /**
+     * Amount of `token` that will actually be spent; the contract caps the
+     * requested amount at the credit account's balance
+     **/
+    amountIn: bigint;
+    /**
+     * Expected outputs of the request: instant outputs land on the credit
+     * account in the same transaction, delayed outputs become claimable
+     * at `claimableAt`
+     **/
+    outputs: WithdrawalOutput[];
+    /**
+     * Credit facade multicall (adapter calls) that submits the withdrawal request
+     **/
+    requestCalls: MultiCall[];
+    /**
+     * Estimated unix timestamp (in seconds) when the delayed outputs become
+     * claimable
+     **/
+    claimableAt: bigint;
+}
+/**
+ * Delayed withdrawals of a credit account, split into immediately claimable
+ * and still-pending entries.
+ **/
+export interface CurrentWithdrawals {
+    /**
+     * Withdrawals that have matured and can be claimed now
+     **/
+    claimable: ClaimableWithdrawal[];
+    /**
+     * Withdrawals that are still maturing
+     **/
+    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 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.
+     **/
+    loadWithdrawableAssets(force?: boolean): Promise<WithdrawableAsset[]>;
+    /**
+     * 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.
+     **/
+    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
+     * tokens. With no tokens given, returns empty lists.
+     * Only supported on v313+ compressors; on older versions throws if
+     * `sdk.strictContractTypes` is `true`, otherwise logs a warning and
+     * returns empty lists.
+     **/
+    getExternalAccountCurrentWithdrawals(account: Address, ...withdrawalTokens: 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.
+     *
+     * When `intent` is provided, it is abi-encoded and passed as `extraData` to
+     * the contract on v313+ compressors. On older versions, passing an intent
+     * throws if `sdk.strictContractTypes` is `true`, otherwise a warning is
+     * logged and the intent is ignored.
+     **/
+    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;
+}
+/**
+ * Redemption data logged by a delayed-withdrawal gateway (Securitize, Midas)
+ * when a redemption is requested, keyed by the redeemer contract address.
+ **/
+export interface RedemptionLog {
+    /**
+     * Credit account the redemption was requested for
+     */
+    creditAccount: Address;
+    /**
+     * Redeemer contract address
+     */
+    redeemer: Address;
+    /**
+     * Additional redemption data; carries the abi-encoded `DelayedIntent`
+     * when the request had one, `0x` otherwise
+     */
+    extraData: Hex;
+}
+/**
+ * Version-agnostic interface of the RedemptionLogger contract that stores
+ * redemption data logged by delayed-withdrawal gateways for off-chain
+ * indexing.
+ **/
+export interface IRedemptionLoggerContract extends IBaseContract {
+    /**
+     * Returns the redemption data logged for a redeemer; all-zero fields when
+     * nothing was logged for it.
+     **/
+    getRedemptionLog(redeemer: Address, blockNumber?: bigint): Promise<RedemptionLog>;
+    /**
+     * Reads the redemption log of a redeemer and decodes the recorded intent.
+     *
+     * @param redeemer - Redeemer contract the withdrawal is claimed from.
+     * @param blockNumber - Optional block number to read the log at.
+     * @returns The decoded intent, or `undefined` when the log carries none
+     * (including when nothing was logged for the redeemer).
+     * @throws InvalidDelayedIntentError when the logged `extraData` is
+     * non-empty but cannot be decoded as a `DelayedIntent`.
+     **/
+    getDelayedIntent(redeemer: Address, blockNumber?: bigint): Promise<DelayedIntent | undefined>;
+}

package/dist/types/sdk/base/BaseContract.d.ts

@@ -151,7 +151,7 @@ export declare class BaseContract<abi extends Abi | readonly unknown[]> extends
      * @param strict - propagated from parseFunctionDataV2 for recursive parsing
      */
     protected parseFunctionParamsV2(params: DecodeFunctionDataReturnType<abi>, _strict?: boolean): Record<string, unknown>;
-    protected wrapParseCallV2(functionName: string, rawArgs: Record<string, unknown>): ParsedCallV2;
+    protected wrapParseCallV2(functionName: string, calldata: Hex, rawArgs: Record<string, unknown>): ParsedCallV2;
     /**
      * Creates a raw transaction for a function in this contract
      * @param parameters

package/dist/types/sdk/base/TokensMeta.d.ts

@@ -1,5 +1,5 @@
 import type { Address, Chain, PublicClient, Transport } from "viem";
-import type { Asset } from "../router/index.js";
+import type { Asset } from "../index.js";
 import type { ILogger } from "../types/logger.js";
 import { AddressMap } from "../utils/index.js";
 import type { PhantomTokenMeta, RWATokenMeta, TokenMetaData } from "./token-types.js";

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

@@ -87,6 +87,20 @@ export interface TokenInfo {
      **/
     success: boolean;
 }
+/**
+ * A token address paired with a balance, used throughout the SDK to
+ * represent holdings, collateral inputs, and leftover targets.
+ **/
+export interface Asset {
+    /**
+     * ERC-20 token address.
+     **/
+    token: Address;
+    /**
+     * Token amount in the token's native decimals.
+     **/
+    balance: bigint;
+}
 /**
  * Compile-time assertion: `U` must be assignable to `T`.
  *
@@ -337,6 +351,10 @@ export interface ParsedCallV2 {
      * For unknown selectors: `"unknown function 0x1a2b3c4d"`
      */
     functionName: string;
+    /**
+     * Raw ABI-encoded calldata this call was parsed from.
+     **/
+    calldata: Hex;
     /**
      * Named arguments with their original types (bigint, Address, etc.).
      **/

package/dist/types/sdk/chain/chains.d.ts

@@ -59,22 +59,22 @@ export declare const SUPPORTED_NETWORKS: readonly ["Mainnet", "Arbitrum", "Optim
  * Zod schema for validating/parsing network type strings.
  **/
 export declare const NetworkType: z.ZodEnum<{
-    Mainnet: "Mainnet";
     Arbitrum: "Arbitrum";
-    Optimism: "Optimism";
-    Base: "Base";
-    Sonic: "Sonic";
-    MegaETH: "MegaETH";
-    Monad: "Monad";
-    Berachain: "Berachain";
     Avalanche: "Avalanche";
     BNB: "BNB";
-    WorldChain: "WorldChain";
+    Base: "Base";
+    Berachain: "Berachain";
     Etherlink: "Etherlink";
     Hemi: "Hemi";
     Lisk: "Lisk";
+    Mainnet: "Mainnet";
+    MegaETH: "MegaETH";
+    Monad: "Monad";
+    Optimism: "Optimism";
     Plasma: "Plasma";
     Somnia: "Somnia";
+    Sonic: "Sonic";
+    WorldChain: "WorldChain";
 }>;
 /**
  * All supported Gearbox network labels

package/dist/types/sdk/constants/address-provider.d.ts

@@ -32,6 +32,7 @@ export declare const AP_WETH_TOKEN = "WETH_TOKEN";
 export declare const AP_ZAPPER_REGISTER = "ZAPPER_REGISTER";
 export declare const AP_ZERO_PRICE_FEED = "ZERO_PRICE_FEED";
 export declare const AP_RWA_COMPRESSOR = "GLOBAL::RWA_COMPRESSOR";
+export declare const AP_REDEMPTION_LOGGER = "LOCAL::REDEMPTION_LOGGER";
 /**
  * Default address provider address for v3.1.0
  * Is determenistic and does not depend on the network type

package/dist/types/sdk/market/MarketConfiguratorContract.d.ts

@@ -1532,13 +1532,13 @@ export declare class MarketConfiguratorContract extends BaseContract<abi> {
     constructor(options: ConstructOptions, address: Address);
     loadCuratorName(): Promise<void>;
     static getPeripheryContractBatch(configurators: MarketConfiguratorContract[], client: MarketConfiguratorContract["client"], contract: PeripheryContract, blockNumber?: bigint): Promise<({
-        error: Error;
-        result?: undefined;
-        status: "failure";
-    } | {
         error?: undefined;
         result: readonly `0x${string}`[];
-        status: "success";
+        status: 'success';
+    } | {
+        error: Error;
+        result?: undefined;
+        status: 'failure';
     })[]>;
     getPeripheryContract(contract: PeripheryContract): Promise<Address>;
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;

package/dist/types/sdk/market/pricefeeds/PythPriceFeed.d.ts

@@ -219,7 +219,7 @@ declare const abi: readonly [{
 type abi = typeof abi;
 declare const iPythAbi: readonly [{
     readonly name: "getUpdateFee";
-    readonly type: "function";
+    readonly type: 'function';
     readonly stateMutability: "view";
     readonly inputs: readonly [{
         readonly type: "bytes[]";

package/dist/types/sdk/market/rwa/securitize/SecuritizeRWAFactory.d.ts

@@ -6,7 +6,7 @@ import type { MultiCall, RawTx } from "../../../types/index.js";
 import type { IRWAFactory, RWACompressorInvestorData, RWAFactoryData } from "../types.js";
 import { RWA_FACTORY_SECURITIZE } from "./constants.js";
 import { SecuritizeDegenNFT } from "./SecuritizeDegenNFT.js";
-import { type DStokenData, type SecuritizeInvestorData, type SecuritizeOpenAccountRequirements, type SecuritizeOperationParams, type SecuritizeRWAFactoryStateHuman } from "./types.js";
+import { type DStokenData, type SecuritizeInvestorData, type SecuritizeMissingOpenAccountRequirements, type SecuritizeOpenAccountRequirements, type SecuritizeOperationArgs, type SecuritizeRWAFactoryStateHuman } from "./types.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly name: "contractType";
@@ -493,15 +493,23 @@ export declare class SecuritizeRWAFactory extends BaseContract<abi> implements I
     /**
      * {@inheritDoc IRWAFactory.multicall}
      */
-    multicall(creditAccount: Address, calls: MultiCall[], options?: SecuritizeOperationParams): RawTx;
+    multicall(creditAccount: Address, calls: MultiCall[], args?: SecuritizeOperationArgs): RawTx;
     /**
      * {@inheritDoc IRWAFactory.getOpenAccountRequirements}
      */
     getOpenAccountRequirements(investor: Address, props: GetOpenAccountRequirementsProps): Promise<SecuritizeOpenAccountRequirements | undefined>;
+    /**
+     * {@inheritDoc IRWAFactory.getMissingRequirements}
+     *
+     * A required signature is omitted when `providedArgs.signaturesToCache`
+     * already carries a signature for the same token: the transaction caches it
+     * on-chain as part of the operation.
+     */
+    getMissingRequirements(requirements: SecuritizeOpenAccountRequirements, providedArgs?: SecuritizeOperationArgs): SecuritizeMissingOpenAccountRequirements | undefined;
     /**
      * {@inheritDoc IRWAFactory.openCreditAccount}
      */
-    openCreditAccount(creditManager: Address, calls: MultiCall[], options?: SecuritizeOperationParams): RawTx;
+    openCreditAccount(creditManager: Address, calls: MultiCall[], args?: SecuritizeOperationArgs): RawTx;
     stateHuman(_raw?: boolean): SecuritizeRWAFactoryStateHuman;
 }
 export {};

package/dist/types/sdk/market/rwa/securitize/types.d.ts

@@ -120,16 +120,32 @@ export interface SecuritizeRWAFactoryStateHuman extends BaseContractStateHuman {
     }[];
 }
 /**
- * Factory-specific parameters for {@link SecuritizeRWAFactory.multicall}
+ * Factory-specific args for {@link SecuritizeRWAFactory.multicall}
  * and {@link SecuritizeRWAFactory.openCreditAccount}.
  **/
-export interface SecuritizeOperationParams {
+export interface SecuritizeOperationArgs {
     type: typeof RWA_FACTORY_SECURITIZE;
     /** DSToken addresses to register for this operation. */
     tokensToRegister: Address[];
     /** Cached EIP-712 registration signatures to store on-chain. */
     signaturesToCache: SecuritizeRegisterMessage[];
 }
+/**
+ * Subset of {@link SecuritizeOpenAccountRequirements} still unfulfilled given
+ * the params already carried by the transaction calldata. Returned by
+ * `SecuritizeRWAFactory.getMissingRequirements`; `undefined` there means the
+ * requirements are satisfied.
+ **/
+export interface SecuritizeMissingOpenAccountRequirements {
+    type: typeof RWA_FACTORY_SECURITIZE;
+    /**
+     * EIP-712 messages the investor still has to sign (not covered by
+     * calldata-provided signatures). Once signed, they become the
+     * `signaturesToCache` arg of the factory's `openCreditAccount`/`multicall`
+     * calls (see {@link SecuritizeOperationArgs}).
+     */
+    requiredSignatures: SecuritizeRegisterVaultMessage[];
+}
 export interface SecuritizeOpenAccountRequirements {
     type: typeof RWA_FACTORY_SECURITIZE;
     /**