@xfuel/verify 0.1.1 → 0.3.0

package/README.md

@@ -25,6 +25,7 @@ console.log(result.matches); // true if binding verified
 // Full verification including on-chain nullifier check
 const fullResult = await verifyReceipt(receipt, { checkNullifier: true });
 console.log(fullResult.overall); // 'verified' | 'partial' | 'failed'
+console.log(fullResult.receipt_lane.freeze); // unsigned; does not change overall
 ```
 
 ### CLI
@@ -33,6 +34,15 @@ console.log(fullResult.overall); // 'verified' | 'partial' | 'failed'
 # Local binding verification (no network required)
 npx xfuel-verify receipt.json
 
+# Hash the canonical object (must match signed payload_hash) and read not_after
+# from a pinned issuer-history snapshot. Both flags are offline.
+npx xfuel-verify receipt.json --canonical-preimage preimage.json --issuer-history-file issuer-history.json
+
+# A signed refusal (schema chit402.refusal.v1) is not a payment.
+# The check proves the issuer refused, at the signed anchor, for that code.
+# It does not prove a payment or that the block still stands.
+npx xfuel-verify refusal.json
+
 # With on-chain nullifier check (requires network)
 npx xfuel-verify receipt.json --check-nullifier
 
@@ -40,7 +50,10 @@ npx xfuel-verify receipt.json --check-nullifier
 npx xfuel-verify receipt.json --json
 
 # From stdin
-curl -s https://api.xfuel.app/receipt/task-123?format=json | npx xfuel-verify -
+curl -s https://api.chit402.com/receipt/task-123?format=json | npx xfuel-verify -
+
+# Dual anchor: inclusion, Solana memo, Base calldata
+npx xfuel-verify receipt.json inclusion.json head.json --rpc
 ```
 
 ## What This Verifies
@@ -48,42 +61,70 @@ curl -s https://api.xfuel.app/receipt/task-123?format=json | npx xfuel-verify -
 | Check | Requires Network? | Description |
 |-------|-------------------|-------------|
 | Payment binding | No | Recompute commitment from receipt fields |
-| Issuer signature | No | ES256 verification — pinned `issuer_jwk` on receipt, or JWKS file |
+| Issuer signature | No, unless `--fetch-jwks` | ES256. Trusted only via JWKS (by kid) or a pinned RFC 7638 kid |
 | Output hash | No | Hash is on the receipt |
 | On-chain settlement | Yes | Query Base RPC for tx |
 | Nullifier anchor | Yes | Query ZKVerifierSP1 contract |
+| Anchored receipt root | Yes, with `--rpc` | Inclusion proof, then Solana memo and Base calldata for that root |
+| Canonical preimage | No | SHA-256 of `--canonical-preimage`, or the stored canonical object, matches signed `payload_hash` |
+| Issuer history | No, with `--issuer-history-file` | `iat` is inside the kid's `not_before` / `not_after`. A payload v10 pin must match the snapshot hash |
 
 ## Issuer Signature Verification (ES256)
 
-Receipts include an `issuer_signature` signed with ES256 (P-256). Verify offline:
+Receipts include `issuer_signature.jws` (compact ES256 / P-256). The signature
+counts only when the verifying key is trusted:
 
-### Pin-first (receipts with `issuer_signature.issuer_jwk`)
+1. **JWKS by kid** — a key in `--jwks-file`, `--jwks-url`, or `--fetch-jwks`
+   (allowlisted host, default `api.chit402.com`) whose `kid` matches the JWS.
+2. **Pinned thumbprint** — the embedded `issuer_jwk` is used only when its
+   RFC 7638 thumbprint equals a trusted kid. The default offline pin is the
+   production kid `IvFpmC-vPhkY_v0vidsrWVT9uzlE5XWKZgAEOeJTq1Q`. Override with
+   `--trusted-kid`, or disable with `--no-trusted-kid`.
 
