@optimystic/db-core 0.13.4 → 0.14.0

package/dist/src/cohort-topic/membership/publisher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher.d.ts","sourceRoot":"","sources":["../../../../src/cohort-topic/membership/publisher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAgC,KAAK,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAE/F,yEAAyE;AACzE,eAAO,MAAM,+BAA+B,QAAa,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,cAAc,GAAG,sBAAsB,CAQvF;AAED,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC9B,+BAA+B;IAC/B,KAAK,EAAE,UAAU,CAAC;IAClB,sCAAsC;IACtC,WAAW,EAAE,UAAU,CAAC;IACxB,iEAAiE;IACjE,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IAC/B,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,eAAe,CAAC,EAAE,UAAU,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IACnC,kEAAkE;IAClE,SAAS,EAAE,UAAU,CAAC;IACtB,0FAA0F;IAC1F,WAAW,EAAE,UAAU,CAAC;IACxB,kFAAkF;IAClF,eAAe,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC;AAED,6CAA6C;AAC7C,MAAM,WAAW,uBAAuB;IACvC;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAAC;IAC3H;;;OAGG;IACH,IAAI,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAAC;CACnH;AAED,MAAM,WAAW,2BAA2B;IAC3C,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,EAAE,sBAAsB,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAwED,2DAA2D;AAC3D,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,2BAA2B,GAAG,uBAAuB,CAExG"}

package/dist/src/cohort-topic/membership/publisher.js

