@morpho-org/evm-simulation 4.2.1 → 5.0.0

package/lib/cjs/simulate/plan/plan-execution.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planExecution = planExecution;
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+/**
+ * Plan the execution of a request as ordered `eth_simulateV1` calls.
+ *
+ * Sequence (design §plan order): every `before` state read → preparation
+ * calls → every user transaction → every `after` state read.
+ *
+ * Preparation calls run `from` the owner; state reads run `from`
+ * `zeroAddress` and never receive a public `txIdx`.
+ *
+ * @param request - The parsed request.
+ * @param owner - The bundle owner; sender of preparation calls.
+ * @param preparations - Ordered authorization preparations to simulate.
+ * @param reads - The full state-read list, replayed at `before` and `after`.
+ * @returns A deep-frozen {@link ExecutionPlan}; pure — equal inputs produce
+ *   structurally equal plans.
+ * @internal
+ */
+function planExecution(params) {
+    const { request, owner, preparations, reads } = params;
+    const calls = [];
+    for (const read of reads) {
+        calls.push({
+            type: "stateRead",
+            phase: "before",
+            read,
+            transaction: {
+                from: viem_1.zeroAddress,
+                to: read.to,
+                data: read.data,
+                value: 0n,
+            },
+        });
+    }
+    for (const preparation of preparations) {
+        preparation.calls.forEach((transaction, callIndex) => {
+            calls.push({
+                type: "preparation",
+                authorizationIndex: preparation.authorizationIndex,
+                callIndex,
+                transaction: { ...transaction, from: owner },
+            });
+        });
+    }
+    request.transactions.forEach((transaction, i) => {
+        calls.push({
+            type: "transaction",
+            transactionIndex: i,
+            transaction: {
+                from: transaction.from,
+                to: transaction.to,
+                data: transaction.data,
+                value: transaction.value ?? 0n,
+            },
+        });
+    });
+    for (const read of reads) {
+        calls.push({
+            type: "stateRead",
+            phase: "after",
+            read,
+            transaction: {
+                from: viem_1.zeroAddress,
+                to: read.to,
+                data: read.data,
+                value: 0n,
+            },
+        });
+    }
+    return (0, morpho_ts_1.deepFreeze)({ request, calls });
+}

package/lib/cjs/simulate/prepare.d.ts

@@ -0,0 +1,30 @@
+import { type Address } from "viem";
+import type { SimulationAuthorization } from "../authorizations.js";
+import type { SimulationTransaction } from "../types.js";
+/** One authorization's preparation calls, in execution order. @internal */
+export interface PlannedPreparation {
+    readonly authorizationIndex: number;
+    readonly calls: readonly Required<Readonly<SimulationTransaction>>[];
+}
+/**
+ * Build the ordered preparation calls a preview execution runs before the
+ * user transactions, so each pending wallet request is satisfied onchain.
+ *
+ * - `erc20Approval` → `approve(spender, amount)`; zero-reset entries produce
+ *   their own `approve(0)` call in list order.
+ * - Signature variants (`erc2612Permit`, `permit2SignatureTransfer`) grant
+ *   owner→bundle allowance for the previewed pull — a permit2 transfer makes
+ *   no change to the nonce bitmap.
+ * - `blueAuthorization` / `blueAuthorizationSignature` →
+ *   `setAuthorization(authorized, isAuthorized)`.
+ *
+ * Final mode produces no preparations. Successful execution proves only the
+ * simulated permissions, not the validity of a future signature.
+ *
+ * @internal
+ */
+export declare function prepareAuthorizations(params: {
+    readonly authorizations: readonly SimulationAuthorization[];
+    readonly owner: Address;
+    readonly morpho: Address;
+}): readonly PlannedPreparation[];

