@typeberry/lib 0.9.0-3f2c45b → 0.9.0-6850f84

package/packages/jam/database/serialized-states-db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialized-states-db.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/serialized-states-db.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGlE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EACL,eAAe,EACf,KAAK,YAAY,EAGlB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE5E,qCAAqC;AACrC,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAEhG,sCAAsC;AACtC,qBAAa,wBAAyB,YAAW,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC;IAc1G,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAd1B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAyE;IAC5F,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8D;WAE1E,GAAG,CAAC,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE;IAKxD,MAAM,CAAC,UAAU,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE;QAAE,SAAS,EAAE,SAAS,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE;IAIpF,OAAO;IAKD,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAiBxG,YAAY,CAAC,KAAK,EAAE,eAAe,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAIpE,iBAAiB,CACrB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,eAAe,CAAC,MAAM,CAAC,EAC9B,MAAM,EAAE,OAAO,CAAC,KAAK,GAAG,cAAc,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAsBxC,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,IAAI;IAkB5D,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAI9B,KAAK;CACZ"}
+{"version":3,"file":"serialized-states-db.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/serialized-states-db.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGlE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EACL,eAAe,EACf,KAAK,YAAY,EAGlB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE5E,qCAAqC;AACrC,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAEhG,sCAAsC;AACtC,qBAAa,wBAAyB,YAAW,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC;IAc1G,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAd1B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAyE;IAC5F,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8D;WAE1E,GAAG,CAAC,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE;IAKxD,MAAM,CAAC,UAAU,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE;QAAE,SAAS,EAAE,SAAS,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE;IAIpF,OAAO;IAKD,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAiBxG,YAAY,CAAC,KAAK,EAAE,eAAe,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAIpE,iBAAiB,CACrB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,eAAe,CAAC,MAAM,CAAC,EAC9B,MAAM,EAAE,OAAO,CAAC,KAAK,GAAG,cAAc,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAsBxC,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,IAAI;IAkB5D,eAAe,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,IAAI;IAK7C,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAI9B,KAAK;CACZ"}

package/packages/jam/database/serialized-states-db.js

@@ -70,6 +70,10 @@ export class InMemorySerializedStates {
         });
         return SerializedState.new(this.spec, this.blake2b, leafDb);
     }
+    commitFinalized(_headers) {
+        // No value pruning here: this in-memory db keeps every value in a plain map
+        // and is not the long-running fuzz target the refcounting is meant for.
+    }
     markUnused(header) {
         this.db.delete(header);
     }

package/packages/jam/database/states.d.ts

@@ -33,6 +33,16 @@ export interface StatesDb<T extends State = State> {
     updateAndSetState(header: HeaderHash, state: T, update: Partial<State & ServicesUpdate>): Promise<Result<OK, StateUpdateError>>;
     /** Retrieve posterior state of given header. */
     getState(header: HeaderHash): T | null;
+    /**
+     * Notify the backend about newly finalized blocks, in ancestor-first order.
+     *
+     * Backends that share data between states (e.g. a content-addressed values DB)
+     * use this to move the blocks' references from speculative to finalized.
+     * MUST be called before `markUnused` of the same finality round, otherwise
+     * the newly finalized blocks would be treated as dead forks and values still
+     * referenced by the finalized state could be dropped.
+     */
+    commitFinalized(headers: HeaderHash[]): void;
     /** Mark state as no longer needed. Backend may remove it asynchronously. */
     markUnused(header: HeaderHash): void;
     /**
@@ -56,6 +66,7 @@ export declare class InMemoryStates implements StatesDb<InMemoryState> {
     /** Insert a full state into the database. */
     insertInitialState(headerHash: HeaderHash, state: InMemoryState): Promise<Result<OK, StateUpdateError>>;
     getState(headerHash: HeaderHash): InMemoryState | null;
+    commitFinalized(_headers: HeaderHash[]): void;
     markUnused(header: HeaderHash): void;
     close(): Promise<void>;
 }

