@typeberry/jam 0.5.8-857ec24 → 0.5.8-b3da767

package/bootstrap-importer.mjs

@@ -28975,6 +28975,113 @@ class TransitionHasher {
 
 
 
+;// CONCATENATED MODULE: ./packages/workers/importer/finality.ts
+
+const finality_logger = Logger.new(import.meta.filename, "finality");
+/**
+ * A simple finalizer that considers a block finalized when N blocks
+ * have been built on top of it.
+ *
+ * Maintains an array of fork chains starting from the last finalized block.
+ * When any chain reaches `depth`, the earliest blocks are finalized and
+ * dead forks (branching from before the finalized point) are discarded.
+ */
+class DummyFinalizer {
+    blocks;
+    depth;
+    lastFinalizedHash;
+    unfinalized = [];
+    static create(blocks, depth) {
+        return new DummyFinalizer(blocks, depth);
+    }
+    constructor(blocks, depth) {
+        this.blocks = blocks;
+        this.depth = depth;
+        this.lastFinalizedHash = blocks.getBestHeaderHash();
+        finality_logger.info `🦭 Dummy Finalizer running with depth=${depth}`;
+    }
+    onBlockImported(headerHash) {
+        const header = this.blocks.getHeader(headerHash);
+        if (header === null) {
+            return null;
+        }
+        const parentHash = header.parentHeaderHash.materialize();
+        // Try to attach the block to an existing chain at its tip.
+        let extendedChain = null;
+        for (const chain of this.unfinalized) {
+            if (chain.length > 0 && chain[chain.length - 1].isEqualTo(parentHash)) {
+                chain.push(headerHash);
+                extendedChain = chain;
+                break;
+            }
+        }
+        if (extendedChain === null) {
+            if (this.lastFinalizedHash.isEqualTo(parentHash)) {
+                // Parent is the finalized block — start a new chain.
+                const newChain = [headerHash];
+                this.unfinalized.push(newChain);
+                extendedChain = newChain;
+            }
+            else {
+                // Fork from the middle of an existing chain — copy the prefix and branch.
+                for (const chain of this.unfinalized) {
+                    const forkIdx = chain.findIndex((h) => h.isEqualTo(parentHash));
+                    if (forkIdx !== -1) {
+                        const newChain = [...chain.slice(0, forkIdx + 1), headerHash];
+                        this.unfinalized.push(newChain);
+                        extendedChain = newChain;
+                        break;
+                    }
+                }
+            }
+        }
+        if (extendedChain === null) {
+            // Orphan block — cannot attach to any known chain.
+            return null;
+        }
+        // Check if the extended chain is long enough to trigger finality.
+        // A chain of length N has N-1 blocks built on top of chain[0].
+        // We finalize chain[0] when there are >= depth blocks after it,
+        // i.e. chain.length > depth.
+        if (extendedChain.length <= this.depth) {
+            return null;
+        }
+        // The newly finalized block sits at index (length - 1 - depth).
+        const finalizedIdx = extendedChain.length - 1 - this.depth;
+        const finalizedHash = extendedChain[finalizedIdx];
+        // Collect prunable hashes and rebuild the unfinalized set.
+        // The previously finalized block's state is no longer needed.
+        const prunable = [this.lastFinalizedHash];
+        const newUnfinalized = [];
+        for (const chain of this.unfinalized) {
+            // Find the finalized block in this chain.
+            const finIdx = chain.findIndex((h) => h.isEqualTo(finalizedHash));
+            if (finIdx !== -1) {
+                // Chain contains the finalized block — it's still alive.
+                // Prune states for blocks before the finalized block.
+                for (let i = 0; i < finIdx; i++) {
+                    prunable.push(chain[i]);
+                }
+                // Keep blocks after the finalized block.
+                const remaining = chain.slice(finIdx + 1);
+                if (remaining.length > 0) {
+                    newUnfinalized.push(remaining);
+                }
+            }
+            else {
+                // Dead fork — branches from a block that is no longer finalized.
+                // Prune all its states.
+                for (const h of chain) {
+                    prunable.push(h);
+                }
+            }
+        }
+        this.lastFinalizedHash = finalizedHash;
+        this.unfinalized = newUnfinalized;
+        return { finalizedHash, prunableStateHashes: prunable };
+    }
+}
+
 // EXTERNAL MODULE: ./node_modules/@opentelemetry/api/build/src/index.js
 var src = __nccwpck_require__(5555);
 ;// CONCATENATED MODULE: ./packages/workers/importer/metrics.ts
@@ -29201,6 +29308,14 @@ class Importer {
         logger.log `${timerDb()}`;
         // finally update the best block
         await this.blocks.setBestHeaderHash(headerHash);
+        // check for finality and prune old states
+        const finality = this.options.finalizer?.onBlockImported(headerHash) ?? null;
+        if (finality !== null) {
+            this.logger.info `🦭 Finalized block: ${finality.finalizedHash} (${finality.prunableStateHashes.length} to prune)`;
+            for (const hash of finality.prunableStateHashes) {
+                this.states.markUnused(hash);
+            }
+        }
         return result_Result.ok(new WithHash(headerHash, block.header.view()));
     }
     getBestStateRootHash() {
@@ -29242,6 +29357,7 @@ function extractTimeSlot(block) {
 
 
 
+
 const main_logger = Logger.new(import.meta.filename, "importer");
 const keccakHasher = KeccakHasher.create();
 const blake2b = Blake2b.createHasher();
@@ -29251,8 +29367,13 @@ async function createImporter(config, options = {}) {
     const pvm = config.workerParams.pvm;
     const blocks = db.getBlocksDb();
     const states = db.getStatesDb();
+    const dummyFinalityDepth = config.workerParams.dummyFinalityDepth ?? 0;
+    const finalizer = dummyFinalityDepth > 0 ? DummyFinalizer.create(blocks, dummyFinalityDepth) : undefined;
     const hasher = new TransitionHasher(await keccakHasher, await blake2b);
-    const importer = new Importer(chainSpec, pvm, hasher, main_logger, blocks, states, options);
+    const importer = new Importer(chainSpec, pvm, hasher, main_logger, blocks, states, {
+        ...options,
+        finalizer,
+    });
     return {
         importer,
         db,
@@ -29570,6 +29691,7 @@ const protocol = createProtocol("importer", {
 });
 class ImporterConfig {
     pvm;
+    dummyFinalityDepth;
     static Codec = codec_codec.Class(ImporterConfig, {
         pvm: codec_codec.u8.convert((i) => tryAsU8(i), (o) => {
             if (o === PvmBackend.BuiltIn) {
@@ -29580,12 +29702,16 @@ class ImporterConfig {
             }
             throw new Error(`Invalid PvmBackend: ${o}`);
         }),
+        dummyFinalityDepth: codec_codec.u16,
     });
-    static create({ pvm }) {
-        return new ImporterConfig(pvm);
+    static create({ pvm, dummyFinalityDepth }) {
+        return new ImporterConfig(pvm, dummyFinalityDepth);
     }
-    constructor(pvm) {
+    constructor(pvm, 
+    /** Dummy finality depth. 0 means disabled, any positive value enables dummy finality with that depth. */
+    dummyFinalityDepth = numbers_tryAsU16(0)) {
         this.pvm = pvm;
+        this.dummyFinalityDepth = dummyFinalityDepth;
     }
 }