@morpho-org/evm-simulation 4.2.0 → 5.0.0

package/lib/esm/authorizations.d.ts

@@ -0,0 +1,95 @@
+import type { Address, Hex } from "viem";
+/** EIP-712 domain separator fields of a signature payload. */
+export interface Eip712Domain {
+    readonly name?: string;
+    readonly version?: string;
+    readonly chainId: number | bigint;
+    readonly verifyingContract: Address;
+    readonly salt?: Hex;
+}
+/** One entry of an EIP-712 `types` field list. */
+export interface Eip712Field {
+    readonly name: string;
+    readonly type: string;
+}
+/** ERC-2612 `Permit` typed data; `domain.verifyingContract` is the token. */
+export interface Erc2612PermitTypedData {
+    readonly domain: Eip712Domain;
+    readonly primaryType: "Permit";
+    readonly types: {
+        readonly Permit: readonly Eip712Field[];
+    };
+    readonly message: {
+        readonly owner: Address;
+        readonly spender: Address;
+        readonly value: bigint;
+        readonly nonce: bigint;
+        readonly deadline: bigint;
+    };
+}
+/** Permit2 `PermitTransferFrom` typed data; the owner is not in the message. */
+export interface Permit2TransferTypedData {
+    readonly domain: Eip712Domain;
+    readonly primaryType: "PermitTransferFrom";
+    readonly types: {
+        readonly PermitTransferFrom: readonly Eip712Field[];
+        readonly TokenPermissions: readonly Eip712Field[];
+    };
+    readonly message: {
+        readonly permitted: {
+            readonly token: Address;
+            readonly amount: bigint;
+        };
+        readonly spender: Address;
+        readonly nonce: bigint;
+        readonly deadline: bigint;
+    };
+}
+/** Morpho `Authorization` typed data consumed by `setAuthorizationWithSig`. */
+export interface BlueAuthorizationTypedData {
+    readonly domain: Eip712Domain;
+    readonly primaryType: "Authorization";
+    readonly types: {
+        readonly Authorization: readonly Eip712Field[];
+    };
+    readonly message: {
+        readonly authorizer: Address;
+        readonly authorized: Address;
+        readonly isAuthorized: boolean;
+        readonly nonce: bigint;
+        readonly deadline: bigint;
+    };
+}
+/** Raw ERC-20 `approve` request. */
+export interface Erc20ApprovalAuthorization {
+    readonly type: "erc20Approval";
+    readonly token: Address;
+    readonly owner: Address;
+    readonly spender: Address;
+    readonly amount: bigint;
+}
+/** ERC-2612 permit request. */
+export interface Erc2612PermitAuthorization {
+    readonly type: "erc2612Permit";
+    readonly typedData: Erc2612PermitTypedData;
+}
+/** Permit2 signature transfer request. */
+export interface Permit2TransferAuthorization {
+    readonly type: "permit2SignatureTransfer";
+    readonly owner: Address;
+    readonly typedData: Permit2TransferTypedData;
+}
+/** Direct Morpho `setAuthorization` request. */
+export interface BlueAuthorization {
+    readonly type: "blueAuthorization";
+    readonly authorizer: Address;
+    readonly authorized: Address;
+    readonly isAuthorized: boolean;
+}
+/** Morpho `setAuthorizationWithSig` request. */
+export interface BlueAuthorizationSignature {
+    readonly type: "blueAuthorizationSignature";
+    readonly typedData: BlueAuthorizationTypedData;
+}
+/** A pending wallet request passed to `simulate()` — the five typed variants. */
+export type SimulationAuthorization = Erc20ApprovalAuthorization | Erc2612PermitAuthorization | Permit2TransferAuthorization | BlueAuthorization | BlueAuthorizationSignature;

package/lib/esm/authorizations.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/errors.d.ts