package/packages/jam/database/states.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"states.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/states.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAElE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,KAAK,EAAe,MAAM,kBAAkB,CAAC;AAE/F,OAAO,EAAe,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE3D,0DAA0D;AAC1D,oBAAY,gBAAgB;IAC1B,oDAAoD;IACpD,QAAQ,IAAI;IACZ,iDAAiD;IACjD,MAAM,IAAI;CACX;AAED,wFAAwF;AACxF,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,KAAK;IACrC,qEAAqE;IACrE,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC,CAAC;CACpG;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK;IAC/C,4CAA4C;IAC5C,YAAY,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAE/C;;;;OAIG;IACH,iBAAiB,CACf,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,OAAO,CAAC,KAAK,GAAG,cAAc,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAEzC,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,CAAC,GAAG,IAAI,CAAC;IAEvC,4EAA4E;IAC5E,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAErC;;;;;OAKG;IACH,eAAe,CAAC,IAAI,MAAM,GAAG,IAAI,CAAC;IAElC,6CAA6C;IAC7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,qBAAa,cAAe,YAAW,QAAQ,CAAC,aAAa,CAAC;IAQxC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAPzC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAmE;IACtF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAE3C,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS;IAI1B,OAAO;IAID,iBAAiB,CACrB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,OAAO,CAAC,KAAK,GAAG,cAAc,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAgBlC,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IAKhE,6CAA6C;IACvC,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAM7G,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI;IAStD,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAI9B,KAAK;CACZ"}
+{"version":3,"file":"states.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/states.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAElE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,KAAK,EAAe,MAAM,kBAAkB,CAAC;AAE/F,OAAO,EAAe,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE3D,0DAA0D;AAC1D,oBAAY,gBAAgB;IAC1B,oDAAoD;IACpD,QAAQ,IAAI;IACZ,iDAAiD;IACjD,MAAM,IAAI;CACX;AAED,wFAAwF;AACxF,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,KAAK;IACrC,qEAAqE;IACrE,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC,CAAC;CACpG;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK;IAC/C,4CAA4C;IAC5C,YAAY,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAE/C;;;;OAIG;IACH,iBAAiB,CACf,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,OAAO,CAAC,KAAK,GAAG,cAAc,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAEzC,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,CAAC,GAAG,IAAI,CAAC;IAEvC;;;;;;;;OAQG;IACH,eAAe,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IAE7C,4EAA4E;IAC5E,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAErC;;;;;OAKG;IACH,eAAe,CAAC,IAAI,MAAM,GAAG,IAAI,CAAC;IAElC,6CAA6C;IAC7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,qBAAa,cAAe,YAAW,QAAQ,CAAC,aAAa,CAAC;IAQxC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAPzC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAmE;IACtF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAE3C,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS;IAI1B,OAAO;IAID,iBAAiB,CACrB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,OAAO,CAAC,KAAK,GAAG,cAAc,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAgBlC,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IAKhE,6CAA6C;IACvC,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAM7G,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI;IAStD,eAAe,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,IAAI;IAI7C,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAI9B,KAAK;CACZ"}

package/packages/jam/database/states.js

@@ -53,6 +53,9 @@ export class InMemoryStates {
         }
         return InMemoryState.copyFrom(this.spec, state, state.intoServicesData());
     }
+    commitFinalized(_headers) {
+        // nothing to do: every state is a full, independent copy.
+    }
     markUnused(header) {
         this.db.delete(header);
     }

package/packages/jam/database/value-refs.d.ts

