@typeberry/lib 0.8.3 → 0.8.4-70b1490

package/packages/workers/api-node/config.js

@@ -1,7 +1,8 @@
 import { Decoder, Encoder } from "#@typeberry/codec";
 import { ChainSpec } from "#@typeberry/config";
 import { InMemoryBlocks, InMemorySerializedStates, } from "#@typeberry/database";
-import { HybridSerializedStates, LmdbBlocks, LmdbRoot, LmdbStates } from "#@typeberry/database-lmdb";
+import { HybridSerializedStates as FjallHybridSerializedStates } from "#@typeberry/database-fjall";
+import { LmdbBlocks, HybridSerializedStates as LmdbHybridSerializedStates, LmdbRoot, LmdbStates, } from "#@typeberry/database-lmdb";
 import { Blake2b } from "#@typeberry/hash";
 import { ThreadPort } from "./port.js";
 /** A worker config that's usable in node.js and uses LMDB database backend. */
@@ -32,9 +33,9 @@ export class LmdbWorkerConfig {
         });
     }
     constructor(nodeName, chainSpec, workerParams, dbPath, blake2b, ports, 
-    // When set, the underlying LMDB skips fsync and compression. Only safe for
-    // throwaway databases (the fuzz target wipes on reset). Not transferred to
-    // worker threads, so the durable main node path always gets the default.
+    // When set, the underlying LMDB skips fsync. Only safe for throwaway
+    // databases (the fuzz target wipes on reset). Not transferred to worker
+    // threads, so the durable main node path always gets the default.
     ephemeral = false) {
         this.nodeName = nodeName;
         this.chainSpec = chainSpec;
@@ -45,7 +46,10 @@ export class LmdbWorkerConfig {
         this.ephemeral = ephemeral;
     }
     openDatabase(options = { readonly: true }) {
-        const lmdb = LmdbRoot.new(this.dbPath, options.readonly, this.ephemeral);
+        const lmdb = LmdbRoot.new(this.dbPath, {
+            readOnly: options.readonly,
+            ephemeral: this.ephemeral,
+        });
         return {
             getBlocksDb: () => LmdbBlocks.new(this.chainSpec, lmdb),
             getStatesDb: () => LmdbStates.new(this.chainSpec, this.blake2b, lmdb),
@@ -107,11 +111,15 @@ export class InMemWorkerConfig {
 }
 /**
  * Hybrid worker config for the fuzz target: in-memory blocks and leaf sets,
- * but large values persisted to LMDB.
+ * but large values persisted to disk (LMDB or fjall, selected by `backend`).
+ *
+ * The fjall backend is opt-in so its performance can be compared against LMDB
+ * before committing to it. fjall opens its keyspace asynchronously, hence the
+ * async `new`.
  *
  * Like `InMemWorkerConfig`, the blocks and leaf sets are shared across the
  * open/close/reopen dance that genesis init performs, so `openDatabase`
- * returns the same instances and a no-op close. The LMDB root is opened once
+ * returns the same instances and a no-op close. The values store is opened once
  * here and closed by `HybridSerializedStates.close()` at importer teardown.
  *
  * In-process only: it holds shared mutable state (the in-memory leaf
@@ -125,33 +133,34 @@ export class HybridWorkerConfig {
     blake2b;
     dbPath;
     ephemeral;
-    static new({ nodeName, chainSpec, workerParams, blake2b, dbPath, ephemeral = false, }) {
-        return new HybridWorkerConfig(nodeName, chainSpec, workerParams, blake2b, dbPath, ephemeral);
+    compression;
+    states;
+    static async new({ nodeName, chainSpec, workerParams, blake2b, dbPath, ephemeral = false, compression = true, backend = "lmdb", }) {
+        // fjall opens its keyspace asynchronously; LMDB is synchronous. Either way
+        // the values store is created once here and shared across reopen.
+        const states = backend === "fjall"
+            ? await FjallHybridSerializedStates.new({ spec: chainSpec, blake2b, dbPath, ephemeral })
+            : LmdbHybridSerializedStates.new({ spec: chainSpec, blake2b, dbPath, ephemeral, compression, readOnly: false });
+        return new HybridWorkerConfig(nodeName, chainSpec, workerParams, blake2b, dbPath, ephemeral, compression, states);
     }
     blocks;
-    states;
-    constructor(nodeName, chainSpec, workerParams, blake2b, dbPath, ephemeral) {
+    constructor(nodeName, chainSpec, workerParams, blake2b, dbPath, ephemeral, compression, states) {
         this.nodeName = nodeName;
         this.chainSpec = chainSpec;
         this.workerParams = workerParams;
         this.blake2b = blake2b;
         this.dbPath = dbPath;
         this.ephemeral = ephemeral;
+        this.compression = compression;
+        this.states = states;
         this.blocks = InMemoryBlocks.new();
-        this.states = HybridSerializedStates.new({
-            spec: this.chainSpec,
-            blake2b: this.blake2b,
-            dbPath: this.dbPath,
-            ephemeral: this.ephemeral,
-            readOnly: false,
-        });
     }
     openDatabase(_options = { readonly: true }) {
         return {
             getBlocksDb: () => this.blocks,
             getStatesDb: () => this.states,
-            // Leaf sets and blocks live in memory; the LMDB values store is closed
-            // via states.close() at importer teardown, so this is a no-op.
+            // Leaf sets and blocks live in memory; the values store is closed via
+            // states.close() at importer teardown, so this is a no-op.
             close: async () => { },
         };
     }

package/packages/workers/api-node/config.test.js

@@ -1,11 +1,12 @@
 import assert from "node:assert";
+import * as fs from "node:fs";
 import { describe, it } from "node:test";
 import { MessageChannel } from "node:worker_threads";
 import { codec } from "#@typeberry/codec";
 import { tinyChainSpec } from "#@typeberry/config";
 import { Blake2b } from "#@typeberry/hash";
 import { tryAsU32 } from "#@typeberry/numbers";
-import { configTransferList, LmdbWorkerConfig } from "./config.js";
+import { configTransferList, HybridWorkerConfig, LmdbWorkerConfig } from "./config.js";
 import { ThreadPort } from "./port.js";
 const spec = tinyChainSpec;
 describe("LmdbWorkerConfig transfer list", () => {
@@ -39,3 +40,39 @@ describe("LmdbWorkerConfig transfer list", () => {
         }
     });
 });
+describe("HybridWorkerConfig", () => {
+    // Both persistent backends must construct asynchronously and hand out a
+    // working db. fjall is the experimental backend we want to benchmark.
+    for (const backend of ["lmdb", "fjall"]) {
+        it(`constructs and opens a ${backend}-backed hybrid db`, async () => {
+            const blake2b = await Blake2b.createHasher();
+            const dbPath = fs.mkdtempSync(`typeberry-hybrid-${backend}-`);
+            try {
+                const config = await HybridWorkerConfig.new({
+                    nodeName: "node",
+                    chainSpec: spec,
+                    workerParams: undefined,
+                    blake2b,
+                    dbPath,
+                    ephemeral: true,
+                    backend,
+                });
+                const db = config.openDatabase({ readonly: false });
+                const states = db.getStatesDb();
+                try {
+                    assert.notStrictEqual(db.getBlocksDb(), undefined);
+                    assert.notStrictEqual(states, undefined);
+                }
+                finally {
+                    // The values store owns the on-disk resources (the no-op db.close()
+                    // does not), so close it explicitly to release the fjall keyspace.
+                    await states.close();
+                    await db.close();
+                }
+            }
+            finally {
+                fs.rmSync(dbPath, { recursive: true, force: true });
+            }
+        });
+    }
+});

package/packages/workers/block-authorship/{generator.d.ts → block-generator.d.ts}

@@ -18,7 +18,7 @@ import { type Opaque } from "#@typeberry/utils";
  *
  */
 export type BlockSealInput = Opaque<BytesBlob, "Seal">;
-/** Construction arguments for {@link Generator}. */
+/** Construction arguments for `BlockGenerator`. */
 export type GeneratorArgs = {
     chainSpec: ChainSpec;
     bandersnatch: BandernsatchWasm;
@@ -27,7 +27,7 @@ export type GeneratorArgs = {
     blocks: BlocksDb;
     states: StatesDb;
 };
-export declare class Generator {
+export declare class BlockGenerator {
     private readonly metrics;
     readonly chainSpec: ChainSpec;
     readonly bandersnatch: BandernsatchWasm;
@@ -35,8 +35,8 @@ export declare class Generator {
     readonly blake2b: Blake2b;
     private readonly blocks;
     private readonly states;
-    /** Build a {@link Generator} from its collaborators. */
-    static new(args: GeneratorArgs): Generator;
+    /** Build a block generator from its collaborators. */
+    static new(args: GeneratorArgs): BlockGenerator;
     private constructor();
     private getLastHeaderAndState;
     nextBlockView(validatorIndex: ValidatorIndex, bandersnatchSecret: BandersnatchSecretSeed, sealPayload: BlockSealInput, timeSlot: TimeSlot, pendingTickets?: {
@@ -71,4 +71,4 @@ export declare class Generator {
         id: EntropyHash;
     }[]): Promise<Block>;
 }
-//# sourceMappingURL=generator.d.ts.map
+//# sourceMappingURL=block-generator.d.ts.map

package/packages/workers/block-authorship/block-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-generator.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/block-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,KAAK,WAAW,EAIhB,KAAK,QAAQ,EACb,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,2BAA2B,CAAC;AAEtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAS,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAoC,KAAK,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAClG,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAIvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAGhF,OAAO,EAAqB,KAAK,MAAM,EAAU,MAAM,kBAAkB,CAAC;AAM1E;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;AAEvD,mDAAmD;AACnD,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,gBAAgB,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,QAAQ,CAAC;IACjB,MAAM,EAAE,QAAQ,CAAC;CAClB,CAAC;AAEF,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2C;IAEnE,SAAgB,SAAS,EAAE,SAAS,CAAC;IACrC,SAAgB,YAAY,EAAE,gBAAgB,CAAC;IAC/C,SAAgB,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC;IAClD,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAElC,sDAAsD;IACtD,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,aAAa;IAI9B,OAAO;IAUP,OAAO,CAAC,qBAAqB;IAYvB,aAAa,CACjB,cAAc,EAAE,cAAc,EAC9B,kBAAkB,EAAE,sBAAsB,EAC1C,WAAW,EAAE,cAAc,EAC3B,QAAQ,EAAE,QAAQ,EAClB,cAAc,GAAE;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,EAAE,EAAE,WAAW,CAAA;KAAE,EAAO,GAC/D,OAAO,CAAC,SAAS,CAAC;IAKrB;;;;;;;;;OASG;YACW,cAAc;IAiB5B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,uBAAuB;IA4BzB,SAAS,CACb,cAAc,EAAE,cAAc,EAC9B,kBAAkB,EAAE,sBAAsB,EAC1C,WAAW,EAAE,cAAc,EAC3B,QAAQ,EAAE,QAAQ,EAClB,cAAc,GAAE;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,EAAE,EAAE,WAAW,CAAA;KAAE,EAAO;CAqGnE"}

package/packages/workers/block-authorship/{generator.js → block-generator.js}

@@ -13,7 +13,7 @@ import { asOpaqueType, now, Result } from "#@typeberry/utils";
 import * as metrics from "./metrics.js";
 const EMPTY_AUX_DATA = BytesBlob.empty();
 const logger = Logger.new(import.meta.filename, "author");
-export class Generator {
+export class BlockGenerator {
     metrics;
     chainSpec;
     bandersnatch;
@@ -21,9 +21,9 @@ export class Generator {
     blake2b;
     blocks;
     states;
-    /** Build a {@link Generator} from its collaborators. */
+    /** Build a block generator from its collaborators. */
     static new(args) {
-        return new Generator(args);
+        return new BlockGenerator(args);
     }
     constructor(args) {
         this.chainSpec = args.chainSpec;

package/packages/workers/block-authorship/block-generator.test.d.ts

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

package/packages/workers/block-authorship/block-generator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-generator.test.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/block-generator.test.ts"],"names":[],"mappings":""}

package/packages/workers/block-authorship/{generator.test.js → block-generator.test.js}

@@ -13,7 +13,7 @@ import { JAM_FALLBACK_SEAL } from "#@typeberry/safrole/constants.js";
 import { VALIDATOR_META_BYTES, ValidatorData } from "#@typeberry/state";
 import { SafroleSealingKeysKind } from "#@typeberry/state/safrole-data.js";
 import { asOpaqueType, deepEqual, Result } from "#@typeberry/utils";
-import { Generator } from "./generator.js";
+import { BlockGenerator } from "./block-generator.js";
 // Test validator data - need 6 validators to match tinyChainSpec.validatorsCount
 const validatorDataArray = [
     {
@@ -157,7 +157,7 @@ describe("Generator", () => {
             const state = createMockState(0);
             const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
             const statesDb = createMockStatesDb(state);
-            const generator = Generator.new({
+            const generator = BlockGenerator.new({
                 chainSpec: tinyChainSpec,
                 bandersnatch,
                 keccakHasher,
@@ -180,7 +180,7 @@ describe("Generator", () => {
             const state = createMockState(0);
             const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
             const statesDb = createMockStatesDb(state);
-            const generator = Generator.new({
+            const generator = BlockGenerator.new({
                 chainSpec: tinyChainSpec,
                 bandersnatch,
                 keccakHasher,
@@ -225,7 +225,7 @@ describe("Generator", () => {
             const state = createMockState(9);
             const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
             const statesDb = createMockStatesDb(state);
-            const generator = Generator.new({
+            const generator = BlockGenerator.new({
                 chainSpec: tinyChainSpec,
                 bandersnatch,
                 keccakHasher,
@@ -262,7 +262,7 @@ describe("Generator", () => {
             };
             const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
             const statesDb = createMockStatesDb(state);
-            const generator = Generator.new({
+            const generator = BlockGenerator.new({
                 chainSpec: tinyChainSpec,
                 bandersnatch,
                 keccakHasher,
@@ -300,7 +300,7 @@ describe("Generator", () => {
             const state = createMockState(0);
             const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
             const statesDb = createMockStatesDb(state);
-            const generator = Generator.new({
+            const generator = BlockGenerator.new({
                 chainSpec: tinyChainSpec,
                 bandersnatch,
                 keccakHasher,
@@ -338,7 +338,7 @@ describe("Generator", () => {
             const state = createMockState(0);
             const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
             const statesDb = createMockStatesDb(state);
-            const generator = Generator.new({
+            const generator = BlockGenerator.new({
                 chainSpec: tinyChainSpec,
                 bandersnatch,
                 keccakHasher,
@@ -384,7 +384,7 @@ describe("Generator", () => {
             const state = createMockState(lastSlotOfEpoch0);
             const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
             const statesDb = createMockStatesDb(state);
-            const generator = Generator.new({
+            const generator = BlockGenerator.new({
                 chainSpec: tinyChainSpec,
                 bandersnatch,
                 keccakHasher,

package/packages/workers/block-authorship/epoch-authoring-slots.d.ts

@@ -0,0 +1,35 @@
+import type { EntropyHash } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import type { BandersnatchKey, BandersnatchSecretSeed, Ed25519Key, Ed25519SecretSeed } from "#@typeberry/crypto";
+import type { BandernsatchWasm } from "#@typeberry/safrole/bandersnatch-wasm.js";
+import { type SafroleSealingKeys } from "#@typeberry/state";
+import type { BlockSealInput } from "./block-generator.js";
+import type { ValidatorSecrets } from "./protocol.js";
+type ValidatorPrivateKeys = {
+    bandersnatchSecret: BandersnatchSecretSeed;
+    ed25519Secret: Ed25519SecretSeed;
+};
+type ValidatorPublicKeys = {
+    bandersnatchPublic: BandersnatchKey;
+    ed25519Public: Ed25519Key;
+};
+type ValidatorKeys = ValidatorPrivateKeys & ValidatorPublicKeys;
+export type SlotSealData = {
+    key: ValidatorKeys;
+    sealPayload: BlockSealInput;
+    logId: string;
+};
+/** A helper class to figure out in which slots in the next epoch we are authoring blocks. */
+export declare class EpochAuthoringSlots {
+    private readonly ticketsPerValidator;
+    private readonly bandersnatch;
+    private readonly keys;
+    static new(chainSpec: ChainSpec, bandersnatch: BandernsatchWasm, ownedSecrets: readonly ValidatorSecrets[]): Promise<EpochAuthoringSlots>;
+    private constructor();
+    getValidatorKeys(): ValidatorKeys[];
+    getBandersnatchPublicKeys(): (import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"BandersnatchKey">)[];
+    getOurSlotsInKeySeries(sealingKeySeries: SafroleSealingKeys, entropy: EntropyHash): Promise<Array<SlotSealData | null>>;
+    private getOwnTicketIds;
+}
+export {};
+//# sourceMappingURL=epoch-authoring-slots.d.ts.map

package/packages/workers/block-authorship/epoch-authoring-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epoch-authoring-slots.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/epoch-authoring-slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGhH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAEhF,OAAO,EAAE,KAAK,kBAAkB,EAA0B,MAAM,kBAAkB,CAAC;AAEnF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,KAAK,oBAAoB,GAAG;IAC1B,kBAAkB,EAAE,sBAAsB,CAAC;IAC3C,aAAa,EAAE,iBAAiB,CAAC;CAClC,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACzB,kBAAkB,EAAE,eAAe,CAAC;IACpC,aAAa,EAAE,UAAU,CAAC;CAC3B,CAAC;AAEF,KAAK,aAAa,GAAG,oBAAoB,GAAG,mBAAmB,CAAC;AAEhE,MAAM,MAAM,YAAY,GAAG;IACzB,GAAG,EAAE,aAAa,CAAC;IACnB,WAAW,EAAE,cAAc,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,6FAA6F;AAC7F,qBAAa,mBAAmB;IAY5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,IAAI;WAbV,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,SAAS,gBAAgB,EAAE;IAUhH,OAAO;IAMP,gBAAgB;IAIhB,yBAAyB;IAInB,sBAAsB,CAC1B,gBAAgB,EAAE,kBAAkB,EACpC,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;YAuBxB,eAAe;CAmB9B"}

package/packages/workers/block-authorship/epoch-authoring-slots.js

@@ -0,0 +1,86 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { HashDictionary } from "#@typeberry/collections";
+import { deriveBandersnatchPublicKey, deriveEd25519PublicKey } from "#@typeberry/crypto/key-derivation.js";
+import bandersnatchVrf from "#@typeberry/safrole/bandersnatch-vrf.js";
+import { JAM_FALLBACK_SEAL, JAM_TICKET_SEAL } from "#@typeberry/safrole/constants.js";
+import { SafroleSealingKeysKind } from "#@typeberry/state";
+import { asOpaqueType } from "#@typeberry/utils";
+/** A helper class to figure out in which slots in the next epoch we are authoring blocks. */
+export class EpochAuthoringSlots {
+    ticketsPerValidator;
+    bandersnatch;
+    keys;
+    static async new(chainSpec, bandersnatch, ownedSecrets) {
+        const keys = await derivePublicKeys(ownedSecrets);
+        const keysDictionary = new HashDictionary();
+        for (const key of keys) {
+            keysDictionary.set(key.bandersnatchPublic, key);
+        }
+        return new EpochAuthoringSlots(chainSpec.ticketsPerValidator, bandersnatch, keysDictionary);
+    }
+    constructor(ticketsPerValidator, bandersnatch, keys) {
+        this.ticketsPerValidator = ticketsPerValidator;
+        this.bandersnatch = bandersnatch;
+        this.keys = keys;
+    }
+    getValidatorKeys() {
+        return Array.from(this.keys.values());
+    }
+    getBandersnatchPublicKeys() {
+        return Array.from(this.keys.keys());
+    }
+    async getOurSlotsInKeySeries(sealingKeySeries, entropy) {
+        // Fallback (keys) mode. Just find keys that match ours.
+        if (sealingKeySeries.kind === SafroleSealingKeysKind.Keys) {
+            const sealPayload = getFallbackSealPayload(entropy);
+            return sealingKeySeries.keys.map((author) => {
+                const key = this.keys.get(author);
+                if (key === undefined) {
+                    return null;
+                }
+                return {
+                    key,
+                    sealPayload,
+                    logId: `key ${key.bandersnatchPublic.toStringTruncated()}`,
+                };
+            });
+        }
+        // Tickets mode. Generate own VrfOutputHash for our tickets (cheap) and check if it matches.
+        const ownTickets = await this.getOwnTicketIds(entropy);
+        const slots = sealingKeySeries.tickets.map((ticket) => ownTickets.get(ticket.id.asOpaque()) ?? null);
+        return slots;
+    }
+    async getOwnTicketIds(entropy) {
+        // generate our own tickets first
+        const ownTickets = new HashDictionary();
+        for (let attempt = 0; attempt < this.ticketsPerValidator; attempt++) {
+            const sealPayload = getTicketSealPayload(entropy, attempt);
+            for (const key of this.keys.values()) {
+                const result = await bandersnatchVrf.getVrfOutputHash(this.bandersnatch, key.bandersnatchSecret, sealPayload);
+                if (result.isOk) {
+                    const ticketId = result.ok.asOpaque();
+                    ownTickets.set(ticketId, {
+                        key,
+                        sealPayload,
+                        logId: `ticket ${ticketId} (attempt ${attempt})`,
+                    });
+                }
+            }
+        }
+        return ownTickets;
+    }
+}
+function derivePublicKeys(keys) {
+    return Promise.all(keys.map(async (secrets) => ({
+        bandersnatchSecret: secrets.bandersnatch,
+        bandersnatchPublic: deriveBandersnatchPublicKey(secrets.bandersnatch),
+        ed25519Secret: secrets.ed25519,
+        ed25519Public: await deriveEd25519PublicKey(secrets.ed25519),
+    })));
+}
+function getTicketSealPayload(entropy, attempt) {
+    return asOpaqueType(BytesBlob.blobFromParts(JAM_TICKET_SEAL, entropy.raw, new Uint8Array([attempt])));
+}
+function getFallbackSealPayload(entropy) {
+    return asOpaqueType(BytesBlob.blobFromParts(JAM_FALLBACK_SEAL, entropy.raw));
+}

package/packages/workers/block-authorship/epoch-tracker.d.ts

@@ -0,0 +1,29 @@
+import { type EntropyHash, type Epoch, type TimeSlot } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import type { Blake2b } from "#@typeberry/hash";
+import type { Logger } from "#@typeberry/logger";
+import type { BandernsatchWasm } from "#@typeberry/safrole/bandersnatch-wasm.js";
+import { type SafroleSealingKeys, type State } from "#@typeberry/state";
+import { Result } from "#@typeberry/utils";
+import { EpochAuthoringSlots, type SlotSealData } from "./epoch-authoring-slots.js";
+import type { ValidatorSecrets } from "./protocol.js";
+/** Per-epoch data computed once when entering (or resuming into) an epoch. */
+export type EpochData = {
+    epoch: Epoch;
+    epochLength: number;
+    sealingKeySeries: SafroleSealingKeys;
+    entropy: EntropyHash;
+    slots: Array<SlotSealData | null>;
+};
+export declare class EpochTracker {
+    private readonly chainSpec;
+    private readonly blake2bHasher;
+    readonly authoring: EpochAuthoringSlots;
+    static new(chainSpec: ChainSpec, bandersnatch: BandernsatchWasm, blake2bHasher: Blake2b, keys: readonly ValidatorSecrets[]): Promise<EpochTracker>;
+    private constructor();
+    isEpochChanged(stateTimeSlot: TimeSlot, newTimeSlot: TimeSlot): boolean;
+    getEpochData(logger: Logger, state: State, newTimeSlot: TimeSlot): Promise<Result<EpochData, string>>;
+    private getSealingKeySeries;
+    private logEpochAuthorshipInfo;
+}
+//# sourceMappingURL=epoch-tracker.d.ts.map

package/packages/workers/block-authorship/epoch-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epoch-tracker.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/epoch-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,KAAK,EAAE,KAAK,QAAQ,EAAc,MAAM,kBAAkB,CAAC;AAC3F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,EAAE,KAAK,kBAAkB,EAA0B,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC/F,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,mBAAmB,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAC;AACpF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,8EAA8E;AAC9E,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,kBAAkB,CAAC;IACrC,OAAO,EAAE,WAAW,CAAC;IACrB,KAAK,EAAE,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;CACnC,CAAC;AAEF,qBAAa,YAAY;IAYrB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,aAAa;aACd,SAAS,EAAE,mBAAmB;WAbnC,GAAG,CACd,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,gBAAgB,EAC9B,aAAa,EAAE,OAAO,EACtB,IAAI,EAAE,SAAS,gBAAgB,EAAE;IAMnC,OAAO;IAMP,cAAc,CAAC,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO;IAOjE,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YA+B7F,mBAAmB;IAejC,OAAO,CAAC,sBAAsB;CAe/B"}

package/packages/workers/block-authorship/epoch-tracker.js

@@ -0,0 +1,80 @@
+import { tryAsEpoch } from "#@typeberry/block";
+import { Safrole } from "#@typeberry/safrole";
+import { SafroleSealingKeysKind } from "#@typeberry/state";
+import { Result } from "#@typeberry/utils";
+import { EpochAuthoringSlots } from "./epoch-authoring-slots.js";
+export class EpochTracker {
+    chainSpec;
+    blake2bHasher;
+    authoring;
+    static async new(chainSpec, bandersnatch, blake2bHasher, keys) {
+        const epochSlots = await EpochAuthoringSlots.new(chainSpec, bandersnatch, keys);
+        return new EpochTracker(chainSpec, blake2bHasher, epochSlots);
+    }
+    constructor(chainSpec, blake2bHasher, authoring) {
+        this.chainSpec = chainSpec;
+        this.blake2bHasher = blake2bHasher;
+        this.authoring = authoring;
+    }
+    isEpochChanged(stateTimeSlot, newTimeSlot) {
+        const epochLength = this.chainSpec.epochLength;
+        const stateEpoch = Math.floor(stateTimeSlot / epochLength);
+        const newEpoch = Math.floor(newTimeSlot / epochLength);
+        return newEpoch > stateEpoch;
+    }
+    async getEpochData(logger, state, newTimeSlot) {
+        const sealingKeySeriesResult = await this.getSealingKeySeries(state, newTimeSlot);
+        // Propagate the typed failure instead of crashing — `main` decides whether to
+        // retry, skip or terminate, and keeps the real error details.
+        if (sealingKeySeriesResult.isError) {
+            return Result.error(`${sealingKeySeriesResult.error}`, sealingKeySeriesResult.details);
+        }
+        const epochLength = this.chainSpec.epochLength;
+        const sealingKeySeries = sealingKeySeriesResult.ok;
+        // On a new epoch, `state.entropy[2]` is the epoch-E entropy (pre-transition);
+        // mid-epoch, it has already shifted to `entropy[3]`. Use the same predicate
+        // as `getSealingKeySeries` so the entropy and the key series stay consistent
+        // even when the first authored block of an epoch isn't exactly at slot E·L.
+        const isNewEpoch = this.isEpochChanged(state.timeslot, newTimeSlot);
+        const entropy = isNewEpoch ? state.entropy[2] : state.entropy[3];
+        const epoch = tryAsEpoch(Math.floor(newTimeSlot / epochLength));
+        logger.log `[E${epoch}] is using ${SafroleSealingKeysKind[sealingKeySeries.kind]}`;
+        logger.trace `[E${epoch}] ${sealingKeySeries}`;
+        const slots = await this.authoring.getOurSlotsInKeySeries(sealingKeySeries, entropy);
+        this.logEpochAuthorshipInfo(logger, epoch, slots);
+        return Result.ok({
+            epoch,
+            epochLength,
+            sealingKeySeries,
+            entropy,
+            slots,
+        });
+    }
+    async getSealingKeySeries(state, newTimeSlot) {
+        // in case we are not changing epoch, just use the state data
+        if (!this.isEpochChanged(state.timeslot, newTimeSlot)) {
+            return Result.ok(state.sealingKeySeries);
+        }
+        // otherwise, pick the new sealing key series already
+        const safrole = new Safrole(this.chainSpec, this.blake2bHasher, state);
+        return await safrole.getSealingKeySeries({
+            entropy: state.entropy[1],
+            slot: newTimeSlot,
+            punishSet: state.disputesRecords.punishSet,
+        });
+    }
+    logEpochAuthorshipInfo(logger, epoch, slots) {
+        let isCreating = false;
+        let slot = epoch * this.chainSpec.epochLength;
+        for (const sealData of slots) {
+            if (sealData !== null) {
+                isCreating = true;
+                logger.info `[E${epoch}#${slot}] Validator ${sealData.key.bandersnatchPublic.toStringTruncated()} will author using ${sealData.logId}`;
+            }
+            slot += 1;
+        }
+        if (isCreating === false) {
+            logger.info `[E${epoch}] No blocks to author for this epoch.`;
+        }
+    }
+}

package/packages/workers/block-authorship/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,eAAO,MAAM,MAAM,mBAAwD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,eAAO,MAAM,MAAM,mBAAyD,CAAC"}

package/packages/workers/block-authorship/index.js

@@ -1,4 +1,4 @@
 export * from "./main.js";
 export * from "./metrics.js";
 export * from "./protocol.js";
-export const WORKER = new URL("./bootstrap-generator.mjs", import.meta.url);
+export const WORKER = new URL("./bootstrap-authorship.mjs", import.meta.url);

package/packages/workers/block-authorship/main.d.ts

@@ -2,6 +2,9 @@ import type { NetworkingComms } from "#@typeberry/comms-authorship-network";
 import type { WorkerConfig } from "#@typeberry/workers-api";
 import type { BlockAuthorshipConfig, GeneratorInternal } from "./protocol.js";
 type Config = WorkerConfig<BlockAuthorshipConfig>;
+/**
+ * The `BlockAuthorship` should create new blocks and send them as signals to the main thread.
+ */
 export declare function main(config: Config, comms: GeneratorInternal, networkingComms: NetworkingComms): Promise<void>;
 export {};
 //# sourceMappingURL=main.d.ts.map

package/packages/workers/block-authorship/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/main.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAiB3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAK9E,KAAK,MAAM,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAC;AAwBlD,wBAAsB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,iBAiapG"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/main.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAS3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAG3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAM9E,KAAK,MAAM,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAC;AAElD;;GAEG;AAEH,wBAAsB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,iBAkKpG"}