@absol-labs/agent 0.9.0 → 0.10.0

package/dist/cli/run.js

@@ -0,0 +1,173 @@
+import { assertKnownFlags, booleanFlag, parseArgs } from "./args.js";
+import { CONFIG_FLAGS, GLOBAL_FLAGS, TESTNET_CHAIN_IDS, resolveConfig, } from "./config.js";
+import { CliError, describeError, usageError } from "./errors.js";
+import { createPrinter } from "./output.js";
+import { startHeartbeat } from "./progress.js";
+import { defaultCliDependencies } from "./deps.js";
+import { packageVersion } from "./version.js";
+import { CDP_ENV_VARS, PRIVATE_KEY_ENV } from "./wallet.js";
+import { claimCommand } from "./commands/claim.js";
+import { closeCommand } from "./commands/close.js";
+import { discoverCommand } from "./commands/discover.js";
+import { invokeCommand } from "./commands/invoke.js";
+import { mcpCommand } from "./commands/mcp.js";
+import { openCommand } from "./commands/open.js";
+import { reclaimCommand } from "./commands/reclaim.js";
+import { reclaimUnverifiedCommand } from "./commands/reclaim-unverified.js";
+import { statusCommand } from "./commands/status.js";
+import { streamsCommand } from "./commands/streams.js";
+import { watchCommand } from "./commands/watch.js";
+/**
+ * The command surface, in the order the product loop runs:
+ * discover -> open -> invoke -> watch/status -> close -> reclaim, then the
+ * operator's own redemption (`claim`) and the buyer's last-resort exit
+ * (`reclaim-unverified`). `streams` (which of them are mine?) sits inside that
+ * loop; `mcp` (run the same loop from an MCP host) sits after it.
+ */
+export const COMMANDS = [
+    discoverCommand,
+    openCommand,
+    statusCommand,
+    streamsCommand,
+    watchCommand,
+    invokeCommand,
+    closeCommand,
+    reclaimCommand,
+    reclaimUnverifiedCommand,
+    claimCommand,
+    mcpCommand,
+];
+/**
+ * Runs one CLI invocation and returns the process exit code. Pure in its
+ * inputs: argv, env, output sinks and side-effecting dependencies are all
+ * injected, so the whole surface is testable without a key or an RPC.
+ */
+export async function runCli(options) {
+    const env = options.env ?? process.env;
+    const streams = options.streams ?? {
+        stdout: (line) => process.stdout.write(`${line}\n`),
+        stderr: (line) => process.stderr.write(`${line}\n`),
+    };
+    const deps = options.deps ?? defaultCliDependencies;
+    let json = false;
+    try {
+        const args = parseArgs(options.argv);
+        json = booleanFlag(args, "json");
+        const out = createPrinter(streams, json);
+        // `--version` is checked before the bare-invocation help branch: `metrik
+        // --version` parses to no command at all.
+        if (args.command === "version" || booleanFlag(args, "version")) {
+            streams.stdout(packageVersion());
+            return 0;
+        }
+        if (args.command === null || args.command === "help") {
+            // A misspelled TOP-LEVEL flag must fail like a misspelled per-command one
+            // does. Printing help and exiting 0 tells a script the invocation
+            // succeeded, which is how a typo goes unnoticed.
+            assertKnownFlags(args, [...GLOBAL_FLAGS, "version"]);
+            streams.stdout(renderHelp(args.positionals[0]));
+            return 0;
+        }
+        const command = COMMANDS.find((spec) => spec.name === args.command);
+        if (command === undefined) {
+            throw usageError(`unknown command: ${args.command}`, `commands: ${COMMANDS.map((spec) => spec.name).join(", ")}`);
+        }
+        if (booleanFlag(args, "help")) {
+            streams.stdout(renderHelp(command.name));
+            return 0;
+        }
+        assertKnownFlags(args, [
+            ...GLOBAL_FLAGS,
+            ...CONFIG_FLAGS,
+            ...command.flags,
+        ]);
+        const config = resolveConfig(args, env);
+        // Every command gets the heartbeat, in one place rather than per command:
+        // any of them can be the one waiting on a slow endpoint, and a rule with an
+        // exception is a rule someone forgets to apply to the next command.
+        const heartbeat = startHeartbeat(out.note, `metrik ${command.name}`);
+        try {
+            await command.run({ args, config, env, out, deps });
+        }
+        finally {
+            heartbeat.stop();
+        }
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            emitFailure(streams, json, error.message, error.hint, error.exitCode);
+            return error.exitCode;
+        }
+        emitFailure(streams, json, describeError(error), undefined, 4);
+        return 4;
+    }
+}
+function emitFailure(streams, json, message, hint, exitCode) {
+    if (json) {
+        // The failure goes to stderr even in --json mode so stdout stays either a
+        // result document or nothing at all.
+        streams.stderr(JSON.stringify({ error: message, hint: hint ?? null, exitCode }));
+        return;
+    }
+    streams.stderr(`error: ${message}`);
+    if (hint !== undefined)
+        streams.stderr(`  ${hint}`);
+}
+export function renderHelp(commandName) {
+    const command = COMMANDS.find((spec) => spec.name === commandName);
+    if (command !== undefined) {
+        return [
+            `metrik ${command.name} — ${command.summary}`,
+            "",
+            `Usage: ${command.usage}`,
+            "",
+            command.flags.length === 0
+                ? "Command flags: (none)"
+                : `Command flags: ${command.flags.map((flag) => `--${flag}`).join(" ")}`,
+            `Settlement flags: ${CONFIG_FLAGS.map((flag) => `--${flag}`).join(" ")}`,
+            "Output flags: --json",
+            ...(command.signs
+                ? [
+                    "",
+                    `Broadcasts a transaction. Requires a wallet in the environment: ${PRIVATE_KEY_ENV}, or ${CDP_ENV_VARS.join(" + ")}.`,
+                ]
+                : command.requiresKey === true
+                    ? [
+                        "",
+                        `Broadcasts nothing, but signs an off-chain EIP-712 capability, so it requires a wallet in the environment: ${PRIVATE_KEY_ENV}, or ${CDP_ENV_VARS.join(" + ")}.`,
+                    ]
+                    : []),
+        ].join("\n");
+    }
+    const width = COMMANDS.reduce((max, spec) => Math.max(max, spec.name.length), 0);
+    return [
+        `metrik ${packageVersion()} — pay for verified delivery, metered by the second`,
+        "",
+        "You rent a verified-live endpoint BY TIME, not per call: the oracle probes it and the",
+        "meter runs on availability that verified. One request and a thousand cost the same",
+        "second, and the clock keeps running while you send none. `metrik close` stops it.",
+        "",
+        "Usage: metrik <command> [options]",
+        "",
+        "Commands:",
+        ...COMMANDS.map((spec) => `  ${spec.name.padEnd(width)}  ${spec.summary}${spec.signs ? "  [broadcasts a tx]" : spec.requiresKey === true ? "  [needs a key]" : ""}`),
+        "",
+        "Global flags:",
+        "  --json          machine-readable output on stdout",
+        "  --help          this text, or `metrik <command> --help`",
+        "",
+        "Settlement flags (all default to Metrik's Base Sepolia deployment):",
+        "  --chain-id  --rpc-url  --escrow  --usdc  --oracle-url  --registry-url",
+        "",
+        "Wallet (read from the environment only; never accepted as a flag):",
+        `  ${PRIVATE_KEY_ENV}  a Base Sepolia test key. Checked first.`,
+        `  ${CDP_ENV_VARS.join(", ")}`,
+        "    a Coinbase CDP Server Wallet v2 account. Used when no private key is set.",
+        "  A credential on the command line lands in shell history; these never are.",
+        "",
+        `TESTNET ONLY: this CLI refuses any chain outside ${TESTNET_CHAIN_IDS.join(", ")} (Base Sepolia),`,
+        "and re-checks the chain id the RPC actually serves before signing. There is no override.",
+    ].join("\n");
+}
+//# sourceMappingURL=run.js.map

