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

package/dist/esm/preview/prerequisites/buildPartialLiquidationPrerequisites.js

@@ -0,0 +1,18 @@
+import { allowanceAndBalance } from "./helpers.js";
+function buildPartialLiquidationPrerequisites(tx, ctx) {
+  if (tx.repaidAmount === 0n) {
+    return [];
+  }
+  const suite = ctx.sdk.marketRegister.findByCreditManager(tx.creditManager);
+  return allowanceAndBalance({
+    token: suite.underlying,
+    owner: ctx.wallet,
+    spender: tx.creditManager,
+    required: tx.repaidAmount,
+    allowanceTitle: "Underlying approved to credit manager",
+    balanceTitle: "Sufficient underlying balance"
+  });
+}
+export {
+  buildPartialLiquidationPrerequisites
+};

package/dist/esm/preview/prerequisites/buildPoolPrerequisites.js

@@ -0,0 +1,101 @@
+import { isAddressEqual } from "viem";
+import { NATIVE_ADDRESS } from "../../sdk/index.js";
+import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
+import { BalancePrerequisite } from "./BalancePrerequisite.js";
+import { allowanceAndBalance } from "./helpers.js";
+function buildPoolPrerequisites(tx, wallet) {
+  switch (tx.operation) {
+    // Deposit and Mint both pull the underlying from the caller into the pool;
+    // they only differ in which side (assets vs shares) the caller specifies.
+    // The exact underlying amount for Mint is resolved by the pool, so we can
+    // only require an allowance/balance against the known specified amount —
+    // here we approximate Mint by its shares amount (a lower bound on assets is
+    // not knowable from calldata alone).
+    case "Deposit":
+      if (tx.zapper) {
+        if (isAddressEqual(tx.tokenIn, NATIVE_ADDRESS)) {
+          return [
+            new BalancePrerequisite({
+              token: tx.tokenIn,
+              owner: wallet,
+              required: tx.assets,
+              title: "Sufficient token balance"
+            })
+          ];
+        }
+        return allowanceAndBalance({
+          token: tx.tokenIn,
+          owner: wallet,
+          spender: tx.zapper,
+          required: tx.assets,
+          allowanceTitle: "Token approved to zapper",
+          balanceTitle: "Sufficient token balance"
+        });
+      }
+      return allowanceAndBalance({
+        token: tx.underlying,
+        owner: wallet,
+        spender: tx.pool,
+        required: tx.assets,
+        allowanceTitle: "Token approved to pool",
+        balanceTitle: "Sufficient token balance"
+      });
+    case "Mint":
+      return allowanceAndBalance({
+        token: tx.underlying,
+        owner: wallet,
+        spender: tx.pool,
+        required: tx.shares,
+        allowanceTitle: "Token approved to pool",
+        balanceTitle: "Sufficient token balance"
+      });
+    // Redeem and Withdraw both burn LP shares from `owner`; they only differ in
+    // which side (shares vs assets) the caller specifies.
+    case "Redeem":
+      if (tx.zapper) {
+        return [
+          new BalancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            required: tx.shares,
+            title: "Sufficient share token balance"
+          }),
+          new AllowancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            spender: tx.zapper,
+            required: tx.shares,
+            title: "Share token approved to zapper"
+          })
+        ];
+      }
+      return lpSharePrerequisites(tx.pool, tx.owner, tx.shares, wallet);
+    case "Withdraw":
+      return lpSharePrerequisites(tx.pool, tx.owner, tx.assets, wallet);
+  }
+}
+function lpSharePrerequisites(pool, owner, required, wallet) {
+  const prereqs = [
+    new BalancePrerequisite({
+      token: pool,
+      owner,
+      required,
+      title: "Sufficient LP token balance"
+    })
+  ];
+  if (!isAddressEqual(owner, wallet)) {
+    prereqs.push(
+      new AllowancePrerequisite({
+        token: pool,
+        owner,
+        spender: wallet,
+        required,
+        title: "LP token approved to caller"
+      })
+    );
+  }
+  return prereqs;
+}
+export {
+  buildPoolPrerequisites
+};

package/dist/esm/preview/prerequisites/buildRWAPrerequisites.js