@@ -0,0 +1,117 @@
+import type { HeaderHash } from "#@typeberry/block";
+import type { ValueHash } from "#@typeberry/trie";
+/** The value hashes a single block introduced and stopped referencing. */
+export interface ValueDelta {
+    /** Value hashes (non-embedded) that the block started referencing. */
+    inserted: ValueHash[];
+    /** Value hashes (non-embedded) that the block stopped referencing. */
+    removed: ValueHash[];
+}
+/**
+ * Synchronous, read-only view of the persisted refcounting state.
+ *
+ * Both LMDB and fjall offer synchronous reads, so reads can go straight
+ * to the backing store. All writes go through `ValueRefsUpdate` batches
+ * instead, since persistent backends can only write asynchronously
+ * (LMDB transactions, fjall inserts + persist).
+ */
+export interface ValueRefsReader {
+    /** How many leaves of the finalized-tip state reference the value. Missing keys read as `0`. */
+    getFinalizedCount(hash: ValueHash): number;
+    /** How many surviving, not-yet-finalized blocks inserted the value. Missing keys read as `0`. */
+    getPendingCount(hash: ValueHash): number;
+    /** The value delta of a not-yet-finalized block, if known. */
+    getDelta(header: HeaderHash): ValueDelta | undefined;
+}
+/**
+ * A batch of refcounting mutations produced by a single `ValueRefs` operation.
+ *
+ * The backend is responsible for applying the batch using its own write
+ * primitive - ideally atomically with the state write that triggered it
+ * (one LMDB transaction, one fjall persist).
+ *
+ * Counts are absolute values rather than increments, so applying the same
+ * update more than once (e.g. on crash-replay) is harmless.
+ *
+ * When atomicity is not available, apply in field order and `removeValues`
+ * strictly last: a crash after counts are persisted but before values are
+ * removed only leaks values, while the opposite order could drop a value
+ * the persisted counts still consider referencd.
+ */
+export interface ValueRefsUpdate {
+    /** New absolute finalized counts. Count `0` means the entry should be removed. */
+    finalizedCounts: [ValueHash, number][];
+    /** New absolute pending counts. Count `0` means the entry should be removed. */
+    pendingCounts: [ValueHash, number][];
+    /** Deltas of freshly imported blocks to persist. */
+    setDeltas: [HeaderHash, ValueDelta][];
+    /** Deltas consumed by finalization or fork pruning. */
+    removeDeltas: HeaderHash[];
+    /** Values that are no longer referenced and can be removed from the values DB. */
+    removeValues: ValueHash[];
+}
+/** `true` if applying the update would not change anything. */
+export declare function isEmptyUpdate(update: ValueRefsUpdate): boolean;
+/**
+ * Decides when a content-addressed value can be removed from the values DB.
+ *
+ * A value is needed as long as some surviving state references it. Surviving
+ * states are the finalized tip plus its unfinalized descendants, so we track:
+ * - `finalized`: how many leaves in the current finalized-tip state reference V,
+ *   advanced strictly by replaying finalized blocks' deltas (never on prune);
+ * - `pending`: how many surviving, not-yet-finalized blocks inserted V (an
+ *   over-approximation of unfinalized references).
+ *
+ * A value is removable exactly when both counts reach zero.
+ *
+ * This class only makes decisions: every operation reads the current state
+ * through `ValueRefsReader` and returns a `ValueRefsUpdate` describing what
+ * should change. Nothing is written here - the owning backend applies the
+ * update with whatever consistency guarantees it can provide.
+ */
+export declare class ValueRefs {
+    private readonly reader;
+    constructor(reader: ValueRefsReader);
+    /** Record values referenced by the genesis / initial finalized state. */
+    onInitial(inserted: ValueHash[]): ValueRefsUpdate;
+    /**
+     * Record a freshly imported, not-yet-finalized block.
+     *
+     * Importing the same header twice is a no-op, otherwise the second import
+     * would double-count `pending` references and pin the values forever.
+     */
+    onImport(header: HeaderHash, delta: ValueDelta): ValueRefsUpdate;
+    /**
+     * Apply the value deltas of newly finalized blocks, in finalized (ancestor-first) order.
+     *
+     * Moves each inserted value from `pending` to `finalized`, drops `finalized`
+     * references for removed values, and collects anything that becomes unreferenced.
+     */
+    commitFinalized(headers: HeaderHash[]): ValueRefsUpdate;
+    /**
+     * Release the speculative references of a state being discarded.
+     *
+     * For a header that was still unfinalized (a dead fork) the returned update
+     * releases its inserted values, which may become collectable. For an already
+     * finalized state the update is empty (check with `isEmptyUpdate`): its delta
+     * was consumed on finality and its values are accounted for in `finalized`.
+     */
+    releaseUnfinalized(header: HeaderHash): ValueRefsUpdate;
+}
+/**
+ * In-memory refcounting store, reusable by the in-memory and hybrid states DBs
+ * (the hybrids cannot resume from disk anyway, so persisting counts buys nothing).
+ *
+ * NOTE: `apply` does not touch the values DB - the caller owns it and must
+ * handle `update.removeValues` itself.
+ */
+export declare class InMemoryValueRefsStore implements ValueRefsReader {
+    private readonly finalized;
+    private readonly pending;
+    private readonly deltas;
+    getFinalizedCount(hash: ValueHash): number;
+    getPendingCount(hash: ValueHash): number;
+    getDelta(header: HeaderHash): ValueDelta | undefined;
+    apply(update: ValueRefsUpdate): void;
+}
+//# sourceMappingURL=value-refs.d.ts.map