package/dist/cli/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../../src/cli/run.ts"],"names":[],"mappings":"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"}

package/dist/cli/scan-range.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Pure block-range arithmetic for the escrow log scan behind `metrik streams`.
+ * No RPC, no clock, no env — so the coverage rules below are unit-testable
+ * without a network, which is the point: they decide when an empty result is
+ * allowed to be rendered as "you have no streams".
+ *
+ * ## Why the anchor is the deploy block
+ *
+ * A fixed lookback ("the last N blocks") cannot describe coverage: a wallet
+ * whose stream predates the window is shown an empty list with nothing to
+ * distinguish it from a wallet that never opened one. For a payments tool,
+ * telling someone their escrowed funds do not exist is the worst failure we
+ * have. The escrow has NO history before its deploy block, so that block is the
+ * honest anchor — and whether the budget reached it is then a fact the command
+ * can state.
+ *
+ * ## Why the window is 10 000 blocks
+ *
+ * `buyer` and `operator` are INDEXED on `StreamOpened`, so a per-wallet scan is
+ * a server-side topic filter whose response is tiny regardless of range. What
+ * public RPCs cap is the per-call BLOCK RANGE, and a topic filter does not lift
+ * it: `sepolia.base.org` answers a wider range with `-32614 "eth_getLogs is
+ * limited to a 10,000 range"`. So the page size is the cap, not a guess below
+ * it.
+ */
+/**
+ * getLogs page size. The window is `chunk + 1` blocks (bounds inclusive), so
+ * 9 999 is the largest page `sepolia.base.org` accepts.
+ */
+export declare const LOG_SCAN_CHUNK = 9999n;
+/**
+ * Window budget for one scan. 400 x 10 000 = 4 000 000 blocks, comfortably more
+ * than the live escrow's history (~1.06M blocks on 2026-09-17), so the default
+ * scan is complete rather than merely large. It is a CEILING, not a fixed cost:
+ * windows are built for the actual anchor-to-head span. Exceeding it is not an
+ * error — it is reported as `degraded`.
+ */
+export declare const LOG_SCAN_MAX_WINDOWS = 400;
+export interface ScanRange {
+    readonly fromBlock: bigint;
+    readonly toBlock: bigint;
+    /** Inclusive `[from, to]` windows, in ascending order. */
+    readonly windows: readonly (readonly [bigint, bigint])[];
+    /** True iff the budget could NOT reach `anchor`, i.e. the scan is partial. */
+    readonly degraded: boolean;
+}
+/**
+ * Page `[anchor, head]` into non-overlapping inclusive windows.
+ *
+ * An RPC that is behind the deployment yields an empty-but-valid range rather
+ * than a negative one, and an anchor past the head is clamped: a node still
+ * syncing must not produce a nonsense scan.
+ */
+export declare function escrowScanRange(head: bigint, anchorBlock: bigint, chunk?: bigint, maxWindows?: number): ScanRange;
+//# sourceMappingURL=scan-range.d.ts.map