@@ -0,0 +1,33 @@
+import { AddressSet } from "../../sdk/index.js";
+import { RWAOpenRequirementsPrerequisite } from "./RWAOpenRequirementsPrerequisite.js";
+function buildRWAPrerequisites(multicall, creditManager, providedArgs, ctx) {
+  const { rwaFactory } = ctx.sdk.marketRegister.findByCreditManager(creditManager);
+  if (!rwaFactory) {
+    return [];
+  }
+  const rwaTokens = new AddressSet(rwaFactory.getTokens());
+  const candidates = new AddressSet();
+  for (const op of multicall) {
+    if (op.operation === "AddCollateral" || op.operation === "UpdateQuota") {
+      candidates.add(op.token);
+    }
+  }
+  const prereqs = [];
+  for (const token of candidates) {
+    if (!rwaTokens.has(token)) {
+      continue;
+    }
+    prereqs.push(
+      new RWAOpenRequirementsPrerequisite({
+        token,
+        creditManager,
+        factory: rwaFactory.address,
+        providedArgs
+      })
+    );
+  }
+  return prereqs;
+}
+export {
+  buildRWAPrerequisites
+};

package/dist/esm/preview/prerequisites/checkPrerequisites.js

@@ -0,0 +1,63 @@
+import {
+  parseOperationCalldata
+} from "../parse/parseOperationCalldata.js";
+import { buildCollateralPrerequisites } from "./buildCollateralPrerequisites.js";
+import { buildPartialLiquidationPrerequisites } from "./buildPartialLiquidationPrerequisites.js";
+import { buildPoolPrerequisites } from "./buildPoolPrerequisites.js";
+import { buildRWAPrerequisites } from "./buildRWAPrerequisites.js";
+async function checkPrerequisites(input) {
+  const { sdk, sender: wallet, blockNumber } = input;
+  const tx = parseOperationCalldata(input);
+  const ctx = { sdk, wallet, blockNumber };
+  const prereqs = await buildPrerequisites(tx, ctx);
+  return Promise.all(
+    // Each prereq pairs its own kind with its detail, so the widened
+    // `verify` return is safe to narrow back to the discriminated union.
+    prereqs.map((p) => p.verify(ctx))
+  );
+}
+async function buildPrerequisites(tx, ctx) {
+  const { wallet } = ctx;
+  switch (tx.operation) {
+    case "Deposit":
+    case "Mint":
+    case "Redeem":
+    case "Withdraw":
+      return buildPoolPrerequisites(tx, wallet);
+    case "MultiCall":
+    case "BotMulticall":
+    case "OpenCreditAccount":
+    case "CloseCreditAccount":
+    case "LiquidateCreditAccount":
+      return buildCollateralPrerequisites(
+        tx.operation === "OpenCreditAccount" ? { creditManager: tx.creditManager, borrower: wallet } : {
+          creditManager: tx.creditManager,
+          creditAccount: tx.creditAccount
+        },
+        tx.multicall,
+        ctx
+      );
+    case "RWAOpenCreditAccount":
+      return [
+        ...await buildCollateralPrerequisites(
+          { creditManager: tx.creditManager, borrower: wallet },
+          tx.multicall,
+          ctx
+        ),
+        ...buildRWAPrerequisites(tx.multicall, tx.creditManager, tx.args, ctx)
+      ];
+    case "RWAMulticall":
+      return buildCollateralPrerequisites(
+        { creditManager: tx.creditManager, creditAccount: tx.creditAccount },
+        tx.multicall,
+        ctx
+      );
+    case "PartiallyLiquidateCreditAccount":
+      return buildPartialLiquidationPrerequisites(tx, ctx);
+    default:
+      return [];
+  }
+}
+export {
+  checkPrerequisites
+};

package/dist/esm/preview/prerequisites/helpers.js

@@ -0,0 +1,23 @@
+import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
+import { BalancePrerequisite } from "./BalancePrerequisite.js";
+function allowanceAndBalance(props) {
+  const { token, owner, spender, required } = props;
+  return [
+    new AllowancePrerequisite({
+      token,
+      owner,
+      spender,
+      required,
+      title: props.allowanceTitle
+    }),
+    new BalancePrerequisite({
+      token,
+      owner,
+      required,
+      title: props.balanceTitle
+    })
+  ];
+}
+export {
+  allowanceAndBalance
+};

package/dist/esm/preview/prerequisites/index.js

@@ -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/esm/preview/preview/detectCloseOrRepay.js

@@ -0,0 +1,26 @@
+import { isAddressEqual } from "viem";
+import { MAX_UINT256 } from "../../sdk/index.js";
+function isCloseOrRepay(multicall) {
+  const repaysFullDebt = multicall.some(
+    (op) => op.operation === "DecreaseBorrowedAmount" && op.amount === MAX_UINT256
+  );
+  const withdrawsEverything = multicall.some(
+    (op) => op.operation === "WithdrawCollateral" && op.amount === MAX_UINT256
+  );
+  return repaysFullDebt && withdrawsEverything;
+}
+function classifyCloseOrRepay(multicall, underlying) {
+  for (const op of multicall) {
+    if (op.operation === "AddCollateral") {
+      return "repay";
+    }
+    if (op.operation === "WithdrawCollateral" && !isAddressEqual(op.token, underlying)) {
+      return "repay";
+    }
+  }
+  return "close";
+}
+export {
+  classifyCloseOrRepay,
+  isCloseOrRepay
+};

