@gearbox-protocol/sdk 14.12.0-next.11 → 14.12.0-next.13

package/dist/esm/sdk/accounts/CreditAccountsServiceV310.js

@@ -1589,19 +1589,14 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     );
   }
   /**
-   * {@inheritDoc ICreditAccountsService.assembleCaUpdateCalls}
+   * {@inheritDoc ICreditAccountsService.assembleCaOperations}
    */
-  assembleCaUpdateCalls({
+  assembleCaOperations({
     operations,
-    routerCallGroups,
     creditFacade,
-    withdrawTo,
-    creditAccount,
-    underlyingToken
+    withdrawTo
   }) {
     const calls = [];
-    let swapGroupIndex = 0;
-    let routerGroupsConsumed = 0;
     for (const op of operations) {
       switch (op.type) {
         case "increaseDebt":
@@ -1629,18 +1624,10 @@ class CreditAccountsServiceV310 extends SDKConstruct {
             )
           );
           break;
-        case "swap": {
-          const routerCalls = routerCallGroups[swapGroupIndex];
-          if (!routerCalls) {
-            throw new Error(
-              `assembleCaUpdateCalls: missing router calls for swap leg ${swapGroupIndex}`
-            );
-          }
-          calls.push(...routerCalls);
-          swapGroupIndex += 1;
-          routerGroupsConsumed += 1;
+        case "swap":
+        case "wrapRwaCollateral":
+          calls.push(...op.calls);
           break;
-        }
         case "changeQuota": {
           const quotaAssets = [...op.quotaIncrease, ...op.quotaDecrease];
           if (quotaAssets.length === 0) {
@@ -1654,43 +1641,110 @@ class CreditAccountsServiceV310 extends SDKConstruct {
           );
           break;
         }
-        case "closeCreditAccount": {
-          for (const group of routerCallGroups) {
-            calls.push(...group);
-            routerGroupsConsumed += 1;
-          }
+        default: {
+          const _exhaustive = op;
+          throw new Error(
+            `assembleCaOperations: unsupported operation ${JSON.stringify(_exhaustive)}`
+          );
+        }
+      }
+    }
+    return calls;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.assembleCaUpdateCalls}
+   * @deprecated Prefer {@link CreditAccountsServiceV310.assembleCaOperations}.
+   */
+  assembleCaUpdateCalls({
+    operations,
+    routerCallGroups,
+    creditFacade,
+    withdrawTo,
+    creditAccount,
+    underlyingToken
+  }) {
+    const calls = [];
+    let swapGroupIndex = 0;
+    let routerGroupsConsumed = 0;
+    const encodableOps = [];
+    let pendingClose = null;
+    const flushEncodable = () => {
+      if (encodableOps.length === 0) {
+        return;
+      }
+      calls.push(
+        ...this.assembleCaOperations({
+          operations: encodableOps.splice(0, encodableOps.length),
+          creditFacade,
+          withdrawTo
+        })
+      );
+    };
+    for (const op of operations) {
+      if (op.type === "closeCreditAccount") {
+        flushEncodable();
+        pendingClose = { routerGroupsStart: routerGroupsConsumed };
+        for (const group of routerCallGroups.slice(routerGroupsConsumed)) {
+          calls.push(...group);
+          routerGroupsConsumed += 1;
+        }
+        calls.push(
+          ...this.#prepareDisableQuotas({
+            creditFacade,
+            tokens: Object.entries(creditAccount.initialQuotas).map(
+              ([token, { quota }]) => ({
+                token,
+                quota
+              })
+            )
+          })
+        );
+        if (creditAccount.debt > 0n) {
           calls.push(
-            ...this.#prepareDisableQuotas({
+            ...this.#prepareDecreaseDebt({
               creditFacade,
-              tokens: Object.entries(creditAccount.initialQuotas).map(
-                ([token, { quota }]) => ({
-                  token,
-                  quota
-                })
-              )
+              debt: creditAccount.debt
             })
           );
-          if (creditAccount.debt > 0n) {
-            calls.push(
-              ...this.#prepareDecreaseDebt({
-                creditFacade,
-                debt: creditAccount.debt
-              })
-            );
-          }
-          const hasAssets = creditAccount.assets.some(
-            (asset) => asset.balance > 0n
+        }
+        const hasAssets = creditAccount.assets.some(
+          (asset) => asset.balance > 0n
+        );
+        if (hasAssets) {
+          calls.push(
+            this.#prepareWithdrawToken(
+              creditFacade,
+              underlyingToken,
+              MAX_UINT256,
+              withdrawTo
+            )
           );
-          if (hasAssets) {
-            calls.push(
-              this.#prepareWithdrawToken(
-                creditFacade,
-                underlyingToken,
-                MAX_UINT256,
-                withdrawTo
-              )
+        }
+        continue;
+      }
+      if (pendingClose !== null) {
+        throw new Error(
+          "assembleCaUpdateCalls: operations after closeCreditAccount are not supported"
+        );
+      }
+      switch (op.type) {
+        case "increaseDebt":
+        case "decreaseDebt":
+        case "addCollateral":
+        case "withdrawCollateral":
+        case "changeQuota":
+          encodableOps.push(op);
+          break;
+        case "swap": {
+          const routerCalls = routerCallGroups[swapGroupIndex];
+          if (!routerCalls) {
+            throw new Error(
+              `assembleCaUpdateCalls: missing router calls for swap leg ${swapGroupIndex}`
             );
           }
+          encodableOps.push({ type: "swap", calls: routerCalls });
+          swapGroupIndex += 1;
+          routerGroupsConsumed += 1;
           break;
         }
         default: {
@@ -1701,6 +1755,7 @@ class CreditAccountsServiceV310 extends SDKConstruct {
         }
       }
     }