@@ -0,0 +1,107 @@
+/**
+ * Cohort-topic substrate — cohort-side `MembershipCertV1` publication.
+ *
+ * Per `docs/cohort-topic.md` §Membership snapshots: the cohort publishes a threshold-signed
+ * `MembershipCertV1`
+ *
+ * - at stabilization, and on any change to the first `k − x` members ({@link MembershipCertPublisher.onStabilized});
+ * - refreshed every `T_membership_refresh` (default 5 min) ({@link MembershipCertPublisher.tick}).
+ *
+ * The publisher is db-core logic over the {@link CohortSigner} (threshold sign) and the
+ * {@link IMembershipPublishSink} (serve/advertise). It never imports FRET. Members are sorted
+ * ascending for the cert (matching the sharding order) and the first `minSigs` (= `k − x`) of that
+ * order are the "first `k − x`" whose change forces a fresh publish.
+ */
+import { bytesToB64url, encodeCohortMessage } from "../wire/codec.js";
+import { compareBytes } from "../registration/bytes.js";
+import { DEFAULT_MIN_SIGS } from "../sig/threshold.js";
+import { membershipCertSigningPayload } from "../sig/payloads.js";
+/** Default membership-cert refresh interval (`T_membership_refresh`). */
+export const DEFAULT_T_MEMBERSHIP_REFRESH_MS = 5 * 60_000;
+/**
+ * The canonical {@link MembershipCertSignable} for a stabilized snapshot: members sorted ascending (the
+ * cert / sharding order), byte fields base64url-encoded, over exactly the threshold-signed fields. The
+ * publisher signs `membershipCertSigningPayload` of this; a rotation-attestation **producer** (db-p2p,
+ * `cohort-topic-trust-anchor-rotation-production`) signs the *successor* cert's image through the SAME
+ * helper, so signer and verifier never canonicalize the cert independently (signature-image agreement —
+ * a mismatch makes the db-core chain check fail).
+ */
+export function membershipCertSignable(snapshot) {
+    const sorted = [...snapshot.members].sort(compareBytes);
+    return {
+        cohortCoord: bytesToB64url(snapshot.coord),
+        cohortEpoch: bytesToB64url(snapshot.cohortEpoch),
+        members: sorted.map(bytesToB64url),
+        stabilizedAt: snapshot.stabilizedAt,
+    };
+}
+class SigningMembershipCertPublisher {
+    deps;
+    refreshMs;
+    minSigs;
+    /** base64url of the first `minSigs` members of the last published snapshot. */
+    lastFirstKx;
+    lastPublishedAt;
+    constructor(deps) {
+        this.deps = deps;
+        this.refreshMs = deps.refreshMs ?? DEFAULT_T_MEMBERSHIP_REFRESH_MS;
+        this.minSigs = deps.minSigs ?? DEFAULT_MIN_SIGS;
+    }
+    async onStabilized(snapshot, now, rotation) {
+        const firstKx = this.firstKx(snapshot.members);
+        if (this.lastFirstKx !== undefined && sameOrder(this.lastFirstKx, firstKx)) {
+            return undefined; // first k − x unchanged — no republish needed
+        }
+        return this.publish(snapshot, now, rotation);
+    }
+    async tick(snapshot, now, rotation) {
+        if (this.lastPublishedAt !== undefined && now - this.lastPublishedAt < this.refreshMs) {
+            return undefined;
+        }
+        return this.publish(snapshot, now, rotation);
+    }
+    /** The first `minSigs` members of the cert's ascending order, base64url — the republish-change key. */
+    firstKx(members) {
+        return [...members].sort(compareBytes).slice(0, this.minSigs).map(bytesToB64url);
+    }
+    async publish(snapshot, now, rotation) {
+        const signable = membershipCertSignable(snapshot);
+        const { thresholdSig, signers } = await this.deps.signer.thresholdSign(membershipCertSigningPayload(signable));
+        const cert = {
+            v: 1,
+            ...signable,
+            thresholdSig: bytesToB64url(thresholdSig),
+            signers: signers.map(bytesToB64url),
+        };
+        if (snapshot.fretAttestation !== undefined) {
+            cert.fretAttestation = bytesToB64url(snapshot.fretAttestation);
+        }
+        // A rotation attestation (when given) signs *over* the cert's signing payload, so it is attached to the
+        // envelope after signing and is not part of `membershipCertSigningPayload`. Omitted → no rotation fields.
+        if (rotation !== undefined) {
+            cert.prevEpoch = bytesToB64url(rotation.prevEpoch);
+            cert.rotationSig = bytesToB64url(rotation.rotationSig);
+            cert.rotationSigners = rotation.rotationSigners.map(bytesToB64url);
+        }
+        this.deps.sink.publish(encodeCohortMessage(cert, this.deps.maxMessageBytes));
+        this.lastFirstKx = signable.members.slice(0, this.minSigs);
+        this.lastPublishedAt = now;
+        return cert;
+    }
+}
+function sameOrder(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Build a cohort-side {@link MembershipCertPublisher}. */
+export function createMembershipCertPublisher(deps) {
+    return new SigningMembershipCertPublisher(deps);
+}
+//# sourceMappingURL=publisher.js.map

package/dist/src/cohort-topic/membership/publisher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher.js","sourceRoot":"","sources":["../../../../src/cohort-topic/membership/publisher.ts"],"names":[],"mappings":"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"}

package/dist/src/cohort-topic/membership/source.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Cohort-topic substrate — membership-source dispatch.
+ *
+ * Resolved open question (per `docs/cohort-topic.md` §Membership source): how *committed*
+ * membership is obtained differs by tier.
+ *
+ * - **T0/T1** cohorts serve committed work (transaction commits, chain serving); their membership is
+ *   anchored in the transaction log's commit certificate. The verifier reads it from there (it never
+ *   writes the log).
+ * - **T2/T3** cohorts (matchmaking, push forwarding) derive membership from current FRET state and
+ *   verify against FRET's signed `MembershipCertV1` advertisements.
+ *
+ * Both back-ends present the same {@link IMembershipSource} surface; this router picks between them by
+ * tier. db-p2p supplies the two concrete sources (tx-log reader and FRET cert source).
+ */
+import type { IMembershipSource } from "../ports.js";
+/** Picks the authoritative membership source for a cohort by its tier. */
+export interface IMembershipSourceRouter {
+    /** Source for a cohort at `tier`: T0/T1 → committed tx-log, T2/T3 → FRET certs. */
+    for(tier: number): IMembershipSource;
+}
+/**
+ * Build a router over the two membership back-ends.
+ * @param deps.committed source backed by the transaction-log commit certificate (T0/T1).
+ * @param deps.fret source backed by FRET's signed `MembershipCertV1` advertisements (T2/T3).
+ */
+export declare function createMembershipSourceRouter(deps: {
+    committed: IMembershipSource;
+    fret: IMembershipSource;
+}): IMembershipSourceRouter;
+//# sourceMappingURL=source.d.ts.map

