x402trace 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,130 @@
+/**
+ * X402-14 CLI surface. Two subcommands:
+ *
+ *   x402trace proxy --upstream <url> [--port 8402] [--log human|json] [--reconcile] …
+ *   x402trace inspect <jsonl-log-file> [--log human|json] …
+ *
+ * `commander` does the parsing; we own the wiring + exit-code
+ * discipline. See X402-14 Jira for acceptance criteria.
+ *
+ * `runCli` is the testable entry; `src/cli.ts` is the bin shim that
+ * calls it with the real `process` handles.
+ */
+import "dotenv/config";
+import { Command } from "commander";
+import { runInspectCommand } from "./inspect-command.js";
+import { runProxyCommand } from "./proxy-command.js";
+import { EXIT_SUCCESS, EXIT_USAGE } from "./exit-codes.js";
+// Keep in sync with package.json `version`. A runtime read from
+// package.json would be more durable but requires JSON-module
+// resolution gymnastics in NodeNext + a relative path that works for
+// both `tsx src/cli.ts` (dev) and `dist/cli.js` (published) — folding
+// that into a follow-up cleanup. Until then, the X402-19 release
+// checklist + the changelog-cut step are the guards against drift.
+const VERSION = "0.1.0";
+export async function runCli(argv, ctx) {
+    const program = new Command();
+    program
+        .name("x402trace")
+        .description("Local CLI for debugging x402 payment flows on Base — catches timeout reconciliation failures.")
+        .version(VERSION, "-v, --version")
+        .helpOption("-h, --help", "Show this message")
+        .configureOutput({
+        writeOut: (str) => ctx.stdout.write(str),
+        writeErr: (str) => ctx.stderr.write(str),
+    })
+        // commander would call process.exit on parse errors; we route it
+        // through our own exit-code constants instead.
+        .exitOverride();
+    let exit = EXIT_SUCCESS;
+    program
+        .command("proxy")
+        .description("Start the local HTTP proxy with live x402 capture and reconciliation.")
+        .requiredOption("--upstream <url>", "Upstream HTTP base URL to forward to")
+        .option("--port <n>", "Listen port (default 8402)")
+        .option("--log <human|json>", "Stdout format (default 'human')", validateLogFormat)
+        .option("--log-file <path>", "JSONL log file path (default ./x402trace.jsonl, env X402TRACE_LOG)")
+        .option("--log-secrets", "Keep raw EIP-3009 signatures in the log instead of redacting (default off)")
+        .option("--reconcile", "Subscribe to Base Sepolia and reconcile facilitator rejections against on-chain settlements")
+        .option("--rpc-url <url>", "Base Sepolia RPC URL (env BASE_RPC_URL)")
+        .option("--watch-timeout-ms <n>", "How long to watch the chain for a rejected exchange before giving up (default 60000)")
+        .option("--upstream-timeout-ms <n>", "Per-request timeout to the upstream server; on timeout the proxy emits `upstream_timeout` and returns 502 (default 30000)")
+        .action(async (flags) => {
+        const log = flags.log;
+        exit = await runProxyCommand({
+            ...(flags.upstream !== undefined ? { upstream: flags.upstream } : {}),
+            ...(flags.port !== undefined ? { port: Number(flags.port) } : {}),
+            ...(flags.logFile !== undefined ? { logFile: flags.logFile } : {}),
+            ...(log !== undefined ? { log } : {}),
+            ...(flags.logSecrets !== undefined ? { logSecrets: flags.logSecrets } : {}),
+            ...(flags.reconcile !== undefined ? { reconcile: flags.reconcile } : {}),
+            ...(flags.rpcUrl !== undefined ? { rpcUrl: flags.rpcUrl } : {}),
+            ...(flags.watchTimeoutMs !== undefined
+                ? { watchTimeoutMs: Number(flags.watchTimeoutMs) }
+                : {}),
+            ...(flags.upstreamTimeoutMs !== undefined
+                ? { upstreamTimeoutMs: Number(flags.upstreamTimeoutMs) }
+                : {}),
+        }, {
+            stdout: ctx.stdout,
+            stderr: ctx.stderr,
+            env: ctx.env,
+            waitForShutdown: ctx.waitForShutdown ?? defaultWaitForSignals,
+        });
+    });
+    program
+        .command("inspect")
+        .description("Replay a captured JSONL log and re-run reconciliation offline.")
+        .argument("<jsonl-log-file>", "Path to a JSONL log written by `x402trace proxy --reconcile`")
+        .option("--log <human|json>", "Stdout format (default 'human')", validateLogFormat)
+        .option("--watch-timeout-ms <n>", "Watch window applied during replay (default 60000)")
+        .action(async (logFile, flags) => {
+        const log = flags.log;
+        exit = await runInspectCommand({
+            logFile,
+            ...(log !== undefined ? { log } : {}),
+            ...(flags.watchTimeoutMs !== undefined
+                ? { watchTimeoutMs: Number(flags.watchTimeoutMs) }
+                : {}),
+        }, { stdout: ctx.stdout, stderr: ctx.stderr });
+    });
+    try {
+        await program.parseAsync([...argv], { from: "user" });
+    }
+    catch (err) {
+        // commander's `exitOverride()` throws a CommanderError on
+        // help/version/usage exits. Translate.
+        const code = err.code;
+        const exitCode = err.exitCode;
+        if (code === "commander.helpDisplayed" || code === "commander.version") {
+            return EXIT_SUCCESS;
+        }
+        if (exitCode !== undefined && exitCode !== 0) {
+            return EXIT_USAGE;
+        }
+        ctx.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        return EXIT_USAGE;
+    }
+    return exit;
+}
+function validateLogFormat(value) {
+    if (value !== "human" && value !== "json") {
+        throw new Error(`--log must be 'human' or 'json' (got '${value}')`);
+    }
+    return value;
+}
+/**
+ * Production-mode shutdown gate: resolve on the first SIGINT or
+ * SIGTERM. Used only by the long-running `proxy` subcommand.
+ */
+function defaultWaitForSignals() {
+    return new Promise((resolve) => {
+        const onSig = () => {
+            process.off("SIGINT", onSig);
+            process.off("SIGTERM", onSig);
+            resolve();
+        };
+        process.on("SIGINT", onSig);
+        process.on("SIGTERM", onSig);
+    });
+}