@@ -1,44 +1,238 @@
+import type { Address, Hash } from "viem";
+import type { SimulationOperationSubject } from "./limits.js";
+import type { SimulationMode } from "./params.js";
+/** Stable error codes thrown by this package, part of the public API. */
+export declare const SIMULATION_ERROR_CODES: readonly ["VALIDATION_ERROR", "UNSUPPORTED_CHAIN", "EXTERNAL_SERVICE_ERROR", "SIMULATION_REVERTED", "BLACKLIST_ERROR", "UNSUPPORTED_OPERATION", "INVALID_SIMULATION_RESPONSE", "MISSING_VERIFICATION_EVIDENCE", "AUTHORIZATION_REQUEST_MISMATCH", "CONSUMER_LIMIT_VIOLATION", "UNEXPECTED_SIMULATION_ERROR"];
+/** Stable string discriminator for log aggregation and external mapping. */
+export type SimulationErrorCode = (typeof SIMULATION_ERROR_CODES)[number];
+/**
+ * Machine-readable cause of an execution failure (ADR-2026-09-18 §Errors).
+ * `UNKNOWN_REVERT` is used when the revert maps to no known Morpho condition;
+ * consumers branch on it and never parse `reason`.
+ */
+export type SimulationExecutionReason = "INSUFFICIENT_BALANCE" | "INSUFFICIENT_ALLOWANCE" | "INSUFFICIENT_LIQUIDITY" | "POSITION_UNHEALTHY" | "SLIPPAGE_EXCEEDED" | "SIGNATURE_EXPIRED" | "SIGNATURE_INVALID" | "NONCE_ALREADY_USED" | "CAP_EXCEEDED" | "ACCESS_RESTRICTED" | "UNKNOWN_REVERT";
+declare const SIMULATION_STAGES: readonly ["validation", "preparation", "execution", "verification", "transport"];
+/** Pipeline stage a failure belongs to; `transport` covers RPC and response failures. */
+export type SimulationStage = (typeof SIMULATION_STAGES)[number];
+interface SimulationContextBase {
+    /** Request mode the failure happened in. */
+    readonly mode: SimulationMode;
+    /** Chain the request targeted. */
+    readonly chainId: number;
+    /** Block the simulation was pinned to. */
+    readonly blockNumber: bigint;
+}
+interface SimulationCheckContext extends SimulationContextBase {
+    /** Token whose balance, allowance or transfer was checked. */
+    readonly token?: Address;
+    /** Account whose position, balance or authorization was checked (usually the sender). */
+    readonly account?: Address;
+    /** Spender or operator granted by the checked permission. */
+    readonly spender?: Address;
+    /**
+     * Name of the checked field (e.g. `"assetsReceived"`). Unbound verification
+     * contexts instead carry the failed state read's id
+     * (`balance:<token>:<account>` or `position:<marketId>:<account>`).
+     */
+    readonly field?: string;
+    /** Bound or value `field` was checked against; 32-byte hashes only, never calldata or signatures. */
+    readonly expected?: bigint | boolean | Address | Hash;
+    /** Value observed in the simulation, same domain as `expected`. */
+    readonly observed?: bigint | boolean | Address | Hash;
+    /**
+     * Reserved; not populated for caller-transaction reverts, whose index is on
+     * `SimulationRevertedError.details[].transactionIndex`.
+     */
+    readonly failedTransactionIndex?: number;
+}
+/** Context of a failure while validating the request. */
+export type SimulationValidationContext = SimulationContextBase & {
+    readonly stage: "validation";
+};
+/** Context of a failure while reaching the `eth_simulateV1` backend. */
+export type SimulationTransportContext = SimulationContextBase & {
+    readonly stage: "transport";
+};
+/** Context of a failure while preparing a preview authorization. */
+export type SimulationPreparationContext = SimulationContextBase & {
+    readonly stage: "preparation";
+    /** Index into `authorizations`. */
+    readonly authorizationIndex: number;
+    /** Index into that authorization's preparation calls. */
+    readonly preparationCallIndex?: number;
+};
+/**
+ * Reserved execution-stage context; `SimulationRevertedError` carries none for
+ * caller-transaction or node reverts (see `details[].transactionIndex`).
+ */
+export type SimulationExecutionContext = SimulationCheckContext & SimulationOperationSubject & {
+    readonly stage: "execution";
+};
+/** Context of a verification check that did not hold. */
+export type SimulationVerificationContext = SimulationCheckContext & SimulationOperationSubject & {
+    readonly stage: "verification";
+};
+/**
+ * Where and why a simulation failed, keyed by `stage`
+ * (ADR-2026-10-01-evm-simulation-quoted-slippage-limits).
+ * Every stage carries `mode`, `chainId` and `blockNumber`. Preparation
+ * contexts carry `authorizationIndex` and `preparationCallIndex`. Verification
+ * contexts bound to a limit take `operation` and the subject fields
+ * (`marketId`, `sourceMarketId`/`targetMarketId`, `vault`,
+ * `sourceVault`/`targetVault`) from that `OperationLimit`, not
+ * from decoded calldata; unbound ones carry only a `field` string naming the
+ * failed state read (`balance:<token>:<account>` or
+ * `position:<marketId>:<account>`).
+ * `"execution"` stays in the union, but `SimulationRevertedError` carries no
+ * `context` for caller-transaction or node reverts — the failing
+ * `transactionIndex` is reported on the error's `details`. Never contains
+ * signatures, RPC URLs, credentials, raw calldata or raw causes (`cause`
+ * stays on the error).
+ */
+export type SimulationErrorContext = SimulationValidationContext | SimulationTransportContext | SimulationPreparationContext | SimulationExecutionContext | SimulationVerificationContext | (SimulationCheckContext & {
+    readonly stage: "verification";
+    readonly field: string;
+    readonly operation?: never;
+});
 /**
  * Base class for every error this package throws. Transport-agnostic — no HTTP status codes.
  * Consumers pattern-match with `instanceof` on the concrete subclass.
  */
 export declare abstract class SimulationPackageError extends Error {
     /** Stable string discriminator for log aggregation and external mapping. */
-    abstract readonly code: string;
-    constructor(message: string, options?: ErrorOptions);
+    abstract readonly code: SimulationErrorCode;
+    /** Frozen copy of the failure context, when one was supplied. */
+    readonly context?: SimulationErrorContext;
+    constructor(message: string, options?: ErrorOptions & {
+        context?: SimulationErrorContext;
+    });
 }
 /** Transaction would revert on-chain. Not bypassable. */
 export declare class SimulationRevertedError extends SimulationPackageError {
+    /** Raw revert string as reported by the backend, when any. */
     readonly reason: string | undefined;
     readonly details?: unknown;
+    /** Machine-readable cause; `UNKNOWN_REVERT` when the revert maps to no known Morpho condition. */
+    readonly reasonCode: SimulationExecutionReason;
+    readonly name = "SimulationRevertedError";
     readonly code = "SIMULATION_REVERTED";
-    constructor(reason: string | undefined, details?: unknown);
+    readonly context?: SimulationPreparationContext | SimulationExecutionContext;
+    constructor(
+    /** Raw revert string as reported by the backend, when any. */
+    reason: string | undefined, details?: unknown, 
+    /** Machine-readable cause; `UNKNOWN_REVERT` when the revert maps to no known Morpho condition. */
+    reasonCode?: SimulationExecutionReason, 
+    /** Which transaction/authorization reverted and the operation it belonged to. */
+    context?: SimulationPreparationContext | SimulationExecutionContext);
 }
