@typeberry/lib 0.8.4-faebc7a → 0.9.0-c9f9e4d

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

@@ -1,24 +1,19 @@
 import { setTimeout } from "node:timers/promises";
-import { tryAsEpoch, tryAsTimeSlot, tryAsValidatorIndex, } from "#@typeberry/block";
-import { BytesBlob } from "#@typeberry/bytes";
-import { HashDictionary } from "#@typeberry/collections/hash-dictionary.js";
-import { HashSet } from "#@typeberry/collections/hash-set.js";
+import { tryAsTimeSlot, tryAsValidatorIndex, } from "#@typeberry/block";
 import { initWasm } from "#@typeberry/crypto";
-import { deriveBandersnatchPublicKey, deriveEd25519PublicKey, } from "#@typeberry/crypto/key-derivation.js";
 import { Blake2b, keccak } from "#@typeberry/hash";
 import { Logger } from "#@typeberry/logger";
 import { tryAsU64 } from "#@typeberry/numbers";
-import { Safrole } from "#@typeberry/safrole";
-import bandersnatchVrf from "#@typeberry/safrole/bandersnatch-vrf.js";
 import { BandernsatchWasm } from "#@typeberry/safrole/bandersnatch-wasm.js";
-import { JAM_FALLBACK_SEAL, JAM_TICKET_SEAL } from "#@typeberry/safrole/constants.js";
-import { SafroleSealingKeysKind } from "#@typeberry/state";
 import { VerifiedTicketPool } from "#@typeberry/ticket-pool";
-import { asOpaqueType, Result } from "#@typeberry/utils";
-import { Generator } from "./generator.js";
-import { generateTickets } from "./ticket-generator.js";
+import { BlockGenerator } from "./block-generator.js";
+import { EpochTracker } from "./epoch-tracker.js";
+import { TicketGenerator } from "./ticket-generator/index.js";
 import { BandersnatchTicketValidator } from "./ticket-validator.js";
 const logger = Logger.new(import.meta.filename, "author");
