@morpho-org/evm-simulation 4.2.1 → 5.0.1

package/lib/cjs/errors.js

@@ -1,14 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnsupportedChainError = exports.SimulationValidationError = exports.ExternalServiceError = exports.BlacklistViolationError = exports.SimulationRevertedError = exports.SimulationPackageError = void 0;
+exports.UnexpectedSimulationError = exports.ConsumerLimitViolationError = exports.AuthorizationRequestMismatchError = exports.MissingVerificationEvidenceError = exports.InvalidSimulationResponseError = exports.UnsupportedOperationError = exports.UnsupportedChainError = exports.SimulationValidationError = exports.ExternalServiceError = exports.BlacklistViolationError = exports.SimulationRevertedError = exports.SimulationPackageError = exports.SIMULATION_ERROR_CODES = void 0;
+exports.isSimulationPackageError = isSimulationPackageError;
+const limits_js_1 = require("./limits.js");
+const params_js_1 = require("./params.js");
+/** Stable error codes thrown by this package, part of the public API. */
+exports.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.
  */
 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 });
+        }
     }
 }
 exports.SimulationPackageError = SimulationPackageError;
@@ -16,11 +46,21 @@ exports.SimulationPackageError = SimulationPackageError;
 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;
     }
 }
 exports.SimulationRevertedError = SimulationRevertedError;
@@ -31,26 +71,31 @@ exports.SimulationRevertedError = SimulationRevertedError;
  */
 class BlacklistViolationError extends SimulationPackageError {
     assetChanges;
+    name = "BlacklistViolationError";
     code = "BLACKLIST_ERROR";
+    // biome-ignore lint/complexity/useMaxParams: public error constructor signature
     constructor(message, 
     /** Per-asset net retained amounts keyed by restricted contract and token. */
-    assetChanges) {
-        super(message);
+    assetChanges, context) {
+        super(message, { context });
         this.assetChanges = assetChanges;
     }
 }
 exports.BlacklistViolationError = BlacklistViolationError;
-/** Tenderly or RPC service is down. Bypassable — user can proceed. */
+/** RPC service is down or unreachable. Bypassable — user can proceed. */
 class ExternalServiceError extends SimulationPackageError {
+    name = "ExternalServiceError";
     code = "EXTERNAL_SERVICE_ERROR";
 }
 exports.ExternalServiceError = ExternalServiceError;
 /** Bad input to the simulation functions. Not bypassable. */
 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;
     }
 }
@@ -58,10 +103,143 @@ exports.SimulationValidationError = SimulationValidationError;
 /** Chain ID not configured for any simulation method. Not bypassable. */
 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;
     }
 }
 exports.UnsupportedChainError = UnsupportedChainError;