-Newer receipts pin the issuer public key directly in the receipt. No JWKS file needed:
+`issuer_jwk` on the receipt is not a trust root. A copy re-signed with an
+arbitrary P-256 key reports `key untrusted` (`issuer_signature.valid === false`),
+including when `--jwks-file` points at the real JWKS.
 
 ```bash
-# Offline verify — uses pinned issuer_jwk from the receipt
+# Offline: default production pin, no network
 npx xfuel-verify receipt.json
+
+# Recompute published preimages and check the kid window.
+# A payload v10 receipt pins issuer_history. Hash the stored canonical object:
+curl -sS "https://api.chit402.com/receipt/RECEIPT_ID?format=json" -o receipt.json
+curl -sS "https://api.chit402.com/receipt/RECEIPT_ID/preimage" -o preimage.json
+curl -sS "https://api.chit402.com/.well-known/issuer-history.json?version=1" -o issuer-history.json
+npx xfuel-verify receipt.json --canonical-preimage preimage.json --issuer-history-file issuer-history.json
+
+# Trust the published JWKS instead of (or in addition to) the pin
+curl -o issuer-jwks.json https://api.chit402.com/.well-known/jwks.json
+npx xfuel-verify receipt.json --jwks-file issuer-jwks.json --no-trusted-kid
+
+# Fetch the issuer JWKS (https://api.chit402.com/.well-known/jwks.json)
+npx xfuel-verify receipt.json --fetch-jwks
 ```
 
 ```typescript
 import { verifyReceipt } from '@xfuel/verify';
 
-const result = await verifyReceipt(receipt); // no jwks option required
-console.log(result.issuer_signature.valid); // true when signature intact
+const result = await verifyReceipt(receipt);
+console.log(result.issuer_signature.valid);      // true only for a trusted key
+console.log(result.issuer_signature.key_trusted);
+console.log(result.amount_usdc);                 // from verified claims, not the outer copy
+console.log(result.claim_mismatches);            // outer payment / caller_binding vs JWS
 ```
 
-### Legacy JWKS file (older receipts without pin)
+Amount, payer, payee, asset, and tx are read from the verified JWS claims.
+If the unsigned outer `payment` or `caller_binding` disagrees, verification
+fails. `--check-payer` on Base confirms payer, payee, asset, and amount in the
+USDC `Transfer` log.
 
-```bash
-# Download JWKS once (or obtain from trusted source)
-curl -o issuer-jwks.json https://api.chit402.com/.well-known/jwks.json
-
-# Verify receipt with JWKS file (no network during verification)
-npx xfuel-verify receipt.json --jwks-file issuer-jwks.json
-```
+A paid USDC receipt whose signed `binding.expected_commitment` is null is
+reported as “No payment-binding commitment”, not as an unmetered or TFUEL receipt.
 
-The CLI does **not** automatically fetch JWKS to ensure offline verification. For pinned receipts, `--jwks-file` is optional. Exit code 1 (failed) is returned if the signature is invalid or tampered.
+The CLI does **not** fetch JWKS unless `--fetch-jwks` or `--jwks-url` is set.
+Exit code 1 is returned when the key is untrusted, the signature is invalid, or
+a signed claim disagrees with the outer copy.
 
 ## Frozen Fields
 