package/dist/cli/inspect-command.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `x402trace inspect <jsonl-log-file>` — replay a saved JSONL log,
+ * re-run the reconciliation engine against it, print every result.
+ *
+ * Pure-offline: never opens an HTTP server, never makes an RPC call.
+ * Reads the existing `chain.transfer` lines the live `proxy --reconcile`
+ * already persisted, joins them against `exchange.closed` /
+ * `exchange.payment`, emits `ReconciliationResult`s through the same
+ * formatter the live command uses.
+ *
+ * Useful for: re-running reconciliation after tweaking match logic;
+ * diagnosing a past outage from its captured log; CI smoke tests that
+ * don't want to spin up a real proxy.
+ */
+import type { LogFormat } from "../decoder/types.js";
+import { type Colorizer } from "./color.js";
+import { type ExitCode } from "./exit-codes.js";
+export interface InspectCommandOptions {
+    readonly logFile?: string;
+    readonly log?: LogFormat;
+    readonly watchTimeoutMs?: number;
+}
+export interface InspectRunContext {
+    readonly stdout: NodeJS.WritableStream;
+    readonly stderr: NodeJS.WritableStream;
+    readonly color?: Colorizer;
+}
+export declare function runInspectCommand(opts: InspectCommandOptions, ctx: InspectRunContext): Promise<ExitCode>;

package/dist/cli/inspect-command.js

