@serfab/cadre-core 0.8.1 → 0.10.0

package/src/control-authorization.ts

@@ -0,0 +1,114 @@
+/**
+ * The single definition of the field vector every signed control-plane message
+ * covers. Both producers of signed bytes — `control-database.ts`'s
+ * `buildAuthorizationMessage` (raw digest bytes) and `peer-authorization.ts`'s
+ * digest helpers (base64url digest strings) — build their vector here, so the
+ * byte layout cannot drift between them or away from the SQL constraints in
+ * `schemas/control.qsql`.
+ *
+ * Every vector leads with two fixed literals:
+ *
+ *   digest(<domain>, <action>, <row field 1>, ..., <row field n>)
+ *
+ * so a signature verifies ONLY against the one rule it was minted for. Without
+ * the tags, several rules built byte-identical tuples (e.g. `ValidationKey`
+ * insert and `OwnerKey` insert both signed `digest(Key, StampId)`), so an
+ * approval for a narrow grant doubled as an approval for full ownership.
+ *
+ * This module deliberately has no Quereus / Optimystic / libp2p imports so the
+ * lightweight verifiers (`peer-authorization.ts`, consumed by the offline
+ * `cadre enroll register` check) can use it without pulling in the runtime.
+ */
+
+/**
+ * Names of the CadreControl tables, in schema order. The single list: the
+ * {@link ControlTable} union is derived from it and `ControlDatabase.countRows`
+ * guards its dynamic `from` clause against it (keeping the table name off the
+ * SQL-injection surface), so a new table cannot be added to one and missed in
+ * the other.
+ *
+ * `Revocation` is here for the same two reasons as every other entry: it
+ * derives a `'CadreControl.Revocation'` domain tag — its `Authorized` CHECK
+ * verifies an owner signature over the `'remove'`-tagged digest that
+ * `peer-authorization.ts`'s `revocationDigest` mints, and its `AuthorizedReissue`
+ * CHECK the `'reissue'`-tagged digest `ControlDatabase.reissueRevocations`
+ * signs — and `countRows` counts it.
+ */
+export const CONTROL_TABLES = [
+  'OwnerKey',
+  'ValidationKey',
+  'Strand',
+  'CadrePeer',
+  'DeviceToken',
+  'FormationInvite',
+  'FormationUsage',
+  'Revocation',
+] as const;
+
+/**
+ * Name of a CadreControl table. Doubles as the table half of a
+ * {@link ControlDomain} tag.
+ */
+export type ControlTable = typeof CONTROL_TABLES[number];
+
+/**
+ * The control tables whose rows carry a single-use `StampId` retired into
+ * `CadreControl.Revocation` on delete — i.e. the ones the schema's
+ * `NotRevoked` / `RevocationRecorded` CHECK pair guards, and the only values
+ * `Revocation.RowIsGone` accepts in `TableName`. `Extract` from
+ * {@link ControlTable} rather than a fresh literal list, so a renamed table is a
+ * compile error here instead of a silently dead branch.
+ *
+ * Lives in this import-free module rather than beside its main consumer
+ * (`control-database.ts`) so the lightweight signers — `peer-authorization.ts`'s
+ * `revocationDigest` — can type against it without pulling in the runtime.
+ */
+export type RevocableTable = Extract<ControlTable, 'OwnerKey' | 'CadrePeer' | 'ValidationKey' | 'Strand' | 'DeviceToken'>;
+
+/**
+ * What a signature authorizes, scoped to one table rule — or, for
+ * `'Cadre.Enrollment'`, the offline peer vouch that `cadre enroll register`
+ * verifies (no table checks it, so it needs its own domain to stay disjoint
+ * from every table rule).
+ */
+export type ControlDomain = `CadreControl.${ControlTable}` | 'Cadre.Enrollment';
+
+/**
+ * The action half of the tag:
+ *  - `'add'` / `'remove'` — insert / delete of the named row.
+ *  - `'vouch'` — an owner (or validation key) vouches the row's semantics
+ *    without adding or removing it: the `CadrePeer` membership vouch (shared,
+ *    deliberately, by its insert and its owner-update branch), the
+ *    `FormationUsage` disclosure validation, and the offline enrollment vouch.
+ *    `DeviceToken` has no `'vouch'` digest — its owner re-touch branch was
+ *    removed (it rewrote the row outside the monotonicity guard), so an owner
+ *    correcting a token deletes and re-inserts it.
+ *  - `'publish'` — a peer self-signs its OWN record (the `CadrePeer` /
+ *    `DeviceToken` self-update branches), with its own key rather than an
+ *    owner key.
+ *  - `'consent'` — a peer self-signs its OWN `FormationUsage` redemption (the
+ *    joiner proving it agreed to join), with its own key. Distinct from the
+ *    approver's `'vouch'` over the same table so the two stored signatures are
+ *    never interchangeable.
+ *  - `'reissue'` — an owner re-writes an existing `Revocation` tombstone,
+ *    bumping its `ReissuedAt` counter so a tombstone committed while the node
+ *    was alone can be re-broadcast. Distinct from `'remove'` so a tombstone
+ *    append approval can never be replayed as a re-issue and vice versa.
+ */
+export type ControlAction = 'add' | 'remove' | 'vouch' | 'publish' | 'consent' | 'reissue';
+
+/**
+ * The full ordered field vector a control-plane signature covers. Digest this
+ * with the crypto plugin's injective multi-field encoding (every field TEXT);
+ * the SQL mirror passes the same literals as leading `digest(...)` arguments:
+ *
+ *   TS:  digest(controlAuthorizationFields('CadreControl.X', 'add', [a, b]), 'sha256', ...)
+ *   SQL: digest('CadreControl.X', 'add', new.A, new.B)
+ */
+export function controlAuthorizationFields(
+  domain: ControlDomain,
+  action: ControlAction,
+  rowFields: string[],
+): string[] {
+  return [domain, action, ...rowFields];
+}