+/**
+ * The `BlockAuthorship` should create new blocks and send them as signals to the main thread.
+ */
 export async function main(config, comms, networkingComms) {
     await initWasm();
     logger.info `🎁 Block Authorship running`;
@@ -26,19 +21,19 @@ export async function main(config, comms, networkingComms) {
     const db = config.openDatabase();
     const blocks = db.getBlocksDb();
     const states = db.getStatesDb();
-    let isFinished = false;
-    comms.setOnFinish(async () => {
-        isFinished = true;
-    });
-    // Generate blocks until the close signal is received.
-    let counter = 0;
+    const getBestState = () => {
+        const state = states.getState(blocks.getBestHeaderHash());
+        if (state === null) {
+            throw new Error("Authorship: State for the best block is missing. Terminating.");
+        }
+        return state;
+    };
     const blake2bHasher = await Blake2b.createHasher();
     const bandersnatch = await BandernsatchWasm.new();
     const keccakHasher = await keccak.KeccakHasher.create();
-    const hash = blocks.getBestHeaderHash();
-    const startTime = tryAsU64(process.hrtime.bigint() / 1000000n);
-    const startTimeSlot = states.getState(hash)?.timeslot ?? tryAsTimeSlot(0);
-    const generator = Generator.new({
+    const epochTracker = await EpochTracker.new(chainSpec, bandersnatch, blake2bHasher, config.workerParams.keys);
+    logger.info `👛 Authoring with: ${epochTracker.authoring.getBandersnatchPublicKeys().map((bandersnatchPublic, index) => `\n ${index}: ${bandersnatchPublic}`)}`;
+    const generator = BlockGenerator.new({
         chainSpec,
         bandersnatch,
         keccakHasher,
@@ -46,261 +41,198 @@ export async function main(config, comms, networkingComms) {
         blocks,
         states,
     });
-    const keys = await Promise.all(config.workerParams.keys.map(async (secrets) => ({
-        bandersnatchSecret: secrets.bandersnatch,
-        bandersnatchPublic: deriveBandersnatchPublicKey(secrets.bandersnatch),
-        ed25519Secret: secrets.ed25519,
-        ed25519Public: await deriveEd25519PublicKey(secrets.ed25519),
-    })));
-    const initialHash = blocks.getBestHeaderHash();
-    const initialState = states.getState(initialHash);
-    logger.info `Block authorship validator keys: ${keys.map(({ bandersnatchPublic }, index) => `\n ${index}: ${bandersnatchPublic.toString()}`)}`;
-    // Per-epoch cache for Tickets mode: index corresponds to position in sealingKeySeries.tickets.
-    // null entry means none of our keys match that slot.
-    // Rebuilt once per epoch via buildTicketAuthorshipCache().
-    // Declared here (before the eager startup build below) so its TDZ doesn't fire
-    // when `buildTicketAuthorshipCache` runs during initialisation.
-    let ticketAuthorshipCache = null;
-    if (initialState !== null) {
-        const isEpochStart = startTimeSlot % chainSpec.epochLength === 0;
-        const initialKeys = await getSealingKeySeries(isEpochStart, startTimeSlot, initialState);
-        if (initialKeys.isOk) {
-            logEpochBlockCreation(tryAsEpoch(Math.floor(startTimeSlot / chainSpec.epochLength)), initialKeys.ok);
-            // Build the cache eagerly so the first slot of a session doesn't need an
-            // on-the-fly VRF scan. After this, `buildTicketAuthorshipCache` is only
-            // re-run on epoch boundaries.
-            const initialEntropy = isEpochStart ? initialState.entropy[2] : initialState.entropy[3];
-            await buildTicketAuthorshipCache(initialKeys.ok, initialEntropy);
-        }
-    }
-    function getTime() {
-        const currentTime = process.hrtime.bigint() / 1000000n;
-        const timeFromStart = currentTime - startTime;
-        const slotDurationMs = BigInt(chainSpec.slotDuration * 1000);
-        return tryAsU64(BigInt(startTimeSlot) * slotDurationMs + timeFromStart + slotDurationMs);
-    }
-    function getValidatorIndex(key, currentValidatorData) {
-        const index = currentValidatorData.findIndex((data) => data.bandersnatch.isEqualTo(key.bandersnatchPublic));
-        if (index < 0) {
-            return null;
-        }
-        return tryAsValidatorIndex(index);
-    }
-    /**
-     * Precomputes which slots we are the author of for the current epoch (Tickets mode).
-     */
-    async function buildTicketAuthorshipCache(sealingKeySeries, entropy) {
-        if (sealingKeySeries.kind !== SafroleSealingKeysKind.Tickets) {
-            ticketAuthorshipCache = null;
-            return;
+    // Verified tickets for the next epoch, keyed by entropy hash (ticket id).
+    const verifiedPool = VerifiedTicketPool.new();
+    const ticketValidator = BandersnatchTicketValidator.new(chainSpec, bandersnatch, getBestState);
+    const keys = epochTracker.authoring.getValidatorKeys().map((x) => ({
+        public: x.bandersnatchPublic,
+        secret: x.bandersnatchSecret,
+    }));
+    const ticketGenerator = await TicketGenerator.new(chainSpec, keys);
+    // handling incoming tickets
+    const onEpochTickets = async (epochIndex, tickets, source) => {
+        logger.log `[E${epochIndex}] Received (${tickets.length}) tickets from ${source}`;
+        const result = await ticketValidator.validate(epochIndex, tickets);
+        // add to our pool as well
+        if (result.isOk) {
+            verifiedPool.add(epochIndex, result.ok);
         }
-        const ownTickets = new HashDictionary();
-        for (let attempt = 0; attempt < chainSpec.ticketsPerValidator; attempt++) {
-            const payload = getTicketSealPayload(entropy, attempt);
-            for (const key of keys) {
-                const result = await bandersnatchVrf.getVrfOutputHash(bandersnatch, key.bandersnatchSecret, payload);
-                if (result.isOk) {
-                    ownTickets.set(result.ok.asOpaque(), { key, sealPayload: asOpaqueType(payload) });
-                }
+        return result.isOk;
+    };
+    // Receive tickets from networking.
+    networkingComms.setOnReceivedTickets(async ({ epochIndex, tickets }) => {
+        return await onEpochTickets(epochIndex, tickets, "network");
+    });
+    const state = getBestState();
+    const timeSlotHandler = TimeSlotHandler.new(config.workerParams.isFastForward, chainSpec, state.timeslot);
+    // per-epoch cached data
+    let epochData = null;
+    // Generate blocks until the close signal is received.
+    let isFinished = false;
+    comms.setOnFinish(async () => {
+        isFinished = true;
+    });
+    let ticketGeneratorDone = Promise.resolve();
+    while (!isFinished) {
+        const state = getBestState();
+        // query current expected time slot
+        const stateTimeSlot = state.timeslot;
+        const newTimeSlot = timeSlotHandler.getCurrentTimeSlot(stateTimeSlot);
+        const epochPhase = newTimeSlot % chainSpec.epochLength;
+        // Seems that the epoch is changing, let's transition
+        if (epochData === null || epochTracker.isEpochChanged(stateTimeSlot, newTimeSlot)) {
+            const oldEpochData = epochData;
+            const epochDataResult = await epochTracker.getEpochData(logger, state, newTimeSlot);
+            if (epochDataResult.isError) {
+                // Couldn't compute the sealing keys for this epoch — wait and retry rather
+                // than crashing the worker (`epochData` keeps its previous value, if any).
+                logger.warn `[#${newTimeSlot}] Could not compute epoch data: ${epochDataResult.details()}`;
+                await timeSlotHandler.waitForNextSlot(false, epochPhase, ticketGeneratorDone);
+                continue;
             }
-        }
-        const cache = sealingKeySeries.tickets.map((ticket) => ownTickets.get(ticket.id.asOpaque()) ?? null);
-        ticketAuthorshipCache = cache;
-        const ours = cache.filter(Boolean).length;
-        logger.info `Built ticket authorship cache: ${ours}/${cache.length} slots assigned to us this epoch.`;
-    }
-    function getTicketSealPayload(entropy, attempt) {
-        return BytesBlob.blobFromParts(JAM_TICKET_SEAL, entropy.raw, new Uint8Array([attempt]));
-    }
-    function getFallbackSealPayload(entropy) {
-        return asOpaqueType(BytesBlob.blobFromParts(JAM_FALLBACK_SEAL, entropy.raw));
-    }
-    /**
-     * Returns the validator key and seal payload for the current slot, or null if we are not the author.
-     *
-     * Keys mode (fallback): matches our key against the slot's assigned bandersnatch key.
-     * Tickets mode: O(1) lookup against the per-epoch authorship cache (built eagerly at
-     * startup and on every epoch transition, so we never fall back to on-the-fly VRF).
-     */
-    function getSealData(sealingKeySeries, keys, timeSlot, entropy) {
-        if (sealingKeySeries.kind === SafroleSealingKeysKind.Keys) {
-            const indexForCurrentSlot = timeSlot % sealingKeySeries.keys.length;
-            const sealingKey = sealingKeySeries.keys[indexForCurrentSlot];
-            const key = keys.find((x) => x.bandersnatchPublic.isEqualTo(sealingKey)) ?? null;
-            if (key === null) {
-                return null;
+            epochData = epochDataResult.ok;
+            const epochIndex = epochData.epoch;
+            if (oldEpochData === null) {
+                logger.info `🎁 [E${epochIndex}#${newTimeSlot}] starting authorship (state at #${stateTimeSlot})`;
             }
-            return {
-                key,
-                sealPayload: getFallbackSealPayload(entropy),
-                logId: `key ${key.bandersnatchPublic}`,
-            };
-        }
-        // Tickets mode: each slot is sealed by the validator who can produce the VRF output
-        // matching the ticket's ID for that slot.
-        const index = timeSlot % sealingKeySeries.tickets.length;
-        const ticket = sealingKeySeries.tickets.at(index) ?? null;
-        const cached = ticketAuthorshipCache?.at(index) ?? null;
-        if (ticket === null || cached === null) {
-            return null;
-        }
-        return { ...cached, logId: `ticket ${ticket.id} (attempt ${ticket.attempt})` };
-    }
-    function isEpochChanged(lastTimeslot, currentTimeslot) {
-        const lastEpoch = Math.floor(lastTimeslot / chainSpec.epochLength);
-        const currentEpoch = Math.floor(currentTimeslot / chainSpec.epochLength);
-        return currentEpoch > lastEpoch;
-    }
-    function logEpochBlockCreation(epoch, sealingKeySeries) {
-        if (sealingKeySeries.kind === SafroleSealingKeysKind.Tickets) {
-            logger.info `[EPOCH ${epoch}] Tickets mode active with ${sealingKeySeries.tickets.length} tickets.`;
-            return;
-        }
-        let isCreating = false;
-        const epochStart = epoch * chainSpec.epochLength;
-        const epochEnd = epochStart + chainSpec.epochLength;
-        for (let slot = epochStart; slot < epochEnd; slot++) {
-            const indexForCurrentSlot = slot % sealingKeySeries.keys.length;
-            const sealingKey = sealingKeySeries.keys[indexForCurrentSlot];
-            const key = keys.find((x) => x.bandersnatchPublic.isEqualTo(sealingKey)) ?? null;
-            if (key !== null) {
-                isCreating = true;
-                logger.info `[EPOCH ${epoch}] Validator ${key.bandersnatchPublic.toString()} will author block at slot ${slot}`;
+            else {
+                logger.info `🎁 [E${oldEpochData.epoch}#${stateTimeSlot} -> E${epochIndex}#${newTimeSlot}] epoch transition`;
             }
-        }
-        if (isCreating === false) {
-            logger.info `[EPOCH ${epoch}] No blocks to author for this epoch.`;
-        }
-    }
-    async function getSealingKeySeries(isNewEpoch, timeSlot, state) {
-        if (isNewEpoch) {
-            const safrole = new Safrole(chainSpec, blake2bHasher, state);
-            return await safrole.getSealingKeySeries({
-                entropy: state.entropy[1],
-                slot: timeSlot,
-                punishSet: state.disputesRecords.punishSet,
+            // On every epoch boundary, push the authoritative ticket pool to networking so it
+            // can replace its redistribution set; this keeps the two sides from drifting.
+            const tickets = verifiedPool.getForEpoch(epochIndex).map((entry) => entry.ticket);
+            await networkingComms.sendReplaceTicketPool({
+                epochIndex,
+                tickets,
             });
-        }
-        return Result.ok(state.sealingKeySeries);
-    }
-    // Verified tickets for the current epoch, keyed by entropy hash (ticket id).
-    // Tickets enter via `validator.validate(...)` which both verifies and inserts.
-    const verifiedPool = new VerifiedTicketPool();
-    const ticketValidator = new BandersnatchTicketValidator(bandersnatch, chainSpec, verifiedPool, () => states.getState(blocks.getBestHeaderHash()));
-    // Receive a single ticket from peers (via jam-network worker).
-    // Returns true if the ticket passed validation so jam-network can decide whether to redistribute it.
-    networkingComms.setOnReceivedTickets(async ({ epochIndex, ticket }) => {
-        logger.log `Received ticket from peer for epoch ${epochIndex}`;
-        const result = await ticketValidator.validate(epochIndex, ticket);
-        return result.isOk;
-    });
-    const isFastForward = config.workerParams.isFastForward;
-    let lastGeneratedSlot = startTimeSlot;
-    let ticketsGeneratedForEpoch = -1;
-    while (!isFinished) {
-        const hash = blocks.getBestHeaderHash();
-        const state = states.getState(hash);
-        const currentValidatorData = state?.currentValidatorData ?? null;
-        if (state === null) {
-            continue;
-        }
-        const lastTimeSlot = state.timeslot;
-        /**
-         * In fastForward mode, use simulated time (next slot after current state).
-         * In normal mode, use wall clock time.
-         * Assuming `slotDuration` is 6 sec it is safe till year 2786.
-         * If `slotDuration` is 1 sec then it is safe till 2106.
-         */
-        const timeSlot = isFastForward === true
-            ? tryAsTimeSlot(lastTimeSlot + 1)
-            : tryAsTimeSlot(Number(getTime() / 1000n / BigInt(chainSpec.slotDuration)));
-        // In fastForward mode, skip if we already generated for this slot (waiting for import)
-        if (isFastForward === true && timeSlot <= lastGeneratedSlot) {
-            continue;
-        }
-        const isNewEpoch = isEpochChanged(lastTimeSlot, timeSlot);
-        // Generate tickets if within contest period and not yet generated for this epoch
-        const epoch = tryAsEpoch(Math.floor(timeSlot / chainSpec.epochLength));
-        const slotInEpoch = timeSlot % chainSpec.epochLength;
-        const shouldGenerateTickets = slotInEpoch < chainSpec.contestLength && ticketsGeneratedForEpoch !== epoch;
-        if (shouldGenerateTickets) {
-            const designatedValidatorData = state.designatedValidatorData;
-            const ringKeys = designatedValidatorData.map((data) => data.bandersnatch);
-            const designatedKeySet = HashSet.from(ringKeys);
-            const validatorKeys = keys
-                .filter((k) => designatedKeySet.has(k.bandersnatchPublic))
-                .map((k) => ({ secret: k.bandersnatchSecret, public: k.bandersnatchPublic }));
-            if (validatorKeys.length > 0) {
-                // If state is from the previous epoch, entropy hasn't been shifted yet (index 1).
-                // After epoch change, it has been shifted to index 2.
-                const ticketEntropy = isNewEpoch ? state.entropy[1] : state.entropy[2];
-                logger.info `Epoch ${epoch}, slot ${slotInEpoch}/${chainSpec.contestLength}. Generating tickets for ${validatorKeys.length} validators...`;
-                const ticketsResult = await generateTickets(bandersnatch, ringKeys, validatorKeys, ticketEntropy, chainSpec.ticketsPerValidator);
-                if (ticketsResult.isError) {
-                    logger.warn `Failed to generate tickets for epoch ${epoch}: ${ticketsResult.error}`;
-                }
-                else {
-                    logger.log `Generated ${ticketsResult.ok.length} tickets for epoch ${epoch}. Distributing...`;
-                    // Verify own tickets (validator stores them in the pool with computed ids).
-                    for (const ticket of ticketsResult.ok) {
-                        await ticketValidator.validate(epoch, ticket);
+            // Let's generate some tickets for the next epoch if we still have time
+            if (epochPhase < chainSpec.contestLength) {
+                const generatingForEpoch = epochData.epoch;
+                const isEpochStart = epochPhase === 0;
+                ticketGeneratorDone = ticketGenerator.generateTickets(state, isEpochStart, async (tickets) => {
+                    // too late!
+                    if (generatingForEpoch !== epochData?.epoch) {
+                        return;
                     }
-                    // Send directly to network worker (bypasses main thread)
-                    await networkingComms.sendTickets({ epochIndex: epoch, tickets: ticketsResult.ok });
-                }
-            }
-            ticketsGeneratedForEpoch = epoch;
-        }
-        const selingKeySeriesResult = await getSealingKeySeries(isNewEpoch, timeSlot, state);
-        if (selingKeySeriesResult.isError) {
-            continue;
-        }
-        // On a new epoch, `state.entropy[2]` is the epoch-E entropy (pre-transition);
-        // mid-epoch, it has already shifted to `entropy[3]`.
-        const entropy = isNewEpoch ? state.entropy[2] : state.entropy[3];
-        // Rebuild the authorship cache on each epoch boundary, and also catch the case
-        // where the startup prebuild was skipped (e.g. initialState was null or the
-        // initial sealing-key transition errored) so we don't silently miss Tickets-mode
-        // slots until the next epoch boundary.
-        const needsCacheRebuild = isNewEpoch ||
-            (selingKeySeriesResult.ok.kind === SafroleSealingKeysKind.Tickets && ticketAuthorshipCache === null);
-        if (needsCacheRebuild) {
-            if (isNewEpoch) {
-                logEpochBlockCreation(epoch, selingKeySeriesResult.ok);
+                    const isValid = await onEpochTickets(generatingForEpoch, tickets, "generator");
+                    // Push our freshly generated tickets to networking so they're redistributed
+                    // to peers (who include them in their blocks). Without this, a multi-node
+                    // network never shares tickets and accumulators only ever hold local ones.
+                    if (isValid) {
+                        await networkingComms.sendTickets({ epochIndex: generatingForEpoch, tickets });
+                    }
+                });
             }
-            await buildTicketAuthorshipCache(selingKeySeriesResult.ok, entropy);
-        }
-        // On every epoch boundary, push the authoritative ticket pool to networking so it
-        // can replace its redistribution set; this keeps the two sides from drifting.
-        if (isNewEpoch) {
-            const dumpTickets = verifiedPool.getForEpoch(epoch).map((entry) => entry.ticket);
-            await networkingComms.sendReplaceTicketPool({ epochIndex: epoch, tickets: dumpTickets });
         }
-        const sealData = getSealData(selingKeySeriesResult.ok, keys, timeSlot, entropy);
-        if (sealData !== null && currentValidatorData !== null) {
-            const { key, sealPayload } = sealData;
-            const validatorIndex = getValidatorIndex(key, currentValidatorData);
+        const logPrefix = `[E${epochData.epoch}#${newTimeSlot}]`;
+        // author a block if we are assigned to that slot
+        const currentSlot = epochData.slots[epochPhase];
+        if (currentSlot !== null) {
+            const { logId, key, sealPayload } = currentSlot;
+            // figure out validator index
+            const validatorIndex = getValidatorIndex(key.bandersnatchPublic, state.currentValidatorData);
             if (validatorIndex === null) {
+                logger.log `${logPrefix} Not currently validator, yet ${currentSlot.logId} is present.`;
+                // Don't spin: wait for the next slot before re-checking (otherwise this is
+                // a tight hot loop until some other component advances the DB).
+                await timeSlotHandler.waitForNextSlot(false, epochPhase, ticketGeneratorDone);
                 continue;
             }
-            logger.log `Attempting to create a block using ${sealData.logId} located at validator index ${validatorIndex}.`;
-            const currentEpochTickets = verifiedPool.getForEpoch(epoch);
-            const newBlock = await generator.nextBlockView(validatorIndex, key.bandersnatchSecret, sealPayload, timeSlot, 
+            logger.log `${logPrefix} Creating block using ${logId} (valIdx: ${validatorIndex})`;
+            // retrieve epoch tickets to include
+            const currentEpochTickets = verifiedPool.getForEpoch(epochData.epoch);
+            const newBlock = await generator.nextBlockView(validatorIndex, key.bandersnatchSecret, sealPayload, newTimeSlot, 
             // VerifiedTicket has the same `{ ticket, id }` shape the generator expects.
             [...currentEpochTickets]);
-            counter += 1;
-            lastGeneratedSlot = timeSlot;
-            logger.trace `Sending block ${counter}`;
+            logger.trace `${logPrefix} sending block`;
             await comms.sendBlock(newBlock);
         }
-        else if (isFastForward === true) {
-            // In fast-forward mode, if this slot is not ours, wait briefly for other validators to produce blocks
-            await setTimeout(10);
-        }
-        if (isFastForward === false) {
-            await setTimeout(chainSpec.slotDuration * 1000);
-        }
+        logger.trace `${logPrefix} awaiting next slot`;
+        await timeSlotHandler.waitForNextSlot(currentSlot !== null, epochPhase, ticketGeneratorDone);
     }
     logger.info `🎁 Block Authorship finished. Closing channel.`;
     await db.close();
 }
+function getValidatorIndex(key, currentValidatorData) {
+    const index = currentValidatorData.findIndex((data) => data.bandersnatch.isEqualTo(key));
+    if (index < 0) {
+        return null;
+    }
+    return tryAsValidatorIndex(index);
+}
+/**
+ * How many slots before the end of the contest period we force-await the ticket
+ * generator in fast-forward mode. Without this, blocks are produced faster than
+ * tickets are generated and the accumulator never fills (→ Keys-mode fallback).
+ *
+ * Derived so that, after the wait completes, there are enough remaining contest
+ * slots to include a full accumulator worth of tickets (`epochLength` tickets at
+ * `maxTicketsPerExtrinsic` per block), plus a small buffer.
+ */
+function ticketInclusionMargin(chainSpec) {
+    return Math.ceil(chainSpec.epochLength / chainSpec.maxTicketsPerExtrinsic) + 4;
+}
+function systemTimeMs() {
+    return process.hrtime.bigint() / 1000000n;
+}
+class TimeSlotHandler {
+    initialStateTimeSlot;
+    slotDurationMs;
+    isFastForward;
+    contestLength;
+    inclusionMargin;
+    systemStartTimeMs;
+    stateStartTime;
+    static new(isFastForward, chainSpec, stateTimeSlot) {
+        const slotDurationMs = BigInt(chainSpec.slotDuration) * 1000n;
+        return new TimeSlotHandler(stateTimeSlot, slotDurationMs, isFastForward, chainSpec.contestLength, ticketInclusionMargin(chainSpec));
+    }
+    constructor(initialStateTimeSlot, slotDurationMs, isFastForward, contestLength, inclusionMargin) {
+        this.initialStateTimeSlot = initialStateTimeSlot;
+        this.slotDurationMs = slotDurationMs;
+        this.isFastForward = isFastForward;
+        this.contestLength = contestLength;
+        this.inclusionMargin = inclusionMargin;
+        this.systemStartTimeMs = systemTimeMs();
+        this.stateStartTime = BigInt(initialStateTimeSlot) * slotDurationMs;
+    }
+    /**
+     * In fastForward mode, use simulated time (next slot after current state).
+     * In normal mode, use wall clock time.
+     * Assuming `slotDuration` is 6 sec it is safe till year 2786.
+     * If `slotDuration` is 1 sec then it is safe till 2106.
+     */
+    getCurrentTimeSlot(stateTimeSlot) {
+        return this.isFastForward === true
+            ? tryAsTimeSlot(stateTimeSlot + 1)
+            : tryAsTimeSlot(Number(this.getVirtualTimeMs() / this.slotDurationMs));
+    }
+    async waitForNextSlot(wasAuthoring, epochPhase, ticketGeneratorDone) {
+        if (this.isFastForward) {
+            // when we approach the end of the contest period make sure to wait for all tickets
+            if (epochPhase < this.contestLength && epochPhase + this.inclusionMargin > this.contestLength) {
+                await ticketGeneratorDone;
+            }
+            // return as fast as possible
+            if (wasAuthoring) {
+                return;
+            }
+            // or wait for other nodes to produce a block
+            return await setTimeout(100);
+        }
+        // Sleep until the next slot boundary (not a full slot from "now") so the
+        // wakeup doesn't drift later and later as block work eats into each slot.
+        const elapsedInSlot = this.getVirtualTimeMs() % this.slotDurationMs;
+        const waitMs = elapsedInSlot === 0n ? this.slotDurationMs : this.slotDurationMs - elapsedInSlot;
+        await setTimeout(Number(waitMs));
+    }
+    /**
+     * We assume there is no gap between system time and the initial state time.
+     *
+     * I.e. we can resume any database by moving the state time to the future.
+     */
+    getVirtualTimeMs() {
+        const timeFromStart = systemTimeMs() - this.systemStartTimeMs;
+        return tryAsU64(this.stateStartTime + timeFromStart + this.slotDurationMs);
+    }
+}

package/packages/workers/block-authorship/ticket-generator/bootstrap-main.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bootstrap-main.d.ts.map

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

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

package/packages/workers/block-authorship/ticket-generator/bootstrap-main.js

@@ -0,0 +1,23 @@
+// biome-ignore-all lint/suspicious/noConsole: worker bootstrap
+//
+// Worker-thread entry point for parallel ticket generation. Spawned by
+// `TicketGeneratorPool` (via the `.mjs` bootstrap), it initialises the native
+// bandersnatch binding once and then answers shard requests by running
+// `batchGenerateRingVrfForValidators` and returning the raw signature bytes.
+import { ConcurrentWorker } from "#@typeberry/concurrent";
+import { initWasm } from "#@typeberry/crypto";
+import { BandernsatchWasm } from "#@typeberry/safrole/bandersnatch-wasm.js";
+import { TicketGenShardResult } from "./protocol.js";
+async function main() {
+    await initWasm();
+    const bandersnatch = await BandernsatchWasm.new();
+    const worker = ConcurrentWorker.new(async (params, bs) => {
+        const signatures = await bs.batchGenerateRingVrfForValidators(params.ringKeysData, params.proverKeyIndices, params.secretSeedsData, params.secretSeedDataLen, params.inputsData, params.vrfInputDataLen);
+        return new TicketGenShardResult(signatures);
+    }, bandersnatch);
+    worker.listenToParentPort();
+}
+main().catch((e) => {
+    console.error("ticket-generator worker failed to start:", e);
+    process.exit(1);
+});

package/packages/workers/block-authorship/ticket-generator/index.d.ts

@@ -0,0 +1,16 @@
+import { type SignedTicket } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import type { State } from "#@typeberry/state";
+import type { ValidatorKey } from "./ticket-generator.js";
+export type TicketGeneratorOptions = {
+    useWorkerPool: boolean;
+};
+export declare class TicketGenerator {
+    private readonly chainSpec;
+    private readonly keys;
+    private readonly pool;
+    static new(chainSpec: ChainSpec, keys: ValidatorKey[]): Promise<TicketGenerator>;
+    private constructor();
+    generateTickets(state: State, isEpochStart: boolean, onTickets: (tickets: SignedTicket[]) => Promise<void>): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/block-authorship/ticket-generator/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,YAAY,EAAc,MAAM,kBAAkB,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AA2B1D,MAAM,MAAM,sBAAsB,GAAG;IACnC,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,qBAAa,eAAe;IAOxB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI;WARV,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE;IAK3D,OAAO;IAMD,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC;CAyBjH"}

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

@@ -0,0 +1,62 @@
+import os from "node:os";
+import { tryAsEpoch } from "#@typeberry/block";
+import { HashSet } from "#@typeberry/collections";
+import { Logger } from "#@typeberry/logger";
+import { measure } from "#@typeberry/utils";
+import { TicketGeneratorPool } from "./worker-pool.js";
+/**
+ * Extra validators to generate tickets for, beyond the minimum needed to fill the
+ * accumulator. Filling requires `epochLength` distinct valid tickets; each validator
+ * yields `ticketsPerValidator`. The margin guards against a few tickets failing to
+ * land (extra tickets are simply dropped by the accumulator).
+ */
+const TICKET_GENERATION_VALIDATOR_MARGIN = 8;
+/** Leave this many cores for the main thread, importer, network and the OS. */
+const TICKET_POOL_RESERVED_CORES = 4;
+/** Hard cap on ticket-generation worker threads. */
+const TICKET_POOL_MAX_WORKERS = 8;
+const logger = Logger.new(import.meta.filename, "tickets");
+const measureTicketGen = measure("ticket:gen");
+/** Number of worker threads to use for parallel ticket generation. */
+function ticketPoolWorkerCount(validators) {
+    const cores = os.availableParallelism?.() ?? os.cpus().length;
+    const availableCores = Math.min(cores - TICKET_POOL_RESERVED_CORES, TICKET_POOL_MAX_WORKERS);
+    // never reserve more cores than we have validators (makes no sense)
+    const requiredCores = Math.min(validators, availableCores);
+    return Math.max(1, requiredCores);
+}
+export class TicketGenerator {
+    chainSpec;
+    keys;
+    pool;
+    static async new(chainSpec, keys) {
+        const pool = await TicketGeneratorPool.create(ticketPoolWorkerCount(keys.length));
+        return new TicketGenerator(chainSpec, keys, pool);
+    }
+    constructor(chainSpec, keys, pool) {
+        this.chainSpec = chainSpec;
+        this.keys = keys;
+        this.pool = pool;
+    }
+    async generateTickets(state, isEpochStart, onTickets) {
+        // Pick the right entropy and validator set
+        const validators = isEpochStart ? state.designatedValidatorData : state.nextValidatorData;
+        const entropy = isEpochStart ? state.entropy[1] : state.entropy[2];
+        const epoch = tryAsEpoch(Math.floor(state.timeslot / this.chainSpec.epochLength));
+        const ringKeys = validators.map((d) => d.bandersnatch);
+        const nextKeySet = HashSet.from(ringKeys);
+        const validatorKeys = this.keys.filter((k) => nextKeySet.has(k.public));
+        // Generate just enough validators to fill the accumulator, plus a margin.
+        const needed = Math.ceil(this.chainSpec.epochLength / this.chainSpec.ticketsPerValidator) + TICKET_GENERATION_VALIDATOR_MARGIN;
+        const selected = validatorKeys.slice(0, Math.min(validatorKeys.length, needed));
+        const ticketGen = measureTicketGen();
+        logger.info `🎫 [E${epoch}] generating tickets for ${selected.length} validators across ${this.pool.workerCount} worker threads…`;
+        try {
+            await this.pool.generate(ringKeys, selected, entropy, this.chainSpec.ticketsPerValidator, onTickets);
+            logger.info `🎫 [E${epoch}] ${ticketGen}`;
+        }
+        catch (e) {
+            logger.warn `🎫 [E${epoch}] ticket generation failed: ${e}`;
+        }
+    }
+}