package/packages/jam/database/value-refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-refs.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/value-refs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,0EAA0E;AAC1E,MAAM,WAAW,UAAU;IACzB,sEAAsE;IACtE,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,sEAAsE;IACtE,OAAO,EAAE,SAAS,EAAE,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,gGAAgG;IAChG,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC;IAC3C,iGAAiG;IACjG,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC;IACzC,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;CACtD;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,CAAC;IACvC,gFAAgF;IAChF,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,CAAC;IACrC,oDAAoD;IACpD,SAAS,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE,CAAC;IACtC,uDAAuD;IACvD,YAAY,EAAE,UAAU,EAAE,CAAC;IAC3B,kFAAkF;IAClF,YAAY,EAAE,SAAS,EAAE,CAAC;CAC3B;AAED,+DAA+D;AAC/D,wBAAgB,aAAa,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAQ9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,SAAS;IACR,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,eAAe;IAEpD,yEAAyE;IACzE,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,eAAe;IAQjD;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,eAAe;IAYhE;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,eAAe;IAoBvD;;;;;;;OAOG;IACH,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,eAAe;CAYxD;AA0ED;;;;;;GAMG;AACH,qBAAa,sBAAuB,YAAW,eAAe;IAC5D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2D;IACrF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2D;IACnF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgE;IAEvF,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;IAI1C,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;IAIxC,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS;IAIpD,KAAK,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;CAUrC"}

package/packages/jam/database/value-refs.js