package/lib/cjs/simulate/prepare.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareAuthorizations = prepareAuthorizations;
+const abis_1 = require("@morpho-org/morpho-sdk/abis");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+// biome-ignore lint/complexity/useMaxParams: lookup helpers read clearest with positional arguments
+const approvalTx = (owner, token, spender, amount) => ({
+    from: (0, viem_1.getAddress)(owner),
+    to: (0, viem_1.getAddress)(token),
+    data: (0, viem_1.encodeFunctionData)({
+        abi: viem_1.erc20Abi,
+        functionName: "approve",
+        args: [spender, amount],
+    }),
+    value: 0n,
+});
+/**
+ * Build the ordered preparation calls a preview execution runs before the
+ * user transactions, so each pending wallet request is satisfied onchain.
+ *
+ * - `erc20Approval` → `approve(spender, amount)`; zero-reset entries produce
+ *   their own `approve(0)` call in list order.
+ * - Signature variants (`erc2612Permit`, `permit2SignatureTransfer`) grant
+ *   owner→bundle allowance for the previewed pull — a permit2 transfer makes
+ *   no change to the nonce bitmap.
+ * - `blueAuthorization` / `blueAuthorizationSignature` →
+ *   `setAuthorization(authorized, isAuthorized)`.
+ *
+ * Final mode produces no preparations. Successful execution proves only the
+ * simulated permissions, not the validity of a future signature.
+ *
+ * @internal
+ */
+function prepareAuthorizations(params) {
+    const { authorizations, owner, morpho } = params;
+    const preparations = [];
+    authorizations.forEach((auth, authorizationIndex) => {
+        const calls = [];
+        switch (auth.type) {
+            case "erc20Approval":
+                calls.push(approvalTx(owner, auth.token, auth.spender, auth.amount));
+                break;
+            case "erc2612Permit": {
+                const { message, domain } = auth.typedData;
+                calls.push(approvalTx(owner, domain.verifyingContract, message.spender, message.value));
+                break;
+            }
+            case "permit2SignatureTransfer": {
+                const { message } = auth.typedData;
+                calls.push(approvalTx(owner, message.permitted.token, message.spender, message.permitted.amount));
+                break;
+            }
+            case "blueAuthorization":
+            case "blueAuthorizationSignature": {
+                const { authorized, isAuthorized } = auth.type === "blueAuthorization" ? auth : auth.typedData.message;
+                calls.push({
+                    from: (0, viem_1.getAddress)(owner),
+                    to: (0, viem_1.getAddress)(morpho),
+                    data: (0, viem_1.encodeFunctionData)({
+                        abi: abis_1.blueAbi,
+                        functionName: "setAuthorization",
+                        args: [authorized, isAuthorized],
+                    }),
+                    value: 0n,
+                });
+                break;
+            }
+            default: {
+                const exhaustive = auth;
+                void exhaustive;
+            }
+        }
+        preparations.push({
+            authorizationIndex,
+            calls: (0, morpho_ts_1.deepFreeze)(calls),
+        });
+    });
+    return (0, morpho_ts_1.deepFreeze)(preparations);
+}

package/lib/cjs/simulate/request/index.d.ts

@@ -0,0 +1 @@
+export { parseRequest } from "./parse-request.js";

package/lib/cjs/simulate/request/index.js

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

package/lib/cjs/simulate/request/parse-request.d.ts

@@ -0,0 +1,44 @@
+import { type Address, type BlockTag, type Hex } from "viem";
+import type { SimulationAuthorization } from "../../authorizations.js";
+import type { SimulationLimits } from "../../limits.js";
+import { type SimulateParams, type SimulationMode } from "../../params.js";
+/** A normalized user transaction: checksummed addresses, `value` defaulted to `0n`.
+ * @internal
+ */
+export interface ParsedTransaction {
+    readonly from: Address;
+    readonly to: Address;
+    readonly data: Hex;
+    readonly value: bigint;
+}
+/** The output of {@link parseRequest}: the caller's input validated, checksummed and defaulted.
+ * @internal
+ */
+export interface ParsedRequest {
+    readonly chainId: number;
+    readonly mode: SimulationMode;
+    readonly transactions: readonly ParsedTransaction[];
+    /** Always empty in final mode. */
+    readonly authorizations: readonly SimulationAuthorization[];
+    readonly blockNumber?: bigint | Exclude<BlockTag, "pending">;
+    readonly limits?: SimulationLimits;
+}
+/**
+ * Parse and normalize raw `simulate` input into a {@link ParsedRequest}.
+ *
+ * The public types own the key shape; runtime validation rejects unknown keys
+ * (`<path>.<key>: unknown field`), checks values — address and hex formats,
+ * uint256 ranges, typed-data field lists — and rejects legacy `{type: "approval"}` / `{type: "signature"}` authorizations and Permit2
+ * `PermitSingle` payloads rather than silently reinterpreting them. Cross-field
+ * rules then pin a single owner: every transaction `from` and every
+ * authorization owner must be the same checksummed address, typed-data domains
+ * must bind to `chainId`, and `mode: "final"` rejects authorizations outright.
+ *
+ * @param input - Caller input (`SimulateParams`-shaped).
+ * @returns A deep-frozen, checksummed request: `mode` explicit (`"final"`
+ *   default), `authorizations` always an array, `value` defaulted to `0n`.
+ * @throws {SimulationValidationError} On any unknown key, value or cross-field
+ *   violation.
+ * @internal
+ */
+export declare function parseRequest(input: SimulateParams): ParsedRequest;