lovewebconnection 0.0.0-stage → 0.2.0

package/dist/tokenfile.js

@@ -0,0 +1,218 @@
+import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { getAddress } from "viem";
+import { BalancesArgError, MAX_SUB_CALLS, loadTokenList, parseTokenSpec, rememberTokenLabel, } from "./balances.js";
+export class TokenFileArgError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TokenFileArgError";
+    }
+}
+/** Parse one address spec (`0xAddress`, `0xAddress=Label`, `0xAddress:Label`). */
+function parseMaxSubCalls(raw) {
+    if (!/^\d+$/.test(raw)) {
+        throw new TokenFileArgError(`--max-subcalls must be a whole number, got "${raw}".`);
+    }
+    const value = Number(raw);
+    if (value < 1 || value > MAX_SUB_CALLS) {
+        throw new TokenFileArgError(`--max-subcalls must be between 1 and ${MAX_SUB_CALLS}.`);
+    }
+    return value;
+}
+function parseEntry(raw) {
+    try {
+        return parseTokenSpec(raw);
+    }
+    catch (error) {
+        if (error instanceof BalancesArgError)
+            throw new TokenFileArgError(error.message);
+        throw error;
+    }
+}
+/** Normalize addresses and `{address, label}` entries to labeled entries. */
+function normalizeEntries(entries) {
+    return entries.map((entry) => {
+        if (typeof entry === "string")
+            return { address: getAddress(entry), label: null };
+        const label = entry.label?.trim() ?? "";
+        return { address: getAddress(entry.address), label: label.length > 0 ? label : null };
+    });
+}
+/**
+ * Keep the entries already in a list — same order, same labels — then append the
+ * addresses that are not there yet. A new label for an existing address replaces
+ * the old one, and a differing pair is reported in `warnings`.
+ */
+export function mergeTokenEntries(existing, added, warnings = []) {
+    const order = [];
+    const seen = new Set();
+    const labels = new Map();
+    for (const entry of [...normalizeEntries(existing), ...normalizeEntries(added)]) {
+        const key = entry.address.toLowerCase();
+        if (!seen.has(key)) {
+            seen.add(key);
+            order.push(entry.address);
+        }
+        // Present labels win in order, so an existing label survives an unlabeled
+        // repeat and a later label replaces an earlier one.
+        rememberTokenLabel(entry, labels, warnings);
+    }
+    return order.map((address) => ({
+        address,
+        label: labels.get(address.toLowerCase()) ?? null,
+    }));
+}
+/**
+ * Build a `--tokens-file` list from command-line addresses. Pure local work: no
+ * RPC call is needed, and labels are carried through to the written file. With
+ * `--merge` the existing file is read so only new addresses are appended.
+ */
+export function parseTokenFileArgs(argv) {
+    const raw = [];
+    let outPath = null;
+    let force = false;
+    let merge = false;
+    let maxSubCalls = null;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index] ?? "";
+        if (arg === "--out") {
+            const value = argv[index + 1];
+            if (!value || (value.startsWith("-") && value !== "-")) {
+                throw new TokenFileArgError("--out requires a path, or - for stdout.");
+            }
+            outPath = value;
+            index += 1;
+        }
+        else if (arg.startsWith("--out=")) {
+            const value = arg.slice("--out=".length);
+            if (!value)
+                throw new TokenFileArgError("--out requires a path, or - for stdout.");
+            outPath = value;
+        }
+        else if (arg === "--force") {
+            force = true;
+        }
+        else if (arg === "--merge") {
+            merge = true;
+        }
+        else if (arg === "--max-subcalls") {
+            const value = argv[index + 1];
+            if (!value)
+                throw new TokenFileArgError("--max-subcalls requires a value.");
+            maxSubCalls = parseMaxSubCalls(value);
+            index += 1;
+        }
+        else if (arg.startsWith("--max-subcalls=")) {
+            maxSubCalls = parseMaxSubCalls(arg.slice("--max-subcalls=".length));
+        }
+        else if (arg === "--token") {
+            const value = argv[index + 1];
+            if (!value || value.startsWith("-"))
+                throw new TokenFileArgError("--token requires an address.");
+            raw.push(value);
+            index += 1;
+        }
+        else if (arg.startsWith("--token=")) {
+            raw.push(arg.slice("--token=".length));
+        }
+        else if (arg === "--tokens") {
+            const value = argv[index + 1];
+            if (!value || value.startsWith("-")) {
+                throw new TokenFileArgError("--tokens requires a comma-separated list.");
+            }
+            raw.push(...value.split(","));
+            index += 1;
+        }
+        else if (arg.startsWith("--tokens=")) {
+            raw.push(...arg.slice("--tokens=".length).split(","));
+        }
+        else if (arg.startsWith("-")) {
+            continue; // --json and other global flags are handled by the caller.
+        }
+        else {
+            raw.push(arg);
+        }
+    }
+    if (outPath === null) {
+        throw new TokenFileArgError("--out <path> is required (use --out - for stdout).");
+    }
+    if (merge && outPath === "-") {
+        throw new TokenFileArgError("--merge needs a file path; it cannot append to --out -.");
+    }
+    const addresses = [];
+    const labels = new Map();
+    const warnings = [];
+    const seen = new Set();
+    for (const value of raw) {
+        const candidate = value.trim();
+        if (!candidate)
+            continue;
+        const entry = parseEntry(candidate);
+        // Duplicates keep the first position but the last label, and a differing
+        // label is reported rather than silently dropped.
+        rememberTokenLabel(entry, labels, warnings);
+        const key = entry.address.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        addresses.push(entry.address);
+    }
+    if (addresses.length === 0) {
+        throw new TokenFileArgError("at least one token address is required.");
+    }
+    const given = addresses.map((address) => ({
+        address,
+        label: labels.get(address.toLowerCase()) ?? null,
+    }));
+    let entries = given;
+    if (merge && existsSync(outPath)) {
+        let existing;
+        try {
+            existing = loadTokenList(outPath);
+        }
+        catch (error) {
+            throw new TokenFileArgError(error instanceof Error ? error.message : String(error));
+        }
+        entries = mergeTokenEntries(existing, given, warnings);
+    }
+    return {
+        addresses: entries.map((entry) => entry.address),
+        entries,
+        outPath,
+        force,
+        merge,
+        maxSubCalls,
+        warnings,
+    };
+}
+/**
+ * The written shape: a checksummed address string when there is no label, and an
+ * `{ address, label }` object when there is — both forms `--tokens-file` reads.
+ */
+export function tokenListItems(entries) {
+    return normalizeEntries(entries).map((entry) => entry.label === null ? entry.address : { address: entry.address, label: entry.label });
+}
+/** JSON array in the format `--tokens-file` reads, labels included. */
+export function buildTokenListJson(entries) {
+    return `${JSON.stringify(tokenListItems(entries), null, 2)}\n`;
+}
+/** Write the list (or return it for "-"), never replacing a file without force. */
+export function saveTokenList(outPath, entries, options = {}) {
+    const json = buildTokenListJson(entries);
+    if (outPath === "-")
+        return json;
+    if (!options.force && existsSync(outPath)) {
+        throw new TokenFileArgError(`${outPath} already exists; pass --force to replace it.`);
+    }
+    try {
+        mkdirSync(dirname(outPath), { recursive: true });
+        const temporary = `${outPath}.tmp`;
+        writeFileSync(temporary, json);
+        renameSync(temporary, outPath);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new TokenFileArgError(`cannot write ${outPath}: ${reason}`);
+    }
+    return json;
+}