@@ -0,0 +1,63 @@
+/**
+ * `x402trace inspect <jsonl-log-file>` — replay a saved JSONL log,
+ * re-run the reconciliation engine against it, print every result.
+ *
+ * Pure-offline: never opens an HTTP server, never makes an RPC call.
+ * Reads the existing `chain.transfer` lines the live `proxy --reconcile`
+ * already persisted, joins them against `exchange.closed` /
+ * `exchange.payment`, emits `ReconciliationResult`s through the same
+ * formatter the live command uses.
+ *
+ * Useful for: re-running reconciliation after tweaking match logic;
+ * diagnosing a past outage from its captured log; CI smoke tests that
+ * don't want to spin up a real proxy.
+ */
+import { stat } from "node:fs/promises";
+import { createColorizer } from "./color.js";
+import { EXIT_RUNTIME, EXIT_SUCCESS, EXIT_USAGE } from "./exit-codes.js";
+import { formatResultHuman, formatResultJson } from "./format-result.js";
+import { replayLog } from "./replay.js";
+const DEFAULT_WATCH_TIMEOUT_MS = 60_000;
+export async function runInspectCommand(opts, ctx) {
+    const logFile = opts.logFile;
+    if (!logFile) {
+        ctx.stderr.write("error: <jsonl-log-file> argument is required\n");
+        return EXIT_USAGE;
+    }
+    try {
+        const s = await stat(logFile);
+        if (!s.isFile()) {
+            ctx.stderr.write(`error: ${logFile} is not a regular file\n`);
+            return EXIT_USAGE;
+        }
+    }
+    catch {
+        ctx.stderr.write(`error: cannot read log file: ${logFile}\n`);
+        return EXIT_USAGE;
+    }
+    const format = opts.log ?? "human";
+    const color = ctx.color ?? createColorizer({ stream: ctx.stdout });
+    try {
+        const report = await replayLog({
+            logPath: logFile,
+            watchTimeoutMs: opts.watchTimeoutMs ?? DEFAULT_WATCH_TIMEOUT_MS,
+        });
+        if (format === "human") {
+            ctx.stdout.write(color.paint("dim", `replayed ${report.counts.linesTotal} lines (skipped=${report.counts.linesSkipped}, closed=${report.counts.proxyClosed}, payments=${report.counts.decoderPayments}, transfers=${report.counts.chainTransfers}, results=${report.counts.results})`) + "\n");
+        }
+        for (const result of report.results) {
+            ctx.stdout.write(format === "human"
+                ? `${formatResultHuman(result, color)}\n`
+                : `${formatResultJson(result)}\n`);
+        }
+        if (format === "json") {
+            // Trailer record with replay counts so JSON consumers can sanity-check.
+            ctx.stdout.write(`${JSON.stringify({ event: "inspect.summary", ...report.counts })}\n`);
+        }
+        return EXIT_SUCCESS;
+    }
+    catch (err) {
+        ctx.stderr.write(`${color.paint("red", "inspect failed:")} ${err instanceof Error ? err.message : String(err)}\n`);
+        return EXIT_RUNTIME;
+    }
+}

package/dist/cli/proxy-command.d.ts

