@xfuel/verify 0.3.1 → 0.3.3

package/dist/anchor-witness.js

@@ -1,13 +1,16 @@
 "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.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
@@ -18,8 +21,11 @@ exports.verifyAnchoredRoot = verifyAnchoredRoot;
  * 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';
@@ -35,15 +41,18 @@ exports.SOLANA_GENESIS = {
 };
 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.',
+    '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();
@@ -58,19 +67,102 @@ 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);
+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 false;
+            return null;
         const sib = Buffer.from(step.hash, 'hex');
-        const next = step.position === 'left' ? nodeHash(sib, hash) : nodeHash(hash, sib);
-        hash = new Uint8Array(next);
+        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 Buffer.from(hash).toString('hex') === String(rootHex).replace(/^0x/, '').toLowerCase();
+    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))
@@ -180,18 +272,132 @@ async function fetchBaseAnchorTransaction(txHash, rpcUrl) {
     return {
         hash: tx.hash,
         input: tx.input,
+        from: tx.from,
         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' };
+/** 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')
@@ -218,7 +424,24 @@ async function verifyAnchoredRoot(input) {
     let inclusionReason;
     const taskId = input.receipt?.task_id ? String(input.receipt.task_id) : '';
     const inclusionError = input.inclusion?.error;
-    if (inclusionError === 'not_in_tree') {
+    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) {
@@ -239,7 +462,10 @@ async function verifyAnchoredRoot(input) {
     else {
         const row = rowHashFrom(input.receipt, input.inclusion);
         let leaf = null;
-        if (row) {
+        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')) {
@@ -247,11 +473,6 @@ async function verifyAnchoredRoot(input) {
                 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';
         }
@@ -262,8 +483,9 @@ async function verifyAnchoredRoot(input) {
                 inclusionReason = 'inclusion_failed';
         }
     }
-    if (!inclusionValid && inclusionReason)
+    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);
@@ -296,6 +518,35 @@ async function verifyAnchoredRoot(input) {
     }
     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;
@@ -307,6 +558,7 @@ async function verifyAnchoredRoot(input) {
         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 = {
@@ -314,17 +566,53 @@ async function verifyAnchoredRoot(input) {
         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,
     };
-    if (!inclusionValid) {
+    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 {
@@ -361,6 +649,10 @@ async function verifyAnchoredRoot(input) {
                     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];
@@ -379,6 +671,10 @@ async function verifyAnchoredRoot(input) {
             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 {
@@ -396,6 +692,8 @@ async function verifyAnchoredRoot(input) {
                     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;
@@ -410,22 +708,111 @@ async function verifyAnchoredRoot(input) {
                 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;
-    if (!inclusionValid || epochReason || (solana.checked && !solana.valid) || (base.checked && !base.valid))
+    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');
+    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 },
+        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,
-        proves: exports.ANCHOR_PROVES,
+        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