@morpho-org/evm-simulation 2.0.2 → 4.0.0

package/lib/esm/simulate/backends/tenderly-rest.js

@@ -1,276 +0,0 @@
-import { isAddress, isHex } from "viem";
-import { z } from "zod";
-import { ExternalServiceError, SimulationRevertedError } from "../../errors.js";
-// Zod validators for the subset of Tenderly responses we consume.
-// Addresses must be 40-hex-digit `0x...` (not just any string); topics and
-// data must be `0x`-prefixed hex so downstream `getAddress()` / `BigInt()`
-// calls don't throw inside `parseTransfers`, silently dropping transfers.
-const addressSchema = z.custom((val) => typeof val === "string" && isAddress(val));
-const hexSchema = z.custom((val) => typeof val === "string" && isHex(val));
-const tenderlyRawResponseSchema = z
-    .object({
-    simulation: z
-        .object({
-        id: z.string().optional(),
-        status: z.boolean().optional(),
-        error_message: z.string().optional(),
-    })
-        .passthrough(),
-    transaction: z
-        .object({
-        error_message: z.string().optional(),
-        gas_used: z.number(),
-        transaction_info: z
-            .object({
-            logs: z
-                .array(z
-                .object({
-                raw: z
-                    .object({
-                    address: addressSchema,
-                    topics: z.array(hexSchema).optional(),
-                    data: hexSchema.optional(),
-                })
-                    .passthrough()
-                    .optional(),
-            })
-                .passthrough())
-                .optional(),
-            asset_changes: z.unknown().optional(),
-            call_trace: z
-                .object({
-                output: hexSchema,
-            })
-                .passthrough(),
-        })
-            .passthrough(),
-    })
-        .passthrough(),
-})
-    .passthrough();
-const tenderlyBundleRawResponseSchema = z
-    .object({
-    simulation_results: z.array(tenderlyRawResponseSchema).min(1),
-})
-    .passthrough();
-/**
- * Simulate transactions using Tenderly REST API.
- *
- * @param shareable - true persists the simulation in Tenderly and returns a shareable URL;
- *   false runs ephemerally with no URL. Translates to Tenderly's `save` wire field
- *   (`save_if_fails` is also set to `shareable` — so failed preview simulations are
- *   ALSO persisted and shareable. Callers that preview sensitive calldata should be
- *   aware this persists in Tenderly's dashboard regardless of success/failure).
- */
-export async function simulateTenderlyRest(params) {
-    const { config, chainId, transactions, blockNumber, shareable, signal, logger, } = params;
-    const baseUrl = buildBaseUrl(config);
-    try {
-        if (transactions.length === 1) {
-            return await simulateSingle({
-                baseUrl,
-                config,
-                chainId,
-                tx: transactions[0],
-                blockNumber,
-                shareable,
-                signal,
-                logger,
-            });
-        }
-        return await simulateBundle({
-            baseUrl,
-            config,
-            chainId,
-            transactions,
-            blockNumber,
-            shareable,
-            signal,
-            logger,
-        });
-    }
-    catch (error) {
-        if (error instanceof SimulationRevertedError)
-            throw error;
-        if (error instanceof ExternalServiceError)
-            throw error;
-        throw new ExternalServiceError(`Tenderly REST API error: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
-}
-/** URL-encode the path-segment config values so `/`, `?`, `#` can't retarget the request. */
-function buildBaseUrl(config) {
-    const account = encodeURIComponent(config.accountSlug);
-    const project = encodeURIComponent(config.projectSlug);
-    return `${config.apiBaseUrl}/api/v1/account/${account}/project/${project}`;
-}
-/** Build the `TenderlySimulateRequest` body for one transaction. Shared by single + bundle. */
-// biome-ignore lint/complexity/useMaxParams: TODO refactor to ≤2 params
-function buildTxBody(tx, chainId, shareable, blockNumber) {
-    return {
-        network_id: String(chainId),
-        from: tx.from,
-        to: tx.to,
-        input: tx.data,
-        value: String(tx.value ?? 0n),
-        save: shareable,
-        save_if_fails: shareable,
-        simulation_type: "full",
-        ...(blockNumber !== undefined && {
-            block_number: typeof blockNumber === "bigint" ? String(blockNumber) : blockNumber,
-        }),
-    };
-}
-async function simulateSingle(params) {
-    const { baseUrl, config, chainId, tx, blockNumber, shareable, signal, logger, } = params;
-    const body = buildTxBody(tx, chainId, shareable, blockNumber);
-    const response = await fetch(`${baseUrl}/simulate`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "X-Access-Key": config.accessToken,
-        },
-        body: JSON.stringify(body),
-        signal,
-    });
-    if (!response.ok) {
-        throw new ExternalServiceError(`Tenderly REST API returned ${response.status}: ${response.statusText}`);
-    }
-    const data = tenderlyRawResponseSchema.parse(await response.json());
-    const call = parseTenderlyCall(data);
-    const tenderlyUrl = await resolveTenderlyUrl({
-        baseUrl,
-        config,
-        simulationId: data.simulation.id,
-        shareable,
-        signal,
-        logger,
-    });
-    return { calls: [call], tenderlyUrl };
-}
-async function simulateBundle(params) {
-    const { baseUrl, config, chainId, transactions, blockNumber, shareable, signal, logger, } = params;
-    const body = {
-        simulations: transactions.map((tx) => buildTxBody(tx, chainId, shareable, blockNumber)),
-    };
-    const response = await fetch(`${baseUrl}/simulate-bundle`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "X-Access-Key": config.accessToken,
-        },
-        body: JSON.stringify(body),
-        signal,
-    });
-    if (!response.ok) {
-        throw new ExternalServiceError(`Tenderly REST API returned ${response.status}: ${response.statusText}`);
-    }
-    const data = tenderlyBundleRawResponseSchema.parse(await response.json());
-    const simulations = data.simulation_results;
-    const calls = simulations.map((sim) => parseTenderlyCall(sim));
-    const lastSim = simulations[simulations.length - 1];
-    const tenderlyUrl = await resolveTenderlyUrl({
-        baseUrl,
-        config,
-        simulationId: lastSim.simulation.id,
-        shareable,
-        signal,
-        logger,
-    });
-    return { calls, tenderlyUrl };
-}
-/**
- * Build the shareable Tenderly dashboard URL for the given simulation, if
- * `shareable=true` and `/share` succeeds. Returns `undefined` otherwise.
- *
- * Mirrors the legacy "build optimistically, clear on failure" pattern: the
- * URL is constructed up-front and cleared if `shareSimulation` returns false.
- */
-async function resolveTenderlyUrl(params) {
-    const { baseUrl, config, simulationId, shareable, signal, logger } = params;
-    if (!shareable || !simulationId)
-        return undefined;
-    let tenderlyUrl = `https://dashboard.tenderly.co/shared/simulation/${simulationId}`;
-    const shared = await shareSimulation({
-        baseUrl,
-        config,
-        simulationId,
-        signal,
-        logger,
-    });
-    if (!shared)
-        tenderlyUrl = undefined;
-    return tenderlyUrl;
-}
-/**
- * Try to make a simulation publicly shareable. Returns true iff Tenderly's
- * `/share` endpoint responded 2xx. On any other outcome (non-ok response,
- * abort, network error), logs via `logger` and returns false — the caller
- * then clears `tenderlyUrl`. `AbortError` is re-thrown so cancellation
- * propagates cleanly instead of silently downgrading to "no URL".
- */
-async function shareSimulation(params) {
-    const { baseUrl, config, simulationId, signal, logger } = params;
-    const safeId = encodeURIComponent(simulationId);
-    try {
-        const response = await fetch(`${baseUrl}/simulations/${safeId}/share`, {
-            method: "POST",
-            headers: { "X-Access-Key": config.accessToken },
-            signal,
-        });
-        if (!response.ok) {
-            logger?.warn("Tenderly /share returned non-ok; tenderlyUrl will be cleared", {
-                simulationId,
-                status: response.status,
-                statusText: response.statusText,
-            });
-            return false;
-        }
-        return true;
-    }
-    catch (error) {
-        // Propagate cancellation; swallow only genuine fetch-layer failures.
-        if (error instanceof Error && error.name === "AbortError")
-            throw error;
-        logger?.warn("Tenderly /share fetch failed; tenderlyUrl will be cleared", {
-            simulationId,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return false;
-    }
-}
-/**
- * Parse one Tenderly simulation response into a `RawCall`. The caller
- * (single-sim or bundle) assembles the `RawSimulationResult` around it.
- *
- * Throws `SimulationRevertedError` if `simulation.status !== true`.
- */
-function parseTenderlyCall(data) {
-    const { simulation, transaction } = data;
-    if (simulation.status !== true) {
-        const errorMessage = transaction.error_message ||
-            simulation.error_message ||
-            "Transaction simulation reverted";
-        // NOTE: `data` includes the full Tenderly response (request body, calldata,
-        // asset changes). Callers that log `error.details` should redact — see
-        // `errors.ts` doc for `SimulationRevertedError.details`.
-        throw new SimulationRevertedError(errorMessage, data);
-    }
-    const rawLogs = [];
-    const logs = transaction.transaction_info.logs ?? [];
-    for (const log of logs) {
-        if (log.raw) {
-            rawLogs.push({
-                address: log.raw.address,
-                topics: log.raw.topics ?? [],
-                data: log.raw.data ?? "0x",
-            });
-        }
-    }
-    return {
-        logs: rawLogs,
-        status: true,
-        returnData: transaction.transaction_info.call_trace.output,
-        gasUsed: BigInt(transaction.gas_used),
-        assetChanges: transaction.transaction_info.asset_changes,
-    };
-}