@optimystic/db-p2p 0.13.4 → 0.14.0

package/dist/src/dispute/invalidation.d.ts

@@ -0,0 +1,266 @@
+import type { ActionId, BlockId, IBlock, Log, DisputeResolutionProof, RevertedBlock } from '@optimystic/db-core';
+import type { IBlockStorage } from '../storage/i-block-storage.js';
+import type { DisputeResolution } from './types.js';
+/**
+ * Accepted arbitration-vote wire-format version. The v3 signed payload binds each vote to BOTH the
+ * specific reversed transaction (`targetHash`, #2) and the legitimately-selected arbitrator set
+ * (`setHash`, #1); v1/v2 (un-set-bound) votes are rejected, never accepted-by-default.
+ */
+export declare const VOTE_VERSION: "v3";
+/**
+ * The transaction an invalidation certificate's votes are bound to — the committed action being
+ * reversed and the blocks it wrote. Threaded into {@link verifyInvalidationCertificate} so a genuine
+ * `challenger-wins` proof for transaction X cannot be replayed to revert an unrelated transaction Y:
+ * the arbitrators signed over X's `targetHash`, so verifying against any other target makes every
+ * signature fail → 0 decisive votes → reject.
+ */
+export type CertificateTarget = {
+    readonly invalidatedActionId: ActionId;
+    readonly blockIds: ReadonlyArray<BlockId>;
+};
+/**
+ * Binds a vote to its reversal target: `hashString(`${messageHash}|${invalidatedActionId}|${sortedBlockIds}`)`.
+ * `blockIds` are lexically sorted so the binding is independent of the order a member happens to list
+ * them, and {@link hashString} is the same db-core helper the compensating-state computation uses, so
+ * every member recomputes an identical `targetHash`.
+ */
+export declare function computeTargetHash(messageHash: string, target: CertificateTarget): Promise<string>;
+/**
+ * Digest of the legitimately-selected arbitrator set (#1) — `hashString(sortedArbitratorSet.join(','))`.
+ * Peer-ids are lexically sorted so the digest is independent of the order any party happens to list the
+ * set in, and every member (arbitrators signing votes, the challenger signing the set, the verifier)
+ * recomputes an identical `setHash`.
+ */
+export declare function computeArbitratorSetHash(arbitratorSet: ReadonlyArray<string>): Promise<string>;
+/**
+ * The exact bytes an arbitrator signs for a v3 vote — `utf8(`v3:${disputeId}:${vote}:${computedHash}:${targetHash}:${setHash}`)`.
+ * Shared by the origination path ({@link makeVote in dispute-service}) and {@link verifyVoteSignature}
+ * so the signed and verified preimages can never drift.
+ */
+export declare function voteSigningPayload(disputeId: string, vote: string, computedHash: string, targetHash: string, setHash: string): Uint8Array;
+/**
+ * The exact bytes the **challenger** signs to bind `(disputeId, target, arbitratorSet)` —
+ * `utf8(`v3set:${disputeId}:${targetHash}:${setHash}`)`. Verified against the challenger's embedded key
+ * ({@link DisputeResolutionProof.challengerPeerId}); shared with the origination path so it can never drift.
+ * The version marker is derived from {@link VOTE_VERSION} (currently `v3` → `v3set`) so a future format
+ * bump moves the vote and set preimages together — a proof is wholly one wire version, never a mix.
+ */
+export declare function arbitratorSetSigningPayload(disputeId: string, targetHash: string, setHash: string): Uint8Array;
+/**
+ * Context handed to an {@link ArbitratorSetRecompute} capability: everything it needs to re-derive the
+ * legitimate arbitrator set from the verifying member's own topology and judge the carried set against it.
+ */
+export type ArbitratorSetRecomputeContext = {
+    readonly disputeId: string;
+    readonly messageHash: string;
+    readonly invalidatedActionId: ActionId;
+    readonly blockIds: ReadonlyArray<BlockId>;
+    /** The carried set being judged (peer-id strings). */
+    readonly arbitratorSet: ReadonlyArray<string>;
+};
+/**
+ * Verdict from an {@link ArbitratorSetRecompute}:
+ *  - `{ feasible: false }` — the member could not reconstruct the historical selection (late-joiner,
+ *    churned DHT view); the verifier falls through to the degradation posture (layer-1 accept + log).
+ *  - `{ feasible: true, legitimate }` — it recomputed the eligible set and judged whether the carried
+ *    `arbitratorSet` matches it (within whatever churn tolerance the capability applies).
+ */
+export type ArbitratorSetVerdict = {
+    readonly feasible: false;
+} | {
+    readonly feasible: true;
+    readonly legitimate: boolean;
+};
+/**
+ * Injected **layer-2** capability: re-derives the legitimately-selected arbitrator set from the verifying
+ * member's topology view (it has `peerNetwork` / FRET routing) and judges the carried set. Supplied by
+ * callers that hold a network (e.g. `ClusterMember.applyConsensusInvalidation`); the pure
+ * {@link verifyInvalidationCertificate} stays usable without it (layer-1 + degradation). Closing the
+ * fully-malicious-challenger vector requires this layer (or the layer-3 trust anchor).
+ */
+export type ArbitratorSetRecompute = (ctx: ArbitratorSetRecomputeContext) => Promise<ArbitratorSetVerdict>;
+/** Reported when a certificate is accepted on layer-1 alone — see {@link VerifyCertificateOptions.onUnanchored}. */
+export type UnanchoredAcceptanceInfo = {
+    readonly disputeId: string;
+    readonly arbitratorSet: ReadonlyArray<string>;
+    /** Why the stronger layers did not apply. */
+    readonly reason: 'no-recompute-capability' | 'recompute-infeasible';
+};
+/** Optional capabilities a caller threads into {@link verifyInvalidationCertificate} when it has a network. */
+export type VerifyCertificateOptions = {
+    /** Layer-2 recompute capability; omitted → pure layer-1 verification with the documented degradation. */
+    readonly recomputeArbitratorSet?: ArbitratorSetRecompute;
+    /**
+     * Invoked when the certificate is accepted on the challenger-bound set + membership + dedup ALONE —
+     * the interim posture when neither recompute (layer 2) nor a trust anchor (layer 3) resolved the set.
+     * Lets a caller surface "applied an invalidation it could not fully anchor" alongside the internal log.
+     */
+    readonly onUnanchored?: (info: UnanchoredAcceptanceInfo) => void;
+};
+/**
+ * Marks a `reverted` block whose as-if-`T_inv`-absent state is a *deletion* (T_inv created the
+ * block, so there is no prior content to restore). {@link applyInvalidation} now physically removes
+ * such blocks (a forward tombstone via {@link IBlockStorage.saveDeletion}); this sentinel is the
+ * `restoredContentHash` it records for the deleted block, telling read-dependents "the observed
+ * content no longer exists → invalidate" (a created block can never equal "absent"). Greppable so it
+ * is never mistaken for a real content hash.
+ */
+export declare const DELETED_BLOCK_RESTORE = "deleted:block-creation-reverted";
+/**
+ * The arbitrator-set binding a proof carries (#1): the legitimately-selected set, the challenger that
+ * selected it, and the challenger's signature over `(disputeId, target, arbitratorSet)`. Assembled by
+ * the originator ({@link DisputeService.maybeInvalidate}), which holds the selected set from
+ * `initiateDispute` and signs it with the challenger's key.
+ */
+export type ArbitratorSetBinding = {
+    readonly arbitratorSet: ReadonlyArray<string>;
+    readonly challengerPeerId: string;
+    readonly arbitratorSetSignature: string;
+};
+/**
+ * Projects a db-p2p {@link DisputeResolution} onto the db-core {@link DisputeResolutionProof} —
+ * the independently-verifiable subset (outcome + signed votes + arbitrator-set binding) that an
+ * {@link InvalidationEntry} carries. `messageHash` is the original transaction's hash (from the
+ * challenge), the anchor the proof pins the reversal to; `binding` carries the legitimately-selected
+ * arbitrator set and the challenger's signature over it (#1).
+ */
+export declare function buildDisputeResolutionProof(resolution: DisputeResolution, messageHash: string, binding: ArbitratorSetBinding): DisputeResolutionProof;
+/**
+ * Verifies that a {@link DisputeResolutionProof} is a valid invalidation certificate — the reversal
+ * analogue of the commit certificate. A member accepts an invalidation **only** if this returns true.
+ * Defense-in-depth, strongest-available-layer-wins:
+ *
+ * **Target binding (#2).** `target` is the transaction actually being reverted; the verifier recomputes
+ * `targetHash` from `proof.messageHash` + `target` and checks each vote's signature over the v3 payload
+ * `v3:${disputeId}:${vote}:${computedHash}:${targetHash}:${setHash}`. Because the arbitrators signed the
+ * *real* transaction's `targetHash`, feeding any other target (a replay against an innocent transaction)
+ * makes every signature fail. A vote whose version is absent/unrecognized (legacy/v1/v2) is rejected
+ * before counting — never accepted-by-default.
+ *
+ * **Arbitrator-set binding (#1) — layer 1 (always).** The proof carries `arbitratorSet` (the K peer-ids
+ * the challenger selected) and `arbitratorSetSignature` (the challenger's signature over
+ * `(disputeId, target, arbitratorSet)`, verified against `challengerPeerId`'s embedded key). The verifier:
+ *  - rejects a proof missing the set / challenger fields;
+ *  - rejects a proof whose challenger signature does not validate over the recomputed `(targetHash, setHash)`
+ *    — so tampering with the set (adding sybils) breaks the certificate;
+ *  - counts only votes whose `arbitratorPeerId` ∈ `arbitratorSet` (a signature-valid vote from a peer
+ *    outside the set is dropped), and whose vote payload also commits to the same `setHash`.
+ * This closes the third-party-relay / originator sybil vector and binds the originator. It does NOT by
+ * itself stop a *fully-malicious* challenger (who legitimately holds its own key and signs a sybil set it
+ * minted) — that needs layer 2 or 3.
+ *
+ * **Per-arbitrator dedup (#3).** Among the in-set votes, decisive verdicts are tallied at most once per
+ * `arbitratorPeerId`: a repeated identical decisive vote counts once; an arbitrator with conflicting
+ * decisive votes (equivocation) is dropped from both sides. `inconclusive` votes are non-decisive.
+ *
+ * **Recompute — layer 2 (best effort).** When `options.recomputeArbitratorSet` is supplied (the caller
+ * holds a topology view), the carried set is re-derived and judged. A `{feasible:true, legitimate:false}`
+ * verdict rejects the certificate even though layer 1 passed — closing the malicious-challenger vector.
+ * `{feasible:false}` (member can't reconstruct the historical topology) falls through to degradation.
+ *
+ * **Degradation (layer 3 / none-available).** With no recompute capability (or an infeasible recompute)
+ * and no trust anchor yet, a layer-1-valid certificate is **accepted and logged** as not-fully-anchored
+ * (and `options.onUnanchored` is invoked) — never a silent accept-by-default, and never a false reject
+ * that would break liveness for late-joiners. This is the interim posture until the cohort-topic
+ * membership-cert trust-anchor chain lands (`tickets/plan/cohort-topic-membership-cert-trust-anchoring.md`),
+ * at which point it is upgraded to a hard gate.
+ */
+export declare function verifyInvalidationCertificate(proof: DisputeResolutionProof, target: CertificateTarget, options?: VerifyCertificateOptions): Promise<boolean>;
+/**
+ * The recomputed "as-if-`T_inv`-never-committed" state for a single block.
+ *  - `restore`: the block existed before `T_inv`; `block` is its recomputed content (the revision
+ *    immediately before `T_inv`, with any surviving later actions replayed on top).
+ *  - `delete`: `T_inv` created the block, so the as-if-absent state is a deletion (physically removed
+ *    by {@link applyInvalidation} via a tombstone — see {@link DELETED_BLOCK_RESTORE}).
+ */
+export type RevertedComputation = {
+    kind: 'restore';
+    block: IBlock;
+    restoredContentHash: string;
+    fromRev: number;
+    laterActions: number;
+} | {
+    kind: 'delete';
+    fromRev: number;
+};
+/**
+ * Reconstructs the compensating content for one block from stored revisions only (never by re-running
+ * the engine — so it does not depend on engine availability and stays deterministic across members).
+ *
+ * Base = the block's content at the highest stored revision strictly before `T_inv` (no such revision
+ * ⇒ `T_inv` created the block ⇒ a deletion). In the single-collection/no-cascade core, "surviving later
+ * actions" = every committed action after `T_inv` on this block, replayed verbatim on the rolled-back
+ * base. The cascade (see `cascade.ts`) layers true read-dependent re-evaluation on top of this blind
+ * replay — it reverts the genuine successors this primitive leaves as-is and logs.
+ */
+export declare function computeRevertedBlock(blockStorage: IBlockStorage, invalidatedRev: number): Promise<RevertedComputation>;
+/**
+ * Deterministic content hash for a materialized block — the single hashing convention shared by
+ * the compensating-state computation ({@link computeRevertedBlock}) and the cascade re-evaluator
+ * (`db-p2p/src/dispute/cascade.ts`). Both must agree byte-for-byte: the cascade decides whether a
+ * read-dependent still holds by comparing the hash of the content it *observed* against the
+ * `restoredContentHash` an invalidation recorded — so the two hashes have to be produced the same way.
+ */
+export declare function hashBlockContent(block: IBlock): Promise<string>;
+/** Everything the apply primitive needs from the host: the collection log and per-block storage. */
+export type InvalidationContext = {
+    /** The collection log of the collection `T_inv` wrote (where the compensating entry is appended). */
+    readonly log: Log<unknown>;
+    /** Resolves a block's storage so the compensating revision can be written. */
+    readonly createBlockStorage: (blockId: BlockId) => IBlockStorage;
+};
+export type ApplyInvalidationParams = {
+    readonly invalidatedActionId: ActionId;
+    readonly invalidatedRev: number;
+    /** Blocks `T_inv` wrote (its commit's blockIds). */
+    readonly blockIds: ReadonlyArray<BlockId>;
+    /** The invalidation certificate. */
+    readonly proof: DisputeResolutionProof;
+    /**
+     * Consensus-assigned revision slot for the compensating revision (collection-global). When
+     * omitted, computed as one past the highest current tip across the reverted blocks — the value a
+     * local/single-node apply uses; the consensus path passes the agreed slot.
+     */
+    readonly rev?: number;
+    /**
+     * When this invalidation is a cascade step (a read-dependent of an already-invalidated root being
+     * reverted), the `actionId` of the root invalidation that triggered the cascade. Recorded on the
+     * resulting {@link InvalidationEntry} (`cascadeRoot`) so the reversal is auditable as part of one
+     * logical cascade event. Absent for a root invalidation.
+     */
+    readonly cascadeRoot?: ActionId;
+    /**
+     * The target the proof's votes are bound to — the transaction the dispute actually resolved. For a
+     * **root** invalidation this equals this call's own `(invalidatedActionId, blockIds)` and may be
+     * omitted (defaulted below). A **cascade child** reuses the *root's* proof to authorize reverting a
+     * read-dependent whose own target differs, so it MUST pass the root's target here: the votes were
+     * signed over the root's `targetHash`, not the child's. The child-specific justification is the
+     * deterministic cascade derivation every member replays — not the certificate, which only attests
+     * the root is invalid. (The network-facing apply path `applyConsensusInvalidation` never sets this:
+     * it verifies against the request's *own* target, which is the replay boundary this ticket closes.)
+     */
+    readonly certificateTarget?: CertificateTarget;
+    readonly timestamp?: number;
+};
+export type ApplyInvalidationResult = {
+    readonly applied: boolean;
+    readonly reason?: 'already-applied' | 'invalid-certificate';
+    readonly rev?: number;
+    readonly reverted: ReadonlyArray<RevertedBlock>;
+};
+/**
+ * Deterministically applies a single-collection invalidation: the durable reversal primitive every
+ * cluster member runs identically (it carries the `reverted` targets and proof, exactly as the
+ * consensus-apply path runs committed operations on every peer).
+ *
+ * Steps, in order:
+ *  1. **Dedup** — if the log already holds an invalidation for `(invalidatedActionId, disputeId)`,
+ *     this is a re-receipt (rebroadcast / sync / retry): no-op, append nothing.
+ *  2. **Certificate** — reject (append nothing) unless `proof` is a valid challenger-wins certificate.
+ *  3. **Reverted revisions** — for each block, recompute the as-if-`T_inv`-absent content and write a
+ *     new monotonic revision (a forward compensating transform; prior revisions are retained).
+ *  4. **Log entry** — append the {@link InvalidationEntry} carrying the proof and `reverted` targets,
+ *     making `committed-invalidated` durable and recoverable on sync.
+ */
+export declare function applyInvalidation(ctx: InvalidationContext, params: ApplyInvalidationParams): Promise<ApplyInvalidationResult>;
+//# sourceMappingURL=invalidation.d.ts.map

package/dist/src/dispute/invalidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidation.d.ts","sourceRoot":"","sources":["../../../src/dispute/invalidation.ts"],"names":[],"mappings":"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"}