+    flushEncodable();
     if (routerGroupsConsumed !== routerCallGroups.length) {
       throw new Error(
         `assembleCaUpdateCalls: router call group mismatch (consumed ${routerGroupsConsumed}, got ${routerCallGroups.length})`

package/dist/esm/sdk/market/rwa/securitize/SecuritizeRWAFactory.js

@@ -170,8 +170,8 @@ class SecuritizeRWAFactory extends BaseContract {
   /**
    * {@inheritDoc IRWAFactory.multicall}
    */
-  multicall(creditAccount, calls, options) {
-    const { tokensToRegister = [], signaturesToCache = [] } = options ?? {};
+  multicall(creditAccount, calls, args) {
+    const { tokensToRegister = [], signaturesToCache = [] } = args ?? {};
     return this.createRawTx({
       functionName: "multicall",
       args: [creditAccount, calls, tokensToRegister, signaturesToCache]
@@ -201,11 +201,33 @@ class SecuritizeRWAFactory extends BaseContract {
       requiredSignatures
     };
   }
+  /**
+   * {@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, providedArgs) {
+    const providedTokens = new AddressSet(
+      (providedArgs?.signaturesToCache ?? []).map((s) => s.token)
+    );
+    const requiredSignatures = requirements.requiredSignatures.filter(
+      (message) => !providedTokens.has(message.message.token)
+    );
+    if (requiredSignatures.length === 0) {
+      return void 0;
+    }
+    return {
+      type: RWA_FACTORY_SECURITIZE,
+      requiredSignatures
+    };
+  }
   /**
    * {@inheritDoc IRWAFactory.openCreditAccount}
    */
-  openCreditAccount(creditManager, calls, options) {
-    const { tokensToRegister = [], signaturesToCache = [] } = options ?? {};
+  openCreditAccount(creditManager, calls, args) {
+    const { tokensToRegister = [], signaturesToCache = [] } = args ?? {};
     return this.createRawTx({
       functionName: "openCreditAccount",
       args: [creditManager, calls, tokensToRegister, signaturesToCache]

package/dist/esm/sdk/utils/AddressSet.js

@@ -15,6 +15,13 @@ class AddressSet extends Set {
   has(value) {
     return super.has(getAddress(value));
   }
+  difference(other) {
+    const result = new AddressSet(this.keys());
+    for (const key of other) {
+      result.delete(getAddress(key));
+    }
+    return result;
+  }
   /**
    * Returns all addresses as an array.
    **/

package/dist/types/preview/parse/parseRWAFactoryOperationCalldata.d.ts

@@ -17,6 +17,6 @@ export interface ParseRWAFactoryOperationCalldataProps {
  * identical to {@link parseFacadeOperationCalldata}.
  *
  * Dispatches on the factory's contract type; supporting a new factory type
- * requires a new branch here plus new operation types in `types-rwa.ts`.
+ * requires a new branch here.
  */
 export declare function parseRWAFactoryOperationCalldata(props: ParseRWAFactoryOperationCalldataProps): RWAOperation;

package/dist/types/preview/parse/types-rwa.d.ts

@@ -1,5 +1,5 @@
 import type { Address } from "viem";
-import type { SecuritizeRegisterMessage } from "../../sdk/index.js";
+import type { RWAOperationArgs } from "../../sdk/index.js";
 import type { InnerOperation } from "./types-facades.js";
 /**
  * Metadata shared by all RWA factory operations. RWA credit accounts are
@@ -13,36 +13,24 @@ export interface RWAOperationMetadata {
     creditManager: Address;
     creditFacade: Address;
 }
-export interface SecuritizeOpenCreditAccountOperation<Ext extends object = {}> extends RWAOperationMetadata {
-    operation: "SecuritizeOpenCreditAccount";
+export interface RWAOpenCreditAccountOperation<Ext extends object = {}> extends RWAOperationMetadata {
+    operation: "RWAOpenCreditAccount";
     multicall: InnerOperation<Ext>[];
     /**
-     * DSToken addresses to register, decoded from calldata. Empty in the
-     * template flow, where the real value comes from the factory's open-account
-     * requirements.
+     * Factory-specific registration args decoded from calldata (for
+     * Securitize: `tokensToRegister`/`signaturesToCache`).
      */
-    tokensToRegister: Address[];
-    /**
-     * EIP-712 registration signatures to store on-chain, decoded from calldata.
-     * Empty in the template flow.
-     */
-    signaturesToCache: SecuritizeRegisterMessage[];
+    args: RWAOperationArgs;
 }
-/**
- * `SecuritizeRWAFactory.multicall` call: like the facade's `multicall`, plus
- * the factory-specific registration args.
- */
-export interface SecuritizeMulticallOperation<Ext extends object = {}> extends RWAOperationMetadata {
-    operation: "SecuritizeMulticall";
+export interface RWAMulticallOperation<Ext extends object = {}> extends RWAOperationMetadata {
+    operation: "RWAMulticall";
     creditAccount: Address;
     multicall: InnerOperation<Ext>[];
-    /** DSToken addresses to register, decoded from calldata. */
-    tokensToRegister: Address[];
-    /** EIP-712 registration signatures to store on-chain, decoded from calldata. */
-    signaturesToCache: SecuritizeRegisterMessage[];
+    /** Factory-specific registration args decoded from calldata. */
+    args: RWAOperationArgs;
 }
 /**
  * Discriminated union of all RWA factory operation types. Extend it when
  * adding support for a new RWA factory type.
  */
-export type RWAOperation<Ext extends object = {}> = SecuritizeOpenCreditAccountOperation<Ext> | SecuritizeMulticallOperation<Ext>;
+export type RWAOperation<Ext extends object = {}> = RWAOpenCreditAccountOperation<Ext> | RWAMulticallOperation<Ext>;

package/dist/types/preview/prerequisites/AllowancePrerequisite.d.ts

@@ -1,6 +1,6 @@
-import { type Address, type ContractFunctionParameters } from "viem";
-import { type MulticallCallResult, Prerequisite } from "./Prerequisite.js";
-import type { PrerequisiteDetail, PrerequisiteResult } from "./types.js";
+import { type Address } from "viem";
+import { Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteResult } from "./types.js";
 export interface AllowancePrerequisiteProps {
     token: Address;
     owner: Address;
@@ -17,6 +17,5 @@ export declare class AllowancePrerequisite extends Prerequisite<"allowance"> {
     get kind(): "allowance";
     get title(): string;
     get detail(): PrerequisiteDetail<"allowance">;
-    calls(): ContractFunctionParameters[];
-    resolve(slice: MulticallCallResult[]): PrerequisiteResult<"allowance">;
+    protected check(ctx: PrerequisiteContext): Promise<PrerequisiteResult<"allowance">>;
 }

package/dist/types/preview/prerequisites/BalancePrerequisite.d.ts

@@ -1,5 +1,5 @@
-import { type Address, type ContractFunctionParameters } from "viem";
-import { type MulticallCallResult, Prerequisite } from "./Prerequisite.js";
+import { type Address } from "viem";
+import { Prerequisite } from "./Prerequisite.js";
 import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteResult } from "./types.js";
 export interface BalancePrerequisiteProps {
     token: Address;
@@ -11,8 +11,7 @@ export interface BalancePrerequisiteProps {
 /**
  * Checks that `owner` holds a token balance >= `required`. The token is read
  * as an ERC-20, except for the native pseudo-address ({@link NATIVE_ADDRESS},
- * e.g. ETH-zapper deposits) whose balance is read via multicall3's
- * `getEthBalance`.
+ * e.g. ETH-zapper deposits) whose balance is read via `getBalance`.
  */
 export declare class BalancePrerequisite extends Prerequisite<"balance"> {
     #private;
@@ -21,6 +20,5 @@ export declare class BalancePrerequisite extends Prerequisite<"balance"> {
     get kind(): "balance";
     get title(): string;
     get detail(): PrerequisiteDetail<"balance">;
-    calls(ctx: PrerequisiteContext): ContractFunctionParameters[];
-    resolve(slice: MulticallCallResult[]): PrerequisiteResult<"balance">;
+    protected check(ctx: PrerequisiteContext): Promise<PrerequisiteResult<"balance">>;
 }

package/dist/types/preview/prerequisites/Prerequisite.d.ts

@@ -1,37 +1,10 @@
-import { type ContractFunctionParameters } from "viem";
-import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteError, PrerequisiteKind, PrerequisiteResult } from "./types.js";
+import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteKind, PrerequisiteResult } from "./types.js";
 /**
- * One entry of a viem `multicall({ allowFailure: true })` response: either a
- * decoded `result` or the `error` that the call reverted with.
- */
-export type MulticallCallResult = {
-    status: "success";
-    result: unknown;
-    error?: undefined;
-} | {
-    status: "failure";
-    result?: undefined;
-    error: Error;
-};
-/**
- * Decodes an unknown error into a {@link PrerequisiteError} with a
- * human-readable revert reason. Mirrors the SDK's `extractCallError`: walk the
- * viem error chain for a {@link ContractFunctionRevertedError} and use its
- * `errorName`, otherwise fall back to the error's short message / name.
- */
-export declare function toPrerequisiteError(cause: unknown): PrerequisiteError;
-/**
- * A single verifiable prerequisite for a transaction. Subclasses describe the
- * on-chain reads they need ({@link calls}) and how to turn the multicall slice
- * into a {@link PrerequisiteResult} ({@link resolve}).
+ * A single verifiable prerequisite for a transaction. Subclasses implement
+ * {@link check} to perform whatever async reads they need (an ERC-20
+ * `readContract`, a compressor call, ...) and map the outcome into a
+ * {@link PrerequisiteResult}.
  *
- * Identity (`id`, `kind`, `title`) and build-time `detail` are exposed as
- * read-only accessors; subclasses back them with private fields. The shared
- * {@link satisfiedResult}/{@link errorResult} helpers are `protected` so each
- * subclass builds results consistently.
- *
- * The same instance can be verified standalone via {@link verify} or batched
- * together with others by `verifyPrerequisites`.
  */
 export declare abstract class Prerequisite<K extends PrerequisiteKind> {
     /** Stable identifier, used as a React key and for deduplication. */
@@ -42,19 +15,22 @@ export declare abstract class Prerequisite<K extends PrerequisiteKind> {
     abstract get title(): string;
     /** Inputs known before reading the chain (no `actual` yet). */
     abstract get detail(): PrerequisiteDetail<K>;
-    /** Contract reads this check needs (usually one). */
-    abstract calls(ctx: PrerequisiteContext): ContractFunctionParameters[];
-    /** Maps this check's slice of the multicall response into a result. */
-    abstract resolve(slice: MulticallCallResult[]): PrerequisiteResult<K>;
     /**
-     * Verifies this prerequisite on its own using an `allowFailure` multicall.
-     * Prefer `verifyPrerequisites` to batch several checks into one round-trip.
+     * Verifies this prerequisite. Never rejects: any error thrown by
+     * {@link check} (revert, RPC/network failure, compressor error) is
+     * normalized into an `error` result.
      */
     verify(ctx: PrerequisiteContext): Promise<PrerequisiteResult<K>>;
+    /**
+     * Performs the reads this prerequisite needs and maps them into a result.
+     * May throw on read failure; {@link verify} converts throws into `error`
+     * results.
+     */
+    protected abstract check(ctx: PrerequisiteContext): Promise<PrerequisiteResult<K>>;
     /** Builds a successful result; `detail` carries the on-chain `actual`. */
     protected satisfiedResult(satisfied: boolean, detail: PrerequisiteDetail<K>): PrerequisiteResult<K>;
-    /** Builds a failed result from a decoded read error. */
-    protected errorResult(error: PrerequisiteError): PrerequisiteResult<K>;
+    /** Builds a failed result from a raw read error (normalized internally). */
+    protected errorResult(cause: unknown): PrerequisiteResult<K>;
 }
 /** Any prerequisite regardless of its kind, used for heterogeneous lists. */
 export type AnyPrerequisite = Prerequisite<PrerequisiteKind>;

package/dist/types/preview/prerequisites/RWAOpenRequirementsPrerequisite.d.ts

@@ -1,14 +1,21 @@
-import type { Address, ContractFunctionParameters } from "viem";
-import type { RWAOpenAccountRequirements } from "../../sdk/index.js";
+import type { Address } from "viem";
+import type { RWAOperationArgs } from "../../sdk/index.js";
 import { Prerequisite } from "./Prerequisite.js";
-import type { PrerequisiteDetail, PrerequisiteResult } from "./types.js";
+import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteResult } from "./types.js";
 export interface RWAOpenRequirementsPrerequisiteProps {
-    /** Requirements already resolved via `sdk.accounts.getOpenAccountRequirements`. */
-    requirements: RWAOpenAccountRequirements;
-    /** RWA token (e.g. Securitize DSToken) the requirements were computed for. */
+    /** RWA token (e.g. Securitize DSToken) to check the requirements for. */
     token: Address;
-    /** RWA factory that produced the requirements. */
+    /** Credit manager of the RWA market. */
+    creditManager: Address;
+    /** RWA factory that gates the token. */
     factory: Address;
+    /**
+     * Factory-specific registration params already carried by the transaction
+     * calldata. Passed through to the factory's `getMissingRequirements`: e.g.
+     * signatures provided here need not be signed again, since the transaction
+     * itself caches them on-chain.
+     */
+    providedArgs?: RWAOperationArgs;
     title?: string;
     id?: string;
 }
@@ -16,12 +23,13 @@ export interface RWAOpenRequirementsPrerequisiteProps {
  * Checks that the borrower has fulfilled the RWA factory's open-account
  * requirements (issuer-side token registration, EIP-712 signatures).
  *
- * Unlike `allowance`/`balance`, the requirements cannot be derived from plain
- * ERC-20 multicall reads: they come from an async compressor read performed by
- * `sdk.accounts.getOpenAccountRequirements`. The prerequisite is therefore
- * *pre-resolved*: it is constructed with the requirements already computed,
- * contributes no calls to the verification multicall, and `resolve` only
- * interprets the stored payload.
+ * The requirements are fetched at verify time via
+ * `sdk.accounts.getOpenAccountRequirements`, so re-running verification picks
+ * up off-chain progress (the borrower registering on the issuer's website or
+ * signing the factory's message) without rebuilding the prerequisites. The
+ * unfulfilled subset is computed by the factory itself
+ * (`IRWAFactory.getMissingRequirements`) and exposed on the result's
+ * `detail.missing`; the full requirements are kept on `detail.requirements`.
  */
 export declare class RWAOpenRequirementsPrerequisite extends Prerequisite<"rwaOpenRequirements"> {
     #private;
@@ -30,7 +38,5 @@ export declare class RWAOpenRequirementsPrerequisite extends Prerequisite<"rwaOp
     get kind(): "rwaOpenRequirements";
     get title(): string;
     get detail(): PrerequisiteDetail<"rwaOpenRequirements">;
-    /** Pre-resolved: no on-chain reads to contribute. */
-    calls(): ContractFunctionParameters[];
-    resolve(): PrerequisiteResult<"rwaOpenRequirements">;
+    protected check(ctx: PrerequisiteContext): Promise<PrerequisiteResult<"rwaOpenRequirements">>;
 }

package/dist/types/preview/prerequisites/buildCollateralPrerequisites.d.ts

@@ -0,0 +1,14 @@
+import { type GetApprovalAddressProps } from "../../sdk/index.js";
+import type { InnerOperation } from "../parse/index.js";
+import type { AnyPrerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext } from "./types.js";
+/**
+ * For every `addCollateral` inside a multicall, requires the wallet to approve
+ * and hold the collateral token for the collateral spender.
+ *
+ * The approval spender is resolved via {@link OnchainSDK.accounts.getApprovalAddress}:
+ * the credit manager for classic markets, but a per-investor "special wallet"
+ * for RWA markets. The resolution happens at build time because the spender is
+ * part of the prerequisite's identity and UI detail.
+ */
+export declare function buildCollateralPrerequisites(spenderOptions: GetApprovalAddressProps, multicall: InnerOperation[], ctx: PrerequisiteContext): Promise<AnyPrerequisite[]>;

package/dist/types/preview/prerequisites/buildPartialLiquidationPrerequisites.d.ts

@@ -0,0 +1,8 @@
+import type { PartialLiquidationOperation } from "../parse/index.js";
+import type { AnyPrerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext } from "./types.js";
+/**
+ * Partial liquidation pulls the repaid underlying from the liquidator: they
+ * must have approved it to the credit manager and hold enough of it.
+ */
+export declare function buildPartialLiquidationPrerequisites(tx: PartialLiquidationOperation, ctx: PrerequisiteContext): AnyPrerequisite[];

package/dist/types/preview/prerequisites/buildPoolPrerequisites.d.ts

@@ -0,0 +1,8 @@
+import { type Address } from "viem";
+import type { PoolOperation } from "../parse/index.js";
+import type { AnyPrerequisite } from "./Prerequisite.js";
+/**
+ * Prerequisites for ERC4626 pool operations (deposit, mint, withdraw, redeem),
+ * either direct or zapper-routed.
+ */
+export declare function buildPoolPrerequisites(tx: PoolOperation, wallet: Address): AnyPrerequisite[];

package/dist/types/preview/prerequisites/buildRWAPrerequisites.d.ts

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+import { type RWAOperationArgs } from "../../sdk/index.js";
+import type { InnerOperation } from "../parse/index.js";
+import type { AnyPrerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext } from "./types.js";
+/**
+ * For RWA-factory open-account operations (e.g. `RWAOpenCreditAccount`),
+ * builds a prerequisite per RWA token the multicall touches; each one checks
+ * the factory's open-account requirements (issuer-side token registration,
+ * EIP-712 signatures) at verify time.
+ *
+ * The `providedArgs` params are the registration values decoded from the
+ * transaction calldata itself: signatures already included there satisfy the
+ * signature requirement, so a fully built transaction is not reported as
+ * missing signatures. In the template flow they are empty and the verified
+ * result's `detail.missing` describes what is still unfulfilled; acting on it
+ * (signing, rebuilding calldata) is up to the consumer.
+ *
+ * Returns nothing for non-RWA markets.
+ */
+export declare function buildRWAPrerequisites(multicall: InnerOperation[], creditManager: Address, providedArgs: RWAOperationArgs, ctx: PrerequisiteContext): AnyPrerequisite[];

package/dist/types/preview/prerequisites/checkPrerequisites.d.ts

@@ -0,0 +1,27 @@
+import type { PluginsMap } from "../../sdk/index.js";
+import { type ParseOperationCalldataInput } from "../parse/parseOperationCalldata.js";
+import type { AnyPrerequisiteResult } from "./types.js";
+/**
+ * Input of {@link checkPrerequisites}: the same raw-calldata input as the
+ * internal calldata parser, plus an optional block to read at.
+ */
+export type CheckPrerequisitesInput<P extends PluginsMap = PluginsMap> = ParseOperationCalldataInput<P> & {
+    /** Block to read at; defaults to latest. Only set for testnet forks. */
+    blockNumber?: bigint;
+};
+/**
+ * Derives and verifies the on-chain prerequisites for an operation given its
+ * raw calldata: the conditions that must hold for the call not to revert and
+ * that we can verify with the SDK (token approvals, wallet balances, RWA
+ * open-account requirements).
+ *
+ * Each prerequisite performs its own reads and resolves into an
+ * {@link AnyPrerequisiteResult} (`satisfied` or `error`).
+ *
+ * Only *sender-actionable* prerequisites belong here: conditions the LP
+ * provider or borrower can fix themselves before retrying (e.g. approve a
+ * token, top up a balance, sign the RWA factory's messages). Non-actionable
+ * protocol/admin state (e.g. pool is paused) is intentionally out of scope,
+ * since the user cannot resolve it.
+ */
+export declare function checkPrerequisites<P extends PluginsMap>(input: CheckPrerequisitesInput<P>): Promise<AnyPrerequisiteResult[]>;

package/dist/types/preview/prerequisites/helpers.d.ts

@@ -0,0 +1,15 @@
+import type { Address } from "viem";
+import type { AnyPrerequisite } from "./Prerequisite.js";
+export interface AllowanceAndBalanceProps {
+    token: Address;
+    owner: Address;
+    spender: Address;
+    required: bigint;
+    allowanceTitle: string;
+    balanceTitle: string;
+}
+/**
+ * The most common prerequisite pair: `owner` must have approved `spender` for
+ * `required` of `token` and must hold at least that much of it.
+ */
+export declare function allowanceAndBalance(props: AllowanceAndBalanceProps): AnyPrerequisite[];

package/dist/types/preview/prerequisites/index.d.ts

@@ -1,8 +1,6 @@
 export * from "./AllowancePrerequisite.js";
 export * from "./BalancePrerequisite.js";
-export * from "./buildPrerequisites.js";
+export * from "./checkPrerequisites.js";
 export * from "./Prerequisite.js";
-export * from "./prepareAction.js";
 export * from "./RWAOpenRequirementsPrerequisite.js";
-export * from "./runPrerequisites.js";
 export * from "./types.js";

package/dist/types/preview/prerequisites/types.d.ts

@@ -1,5 +1,5 @@
 import type { Address } from "viem";
-import type { OnchainSDK, RWAOpenAccountRequirements } from "../../sdk/index.js";
+import type { OnchainSDK, RWAMissingOpenAccountRequirements, RWAOpenAccountRequirements } from "../../sdk/index.js";
 /**
  * Extension point that ties each prerequisite kind to its detail payload.
  *
@@ -33,7 +33,26 @@ export interface PrerequisiteDetailMap {
      * registration and/or EIP-712 signatures the borrower must provide before
      * opening a credit account in an RWA market.
      */
-    rwaOpenRequirements: RWAOpenAccountRequirements;
+    rwaOpenRequirements: {
+        /** RWA token (e.g. Securitize DSToken) the requirements are checked for. */
+        token: Address;
+        /** Credit manager of the RWA market. */
+        creditManager: Address;
+        /** RWA factory that gates the token. */
+        factory: Address;
+        /**
+         * Full requirements fetched at verify time via
+         * `sdk.accounts.getOpenAccountRequirements`; only present when the read
+         * succeeded and the factory gates the token.
+         */
+        requirements?: RWAOpenAccountRequirements;
+        /**
+         * Subset of `requirements` still unfulfilled, computed by the RWA
+         * factory at verify time (`IRWAFactory.getMissingRequirements`);
+         * `undefined` when everything is satisfied.
+         */
+        missing?: RWAMissingOpenAccountRequirements;
+    };
 }
 export type PrerequisiteKind = keyof PrerequisiteDetailMap;
 export type PrerequisiteDetail<K extends PrerequisiteKind = PrerequisiteKind> = PrerequisiteDetailMap[K];