twzrd-log-verifier 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TWZRD
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,170 @@
-# Temporary Holding Version
+# twzrd-log-verifier
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Offline verifier for the **TWZRD Receipt Transparency log** — the append-only,
+Solana-anchored Merkle log of issued trust receipts (V7 today; the first leaves are V6). Spec:
+[`docs/transparency-log.md`](../docs/transparency-log.md).
+
+Verifies, with **no trust in TWZRD's servers or code**, that:
+
+- a receipt leaf is included in a signed tree head (**inclusion proof**);
+- a newer tree head only appended to an older one (**consistency proof**);
+- a tree head was **anchored on Solana** by the published anchor authority (the `anchor_head` program form the live log uses, or the memo form of the spec draft);
+- heads stay verifiable **across key rotations**, via a pinned key directory;
+- two contradictory signed tree heads are a portable **misbehavior proof**
+  (**equivocation detection**) — including when different keys signed them.
+
+Full source ships in this repo and in the npm tarball. Crypto comes from the
+same audited libraries as
+[`twzrd-receipt-verifier`](https://github.com/twzrd-sol/twzrd-receipt-verifier)
+(`tweetnacl` = ref Ed25519, `js-sha3` = Keccak, `bs58`); the RFC 6962/9162
+Merkle algorithms and the TWZRD byte layouts are the only logic here.
+
+## Why this exists
+
+A valid V6 or V7 receipt proves TWZRD authored it. It does not stop TWZRD from
+answering differently to different buyers (equivocation) or issuing receipts
+after the fact (backdating). The transparency log makes both **provable**: every
+receipt leaf is appended to one Merkle tree, heads are signed and anchored on
+Solana, and any relying party can hold the log to its own history.
+
+## Usage
+
+On npm from 0.3.0 (the first published version). Run it without installing:
+
+```bash
+npx -y twzrd-log-verifier selftest
+```
+
+or install it (`npm i -g twzrd-log-verifier`) and drop the `npx` prefix, as the
+lines below do. To run the source in this repo instead:
+
+```bash
+npm --prefix twzrd-log-verifier install && npm --prefix twzrd-log-verifier run build
+alias twzrd-log-verifier='node "$PWD/twzrd-log-verifier/dist/src/cli.js"'
+```
+
+```bash
+twzrd-log-verifier selftest   # prove the checker checks (no files, no network)
+
+# Is my paid receipt in the log the current signed head commits to?
+twzrd-log-verifier inclusion --receipt receipt.json --proof proof.json --sth sth.json
+
+# A paid response already carries its proof — verify it directly, no separate
+# --leaf/--sth files (log_inclusion or the whole response as --proof):
+twzrd-log-verifier inclusion --proof paid-response.json
+
+# Did the log only append between two heads I saw at different times?
+twzrd-log-verifier consistency --old sth-old.json --new sth-new.json --proof proof.json
+
+# Was this head anchored on Solana by the published authority? Reads the transaction
+# (use a mainnet tx_signature from /v1/log/anchors), requires it to have succeeded, and
+# matches an anchor_head instruction of the evidence-ledger program (--program overrides
+# it; --ledger also pins the ledger account, anchor_ledger_pda) or an anchor memo.
+twzrd-log-verifier anchor --sth sth.json --tx <tx-signature> --authority <b58> [--program <id>] [--ledger <b58>] [--rpc <url>]
+
+# Do two heads contradict each other? (a positive result is publishable proof)
+twzrd-log-verifier equivocation --a sth-a.json --b sth-b.json [--proof consistency.json]
+
+# Watch a live log: prove it only appended since the head you last pinned.
+twzrd-log-verifier monitor --base-url https://intel.twzrd.xyz --state ./pin.json
+```
+
+`monitor` is the split-view detector. It fetches the log's current head, demands
+a consistency proof against the head you last pinned, and persists the new pin.
+It reports one of `pinned` / `unchanged` / `advanced` / `lagging` /
+`equivocation` / `error`, and **never advances the pin on an unproven step** — a
+missing or failing proof leaves the old pin in place. A head *behind* your pin is
+treated as replica lag and proven consistent in the other direction, not
+misreported as an attack. Run it on a schedule; on `equivocation` it writes a
+publishable proof bundle (`--proof-out`) and exits 2.
+
+Exit code 0 = the requested verification succeeded; 1 = it failed or errored;
+2 = `monitor` proved equivocation. Inclusion, consistency, and equivocation
+checks are fully offline. The anchor check needs any Solana RPC endpoint — the
+RPC is a data source only and cannot forge a signer or a memo binding.
+
+## Pinning keys
+
+Every command takes either form:
+
+- `--pubkey KEY` — pin one base58 Ed25519 key.
+- `--keys FILE` — pin a **key directory**, which is what you want once the log
+  has rotated a signing key. Each head names the `key_id` that signed it, bound
+  into the signature, and the directory says which key was entitled to sign
+  when. Retiring a key does not invalidate the heads it already signed, and a
+  retired key cannot be used to backdate a head into a window it never held.
+
+The default is the built-in single key
+(`Ak5SQwHpuQAqU7ty7ZWX7qgF39A9yi72c22KNn8sHzvS`, the current receipt issuer key,
+also published at `intel.twzrd.xyz/.well-known/twzrd-receipt-pubkey`).
+
+The log's own descriptor is **not** a root of trust — a compromised log would
+advertise the attacker's keys. A pin you supply always wins over the descriptor;
+to accept the log's self-advertised keys you must opt in with
+`--trust-descriptor`, and the output labels that run as TOFU.
+
+## Library
+
+```typescript
+import {
+  // proofs
+  verifyInclusion, verifyConsistency, verifySth, verifyAnchor, checkEquivocation,
+  merkleRoot, inclusionProof, consistencyProof,
+  // keys
+  validateLogKeyDirectory, resolveLogKey, currentSigningKey,
+  // live log
+  fetchLogDescriptor, fetchSth, fetchInclusionProof, fetchConsistencyProof,
+  verifyReceiptInLog, resolveTrust,
+  // split-view detection
+  createSthPinStore,
+  DEFAULT_STH_PUBKEY,
+} from "twzrd-log-verifier";
+
+// Is this paid receipt actually in the log, under a head my pinned keys signed?
+const res = await verifyReceiptInLog({
+  baseUrl: "https://intel.twzrd.xyz",
+  receipt,                 // or: leaf: "<64 hex>"
+  trusted: myPinnedKeyDirectory,
+});
+// res.valid === true  =>  inclusion proven against a signed head
+```
+
+Generation functions (`merkleRoot`, `inclusionProof`, `consistencyProof`,
+`signSth`) are exported so proofs are reproducible from an entry list; relying
+parties only need the `verify*` half.
+
+## File shapes
+
+```jsonc
+// Signed Tree Head (GET /v1/log/sth)
+{
+  "domain": "TWZRD:RECEIPT_LOG_STH_V2",
+  "log_id": "intel.twzrd.xyz/v6",
+  "key_id": "twzrd-log-ed25519-v1",
+  "tree_size": 48213,
+  "timestamp_unix": 1755072000,
+  "root": "0x…64 hex…",
+  "signature": "<base58 Ed25519>",
+  "signing_pubkey": "<base58>"
+}
+
+// Key directory (--keys), also served inside the log descriptor
+{
+  "version": 1,
+  "log_id": "intel.twzrd.xyz/v6",
+  "keys": [
+    { "key_id": "twzrd-log-ed25519-v1", "public_key": "<base58>",
+      "mode": "sign", "not_before_unix": 1756000000, "not_after_unix": null }
+  ]
+}
+
+// Inclusion proof (GET /v1/log/proof/inclusion?leaf=…)
+{ "leaf_index": 17, "tree_size": 48213, "audit_path": ["0x…", "…"], "sth": { … } }
+
+// Consistency proof (GET /v1/log/proof/consistency?old_size=…&new_size=…)
+{ "path": ["0x…", "…"] }
+```
+
+## License
+
+MIT

package/dist/src/anchor.d.ts

@@ -0,0 +1,84 @@
+import { type SignedTreeHead } from "./sth.js";
+import { type FetchLike } from "./util.js";
+import type { LogKeyDirectory } from "./keydir.js";
+export declare const ANCHOR_MEMO_PREFIX = "twzrd-log-anchor:v1:";
+export declare const MEMO_PROGRAM_IDS: Set<string>;
+export declare const DEFAULT_RPC_URL = "https://api.mainnet-beta.solana.com";
+/** The evidence-ledger program the live log anchors through (`anchor_program_id`). */
+export declare const EVIDENCE_LEDGER_PROGRAM_ID = "BzBAYJxUtJp6mUkJPjEYjd8vdb2FUGnAfB5X9LqrQ72W";
+/** sha256("global:anchor_head")[0..8], the program's instruction discriminator. */
+export declare const ANCHOR_HEAD_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export interface AnchorPayload {
+    log_id: string;
+    tree_size: number;
+    root: string;
+}
+/**
+ * Parse `twzrd-log-anchor:v1:<log_id>:<tree_size>:<root_hex>`.
+ * Parsed from the end so a log_id containing ':' cannot shift fields.
+ * Returns null for anything that is not a well-formed anchor memo.
+ */
+export declare function parseAnchorMemo(memo: string): AnchorPayload | null;
+export interface AnchorHeadPayload extends AnchorPayload {
+    timestamp_unix: number;
+}
+/**
+ * Decode `anchor_head` instruction data: the discriminator, then
+ * `[tree_size u64 LE][timestamp_unix u64 LE][root 32][log_id_len u8][log_id UTF-8]`.
+ * Returns null for anything that is not exactly that (trailing bytes included).
+ */
+export declare function parseAnchorHeadData(data: Uint8Array): AnchorHeadPayload | null;
+export declare function formatAnchorMemo(payload: AnchorPayload): string;
+/** Field mismatches between an anchor and a head; `timestamp_unix` is compared when the anchor carries it. */
+export declare function anchorMatchesSth(payload: AnchorPayload | AnchorHeadPayload, sth: SignedTreeHead): string[];
+export interface FetchedAnchorHead {
+    program_id: string;
+    /** [authority, payer, ledger, root entry, system program, instructions sysvar] */
+    accounts: string[];
+    payload: AnchorHeadPayload;
+}
+export interface FetchedAnchorTx {
+    memos: string[];
+    anchorHeads: FetchedAnchorHead[];
+    signers: string[];
+    /** false when the transaction failed (`meta.err` set) or carried no status: it anchored nothing. */
+    succeeded: boolean;
+    slot: number | null;
+    blockTime: number | null;
+}
+/** Fetch a transaction over plain JSON-RPC and extract memos, anchor_head instructions and signers. */
+export declare function fetchAnchorTransaction(txSignature: string, rpcUrl?: string, fetchImpl?: FetchLike): Promise<FetchedAnchorTx>;
+export interface AnchorVerifyResult {
+    valid: boolean;
+    errors: string[];
+    sth_valid: boolean;
+    /** Which binding matched the head: the program's anchor_head instruction, or a memo. */
+    anchor_kind: "anchor_head" | "memo" | null;
+    anchor_head_found: boolean;
+    memo_found: boolean;
+    tx_succeeded: boolean;
+    authority_signed: boolean;
+    slot: number | null;
+    block_time: number | null;
+}
+/**
+ * Full anchor check: STH signature, a successful transaction, a binding to
+ * this head (an `anchor_head` instruction of the pinned program whose
+ * authority account is the pinned authority, or an anchor memo), and the
+ * authority among the signers. A valid result proves the STH's
+ * (log_id, tree_size, root) existed on Solana no later than `block_time`,
+ * published by the pinned anchor authority.
+ */
+export declare function verifyAnchor(opts: {
+    sth: SignedTreeHead;
+    txSignature: string;
+    /** Pinned key, or a pinned key directory when heads carry `key_id`. */
+    sthPubkey: string | LogKeyDirectory;
+    anchorAuthority: string;
+    /** The program an anchor_head must belong to (default: the evidence-ledger program). */
+    anchorProgramId?: string;
+    /** Optional ledger account pin (`anchor_ledger_pda`); checked against the instruction's ledger account. */
+    ledger?: string;
+    rpcUrl?: string;
+    fetchImpl?: FetchLike;
+}): Promise<AnchorVerifyResult>;

package/dist/src/anchor.js

@@ -0,0 +1,249 @@
+/*
+ * Solana anchor verification: a Signed Tree Head is anchored by a successful
+ * mainnet transaction that commits to (log_id, tree_size, root) and is signed
+ * by the published anchor authority.
+ *
+ * The live log anchors through the evidence-ledger program: one
+ * `anchor_head` instruction carrying (tree_size, timestamp_unix, root,
+ * log_id), which the program accepts only from the ledger's authority and
+ * only after the runtime's ed25519 precompile has checked the head's
+ * signature in the same transaction. The SPL Memo form
+ * (`twzrd-log-anchor:v1:...`) of the v0.2 spec draft is still accepted.
+ *
+ * The RPC endpoint is only a data source — the binding is checked locally
+ * and the authority must appear among the transaction's signers, so a
+ * malicious RPC can hide an anchor but cannot forge one.
+ */
+import { verifySth } from "./sth.js";
+import { hexToBytes, bytesToHex, b58decode } from "./util.js";
+import { HASH_LEN } from "./merkle.js";
+export const ANCHOR_MEMO_PREFIX = "twzrd-log-anchor:v1:";
+export const MEMO_PROGRAM_IDS = new Set([
+    "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr", // Memo v2
+    "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo", // Memo v1
+]);
+export const DEFAULT_RPC_URL = "https://api.mainnet-beta.solana.com";
+/** The evidence-ledger program the live log anchors through (`anchor_program_id`). */
+export const EVIDENCE_LEDGER_PROGRAM_ID = "BzBAYJxUtJp6mUkJPjEYjd8vdb2FUGnAfB5X9LqrQ72W";
+/** sha256("global:anchor_head")[0..8], the program's instruction discriminator. */
+export const ANCHOR_HEAD_DISCRIMINATOR = Uint8Array.of(0x6d, 0xab, 0x20, 0x3d, 0xc5, 0x98, 0xeb, 0x71);
+const MAX_LOG_ID = 64;
+/**
+ * Parse `twzrd-log-anchor:v1:<log_id>:<tree_size>:<root_hex>`.
+ * Parsed from the end so a log_id containing ':' cannot shift fields.
+ * Returns null for anything that is not a well-formed anchor memo.
+ */
+export function parseAnchorMemo(memo) {
+    if (typeof memo !== "string" || !memo.startsWith(ANCHOR_MEMO_PREFIX))
+        return null;
+    const rest = memo.slice(ANCHOR_MEMO_PREFIX.length);
+    const lastColon = rest.lastIndexOf(":");
+    if (lastColon < 0)
+        return null;
+    const secondLastColon = rest.lastIndexOf(":", lastColon - 1);
+    if (secondLastColon < 0)
+        return null;
+    const logId = rest.slice(0, secondLastColon);
+    const sizeStr = rest.slice(secondLastColon + 1, lastColon);
+    const rootHex = rest.slice(lastColon + 1).toLowerCase();
+    if (logId.length === 0)
+        return null;
+    if (!/^[0-9]+$/.test(sizeStr))
+        return null;
+    const treeSize = Number(sizeStr);
+    if (!Number.isSafeInteger(treeSize))
+        return null;
+    if (!/^[0-9a-f]{64}$/.test(rootHex))
+        return null;
+    return { log_id: logId, tree_size: treeSize, root: rootHex };
+}
+function u64At(view, offset) {
+    const v = view.getBigUint64(offset, true);
+    return v <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v) : null;
+}
+/**
+ * Decode `anchor_head` instruction data: the discriminator, then
+ * `[tree_size u64 LE][timestamp_unix u64 LE][root 32][log_id_len u8][log_id UTF-8]`.
+ * Returns null for anything that is not exactly that (trailing bytes included).
+ */
+export function parseAnchorHeadData(data) {
+    if (data.length < 58)
+        return null;
+    if (ANCHOR_HEAD_DISCRIMINATOR.some((b, i) => data[i] !== b))
+        return null;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const treeSize = u64At(view, 8);
+    const timestamp = u64At(view, 16);
+    const len = data[56];
+    if (!treeSize || timestamp === null || len === 0 || len > MAX_LOG_ID || data.length !== 57 + len)
+        return null;
+    let logId;
+    try {
+        logId = new TextDecoder("utf-8", { fatal: true }).decode(data.subarray(57));
+    }
+    catch {
+        return null;
+    }
+    return { log_id: logId, tree_size: treeSize, timestamp_unix: timestamp, root: bytesToHex(data.subarray(24, 56)) };
+}
+export function formatAnchorMemo(payload) {
+    const root = hexToBytes(payload.root);
+    if (root.length !== HASH_LEN)
+        throw new Error("anchor root must be 32 bytes");
+    return `${ANCHOR_MEMO_PREFIX}${payload.log_id}:${payload.tree_size}:${bytesToHex(root)}`;
+}
+/** Field mismatches between an anchor and a head; `timestamp_unix` is compared when the anchor carries it. */
+export function anchorMatchesSth(payload, sth) {
+    const errors = [];
+    if (payload.log_id !== String(sth.log_id)) {
+        errors.push(`anchor log_id ${JSON.stringify(payload.log_id)} != STH log_id ${JSON.stringify(String(sth.log_id))}`);
+    }
+    if (payload.tree_size !== Number(sth.tree_size)) {
+        errors.push(`anchor tree_size ${payload.tree_size} != STH tree_size ${sth.tree_size}`);
+    }
+    const sthRoot = String(sth.root || "").toLowerCase().replace(/^0x/, "");
+    if (payload.root !== sthRoot) {
+        errors.push(`anchor root ${payload.root} != STH root ${sthRoot}`);
+    }
+    if ("timestamp_unix" in payload && payload.timestamp_unix !== Number(sth.timestamp_unix)) {
+        errors.push(`anchor timestamp_unix ${payload.timestamp_unix} != STH timestamp_unix ${sth.timestamp_unix}`);
+    }
+    return errors;
+}
+/** Fetch a transaction over plain JSON-RPC and extract memos, anchor_head instructions and signers. */
+export async function fetchAnchorTransaction(txSignature, rpcUrl = DEFAULT_RPC_URL, fetchImpl = fetch) {
+    const res = await fetchImpl(rpcUrl, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "getTransaction",
+            params: [
+                txSignature,
+                { encoding: "jsonParsed", maxSupportedTransactionVersion: 0, commitment: "finalized" },
+            ],
+        }),
+    });
+    if (!res.ok)
+        throw new Error(`RPC HTTP ${res.status}`);
+    const body = (await res.json());
+    if (body.error)
+        throw new Error(`RPC error: ${body.error.message || "unknown"}`);
+    if (!body.result)
+        throw new Error("transaction not found (or RPC pruned it)");
+    const msg = body.result.transaction?.message || {};
+    const signers = (msg.accountKeys || [])
+        .filter((k) => k && k.signer === true && typeof k.pubkey === "string")
+        .map((k) => k.pubkey);
+    const memos = [];
+    const anchorHeads = [];
+    for (const ix of msg.instructions || []) {
+        const isMemo = ix.program === "spl-memo" || MEMO_PROGRAM_IDS.has(String(ix.programId || ""));
+        if (isMemo && typeof ix.parsed === "string")
+            memos.push(ix.parsed);
+        if (typeof ix.data !== "string")
+            continue;
+        let payload = null;
+        try {
+            payload = parseAnchorHeadData(b58decode(ix.data));
+        }
+        catch {
+            continue; // not base58: some other program's data
+        }
+        if (payload) {
+            const accounts = (ix.accounts || []).filter((a) => typeof a === "string");
+            anchorHeads.push({ program_id: String(ix.programId || ""), accounts, payload });
+        }
+    }
+    const meta = body.result.meta;
+    return {
+        memos,
+        anchorHeads,
+        signers,
+        succeeded: meta !== undefined && meta !== null && meta.err === null,
+        slot: typeof body.result.slot === "number" ? body.result.slot : null,
+        blockTime: typeof body.result.blockTime === "number" ? body.result.blockTime : null,
+    };
+}
+/**
+ * Full anchor check: STH signature, a successful transaction, a binding to
+ * this head (an `anchor_head` instruction of the pinned program whose
+ * authority account is the pinned authority, or an anchor memo), and the
+ * authority among the signers. A valid result proves the STH's
+ * (log_id, tree_size, root) existed on Solana no later than `block_time`,
+ * published by the pinned anchor authority.
+ */
+export async function verifyAnchor(opts) {
+    const out = {
+        valid: false,
+        errors: [],
+        sth_valid: false,
+        anchor_kind: null,
+        anchor_head_found: false,
+        memo_found: false,
+        tx_succeeded: false,
+        authority_signed: false,
+        slot: null,
+        block_time: null,
+    };
+    const sthRes = verifySth(opts.sth, opts.sthPubkey);
+    out.sth_valid = sthRes.valid;
+    if (!sthRes.valid)
+        out.errors.push(...sthRes.errors.map((e) => `sth: ${e}`));
+    let tx;
+    try {
+        tx = await fetchAnchorTransaction(opts.txSignature, opts.rpcUrl, opts.fetchImpl);
+    }
+    catch (e) {
+        out.errors.push(`fetch: ${e.message}`);
+        return out;
+    }
+    out.slot = tx.slot;
+    out.block_time = tx.blockTime;
+    out.tx_succeeded = tx.succeeded;
+    if (!tx.succeeded)
+        out.errors.push("transaction failed or has no status, so it anchored nothing");
+    const program = opts.anchorProgramId ?? EVIDENCE_LEDGER_PROGRAM_ID;
+    const heads = tx.anchorHeads.filter((h) => h.program_id === program);
+    for (const h of heads) {
+        const mismatches = anchorMatchesSth(h.payload, opts.sth);
+        if (h.accounts[0] !== opts.anchorAuthority) {
+            mismatches.push(`anchor_head authority ${h.accounts[0]} != pinned authority ${opts.anchorAuthority}`);
+        }
+        if (opts.ledger !== undefined && h.accounts[2] !== opts.ledger) {
+            mismatches.push(`anchor_head ledger ${h.accounts[2]} != pinned ledger ${opts.ledger}`);
+        }
+        if (mismatches.length === 0) {
+            out.anchor_head_found = true;
+            break;
+        }
+        out.errors.push(...mismatches);
+    }
+    if (!out.anchor_head_found) {
+        for (const memo of tx.memos) {
+            const parsed = parseAnchorMemo(memo);
+            if (!parsed)
+                continue;
+            const mismatches = anchorMatchesSth(parsed, opts.sth);
+            if (mismatches.length === 0) {
+                out.memo_found = true;
+                break;
+            }
+            out.errors.push(...mismatches);
+        }
+    }
+    out.anchor_kind = out.anchor_head_found ? "anchor_head" : out.memo_found ? "memo" : null;
+    if (out.anchor_kind === null && heads.length === 0 && tx.memos.length === 0) {
+        out.errors.push(`transaction contains no anchor_head instruction of ${program} and no memo instruction`);
+    }
+    else if (out.anchor_kind === null) {
+        out.errors.push("no anchor_head instruction or memo in the transaction matches this STH");
+    }
+    out.authority_signed = tx.signers.includes(opts.anchorAuthority);
+    if (!out.authority_signed) {
+        out.errors.push(`anchor authority ${opts.anchorAuthority} is not a signer of the transaction (signers: ${tx.signers.join(", ") || "none"})`);
+    }
+    out.valid = out.sth_valid && out.tx_succeeded && out.anchor_kind !== null && out.authority_signed;
+    return out;
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};