@@ -0,0 +1,74 @@
+/**
+ * `x402trace proxy` — start the local HTTP proxy with live decoder +
+ * (optionally) chain subscription + reconciliation engine.
+ *
+ * Wires together the four substrates built across X402-10 → X402-13.
+ * Per [SPEC.md § 3 user flow](../../SPEC.md#3-user-flow) the headline
+ * line is `RECONCILED ⚠ settled-but-server-thinks-not`; that's rendered
+ * here (via `format-result.ts`) and persisted to JSONL as a
+ * `reconcile.result` record — the canonical artifact downstream tools
+ * read.
+ *
+ * Closes the X402-13 deferred acceptance bullet: every emitted
+ * `ReconciliationResult` and every observed `ChainTransfer` is written
+ * to the same JSONL log as the proxy events.
+ */
+import { type LogFormat } from "../decoder/index.js";
+import { type Colorizer } from "./color.js";
+import { type ExitCode } from "./exit-codes.js";
+export interface ProxyCommandOptions {
+    readonly upstream?: string;
+    readonly port?: number;
+    readonly logFile?: string;
+    readonly log?: LogFormat;
+    readonly logSecrets?: boolean;
+    readonly reconcile?: boolean;
+    readonly rpcUrl?: string;
+    readonly watchTimeoutMs?: number;
+    readonly upstreamTimeoutMs?: number;
+}
+export interface RunContext {
+    readonly stdout: NodeJS.WritableStream;
+    readonly stderr: NodeJS.WritableStream;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    /** Resolves with the chosen exit code once SIGINT/SIGTERM is observed. */
+    readonly waitForShutdown: () => Promise<void>;
+    readonly color?: Colorizer;
+}
+/**
+ * Pure config resolver for the `proxy` subcommand. Encapsulates the
+ * flag-vs-env-vs-default precedence rules from
+ * [ARCHITECTURE.md § Configuration](../../ARCHITECTURE.md#configuration)
+ * so they can be unit-tested without spinning up a real proxy.
+ *
+ * Precedence (highest wins): CLI flag → env var → built-in default.
+ *
+ * Returns either a fully-resolved config or a `usage_error` when the
+ * required `--upstream` is missing from both flag and env.
+ */
+export type ResolveProxyConfigResult = {
+    readonly ok: true;
+    readonly config: ResolvedProxyConfig;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+export interface ResolvedProxyConfig {
+    readonly upstream: string;
+    readonly port: number;
+    readonly logPath: string;
+    readonly format: LogFormat;
+    readonly logSecrets: boolean;
+    readonly reconcile: boolean;
+    readonly rpcUrl: string | undefined;
+    readonly watchTimeoutMs: number;
+    readonly upstreamTimeoutMs: number | undefined;
+}
+export declare function resolveProxyConfig(opts: ProxyCommandOptions, env: Readonly<Record<string, string | undefined>>): ResolveProxyConfigResult;
+/**
+ * Run the `proxy` subcommand. Returns the exit code; callers
+ * (`src/cli.ts`) translate this to `process.exit`. Tests inject a
+ * fast-resolving `waitForShutdown` so the command can run end-to-end
+ * without a real signal.
+ */
+export declare function runProxyCommand(opts: ProxyCommandOptions, ctx: RunContext): Promise<ExitCode>;

package/dist/cli/proxy-command.js

@@ -0,0 +1,197 @@
+/**
+ * `x402trace proxy` — start the local HTTP proxy with live decoder +
+ * (optionally) chain subscription + reconciliation engine.
+ *
+ * Wires together the four substrates built across X402-10 → X402-13.
+ * Per [SPEC.md § 3 user flow](../../SPEC.md#3-user-flow) the headline
+ * line is `RECONCILED ⚠ settled-but-server-thinks-not`; that's rendered
+ * here (via `format-result.ts`) and persisted to JSONL as a
+ * `reconcile.result` record — the canonical artifact downstream tools
+ * read.
+ *
+ * Closes the X402-13 deferred acceptance bullet: every emitted
+ * `ReconciliationResult` and every observed `ChainTransfer` is written
+ * to the same JSONL log as the proxy events.
+ */
+import { createChainClient } from "../chain/index.js";
+import { createDecoder, formatHuman, formatJson } from "../decoder/index.js";
+import { JsonlSink } from "../proxy/jsonl-sink.js";
+import { createProxy } from "../proxy/index.js";
+import { createReconciliationEngine } from "../reconciliation/index.js";
+import { createColorizer } from "./color.js";
+import { EXIT_RUNTIME, EXIT_SUCCESS, EXIT_USAGE } from "./exit-codes.js";
+import { formatResultHuman, formatResultJson } from "./format-result.js";
+import { chainTransferToJsonl } from "./replay.js";
+const DEFAULT_PORT = 8402;
+const DEFAULT_LOG_PATH = "./x402trace.jsonl";
+const DEFAULT_WATCH_TIMEOUT_MS = 60_000;
+export function resolveProxyConfig(opts, env) {
+    const upstream = opts.upstream ?? env.X402TRACE_UPSTREAM;
+    if (!upstream) {
+        return { ok: false, message: "--upstream is required" };
+    }
+    return {
+        ok: true,
+        config: {
+            upstream,
+            port: opts.port ?? toIntOrNull(env.X402TRACE_PORT) ?? DEFAULT_PORT,
+            logPath: opts.logFile ?? env.X402TRACE_LOG ?? DEFAULT_LOG_PATH,
+            format: opts.log ?? "human",
+            logSecrets: opts.logSecrets ?? false,
+            reconcile: opts.reconcile ?? truthy(env.X402TRACE_RECONCILE),
+            rpcUrl: opts.rpcUrl ?? env.BASE_RPC_URL,
+            watchTimeoutMs: opts.watchTimeoutMs ??
+                toIntOrNull(env.X402TRACE_WATCH_TIMEOUT_MS) ??
+                DEFAULT_WATCH_TIMEOUT_MS,
+            upstreamTimeoutMs: opts.upstreamTimeoutMs ?? toIntOrNull(env.X402TRACE_UPSTREAM_TIMEOUT_MS) ?? undefined,
+        },
+    };
+}
+/**
+ * Run the `proxy` subcommand. Returns the exit code; callers
+ * (`src/cli.ts`) translate this to `process.exit`. Tests inject a
+ * fast-resolving `waitForShutdown` so the command can run end-to-end
+ * without a real signal.
+ */
+export async function runProxyCommand(opts, ctx) {
+    const resolved = resolveProxyConfig(opts, ctx.env);
+    if (!resolved.ok) {
+        ctx.stderr.write(`error: ${resolved.message}\n`);
+        return EXIT_USAGE;
+    }
+    const { upstream, port, logPath, format, logSecrets, reconcile, rpcUrl, watchTimeoutMs, upstreamTimeoutMs, } = resolved.config;
+    const color = ctx.color ?? createColorizer({ stream: ctx.stdout });
+    // The proxy owns its own JsonlSink for proxy events; we open a
+    // SECOND sink against the same path for chain + reconcile events.
+    // Both use O_APPEND so kernel-level atomicity covers per-line writes.
+    const proxyHandle = await createProxy({
+        upstream,
+        port,
+        logPath,
+        ...(upstreamTimeoutMs !== undefined ? { upstreamTimeoutMs } : {}),
+    });
+    const sideSink = new JsonlSink(logPath);
+    await sideSink.open();
+    ctx.stdout.write(color.paint("bold", `x402trace proxy listening on ${proxyHandle.url}`) + `  →  ${upstream}\n`);
+    ctx.stdout.write(`${color.paint("dim", "log:")} ${logPath}  ${color.paint("dim", "format:")} ${format}  ${color.paint("dim", "secrets:")} ${logSecrets ? "shown" : "redacted"}  ${color.paint("dim", "reconcile:")} ${reconcile ? "on" : "off"}\n`);
+    const decoder = createDecoder({ logSecrets });
+    const engine = reconcile ? createReconciliationEngine({ watchTimeoutMs }) : null;
+    const chain = reconcile ? createChainClient({ ...(rpcUrl ? { rpcUrl } : {}) }) : null;
+    // --- Proxy / decoder event loop ---
+    const proxySub = proxyHandle.events.subscribe();
+    const proxyTask = (async () => {
+        for await (const event of proxySub) {
+            if (event.event === "exchange.opened") {
+                ctx.stdout.write(`${color.paint("dim", `[${event.t}]`)} HTTP ${event.request.method} ${event.request.path} (id=${event.id.slice(0, 8)})\n`);
+            }
+            else if (event.event === "exchange.closed") {
+                ctx.stdout.write(`${color.paint("dim", `[${event.t}]`)} HTTP ${event.response.status} ${event.outcome.kind} (id=${event.id.slice(0, 8)}, ${event.durationMs}ms)\n`);
+            }
+            else if (event.event === "proxy.error") {
+                ctx.stderr.write(`${color.paint("red", `[${event.t}] proxy error:`)} ${event.message}\n`);
+            }
+            engine?.ingestProxyEvent(event);
+            for (const decoded of decoder.decode(event)) {
+                engine?.ingestDecoderEvent(decoded);
+                ctx.stdout.write(format === "human" ? `  ${formatHuman(decoded)}\n` : `${formatJson(decoded)}\n`);
+            }
+        }
+    })();
+    // --- Chain subscription (only when --reconcile) ---
+    let chainSub = null;
+    let chainTask = null;
+    if (engine && chain) {
+        chainSub = chain.subscribeUsdcTransfers();
+        chainTask = (async () => {
+            try {
+                for await (const transfer of chainSub) {
+                    sideSink.append(chainTransferToJsonl(transfer, new Date().toISOString()));
+                    engine.ingestChainTransfer(transfer);
+                }
+            }
+            catch (err) {
+                ctx.stderr.write(`${color.paint("red", "chain subscription error:")} ${errMsg(err)}\n`);
+            }
+        })();
+    }
+    // --- Reconciliation result loop ---
+    let resultSub = null;
+    let resultTask = null;
+    if (engine) {
+        resultSub = engine.results();
+        resultTask = (async () => {
+            for await (const result of resultSub) {
+                sideSink.append({ event: "reconcile.result", ...serialiseBigints(result) });
+                ctx.stdout.write(format === "human"
+                    ? `${formatResultHuman(result, color)}\n`
+                    : `${formatResultJson(result)}\n`);
+            }
+        })();
+    }
+    // --- Wait for shutdown ---
+    try {
+        await ctx.waitForShutdown();
+    }
+    catch (err) {
+        ctx.stderr.write(`${color.paint("red", "runtime error:")} ${errMsg(err)}\n`);
+        await teardown();
+        return EXIT_RUNTIME;
+    }
+    await teardown();
+    return EXIT_SUCCESS;
+    async function teardown() {
+        proxySub.unsubscribe();
+        resultSub?.unsubscribe();
+        chainSub?.unsubscribe();
+        await proxyHandle.close();
+        await chain?.close();
+        await engine?.close();
+        await sideSink.close();
+        await proxyTask;
+        if (resultTask)
+            await resultTask;
+        if (chainTask)
+            await chainTask;
+    }
+}
+/**
+ * Returns a copy of `result` where any embedded `bigint` is coerced to
+ * a string so `JSON.stringify` doesn't throw. The strings round-trip
+ * via `BigInt(str)` in the replay reader.
+ */
+function serialiseBigints(result) {
+    // Walk one level deep — the only bigints are in `onChain` (ChainTransfer)
+    // and the top-level `expected`/`actual` of value_mismatch.
+    const out = {};
+    for (const [k, v] of Object.entries(result)) {
+        if (typeof v === "bigint") {
+            out[k] = v.toString();
+        }
+        else if (v && typeof v === "object" && !Array.isArray(v)) {
+            const nested = {};
+            for (const [k2, v2] of Object.entries(v)) {
+                nested[k2] = typeof v2 === "bigint" ? v2.toString() : v2;
+            }
+            out[k] = nested;
+        }
+        else {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+function toIntOrNull(value) {
+    if (!value)
+        return null;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+}
+function truthy(value) {
+    if (!value)
+        return false;
+    const v = value.toLowerCase();
+    return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/cli/replay.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Offline JSONL replay. Reads a log written by `x402trace proxy
+ * --reconcile`, reconstructs the four event streams the engine cares
+ * about (proxy `exchange.closed`, decoder `exchange.payment`, chain
+ * `chain.transfer`), and feeds them into a fresh engine.
+ *
+ * The engine runs on a *virtual clock* driven by each line's `t`
+ * field so the `not_settled` sweep fires at the right virtual moment
+ * even though the whole file replays in milliseconds.
+ *
+ * Per [ARCHITECTURE.md § JSONL record format](../../ARCHITECTURE.md#jsonl-record-format):
+ * "the file IS the API." This reader is the consumer side of that
+ * contract.
+ */
+import type { ChainTransfer } from "../chain/types.js";
+import type { ReconciliationEngine } from "../reconciliation/engine.js";
+import type { ReconciliationResult } from "../reconciliation/types.js";
+export interface ReplayOptions {
+    readonly logPath: string;
+    readonly watchTimeoutMs?: number;
+}
+export interface ReplayCounts {
+    readonly linesTotal: number;
+    readonly linesSkipped: number;
+    readonly proxyClosed: number;
+    readonly decoderPayments: number;
+    readonly chainTransfers: number;
+    readonly results: number;
+}
+export interface ReplayReport {
+    readonly counts: ReplayCounts;
+    readonly results: readonly ReconciliationResult[];
+}
+/**
+ * Replay the whole file, collect every emitted `ReconciliationResult`.
+ *
+ * Returns once the file is exhausted and the engine has been ticked
+ * once past the final virtual timestamp so any still-pending entry
+ * past `watchTimeoutMs` fires `not_settled`.
+ */
+export declare function replayLog(opts: ReplayOptions): Promise<ReplayReport>;
+/** Test seam: serialise a ChainTransfer to its JSONL-stored shape. */
+export declare function chainTransferToJsonl(transfer: ChainTransfer, t?: string): Record<string, unknown>;
+export type { ReconciliationEngine };