package/dist/esm/preview/preview/index.js

@@ -1,5 +1,7 @@
 export * from "./applyInnerOperations.js";
+export * from "./detectCloseOrRepay.js";
 export * from "./errors.js";
 export * from "./previewAdjustCreditAccount.js";
+export * from "./previewCloseOrRepay.js";
 export * from "./previewOperation.js";
 export * from "./types.js";

package/dist/esm/preview/preview/previewCloseOrRepay.js

@@ -0,0 +1,76 @@
+import {
+  AP_WETH_TOKEN,
+  NO_VERSION
+} from "../../sdk/index.js";
+import {
+  applyInnerOperations,
+  makeInnerOperationsState
+} from "./applyInnerOperations.js";
+import { classifyCloseOrRepay } from "./detectCloseOrRepay.js";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
+async function previewCloseOrRepay(input, operation, permanent, options) {
+  const { sdk } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const kind = classifyCloseOrRepay(operation.multicall, market.underlying);
+  return kind === "close" ? previewCloseCreditAccount(input, operation, permanent, options) : previewRepayCreditAccount(input, operation, permanent, options);
+}
+async function previewCloseCreditAccount(input, operation, permanent, options) {
+  const { sdk } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const { state } = await replayMulticall(sdk, operation, options);
+  return {
+    operation: "CloseCreditAccount",
+    permanent,
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    receivedAmount: state.collateralWithdrawn.getOrZero(market.underlying)
+  };
+}
+async function previewRepayCreditAccount(input, operation, permanent, options) {
+  const { sdk, value = 0n } = input;
+  const { ca, state } = await replayMulticall(sdk, operation, options);
+  const collateralAdded = unwrapNativeCollateral(
+    state.collateralAdded.toAssets(),
+    value,
+    sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
+  );
+  const initialTotalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
+  return {
+    operation: "RepayCreditAccount",
+    permanent,
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    collateralAdded,
+    debtRepaid: initialTotalDebt - state.totalDebt,
+    collateralWithdrawn: state.collateralWithdrawn.toAssets()
+  };
+}
+async function replayMulticall(sdk, operation, options) {
+  let ca = options?.creditAccount;
+  if (!ca) {
+    ca = await sdk.accounts.getCreditAccountData(
+      operation.creditAccount,
+      options?.blockNumber
+    );
+  }
+  if (!ca) {
+    throw new Error(`credit account ${operation.creditAccount} not found`);
+  }
+  const state = makeInnerOperationsState();
+  for (const t of ca.tokens) {
+    if (t.balance > 1n) {
+      state.balances.upsert(t.token, t.balance);
+    }
+  }
+  state.debt = ca.debt;
+  state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
+  applyInnerOperations(sdk, operation.multicall, state);
+  return { ca, state };
+}
+export {
+  previewCloseOrRepay
+};

package/dist/esm/preview/preview/previewOperation.js

@@ -1,6 +1,8 @@
 import { isPoolOperation, parseOperationCalldata } from "../parse/index.js";
+import { isCloseOrRepay } from "./detectCloseOrRepay.js";
 import { UnsupportedOperationError } from "./errors.js";
 import { previewAdjustCreditAccount } from "./previewAdjustCreditAccount.js";
+import { previewCloseOrRepay } from "./previewCloseOrRepay.js";
 import { previewOpenCreditAccount } from "./previewOpenCreditAccount.js";
 import { previewPoolOperation } from "./previewPoolOperation.js";
 async function previewOperation(input, options) {
@@ -8,10 +10,16 @@ async function previewOperation(input, options) {
   if (isPoolOperation(operation)) {
     return previewPoolOperation(input, operation, options);
   }
-  if (operation.operation === "OpenCreditAccount" || operation.operation === "SecuritizeOpenCreditAccount") {
+  if (operation.operation === "OpenCreditAccount" || operation.operation === "RWAOpenCreditAccount") {
     return previewOpenCreditAccount(input, operation);
   }
-  if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "SecuritizeMulticall") {
+  if (operation.operation === "CloseCreditAccount") {
+    return previewCloseOrRepay(input, operation, true, options);
+  }
+  if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "RWAMulticall") {
+    if (isCloseOrRepay(operation.multicall)) {
+      return previewCloseOrRepay(input, operation, false, options);
+    }
     return previewAdjustCreditAccount(input, operation, options);
   }
   throw new UnsupportedOperationError(operation.operation);

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>;