package/dist/cli/scan-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-range.d.ts","sourceRoot":"","sources":["../../src/cli/scan-range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAS,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;IACzD,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,MAAuB,EAC9B,UAAU,GAAE,MAA6B,GACxC,SAAS,CAaX"}

package/dist/cli/scan-range.js

@@ -0,0 +1,57 @@
+/**
+ * Pure block-range arithmetic for the escrow log scan behind `metrik streams`.
+ * No RPC, no clock, no env — so the coverage rules below are unit-testable
+ * without a network, which is the point: they decide when an empty result is
+ * allowed to be rendered as "you have no streams".
+ *
+ * ## Why the anchor is the deploy block
+ *
+ * A fixed lookback ("the last N blocks") cannot describe coverage: a wallet
+ * whose stream predates the window is shown an empty list with nothing to
+ * distinguish it from a wallet that never opened one. For a payments tool,
+ * telling someone their escrowed funds do not exist is the worst failure we
+ * have. The escrow has NO history before its deploy block, so that block is the
+ * honest anchor — and whether the budget reached it is then a fact the command
+ * can state.
+ *
+ * ## Why the window is 10 000 blocks
+ *
+ * `buyer` and `operator` are INDEXED on `StreamOpened`, so a per-wallet scan is
+ * a server-side topic filter whose response is tiny regardless of range. What
+ * public RPCs cap is the per-call BLOCK RANGE, and a topic filter does not lift
+ * it: `sepolia.base.org` answers a wider range with `-32614 "eth_getLogs is
+ * limited to a 10,000 range"`. So the page size is the cap, not a guess below
+ * it.
+ */
+/**
+ * getLogs page size. The window is `chunk + 1` blocks (bounds inclusive), so
+ * 9 999 is the largest page `sepolia.base.org` accepts.
+ */
+export const LOG_SCAN_CHUNK = 9999n;
+/**
+ * Window budget for one scan. 400 x 10 000 = 4 000 000 blocks, comfortably more
+ * than the live escrow's history (~1.06M blocks on 2026-09-17), so the default
+ * scan is complete rather than merely large. It is a CEILING, not a fixed cost:
+ * windows are built for the actual anchor-to-head span. Exceeding it is not an
+ * error — it is reported as `degraded`.
+ */
+export const LOG_SCAN_MAX_WINDOWS = 400;
+/**
+ * Page `[anchor, head]` into non-overlapping inclusive windows.
+ *
+ * An RPC that is behind the deployment yields an empty-but-valid range rather
+ * than a negative one, and an anchor past the head is clamped: a node still
+ * syncing must not produce a nonsense scan.
+ */
+export function escrowScanRange(head, anchorBlock, chunk = LOG_SCAN_CHUNK, maxWindows = LOG_SCAN_MAX_WINDOWS) {
+    const anchor = anchorBlock < 0n ? 0n : anchorBlock > head ? head : anchorBlock;
+    const maxSpan = (chunk + 1n) * BigInt(maxWindows);
+    const degraded = head - anchor > maxSpan;
+    const fromBlock = degraded ? head - maxSpan : anchor;
+    const windows = [];
+    for (let start = fromBlock; start <= head; start += chunk + 1n) {
+        windows.push([start, start + chunk > head ? head : start + chunk]);
+    }
+    return { fromBlock, toBlock: head, windows, degraded };
+}
+//# sourceMappingURL=scan-range.js.map

