@dcasegr/skein 0.0.0-stage → 0.1.2

package/dist/host/arc.js

@@ -0,0 +1,425 @@
+// The host's broadcaster (#58, #65): one Arcade (bsv-blockchain/arcade) per
+// host, the wiring that carries the instances' broadcast events out and
+// their transactions' proofs and statuses in. The instance never sees a URL,
+// a 503 or a retry: a step emits a broadcast event (kernel `emit`, {event:
+// "broadcast", tx, beef?}) and ends waiting on the transaction; the kernel
+// hands the event here once the step is committed (providers.ts, transport
+// `event`).
+//
+// Out — the durable queue (#58's): each transaction is queued in host.db
+// (`broadcast_queue`, by txid: the bytes for Arcade, who broadcast it) and
+// posted to Arcade's POST /tx in Extended Format (the Atomic BEEF's subject
+// with its inputs' sources; the raw transaction when the event carried no
+// BEEF) under the host's one callback token (X-CallbackToken,
+// X-FullStatusUpdates: true, X-CallbackUrl when the host has a public
+// webhook URL). Arcade's answer settles the row: a 2xx (RECEIVED, or a
+// duplicate's current status) or a 4xx (a rejection) is taken as a status
+// (below) and the row goes; a 5xx or no answer (backpressure, Arcade down)
+// keeps it, tried again with backoff (`retry`: 1 s doubling to 5 min) until
+// `giveUpMs` (a day) after it was queued. A restart picks the queue up where
+// it was; a transaction queued again while queued is one row (its
+// broadcasters added).
+//
+// In — one SSE session per host: Arcade's `/events?callbackToken=<the host
+// token>` carries every transaction submitted under the token, resumed with
+// `Last-Event-ID` (the last event id taken, host.db `stream_cursor`, written
+// once the event is routed), reconnecting with backoff (feeds.ts SseStream);
+// Arcade's webhooks, when it has a callback URL, take the same path (POST
+// /arc/callback, the host token as bearer). Each status goes to **every
+// instance whose state holds the transaction** (#58), two ways (#65):
+//
+//   a merkle path (MINED, IMMUTABLE with its BUMP)   a **proof event** in box `chain`, unsigned:
+//       {kind: "proof", subject: <tx CID>, txid, path: bytes (BRC-74), blockHash?, blockHeight?}
+//       — self-validating, recorded by the VM only when the path's root is its header's at that
+//       height; specific wiring (this session), never an open box
+//   anything else (RECEIVED, SEEN_ON_NETWORK, REJECTED, DOUBLE_SPEND_ATTEMPTED, …)
+//       a **status message** from the host's status provider (providers.ts `status`): a signed
+//       message, box `chain/status` (the chain app's, #128), `subject` the transaction's CID, body
+//       {kind: "status", txid, txStatus, blockHash?, blockHeight?, extraInfo?} — admitted by an
+//       instance only if it has a row from that provider ({sender: <its key>, box: "chain/status"}). Optional: an instance
+//       without the subscription learns acceptance from the proof, rejection from a competing
+//       proof or abandonment (docs/WALLET.md).
+//
+// A status already routed (txid + txStatus + blockHash, host.db
+// `status_seen`) is not routed again — but Arcade's answer to a post always
+// reaches the instances that broadcast it (a later broadcaster's news). Who holds a transaction is read, never
+// written: the kernel's `has` of the transaction's CID (bitcoin-tx: its
+// txid), cached per txid — filled by the broadcasts (who sent it) and by a
+// sweep of every enabled instance (hydrated to ask) at a txid's first status
+// since the router started; a later status asks again only the running
+// instances not yet known.
+//
+// Arcade itself may later sign its statuses (a signed-message callback beside
+// webhook and SSE): it would then be the status provider an instance
+// subscribes to, and nothing on the instance's side changes.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { Transaction } from "@bsv/sdk";
+import { DEFAULT_BOX, SseStream, statusOf, txCid } from "./feeds.js";
+/** The webhook's path on the router. */
+export const ARC_ROUTE = "/arc";
+/** The host's Arcade from SKEIN_ARC_URL, SKEIN_ARC_TOKEN, SKEIN_ARC_EVENTS_URL, SKEIN_ARC_CALLBACK_URL (the environment, else $SKEIN_HOME/host.env); none without a URL. */
+export function hostArcConfig(vars, home) {
+    const file = {};
+    const envFile = home ? join(home, "host.env") : undefined;
+    if (envFile && existsSync(envFile)) {
+        for (const line of readFileSync(envFile, "utf8").split("\n")) {
+            const m = /^\s*(?:export\s+)?(SKEIN_ARC_[A-Z_]+)=(.*)$/.exec(line);
+            if (m)
+                file[m[1]] = m[2].trim().replace(/^(["'])(.*)\1$/, "$2");
+        }
+    }
+    const get = (k) => vars[k] || file[k] || undefined;
+    const url = get("SKEIN_ARC_URL");
+    if (!url)
+        return undefined;
+    const token = get("SKEIN_ARC_TOKEN");
+    if (!token)
+        throw new Error("SKEIN_ARC_URL is set but SKEIN_ARC_TOKEN is not: the host's callback token scopes its status stream");
+    const events = get("SKEIN_ARC_EVENTS_URL"), callbackUrl = get("SKEIN_ARC_CALLBACK_URL");
+    return { url: url.replace(/\/+$/, ""), token, ...(events ? { events } : {}), ...(callbackUrl ? { callbackUrl } : {}) };
+}
+const enc = (v) => new TextEncoder().encode(JSON.stringify(v));
+const json = (status, v, headers = {}) => ({ status, headers: { "content-type": "application/json", ...headers }, body: enc(v) });
+/** The transaction a broadcast body carries (Atomic BEEF, BEEF, raw), and the bytes to post to Arcade: Extended Format when its inputs' sources are there. */
+export function arcadeBody(body) {
+    const bytes = [...body];
+    let tx;
+    for (const parse of [() => Transaction.fromAtomicBEEF(bytes), () => Transaction.fromBEEF(bytes)]) {
+        try {
+            tx = parse();
+            break;
+        }
+        catch { /* not this form: the next, then a raw transaction below */ }
+    }
+    if (!tx) {
+        try {
+            return { txid: Transaction.fromBinary(bytes).id("hex"), bytes: body };
+        }
+        catch {
+            return { bytes: body };
+        } // no txid: enqueue says so and posts the raw transaction
+    }
+    // toEF throws when an input's source transaction is not in the BEEF: then the raw transaction, which Arcade takes too.
+    try {
+        return { txid: tx.id("hex"), bytes: Uint8Array.from(tx.toEF()) };
+    }
+    catch {
+        return { txid: tx.id("hex"), bytes: Uint8Array.from(tx.toBinary()) };
+    }
+}
+/** A status with a merkle path as the proof event an instance records (#65), or undefined. */
+export function proofOf(ev) {
+    if (!(ev.merklePath instanceof Uint8Array))
+        return undefined;
+    return {
+        kind: "proof", subject: ev.subject, txid: ev.txid, path: ev.merklePath,
+        ...(typeof ev.blockHash === "string" ? { blockHash: ev.blockHash } : {}), ...(typeof ev.blockHeight === "number" ? { blockHeight: ev.blockHeight } : {}),
+    };
+}
+/** A status without a path as the status provider's message body (#65). */
+export function statusBodyOf(ev) {
+    return {
+        kind: "status", txid: ev.txid, txStatus: ev.txStatus,
+        ...(typeof ev.blockHash === "string" ? { blockHash: ev.blockHash } : {}), ...(typeof ev.blockHeight === "number" ? { blockHeight: ev.blockHeight } : {}),
+        ...(typeof ev.extraInfo === "string" && ev.extraInfo ? { extraInfo: ev.extraInfo } : {}),
+    };
+}
+export class Broadcaster {
+    o;
+    /** txid → the instances known to hold it, and whether every enabled instance was asked. */
+    known = new Map();
+    /** Statuses being routed now (txid + key): a webhook and the stream delivering the same one route it once. */
+    inflight = new Map();
+    stream;
+    timer;
+    pumping;
+    again = false;
+    stopped = false;
+    /** Counts (tests, the log): statuses routed, redeliveries dropped, admissions (proofs and status messages), posts. */
+    stats = { routed: 0, duplicates: 0, admitted: 0, proofs: 0, statuses: 0, posted: 0 };
+    constructor(o) { this.o = o; }
+    say(source, line) { this.o.log?.(source, line); }
+    now() { return (this.o.now ?? Date.now)(); }
+    /** Arcade's SSE service for the host's token. */
+    eventsUrl() { return this.o.arc.events ?? `${this.o.arc.url}/events`; }
+    /** Open the subscription (resuming after the last event id taken), and take up the queue where it was. */
+    start() {
+        this.stopped = false;
+        this.kick();
+        if (this.stream)
+            return;
+        const key = this.eventsUrl();
+        const url = new URL(key);
+        url.searchParams.set("callbackToken", this.o.arc.token);
+        this.stream = new SseStream(url.toString(), async (ev) => {
+            if (ev.event === undefined || ev.event === "status" || ev.event === "message") {
+                let v;
+                try {
+                    v = JSON.parse(ev.data);
+                }
+                catch {
+                    this.say("router", `arcade: an event that is not JSON: ignored: ${ev.data.slice(0, 200)}`);
+                    v = undefined;
+                }
+                if (v !== undefined)
+                    await this.deliver(v, "stream");
+            }
+            if (ev.id !== undefined)
+                this.o.db.setCursor(key, ev.id);
+        }, { lastId: this.o.db.cursor(key), backoff: this.o.backoff, fetch: this.o.fetch, log: (l) => this.say("router", `arcade events ${key}: ${l}`) });
+        this.stream.start();
+    }
+    async stop() {
+        this.stopped = true;
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        await this.pumping;
+        await this.stream?.stop();
+        this.stream = undefined;
+    }
+    /** `handle` holds `txid` (it broadcast it). */
+    note(txid, handle) {
+        const t = txid.toLowerCase();
+        let k = this.known.get(t);
+        if (!k) {
+            this.known.set(t, (k = { handles: new Set(), swept: false }));
+            const max = this.o.maxKnown ?? 100_000;
+            if (this.known.size > max)
+                this.known.delete(this.known.keys().next().value);
+        }
+        k.handles.add(handle);
+    }
+    /** The instances holding `txid`: the cached ones, and those a read finds (every enabled one the first time, then the running ones not known yet). */
+    async holders(txid) {
+        const k = this.known.get(txid) ?? { handles: new Set(), swept: false };
+        this.known.set(txid, k);
+        const { all, running } = this.o.instances();
+        const ask = (k.swept ? running : all).filter((h) => !k.handles.has(h));
+        for (const h of ask) {
+            try {
+                if (await this.o.holds(h, txid))
+                    k.handles.add(h);
+            }
+            catch (e) {
+                this.say(h, `arcade: could not read whether it holds ${txid.slice(0, 8)}: ${e.message}`);
+            }
+        }
+        k.swept = true;
+        return [...k.handles].filter((h) => all.includes(h));
+    }
+    /**
+     * One status from Arcade (the stream's, a webhook's, or its answer to a
+     * post): routed to every instance holding the transaction, once — a proof
+     * as an event, anything else as a status message. `askers` (a post's
+     * broadcasters) get it even when it was routed before: Arcade's answer to
+     * a duplicate is the news for an instance that broadcast it later. The
+     * number of instances it reached.
+     */
+    async deliver(v, via, askers = []) {
+        const ev = statusOf(v);
+        if (typeof ev === "string") {
+            this.say("router", `arcade ${via}: not a status (${ev}): ignored`);
+            return 0;
+        }
+        const txid = ev.txid;
+        const key = `${String(ev.txStatus)} ${String(ev.blockHash ?? "")}`;
+        const proof = proofOf(ev);
+        const send = async (hs) => {
+            let n = 0;
+            for (const h of hs) {
+                try {
+                    if (proof)
+                        await this.o.admit(h, DEFAULT_BOX, proof);
+                    else
+                        await this.o.status(h, statusBodyOf(ev), txCid(txid));
+                    n++;
+                }
+                catch (e) {
+                    this.say(h, `arcade: ${proof ? "proof" : "status"} ${txid.slice(0, 8)} ${String(ev.txStatus)} not delivered: ${e.message}`);
+                }
+            }
+            return n;
+        };
+        const busy = this.inflight.get(`${txid} ${key}`);
+        if (busy)
+            await busy;
+        if (busy || this.o.db.hasStatus(txid, key)) {
+            this.stats.duplicates++;
+            if (!askers.length)
+                return 0;
+            const n = await send(askers);
+            this.say("router", `arcade ${via}: ${txid.slice(0, 8)} ${String(ev.txStatus)} (routed before) → ${askers.join(", ")}, who broadcast it`);
+            return n;
+        }
+        const p = (async () => {
+            const hs = [...new Set([...(await this.holders(txid)), ...askers])];
+            const n = await send(hs);
+            this.o.db.markStatus(txid, key);
+            this.stats.routed++;
+            this.stats.admitted += n;
+            if (proof)
+                this.stats.proofs += n;
+            else
+                this.stats.statuses += n;
+            this.say("router", `arcade ${via}: ${txid.slice(0, 8)} ${String(ev.txStatus)}${proof ? " (a proof event)" : " (a status message)"} → ${hs.length ? hs.join(", ") : "no instance holds it"}`);
+            return n;
+        })();
+        this.inflight.set(`${txid} ${key}`, p);
+        try {
+            return await p;
+        }
+        finally {
+            this.inflight.delete(`${txid} ${key}`);
+        }
+    }
+    // ---------------------------------------------------------------- out: the queue
+    /**
+     * A broadcast event from `handle` (#65): the transaction's bytes and, if
+     * the event carried it, its Atomic BEEF. Queued durably and posted; the
+     * txid, or undefined when the bytes are not a transaction.
+     */
+    enqueue(handle, tx, beef) {
+        let raw;
+        try {
+            raw = Transaction.fromBinary([...tx]).id("hex");
+        }
+        catch {
+            this.say(handle, "broadcast: the event's transaction does not parse: dropped");
+            return undefined;
+        }
+        // The BEEF's subject must be the transaction: else the raw transaction goes (Arcade then needs its parents).
+        const fromBeef = beef ? arcadeBody(beef) : undefined;
+        const bytes = fromBeef?.txid === raw ? fromBeef.bytes : tx;
+        if (beef && fromBeef?.txid !== raw)
+            this.say(handle, `broadcast ${raw.slice(0, 8)}: the event's BEEF is not of its transaction: the raw transaction goes`);
+        this.note(raw, handle);
+        this.o.db.queueBroadcast(raw, bytes, handle, this.now());
+        this.kick();
+        return raw;
+    }
+    /** Post what is due now, then wait for the next. */
+    kick() {
+        if (this.stopped)
+            return;
+        if (this.pumping) {
+            this.again = true;
+            return;
+        }
+        this.pumping = this.pump().catch((e) => this.say("router", `broadcast queue: ${e.message}`)).finally(() => {
+            this.pumping = undefined;
+            if (this.again) {
+                this.again = false;
+                this.kick();
+            }
+        });
+    }
+    async pump() {
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        for (const row of this.o.db.dueBroadcasts(this.now())) {
+            if (this.stopped)
+                return;
+            await this.post(row);
+        }
+        const next = this.o.db.nextBroadcastAt();
+        if (next !== undefined && !this.stopped)
+            this.timer = setTimeout(() => this.kick(), Math.min(2 ** 31 - 1, Math.max(0, next - this.now()) + 1));
+    }
+    async post(row) {
+        for (const h of row.instances)
+            this.note(row.txid, h);
+        const from = row.instances[0] ?? "router";
+        const a = this.o.arc;
+        const r = await this.arcade("POST", "/tx", {
+            headers: {
+                "content-type": "application/octet-stream", "x-callbacktoken": a.token, "x-fullstatusupdates": "true",
+                ...(a.callbackUrl ? { "x-callbackurl": a.callbackUrl } : {}),
+            },
+            body: row.body,
+        });
+        this.stats.posted++;
+        const what = summary(r.body);
+        this.say(from, `broadcast ${row.txid.slice(0, 8)} → Arcade: ${r.status ? `HTTP ${r.status}` : "no answer"}${what ? ` ${what}` : ""}`);
+        if (r.status >= 200 && r.status < 500 && r.status !== 408 && r.status !== 425 && r.status !== 429) {
+            // Taken (or a duplicate's current status) or refused: the row goes, and the answer is a status.
+            this.o.db.unqueueBroadcast(row.txid);
+            let v = {};
+            try {
+                v = JSON.parse(new TextDecoder().decode(r.body));
+            }
+            catch { /* no JSON: the status is the HTTP code's (below), and the line above logged the answer */ }
+            const reason = [v.reason, v.extraInfo, v.detail, v.title].find((x) => typeof x === "string" && x);
+            const status = r.status < 300
+                ? { ...v, txid: row.txid, txStatus: typeof v.txStatus === "string" && v.txStatus ? v.txStatus : "RECEIVED" }
+                : { txid: row.txid, txStatus: typeof v.txStatus === "string" && v.txStatus ? v.txStatus : "REJECTED", ...(reason ? { extraInfo: reason } : {}) };
+            await this.deliver(status, "post", row.instances);
+            return;
+        }
+        // Not taken (backpressure, unreachable): tried again later, until given up.
+        const at = this.now();
+        if (at - row.since >= (this.o.giveUpMs ?? 86_400_000)) {
+            this.o.db.unqueueBroadcast(row.txid);
+            this.say(from, `broadcast ${row.txid.slice(0, 8)}: Arcade did not take it in ${Math.round((at - row.since) / 1000)} s: dropped (the instance abandons it)`);
+            return;
+        }
+        const { min, max } = this.o.retry ?? { min: 1000, max: 300_000 };
+        const wait = Math.min(max, min * 2 ** Math.min(row.attempts, 30));
+        const retryAfter = Number(r.headers["retry-after"]);
+        this.o.db.retryBroadcast(row.txid, at + Math.max(wait, Number.isFinite(retryAfter) ? retryAfter * 1000 : 0), `${r.status || "no answer"} ${what}`.trim());
+    }
+    /** Whether a post (and the routing of its answer) is under way. */
+    busy() { return this.pumping !== undefined; }
+    /** Until the posts under way, and the routing of their answers, are done (tests, the corpus: Router.settled). */
+    async idle() {
+        while (this.pumping)
+            await this.pumping;
+    }
+    /** The queue as it stands (tests, the log). */
+    queued() { return this.o.db.broadcasts().map(({ txid, attempts, next }) => ({ txid, attempts, next })); }
+    async arcade(method, path, init = {}) {
+        try {
+            const r = await (this.o.fetch ?? fetch)(`${this.o.arc.url}${path}`, {
+                method, headers: { accept: "application/json", ...init.headers }, body: init.body,
+                signal: AbortSignal.timeout(this.o.timeoutMs ?? 30_000),
+            });
+            const headers = { "content-type": r.headers.get("content-type") ?? "application/json" };
+            const retry = r.headers.get("retry-after");
+            if (retry)
+                headers["retry-after"] = retry;
+            return { status: r.status, headers, body: new Uint8Array(await r.arrayBuffer()) };
+        }
+        catch (e) {
+            // No answer: not taken, tried again.
+            return json(0, { title: "Arcade unreachable", extraInfo: e.message });
+        }
+    }
+    // ---------------------------------------------------------------- the webhook
+    /** POST /arc/callback: Arcade's webhook, with the host token as bearer; answered once the status is routed (Arcade retries otherwise). */
+    async callback(headers, raw) {
+        if (headers.authorization !== `Bearer ${this.o.arc.token}`)
+            return json(401, { status: "error", code: "ERR_UNAUTHORIZED" });
+        let v;
+        try {
+            v = JSON.parse(new TextDecoder().decode(raw));
+        }
+        catch {
+            return json(400, { status: "error", code: "ERR_BAD_BODY", description: "not JSON" });
+        }
+        const ev = statusOf(v);
+        if (typeof ev === "string")
+            return json(400, { status: "error", code: "ERR_BAD_CALLBACK", description: ev });
+        await this.deliver(v, "webhook");
+        return json(200, { status: "success" });
+    }
+}
+/** An Arcade answer in a few words for the log: its txStatus, else its reason / title. */
+function summary(body) {
+    try {
+        const j = JSON.parse(new TextDecoder().decode(body.subarray(0, 4000)));
+        return String(j.txStatus ?? j.reason ?? j.title ?? j.extraInfo ?? "");
+    }
+    catch {
+        return "";
+    } // not JSON: the log line keeps the HTTP status alone
+}

package/dist/host/billing.d.ts

@@ -0,0 +1,102 @@
+import type { CID } from "multiformats/cid";
+import type { DispatchRow } from "../runtime/dispatch.ts";
+/** The kernel's head (billing.zig HEAD). */
+export declare const BILLING_HEAD = "billing";
+/** The host row's kernel operation. */
+export declare const TICK_OP = "tick";
+/** The host row's box by convention (the row's address is what a tick goes to). */
+export declare const BILLING_BOX = "billing";
+export declare const NSAT = 1000000000n;
+export declare const RATE_NAMES: readonly ["fuel", "storage", "served", "fetch", "authfetch", "publish"];
+export type RateName = typeof RATE_NAMES[number];
+/**
+ * The rates, whole sats: fuel per 10^9 fuel; storage per 10^6 bytes held a day; served per 10^6
+ * bytes served; fetch, authfetch and publish per event (billing.zig).
+ */
+export type Rates = Record<RateName, number>;
+/** What this host supports. */
+export interface BillingConfig {
+    /** The block a skein prepays at a time (sats). */
+    x: number;
+    rates: Rates;
+    /** The free allowance per skein (sats): its allocation before any payment. */
+    allowance: number;
+    /** How often it ticks a billed skein (ms). */
+    tickMs: number;
+    /** How long after a skein went asleep it may be reclaimed (ms). */
+    graceMs: number;
+}
+/** Small dev defaults (#130 decided, "Numbers": configuration; real numbers later). */
+export declare const DEV_BILLING: BillingConfig;
+/**
+ * The host's billing from its environment: SKEIN_BILLING=off for none; else DEV_BILLING with
+ * SKEIN_BILLING_X, SKEIN_BILLING_RATES (JSON {fuel, storage, served, fetch, authfetch, publish}),
+ * SKEIN_BILLING_ALLOWANCE, SKEIN_BILLING_TICK_MS, SKEIN_BILLING_GRACE_MS over it.
+ */
+export declare function billingConfig(v: Record<string, string | undefined>): BillingConfig | undefined;
+/** The host row's terms: the host's key (hex), X, the rates, the box ticks go to. */
+export interface Terms {
+    host: string;
+    x: number;
+    rates: Rates;
+    address: string;
+}
+/** The host row (billing.zig termsOf): the first kernel route whose fn is `tick`, in table order; #143: the host's key its `host` setting. */
+export declare function termsOf(rows: DispatchRow[]): Terms | undefined;
+/** Why the terms are not what this host (key `host`) supports (undefined: they are): another key, X or a rate below its own. */
+export declare function mismatch(cfg: BillingConfig, host: string, t: Terms): string | undefined;
+/** The kernel's billing state (the head `billing`'s record), as the host reads it. */
+export interface BillingState {
+    host: string;
+    allowance: bigint;
+    paid: bigint;
+    tally: bigint;
+    lastTick: number;
+    ticks: number;
+    bytes: number;
+    payments: number;
+    asleep: boolean;
+}
+export declare function stateOf(rec: unknown): BillingState | undefined;
+/** What the instance may consume (nanosats). */
+export declare const allocation: (s: BillingState) => bigint;
+/** The host's amounts at the rates (nanosats): billing.zig priceHost. */
+export declare const priceHost: (r: Rates, fuel: number, served: number) => bigint;
+/** One line of the host's log for a period: a read call, or a response served. */
+export interface LogLine {
+    at: number;
+    op: string;
+    caller?: string;
+    fuel: number;
+    bytes: number;
+}
+/** What the host has metered for an instance since its last tick. */
+export declare class Period {
+    since: number;
+    fuel: number;
+    served: number;
+    lines: LogLine[];
+    constructor(since: number);
+    add(l: LogLine): void;
+    get empty(): boolean;
+}
+/**
+ * The period's record — {kind: "host-log", instance: <its identity>, from, to, lines: [{at, op,
+ * caller?, fuel, bytes}]} — and its CID, which the tick commits to (`log`): the host keeps the
+ * record (host.db billing_ticks), so it can show what it charged.
+ */
+export declare function periodRecord(identity: string, p: Period, to: number): {
+    record: Record<string, unknown>;
+    bytes: Uint8Array;
+    cid: CID;
+};
+/** A tick's body (billing.zig tickOf). */
+export declare function tickBody(at: number, cfg: BillingConfig, p: Period, log: CID): Record<string, unknown>;
+/** What the host knows of a billed instance after it last read it. */
+export interface BillingView {
+    terms?: Terms;
+    state?: BillingState;
+    mismatch?: string;
+}
+/** Why the host forwards nothing to the instance (undefined: it forwards as usual). */
+export declare function closedBy(v: BillingView | undefined): string | undefined;