package/dist/views.d.ts

@@ -0,0 +1,63 @@
+import { type Abi, type AbiFunction, type Address, type PublicClient } from "viem";
+import { type CallArgError } from "./call.ts";
+export declare class ViewsArgError extends Error {
+    constructor(message: string);
+}
+export type ViewsArgsSpec = {
+    kind: "array";
+    args: unknown[];
+} | {
+    kind: "map";
+    args: Record<string, unknown[]>;
+} | null;
+export interface ViewsArgs {
+    address: Address;
+    /** null means no `--abi` was given, so the built-in ERC-20 ABI applies. */
+    abiPath: string | null;
+    spec: ViewsArgsSpec;
+    /** Block to read at, or "latest" to use the head at run time. */
+    block: "latest" | bigint;
+    /** Fixed sub-call budget per Multicall3 request, or null for one request. */
+    maxSubCalls: number | null;
+}
+export declare function parseViewsArgs(argv: string[]): ViewsArgs;
+/** Every function in the ABI that can be called read-only, in ABI order. */
+export declare function listViewFunctions(abi: Abi): AbiFunction[];
+export type ViewCallStatus = "ok" | "error" | "skipped";
+export interface ViewCallResult {
+    fn: AbiFunction;
+    signature: string;
+    status: ViewCallStatus;
+    /** Decoded result when status is "ok". */
+    value: unknown;
+    /** Failure message when status is "error". */
+    error: string | null;
+    /** Why the call was not attempted, when status is "skipped". */
+    reason: string | null;
+    args: unknown[];
+}
+export interface ViewsReport {
+    contract: Address;
+    /** Display source: the `--abi` path, or the built-in ABI label. */
+    abiPath: string;
+    blockNumber: bigint;
+    results: ViewCallResult[];
+    called: number;
+    failed: number;
+    skipped: number;
+    /** Multicall3 requests sent; 1 without a cap, more when chunked. */
+    chunks: number;
+    maxSubCalls: number | null;
+}
+/**
+ * Call every view function once, packed into a single Multicall3 aggregate3
+ * request at one block. Functions that need arguments are skipped unless `spec`
+ * supplies them, a reverting getter is reported in its own row, and if a
+ * batch itself fails that group's calls are retried individually. A
+ * `maxSubCalls` cap splits the work across several Multicall3 requests.
+ */
+export declare function runViewFunctions(client: PublicClient, contract: Address, abi: Abi, abiPath: string, spec?: ViewsArgsSpec, block?: "latest" | bigint, maxSubCalls?: number | null): Promise<ViewsReport>;
+export declare function formatViews(report: ViewsReport): string;
+export declare function toViewsJson(report: ViewsReport): Record<string, unknown>;
+/** Exported only so callers can share the error type in their own checks. */
+export type { CallArgError };