package/dist/src/cohort-topic/membership/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../../../src/cohort-topic/membership/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,0EAA0E;AAC1E,MAAM,WAAW,uBAAuB;IACvC,mFAAmF;IACnF,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAC;CACrC;AAOD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IAAE,SAAS,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAAG,uBAAuB,CAMrI"}

package/dist/src/cohort-topic/membership/source.js

@@ -0,0 +1,32 @@
+/**
+ * Cohort-topic substrate — membership-source dispatch.
+ *
+ * Resolved open question (per `docs/cohort-topic.md` §Membership source): how *committed*
+ * membership is obtained differs by tier.
+ *
+ * - **T0/T1** cohorts serve committed work (transaction commits, chain serving); their membership is
+ *   anchored in the transaction log's commit certificate. The verifier reads it from there (it never
+ *   writes the log).
+ * - **T2/T3** cohorts (matchmaking, push forwarding) derive membership from current FRET state and
+ *   verify against FRET's signed `MembershipCertV1` advertisements.
+ *
+ * Both back-ends present the same {@link IMembershipSource} surface; this router picks between them by
+ * tier. db-p2p supplies the two concrete sources (tx-log reader and FRET cert source).
+ */
+/** Tiers whose committed membership is anchored in the transaction log. */
+function isCommittedTier(tier) {
+    return tier === 0 || tier === 1;
+}
+/**
+ * Build a router over the two membership back-ends.
+ * @param deps.committed source backed by the transaction-log commit certificate (T0/T1).
+ * @param deps.fret source backed by FRET's signed `MembershipCertV1` advertisements (T2/T3).
+ */
+export function createMembershipSourceRouter(deps) {
+    return {
+        for(tier) {
+            return isCommittedTier(tier) ? deps.committed : deps.fret;
+        },
+    };
+}
+//# sourceMappingURL=source.js.map

