@morpho-org/evm-simulation 4.2.0 → 5.0.0

package/lib/esm/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/esm/simulate/prepare.js

@@ -0,0 +1,77 @@
+import { blueAbi } from "@morpho-org/morpho-sdk/abis";
+import { deepFreeze } from "@morpho-org/morpho-ts";
+import { encodeFunctionData, erc20Abi, getAddress } from "viem";
+// biome-ignore lint/complexity/useMaxParams: lookup helpers read clearest with positional arguments
+const approvalTx = (owner, token, spender, amount) => ({
+    from: getAddress(owner),
+    to: getAddress(token),
+    data: encodeFunctionData({
+        abi: 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
+ */
+export 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: getAddress(owner),
+                    to: getAddress(morpho),
+                    data: encodeFunctionData({
+                        abi: blueAbi,
+                        functionName: "setAuthorization",
+                        args: [authorized, isAuthorized],
+                    }),
+                    value: 0n,
+                });
+                break;
+            }
+            default: {
+                const exhaustive = auth;
+                void exhaustive;
+            }
+        }
+        preparations.push({
+            authorizationIndex,
+            calls: deepFreeze(calls),
+        });
+    });
+    return deepFreeze(preparations);
+}

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

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

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

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

package/lib/esm/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;