@@ -0,0 +1,206 @@
+import { HashDictionary } from "#@typeberry/collections";
+/** `true` if applying the update would not change anything. */
+export function isEmptyUpdate(update) {
+    return (update.finalizedCounts.length === 0 &&
+        update.pendingCounts.length === 0 &&
+        update.setDeltas.length === 0 &&
+        update.removeDeltas.length === 0 &&
+        update.removeValues.length === 0);
+}
+/**
+ * Decides when a content-addressed value can be removed from the values DB.
+ *
+ * A value is needed as long as some surviving state references it. Surviving
+ * states are the finalized tip plus its unfinalized descendants, so we track:
+ * - `finalized`: how many leaves in the current finalized-tip state reference V,
+ *   advanced strictly by replaying finalized blocks' deltas (never on prune);
+ * - `pending`: how many surviving, not-yet-finalized blocks inserted V (an
+ *   over-approximation of unfinalized references).
+ *
+ * A value is removable exactly when both counts reach zero.
+ *
+ * This class only makes decisions: every operation reads the current state
+ * through `ValueRefsReader` and returns a `ValueRefsUpdate` describing what
+ * should change. Nothing is written here - the owning backend applies the
+ * update with whatever consistency guarantees it can provide.
+ */
+export class ValueRefs {
+    reader;
+    constructor(reader) {
+        this.reader = reader;
+    }
+    /** Record values referenced by the genesis / initial finalized state. */
+    onInitial(inserted) {
+        const update = new UpdateBuilder(this.reader);
+        for (const v of inserted) {
+            update.incFinalized(v);
+        }
+        return update.build();
+    }
+    /**
+     * Record a freshly imported, not-yet-finalized block.
+     *
+     * Importing the same header twice is a no-op, otherwise the second import
+     * would double-count `pending` references and pin the values forever.
+     */
+    onImport(header, delta) {
+        const update = new UpdateBuilder(this.reader);
+        if (update.getDelta(header) !== undefined) {
+            return update.build();
+        }
+        update.setDelta(header, delta);
+        for (const v of delta.inserted) {
+            update.incPending(v);
+        }
+        return update.build();
+    }
+    /**
+     * Apply the value deltas of newly finalized blocks, in finalized (ancestor-first) order.
+     *
+     * Moves each inserted value from `pending` to `finalized`, drops `finalized`
+     * references for removed values, and collects anything that becomes unreferenced.
+     */
+    commitFinalized(headers) {
+        const update = new UpdateBuilder(this.reader);
+        for (const header of headers) {
+            const delta = update.getDelta(header);
+            if (delta === undefined) {
+                // already committed, or not tracked (e.g. genesis)
+                continue;
+            }
+            for (const v of delta.inserted) {
+                update.incFinalized(v);
+                update.decPending(v);
+            }
+            for (const v of delta.removed) {
+                update.decFinalized(v);
+            }
+            update.removeDelta(header);
+        }
+        return update.build();
+    }
+    /**
+     * Release the speculative references of a state being discarded.
+     *
+     * For a header that was still unfinalized (a dead fork) the returned update
+     * releases its inserted values, which may become collectable. For an already
+     * finalized state the update is empty (check with `isEmptyUpdate`): its delta
+     * was consumed on finality and its values are accounted for in `finalized`.
+     */
+    releaseUnfinalized(header) {
+        const update = new UpdateBuilder(this.reader);
+        const delta = update.getDelta(header);
+        if (delta === undefined) {
+            return update.build();
+        }
+        for (const v of delta.inserted) {
+            update.decPending(v);
+        }
+        update.removeDelta(header);
+        return update.build();
+    }
+}
+/**
+ * Accumulates mutations of a single operation as an overlay over the reader,
+ * so that later steps observe earlier ones (e.g. several blocks finalized at once).
+ */
+class UpdateBuilder {
+    reader;
+    finalized = HashDictionary.new();
+    pending = HashDictionary.new();
+    setDeltas = HashDictionary.new();
+    removedDeltas = HashDictionary.new();
+    /** Values that lost a reference and may need removal - verified against final counts in `build`. */
+    removalCandidates = HashDictionary.new();
+    constructor(reader) {
+        this.reader = reader;
+    }
+    getDelta(header) {
+        if (this.removedDeltas.has(header)) {
+            return undefined;
+        }
+        return this.setDeltas.get(header) ?? this.reader.getDelta(header);
+    }
+    setDelta(header, delta) {
+        this.setDeltas.set(header, delta);
+    }
+    removeDelta(header) {
+        this.removedDeltas.set(header, header);
+    }
+    incFinalized(v) {
+        this.finalized.set(v, this.getFinalized(v) + 1);
+    }
+    decFinalized(v) {
+        this.finalized.set(v, Math.max(0, this.getFinalized(v) - 1));
+        this.removalCandidates.set(v, v);
+    }
+    incPending(v) {
+        this.pending.set(v, this.getPending(v) + 1);
+    }
+    decPending(v) {
+        this.pending.set(v, Math.max(0, this.getPending(v) - 1));
+        this.removalCandidates.set(v, v);
+    }
+    build() {
+        const removeValues = [];
+        for (const v of this.removalCandidates.values()) {
+            if (this.getFinalized(v) === 0 && this.getPending(v) === 0) {
+                removeValues.push(v);
+            }
+        }
+        return {
+            finalizedCounts: Array.from(this.finalized),
+            pendingCounts: Array.from(this.pending),
+            setDeltas: Array.from(this.setDeltas),
+            removeDeltas: Array.from(this.removedDeltas.keys()),
+            removeValues,
+        };
+    }
+    getFinalized(v) {
+        return this.finalized.get(v) ?? this.reader.getFinalizedCount(v);
+    }
+    getPending(v) {
+        return this.pending.get(v) ?? this.reader.getPendingCount(v);
+    }
+}
+/**
+ * In-memory refcounting store, reusable by the in-memory and hybrid states DBs
+ * (the hybrids cannot resume from disk anyway, so persisting counts buys nothing).
+ *
+ * NOTE: `apply` does not touch the values DB - the caller owns it and must
+ * handle `update.removeValues` itself.
+ */
+export class InMemoryValueRefsStore {
+    finalized = HashDictionary.new();
+    pending = HashDictionary.new();
+    deltas = HashDictionary.new();
+    getFinalizedCount(hash) {
+        return this.finalized.get(hash) ?? 0;
+    }
+    getPendingCount(hash) {
+        return this.pending.get(hash) ?? 0;
+    }
+    getDelta(header) {
+        return this.deltas.get(header);
+    }
+    apply(update) {
+        applyCounts(this.finalized, update.finalizedCounts);
+        applyCounts(this.pending, update.pendingCounts);
+        for (const [header, delta] of update.setDeltas) {
+            this.deltas.set(header, delta);
+        }
+        for (const header of update.removeDeltas) {
+            this.deltas.delete(header);
+        }
+    }
+}
+function applyCounts(store, counts) {
+    for (const [hash, count] of counts) {
+        if (count === 0) {
+            store.delete(hash);
+        }
+        else {
+            store.set(hash, count);
+        }
+    }
+}