+/**
+ * An SDK requirement passed to `toSimulationAuthorizations` cannot be
+ * converted into a simulation authorization.
+ */
+class UnsupportedOperationError extends SimulationPackageError {
+    name = "UnsupportedOperationError";
+    code = "UNSUPPORTED_OPERATION";
+}
+exports.UnsupportedOperationError = UnsupportedOperationError;
+/** The simulation backend returned a response that cannot be parsed. */
+class InvalidSimulationResponseError extends SimulationPackageError {
+    name = "InvalidSimulationResponseError";
+    code = "INVALID_SIMULATION_RESPONSE";
+}
+exports.InvalidSimulationResponseError = InvalidSimulationResponseError;
+/** State needed to verify an operation could not be fetched or derived. */
+class MissingVerificationEvidenceError extends SimulationPackageError {
+    name = "MissingVerificationEvidenceError";
+    code = "MISSING_VERIFICATION_EVIDENCE";
+}
+exports.MissingVerificationEvidenceError = MissingVerificationEvidenceError;
+/** A pending authorization does not match the request it was prepared for. */
+class AuthorizationRequestMismatchError extends SimulationPackageError {
+    name = "AuthorizationRequestMismatchError";
+    code = "AUTHORIZATION_REQUEST_MISMATCH";
+}
+exports.AuthorizationRequestMismatchError = AuthorizationRequestMismatchError;
+/** A consumer-supplied limit was violated. */
+class ConsumerLimitViolationError extends SimulationPackageError {
+    name = "ConsumerLimitViolationError";
+    code = "CONSUMER_LIMIT_VIOLATION";
+}
+exports.ConsumerLimitViolationError = ConsumerLimitViolationError;
+/** The simulation failed for a reason that fits no other code. */
+class UnexpectedSimulationError extends SimulationPackageError {
+    name = "UnexpectedSimulationError";
+    code = "UNEXPECTED_SIMULATION_ERROR";
+}
+exports.UnexpectedSimulationError = UnexpectedSimulationError;
+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);
+ * }
+ * ```
+ */
+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" ||
+        !exports.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" ||
+        !params_js_1.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" ||
+        !limits_js_1.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 (limits_js_1.BLUE_MARKET_OPERATION_TYPES.includes(operation))
+        return isString("marketId");
+    if (limits_js_1.VAULT_OPERATION_TYPES.includes(operation))
+        return isString("vault");
+    return false;
+}

package/lib/cjs/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/cjs/index.js

@@ -1,14 +1,30 @@
 "use strict";
 // Public fns (via feature-folder barrels)
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.simulate = exports.UnsupportedChainError = exports.SimulationValidationError = exports.SimulationRevertedError = exports.SimulationPackageError = exports.ExternalServiceError = exports.BlacklistViolationError = void 0;
+exports.simulate = exports.toSimulationAuthorizations = exports.SIMULATION_MODES = exports.VAULT_OPERATION_TYPES = exports.OPERATION_TYPES = exports.BLUE_MARKET_OPERATION_TYPES = exports.UnsupportedOperationError = exports.UnsupportedChainError = exports.UnexpectedSimulationError = exports.SimulationValidationError = exports.SimulationRevertedError = exports.SimulationPackageError = exports.SIMULATION_ERROR_CODES = exports.MissingVerificationEvidenceError = exports.isSimulationPackageError = exports.InvalidSimulationResponseError = exports.ExternalServiceError = exports.ConsumerLimitViolationError = exports.BlacklistViolationError = exports.AuthorizationRequestMismatchError = void 0;
 // Errors (for instanceof checks by consumers)
 var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "AuthorizationRequestMismatchError", { enumerable: true, get: function () { return errors_js_1.AuthorizationRequestMismatchError; } });
 Object.defineProperty(exports, "BlacklistViolationError", { enumerable: true, get: function () { return errors_js_1.BlacklistViolationError; } });
+Object.defineProperty(exports, "ConsumerLimitViolationError", { enumerable: true, get: function () { return errors_js_1.ConsumerLimitViolationError; } });
 Object.defineProperty(exports, "ExternalServiceError", { enumerable: true, get: function () { return errors_js_1.ExternalServiceError; } });
+Object.defineProperty(exports, "InvalidSimulationResponseError", { enumerable: true, get: function () { return errors_js_1.InvalidSimulationResponseError; } });
+Object.defineProperty(exports, "isSimulationPackageError", { enumerable: true, get: function () { return errors_js_1.isSimulationPackageError; } });
+Object.defineProperty(exports, "MissingVerificationEvidenceError", { enumerable: true, get: function () { return errors_js_1.MissingVerificationEvidenceError; } });
+Object.defineProperty(exports, "SIMULATION_ERROR_CODES", { enumerable: true, get: function () { return errors_js_1.SIMULATION_ERROR_CODES; } });
 Object.defineProperty(exports, "SimulationPackageError", { enumerable: true, get: function () { return errors_js_1.SimulationPackageError; } });
 Object.defineProperty(exports, "SimulationRevertedError", { enumerable: true, get: function () { return errors_js_1.SimulationRevertedError; } });
 Object.defineProperty(exports, "SimulationValidationError", { enumerable: true, get: function () { return errors_js_1.SimulationValidationError; } });
+Object.defineProperty(exports, "UnexpectedSimulationError", { enumerable: true, get: function () { return errors_js_1.UnexpectedSimulationError; } });
 Object.defineProperty(exports, "UnsupportedChainError", { enumerable: true, get: function () { return errors_js_1.UnsupportedChainError; } });
-var index_js_1 = require("./simulate/index.js");
-Object.defineProperty(exports, "simulate", { enumerable: true, get: function () { return index_js_1.simulate; } });
+Object.defineProperty(exports, "UnsupportedOperationError", { enumerable: true, get: function () { return errors_js_1.UnsupportedOperationError; } });
+var limits_js_1 = require("./limits.js");
+Object.defineProperty(exports, "BLUE_MARKET_OPERATION_TYPES", { enumerable: true, get: function () { return limits_js_1.BLUE_MARKET_OPERATION_TYPES; } });
+Object.defineProperty(exports, "OPERATION_TYPES", { enumerable: true, get: function () { return limits_js_1.OPERATION_TYPES; } });
+Object.defineProperty(exports, "VAULT_OPERATION_TYPES", { enumerable: true, get: function () { return limits_js_1.VAULT_OPERATION_TYPES; } });
+var params_js_1 = require("./params.js");
+Object.defineProperty(exports, "SIMULATION_MODES", { enumerable: true, get: function () { return params_js_1.SIMULATION_MODES; } });
+var index_js_1 = require("./requirements/index.js");
+Object.defineProperty(exports, "toSimulationAuthorizations", { enumerable: true, get: function () { return index_js_1.toSimulationAuthorizations; } });
+var index_js_2 = require("./simulate/index.js");
+Object.defineProperty(exports, "simulate", { enumerable: true, get: function () { return index_js_2.simulate; } });

package/lib/cjs/limits.d.ts

@@ -0,0 +1,112 @@
+import type { MarketId } from "@morpho-org/blue-sdk";
+import type { Address } from "viem";
+/** Every operation type; source of `OperationType`. */
+export declare const OPERATION_TYPES: readonly ["blueSupply", "blueWithdraw", "blueSupplyCollateral", "blueBorrow", "blueSupplyCollateralBorrow", "blueRepay", "blueWithdrawCollateral", "blueRepayWithdrawCollateral", "blueRefinance", "vaultV1Deposit", "vaultV2Deposit", "vaultV1Withdraw", "vaultV2Withdraw", "vaultV1Redeem", "vaultV2Redeem", "vaultV2ForceWithdraw", "vaultV2ForceRedeem", "vaultV1InKindRedeem", "vaultV2InKindRedeem", "vaultV1MigrateToV2"];
+/** Discriminator for operations and their limits. */
+export type OperationType = (typeof OPERATION_TYPES)[number];
+/** Operations acting on one Blue market; source of `BlueMarketOperationType`. */
+export declare const BLUE_MARKET_OPERATION_TYPES: readonly ["blueSupply", "blueWithdraw", "blueSupplyCollateral", "blueBorrow", "blueSupplyCollateralBorrow", "blueRepay", "blueWithdrawCollateral", "blueRepayWithdrawCollateral"];
+/** Operations acting on one Blue market. */
+export type BlueMarketOperationType = (typeof BLUE_MARKET_OPERATION_TYPES)[number];
+/** Operations acting on one vault (V1 or V2); source of `VaultOperationType`. */
+export declare const VAULT_OPERATION_TYPES: readonly ["vaultV1Deposit", "vaultV2Deposit", "vaultV1Withdraw", "vaultV2Withdraw", "vaultV1Redeem", "vaultV2Redeem", "vaultV2ForceWithdraw", "vaultV2ForceRedeem", "vaultV1InKindRedeem", "vaultV2InKindRedeem"];
+/** Operations acting on one vault (V1 or V2). */
+export type VaultOperationType = (typeof VAULT_OPERATION_TYPES)[number];
+/** Subject of an operation acting on one Blue market. */
+export interface BlueMarketOperationSubject {
+    readonly operation: BlueMarketOperationType;
+    /** Blue market the operation acts on. */
+    readonly marketId: MarketId;
+}
+/** Subject of a Blue refinance between two markets. */
+export interface BlueRefinanceSubject {
+    readonly operation: "blueRefinance";
+    /** Market the refinance closes. */
+    readonly sourceMarketId: MarketId;
+    /** Market the refinance opens. */
+    readonly targetMarketId: MarketId;
+}
+/** Subject of an operation acting on one vault (V1 or V2). */
+export interface VaultOperationSubject {
+    readonly operation: VaultOperationType;
+    /** Vault the operation acts on. */
+    readonly vault: Address;
+}
+/** Subject of a Vault V1 → V2 migration. */
+export interface VaultV1MigrateToV2Subject {
+    readonly operation: "vaultV1MigrateToV2";
+    /** Vault the migration exits. */
+    readonly sourceVault: Address;
+    /** Vault the migration enters. */
+    readonly targetVault: Address;
+}
+/** Protocol entity a limit's operation acts on, keyed by `operation`; shared by `SimulatedOperation` and the verification error context. */
+export type SimulationOperationSubject = BlueMarketOperationSubject | BlueRefinanceSubject | VaultOperationSubject | VaultV1MigrateToV2Subject;
+/** Caller-quoted net amounts in raw units over the whole bundle.
+ * Supply at least one amount. Unquoted amounts are not checked.
+ */
+export interface SlippageQuote {
+    /**
+     * Expected net assets credited to the receiver. For in-kind vault redemptions,
+     * this measures only the wallet balance of the vault asset, not Morpho positions.
+     */
+    readonly assetsReceived?: bigint;
+    /**
+     * Expected net shares added to the position. For debt shares, this is a
+     * maximum: minting more debt shares than quoted is adverse.
+     */
+    readonly sharesMinted?: bigint;
+    /** Expected net assets debited from the sender. */
+    readonly assetsPaid?: bigint;
+    /**
+     * Expected net shares removed from the position. For debt shares, this is a
+     * minimum: burning fewer debt shares than quoted is adverse.
+     */
+    readonly sharesBurned?: bigint;
+}
+/** Caller quote and permitted adverse percentage deviation. */
+export interface SlippageLimits {
+    readonly quote: SlippageQuote;
+    /** WAD-scaled fraction from 0 to 1e18 inclusive; 1e16 means 1%. No default. */
+    readonly slippageTolerance: bigint;
+}
+/** Caller-selected action and subject with the same quote/tolerance shape for every action.
+ * Measurements cover the entire bundle for the named subject, never an inferred
+ * individual transaction. Use separate simulations for per-transaction bounds.
+ */
+export type OperationLimit = SlippageLimits & {
+    /** Position/share owner; defaults to the transaction sender. */
+    readonly account?: Address;
+    /**
+     * Explicit asset paid; defaults to the action underlying. Use viem's
+     * `ethAddress` (`0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE`) for native ETH;
+     * sentinels such as `zeroAddress` are read as ERC-20 tokens.
+     */
+    readonly assetPaid?: Address;
+    /**
+     * Explicit asset received; defaults to the action underlying. Use viem's
+     * `ethAddress` (`0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE`) for native ETH;
+     * sentinels such as `zeroAddress` are read as ERC-20 tokens.
+     */
+    readonly assetReceived?: Address;
+    /** Asset receiver; defaults to the transaction sender. */
+    readonly receiver?: Address;
+} & ({
+    readonly type: BlueMarketOperationType;
+    readonly marketId: MarketId;
+} | {
+    readonly type: "blueRefinance";
+    readonly sourceMarketId: MarketId;
+    readonly targetMarketId: MarketId;
+} | {
+    readonly type: VaultOperationType;
+    readonly vault: Address;
+} | {
+    readonly type: "vaultV1MigrateToV2";
+    readonly sourceVault: Address;
+    readonly targetVault: Address;
+});
+/** Optional caller-selected checks. No action discovery or default bounds. */
+export interface SimulationLimits {
+    readonly operations?: readonly OperationLimit[];
+}

package/lib/cjs/limits.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VAULT_OPERATION_TYPES = exports.BLUE_MARKET_OPERATION_TYPES = exports.OPERATION_TYPES = void 0;
+/** Every operation type; source of `OperationType`. */
+exports.OPERATION_TYPES = [
+    "blueSupply",
+    "blueWithdraw",
+    "blueSupplyCollateral",
+    "blueBorrow",
+    "blueSupplyCollateralBorrow",
+    "blueRepay",
+    "blueWithdrawCollateral",
+    "blueRepayWithdrawCollateral",
+    "blueRefinance",
+    "vaultV1Deposit",
+    "vaultV2Deposit",
+    "vaultV1Withdraw",
+    "vaultV2Withdraw",
+    "vaultV1Redeem",
+    "vaultV2Redeem",
+    "vaultV2ForceWithdraw",
+    "vaultV2ForceRedeem",
+    "vaultV1InKindRedeem",
+    "vaultV2InKindRedeem",
+    "vaultV1MigrateToV2",
+];
+/** Operations acting on one Blue market; source of `BlueMarketOperationType`. */
+exports.BLUE_MARKET_OPERATION_TYPES = [
+    "blueSupply",
+    "blueWithdraw",
+    "blueSupplyCollateral",
+    "blueBorrow",
+    "blueSupplyCollateralBorrow",
+    "blueRepay",
+    "blueWithdrawCollateral",
+    "blueRepayWithdrawCollateral",
+];
+/** Operations acting on one vault (V1 or V2); source of `VaultOperationType`. */
+exports.VAULT_OPERATION_TYPES = [
+    "vaultV1Deposit",
+    "vaultV2Deposit",
+    "vaultV1Withdraw",
+    "vaultV2Withdraw",
+    "vaultV1Redeem",
+    "vaultV2Redeem",
+    "vaultV2ForceWithdraw",
+    "vaultV2ForceRedeem",
+    "vaultV1InKindRedeem",
+    "vaultV2InKindRedeem",
+];

package/lib/cjs/params.d.ts

@@ -0,0 +1,26 @@
+import type { BlockTag } from "viem";
+import type { SimulationAuthorization } from "./authorizations.js";
+import type { SimulationLimits } from "./limits.js";
+import type { SimulationTransaction } from "./types.js";
+/** Every simulation mode; source of `SimulationMode`. */
+export declare const SIMULATION_MODES: readonly ["preview", "final"];
+/** Simulation mode: `"preview"` accepts pending authorizations, `"final"` does not. */
+export type SimulationMode = (typeof SIMULATION_MODES)[number];
+/**
+ * Input to `simulate()`. `authorizations` is accepted only in "preview";
+ * `mode` defaults to "final".
+ */
+export interface SimulateParams {
+    readonly chainId: number;
+    readonly transactions: readonly SimulationTransaction[];
+    /** Defaults to "final". */
+    readonly mode?: SimulationMode;
+    /** Pending wallet requests, in order. Preview only; rejected in final. */
+    readonly authorizations?: readonly SimulationAuthorization[];
+    /** Resolved once; defaults to "latest" ("finalized" on Monad, whose
+     * "latest" block is not final). Only canonical (mined) blocks can be
+     * pinned; `pending` has no stable hash and is rejected at runtime. */
+    readonly blockNumber?: bigint | Exclude<BlockTag, "pending">;
+    /** Caller-selected quotes and percentage tolerances. Omitted limits are unchecked. */
+    readonly limits?: SimulationLimits;
+}

package/lib/cjs/params.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIMULATION_MODES = void 0;
+/** Every simulation mode; source of `SimulationMode`. */
+exports.SIMULATION_MODES = ["preview", "final"];

package/lib/cjs/requirements/index.d.ts

@@ -0,0 +1 @@
+export { toSimulationAuthorizations } from "./requirements.js";

package/lib/cjs/requirements/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSimulationAuthorizations = void 0;
+var requirements_js_1 = require("./requirements.js");
+Object.defineProperty(exports, "toSimulationAuthorizations", { enumerable: true, get: function () { return requirements_js_1.toSimulationAuthorizations; } });

package/lib/cjs/requirements/requirements.d.ts

@@ -0,0 +1,64 @@
+import type { ActionRequirement } from "@morpho-org/morpho-sdk";
+import type { Address } from "viem";
+import type { SimulationAuthorization } from "../authorizations.js";
+import type { SimulationMode } from "../params.js";
+/**
+ * Maps morpho-sdk action requirements, in order, onto simulation authorization descriptors.
+ *
+ * The adapter is a pure mapper — nothing is decoded or validated; `simulate()`'s request parser
+ * validates each authorization's shape and semantics when the request is parsed. Call requirements
+ * (`erc20Approval`, `blueAuthorization`) are mapped straight from `action.args` (the approval
+ * token is the requirement's `to`). Signature requirements (`permit`,
+ * `permit2SignatureTransfer`, `authorization`) carry their EIP-712 payload through unchanged; a
+ * missing payload throws {@link AuthorizationRequestMismatchError}. Any other requirement type
+ * throws {@link UnsupportedOperationError}.
+ *
+ * The function is pure and synchronous: no RPC reads, no clock, no signing.
+ *
+ * @param params - Mapping parameters.
+ * @param params.chainId - The chain the requirements were resolved on; carried into error contexts.
+ * @param params.mode - Simulation mode carried into error contexts (`"preview"` or `"final"`).
+ * @param params.blockNumber - Pinned block the simulation is verified against; carried into error contexts.
+ * @param params.owner - The account the requirements were resolved for (transaction sender).
+ * @param params.requirements - Requirements returned by `ActionOutput.getRequirements()`.
+ * @returns One {@link SimulationAuthorization} per input requirement, in the same order.
+ * @throws {AuthorizationRequestMismatchError} when a signature requirement carries no `typedData`.
+ * @throws {UnsupportedOperationError} when a requirement's action type is not a supported
+ *   authorization.
+ * @example
+ * ```ts
+ * import { toSimulationAuthorizations } from "@morpho-org/evm-simulation";
+ * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
+ * import { vaults } from "@morpho-org/morpho-test";
+ * import { createPublicClient, http, type Address } from "viem";
+ * import { mainnet } from "viem/chains";
+ *
+ * async function prepare(userAddress: Address, blockNumber: bigint) {
+ *   const client = createPublicClient({ chain: mainnet, transport: http() })
+ *     .extend(morphoViemExtension());
+ *   const vault = client.morpho.vaultV1(
+ *     vaults[mainnet.id].steakUsdc.address,
+ *     mainnet.id,
+ *   );
+ *   const vaultData = await vault.getData();
+ *   const requirements = await vault
+ *     .deposit({ amount: 1_000_000n, userAddress, vaultData })
+ *     .getRequirements();
+ *   const authorizations = toSimulationAuthorizations({
+ *     chainId: mainnet.id,
+ *     mode: "final",
+ *     blockNumber,
+ *     owner: userAddress,
+ *     requirements,
+ *   });
+ *   return authorizations; // readonly SimulationAuthorization[], one entry per requirement
+ * }
+ * ```
+ */
+export declare function toSimulationAuthorizations(params: {
+    readonly chainId: number;
+    readonly mode: SimulationMode;
+    readonly blockNumber: bigint;
+    readonly owner: Address;
+    readonly requirements: readonly ActionRequirement[];
+}): readonly SimulationAuthorization[];