-interface RetainedAsset {
-    address: string | undefined;
-    token: string | undefined;
-    netRetained: string;
+/** Per-asset net retained amount keyed by restricted contract and token. */
+export interface RetainedAsset {
+    /** Restricted bundles contract that ended up holding the token. */
+    readonly address: Address;
+    /** Token retained (native ETH uses viem's `ethAddress`). */
+    readonly token: Address;
+    /** Net balance increase in the token's base units; always positive. */
+    readonly netRetained: bigint;
 }
-/** Funds would flow to restricted standalone bundles contract addresses. Never bypassable. */
+/**
+ * Thrown when net value above the dust threshold is retained by a restricted bundles contract
+ * (VaultExitBundlesV1, VaultBundlesV1, BlueBundlesV1 or MidnightBundlesV1) after simulation;
+ * pass-through flows and net outflows are allowed. Never bypassable.
+ */
 export declare class BlacklistViolationError extends SimulationPackageError {
-    readonly assetChanges?: RetainedAsset[] | undefined;
+    /** Per-asset net retained amounts keyed by restricted contract and token. */
+    readonly assetChanges?: readonly RetainedAsset[] | undefined;
+    readonly name = "BlacklistViolationError";
     readonly code = "BLACKLIST_ERROR";
-    constructor(message: string, assetChanges?: RetainedAsset[] | undefined);
+    constructor(message: string, 
+    /** Per-asset net retained amounts keyed by restricted contract and token. */
+    assetChanges?: readonly RetainedAsset[] | undefined, context?: SimulationErrorContext);
 }
-/** Tenderly or RPC service is down. Bypassable — user can proceed. */
+/** RPC service is down or unreachable. Bypassable — user can proceed. */
 export declare class ExternalServiceError extends SimulationPackageError {
+    readonly name = "ExternalServiceError";
     readonly code = "EXTERNAL_SERVICE_ERROR";
 }
 /** Bad input to the simulation functions. Not bypassable. */
 export declare class SimulationValidationError extends SimulationPackageError {
     readonly fieldErrors?: string[] | undefined;
+    readonly name = "SimulationValidationError";
     readonly code = "VALIDATION_ERROR";
-    constructor(message: string, fieldErrors?: string[] | undefined);
+    constructor(message: string, fieldErrors?: string[] | undefined, context?: SimulationErrorContext);
 }
 /** Chain ID not configured for any simulation method. Not bypassable. */
 export declare class UnsupportedChainError extends SimulationPackageError {
     readonly chainId: number;
+    readonly name = "UnsupportedChainError";
     readonly code = "UNSUPPORTED_CHAIN";
-    constructor(chainId: number);
+    constructor(chainId: number, context?: SimulationErrorContext);
 }
+/**
+ * An SDK requirement passed to `toSimulationAuthorizations` cannot be
+ * converted into a simulation authorization.
+ */
+export declare class UnsupportedOperationError extends SimulationPackageError {
+    readonly name = "UnsupportedOperationError";
+    readonly code = "UNSUPPORTED_OPERATION";
+}
+/** The simulation backend returned a response that cannot be parsed. */
+export declare class InvalidSimulationResponseError extends SimulationPackageError {
+    readonly name = "InvalidSimulationResponseError";
+    readonly code = "INVALID_SIMULATION_RESPONSE";
+}
+/** State needed to verify an operation could not be fetched or derived. */
+export declare class MissingVerificationEvidenceError extends SimulationPackageError {
+    readonly name = "MissingVerificationEvidenceError";
+    readonly code = "MISSING_VERIFICATION_EVIDENCE";
+}
+/** A pending authorization does not match the request it was prepared for. */
+export declare class AuthorizationRequestMismatchError extends SimulationPackageError {
+    readonly name = "AuthorizationRequestMismatchError";
+    readonly code = "AUTHORIZATION_REQUEST_MISMATCH";
+}
+/** A consumer-supplied limit was violated. */
+export declare class ConsumerLimitViolationError extends SimulationPackageError {
+    readonly name = "ConsumerLimitViolationError";
+    readonly code = "CONSUMER_LIMIT_VIOLATION";
+}
+/** The simulation failed for a reason that fits no other code. */
+export declare class UnexpectedSimulationError extends SimulationPackageError {
+    readonly name = "UnexpectedSimulationError";
+    readonly code = "UNEXPECTED_SIMULATION_ERROR";
+}
+/**
+ * Structural guard for consumers where `instanceof` fails across bundles.
+ *
+ * @param value - Anything caught.
+ * @returns `true` for `SimulationPackageError` instances and for objects
+ *   carrying a `message` string, a known `code`, the `name` of the class
+ *   owning that `code`, and an absent or
+ *   well-formed `context` (known `stage`, `mode`, numeric `chainId`,
+ *   `bigint` `blockNumber`, `authorizationIndex` for `preparation`, and a
+ *   known `operation` with its subject fields for `execution`/`verification`,
+ *   or a verification `field` string with no `operation`).
+ * @example
+ * ```ts
+ * import { isSimulationPackageError, simulate } from "@morpho-org/evm-simulation";
+ * import type { Address, Hex } from "viem";
+ *
+ * declare const user: Address;
+ * declare const vault: Address;
+ * declare const encodedDeposit: Hex;
+ * const config = {
+ *   chains: new Map([[1, { simulateV1Url: "https://rpc.example" }]]),
+ * };
+ * try {
+ *   await simulate(config, {
+ *     chainId: 1,
+ *     transactions: [{ from: user, to: vault, data: encodedDeposit }],
+ *   });
+ * } catch (e) {
+ *   if (!isSimulationPackageError(e)) throw e;
+ *   if (e.code !== "SIMULATION_REVERTED") throw e;
+ *   console.log(e.context?.stage, e.message);
+ * }
+ * ```
+ */
+export declare function isSimulationPackageError(value: unknown): value is SimulationPackageError;
 export {};

package/lib/esm/errors.js

@@ -1,52 +1,229 @@
+import { BLUE_MARKET_OPERATION_TYPES, OPERATION_TYPES, VAULT_OPERATION_TYPES, } from "./limits.js";
+import { SIMULATION_MODES } from "./params.js";
+/** Stable error codes thrown by this package, part of the public API. */
+export const SIMULATION_ERROR_CODES = [
+    "VALIDATION_ERROR",
+    "UNSUPPORTED_CHAIN",
+    "EXTERNAL_SERVICE_ERROR",
+    "SIMULATION_REVERTED",
+    "BLACKLIST_ERROR",
+    "UNSUPPORTED_OPERATION",
+    "INVALID_SIMULATION_RESPONSE",
+    "MISSING_VERIFICATION_EVIDENCE",
+    "AUTHORIZATION_REQUEST_MISMATCH",
+    "CONSUMER_LIMIT_VIOLATION",
+    "UNEXPECTED_SIMULATION_ERROR",
+];
+const SIMULATION_STAGES = [
+    "validation",
+    "preparation",
+    "execution",
+    "verification",
+    "transport",
+];
 /**
  * Base class for every error this package throws. Transport-agnostic — no HTTP status codes.
  * Consumers pattern-match with `instanceof` on the concrete subclass.
  */
 export class SimulationPackageError extends Error {
+    /** Frozen copy of the failure context, when one was supplied. */
+    context;
     constructor(message, options) {
-        super(message, options);
-        this.name = this.constructor.name;
+        const { context, ...errorOptions } = options ?? {};
+        super(message, errorOptions);
+        this.name = new.target.name;
+        if (context !== undefined) {
+            this.context = Object.freeze({ ...context });
+        }
     }
 }
 /** Transaction would revert on-chain. Not bypassable. */
 export class SimulationRevertedError extends SimulationPackageError {
     reason;
     details;
+    reasonCode;
+    name = "SimulationRevertedError";
     code = "SIMULATION_REVERTED";
-    constructor(reason, details) {
-        super(reason ?? "Transaction simulation reverted", details instanceof Error ? { cause: details } : undefined);
+    // biome-ignore lint/complexity/useMaxParams: public error constructor signature
+    constructor(
+    /** Raw revert string as reported by the backend, when any. */
+    reason, details, 
+    /** Machine-readable cause; `UNKNOWN_REVERT` when the revert maps to no known Morpho condition. */
+    reasonCode = "UNKNOWN_REVERT", 
+    /** Which transaction/authorization reverted and the operation it belonged to. */
+    context) {
+        super(reason ?? "Transaction simulation reverted", details instanceof Error ? { cause: details, context } : { context });
         this.reason = reason;
         this.details = details;
+        this.reasonCode = reasonCode;
     }
 }
-/** Funds would flow to restricted standalone bundles contract addresses. Never bypassable. */
+/**
+ * Thrown when net value above the dust threshold is retained by a restricted bundles contract
+ * (VaultExitBundlesV1, VaultBundlesV1, BlueBundlesV1 or MidnightBundlesV1) after simulation;
+ * pass-through flows and net outflows are allowed. Never bypassable.
+ */
 export class BlacklistViolationError extends SimulationPackageError {
     assetChanges;
+    name = "BlacklistViolationError";
     code = "BLACKLIST_ERROR";
-    constructor(message, assetChanges) {
-        super(message);
+    // biome-ignore lint/complexity/useMaxParams: public error constructor signature
+    constructor(message, 
+    /** Per-asset net retained amounts keyed by restricted contract and token. */
+    assetChanges, context) {
+        super(message, { context });
         this.assetChanges = assetChanges;
     }
 }
-/** Tenderly or RPC service is down. Bypassable — user can proceed. */
+/** RPC service is down or unreachable. Bypassable — user can proceed. */
 export class ExternalServiceError extends SimulationPackageError {
+    name = "ExternalServiceError";
     code = "EXTERNAL_SERVICE_ERROR";
 }
 /** Bad input to the simulation functions. Not bypassable. */
 export class SimulationValidationError extends SimulationPackageError {
     fieldErrors;
+    name = "SimulationValidationError";
     code = "VALIDATION_ERROR";
-    constructor(message, fieldErrors) {
-        super(message);
+    // biome-ignore lint/complexity/useMaxParams: public error constructor signature
+    constructor(message, fieldErrors, context) {
+        super(message, { context });
         this.fieldErrors = fieldErrors;
     }
 }
 /** Chain ID not configured for any simulation method. Not bypassable. */
 export class UnsupportedChainError extends SimulationPackageError {
     chainId;
+    name = "UnsupportedChainError";
     code = "UNSUPPORTED_CHAIN";
-    constructor(chainId) {
-        super(`Chain ${chainId} is not configured for simulation`);
+    constructor(chainId, context) {
+        super(`Chain ${chainId} is not configured for simulation`, { context });
         this.chainId = chainId;
     }
 }
+/**
+ * An SDK requirement passed to `toSimulationAuthorizations` cannot be
+ * converted into a simulation authorization.
+ */
+export class UnsupportedOperationError extends SimulationPackageError {
+    name = "UnsupportedOperationError";
+    code = "UNSUPPORTED_OPERATION";
+}
+/** The simulation backend returned a response that cannot be parsed. */
+export class InvalidSimulationResponseError extends SimulationPackageError {
+    name = "InvalidSimulationResponseError";
+    code = "INVALID_SIMULATION_RESPONSE";
+}
+/** State needed to verify an operation could not be fetched or derived. */
+export class MissingVerificationEvidenceError extends SimulationPackageError {
+    name = "MissingVerificationEvidenceError";
+    code = "MISSING_VERIFICATION_EVIDENCE";
+}
+/** A pending authorization does not match the request it was prepared for. */
+export class AuthorizationRequestMismatchError extends SimulationPackageError {
+    name = "AuthorizationRequestMismatchError";
+    code = "AUTHORIZATION_REQUEST_MISMATCH";
+}
+/** A consumer-supplied limit was violated. */
+export class ConsumerLimitViolationError extends SimulationPackageError {
+    name = "ConsumerLimitViolationError";
+    code = "CONSUMER_LIMIT_VIOLATION";
+}
+/** The simulation failed for a reason that fits no other code. */
+export class UnexpectedSimulationError extends SimulationPackageError {
+    name = "UnexpectedSimulationError";
+    code = "UNEXPECTED_SIMULATION_ERROR";
+}
+const ERROR_NAME_BY_CODE = Object.freeze({
+    VALIDATION_ERROR: "SimulationValidationError",
+    UNSUPPORTED_CHAIN: "UnsupportedChainError",
+    EXTERNAL_SERVICE_ERROR: "ExternalServiceError",
+    SIMULATION_REVERTED: "SimulationRevertedError",
+    BLACKLIST_ERROR: "BlacklistViolationError",
+    UNSUPPORTED_OPERATION: "UnsupportedOperationError",
+    INVALID_SIMULATION_RESPONSE: "InvalidSimulationResponseError",
+    MISSING_VERIFICATION_EVIDENCE: "MissingVerificationEvidenceError",
+    AUTHORIZATION_REQUEST_MISMATCH: "AuthorizationRequestMismatchError",
+    CONSUMER_LIMIT_VIOLATION: "ConsumerLimitViolationError",
+    UNEXPECTED_SIMULATION_ERROR: "UnexpectedSimulationError",
+});
+/**
+ * Structural guard for consumers where `instanceof` fails across bundles.
+ *
+ * @param value - Anything caught.
+ * @returns `true` for `SimulationPackageError` instances and for objects
+ *   carrying a `message` string, a known `code`, the `name` of the class
+ *   owning that `code`, and an absent or
+ *   well-formed `context` (known `stage`, `mode`, numeric `chainId`,
+ *   `bigint` `blockNumber`, `authorizationIndex` for `preparation`, and a
+ *   known `operation` with its subject fields for `execution`/`verification`,
+ *   or a verification `field` string with no `operation`).
+ * @example
+ * ```ts
+ * import { isSimulationPackageError, simulate } from "@morpho-org/evm-simulation";
+ * import type { Address, Hex } from "viem";
+ *
+ * declare const user: Address;
+ * declare const vault: Address;
+ * declare const encodedDeposit: Hex;
+ * const config = {
+ *   chains: new Map([[1, { simulateV1Url: "https://rpc.example" }]]),
+ * };
+ * try {
+ *   await simulate(config, {
+ *     chainId: 1,
+ *     transactions: [{ from: user, to: vault, data: encodedDeposit }],
+ *   });
+ * } catch (e) {
+ *   if (!isSimulationPackageError(e)) throw e;
+ *   if (e.code !== "SIMULATION_REVERTED") throw e;
+ *   console.log(e.context?.stage, e.message);
+ * }
+ * ```
+ */
+export function isSimulationPackageError(value) {
+    if (value instanceof SimulationPackageError)
+        return true;
+    if (typeof value !== "object" || value === null)
+        return false;
+    const { name, message, code, context } = value;
+    if (typeof message !== "string")
+        return false;
+    if (typeof code !== "string" ||
+        !SIMULATION_ERROR_CODES.includes(code) ||
+        name !== ERROR_NAME_BY_CODE[code])
+        return false;
+    if (context === undefined)
+        return true;
+    if (typeof context !== "object" || context === null || Array.isArray(context))
+        return false;
+    const { stage, mode, chainId, blockNumber, authorizationIndex } = context;
+    if (typeof stage !== "string" ||
+        !SIMULATION_STAGES.includes(stage) ||
+        typeof mode !== "string" ||
+        !SIMULATION_MODES.includes(mode) ||
+        typeof chainId !== "number" ||
+        typeof blockNumber !== "bigint")
+        return false;
+    const c = context;
+    if (stage === "preparation")
+        return typeof authorizationIndex === "number";
+    if (stage === "verification" && c.operation === undefined)
+        return typeof c.field === "string";
+    if (stage !== "execution" && stage !== "verification")
+        return true;
+    const operation = c.operation;
+    if (typeof operation !== "string" ||
+        !OPERATION_TYPES.includes(operation))
+        return false;
+    const isString = (key) => typeof c[key] === "string";
+    if (operation === "blueRefinance")
+        return isString("sourceMarketId") && isString("targetMarketId");
+    if (operation === "vaultV1MigrateToV2")
+        return isString("sourceVault") && isString("targetVault");
+    if (BLUE_MARKET_OPERATION_TYPES.includes(operation))
+        return isString("marketId");
+    if (VAULT_OPERATION_TYPES.includes(operation))
+        return isString("vault");
+    return false;
+}

package/lib/esm/index.d.ts

@@ -1,3 +1,11 @@
-export { BlacklistViolationError, ExternalServiceError, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnsupportedChainError, } from "./errors.js";
+export type { BlueAuthorization, BlueAuthorizationSignature, BlueAuthorizationTypedData, Eip712Domain, Eip712Field, Erc20ApprovalAuthorization, Erc2612PermitAuthorization, Erc2612PermitTypedData, Permit2TransferAuthorization, Permit2TransferTypedData, SimulationAuthorization, } from "./authorizations.js";
+export type { RetainedAsset, SimulationErrorCode, SimulationErrorContext, SimulationExecutionContext, SimulationExecutionReason, SimulationPreparationContext, SimulationStage, SimulationTransportContext, SimulationValidationContext, SimulationVerificationContext, } from "./errors.js";
+export { AuthorizationRequestMismatchError, BlacklistViolationError, ConsumerLimitViolationError, ExternalServiceError, InvalidSimulationResponseError, isSimulationPackageError, MissingVerificationEvidenceError, SIMULATION_ERROR_CODES, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnexpectedSimulationError, UnsupportedChainError, UnsupportedOperationError, } from "./errors.js";
+export type { BlueMarketOperationSubject, BlueMarketOperationType, BlueRefinanceSubject, OperationLimit, OperationType, SimulationLimits, SimulationOperationSubject, SlippageLimits, SlippageQuote, VaultOperationSubject, VaultOperationType, VaultV1MigrateToV2Subject, } from "./limits.js";
+export { BLUE_MARKET_OPERATION_TYPES, OPERATION_TYPES, VAULT_OPERATION_TYPES, } from "./limits.js";
+export type { SimulateParams, SimulationMode, } from "./params.js";
+export { SIMULATION_MODES } from "./params.js";
+export { toSimulationAuthorizations } from "./requirements/index.js";
+export type { AuthorizationPreparation, SimulatedOperation, SimulationVerification, VerifiedSimulationResult, } from "./result.js";
 export { simulate } from "./simulate/index.js";
-export type { AccountAssetChanges, AssetChange, ChainSimulationConfig, RawLog, SimulateParams, SimulationAuthorization, SimulationCall, SimulationConfig, SimulationLogger, SimulationResult, SimulationTransaction, TenderlyRpcConfig, Transfer, } from "./types.js";
+export type { AccountAssetChanges, AssetChange, ChainSimulationConfig, RawLog, SimulationCall, SimulationConfig, SimulationLogger, SimulationResult, SimulationTransaction, Transfer, } from "./types.js";

package/lib/esm/index.js

@@ -1,4 +1,7 @@
 // Public fns (via feature-folder barrels)
 // Errors (for instanceof checks by consumers)
-export { BlacklistViolationError, ExternalServiceError, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnsupportedChainError, } from "./errors.js";
+export { AuthorizationRequestMismatchError, BlacklistViolationError, ConsumerLimitViolationError, ExternalServiceError, InvalidSimulationResponseError, isSimulationPackageError, MissingVerificationEvidenceError, SIMULATION_ERROR_CODES, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnexpectedSimulationError, UnsupportedChainError, UnsupportedOperationError, } from "./errors.js";
+export { BLUE_MARKET_OPERATION_TYPES, OPERATION_TYPES, VAULT_OPERATION_TYPES, } from "./limits.js";
+export { SIMULATION_MODES } from "./params.js";
+export { toSimulationAuthorizations } from "./requirements/index.js";
 export { simulate } from "./simulate/index.js";