chit402-verify 0.3.5 → 0.4.1

package/dist/anchor-witness.js

@@ -0,0 +1,833 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEWEST_ANCHOR_PAGE_CAP = exports.NEWEST_ANCHOR_PAGE_LIMIT = 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.inclusionRoot = inclusionRoot;
+exports.verifyMerkleInclusion = verifyMerkleInclusion;
+exports.parseAnchorMemo = parseAnchorMemo;
+exports.extractMemos = extractMemos;
+exports.fetchSolanaGenesisHash = fetchSolanaGenesisHash;
+exports.fetchBaseAnchorTransaction = fetchBaseAnchorTransaction;
+exports.fetchNewestSolanaAnchorRoot = fetchNewestSolanaAnchorRoot;
+exports.solanaFeePayer = solanaFeePayer;
+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 anchor_trust_js_1 = require("./anchor-trust.js");
+const base_payer_js_1 = require("./base-payer.js");
+const epoch_js_1 = require("./epoch.js");
+const issuer_pin_js_1 = require("./issuer-pin.js");
+const row_hash_js_1 = require("./row-hash.js");
+const solana_payer_js_1 = require("./solana-payer.js");
+exports.MEMO_PROGRAM_ID = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
+exports.MEMO_PROGRAM_ID_V1 = 'Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo';
+/**
+ * Full `getGenesisHash` values. CAIP-2 references keep only the first 32
+ * characters, and `getGenesisHash` returns the whole base58 hash. A prefix
+ * compare never matches mainnet-beta.
+ */
+exports.SOLANA_GENESIS = {
+    'mainnet-beta': '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d',
+    devnet: 'EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG',
+    testnet: '4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY',
+};
+exports.BASE_MAINNET_CHAIN_ID = 8453;
+exports.ANCHOR_PROVES = [
+    'This receipt leaf is inside the tree of the stated size, under the stated root.',
+    'The tree head carries a valid ES256 issuer signature. The kid is trusted by the production pin, issuer history, or JWKS, and the signed root, size, epoch, and anchors match the head.',
+    'The Solana transaction memo contains that root, its fee payer is the signed fee payer, and the RPC genesis hash is the cluster named on the head.',
+    'The Base transaction calldata is that same root, on chain id 8453, and its sender is the signed anchor wallet.',
+    'Those wallets are on the issuer anchor-wallet list: the package pin, or a signed well-known or issuer-history list.',
+];
+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.',
+    'It does not read the on-chain issuer-root registry or the DNS anchor. Those sources are reserved and are not consulted.',
+];
+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;
+}
+function half(n) {
+    return Math.floor(n / 2);
+}
+/**
+ * RFC 9162 fold. Returns the recomputed root, or null when the proof is the
+ * wrong length for `(index, treeSize)` or a sibling is not 32 bytes.
+ * Index and tree size choose the side. A `position` label is not read here.
+ */
+function inclusionRoot(leaf, index, treeSize, proof) {
+    if (!Array.isArray(proof))
+        return null;
+    const leafIndex = Number(index);
+    const size = Number(treeSize);
+    if (!Number.isSafeInteger(leafIndex) || !Number.isSafeInteger(size))
+        return null;
+    if (leafIndex < 0 || leafIndex >= size)
+        return null;
+    let fn = leafIndex;
+    let sn = size - 1;
+    let hash = Buffer.from(leaf);
+    for (const step of proof) {
+        if (sn === 0)
+            return null;
+        if (!step || !/^[0-9a-fA-F]{64}$/.test(step.hash))
+            return null;
+        const sib = Buffer.from(step.hash, 'hex');
+        const siblingOnLeft = (fn % 2) === 1 || fn === sn;
+        if (siblingOnLeft) {
+            hash = nodeHash(sib, hash);
+            if ((fn % 2) === 0) {
+                while ((fn % 2) === 0 && fn !== 0) {
+                    fn = half(fn);
+                    sn = half(sn);
+                }
+            }
+        }
+        else {
+            hash = nodeHash(hash, sib);
+        }
+        fn = half(fn);
+        sn = half(sn);
+    }
+    if (sn !== 0)
+        return null;
+    return hash.toString('hex');
+}
+/**
+ * A present `position` label must name the side `index` and `treeSize` already
+ * chose. An omitted label does not. This is the inclusion-proof check. The
+ * public audit path folds with `inclusionRoot` and does not read the label.
+ */
+function positionAgrees(index, treeSize, proof) {
+    if (!Array.isArray(proof))
+        return false;
+    const leafIndex = Number(index);
+    const size = Number(treeSize);
+    if (!Number.isSafeInteger(leafIndex) || !Number.isSafeInteger(size))
+        return false;
+    if (leafIndex < 0 || leafIndex >= size)
+        return false;
+    let fn = leafIndex;
+    let sn = size - 1;
+    for (const step of proof) {
+        if (sn === 0)
+            return false;
+        const siblingOnLeft = (fn % 2) === 1 || fn === sn;
+        if (typeof step?.position === 'string' && step.position !== '' && step.position !== (siblingOnLeft ? 'left' : 'right')) {
+            return false;
+        }
+        if (siblingOnLeft && (fn % 2) === 0) {
+            while ((fn % 2) === 0 && fn !== 0) {
+                fn = half(fn);
+                sn = half(sn);
+            }
+        }
+        fn = half(fn);
+        sn = half(sn);
+    }
+    return true;
+}
+/**
+ * RFC 9162 §2.1.3.2 inclusion. `index` and `treeSize` choose left or right
+ * at each step. A `position` label is not the source of that side. When a
+ * label is present it must name the side the index already chose, so a
+ * swapped label fails. An omitted label does not. A proof whose length is
+ * not the length that pair requires is rejected, as is `index >= treeSize`.
+ * Leaf and node bytes stay SHA-256(0x00 || leaf) and SHA-256(0x01 || left ||
+ * right). Consistency proofs and the empty root are not this function.
+ */
+function verifyMerkleInclusion(leaf, index, treeSize, rootHex, proof) {
+    const root = String(rootHex || '').replace(/^0x/, '').toLowerCase();
+    if (!/^[0-9a-f]{64}$/.test(root))
+        return false;
+    if (!positionAgrees(index, treeSize, proof))
+        return false;
+    return inclusionRoot(leaf, index, treeSize, proof) === root;
+}
+function memoIdentity(scope, day, root, prev) {
+    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 };
+}
+/** v1 memos stay valid. v2 adds epoch, prev_epoch_root, prev_epoch_size, and the bundle index hash. */
+function parseAnchorMemo(memo) {
+    const parts = String(memo || '').split(':');
+    if (parts[0] !== 'chit402' || parts[1] !== 'root')
+        return null;
+    if (parts.length === 7 && parts[2] === 'v1') {
+        const base = memoIdentity(parts[3], parts[4], parts[5], parts[6]);
+        return base ? { version: 1, ...base } : null;
+    }
+    if (parts.length === 11 && parts[2] === 'v2') {
+        const base = memoIdentity(parts[3], parts[4], parts[5], parts[6]);
+        if (!base)
+            return null;
+        const epoch = Number(parts[7]);
+        const prevEpoch = parts[8];
+        const size = Number(parts[9]);
+        const bundle = parts[10];
+        if (!Number.isInteger(epoch) || epoch < 1)
+            return null;
+        if (!/^[0-9a-f]{64}$/.test(prevEpoch) || !/^[0-9a-f]{64}$/.test(bundle))
+            return null;
+        if (!Number.isInteger(size) || size < 0)
+            return null;
+        return {
+            version: 2,
+            ...base,
+            epoch,
+            prev_epoch_root: prevEpoch,
+            prev_epoch_size: size,
+            bundle_index_hash: bundle,
+        };
+    }
+    return null;
+}
+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,
+        from: tx.from,
+        chainId: chainHex ? Number(chainHex) : undefined,
+    };
+}
+/** Newest-first page size for `getSignaturesForAddress`. */
+exports.NEWEST_ANCHOR_PAGE_LIMIT = 25;
+/** Full pages walked before a missing memo is `newest_anchor_unavailable`. */
+exports.NEWEST_ANCHOR_PAGE_CAP = 8;
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function asSafeInt(value) {
+    if (typeof value === 'number')
+        return Number.isSafeInteger(value) ? value : null;
+    if (typeof value === 'string' && /^(0|[1-9]\d*)$/.test(value)) {
+        const parsed = Number(value);
+        return Number.isSafeInteger(parsed) ? parsed : null;
+    }
+    return null;
+}
+/**
+ * Pending is a leaf past the anchored head. An index inside that head is
+ * `pending_leaf_in_head`. Any other broken bound is `pending_bounds`.
+ * `live_tree_size` is checked only when the inclusion names it.
+ */
+function pendingGeometryReason(inclusion) {
+    const size = asSafeInt(inclusion?.tree_size);
+    const index = asSafeInt(inclusion?.leaf_index);
+    if (size == null || index == null || size < 1)
+        return 'pending_bounds';
+    if (index < size)
+        return 'pending_leaf_in_head';
+    const liveRaw = inclusion?.live_tree_size;
+    if (liveRaw != null) {
+        const live = asSafeInt(liveRaw);
+        if (live == null || size >= live || index >= live)
+            return 'pending_bounds';
+    }
+    return null;
+}
+/**
+ * Newest chit402 root memo paid by this fee payer. `getSignaturesForAddress`
+ * is newest-first and includes transactions that only mention the address.
+ * A memo whose fee payer is anyone else is ignored and is not newer.
+ * Pages use `before` until the first memo this payer actually paid. A listed
+ * signature whose transaction is null or whose fetch throws fails the scan.
+ * Walking `NEWEST_ANCHOR_PAGE_CAP` full pages without such a memo fails the scan.
+ * A short page with no memo from this payer means this payer has no anchor.
+ */
+async function fetchNewestSolanaAnchorRoot(feePayer, rpcUrl, fetchTx) {
+    const load = fetchTx || ((signature, url) => (0, solana_payer_js_1.fetchSolanaTransaction)(signature, url));
+    let before;
+    for (let page = 0; page < exports.NEWEST_ANCHOR_PAGE_CAP; page += 1) {
+        const query = { limit: exports.NEWEST_ANCHOR_PAGE_LIMIT };
+        if (before)
+            query.before = before;
+        const listed = await defaultRpc(rpcUrl, 'getSignaturesForAddress', [feePayer, query]);
+        if (!Array.isArray(listed))
+            throw new Error('newest_anchor_unavailable');
+        if (listed.length === 0)
+            return null;
+        for (const row of listed) {
+            if (!row || typeof row !== 'object')
+                continue;
+            const record = row;
+            if (record.err)
+                continue;
+            if (typeof record.signature !== 'string' || record.signature.length === 0)
+                continue;
+            let tx;
+            try {
+                tx = await load(record.signature, rpcUrl);
+            }
+            catch {
+                throw new Error('newest_anchor_unavailable');
+            }
+            if (!tx)
+                throw new Error('newest_anchor_unavailable');
+            if (solanaFeePayer(tx) !== feePayer)
+                continue;
+            for (const memo of extractMemos(tx)) {
+                const parsed = parseAnchorMemo(memo);
+                if (!parsed?.root)
+                    continue;
+                const rowSlot = finiteNumber(record.slot);
+                return {
+                    root: parsed.root,
+                    signature: record.signature,
+                    slot: rowSlot != null ? rowSlot : finiteNumber(tx.slot),
+                    blockTime: finiteNumber(record.blockTime),
+                };
+            }
+        }
+        if (listed.length < exports.NEWEST_ANCHOR_PAGE_LIMIT)
+            return null;
+        const tail = listed[listed.length - 1];
+        if (typeof tail?.signature !== 'string' || tail.signature.length === 0) {
+            throw new Error('newest_anchor_unavailable');
+        }
+        if (page + 1 === exports.NEWEST_ANCHOR_PAGE_CAP)
+            throw new Error('newest_anchor_unavailable');
+        before = tail.signature;
+    }
+    throw new Error('newest_anchor_unavailable');
+}
+/** Fee payer is the first account. A parsed key that is explicitly not a signer does not count. */
+function solanaFeePayer(tx) {
+    const keys = tx?.transaction?.message?.accountKeys || [];
+    if (!keys.length)
+        return null;
+    const first = keys[0];
+    if (typeof first === 'string')
+        return first;
+    if (first?.signer === false)
+        return null;
+    return first?.pubkey || null;
+}
+function rowHashFrom(receipt, inclusion) {
+    const bound = (0, row_hash_js_1.boundRowHash)(receipt, inclusion);
+    if (!bound.ok)
+        return { reason: 'row_hash_mismatch' };
+    if (bound.row == null || bound.row === '')
+        return null;
+    const fromReceipt = typeof receipt.row_hash === 'string' || typeof receipt.book_chain?.row_hash === 'string';
+    return { rowHash: bound.row, source: fromReceipt ? 'receipt' : 'inclusion' };
+}
+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) : '';
+    const inclusionError = input.inclusion?.error;
+    const pendingLeaf = input.inclusion?.status === 'pending_anchor';
+    if (pendingLeaf) {
+        if (!taskId)
+            inclusionReason = 'missing_task_id';
+        else if (input.inclusion?.task_id && String(input.inclusion.task_id) !== taskId)
+            inclusionReason = 'task_mismatch';
+        else if (!root)
+            inclusionReason = 'bad_root';
+        else if (inclusionRoot && inclusionRoot !== root)
+            inclusionReason = 'root_mismatch';
+        else if (input.head.tree_size != null && input.inclusion.tree_size != null
+            && Number(input.head.tree_size) !== Number(input.inclusion.tree_size)) {
+            inclusionReason = 'tree_size_mismatch';
+        }
+        else
+            inclusionReason = pendingGeometryReason(input.inclusion) || 'pending_anchor';
+    }
+    else if (inclusionError === 'not_in_tree') {
+        inclusionReason = 'not_in_tree';
+    }
+    else 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 && 'reason' in row) {
+            inclusionReason = row.reason;
+        }
+        else 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 {
+            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 (!(pendingLeaf && inclusionReason === 'pending_anchor') && !inclusionValid && inclusionReason) {
+        errors.push(inclusionReason);
+    }
+    let epochReason;
+    if (input.head?.epoch == null) {
+        const link = (0, epoch_js_1.verifyEpochLink)(input.head, null);
+        if (!link.ok)
+            epochReason = link.reason || 'epoch_missing';
+    }
+    const needsEpoch = input.head?.epoch != null || input.epochRecord != null;
+    if (!epochReason && needsEpoch) {
+        if (!input.epochRecord)
+            epochReason = 'epoch_record_missing';
+        else {
+            const checked = (0, epoch_js_1.verifyEpochRecord)(input.epochRecord, { verifySignature: input.verifyEpochSignature });
+            if (!checked.ok)
+                epochReason = checked.reason || 'epoch_record';
+            else if (input.head?.epoch != null && Number(input.head.epoch) > 1) {
+                const prev = (input.epochRecord.epochs || []).find((row) => Number(row.epoch) === Number(input.head.epoch) - 1);
+                const link = (0, epoch_js_1.verifyEpochLink)(input.head, prev ? {
+                    root: prev.final_root || prev.opening_root || null,
+                    tree_size: prev.final_size ?? prev.opening_size ?? null,
+                } : null);
+                if (!link.ok)
+                    epochReason = link.reason || 'epoch_link';
+            }
+            else if (input.head) {
+                const link = (0, epoch_js_1.verifyEpochLink)(input.head, null);
+                if (!link.ok)
+                    epochReason = link.reason || 'epoch_link';
+            }
+        }
+    }
+    if (epochReason)
+        errors.push(epochReason);
+    const headTrust = (0, anchor_trust_js_1.verifyTreeHeadTrust)(input.head, {
+        jwks: input.jwks,
+        trustedKids: input.trustedKids,
+        issuerHistory: input.issuerHistory ?? null,
+        strictIssuerHistory: input.strictIssuerHistory === true,
+    });
+    if (!headTrust.ok && headTrust.reason)
+        errors.push(headTrust.reason);
+    const legacyHead = headTrust.ok && (0, anchor_trust_js_1.headOmitsPinnedSigner)(headTrust.payload);
+    if (legacyHead)
+        errors.push(anchor_trust_js_1.LEGACY_HEAD_UNPINNED_SIGNER);
+    let publishedWallets = null;
+    if (input.anchorWalletDocument) {
+        const listed = (0, anchor_trust_js_1.verifyAnchorWalletDocument)(input.anchorWalletDocument, {
+            jwks: input.jwks,
+            trustedKids: input.trustedKids,
+        });
+        if (!listed.ok)
+            errors.push(listed.reason);
+        else
+            publishedWallets = { base: listed.base, solana: listed.solana };
+    }
+    const walletList = (0, anchor_trust_js_1.compileAnchorWallets)({
+        jwks: input.jwks,
+        trustedKids: input.trustedKids,
+        issuerHistory: headTrust.ok ? (input.issuerHistory ?? null) : null,
+        published: publishedWallets,
+    });
+    const anchorWalletsInvalid = errors.includes('anchor_wallets_invalid');
+    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,
+        fee_payer: input.head?.anchors?.solana?.fee_payer ?? 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,
+        from: input.head?.anchors?.base?.from ?? null,
+        reason: undefined,
+    };
+    const signedFrom = input.head?.anchors?.base?.from || null;
+    const signedPayer = input.head?.anchors?.solana?.fee_payer || null;
+    let walletFailed = anchorWalletsInvalid;
+    if (signedFrom && !(0, anchor_trust_js_1.walletListed)(walletList.base, signedFrom, 'base')) {
+        walletFailed = true;
+        errors.push('anchor_sender_unlisted');
+    }
+    if (signedPayer && !(0, anchor_trust_js_1.walletListed)(walletList.solana, signedPayer, 'solana')) {
+        walletFailed = true;
+        errors.push('fee_payer_unlisted');
+    }
+    const claimsAnchored = input.inclusion?.status === 'anchored' || input.inclusion?.anchor_status === 'anchored';
+    const headHasAnchor = Boolean(solanaSignature(input.head) || baseTxHash(input.head));
+    if (!headHasAnchor && (claimsAnchored || (pendingLeaf && inclusionReason === 'pending_anchor'))) {
+        errors.push('head_not_anchored');
+    }
+    if (pendingLeaf && inclusionReason === 'pending_anchor') {
+        solana.reason = 'pending_anchor';
+        base.reason = 'pending_anchor';
+    }
+    else if (!inclusionValid) {
+        solana.reason = 'inclusion_failed';
+        base.reason = 'inclusion_failed';
+    }
+    else if (!headTrust.ok || walletFailed) {
+        const reason = !headTrust.ok
+            ? (headTrust.reason || 'head_signature_invalid')
+            : (errors.find((code) => code.startsWith('anchor_') || code.startsWith('fee_payer')) || 'anchor_wallets_invalid');
+        solana.reason = solana.fee_payer && errors.includes('fee_payer_unlisted') ? 'fee_payer_unlisted' : reason;
+        base.reason = base.from && errors.includes('anchor_sender_unlisted') ? 'anchor_sender_unlisted' : reason;
+    }
+    else if (legacyHead) {
+        solana.reason = anchor_trust_js_1.LEGACY_HEAD_UNPINNED_SIGNER;
+        base.reason = anchor_trust_js_1.LEGACY_HEAD_UNPINNED_SIGNER;
+    }
+    else {
+        if (!signature) {
+            solana.reason = 'pending';
+            errors.push('solana_pending');
+        }
+        else if (!signedPayer) {
+            solana.reason = 'fee_payer_missing';
+            errors.push('fee_payer_missing');
+        }
+        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';
+                    }
+                    const payer = solanaFeePayer(tx);
+                    if (!solana.reason && payer !== signedPayer) {
+                        solana.reason = 'fee_payer_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 if (!signedFrom) {
+            base.reason = 'anchor_sender_missing';
+            errors.push('anchor_sender_missing');
+        }
+        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 if (!tx.from || !(0, anchor_trust_js_1.sameBaseAddress)(tx.from, signedFrom))
+                        base.reason = 'sender_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}`);
+        }
+    }
+    const pinInput = input.issuerPin || {};
+    const issuerPin = (0, issuer_pin_js_1.assessIssuerPin)({
+        ...pinInput,
+        receipt: pinInput.receipt ?? input.receipt,
+        head: pinInput.head ?? input.head,
+        required: pinInput.required === true || input.issuerPin != null,
+    });
+    if (issuerPin.checked && !issuerPin.ok && issuerPin.code)
+        errors.push(issuerPin.code);
+    const pinFailed = issuerPin.checked && !issuerPin.ok;
+    let staleReason;
+    const claimsAnchor = Boolean(solanaSignature(input.head) || baseTxHash(input.head));
+    if (input.checkNewestAnchor === true && claimsAnchor) {
+        const payerOnList = Boolean(signedPayer && (0, anchor_trust_js_1.walletListed)(walletList.solana, signedPayer, 'solana'));
+        if (!signedPayer || !root || !payerOnList) {
+            staleReason = 'newest_anchor_unavailable';
+        }
+        else {
+            try {
+                const found = input.fetchNewestAnchor
+                    ? await input.fetchNewestAnchor(signedPayer, solanaRpc)
+                    : await fetchNewestSolanaAnchorRoot(signedPayer, solanaRpc, input.fetchSolanaTx);
+                if (!found?.root)
+                    staleReason = 'newest_anchor_unavailable';
+                else if (found.root !== root)
+                    staleReason = 'stale_head';
+            }
+            catch {
+                staleReason = 'newest_anchor_unavailable';
+            }
+        }
+        if (staleReason)
+            errors.push(staleReason);
+    }
+    let overall;
+    const anchorSideFailed = (solana.reason && solana.reason !== 'pending' && solana.reason !== 'pending_anchor')
+        || (base.reason && base.reason !== 'pending' && base.reason !== 'pending_anchor');
+    const pendingOk = pendingLeaf
+        && inclusionReason === 'pending_anchor'
+        && headTrust.ok
+        && !walletFailed
+        && !legacyHead
+        && !epochReason
+        && !staleReason
+        && !pinFailed
+        && headHasAnchor
+        && !errors.includes('head_not_anchored');
+    // A receipt that is not a leaf, and has no other anchor failure, is
+    // NOT_IN_LOG. Pre-log payments such as chit-1ebc5616 are this case.
+    // A pin downgrade or a bad head stays failed. The book row is not rewritten.
+    const chainAsideFromInclusion = (reason) => Boolean(reason && reason !== 'pending' && reason !== 'pending_anchor' && reason !== 'inclusion_failed');
+    const otherAnchorFailure = Boolean(epochReason)
+        || !headTrust.ok
+        || walletFailed
+        || legacyHead
+        || chainAsideFromInclusion(solana.reason)
+        || chainAsideFromInclusion(base.reason)
+        || Boolean(staleReason)
+        || errors.includes('head_not_anchored')
+        || pinFailed;
+    if (inclusionReason === 'not_in_tree' && !otherAnchorFailure)
+        overall = 'not_in_log';
+    else if (pendingOk)
+        overall = 'pending';
+    else if (!inclusionValid
+        || epochReason
+        || !headTrust.ok
+        || walletFailed
+        || legacyHead
+        || anchorSideFailed
+        || staleReason
+        || errors.includes('head_not_anchored')
+        || (solana.checked && !solana.valid)
+        || (base.checked && !base.valid)
+        || pinFailed)
+        overall = 'failed';
+    else if (solana.valid && base.valid)
+        overall = 'verified';
+    else
+        overall = 'partial';
+    let unloggedReason;
+    if (!inclusionValid && !epochReason) {
+        const listed = (0, epoch_js_1.unloggedReasonForTask)(input.epochRecord, taskId);
+        if (listed)
+            unloggedReason = listed.reason;
+    }
+    return {
+        overall,
+        root,
+        inclusion: {
+            valid: inclusionValid,
+            leaf: leafHex,
+            leaf_source: leafSource,
+            reason: inclusionReason,
+            ...(unloggedReason ? { unlogged_reason: unloggedReason } : {}),
+            ...(input.inclusion?.anchored_tree_size != null ? { anchored_tree_size: input.inclusion.anchored_tree_size } : {}),
+            ...(input.inclusion?.live_tree_size != null ? { live_tree_size: input.inclusion.live_tree_size } : {}),
+        },
+        solana,
+        base,
+        head_signature: {
+            checked: Boolean(input.head?.issuer_signature?.jws) || !headTrust.ok,
+            valid: headTrust.ok,
+            kid: headTrust.kid,
+            trust: headTrust.trust,
+            reason: headTrust.reason || undefined,
+            message: headTrust.message || undefined,
+        },
+        anchor_wallets: {
+            base_from: signedFrom,
+            solana_fee_payer: signedPayer,
+            sources: walletList.sources,
+            not_consulted: walletList.not_consulted,
+        },
+        proves: overall === 'pending'
+            ? ['This leaf is past the anchored tree size. It waits for the next anchor.']
+            : exports.ANCHOR_PROVES,
+        does_not_prove: doesNotProve,
+        errors,
+        issuer_pin: issuerPin,
+    };
+}
+//# sourceMappingURL=anchor-witness.js.map