package/dist/cli/scan-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-range.js","sourceRoot":"","sources":["../../src/cli/scan-range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,KAAM,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAC;AAWxC;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,IAAY,EACZ,WAAmB,EACnB,QAAgB,cAAc,EAC9B,aAAqB,oBAAoB;IAEzC,MAAM,MAAM,GACV,WAAW,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC;IAClE,MAAM,OAAO,GAAG,CAAC,KAAK,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAClD,MAAM,QAAQ,GAAG,IAAI,GAAG,MAAM,GAAG,OAAO,CAAC;IACzC,MAAM,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;IAErD,MAAM,OAAO,GAAkC,EAAE,CAAC;IAClD,KAAK,IAAI,KAAK,GAAG,SAAS,EAAE,KAAK,IAAI,IAAI,EAAE,KAAK,IAAI,KAAK,GAAG,EAAE,EAAE,CAAC;QAC/D,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;IACrE,CAAC;IAED,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;AACzD,CAAC"}

package/dist/cli/status.d.ts

@@ -0,0 +1,90 @@
+import type { CheckpointProof, StreamV2 } from "@absol-labs/sdk";
+import { type AttesterSet } from "./attesters.js";
+import { type EscapeHatchWindow } from "./escape-hatch.js";
+import type { CliReadClient } from "./deps.js";
+/**
+ * Whether the accrual figures on this screen are FINAL.
+ *
+ * `reclaimableFor` is answered against a checkpoint's cumulative, and the
+ * escrow's own `reclaimWithProof` refuses until a checkpoint's `checkedAt`
+ * reaches the stream's stop time (`SettlementWindowOpen`). Between closing a
+ * stream and the first checkpoint that covers the close, the latest checkpoint
+ * therefore describes a SHORTER stream than the one that exists — so the
+ * reclaimable figure computed from it is larger than the amount that can
+ * actually be reclaimed, and shrinks when the covering checkpoint lands.
+ *
+ * A live acceptance run read `reclaimable: 1400` immediately after `close`, `0`
+ * two minutes later, and got `NothingToReclaim()` from the reclaim in between.
+ * Nobody reads "buyer reclaimable 0.0014 USDC" as "a provisional figure that
+ * may fall to zero" — they read it as money they have. So while this is
+ * pending, the CLI prints no settled-looking number at all.
+ */
+export interface SettlementCoverage {
+    /**
+     * The instant accrual stops: `closedAt`, or `expiresAt` once it has passed.
+     * `null` while the stream is still running, where there is nothing to cover.
+     */
+    readonly stopAt: number | null;
+    /** How far the oracle has published. `null` when it could not be read. */
+    readonly coveredUpTo: number | null;
+    /** True when a stop time exists and no known checkpoint reaches it. */
+    readonly pending: boolean;
+}
+/**
+ * Coverage from the three facts that decide it. Pure, so the rule is testable
+ * without an RPC.
+ *
+ * Unknown coverage counts as PENDING, not as covered: the buyer-favouring error
+ * is to withhold a number we cannot stand behind, never to print one we cannot.
+ */
+export declare function settlementCoverage(stream: Pick<StreamV2, "closedAt" | "expiresAt">, latestCheckpointCheckedAt: number | null, nowSeconds: number): SettlementCoverage;
+/**
+ * A stream as the CLI reports it.
+ *
+ * The accrual figures come from the ORACLE's checkpoint proof, not from the
+ * stream tuple. `StreamEscrowV2.getStream` reports `claimedCumulative = 0` and
+ * `settledCumulative = 0` for a stream's whole active life — `settledCumulative`
+ * is written by `reclaim` — so a status built from stream fields would print
+ * "earned: 0" for a stream that had been delivering for an hour.
+ */
+export interface StreamReport {
+    readonly streamId: `0x${string}`;
+    readonly stream: StreamV2;
+    /** `null` until the oracle has published a checkpoint covering this stream. */
+    readonly proof: CheckpointProof | null;
+    /** Why there is no proof yet, when applicable. */
+    readonly proofUnavailable: string | null;
+    readonly claimable: bigint | null;
+    readonly reclaimable: bigint | null;
+    readonly protocolFeeBps: number | null;
+    /**
+     * When the buyer's no-proof escape hatch opens, and whether it already has.
+     * `null` only when the escrow would not answer.
+     *
+     * Without this a buyer had no command that could tell them "the proof path is
+     * blocked, but the no-proof path opens at T+grace" — the two facts they need
+     * together when the oracle has stopped answering.
+     */
+    readonly escapeHatch: EscapeHatchWindow | null;
+    /**
+     * How far the oracle has published (`latestCheckpointCheckedAt`). A stale
+     * value beside a blocked reclaim IS the explanation for the blocked reclaim.
+     */
+    readonly latestCheckpointCheckedAt: number | null;
+    readonly nowSeconds: number;
+    /** `local` when the chain's clock could not be read and the caller's was used. */
+    readonly clockSource: "chain" | "local";
+    /** Whether `claimable` / `reclaimable` are final. See {@link SettlementCoverage}. */
+    readonly settlement: SettlementCoverage;
+    /**
+     * The escrow's oracle signer set, and therefore whether this stream's
+     * operator is also one of the parties attesting to its own delivery.
+     * `signers: null` means the set could not be read — which is UNKNOWN, not
+     * "no overlap".
+     */
+    readonly attesters: AttesterSet;
+}
+export declare function readStreamReport(read: CliReadClient, streamId: `0x${string}`, nowSeconds: number): Promise<StreamReport>;
+export declare function streamReportJson(report: StreamReport): unknown;
+export declare function streamReportRows(report: StreamReport): (readonly [string, string])[];
+//# sourceMappingURL=status.d.ts.map