package/dist/src/cohort-topic/membership/source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.js","sourceRoot":"","sources":["../../../../src/cohort-topic/membership/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAUH,2EAA2E;AAC3E,SAAS,eAAe,CAAC,IAAY;IACpC,OAAO,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,CAAC;AACjC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAAC,IAA+D;IAC3G,OAAO;QACN,GAAG,CAAC,IAAY;YACf,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAC3D,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/src/cohort-topic/membership/verifier.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Cohort-topic substrate — participant-side membership verification with a trust-anchor gate.
+ *
+ * Per `docs/cohort-topic.md` §Membership snapshots and §Bootstrapping trust. A participant verifying
+ * a threshold-signed message:
+ *
+ * 1. takes the message's `signers`, the cohort `coord` the signers should belong to, and the tier;
+ * 2. looks up the cached `MembershipCertV1` for that coord (or pulls the source's `current`);
+ * 3. checks the signers are a `≥ minSigs` subset of the cert's members and the signature verifies;
+ * 4. **on failure against a cached/stale cert, re-fetches the cert from any cohort member exactly
+ *    once and retries**; still failing → the message is untrusted.
+ *
+ * **Trust anchoring (the gate this module adds).** Self-consistency (a cert's own threshold signature
+ * is a `≥ minSigs` quorum over its own `members`) proves only internal well-formedness — *not* that the
+ * attesting key set is the legitimate cohort for the coord. An adversary controlling `k − x` keys could
+ * mint a self-consistent cert over a coord it does not own. So before a (re)fetched cert is believed,
+ * {@link CachingMembershipVerifier.certIsTrusted} requires it to be self-consistent **AND** anchored by
+ * at least one of:
+ *
+ * - **Trust root** — `(coord, epoch, member-set)` is in the out-of-band-seeded {@link TrustRoot} set
+ *   (the genesis-block cohorts). Base case of every chain; checked before the direct anchor, so a
+ *   configured root is authoritative.
+ * - **Direct anchor** — the injected {@link IMembershipTrustAnchor} vouches for the binding from a
+ *   source the node directly trusts (FRET ring agreement / tx-log commit cert, bound in db-p2p). A
+ *   `"rejected"` verdict is **fatal** (a forgery, even if self-consistent) and overrides the fallback.
+ * - **Attestation chain** — a cert carrying a rotation attestation (`prevEpoch`/`rotationSig`/
+ *   `rotationSigners`) inherits trust when the node already holds a **trusted** predecessor for the same
+ *   coord at `prevEpoch` whose members form a `≥ minSigs` quorum over this cert's signing payload.
+ *
+ * **Interim TOFU fallback (documented limit).** For a coord the node cannot anchor (the direct anchor
+ * returns `"unknown"` and there is no trust root / chain) and that has **no trusted cert yet**, the
+ * verifier falls back to trust-on-first-use of any self-consistent cert — identical to the pre-anchor
+ * behavior, so there is strictly no regression on coords no node can verify today (distant T2/T3, and
+ * T0/T1 until the committed-index binding lands). Once a coord *does* hold a trusted cert, the chain
+ * governs successors: an un-anchored cert for an already-trusted coord is rejected (no TOFU downgrade),
+ * which is what gives the rotation chain its teeth. The FRET / tx-log direct-anchor bindings that close
+ * the remaining TOFU gap are tracked in `cohort-topic-trust-anchor-fret-binding` and the backlog
+ * `...-fret-stabilization-proof` / `...-txlog-committed-binding` tickets.
+ *
+ * **Deviation from the ticket sketch (documented):** `verifyMessage` takes the cohort `tier`. A coord
+ * is an opaque hash, so the T0/T1-vs-T2/T3 source dispatch the same ticket mandates cannot be derived
+ * from the coord alone; the caller already knows the tier (it computed the coord from the message's
+ * claimed tier/topic). The `tier` is threaded into the gate so the direct anchor is consulted with the
+ * same tier the router used (the binding is tier-scoped).
+ */
+import type { IMembershipTrustAnchor, RingCoord, TrustRoot } from "../ports.js";
+import type { MembershipCertV1 } from "../wire/types.js";
+import { type CohortSigner } from "../sig/threshold.js";
+import type { IMembershipSourceRouter } from "./source.js";
+/** Outcome of verifying a threshold-signed message against cohort membership. */
+export type VerifyResult = "verified" | "untrusted";
+/** Caches certs per coord and verifies threshold-signed messages with one stale-cert refetch. */
+export interface MembershipVerifier {
+    /** Cache `cert` as the latest known membership for its coord. */
+    cache(cert: MembershipCertV1): void;
+    /**
+     * Verify a threshold-signed message. `expectedCoord` is the cohort the `signers` should belong to;
+     * `tier` selects the membership source. Performs the single refetch+retry internally.
+     *
+     * `opts` bounds the network amplification a flood-exposed caller (the `promote` handler) can suffer:
+     * when **both** `minRefetchIntervalMs` and `now` are given, the stale-cert `source.fetch()` retry is
+     * **rate-limited per coord** — at most one refetch per coord per interval — so a stream of verify-misses
+     * (e.g. forged notices) drives a bounded membership-fetch rate rather than one dial per message.
+     * Eventual refetch is *preserved*: a cold cache or a membership rotation still re-fetches once the
+     * interval elapses (unlike outright suppression). Omit `opts` (the default, and every existing caller)
+     * for the unbounded exactly-one-refetch behavior.
+     */
+    verifyMessage(signers: readonly Uint8Array[], expectedCoord: RingCoord, tier: number, payload: Uint8Array, sig: Uint8Array, opts?: RefetchBound): Promise<VerifyResult>;
+}
+/**
+ * Caller-supplied bound on the membership-cert refetch rate (anti-amplification on a flood-exposed verify
+ * path). Both fields are required to take effect; omit either for unbounded refetch.
+ */
+export interface RefetchBound {
+    /** Minimum wall-clock gap (ms) between `source.fetch()` refetches for the same coord. */
+    readonly minRefetchIntervalMs?: number;
+    /** Current wall clock (ms) for the interval comparison. */
+    readonly now?: number;
+}
+export interface MembershipVerifierDeps {
+    signer: CohortSigner;
+    router: IMembershipSourceRouter;
+    minSigs?: number;
+    maxMessageBytes?: number;
+    /**
+     * Direct (base-case) trust anchor for a cert's `coord → keyset` binding. Defaults to
+     * {@link noAuthorityTrustAnchor} (every coord `"unknown"`), which preserves the interim TOFU behavior.
+     * db-p2p injects the FRET-ring-backed anchor.
+     */
+    anchor?: IMembershipTrustAnchor;
+    /** Out-of-band-seeded genesis trust roots (the base case of every attestation chain). Defaults to `[]`. */
+    trustRoots?: readonly TrustRoot[];
+}
+/** Build a participant-side {@link MembershipVerifier}. */
+export declare function createMembershipVerifier(deps: MembershipVerifierDeps): MembershipVerifier;
+//# sourceMappingURL=verifier.d.ts.map

package/dist/src/cohort-topic/membership/verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifier.d.ts","sourceRoot":"","sources":["../../../../src/cohort-topic/membership/verifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAE1E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAE3D,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,WAAW,CAAC;AAEpD,iGAAiG;AACjG,MAAM,WAAW,kBAAkB;IAClC,iEAAiE;IACjE,KAAK,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACpC;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,EAAE,aAAa,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CACxK;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC5B,yFAAyF;IACzF,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,2DAA2D;IAC3D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,sBAAsB;IACtC,MAAM,EAAE,YAAY,CAAC;IACrB,MAAM,EAAE,uBAAuB,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,MAAM,CAAC,EAAE,sBAAsB,CAAC;IAChC,2GAA2G;IAC3G,UAAU,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CAClC;AAgPD,2DAA2D;AAC3D,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,sBAAsB,GAAG,kBAAkB,CAEzF"}

package/dist/src/cohort-topic/membership/verifier.js

@@ -0,0 +1,250 @@
+/**
+ * Cohort-topic substrate — participant-side membership verification with a trust-anchor gate.
+ *
+ * Per `docs/cohort-topic.md` §Membership snapshots and §Bootstrapping trust. A participant verifying
+ * a threshold-signed message:
+ *
+ * 1. takes the message's `signers`, the cohort `coord` the signers should belong to, and the tier;
+ * 2. looks up the cached `MembershipCertV1` for that coord (or pulls the source's `current`);
+ * 3. checks the signers are a `≥ minSigs` subset of the cert's members and the signature verifies;
+ * 4. **on failure against a cached/stale cert, re-fetches the cert from any cohort member exactly
+ *    once and retries**; still failing → the message is untrusted.
+ *
+ * **Trust anchoring (the gate this module adds).** Self-consistency (a cert's own threshold signature
+ * is a `≥ minSigs` quorum over its own `members`) proves only internal well-formedness — *not* that the
+ * attesting key set is the legitimate cohort for the coord. An adversary controlling `k − x` keys could
+ * mint a self-consistent cert over a coord it does not own. So before a (re)fetched cert is believed,
+ * {@link CachingMembershipVerifier.certIsTrusted} requires it to be self-consistent **AND** anchored by
+ * at least one of:
+ *
+ * - **Trust root** — `(coord, epoch, member-set)` is in the out-of-band-seeded {@link TrustRoot} set
+ *   (the genesis-block cohorts). Base case of every chain; checked before the direct anchor, so a
+ *   configured root is authoritative.
+ * - **Direct anchor** — the injected {@link IMembershipTrustAnchor} vouches for the binding from a
+ *   source the node directly trusts (FRET ring agreement / tx-log commit cert, bound in db-p2p). A
+ *   `"rejected"` verdict is **fatal** (a forgery, even if self-consistent) and overrides the fallback.
+ * - **Attestation chain** — a cert carrying a rotation attestation (`prevEpoch`/`rotationSig`/
+ *   `rotationSigners`) inherits trust when the node already holds a **trusted** predecessor for the same
+ *   coord at `prevEpoch` whose members form a `≥ minSigs` quorum over this cert's signing payload.
+ *
+ * **Interim TOFU fallback (documented limit).** For a coord the node cannot anchor (the direct anchor
+ * returns `"unknown"` and there is no trust root / chain) and that has **no trusted cert yet**, the
+ * verifier falls back to trust-on-first-use of any self-consistent cert — identical to the pre-anchor
+ * behavior, so there is strictly no regression on coords no node can verify today (distant T2/T3, and
+ * T0/T1 until the committed-index binding lands). Once a coord *does* hold a trusted cert, the chain
+ * governs successors: an un-anchored cert for an already-trusted coord is rejected (no TOFU downgrade),
+ * which is what gives the rotation chain its teeth. The FRET / tx-log direct-anchor bindings that close
+ * the remaining TOFU gap are tracked in `cohort-topic-trust-anchor-fret-binding` and the backlog
+ * `...-fret-stabilization-proof` / `...-txlog-committed-binding` tickets.
+ *
+ * **Deviation from the ticket sketch (documented):** `verifyMessage` takes the cohort `tier`. A coord
+ * is an opaque hash, so the T0/T1-vs-T2/T3 source dispatch the same ticket mandates cannot be derived
+ * from the coord alone; the caller already knows the tier (it computed the coord from the message's
+ * claimed tier/topic). The `tier` is threaded into the gate so the direct anchor is consulted with the
+ * same tier the router used (the binding is tier-scoped).
+ */
+import { noAuthorityTrustAnchor } from "../ports.js";
+import { b64urlToBytes, bytesToB64url, decodeMembershipCertV1 } from "../wire/codec.js";
+import { CohortWireError } from "../wire/validate.js";
+import { DEFAULT_MIN_SIGS } from "../sig/threshold.js";
+import { membershipCertSigningPayload } from "../sig/payloads.js";
+class CachingMembershipVerifier {
+    deps;
+    byCoord = new Map();
+    /** Per-coord timestamp of the last `source.fetch()` attempt (the rate-limit clock for {@link RefetchBound}). */
+    lastFetchAt = new Map();
+    minSigs;
+    anchor;
+    trustRoots;
+    constructor(deps) {
+        this.deps = deps;
+        this.minSigs = deps.minSigs ?? DEFAULT_MIN_SIGS;
+        this.anchor = deps.anchor ?? noAuthorityTrustAnchor;
+        this.trustRoots = (deps.trustRoots ?? []).map(normalizeTrustRoot);
+    }
+    cache(cert) {
+        // The public cache feeds this node its OWN freshly-published cert — a node trusts a cert it itself
+        // published, so it is marked trusted and may anchor the next rotation in the attestation chain.
+        this.byCoord.set(cert.cohortCoord, { cert, trusted: true });
+    }
+    async verifyMessage(signers, expectedCoord, tier, payload, sig, opts) {
+        const coordKey = bytesToB64url(expectedCoord);
+        const source = this.deps.router.for(tier);
+        // Seed from the cheap cached view if we hold nothing yet. A cached cert already passed the gate when
+        // it was loaded (or was self-published via `cache`), so it is used directly for message verification.
+        let cert = this.byCoord.get(coordKey)?.cert;
+        if (cert === undefined) {
+            cert = await this.loadFrom(source.current(expectedCoord), tier);
+        }
+        if (cert !== undefined && this.messageVerifies(cert, signers, payload, sig)) {
+            return "verified";
+        }
+        // Single fetch-and-retry: a stale or missing cert forces a network refresh. A flood-exposed caller
+        // (the ungated `promote` handler) bounds the amplification via {@link RefetchBound}: the refetch is
+        // then rate-limited to at most one per coord per interval, so a stream of verify-misses (forged
+        // notices) cannot turn into a storm of membership dials. Eventual refetch survives — a cold cache or a
+        // membership rotation still refreshes once the interval elapses.
+        if (!this.refetchAllowed(coordKey, opts)) {
+            return "untrusted";
+        }
+        const refreshed = await this.loadFrom(source.fetch(expectedCoord), tier);
+        if (refreshed !== undefined && this.messageVerifies(refreshed, signers, payload, sig)) {
+            return "verified";
+        }
+        return "untrusted";
+    }
+    /**
+     * Whether a `source.fetch()` refetch is permitted for `coordKey` now. Unbounded (always `true`) unless
+     * the caller supplies both `minRefetchIntervalMs` and `now`, in which case at most one refetch per coord
+     * per interval is allowed — the per-coord fetch-rate bound that caps flood amplification. Records the
+     * attempt time when it returns `true` (the dial is about to happen).
+     */
+    refetchAllowed(coordKey, opts) {
+        const minInterval = opts?.minRefetchIntervalMs;
+        const now = opts?.now;
+        if (minInterval === undefined || now === undefined) {
+            return true;
+        }
+        const last = this.lastFetchAt.get(coordKey);
+        if (last !== undefined && now - last < minInterval) {
+            return false;
+        }
+        this.lastFetchAt.set(coordKey, now);
+        return true;
+    }
+    /**
+     * Decode an encoded cert, run it through the trust gate, cache it (with its trusted status), and return
+     * it for message verification; `undefined` if absent, malformed, or rejected by the gate. A rejected
+     * cert (failed self-consistency, a `"rejected"` direct anchor, or an un-anchored cert for an
+     * already-trusted coord) is treated exactly like an absent cert, so the single refetch still fires.
+     */
+    async loadFrom(pending, tier) {
+        const encoded = await pending;
+        if (encoded === undefined) {
+            return undefined;
+        }
+        let cert;
+        let trust;
+        try {
+            cert = decodeMembershipCertV1(encoded, this.deps.maxMessageBytes);
+            trust = this.certIsTrusted(cert, tier);
+        }
+        catch (err) {
+            if (err instanceof CohortWireError) {
+                return undefined; // a malformed cert (or non-base64url signer) is treated as no cert
+            }
+            throw err;
+        }
+        if (trust === "reject") {
+            return undefined;
+        }
+        // Only a `"trusted"` cert may anchor a successor in the attestation chain; a `"tofu"` cert is cached
+        // for message verification but must never launder trust into a rotation.
+        this.byCoord.set(cert.cohortCoord, { cert, trusted: trust === "trusted" });
+        return cert;
+    }
+    /**
+     * The trust gate (see the module header). A cert is accepted iff it is self-consistent **and** anchored
+     * by a trust root, the direct anchor, or the attestation chain; otherwise it falls to the interim TOFU
+     * fallback (first-use only). Returns whether the cert is a trusted anchor (`"trusted"`), an interim
+     * TOFU acceptance (`"tofu"`), or rejected (`"reject"`).
+     */
+    certIsTrusted(cert, tier) {
+        if (!this.certIsSelfConsistent(cert)) {
+            return "reject"; // internal well-formedness is the precondition for any trust path
+        }
+        if (this.matchesTrustRoot(cert)) {
+            return "trusted"; // a configured genesis root is authoritative, checked before the direct anchor
+        }
+        const verdict = this.anchor.directAnchor(cert, tier);
+        if (verdict === "anchored") {
+            return "trusted";
+        }
+        if (verdict === "rejected") {
+            return "reject"; // a contradicted binding is a forgery — fatal, overrides the TOFU fallback
+        }
+        // verdict === "unknown": no local authority for this coord. Try the attestation chain, else fall back.
+        if (this.hasRotationAttestation(cert) && this.chainGrantsTrust(cert)) {
+            return "trusted";
+        }
+        return this.fallbackTrust(cert);
+    }
+    /**
+     * The interim fallback for a coord with no trust-root / anchor / chain coverage. Trust-on-first-use:
+     * accept a self-consistent cert when the coord holds **no trusted cert yet**, preserving the pre-anchor
+     * behavior on coords no node can verify today. But once a coord *is* trust-established, an un-anchored
+     * cert (a failed/absent rotation, including a forged rotation off a trusted predecessor) is **rejected**
+     * — no silent TOFU downgrade — which is what gives the attestation chain its teeth.
+     */
+    fallbackTrust(cert) {
+        return this.byCoord.get(cert.cohortCoord)?.trusted ? "reject" : "tofu";
+    }
+    /** Whether a cert carries a full rotation attestation (all three fields; validated all-or-nothing on the wire). */
+    hasRotationAttestation(cert) {
+        return cert.prevEpoch !== undefined && cert.rotationSig !== undefined && cert.rotationSigners !== undefined;
+    }
+    /**
+     * Whether `cert`'s rotation attestation is valid: a **trusted** predecessor for the same coord is cached
+     * at `prevEpoch`, the rotation is not self-referential, and the predecessor's members form a `≥ minSigs`
+     * quorum over this cert's signing payload via `rotationSig`. A predecessor that only reached the cache via
+     * TOFU (not trusted) must not anchor the successor — the trusted-cache invariant.
+     */
+    chainGrantsTrust(cert) {
+        const prevEpoch = cert.prevEpoch;
+        if (prevEpoch === cert.cohortEpoch) {
+            return false; // a cert cannot rotate from itself
+        }
+        const predecessor = this.byCoord.get(cert.cohortCoord);
+        if (predecessor === undefined || !predecessor.trusted || predecessor.cert.cohortEpoch !== prevEpoch) {
+            return false;
+        }
+        // `rotationSigners` is validated only as a string array, so `b64urlToBytes` may throw `CohortWireError`
+        // on a malformed signer — `loadFrom`'s try/catch turns that into "no cert", as for `certIsSelfConsistent`.
+        return this.deps.signer.verifyThreshold(membershipCertSigningPayload(cert), b64urlToBytes(cert.rotationSig), cert.rotationSigners.map((s) => b64urlToBytes(s)), predecessor.cert, this.minSigs);
+    }
+    /** Whether `cert` matches a configured trust root by `(coord, epoch)` and an order-independent member set. */
+    matchesTrustRoot(cert) {
+        for (const root of this.trustRoots) {
+            if (root.coord === cert.cohortCoord && root.epoch === cert.cohortEpoch && setEqualsArray(root.members, cert.members)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** A cert is self-consistent only if its own threshold signature is a valid quorum of its members. */
+    certIsSelfConsistent(cert) {
+        // `signers` is validated only as a string array (not per-element base64url), so `b64urlToBytes`
+        // below may throw `CohortWireError` on a malformed signer — `loadFrom`'s try/catch turns that
+        // into "no cert" rather than letting it escape.
+        return this.deps.signer.verifyThreshold(membershipCertSigningPayload(cert), b64urlToBytes(cert.thresholdSig), cert.signers.map((s) => b64urlToBytes(s)), cert, this.minSigs);
+    }
+    messageVerifies(cert, signers, payload, sig) {
+        return this.deps.signer.verifyThreshold(payload, sig, signers, cert, this.minSigs);
+    }
+}
+/** Pre-normalize a {@link TrustRoot} (raw bytes) to the cert's base64url form for cheap matching. */
+function normalizeTrustRoot(root) {
+    return {
+        coord: bytesToB64url(root.coord),
+        epoch: bytesToB64url(root.epoch),
+        members: new Set(root.members.map(bytesToB64url)),
+    };
+}
+/** Order-independent set equality between a trust-root member set and a cert's member array (duplicate-safe). */
+function setEqualsArray(set, members) {
+    const seen = new Set();
+    for (const m of members) {
+        if (!set.has(m)) {
+            return false; // a member not in the root → not a root match
+        }
+        seen.add(m);
+    }
+    // Cover both directions: every distinct cert member is in the root AND every root member is covered,
+    // so a duplicate-inflated member list cannot masquerade as a full-set match.
+    return seen.size === set.size;
+}
+/** Build a participant-side {@link MembershipVerifier}. */
+export function createMembershipVerifier(deps) {
+    return new CachingMembershipVerifier(deps);
+}
+//# sourceMappingURL=verifier.js.map

package/dist/src/cohort-topic/membership/verifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifier.js","sourceRoot":"","sources":["../../../../src/cohort-topic/membership/verifier.ts"],"names":[],"mappings":"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"}