package/packages/jam/database/value-refs.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=value-refs.test.d.ts.map

package/packages/jam/database/value-refs.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-refs.test.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/value-refs.test.ts"],"names":[],"mappings":""}

package/packages/jam/database/value-refs.test.js

@@ -0,0 +1,165 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { InMemoryValueRefsStore, isEmptyUpdate, ValueRefs, } from "./value-refs.js";
+function vh(n) {
+    return Bytes.fill(HASH_SIZE, n).asOpaque();
+}
+function hh(n) {
+    return Bytes.fill(HASH_SIZE, n).asOpaque();
+}
+/** Tracks which value hashes are present in the (simulated) values DB. */
+class TrackingValues {
+    present = new Set();
+    write(h) {
+        this.present.add(h.toString());
+    }
+    delete(h) {
+        this.present.delete(h.toString());
+    }
+    has(h) {
+        return this.present.has(h.toString());
+    }
+}
+function setup() {
+    const store = new InMemoryValueRefsStore();
+    const refs = new ValueRefs(store);
+    const values = new TrackingValues();
+    // what every backend is expected to do with an update
+    const apply = (update) => {
+        store.apply(update);
+        for (const v of update.removeValues) {
+            values.delete(v);
+        }
+    };
+    return { refs, store, values, apply };
+}
+/** Simulate importing a block: write inserted values + record the delta. */
+function importBlock({ refs, values, apply }, header, delta) {
+    const full = { inserted: delta.inserted ?? [], removed: delta.removed ?? [] };
+    for (const v of full.inserted) {
+        values.write(v);
+    }
+    apply(refs.onImport(header, full));
+}
+describe("ValueRefs", () => {
+    it("deletes a value once its only finalized reference is removed", () => {
+        const s = setup();
+        const { refs, values, apply } = s;
+        const V = vh(1);
+        importBlock(s, hh(1), { inserted: [V] });
+        apply(refs.commitFinalized([hh(1)]));
+        assert.ok(values.has(V), "kept while referenced by finalized tip");
+        importBlock(s, hh(2), { removed: [V] });
+        apply(refs.commitFinalized([hh(2)]));
+        assert.ok(!values.has(V), "deleted after last finalized reference removed");
+    });
+    it("keeps a value referenced under multiple keys until all references are gone", () => {
+        const s = setup();
+        const { refs, values, apply } = s;
+        const V = vh(1);
+        importBlock(s, hh(1), { inserted: [V] });
+        apply(refs.commitFinalized([hh(1)]));
+        importBlock(s, hh(2), { inserted: [V] });
+        apply(refs.commitFinalized([hh(2)]));
+        importBlock(s, hh(3), { removed: [V] });
+        apply(refs.commitFinalized([hh(3)]));
+        assert.ok(values.has(V), "kept while one reference remains");
+        importBlock(s, hh(4), { removed: [V] });
+        apply(refs.commitFinalized([hh(4)]));
+        assert.ok(!values.has(V), "deleted after the last reference");
+    });
+    it("keeps a value removed on the finalized chain while an unfinalized fork re-adds it", () => {
+        const s = setup();
+        const { refs, values, apply } = s;
+        const V = vh(1);
+        // genesis already references V
+        apply(refs.onInitial([V]));
+        values.write(V);
+        // finalized chain removes V
+        importBlock(s, hh(10), { removed: [V] });
+        // an unfinalized fork re-adds V
+        importBlock(s, hh(20), { inserted: [V] });
+        apply(refs.commitFinalized([hh(10)]));
+        assert.ok(values.has(V), "kept because an unfinalized fork still references V");
+    });
+    it("collects a value that lived only on a discarded fork", () => {
+        const s = setup();
+        const { refs, values, apply } = s;
+        const W = vh(2);
+        importBlock(s, hh(30), { inserted: [W] });
+        assert.ok(values.has(W));
+        const update = refs.releaseUnfinalized(hh(30));
+        apply(update);
+        assert.strictEqual(isEmptyUpdate(update), false);
+        assert.ok(!values.has(W), "dead-fork-only value is collected");
+    });
+    it("does not touch finalized references when releasing an already finalized header", () => {
+        const s = setup();
+        const { refs, values, apply } = s;
+        const V = vh(1);
+        importBlock(s, hh(1), { inserted: [V] });
+        apply(refs.commitFinalized([hh(1)]));
+        const update = refs.releaseUnfinalized(hh(1));
+        apply(update);
+        assert.strictEqual(isEmptyUpdate(update), true, "header was already finalized");
+        assert.ok(values.has(V), "finalized value is untouched");
+    });
+    it("ignores unknown headers in commitFinalized", () => {
+        const { refs } = setup();
+        const update = refs.commitFinalized([hh(99)]);
+        assert.strictEqual(isEmptyUpdate(update), true);
+    });
+    it("ignores a duplicate import of the same header", () => {
+        const s = setup();
+        const { refs, values, apply } = s;
+        const V = vh(1);
+        importBlock(s, hh(1), { inserted: [V] });
+        const second = refs.onImport(hh(1), { inserted: [V], removed: [] });
+        assert.strictEqual(isEmptyUpdate(second), true, "duplicate import is a no-op");
+        // had the duplicate bumped `pending` twice, releasing the fork would leave
+        // a dangling count and the value would never be collected
+        apply(refs.releaseUnfinalized(hh(1)));
+        assert.ok(!values.has(V));
+    });
+    it("counts a header only once within a single commitFinalized call", () => {
+        const s = setup();
+        const { refs, values, apply } = s;
+        const V = vh(1);
+        importBlock(s, hh(1), { inserted: [V] });
+        apply(refs.commitFinalized([hh(1), hh(1)]));
+        importBlock(s, hh(2), { removed: [V] });
+        apply(refs.commitFinalized([hh(2)]));
+        assert.ok(!values.has(V), "a double-counted finalized reference would keep the value alive");
+    });
+    it("does not remove a value re-referenced later within the same batch", () => {
+        const s = setup();
+        const { refs, values, apply } = s;
+        const V = vh(1);
+        apply(refs.onInitial([V]));
+        values.write(V);
+        // one block removes V, its descendant re-adds it; both finalize at once
+        importBlock(s, hh(1), { removed: [V] });
+        importBlock(s, hh(2), { inserted: [V] });
+        const update = refs.commitFinalized([hh(1), hh(2)]);
+        apply(update);
+        assert.strictEqual(update.removeValues.length, 0);
+        assert.ok(values.has(V), "the re-added reference keeps the value alive");
+    });
+    it("emits absolute counts so re-applying an update is harmless", () => {
+        const s = setup();
+        const { refs, store, values, apply } = s;
+        const V = vh(1);
+        importBlock(s, hh(1), { inserted: [V] });
+        const update = refs.commitFinalized([hh(1)]);
+        apply(update);
+        // crash-replay: same batch applied again
+        apply(update);
+        assert.strictEqual(store.getFinalizedCount(V), 1);
+        assert.strictEqual(store.getPendingCount(V), 0);
+        importBlock(s, hh(2), { removed: [V] });
+        apply(refs.commitFinalized([hh(2)]));
+        assert.ok(!values.has(V), "refcounting still exact after replay");
+    });
+});