package/dist/views.js

@@ -0,0 +1,415 @@
+import { decodeErrorResult, decodeFunctionResult, encodeFunctionData, getAddress, isAddress, } from "viem";
+import { callViewFunction, coerceArgs, formatValue, serializeValue, signatureOf, } from "./call.js";
+import { MAX_SUB_CALLS } from "./balances.js";
+import { MULTICALL3_ADDRESS, multicall3BatchAbi } from "./contract.js";
+/** Standard Solidity revert payloads, decoded so `revert("...")` keeps its reason. */
+const revertErrorAbi = [
+    { type: "error", name: "Error", inputs: [{ name: "message", type: "string" }] },
+    { type: "error", name: "Panic", inputs: [{ name: "code", type: "uint256" }] },
+];
+export class ViewsArgError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ViewsArgError";
+    }
+}
+function normalizeSignatureKey(value) {
+    return value.replace(/\s+/g, "");
+}
+/**
+ * A map entry may name the bare function or a full signature, so overloads are
+ * addressable. Signatures are matched first so `get(uint256)` beats a `get`
+ * entry regardless of key order, and whitespace in a key is ignored.
+ */
+function lookupMapArgs(args, fn) {
+    const signature = normalizeSignatureKey(signatureOf(fn));
+    const name = normalizeSignatureKey(fn.name);
+    for (const [key, value] of Object.entries(args)) {
+        if (normalizeSignatureKey(key) === signature)
+            return value;
+    }
+    for (const [key, value] of Object.entries(args)) {
+        if (normalizeSignatureKey(key) === name)
+            return value;
+    }
+    return undefined;
+}
+function parseBlock(raw) {
+    if (raw === "latest")
+        return "latest";
+    if (!/^\d+$/.test(raw)) {
+        throw new ViewsArgError(`--block must be "latest" or a block number, got "${raw}".`);
+    }
+    return BigInt(raw);
+}
+function parseMaxSubCalls(raw) {
+    if (!/^\d+$/.test(raw)) {
+        throw new ViewsArgError(`--max-subcalls must be a whole number, got "${raw}".`);
+    }
+    const value = Number(raw);
+    if (value < 1 || value > MAX_SUB_CALLS) {
+        throw new ViewsArgError(`--max-subcalls must be between 1 and ${MAX_SUB_CALLS}.`);
+    }
+    return value;
+}
+function parseArgSpec(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new ViewsArgError(`--args is not valid JSON: ${raw}`);
+    }
+    if (Array.isArray(parsed))
+        return { kind: "array", args: parsed };
+    if (parsed && typeof parsed === "object") {
+        const entries = Object.entries(parsed);
+        if (entries.length === 0)
+            return null;
+        for (const [name, value] of entries) {
+            if (!Array.isArray(value)) {
+                throw new ViewsArgError(`--args.${name} must be an array of arguments.`);
+            }
+        }
+        return { kind: "map", args: Object.fromEntries(entries) };
+    }
+    throw new ViewsArgError("--args must be a JSON array or an object of name → argument array.");
+}
+export function parseViewsArgs(argv) {
+    const positional = [];
+    let abiPath = null;
+    let spec = null;
+    let block = "latest";
+    let maxSubCalls = null;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index] ?? "";
+        const readValue = (flag) => {
+            const value = argv[index + 1];
+            if (!value)
+                throw new ViewsArgError(`${flag} requires a value.`);
+            index += 1;
+            return value;
+        };
+        if (arg === "--abi" || arg.startsWith("--abi=")) {
+            abiPath = arg.startsWith("--abi=") ? arg.slice("--abi=".length) : readValue("--abi");
+            if (!abiPath)
+                throw new ViewsArgError("--abi requires a file path.");
+        }
+        else if (arg === "--args" || arg.startsWith("--args=")) {
+            const value = arg.startsWith("--args=") ? arg.slice("--args=".length) : readValue("--args");
+            if (!value)
+                throw new ViewsArgError("--args requires JSON.");
+            spec = parseArgSpec(value);
+        }
+        else if (arg === "--block" || arg.startsWith("--block=")) {
+            const value = arg.startsWith("--block=") ? arg.slice("--block=".length) : readValue("--block");
+            block = parseBlock(value);
+        }
+        else if (arg === "--max-subcalls") {
+            maxSubCalls = parseMaxSubCalls(readValue("--max-subcalls"));
+        }
+        else if (arg.startsWith("--max-subcalls=")) {
+            maxSubCalls = parseMaxSubCalls(arg.slice("--max-subcalls=".length));
+        }
+        else if (arg.startsWith("-")) {
+            // Other flags (e.g. --json) are handled by the caller.
+            continue;
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    const [addressRaw] = positional;
+    if (!addressRaw) {
+        throw new ViewsArgError("A contract address is required: lwc views <address> [--abi <file>]");
+    }
+    if (!isAddress(addressRaw)) {
+        throw new ViewsArgError(`"${addressRaw}" is not a valid EVM address.`);
+    }
+    if (positional.length > 1) {
+        throw new ViewsArgError(`Unexpected extra argument: ${positional[1]}.`);
+    }
+    return { address: getAddress(addressRaw), abiPath, spec, block, maxSubCalls };
+}
+/** Every function in the ABI that can be called read-only, in ABI order. */
+export function listViewFunctions(abi) {
+    return abi.filter((item) => {
+        if (item.type !== "function")
+            return false;
+        const fn = item;
+        return (fn.stateMutability === "view" ||
+            fn.stateMutability === "pure" ||
+            (fn.stateMutability === undefined && fn.constant === true));
+    });
+}
+function describeError(error) {
+    if (error instanceof Error) {
+        const short = error.shortMessage;
+        if (typeof short === "string" && short.length > 0)
+            return short;
+        return error.message;
+    }
+    return String(error);
+}
+function resultOf(plan, status, value, error, reason) {
+    return {
+        fn: plan.fn,
+        signature: plan.signature,
+        status,
+        value,
+        error,
+        reason,
+        args: plan.args ?? plan.rawArgs,
+    };
+}
+/** Work out arguments and calldata before any network read, so a wide ABI is one batch. */
+function planViewCall(fn, spec) {
+    const signature = signatureOf(fn);
+    const inputs = fn.inputs ?? [];
+    let rawArgs;
+    if (inputs.length === 0) {
+        rawArgs = [];
+    }
+    else if (spec === null) {
+        return {
+            fn,
+            signature,
+            args: null,
+            rawArgs: [],
+            callData: null,
+            skipReason: `needs ${inputs.length} argument(s)`,
+            prepError: null,
+        };
+    }
+    else if (spec.kind === "array") {
+        if (spec.args.length !== inputs.length) {
+            return {
+                fn,
+                signature,
+                args: null,
+                rawArgs: [],
+                callData: null,
+                skipReason: `needs ${inputs.length} argument(s), --args has ${spec.args.length}`,
+                prepError: null,
+            };
+        }
+        rawArgs = spec.args;
+    }
+    else {
+        const entry = lookupMapArgs(spec.args, fn);
+        if (entry === undefined) {
+            return {
+                fn,
+                signature,
+                args: null,
+                rawArgs: [],
+                callData: null,
+                skipReason: `needs ${inputs.length} argument(s)`,
+                prepError: null,
+            };
+        }
+        rawArgs = entry;
+    }
+    try {
+        const args = coerceArgs(fn, rawArgs);
+        const callData = encodeFunctionData({
+            abi: [fn],
+            functionName: fn.name,
+            args,
+        });
+        return { fn, signature, args, rawArgs, callData, skipReason: null, prepError: null };
+    }
+    catch (error) {
+        return {
+            fn,
+            signature,
+            args: null,
+            rawArgs,
+            callData: null,
+            skipReason: null,
+            prepError: describeError(error),
+        };
+    }
+}
+function revertMessage(data) {
+    if (!data || data === "0x")
+        return "execution reverted (no data)";
+    try {
+        const decoded = decodeErrorResult({ abi: revertErrorAbi, data });
+        const args = decoded.args;
+        if (decoded.errorName === "Error" && typeof args?.[0] === "string") {
+            return `execution reverted: ${args[0]}`;
+        }
+        if (decoded.errorName === "Panic" && typeof args?.[0] === "bigint") {
+            return `execution reverted: panic 0x${args[0].toString(16)}`;
+        }
+    }
+    catch {
+        // Not a standard Error(string) or Panic(uint256) payload.
+    }
+    return `execution reverted (${data.length > 10 ? `${data.slice(0, 10)}…` : data})`;
+}
+function decodeReturn(plan, data) {
+    try {
+        const value = decodeFunctionResult({
+            abi: [plan.fn],
+            functionName: plan.fn.name,
+            data,
+        });
+        return resultOf(plan, "ok", value, null, null);
+    }
+    catch (error) {
+        return resultOf(plan, "error", null, describeError(error), null);
+    }
+}
+/**
+ * One eth_call: every callable function as an aggregate3 sub-call, pinned to
+ * the same block. Returns null when the batch cannot be used at all, so the
+ * caller can fall back to individual reads.
+ */
+async function callBatch(client, contract, plans, blockNumber) {
+    const calls = plans.map((plan) => ({
+        target: contract,
+        allowFailure: true,
+        callData: plan.callData,
+    }));
+    let results;
+    try {
+        results = (await client.readContract({
+            address: MULTICALL3_ADDRESS,
+            abi: multicall3BatchAbi,
+            functionName: "aggregate3",
+            args: [calls],
+            blockNumber,
+        }));
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(results) || results.length !== plans.length)
+        return null;
+    return plans.map((plan, index) => {
+        const result = results[index];
+        if (!result || result.success !== true) {
+            return resultOf(plan, "error", null, revertMessage(result?.returnData), null);
+        }
+        return decodeReturn(plan, result.returnData);
+    });
+}
+/** Split calls into request-sized groups; one group when no cap is set. */
+function chunkPlans(plans, maxSubCalls) {
+    if (plans.length === 0)
+        return [];
+    if (maxSubCalls === null)
+        return [plans];
+    const chunks = [];
+    for (let index = 0; index < plans.length; index += maxSubCalls) {
+        chunks.push(plans.slice(index, index + maxSubCalls));
+    }
+    return chunks;
+}
+async function callOneByOne(client, contract, abi, plans, blockNumber) {
+    return Promise.all(plans.map(async (plan) => {
+        try {
+            const outcome = await callViewFunction(client, contract, abi, plan.fn, plan.args ?? [], blockNumber);
+            return resultOf(plan, "ok", outcome.result, null, null);
+        }
+        catch (error) {
+            return resultOf(plan, "error", null, describeError(error), null);
+        }
+    }));
+}
+/**
+ * Call every view function once, packed into a single Multicall3 aggregate3
+ * request at one block. Functions that need arguments are skipped unless `spec`
+ * supplies them, a reverting getter is reported in its own row, and if a
+ * batch itself fails that group's calls are retried individually. A
+ * `maxSubCalls` cap splits the work across several Multicall3 requests.
+ */
+export async function runViewFunctions(client, contract, abi, abiPath, spec = null, block = "latest", maxSubCalls = null) {
+    const planned = listViewFunctions(abi).map((fn) => planViewCall(fn, spec));
+    const blockNumber = block === "latest" ? await client.getBlockNumber() : block;
+    const callable = planned.filter((plan) => plan.callData !== null);
+    const batches = chunkPlans(callable, maxSubCalls);
+    const outcomes = [];
+    for (const batch of batches) {
+        outcomes.push(...((await callBatch(client, contract, batch, blockNumber)) ??
+            (await callOneByOne(client, contract, abi, batch, blockNumber))));
+    }
+    let next = 0;
+    const results = planned.map((plan) => {
+        if (plan.skipReason !== null)
+            return resultOf(plan, "skipped", null, null, plan.skipReason);
+        if (plan.prepError !== null)
+            return resultOf(plan, "error", null, plan.prepError, null);
+        const outcome = outcomes[next];
+        next += 1;
+        return outcome ?? resultOf(plan, "error", null, "no result returned for this call", null);
+    });
+    return {
+        contract,
+        abiPath,
+        blockNumber,
+        results,
+        called: results.filter((result) => result.status === "ok").length,
+        failed: results.filter((result) => result.status === "error").length,
+        skipped: results.filter((result) => result.status === "skipped").length,
+        chunks: batches.length,
+        maxSubCalls,
+    };
+}
+export function formatViews(report) {
+    const width = Math.max(8, ...report.results.map((result) => result.signature.length));
+    const lines = [
+        "lwc — view calls",
+        "",
+        `  ${"contract".padEnd(14)}${report.contract}`,
+        `  ${"abi".padEnd(14)}${report.abiPath}`,
+        `  ${"functions".padEnd(14)}${report.results.length} view/pure: ${report.called} called, ${report.failed} failed, ${report.skipped} skipped`,
+        `  ${"block".padEnd(14)}${report.blockNumber}`,
+    ];
+    if (report.maxSubCalls !== null) {
+        lines.push(`  ${"requests".padEnd(14)}${report.chunks} multicall3 request${report.chunks === 1 ? "" : "s"}, max ${report.maxSubCalls} sub-calls`);
+    }
+    lines.push("");
+    for (const result of report.results) {
+        const detail = result.status === "ok"
+            ? formatValue(result.value)
+            : result.status === "error"
+                ? `error: ${result.error}`
+                : `skipped: ${result.reason}`;
+        lines.push(`  ${result.signature.padEnd(width)}  ${detail}`);
+    }
+    return lines.join("\n");
+}
+export function toViewsJson(report) {
+    return {
+        ok: report.failed === 0,
+        contract: report.contract,
+        abi: report.abiPath,
+        blockNumber: report.blockNumber.toString(),
+        called: report.called,
+        failed: report.failed,
+        skipped: report.skipped,
+        chunkCount: report.chunks,
+        maxSubCalls: report.maxSubCalls,
+        functions: report.results.map((result) => ({
+            name: result.fn.name,
+            signature: result.signature,
+            stateMutability: result.fn.stateMutability ?? null,
+            inputs: (result.fn.inputs ?? []).map((input) => ({
+                name: input.name && input.name.length > 0 ? input.name : null,
+                type: input.type,
+            })),
+            outputs: (result.fn.outputs ?? []).map((output) => ({
+                name: output.name && output.name.length > 0 ? output.name : null,
+                type: output.type,
+            })),
+            status: result.status,
+            args: serializeValue(result.args),
+            value: result.status === "ok" ? serializeValue(result.value) : null,
+            error: result.error,
+            reason: result.reason,
+        })),
+    };
+}