package/src/control-cohort.ts

@@ -5,14 +5,14 @@
  * connected (and thus replicating), without devolving into an N² mesh.
  *
  * FRET only needs a *connected* graph with the block clusters reachable, not a
- * full mesh. Storage/authority nodes are the stable, publicly-dialable backbone
+ * full mesh. Storage/owner nodes are the stable, publicly-dialable backbone
  * that hold the control blocks, so the policy is **backbone-preferential with a
  * bounded out-degree**:
  *
- * - **Always dial every backbone (authority) member** — the authority set is
+ * - **Always dial every backbone (owner) member** — the owner set is
  *   small by design, and routing cohort formation through publicly-dialable
- *   authority nodes keeps the cohort ≥2 where authority-signed writes originate.
- * - **Fill the remainder** up to `targetDegree` with non-authority members,
+ *   owner nodes keeps the cohort ≥2 where owner-signed writes originate.
+ * - **Fill the remainder** up to `targetDegree` with non-owner members,
  *   ordered deterministically (peerId sort) so every node makes the same stable
  *   choice across passes and load spreads predictably.
  *
@@ -32,8 +32,8 @@ import type { CohortPeerRow } from './strand-cohort.js';
 export const DEFAULT_CONTROL_COHORT_RECONCILE_MS = 15_000;
 
 /**
- * Default cap on the number of **non-authority** members a single reconcile pass
- * proactively dials. Backbone (authority) members are always dialed and do NOT
+ * Default cap on the number of **non-owner** members a single reconcile pass
+ * proactively dials. Backbone (owner) members are always dialed and do NOT
  * count against this cap.
  */
 export const DEFAULT_CONTROL_COHORT_TARGET_DEGREE = 6;
@@ -41,14 +41,14 @@ export const DEFAULT_CONTROL_COHORT_TARGET_DEGREE = 6;
 /** Outcome of {@link selectControlCohortDials}: who to dial + what the cap dropped. */
 export interface ControlCohortSelection {
   /**
-   * Siblings to dial this pass, backbone first then the bounded non-authority
+   * Siblings to dial this pass, backbone first then the bounded non-owner
    * fill. Already self-excluded (the caller must pass self-excluded `siblings`).
    * Still includes peers that may turn out to be already-connected — the caller
    * diffs against live connections separately.
    */
   dials: CohortPeerRow[];
-  /** Non-authority members dropped by the `targetDegree` cap (0 when none). */
-  cappedNonAuthority: number;
+  /** Non-owner members dropped by the `targetDegree` cap (0 when none). */
+  cappedNonOwner: number;
 }
 
 /** Stable peerId ordering so the bounded fill is identical across passes/nodes. */
@@ -63,19 +63,19 @@ function byPeerId(a: CohortPeerRow, b: CohortPeerRow): number {
  * to dial.
  *
  * A member is **backbone** iff the ed25519 key derived from its peerId
- * (see {@link ed25519PublicKeyB64FromPeerId}) is in `authorityKeys`. All backbone
- * members are selected; non-authority members fill up to `targetDegree` in
+ * (see {@link ed25519PublicKeyB64FromPeerId}) is in `ownerKeys`. All backbone
+ * members are selected; non-owner members fill up to `targetDegree` in
  * deterministic peerId order.
  *
  * @param siblings - cadre members EXCLUDING self (the caller filters self out).
- * @param authorityKeys - the converged `AuthorityKey` set; may be empty/partial
- *   before authority convergence, in which case no member classifies as backbone
+ * @param ownerKeys - the converged `OwnerKey` set; may be empty/partial
+ *   before owner convergence, in which case no member classifies as backbone
  *   yet and the bounded fill still makes progress (preference sharpens later).
- * @param targetDegree - cap on non-authority dials (negative is treated as 0).
+ * @param targetDegree - cap on non-owner dials (negative is treated as 0).
  */
 export function selectControlCohortDials(
   siblings: CohortPeerRow[],
-  authorityKeys: ReadonlySet<string>,
+  ownerKeys: ReadonlySet<string>,
   targetDegree: number,
 ): ControlCohortSelection {
   const backbone: CohortPeerRow[] = [];
@@ -83,7 +83,7 @@ export function selectControlCohortDials(
 
   for (const peer of siblings) {
     const pubKey = ed25519PublicKeyB64FromPeerId(peer.peerId);
-    if (pubKey !== null && authorityKeys.has(pubKey)) {
+    if (pubKey !== null && ownerKeys.has(pubKey)) {
       backbone.push(peer);
     } else {
       rest.push(peer);
@@ -98,6 +98,6 @@ export function selectControlCohortDials(
 
   return {
     dials: [...backbone, ...fill],
-    cappedNonAuthority: rest.length - fill.length,
+    cappedNonOwner: rest.length - fill.length,
   };
 }