@@ -181,6 +222,10 @@ Full verification combining binding and optional nullifier check.
 }
 ```
 
+## Build digest
+
+`npm run digest` writes `BUILD_DIGEST.txt`. That file is the SHA-256 of the sorted `src/**/*.ts` listing, not a bit-reproducible `tsc` binary. The same sources produce the same digest. The receipt-tree genesis leaf copies this digest so a holder can see which verifier source the issuer vouches for. It does not prove the process that served the receipt ran that exact binary.
+
 ## License
 
 Apache-2.0

package/dist/anchor-witness.d.ts

@@ -0,0 +1,138 @@
+export declare const MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+export declare const MEMO_PROGRAM_ID_V1 = "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo";
+/** Genesis hashes from the Solana cluster CAIP-2 references. */
+export declare const SOLANA_GENESIS: Record<string, string>;
+export declare const BASE_MAINNET_CHAIN_ID = 8453;
+export declare const ANCHOR_PROVES: string[];
+export declare const ANCHOR_DOES_NOT_PROVE: string[];
+export interface InclusionStep {
+    hash: string;
+    position: string;
+}
+export interface AnchorReceipt {
+    task_id?: string;
+    row_hash?: string | null;
+    book_chain?: {
+        row_hash?: string | null;
+    } | null;
+}
+export interface AnchorInclusion {
+    task_id?: string;
+    leaf_index: number;
+    tree_size: number;
+    root: string;
+    leaf?: string;
+    row_hash?: string | null;
+    proof: InclusionStep[];
+}
+export interface AnchorHead {
+    root: string;
+    tree_size?: number;
+    anchor_tx?: string | null;
+    anchor?: {
+        tx?: string | null;
+        calldata?: string | null;
+        chain_id?: number | null;
+    } | null;
+    anchors?: {
+        base?: {
+            tx?: string | null;
+            calldata?: string | null;
+            chain_id?: number | null;
+            status?: string;
+        } | null;
+        solana?: {
+            signature?: string | null;
+            slot?: number | null;
+            cluster?: string | null;
+            memo?: string | null;
+            status?: string | null;
+        } | null;
+    } | null;
+}
+interface SolanaIx {
+    program?: string;
+    programId?: string;
+    parsed?: string | {
+        memo?: string;
+        info?: string;
+    };
+}
+export interface SolanaAnchorTx {
+    slot?: number;
+    meta?: {
+        err?: unknown;
+        logMessages?: string[];
+        innerInstructions?: Array<{
+            instructions?: SolanaIx[];
+        }>;
+    } | null;
+    transaction?: {
+        message?: {
+            instructions?: SolanaIx[];
+        };
+    };
+}
+export interface BaseAnchorTx {
+    hash?: string;
+    input?: string;
+    chainId?: number;
+}
+export interface AnchorWitnessResult {
+    overall: 'verified' | 'partial' | 'failed';
+    root: string | null;
+    inclusion: {
+        valid: boolean;
+        leaf: string | null;
+        leaf_source: string;
+        reason?: string;
+    };
+    solana: {
+        checked: boolean;
+        valid: boolean;
+        signature: string | null;
+        slot: number | null;
+        cluster: string | null;
+        memo: string | null;
+        reason?: string;
+    };
+    base: {
+        checked: boolean;
+        valid: boolean;
+        tx: string | null;
+        chain_id: number | null;
+        reason?: string;
+    };
+    proves: string[];
+    does_not_prove: string[];
+    errors: string[];
+}
+export declare function leafHash(bytes: Uint8Array): Buffer;
+export declare function normalizeRoot(root: string | null | undefined): string | null;
+/** RFC 6962-style inclusion. Same rule as the gateway tree. */
+export declare function verifyMerkleInclusion(leaf: Buffer, index: number, treeSize: number, rootHex: string, proof: InclusionStep[]): boolean;
+export declare function parseAnchorMemo(memo: string): {
+    scope: string;
+    day: string;
+    root: string;
+    prev: string;
+} | null;
+export declare function extractMemos(tx: SolanaAnchorTx | null | undefined): string[];
+export declare function fetchSolanaGenesisHash(rpcUrl: string): Promise<string>;
+export declare function fetchBaseAnchorTransaction(txHash: string, rpcUrl: string): Promise<BaseAnchorTx | null>;
+export interface VerifyAnchoredRootInput {
+    receipt: AnchorReceipt;
+    inclusion: AnchorInclusion;
+    head: AnchorHead;
+    baseRpcUrl?: string;
+    solanaRpcUrl?: string;
+    fetchSolanaTx?: (signature: string, rpcUrl: string) => Promise<SolanaAnchorTx | null>;
+    fetchGenesis?: (rpcUrl: string) => Promise<string>;
+    fetchBaseTx?: (txHash: string, rpcUrl: string) => Promise<BaseAnchorTx | null>;
+}
+/**
+ * Verify inclusion, then the Solana memo and the Base calldata for that root.
+ */
+export declare function verifyAnchoredRoot(input: VerifyAnchoredRootInput): Promise<AnchorWitnessResult>;
+export {};
+//# sourceMappingURL=anchor-witness.d.ts.map

package/dist/anchor-witness.d.ts.map

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

package/dist/anchor-witness.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANCHOR_DOES_NOT_PROVE = exports.ANCHOR_PROVES = exports.BASE_MAINNET_CHAIN_ID = exports.SOLANA_GENESIS = exports.MEMO_PROGRAM_ID_V1 = exports.MEMO_PROGRAM_ID = void 0;
+exports.leafHash = leafHash;
+exports.normalizeRoot = normalizeRoot;
+exports.verifyMerkleInclusion = verifyMerkleInclusion;
+exports.parseAnchorMemo = parseAnchorMemo;
+exports.extractMemos = extractMemos;
+exports.fetchSolanaGenesisHash = fetchSolanaGenesisHash;
+exports.fetchBaseAnchorTransaction = fetchBaseAnchorTransaction;
+exports.verifyAnchoredRoot = verifyAnchoredRoot;
+/**
+ * Check a receipt leaf against a signed tree head, then against the two
+ * anchors that publish that root: an SPL Memo on Solana and calldata on Base.
+ *
+ * Inclusion is local. The chain checks use the RPC you pass. A matching memo
+ * and matching calldata show the issuer published this root. They do not show
+ * the payment.
+ */
+const node_crypto_1 = require("node:crypto");
+const base_payer_js_1 = require("./base-payer.js");
+const solana_payer_js_1 = require("./solana-payer.js");
+exports.MEMO_PROGRAM_ID = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
+exports.MEMO_PROGRAM_ID_V1 = 'Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo';
+/** Genesis hashes from the Solana cluster CAIP-2 references. */
+exports.SOLANA_GENESIS = {
+    'mainnet-beta': '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+    devnet: 'EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG',
+    testnet: '4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY',
+};
+exports.BASE_MAINNET_CHAIN_ID = 8453;
+exports.ANCHOR_PROVES = [
+    'This receipt leaf is inside the issuer append-only tree of the stated size, under the stated root.',
+    'The Solana transaction memo contains that root, and the RPC genesis hash is the cluster named on the head.',
+    'The Base transaction calldata is that same root, on chain id 8453.',
+];
+exports.ANCHOR_DOES_NOT_PROVE = [
+    'It does not prove the payment, the payer, the payee, or the model output.',
+    'It does not prove a receipt appended after this tree size is inside the root.',
+    'It does not prove the issuer included only honest rows. It proves this leaf hashes into the published root.',
+    'It does not prove the RPC itself is honest. It checks the transaction and genesis hash that RPC returned.',
+];
+function sha256(buf) {
+    return (0, node_crypto_1.createHash)('sha256').update(buf).digest();
+}
+function leafHash(bytes) {
+    return sha256(Buffer.concat([Buffer.from([0x00]), Buffer.from(bytes)]));
+}
+function nodeHash(left, right) {
+    return sha256(Buffer.concat([Buffer.from([0x01]), left, right]));
+}
+function normalizeRoot(root) {
+    const hex = String(root || '').replace(/^0x/, '').toLowerCase();
+    return /^[0-9a-f]{64}$/.test(hex) ? hex : null;
+}
+/** RFC 6962-style inclusion. Same rule as the gateway tree. */
+function verifyMerkleInclusion(leaf, index, treeSize, rootHex, proof) {
+    if (!Array.isArray(proof) || index < 0 || index >= treeSize)
+        return false;
+    let hash = new Uint8Array(leaf);
+    for (const step of proof) {
+        if (!step || !/^[0-9a-fA-F]{64}$/.test(step.hash))
+            return false;
+        const sib = Buffer.from(step.hash, 'hex');
+        const next = step.position === 'left' ? nodeHash(sib, hash) : nodeHash(hash, sib);
+        hash = new Uint8Array(next);
+    }
+    return Buffer.from(hash).toString('hex') === String(rootHex).replace(/^0x/, '').toLowerCase();
+}
+function parseAnchorMemo(memo) {
+    const parts = String(memo || '').split(':');
+    if (parts.length !== 7)
+        return null;
+    if (parts[0] !== 'chit402' || parts[1] !== 'root' || parts[2] !== 'v1')
+        return null;
+    const scope = parts[3];
+    const day = parts[4];
+    const root = parts[5];
+    const prev = parts[6];
+    if (!/^[A-Za-z0-9_-]{1,64}$/.test(scope))
+        return null;
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(day))
+        return null;
+    if (!/^[0-9a-f]{64}$/.test(root) || !/^[0-9a-f]{64}$/.test(prev))
+        return null;
+    return { scope, day, root, prev };
+}
+function isMemoIx(ix) {
+    const program = ix.program || '';
+    const programId = ix.programId || '';
+    return program === 'spl-memo'
+        || programId === exports.MEMO_PROGRAM_ID
+        || programId === exports.MEMO_PROGRAM_ID_V1;
+}
+function extractMemos(tx) {
+    if (!tx)
+        return [];
+    const found = [];
+    const push = (value) => {
+        if (value && !found.includes(value))
+            found.push(value);
+    };
+    const visit = (ix) => {
+        if (!ix || !isMemoIx(ix))
+            return;
+        if (typeof ix.parsed === 'string')
+            push(ix.parsed);
+        else if (ix.parsed && typeof ix.parsed.memo === 'string')
+            push(ix.parsed.memo);
+        else if (ix.parsed && typeof ix.parsed.info === 'string')
+            push(ix.parsed.info);
+    };
+    for (const ix of tx.transaction?.message?.instructions || [])
+        visit(ix);
+    for (const inner of tx.meta?.innerInstructions || []) {
+        for (const ix of inner.instructions || [])
+            visit(ix);
+    }
+    for (const line of tx.meta?.logMessages || []) {
+        const match = /Memo \(len \d+\): "(.*)"/.exec(line);
+        if (match)
+            push(match[1]);
+    }
+    return found;
+}
+async function defaultRpc(url, method, params) {
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+    });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+    const json = await res.json();
+    if (json.error)
+        throw new Error(json.error.message || 'rpc_error');
+    return json.result ?? null;
+}
+async function fetchSolanaGenesisHash(rpcUrl) {
+    const result = await defaultRpc(rpcUrl, 'getGenesisHash', []);
+    if (typeof result !== 'string' || result.length === 0)
+        throw new Error('no_genesis');
+    return result;
+}
+async function fetchBaseAnchorTransaction(txHash, rpcUrl) {
+    const tx = await defaultRpc(rpcUrl, 'eth_getTransactionByHash', [txHash]);
+    const chainHex = await defaultRpc(rpcUrl, 'eth_chainId', []);
+    if (!tx)
+        return null;
+    return {
+        hash: tx.hash,
+        input: tx.input,
+        chainId: chainHex ? Number(chainHex) : undefined,
+    };
+}
+function rowHashFrom(receipt, inclusion) {
+    if (typeof receipt.row_hash === 'string')
+        return { rowHash: receipt.row_hash, source: 'receipt' };
+    if (typeof receipt.book_chain?.row_hash === 'string')
+        return { rowHash: receipt.book_chain.row_hash, source: 'receipt' };
+    if (typeof inclusion.row_hash === 'string')
+        return { rowHash: inclusion.row_hash, source: 'inclusion' };
+    return null;
+}
+function solanaSignature(head) {
+    const sol = head.anchors?.solana;
+    if (!sol || sol.status === 'pending')
+        return null;
+    return sol.signature || null;
+}
+function baseTxHash(head) {
+    const base = head.anchors?.base;
+    if (base?.status === 'pending')
+        return null;
+    return base?.tx || head.anchor?.tx || head.anchor_tx || null;
+}
+/**
+ * Verify inclusion, then the Solana memo and the Base calldata for that root.
+ */
+async function verifyAnchoredRoot(input) {
+    const errors = [];
+    const doesNotProve = [...exports.ANCHOR_DOES_NOT_PROVE];
+    const root = normalizeRoot(input.head?.root);
+    const inclusionRoot = normalizeRoot(input.inclusion?.root);
+    let leafHex = null;
+    let leafSource = 'none';
+    let inclusionValid = false;
+    let inclusionReason;
+    const taskId = input.receipt?.task_id ? String(input.receipt.task_id) : '';
+    if (!taskId) {
+        inclusionReason = 'missing_task_id';
+    }
+    else if (input.inclusion?.task_id && String(input.inclusion.task_id) !== taskId) {
+        inclusionReason = 'task_mismatch';
+    }
+    else if (!root || !inclusionRoot) {
+        inclusionReason = 'bad_root';
+    }
+    else if (root !== inclusionRoot) {
+        inclusionReason = 'root_mismatch';
+    }
+    else if (input.head.tree_size != null && Number(input.head.tree_size) !== Number(input.inclusion.tree_size)) {
+        inclusionReason = 'tree_size_mismatch';
+    }
+    else {
+        const row = rowHashFrom(input.receipt, input.inclusion);
+        let leaf = null;
+        if (row) {
+            leaf = leafHash(Buffer.from(`${taskId}|${row.rowHash}`));
+            leafSource = row.source;
+            if (input.inclusion.leaf && input.inclusion.leaf.toLowerCase() !== leaf.toString('hex')) {
+                inclusionReason = 'leaf_mismatch';
+                leaf = null;
+            }
+        }
+        else if (input.inclusion.leaf && /^[0-9a-fA-F]{64}$/.test(input.inclusion.leaf)) {
+            leaf = Buffer.from(input.inclusion.leaf, 'hex');
+            leafSource = 'inclusion';
+            doesNotProve.push('The leaf was taken from the inclusion object. The receipt had no row_hash, so this check did not recompute the leaf from the receipt bytes.');
+        }
+        else {
+            inclusionReason = 'no_leaf';
+        }
+        if (leaf) {
+            leafHex = leaf.toString('hex');
+            inclusionValid = verifyMerkleInclusion(leaf, Number(input.inclusion.leaf_index), Number(input.inclusion.tree_size), root, input.inclusion.proof || []);
+            if (!inclusionValid)
+                inclusionReason = 'inclusion_failed';
+        }
+    }
+    if (!inclusionValid && inclusionReason)
+        errors.push(inclusionReason);
+    const solanaRpc = input.solanaRpcUrl || process.env.SOLANA_RPC_URL || solana_payer_js_1.SOLANA_RPC_URL;
+    const baseRpc = input.baseRpcUrl || base_payer_js_1.BASE_RPC_URL;
+    const signature = root && inclusionValid ? solanaSignature(input.head) : null;
+    const txHash = root && inclusionValid ? baseTxHash(input.head) : null;
+    const solana = {
+        checked: false,
+        valid: false,
+        signature: input.head?.anchors?.solana?.signature ?? null,
+        slot: input.head?.anchors?.solana?.slot ?? null,
+        cluster: input.head?.anchors?.solana?.cluster ?? null,
+        memo: input.head?.anchors?.solana?.memo ?? null,
+        reason: undefined,
+    };
+    const base = {
+        checked: false,
+        valid: false,
+        tx: input.head?.anchors?.base?.tx || input.head?.anchor?.tx || input.head?.anchor_tx || null,
+        chain_id: input.head?.anchors?.base?.chain_id ?? input.head?.anchor?.chain_id ?? null,
+        reason: undefined,
+    };
+    if (!inclusionValid) {
+        solana.reason = 'inclusion_failed';
+        base.reason = 'inclusion_failed';
+    }
+    else {
+        if (!signature) {
+            solana.reason = 'pending';
+            errors.push('solana_pending');
+        }
+        else {
+            solana.checked = true;
+            try {
+                const fetchTx = input.fetchSolanaTx || ((sig, url) => (0, solana_payer_js_1.fetchSolanaTransaction)(sig, url));
+                const fetchGenesis = input.fetchGenesis || fetchSolanaGenesisHash;
+                const tx = await fetchTx(signature, solanaRpc);
+                if (!tx) {
+                    solana.reason = 'tx_not_found';
+                }
+                else if (tx.meta?.err) {
+                    solana.reason = 'tx_failed';
+                }
+                else {
+                    const memos = extractMemos(tx);
+                    const recorded = input.head.anchors?.solana?.memo || null;
+                    const matched = memos.filter((memo) => {
+                        const parsed = parseAnchorMemo(memo);
+                        return Boolean(parsed && parsed.root === root && memo.includes(root) && (!recorded || memo === recorded));
+                    });
+                    const cluster = input.head.anchors?.solana?.cluster || null;
+                    const expectedGenesis = cluster ? exports.SOLANA_GENESIS[cluster] : null;
+                    if (matched.length === 0)
+                        solana.reason = 'memo_mismatch';
+                    else if (!cluster)
+                        solana.reason = 'no_cluster';
+                    else if (!expectedGenesis)
+                        solana.reason = 'unknown_cluster';
+                    else {
+                        const genesis = await fetchGenesis(solanaRpc);
+                        if (genesis !== expectedGenesis)
+                            solana.reason = 'cluster_mismatch';
+                    }
+                    const headSlot = input.head.anchors?.solana?.slot;
+                    if (!solana.reason && headSlot != null && tx.slot != null && Number(tx.slot) !== Number(headSlot)) {
+                        solana.reason = 'slot_mismatch';
+                    }
+                    if (!solana.reason) {
+                        solana.valid = true;
+                        solana.memo = matched[0];
+                        if (tx.slot != null)
+                            solana.slot = tx.slot;
+                    }
+                }
+            }
+            catch (err) {
+                solana.reason = err instanceof Error ? err.message : 'solana_rpc_error';
+            }
+            if (!solana.valid && solana.reason)
+                errors.push(`solana:${solana.reason}`);
+        }
+        if (!txHash) {
+            base.reason = 'pending';
+            errors.push('base_pending');
+        }
+        else {
+            base.checked = true;
+            try {
+                const fetchBase = input.fetchBaseTx || fetchBaseAnchorTransaction;
+                const tx = await fetchBase(txHash, baseRpc);
+                const expectedChain = input.head.anchors?.base?.chain_id || input.head.anchor?.chain_id || exports.BASE_MAINNET_CHAIN_ID;
+                if (!tx) {
+                    base.reason = 'tx_not_found';
+                }
+                else if (tx.chainId != null && Number(tx.chainId) !== Number(expectedChain)) {
+                    base.reason = 'chain_mismatch';
+                    base.chain_id = Number(tx.chainId);
+                }
+                else {
+                    const inputData = String(tx.input || '').toLowerCase().replace(/^0x/, '');
+                    if (inputData !== root)
+                        base.reason = 'calldata_mismatch';
+                    else {
+                        base.valid = true;
+                        base.tx = tx.hash || txHash;
+                        base.chain_id = tx.chainId ?? expectedChain;
+                    }
+                }
+            }
+            catch (err) {
+                base.reason = err instanceof Error ? err.message : 'base_rpc_error';
+            }
+            if (!base.valid && base.reason)
+                errors.push(`base:${base.reason}`);
+        }
+    }
+    let overall;
+    if (!inclusionValid || (solana.checked && !solana.valid) || (base.checked && !base.valid))
+        overall = 'failed';
+    else if (solana.valid && base.valid)
+        overall = 'verified';
+    else
+        overall = 'partial';
+    return {
+        overall,
+        root,
+        inclusion: { valid: inclusionValid, leaf: leafHex, leaf_source: leafSource, reason: inclusionReason },
+        solana,
+        base,
+        proves: exports.ANCHOR_PROVES,
+        does_not_prove: doesNotProve,
+        errors,
+    };
+}
+//# sourceMappingURL=anchor-witness.js.map