package/dist/cli/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/cli/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAGjE,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAKL,KAAK,iBAAiB,EACvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,CAAC,EAChD,yBAAyB,EAAE,MAAM,GAAG,IAAI,EACxC,UAAU,EAAE,MAAM,GACjB,kBAAkB,CAgBpB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IACvC,kDAAkD;IAClD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC/C;;;OAGG;IACH,QAAQ,CAAC,yBAAyB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,kFAAkF;IAClF,QAAQ,CAAC,WAAW,EAAE,OAAO,GAAG,OAAO,CAAC;IACxC,qFAAqF;IACrF,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;CACjC;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,aAAa,EACnB,QAAQ,EAAE,KAAK,MAAM,EAAE,EACvB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,YAAY,CAAC,CAwEvB;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAgE9D;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,YAAY,GACnB,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAuF/B"}

package/dist/cli/status.js

@@ -0,0 +1,252 @@
+import { formatDuration, formatUsdc } from "./amounts.js";
+import { operatorAttestsOwnDelivery, readAttesterSet, } from "./attesters.js";
+import { describeError } from "./errors.js";
+import { describeEscapeHatch, escapeHatchWindow, formatTimestamp, readChainNow, } from "./escape-hatch.js";
+/**
+ * Coverage from the three facts that decide it. Pure, so the rule is testable
+ * without an RPC.
+ *
+ * Unknown coverage counts as PENDING, not as covered: the buyer-favouring error
+ * is to withhold a number we cannot stand behind, never to print one we cannot.
+ */
+export function settlementCoverage(stream, latestCheckpointCheckedAt, nowSeconds) {
+    const stopAt = stream.closedAt > 0
+        ? stream.closedAt
+        : nowSeconds >= stream.expiresAt
+            ? stream.expiresAt
+            : null;
+    const coveredUpTo = latestCheckpointCheckedAt !== null && latestCheckpointCheckedAt > 0
+        ? latestCheckpointCheckedAt
+        : null;
+    return {
+        stopAt,
+        coveredUpTo,
+        pending: stopAt !== null && (coveredUpTo === null || coveredUpTo < stopAt),
+    };
+}
+export async function readStreamReport(read, streamId, nowSeconds) {
+    const stream = await read.getStreamV2(streamId);
+    // Timing is answered against the chain, because every deadline on this screen
+    // — expiry, and the escape hatch in particular — is compared against
+    // `block.timestamp` by the escrow, not against this machine's clock.
+    const now = await readChainNow(read, nowSeconds);
+    let proof = null;
+    let proofUnavailable = null;
+    try {
+        proof = await read.checkpointProof(streamId);
+    }
+    catch (error) {
+        proofUnavailable = describeError(error);
+    }
+    let claimable = null;
+    let reclaimable = null;
+    if (proof !== null) {
+        [claimable, reclaimable] = await Promise.all([
+            read.claimableForV2(streamId, proof.cumulativeAmount),
+            read.reclaimableForV2(streamId, proof.cumulativeAmount),
+        ]);
+    }
+    let protocolFeeBps = null;
+    try {
+        protocolFeeBps = await read.protocolFeeBps();
+    }
+    catch {
+        protocolFeeBps = null;
+    }
+    let escapeHatch = null;
+    try {
+        escapeHatch = escapeHatchWindow(stream, await read.escapeGraceSeconds(), now.seconds);
+    }
+    catch {
+        escapeHatch = null;
+    }
+    let latestCheckpointCheckedAt = null;
+    try {
+        latestCheckpointCheckedAt = await read.latestCheckpointCheckedAt();
+    }
+    catch {
+        latestCheckpointCheckedAt = null;
+    }
+    const settlement = settlementCoverage(stream, latestCheckpointCheckedAt, now.seconds);
+    const attesters = await readAttesterSet(read);
+    return {
+        streamId,
+        stream,
+        proof,
+        proofUnavailable,
+        claimable,
+        reclaimable,
+        protocolFeeBps,
+        escapeHatch,
+        latestCheckpointCheckedAt,
+        nowSeconds: now.seconds,
+        clockSource: now.source,
+        settlement,
+        attesters,
+    };
+}
+export function streamReportJson(report) {
+    const { stream, proof } = report;
+    return {
+        streamId: report.streamId,
+        // StreamEscrowV2 has exactly two states. There is no "paused".
+        status: stream.status,
+        reclaimed: stream.reclaimed,
+        buyer: stream.buyer,
+        operator: stream.operator,
+        serviceRef: stream.serviceRef,
+        deposit: stream.deposit,
+        ratePerSecond: stream.ratePerSecond,
+        claimedCumulative: stream.claimedCumulative,
+        settledCumulative: stream.settledCumulative,
+        feesPaid: stream.feesPaid,
+        openedAt: stream.openedAt,
+        expiresAt: stream.expiresAt,
+        closedAt: stream.closedAt,
+        protocolFeeBps: report.protocolFeeBps,
+        verifiedAccrual: proof === null
+            ? null
+            : {
+                cumulativeAmount: proof.cumulativeAmount,
+                checkpointId: proof.checkpointId,
+                checkedAt: proof.checkedAt,
+                root: proof.root,
+            },
+        verifiedAccrualUnavailable: report.proofUnavailable,
+        // `null` while settlement is pending. A consumer that reads this field gets
+        // either an amount that can actually be obtained or nothing — never a
+        // settled-looking number derived from a checkpoint that predates the
+        // stream's stop time. The superseded figure is still available, explicitly
+        // labelled, under `settlement.provisionalReclaimable`.
+        claimable: report.claimable,
+        reclaimable: report.settlement.pending ? null : report.reclaimable,
+        settlement: {
+            pending: report.settlement.pending,
+            stopAt: report.settlement.stopAt,
+            coveredUpTo: report.settlement.coveredUpTo,
+            provisionalReclaimable: report.settlement.pending
+                ? report.reclaimable
+                : null,
+            provisionalClaimable: report.settlement.pending ? report.claimable : null,
+        },
+        // Who attests. `operatorIsOracleSigner: null` means the signer set could
+        // not be read — UNKNOWN, never "no overlap".
+        oracleSigners: report.attesters.signers,
+        oracleSignersUnavailable: report.attesters.unavailable,
+        operatorIsOracleSigner: operatorAttestsOwnDelivery(report.attesters, stream.operator),
+        latestCheckpointCheckedAt: report.latestCheckpointCheckedAt,
+        escapeHatch: report.escapeHatch === null
+            ? null
+            : {
+                escapeGraceSeconds: report.escapeHatch.graceSeconds,
+                readyAt: report.escapeHatch.readyAt,
+                ready: report.escapeHatch.ready,
+                secondsUntilReady: report.escapeHatch.secondsRemaining,
+            },
+    };
+}
+export function streamReportRows(report) {
+    const { stream, proof } = report;
+    const rows = [
+        [
+            "status",
+            stream.reclaimed ? `${stream.status} (reclaimed)` : stream.status,
+        ],
+        ["buyer", stream.buyer],
+        ["operator", stream.operator],
+        ["serviceRef", stream.serviceRef],
+        ["deposit", formatUsdc(stream.deposit)],
+        ["rate", `${formatUsdc(stream.ratePerSecond)} / second`],
+        ["opened", formatTimestamp(stream.openedAt)],
+        ["expires", describeDeadline(stream.expiresAt, report.nowSeconds)],
+    ];
+    if (stream.closedAt > 0) {
+        rows.push(["closed", formatTimestamp(stream.closedAt)]);
+    }
+    rows.push([
+        "verified accrual",
+        proof === null
+            ? `not checkpointed yet (${report.proofUnavailable ?? "no proof"})`
+            : `${formatUsdc(proof.cumulativeAmount)} @ checkpoint ${proof.checkpointId} (${formatTimestamp(Number(proof.checkedAt))})`,
+    ]);
+    // `claim` accepts ANY retained root, so the operator's balance is obtainable
+    // now — it is merely not FINAL until the covering checkpoint lands, and it
+    // can only grow. `reclaim` requires the LATEST root to reach the stop time,
+    // so the buyer's figure is not obtainable at all while that is pending: it is
+    // withheld rather than printed as money the buyer does not have.
+    rows.push([
+        "operator claimable",
+        report.claimable === null
+            ? "-"
+            : report.settlement.pending
+                ? `${formatUsdc(report.claimable)} so far — not final until the checkpoint covering the stop time lands`
+                : formatUsdc(report.claimable),
+    ]);
+    rows.push([
+        "buyer reclaimable",
+        report.settlement.pending
+            ? describePendingSettlement(report.settlement)
+            : report.reclaimable === null
+                ? "-"
+                : formatUsdc(report.reclaimable),
+    ]);
+    rows.push(["fees paid", formatUsdc(stream.feesPaid)]);
+    rows.push([
+        "oracle checkpoint",
+        report.latestCheckpointCheckedAt === null
+            ? "-"
+            : report.latestCheckpointCheckedAt <= 0
+                ? "none posted yet"
+                : `latest covers up to ${formatTimestamp(report.latestCheckpointCheckedAt)}`,
+    ]);
+    // The no-proof path. Printed for every stream, not only blocked ones: a buyer
+    // should learn that this exists before they need it.
+    rows.push([
+        "escape hatch",
+        report.escapeHatch === null
+            ? "-"
+            : `${describeEscapeHatch(report.escapeHatch)} — no-proof reclaim, forfeits the operator's unclaimed earnings`,
+    ]);
+    // The same row, read from the seller's side. `reclaimUnverified` pays the
+    // buyer the WHOLE remaining deposit with no proof, so an operator who has
+    // earned but not claimed loses it the moment that window opens. The window is
+    // `expiresAt + escapeGraceSeconds` and the grace is immutable on the live
+    // escrow, so the only thing an operator can do about it is claim in time —
+    // which they cannot do if nothing tells them the deadline exists.
+    if (report.escapeHatch !== null &&
+        report.claimable !== null &&
+        report.claimable > 0n) {
+        rows.push([
+            "operator deadline",
+            report.escapeHatch.ready
+                ? `${formatUsdc(report.claimable)} is unclaimed and the buyer's no-proof reclaim is ALREADY open — it would take this amount from the operator`
+                : `${formatUsdc(report.claimable)} is unclaimed; \`metrik claim\` it before ${formatTimestamp(report.escapeHatch.readyAt)}, after which a buyer's no-proof reclaim can take it`,
+        ]);
+    }
+    if (report.protocolFeeBps !== null) {
+        rows.push([
+            "protocol fee",
+            `${report.protocolFeeBps} bps (read from the escrow)`,
+        ]);
+    }
+    return rows;
+}
+/**
+ * What is being waited for, in the place a number used to be. Names the two
+ * timestamps whose ordering decides it, so the reader can see the wait end.
+ */
+function describePendingSettlement(settlement) {
+    const stopAt = settlement.stopAt === null ? "unknown" : formatTimestamp(settlement.stopAt);
+    const covered = settlement.coveredUpTo === null
+        ? "unknown (the escrow would not answer)"
+        : formatTimestamp(settlement.coveredUpTo);
+    return `pending final checkpoint — the stream stopped at ${stopAt}, the oracle has published only to ${covered}. Reclaim reverts until a checkpoint reaches the stop time (~15-22s apart).`;
+}
+function describeDeadline(expiresAt, nowSeconds) {
+    const remaining = expiresAt - nowSeconds;
+    const suffix = remaining > 0
+        ? `in ${formatDuration(remaining)}`
+        : `${formatDuration(-remaining)} ago`;
+    return `${formatTimestamp(expiresAt)} — ${suffix}`;
+}
+//# sourceMappingURL=status.js.map