@bsv/dpp-core 0.3.0-beta.1

package/dist/evidence.js

@@ -0,0 +1,716 @@
+import { Hash, LockingScript, Utils } from '@bsv/sdk';
+import { inspectAttestationAnchor } from './anchor.js';
+import { LIFECYCLE_MEDIA_TYPE, LIFECYCLE_REPRESENTATION, lifecycleClaimDigest, verifyLifecycleClaim, } from './attestation.js';
+import { didKeyFromIdentityKey } from './did.js';
+import { inspectChain } from './verifyChain.js';
+import { verifyPolicyChain } from './publisherPolicy.js';
+import { bindAcceptanceToState, inspectManagedAcceptance } from './acceptance.js';
+/**
+ * The one verification contract (`spec/verification.md`): sixteen named checks,
+ * four answers each, an independently expected subject and an observation of
+ * the latest state that is never a proof. `verifyChain` stays the verifier of
+ * supplied history; this is the report every surface produces from it and
+ * from the attestation, anchor and credential rails beside it.
+ *
+ * The core is dependency-light, so the pieces that need a proof suite, a
+ * status list or an authority registry arrive through the policy as
+ * functions. A caller that supplies none gets `unknown` on those checks, with
+ * a reason that says why, which is the contract's whole point: nothing is
+ * passed because it was not looked at.
+ */
+export const REPORT_VERSION = '1';
+export const EVIDENCE_CHECK_NAMES = [
+    'recordEncoding',
+    'actorSignatures',
+    'publisherSignatures',
+    'linkage',
+    'inclusion',
+    'nativeAttestationSignature',
+    'anchorSignature',
+    'anchorKeyDerivation',
+    'anchorDigestAndMetadataBinding',
+    'externalCredentialProof',
+    'subjectBinding',
+    'issuerAuthority',
+    'schema',
+    'credentialTime',
+    'credentialStatus',
+    'evidenceAvailability',
+];
+const outpointRef = (o) => `${o.txid}:${o.outputIndex}`;
+const digestRef = (hex) => `sha256:${hex}`;
+const sameOutpoint = (a, b) => a.txid === b.txid && a.outputIndex === b.outputIndex;
+function toBytes(value) {
+    return typeof value === 'string' ? Utils.toArray(value, 'utf8') : value;
+}
+function check(name, status, reasonCode, evidenceRefs = [], extra = {}) {
+    return { name, status, ...(reasonCode == null ? {} : { reasonCode }), evidenceRefs, ...extra };
+}
+/** Combine several partial answers into one: a failure outranks an unknown, an unknown outranks a pass. */
+function combine(name, parts, empty) {
+    if (parts.length === 0)
+        return empty;
+    const refs = [...new Set(parts.flatMap((p) => p.evidenceRefs ?? []))];
+    const details = parts.map((p) => p.detail).filter((d) => d !== undefined);
+    const pick = (status) => parts.find((p) => p.status === status);
+    const worst = pick('fail') ?? pick('unknown') ?? (parts.every((p) => p.status === 'not-applicable') ? pick('not-applicable') : undefined);
+    if (worst != null) {
+        return check(name, worst.status, worst.reasonCode ?? 'x-unspecified', refs, details.length > 0 ? { detail: details } : {});
+    }
+    return check(name, 'pass', undefined, refs, details.length > 0 ? { detail: details } : {});
+}
+function tokenChecks(txs, inspection, policy) {
+    const names = ['recordEncoding', 'actorSignatures', 'publisherSignatures', 'linkage', 'inclusion'];
+    const publisherSelected = (policy.publisherKeys ?? []).length > 0 || policy.publisherPolicy != null;
+    if (txs == null || txs.length === 0 || inspection == null) {
+        return {
+            tip: null,
+            checks: names.map((n) => n === 'publisherSignatures' && !publisherSelected
+                ? check(n, 'not-applicable', 'publisher-not-selected')
+                : check(n, 'unknown', 'no-evidence')),
+        };
+    }
+    const states = inspection.states;
+    const refs = states.map((s) => outpointRef({ txid: s.txid, outputIndex: s.outputIndex }));
+    const perState = states.map((s) => ({
+        index: s.index,
+        txid: s.txid,
+        version: s.version,
+        op: s.op,
+        userSignatureValid: s.userSignatureValid,
+        serverSignatureValid: s.serverSignatureValid,
+        linkageValid: s.linkageValid,
+        ownerConsentValid: s.ownerConsentValid,
+        controlValid: s.controlValid,
+        spv: s.spv,
+        ...(s.spvReason == null ? {} : { spvReason: s.spvReason }),
+    }));
+    const failure = inspection.failure;
+    // The inspection evaluates every check on a state before stopping at it, so
+    // the states nobody looked at are the ones after the failing index; a
+    // transaction that yielded no state was looked at and could not be checked.
+    const inspectedCount = failure?.kind === 'encoding' ? failure.index + 1 : states.length;
+    const uninspected = inspectedCount < txs.length;
+    /** A check that held on every inspected state: pass when every supplied state was inspected, otherwise unknown. */
+    const heldOrNotInspected = (name) => failure?.kind === 'encoding'
+        ? check(name, 'unknown', 'decode-failed', refs, { detail: perState, scope: { stateIndex: failure.index } })
+        : uninspected
+            ? check(name, 'unknown', 'not-inspected', refs, { detail: perState, scope: failure == null ? {} : { stateIndex: failure.index } })
+            : check(name, 'pass', undefined, refs, { detail: perState });
+    const encoding = failure?.kind === 'encoding'
+        ? check('recordEncoding', 'fail', 'decode-failed', [...refs, failure.txid], { scope: { stateIndex: failure.index }, detail: failure.message })
+        : heldOrNotInspected('recordEncoding');
+    const actor = failure?.kind === 'userSignature'
+        ? check('actorSignatures', 'fail', 'signature-invalid', refs, { scope: { stateIndex: failure.index }, detail: perState })
+        : heldOrNotInspected('actorSignatures');
+    const publisher = !publisherSelected
+        ? check('publisherSignatures', 'not-applicable', 'publisher-not-selected', [])
+        : failure?.kind === 'serverSignature'
+            ? check('publisherSignatures', 'fail', states[failure.index]?.publisherOutsideWindow ? 'publisher-not-authorised' : 'signature-invalid', refs, { scope: { stateIndex: failure.index }, detail: perState })
+            : heldOrNotInspected('publisherSignatures');
+    const linkage = failure?.kind === 'linkage'
+        ? check('linkage', 'fail', linkageReasonCode(failure.message), refs, { scope: { stateIndex: failure.index }, detail: failure.message })
+        : failure?.kind === 'consent'
+            ? check('linkage', 'fail', failure.message.includes('authorisation_commitment') ? 'acceptance-commitment-absent' : 'consent-not-proven', refs, { scope: { stateIndex: failure.index }, detail: failure.message })
+            : heldOrNotInspected('linkage');
+    let inclusion;
+    if (failure?.kind === 'inclusion') {
+        inclusion = check('inclusion', 'fail', 'proof-refuted', refs, { scope: { stateIndex: failure.index }, detail: failure.message });
+    }
+    else if (failure?.kind === 'encoding') {
+        inclusion = check('inclusion', 'unknown', 'decode-failed', refs, { scope: { stateIndex: failure.index }, detail: perState });
+    }
+    else if (uninspected) {
+        inclusion = check('inclusion', 'unknown', 'not-inspected', refs, { detail: perState });
+    }
+    else if (states.some((s) => s.spvReason === 'header-source-unavailable')) {
+        inclusion = check('inclusion', 'unknown', 'header-source-unavailable', refs, { detail: inspection.spvUnavailable ?? perState });
+    }
+    else if (states.some((s) => s.spvReason === 'no-proof')) {
+        inclusion = check('inclusion', 'unknown', 'proof-absent', refs, { detail: perState });
+    }
+    else if (states.some((s) => s.spvReason === 'header-check-disabled')) {
+        inclusion = check('inclusion', 'unknown', 'not-selected', refs, { detail: perState });
+    }
+    else {
+        inclusion = check('inclusion', 'pass', undefined, refs, { detail: perState });
+    }
+    const last = states.at(-1);
+    return {
+        inspection,
+        tip: last == null ? null : { txid: last.txid, outputIndex: last.outputIndex },
+        genesis: states[0],
+        checks: [encoding, actor, publisher, linkage, inclusion],
+    };
+}
+/**
+ * Which shared reason code a linkage failure carries. The message is the
+ * verifier's own sentence (`transition.ts`, `owner.ts`); the code is the
+ * contract's word for the rule it names, so a consumer branches on the code
+ * and a person reads the sentence.
+ */
+function linkageReasonCode(message) {
+    if (message.includes('retired'))
+        return 'lineage-retired';
+    if (message.includes('control_linkage') || message.includes('not the controller'))
+        return 'control-not-proven';
+    if (message.includes('version 1') || message.includes('version 2') || message.includes('upgrade transition'))
+        return 'version-transition-invalid';
+    return 'link-broken';
+}
+function inspectNativeClaims(claims) {
+    const findings = { claims: [], invalid: [] };
+    for (const [index, value] of (claims ?? []).entries()) {
+        // Subject binding is its own check; the signature check must not fail a
+        // claim for naming another product, so no expectation is passed here.
+        const result = verifyLifecycleClaim(value);
+        if (result.signature !== 'verified') {
+            findings.invalid.push({ index, reason: result.reason ?? 'native claim signature does not verify' });
+            continue;
+        }
+        const claim = value;
+        const digest = lifecycleClaimDigest(claim);
+        findings.claims.push({ claim, digest, issuerKey: result.issuerKey, ref: digestRef(digest) });
+    }
+    return findings;
+}
+function inspectAnchors(anchors) {
+    return (anchors ?? []).map((anchor, index) => {
+        // A script that is not even hex is evidence that fails, not an exception:
+        // the finding carries the reason and the report stays a report.
+        let script;
+        let parseFailure;
+        try {
+            script = typeof anchor.lockingScript === 'string' ? LockingScript.fromHex(anchor.lockingScript) : anchor.lockingScript;
+        }
+        catch {
+            parseFailure = 'lockingScript is not hex';
+        }
+        const inspection = script == null
+            ? { metadata: undefined, keyDerivationValid: null, signatureValid: null, failure: parseFailure }
+            : inspectAttestationAnchor(script);
+        const ref = anchor.txid != null && anchor.outputIndex != null ? outpointRef({ txid: anchor.txid, outputIndex: anchor.outputIndex }) : `anchor:${index}`;
+        return {
+            index,
+            ref,
+            metadata: inspection.metadata,
+            keyDerivationValid: inspection.keyDerivationValid,
+            signatureValid: inspection.signatureValid,
+            failure: inspection.failure,
+            ...(anchor.securedBytes == null ? {} : { securedBytes: toBytes(anchor.securedBytes) }),
+        };
+    });
+}
+function observe(policy, passportId, tip, alternativeTips, checkedAt) {
+    const observers = policy.observers ?? [];
+    return Promise.all(observers.map(async (observer) => {
+        try {
+            const answer = await observer.observe({ passportId, tip });
+            return {
+                id: observer.id,
+                kind: observer.kind,
+                observedAt: checkedAt,
+                result: answer.result,
+                ...(answer.height == null ? {} : { height: answer.height }),
+                ...(answer.blockHash == null ? {} : { blockHash: answer.blockHash }),
+                ...(answer.spendingTxid == null ? {} : { spendingTxid: answer.spendingTxid }),
+                ...(answer.detail == null ? {} : { detail: answer.detail }),
+                candidateOutpoints: answer.candidateOutpoints ?? [],
+            };
+        }
+        catch (cause) {
+            return {
+                id: observer.id,
+                kind: observer.kind,
+                observedAt: checkedAt,
+                result: 'unavailable',
+                detail: cause instanceof Error ? cause.message : String(cause),
+                candidateOutpoints: [],
+            };
+        }
+    })).then((answers) => {
+        const candidates = [];
+        const add = (o) => {
+            if (!candidates.some((c) => sameOutpoint(c, o)))
+                candidates.push(o);
+        };
+        if (tip != null)
+            add(tip);
+        alternativeTips.forEach(add);
+        answers.forEach((a) => a.candidateOutpoints.forEach(add));
+        const answered = answers.filter((a) => a.result !== 'unavailable');
+        let latestState;
+        if (alternativeTips.length > 0 || answers.some((a) => a.result === 'conflicting'))
+            latestState = 'conflicting';
+        else if (answered.length === 0)
+            latestState = 'unknown';
+        else if (answered.some((a) => a.result === 'spent')) {
+            latestState = answered.every((a) => a.result === 'spent') ? 'superseded' : 'conflicting';
+        }
+        else if (answered.every((a) => a.result === 'unspent'))
+            latestState = 'observed';
+        else
+            latestState = 'conflicting';
+        return {
+            latestState,
+            sources: answers.map(({ candidateOutpoints: _c, ...source }) => source),
+            queryScope: observers.length === 0 ? 'no source asked' : `${observers.map((o) => `${o.kind} ${o.id}`).join(', ')} asked for ${passportId}`,
+            observedAt: checkedAt,
+            candidateOutpoints: candidates,
+        };
+    });
+}
+/**
+ * Evaluate the evidence for one passport and report it as `spec/verification.md`
+ * requires. Never throws for evidence that fails: every failure is a check with
+ * a reason. It throws only for a caller error, such as a malformed policy key.
+ */
+export async function verifyPassportEvidence(evidence, expected, policy = {}) {
+    const checkedAt = policy.checkedAt ?? new Date().toISOString();
+    const policyId = policy.policyId ?? 'none';
+    const limits = [
+        'Supplied-history validity does not establish current ownership, an authorised genesis or the absence of later states.',
+        'An anchor establishes its anchoring service\'s commitment to bytes, not the truth of the claim those bytes carry.',
+    ];
+    // The publisher policy is verified before any key in it is trusted. A chain
+    // that does not hold selects the check (the caller asked for it) and leaves
+    // it unknown: no key is trusted, and none is called a stranger either.
+    const policyChain = policy.publisherPolicy == null ? undefined : verifyPolicyChain(policy.publisherPolicy.chain, policy.publisherPolicy.operatorIdentityKeys);
+    const verifiedPolicyChain = policyChain?.ok === true ? policy.publisherPolicy.chain : undefined;
+    const policyFailure = policyChain != null && !policyChain.ok ? policyChain.failure : undefined;
+    // The token rail, and the alternative histories that make a genesis ambiguous.
+    const txs = evidence.tokenHistory;
+    const chainOptions = {
+        chainTracker: policy.chainTracker,
+        publisherKeys: policy.publisherKeys,
+        publisherPolicy: verifiedPolicyChain,
+        ownerConsent: policy.ownerConsent,
+        ...(policy.controlAuthorities == null ? {} : { controlAuthorities: policy.controlAuthorities }),
+        managedAcceptance: policy.managedAcceptance?.required === true,
+    };
+    const inspection = txs != null && txs.length > 0 ? await inspectChain(txs, chainOptions) : undefined;
+    const token = tokenChecks(txs, inspection, policy);
+    if (policyFailure != null) {
+        const at = token.checks.findIndex((c) => c.name === 'publisherSignatures');
+        if (at >= 0)
+            token.checks[at] = check('publisherSignatures', 'unknown', 'publisher-policy-invalid', [], { detail: `publisher policy version ${policyFailure.version}: ${policyFailure.reason}, ${policyFailure.detail}` });
+    }
+    const alternatives = [];
+    for (const history of evidence.alternativeHistories ?? []) {
+        if (history.length === 0)
+            continue;
+        const alt = await inspectChain(history, chainOptions);
+        const last = alt.states.at(-1);
+        alternatives.push({ inspection: alt, tip: last == null ? null : { txid: last.txid, outputIndex: last.outputIndex } });
+    }
+    const validAlternatives = alternatives.filter((a) => a.inspection.complete && a.inspection.states[0]?.state.passportId === expected.passportId);
+    // A valid alternative that shares this history's genesis is a fork, two
+    // successors of one state, which accepted-chain spending decides and this
+    // report only names; one with another genesis is a rival claim to the
+    // identifier, which an authority policy decides. The two are told apart
+    // because they mean different things and get different words.
+    const genesisTxid = token.genesis?.txid;
+    const forks = validAlternatives.filter((a) => genesisTxid != null && a.inspection.states[0]?.txid === genesisTxid);
+    const rivalGenesis = validAlternatives.filter((a) => !forks.includes(a));
+    // The attestation and anchor rails.
+    const native = inspectNativeClaims(evidence.nativeClaims);
+    const anchors = inspectAnchors(evidence.anchors);
+    const nativeRefs = native.claims.map((c) => c.ref);
+    const nativeAttestationSignature = (evidence.nativeClaims ?? []).length === 0
+        ? check('nativeAttestationSignature', 'unknown', 'no-evidence')
+        : native.invalid.length > 0
+            ? check('nativeAttestationSignature', 'fail', 'signature-invalid', nativeRefs, { detail: native.invalid })
+            : check('nativeAttestationSignature', 'pass', undefined, nativeRefs);
+    const anchorRefs = anchors.map((a) => a.ref);
+    const anchorSignature = anchors.length === 0
+        ? check('anchorSignature', 'unknown', 'no-evidence')
+        : anchors.some((a) => a.metadata == null)
+            ? check('anchorSignature', 'fail', 'decode-failed', anchorRefs, { detail: anchors.filter((a) => a.metadata == null).map((a) => ({ ref: a.ref, failure: a.failure })) })
+            : anchors.some((a) => a.signatureValid !== true)
+                ? check('anchorSignature', 'fail', 'signature-invalid', anchorRefs, { detail: anchors.filter((a) => a.signatureValid !== true).map((a) => a.ref) })
+                : check('anchorSignature', 'pass', undefined, anchorRefs);
+    const anchorKeyDerivation = anchors.length === 0
+        ? check('anchorKeyDerivation', 'unknown', 'no-evidence')
+        : anchors.some((a) => a.metadata == null)
+            ? check('anchorKeyDerivation', 'unknown', 'decode-failed', anchorRefs)
+            : anchors.some((a) => a.keyDerivationValid !== true)
+                ? check('anchorKeyDerivation', 'fail', 'key-derivation-mismatch', anchorRefs, { detail: anchors.filter((a) => a.keyDerivationValid !== true).map((a) => a.ref) })
+                : check('anchorKeyDerivation', 'pass', undefined, anchorRefs);
+    // Secured representations: the bytes an anchor commits to, from the anchor
+    // itself, from a supplied credential, or from a supplied native claim.
+    const externals = (evidence.externalCredentials ?? []).map((c, index) => {
+        const bytes = toBytes(c.bytes);
+        return { index, representation: c.representation, mediaType: c.mediaType, bytes, digest: Utils.toHex(Hash.sha256(bytes)) };
+    });
+    const bytesByDigest = new Map();
+    for (const ext of externals)
+        bytesByDigest.set(ext.digest, { bytes: ext.bytes, representation: ext.representation });
+    for (const anchor of anchors) {
+        if (anchor.securedBytes != null)
+            bytesByDigest.set(Utils.toHex(Hash.sha256(anchor.securedBytes)), { bytes: anchor.securedBytes });
+    }
+    // Credential verification runs once per distinct byte string, and its answers
+    // serve both the anchor binding and the credential checks.
+    const verifications = new Map();
+    const credentialInputs = new Map();
+    for (const ext of externals)
+        credentialInputs.set(ext.digest, { representation: ext.representation, mediaType: ext.mediaType, bytes: ext.bytes });
+    // An anchor that declares an external representation and arrives without
+    // its bytes is a missing input: the proof check is unknown for it, never
+    // not-applicable (spec/verification.md section 4).
+    const proofExtras = [];
+    for (const anchor of anchors) {
+        if (anchor.metadata == null)
+            continue;
+        if (anchor.metadata.representation === LIFECYCLE_REPRESENTATION)
+            continue;
+        if (anchor.securedBytes == null) {
+            proofExtras.push({ status: 'unknown', reasonCode: 'secured-bytes-absent', evidenceRefs: [anchor.ref, digestRef(anchor.metadata.digest)], detail: `anchor ${anchor.ref} declares ${anchor.metadata.representation} and its bytes were not supplied` });
+            continue;
+        }
+        const digest = Utils.toHex(Hash.sha256(anchor.securedBytes));
+        if (!credentialInputs.has(digest))
+            credentialInputs.set(digest, { representation: anchor.metadata.representation, mediaType: anchor.metadata.mediaType, bytes: anchor.securedBytes });
+    }
+    if (policy.credentialVerifier != null) {
+        for (const [digest, input] of credentialInputs) {
+            try {
+                verifications.set(digest, await policy.credentialVerifier({ ...input, digest, checkedAt }));
+            }
+            catch (cause) {
+                const failed = { status: 'unknown', reasonCode: 'verifier-not-supplied', detail: cause instanceof Error ? cause.message : String(cause) };
+                verifications.set(digest, { proof: failed, schema: failed, time: failed, status: failed, authority: failed });
+            }
+        }
+    }
+    const bindingParts = [];
+    const unavailableRefs = [];
+    for (const anchor of anchors) {
+        const meta = anchor.metadata;
+        if (meta == null)
+            continue;
+        const ref = anchor.ref;
+        const scopeRefs = [ref, digestRef(meta.digest)];
+        if (meta.representation === LIFECYCLE_REPRESENTATION) {
+            const claim = native.claims.find((c) => c.digest === meta.digest);
+            const bytes = anchor.securedBytes;
+            if (claim == null && bytes == null) {
+                unavailableRefs.push(digestRef(meta.digest));
+                bindingParts.push({ status: 'unknown', reasonCode: 'secured-bytes-absent', evidenceRefs: scopeRefs });
+                continue;
+            }
+            if (claim == null && bytes != null) {
+                // Bytes supplied for a native anchor must themselves be a signed claim.
+                let parsed;
+                try {
+                    parsed = JSON.parse(Utils.toUTF8(bytes));
+                }
+                catch {
+                    parsed = undefined;
+                }
+                const result = parsed === undefined ? undefined : verifyLifecycleClaim(parsed);
+                if (result?.signature !== 'verified') {
+                    bindingParts.push({ status: 'fail', reasonCode: 'digest-mismatch', evidenceRefs: scopeRefs, detail: 'supplied bytes are not a verified native claim with this digest' });
+                    continue;
+                }
+                const digest = lifecycleClaimDigest(parsed);
+                if (digest !== meta.digest) {
+                    bindingParts.push({ status: 'fail', reasonCode: 'digest-mismatch', evidenceRefs: [...scopeRefs, digestRef(digest)] });
+                    continue;
+                }
+                native.claims.push({ claim: parsed, digest, issuerKey: result.issuerKey, ref: digestRef(digest) });
+            }
+            const bound = native.claims.find((c) => c.digest === meta.digest);
+            const mismatches = [];
+            if (meta.issuer !== bound.claim.issuer)
+                mismatches.push('issuer');
+            if (meta.subject !== bound.claim.passportId)
+                mismatches.push('subject');
+            if (meta.attestationType !== bound.claim.eventType)
+                mismatches.push('attestationType');
+            if (meta.mediaType !== LIFECYCLE_MEDIA_TYPE)
+                mismatches.push('mediaType');
+            bindingParts.push(mismatches.length === 0
+                ? { status: 'pass', evidenceRefs: scopeRefs }
+                : { status: 'fail', reasonCode: 'metadata-mismatch', evidenceRefs: scopeRefs, detail: mismatches });
+            continue;
+        }
+        const supplied = bytesByDigest.get(meta.digest);
+        const bytes = anchor.securedBytes ?? supplied?.bytes;
+        if (bytes == null || bytes.length === 0) {
+            unavailableRefs.push(digestRef(meta.digest));
+            bindingParts.push({ status: 'unknown', reasonCode: 'secured-bytes-absent', evidenceRefs: scopeRefs });
+            continue;
+        }
+        const digest = Utils.toHex(Hash.sha256(bytes));
+        if (digest !== meta.digest) {
+            bindingParts.push({ status: 'fail', reasonCode: 'digest-mismatch', evidenceRefs: [...scopeRefs, digestRef(digest)] });
+            continue;
+        }
+        const verified = verifications.get(digest);
+        if (verified == null) {
+            bindingParts.push({ status: 'unknown', reasonCode: policy.credentialVerifier == null ? 'representation-unsupported' : 'verifier-not-supplied', evidenceRefs: scopeRefs, detail: meta.representation });
+            continue;
+        }
+        if (verified.proof.status !== 'pass') {
+            bindingParts.push({ status: 'unknown', reasonCode: 'referenced-artefact-mismatch', evidenceRefs: scopeRefs, detail: 'the committed credential did not verify, so its metadata cannot be compared' });
+            continue;
+        }
+        const mismatches = [];
+        if (verified.issuer != null && meta.issuer !== verified.issuer)
+            mismatches.push('issuer');
+        if (verified.subjects != null && !verified.subjects.includes(meta.subject))
+            mismatches.push('subject');
+        if (verified.attestationType != null && meta.attestationType !== verified.attestationType)
+            mismatches.push('attestationType');
+        if (verified.id != null && meta.attestationId !== verified.id)
+            mismatches.push('attestationId');
+        bindingParts.push(mismatches.length === 0
+            ? { status: 'pass', evidenceRefs: scopeRefs }
+            : { status: 'fail', reasonCode: 'metadata-mismatch', evidenceRefs: scopeRefs, detail: mismatches });
+    }
+    const anchorDigestAndMetadataBinding = anchors.length === 0
+        ? check('anchorDigestAndMetadataBinding', 'unknown', 'no-evidence')
+        : combine('anchorDigestAndMetadataBinding', bindingParts, check('anchorDigestAndMetadataBinding', 'unknown', 'decode-failed', anchorRefs));
+    // Credential checks: external credentials through the supplied verifier.
+    const credentialParts = (key) => [...credentialInputs.keys()].map((digest) => {
+        const v = verifications.get(digest);
+        if (v == null)
+            return { status: 'unknown', reasonCode: 'verifier-not-supplied', evidenceRefs: [digestRef(digest)] };
+        return { ...v[key], evidenceRefs: [digestRef(digest), ...(v[key].evidenceRefs ?? [])] };
+    });
+    const externalCredentialProof = credentialInputs.size === 0 && proofExtras.length === 0
+        ? check('externalCredentialProof', 'not-applicable', 'no-external-credential')
+        : combine('externalCredentialProof', [...credentialParts('proof'), ...proofExtras], check('externalCredentialProof', 'unknown', 'verifier-not-supplied'));
+    // Subject binding, from an expectation the evidence did not supply.
+    const subjectRefs = [];
+    let subjectBinding;
+    if (expected.source === 'none') {
+        subjectBinding = check('subjectBinding', 'unknown', 'subject-not-independent');
+        limits.push('The subject was taken from the evidence itself, so no check can establish that the evidence concerns the passport the reader asked about.');
+    }
+    else {
+        const problems = [];
+        for (const s of token.inspection?.states ?? []) {
+            subjectRefs.push(outpointRef({ txid: s.txid, outputIndex: s.outputIndex }));
+            if (s.state.passportId !== expected.passportId)
+                problems.push({ reasonCode: 'subject-mismatch', detail: `state ${s.index} names ${s.state.passportId}` });
+        }
+        if (token.genesis != null) {
+            const genesisOutpoint = { txid: token.genesis.txid, outputIndex: token.genesis.outputIndex };
+            if (expected.expectedGenesisOutpoint != null && !sameOutpoint(expected.expectedGenesisOutpoint, genesisOutpoint)) {
+                problems.push({ reasonCode: 'genesis-mismatch', detail: `genesis is ${outpointRef(genesisOutpoint)}, expected ${outpointRef(expected.expectedGenesisOutpoint)}` });
+            }
+            if (expected.expectedIssuer != null) {
+                const actorKey = token.genesis.state.actorIdentityKey;
+                const names = [actorKey, didKeyFromIdentityKey(actorKey)];
+                if (!names.includes(expected.expectedIssuer))
+                    problems.push({ reasonCode: 'issuer-mismatch', detail: `genesis actor is ${names[1]}` });
+            }
+        }
+        if (expected.expectedStateOutpoint != null && token.tip != null && !sameOutpoint(expected.expectedStateOutpoint, token.tip)) {
+            problems.push({ reasonCode: 'state-mismatch', detail: `supplied tip is ${outpointRef(token.tip)}, expected ${outpointRef(expected.expectedStateOutpoint)}` });
+        }
+        for (const c of native.claims) {
+            subjectRefs.push(c.ref);
+            if (c.claim.passportId !== expected.passportId)
+                problems.push({ reasonCode: 'subject-mismatch', detail: `native claim ${c.ref} names ${c.claim.passportId}` });
+            if (expected.expectedIssuer != null && c.claim.issuer !== expected.expectedIssuer && c.claim.issuerKeyDid !== expected.expectedIssuer) {
+                problems.push({ reasonCode: 'issuer-mismatch', detail: `native claim ${c.ref} is issued by ${c.claim.issuer}` });
+            }
+        }
+        for (const a of anchors) {
+            if (a.metadata == null)
+                continue;
+            subjectRefs.push(a.ref);
+            const accepted = [expected.passportId, ...(expected.productIdentifier == null ? [] : [expected.productIdentifier])];
+            if (!accepted.includes(a.metadata.subject))
+                problems.push({ reasonCode: 'subject-mismatch', detail: `anchor ${a.ref} names ${a.metadata.subject}` });
+        }
+        for (const [digest, v] of verifications) {
+            subjectRefs.push(digestRef(digest));
+            const accepted = [expected.passportId, ...(expected.productIdentifier == null ? [] : [expected.productIdentifier])];
+            if (v.subjects != null && !v.subjects.some((s) => accepted.includes(s)))
+                problems.push({ reasonCode: 'subject-mismatch', detail: `credential ${digestRef(digest)} names ${v.subjects.join(', ')}` });
+        }
+        if (rivalGenesis.length > 0 && expected.expectedGenesisOutpoint == null) {
+            problems.push({ reasonCode: 'genesis-ambiguous', detail: `${rivalGenesis.length + 1} valid genesis records carry this passport identifier` });
+        }
+        if (subjectRefs.length === 0)
+            subjectBinding = check('subjectBinding', 'unknown', 'no-evidence');
+        else if (problems.length === 0)
+            subjectBinding = check('subjectBinding', 'pass', undefined, subjectRefs);
+        else {
+            const ambiguous = problems.every((p) => p.reasonCode === 'genesis-ambiguous');
+            subjectBinding = check('subjectBinding', ambiguous ? 'unknown' : 'fail', problems[0].reasonCode, subjectRefs, { detail: problems });
+        }
+    }
+    // Managed acceptance (`spec/managed-custody.md`): every version 2 TRANSFER
+    // that commits to an acceptance record references an artefact. A supplied
+    // record that binds to its TRANSFER makes the reference available; one that
+    // does not is a mismatch; a commitment nobody supplied a record for is an
+    // artefact the verifier could not fetch, never a pass.
+    const acceptanceParts = [];
+    const acceptanceCustodianQuestions = [];
+    const committedTransfers = (token.inspection?.states ?? []).filter((s) => s.state.version === '2' && s.state.op === 'TRANSFER' && s.state.authorisationCommitment !== '');
+    const suppliedAcceptances = (evidence.acceptanceRecords ?? []).map((value, index) => ({ index, value, inspection: inspectManagedAcceptance(value) }));
+    for (const transfer of committedTransfers) {
+        const ref = `acceptance:sha256:${transfer.state.authorisationCommitment}`;
+        const stateRef = outpointRef({ txid: transfer.txid, outputIndex: transfer.outputIndex });
+        const supplied = suppliedAcceptances.find((a) => a.inspection.commitment === transfer.state.authorisationCommitment);
+        if (supplied == null) {
+            acceptanceParts.push({ status: 'unknown', reasonCode: 'referenced-artefact-unavailable', evidenceRefs: [stateRef, ref], detail: `the acceptance record ${stateRef} commits to was not supplied` });
+            continue;
+        }
+        const failures = [...supplied.inspection.failures];
+        if (supplied.inspection.signatureValid === true)
+            failures.push(...bindAcceptanceToState(supplied.value, transfer.state));
+        if (failures.length > 0) {
+            acceptanceParts.push({ status: 'fail', reasonCode: 'referenced-artefact-mismatch', evidenceRefs: [stateRef, ref], detail: failures.map((f) => f.detail) });
+            continue;
+        }
+        acceptanceParts.push({ status: 'pass', evidenceRefs: [stateRef, ref] });
+        acceptanceCustodianQuestions.push({ role: 'acceptance-custodian', identity: supplied.value.custodian, at: supplied.value.acceptance.acceptedAt, ref });
+    }
+    for (const orphan of suppliedAcceptances) {
+        if (committedTransfers.some((t) => t.state.authorisationCommitment === orphan.inspection.commitment))
+            continue;
+        acceptanceParts.push({ status: 'fail', reasonCode: 'referenced-artefact-mismatch', evidenceRefs: [`acceptance:${orphan.index}`], detail: orphan.inspection.commitment == null ? orphan.inspection.failures.map((f) => f.detail) : 'no supplied TRANSFER commits to this acceptance record' });
+    }
+    if (committedTransfers.length > 0) {
+        limits.push('An acceptance commitment binds a transfer to acceptance evidence the custodian retained and signed; it is custody-dependent evidence, not a signature made with a key the recipient controls.');
+    }
+    // Authority, role by role, on the policy's lists or verifier.
+    let issuerAuthority;
+    const authorityRefs = [...subjectRefs];
+    if (policy.authority == null) {
+        issuerAuthority = check('issuerAuthority', 'unknown', 'policy-missing');
+    }
+    else if (!policy.authority.required) {
+        issuerAuthority = check('issuerAuthority', 'not-applicable', 'authority-not-required', [], { detail: policy.authority.reason });
+    }
+    else {
+        const auth = policy.authority;
+        const questions = [];
+        if (token.genesis != null) {
+            questions.push({ role: 'genesis-issuer', identity: token.genesis.state.actorIdentityKey, at: token.genesis.state.timestamp, ref: outpointRef({ txid: token.genesis.txid, outputIndex: token.genesis.outputIndex }) });
+        }
+        for (const c of native.claims)
+            questions.push({ role: 'lifecycle-claimant', identity: c.claim.issuer, at: c.claim.timestamp, ref: c.ref });
+        for (const a of anchors)
+            if (a.metadata != null)
+                questions.push({ role: 'anchoring-service', identity: a.metadata.anchoredBy, ref: a.ref });
+        questions.push(...acceptanceCustodianQuestions);
+        const parts = [];
+        for (const q of questions) {
+            const list = q.role === 'genesis-issuer' ? auth.genesisIssuers : q.role === 'lifecycle-claimant' ? auth.claimIssuers : q.role === 'anchoring-service' ? auth.anchoringServices : auth.acceptanceCustodians;
+            if (list != null) {
+                const names = q.role === 'genesis-issuer' ? [q.identity, didKeyFromIdentityKey(q.identity)] : [q.identity];
+                parts.push(names.some((n) => list.includes(n)) ? { status: 'pass', evidenceRefs: [q.ref, policyId] } : { status: 'fail', reasonCode: 'authority-unconfirmed', evidenceRefs: [q.ref], detail: `${q.role} ${q.identity} is not permitted by ${policyId}` });
+            }
+            else if (auth.verify != null) {
+                try {
+                    parts.push({ ...(await auth.verify(q)), evidenceRefs: [q.ref] });
+                }
+                catch (cause) {
+                    parts.push({ status: 'unknown', reasonCode: 'authority-unavailable', evidenceRefs: [q.ref], detail: cause instanceof Error ? cause.message : String(cause) });
+                }
+            }
+            else {
+                parts.push({ status: 'unknown', reasonCode: 'authority-unconfirmed', evidenceRefs: [q.ref], detail: `${policyId} names no authority for ${q.role}` });
+            }
+        }
+        parts.push(...credentialParts('authority'));
+        issuerAuthority = combine('issuerAuthority', parts, check('issuerAuthority', 'unknown', 'no-evidence', authorityRefs));
+    }
+    // Schema, time and status, across native claims and external credentials.
+    const schemaParts = [];
+    for (const c of native.claims) {
+        if (policy.profileValidator == null)
+            schemaParts.push({ status: 'unknown', reasonCode: 'schema-unavailable', evidenceRefs: [c.ref], detail: `${c.claim.profile}@${c.claim.profile_version}` });
+        else {
+            try {
+                schemaParts.push({ ...(await policy.profileValidator(c.claim)), evidenceRefs: [c.ref] });
+            }
+            catch (cause) {
+                schemaParts.push({ status: 'unknown', reasonCode: 'schema-unavailable', evidenceRefs: [c.ref], detail: cause instanceof Error ? cause.message : String(cause) });
+            }
+        }
+    }
+    schemaParts.push(...credentialParts('schema'));
+    const schema = combine('schema', schemaParts, check('schema', 'unknown', 'no-evidence'));
+    const timeParts = native.claims.map((c) => ({ status: 'pass', evidenceRefs: [c.ref], detail: c.claim.timestamp }));
+    timeParts.push(...credentialParts('time'));
+    const credentialTime = combine('credentialTime', timeParts, check('credentialTime', 'unknown', 'no-evidence'));
+    const statusParts = native.claims.map((c) => ({ status: 'not-applicable', reasonCode: 'format-defines-no-status', evidenceRefs: [c.ref] }));
+    statusParts.push(...credentialParts('status'));
+    const credentialStatus = combine('credentialStatus', statusParts, check('credentialStatus', 'unknown', 'no-evidence'));
+    // Availability of everything the evidence pointed at.
+    const availabilityParts = unavailableRefs.map((ref) => ({ status: 'unknown', reasonCode: 'referenced-artefact-unavailable', evidenceRefs: [ref] }));
+    availabilityParts.push(...acceptanceParts);
+    for (const [digest, v] of verifications)
+        if (v.availability != null)
+            availabilityParts.push({ ...v.availability, evidenceRefs: [digestRef(digest), ...(v.availability.evidenceRefs ?? [])] });
+    const referenced = [...(token.inspection?.states.map((s) => outpointRef({ txid: s.txid, outputIndex: s.outputIndex })) ?? []), ...anchorRefs, ...nativeRefs];
+    const evidenceAvailability = referenced.length === 0 && availabilityParts.length === 0
+        ? check('evidenceAvailability', 'unknown', 'no-evidence')
+        : combine('evidenceAvailability', availabilityParts.length === 0 ? [{ status: 'pass', evidenceRefs: referenced }] : availabilityParts, check('evidenceAvailability', 'pass', undefined, referenced));
+    const observations = await observe(policy, expected.passportId, token.tip, validAlternatives.map((a) => a.tip).filter((t) => t != null), checkedAt);
+    if (observations.latestState !== 'unknown') {
+        limits.push('The latest-state observation is as fresh and as complete as the sources asked; it is not a proof that no later spend exists.');
+    }
+    if (forks.length > 0) {
+        limits.push('Two valid successors of one state were supplied; which continuation is recognised is decided by accepted-chain spending evidence, never by this report or by counting sources.');
+    }
+    if ((token.inspection?.states ?? []).some((s) => s.version === '1')) {
+        limits.push('Version 1 states sign an unframed preimage: their field boundaries are established by field validation and the chain rules, not by the signature alone, and a version 1 TRANSFER proves control only where the owner-signed transfer is selected.');
+    }
+    const checks = [
+        ...token.checks,
+        nativeAttestationSignature,
+        anchorSignature,
+        anchorKeyDerivation,
+        anchorDigestAndMetadataBinding,
+        externalCredentialProof,
+        subjectBinding,
+        issuerAuthority,
+        schema,
+        credentialTime,
+        credentialStatus,
+        evidenceAvailability,
+    ];
+    for (const c of checks) {
+        if (c.status === 'unknown')
+            limits.push(`${c.name} was not established: ${c.reasonCode ?? 'no reason recorded'}.`);
+    }
+    return {
+        reportVersion: REPORT_VERSION,
+        checkedAt,
+        expectedSubject: expected,
+        suppliedTip: token.tip,
+        policyId,
+        checks,
+        observations,
+        limits,
+    };
+}
+/** The short label a surface may show beside a check; the technical name stays in the report. */
+export const EVIDENCE_CHECK_LABELS = {
+    recordEncoding: 'Every entry is a well-formed record',
+    actorSignatures: 'Every entry was signed by whoever wrote it',
+    publisherSignatures: 'Every entry was countersigned by the named publisher',
+    linkage: 'No step is missing from the middle',
+    inclusion: 'Every entry is in a block',
+    nativeAttestationSignature: 'Every lifecycle claim was signed by its issuer',
+    anchorSignature: 'Every anchor was signed by its anchoring service',
+    anchorKeyDerivation: 'Every anchor is locked to the key its service derives',
+    anchorDigestAndMetadataBinding: 'Every anchor commits to the exact bytes and names what they say',
+    externalCredentialProof: 'Every credential verifies under its own proof suite',
+    subjectBinding: 'Everything concerns the passport that was asked about',
+    issuerAuthority: 'Every issuer held the authority the policy requires',
+    schema: 'Every payload matches its declared profile',
+    credentialTime: 'Every credential is within its validity period',
+    credentialStatus: 'No credential is revoked or suspended',
+    evidenceAvailability: 'Everything the evidence points at was available',
+};
+//# sourceMappingURL=evidence.js.map