package/packages/jam/database-fjall/hybrid-states.d.ts

@@ -39,6 +39,14 @@ export declare class FjallValuesSession {
  *
  * Construction is async, and value writes are flushed explicitly, because fjall
  * has no transaction primitive.
+ *
+ * Values that no longer belong to any surviving state are removed from fjall,
+ * decided by in-memory refcounting (`ValueRefs`) driven by the importer's
+ * finality signal. Counts are not persisted: this db cannot resume from disk
+ * anyway (the leaf sets live in memory), so values left over by a previous run
+ * are never collected. An instance backed by a shared session (fuzz reset
+ * reuse) only ever prunes values it inserted itself, since its refcounts start
+ * empty - values left behind by earlier resets stay untouched.
  */
 export declare class HybridSerializedStates implements StatesDb<SerializedState<LeafDb>>, InitStatesDb<StateEntries> {
     private readonly spec;
@@ -66,13 +74,19 @@ export declare class HybridSerializedStates implements StatesDb<SerializedState<
     private readonly valuesDb;
     /** Shared content-addressed values partition (owned by `session`). */
     private readonly values;
+    private readonly refsStore;
+    private readonly refs;
+    private pendingCleanup;
     private constructor();
     insertInitialState(headerHash: HeaderHash, entries: StateEntries): Promise<Result<OK, StateUpdateError>>;
     updateAndSetState(header: HeaderHash, state: SerializedState<LeafDb>, update: Partial<State & ServicesUpdate>): Promise<Result<OK, StateUpdateError>>;
     getStateRoot(state: SerializedState<LeafDb>): Promise<StateRootHash>;
     getState(header: HeaderHash): SerializedState<LeafDb> | null;
+    commitFinalized(headers: HeaderHash[]): void;
     markUnused(header: HeaderHash): void;
     diskSizeInBytes(): number | null;
+    /** Apply a refcounting update and remove values that lost their last reference. */
+    private applyRefs;
     close(): Promise<void>;
     /** Write new large values to fjall in a single batch, then flush. */
     private writeValues;

package/packages/jam/database-fjall/hybrid-states.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hybrid-states.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database-fjall/hybrid-states.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"hybrid-states.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database-fjall/hybrid-states.ts"],"names":[],"mappings":"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"}