@typeberry/lib 0.8.4-2e4ce67 → 0.8.4-79f2119

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}`;
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+import type { Transferable } from "node:worker_threads";
+/**
+ * Parameters for a single ticket-generation shard sent to a worker thread.
+ */
+export declare class TicketGenShardParams {
+    /** Concatenated ring public keys (`ringSize * 32` bytes). */
+    readonly ringKeysData: Uint8Array;
+    /** Index within the ring for each validator in this shard. */
+    readonly proverKeyIndices: Uint32Array;
+    /** Concatenated validator secret seeds (`count * secretSeedDataLen` bytes). */
+    readonly secretSeedsData: Uint8Array;
+    /** Length of each secret seed in `secretSeedsData`. */
+    readonly secretSeedDataLen: number;
+    /** Concatenated VRF inputs, one per attempt. */
+    readonly inputsData: Uint8Array;
+    /** Length of each VRF input in `inputsData`. */
+    readonly vrfInputDataLen: number;
+    constructor(
+    /** Concatenated ring public keys (`ringSize * 32` bytes). */
+    ringKeysData: Uint8Array, 
+    /** Index within the ring for each validator in this shard. */
+    proverKeyIndices: Uint32Array, 
+    /** Concatenated validator secret seeds (`count * secretSeedDataLen` bytes). */
+    secretSeedsData: Uint8Array, 
+    /** Length of each secret seed in `secretSeedsData`. */
+    secretSeedDataLen: number, 
+    /** Concatenated VRF inputs, one per attempt. */
+    inputsData: Uint8Array, 
+    /** Length of each VRF input in `inputsData`. */
+    vrfInputDataLen: number);
+    /**
+     * No transfers: `ringKeysData` and `inputsData` are shared across all shards,
+     * so transferring would detach them for the other shards.
+     */
+    getTransferList(): Transferable[];
+}
+/** Result of a ticket-generation shard: the raw `batchGenerateRingVrfForValidators` output. */
+export declare class TicketGenShardResult {
+    /** Raw output: validator-major, attempt-major records of `status || signature`. */
+    readonly signatures: Uint8Array;
+    constructor(
+    /** Raw output: validator-major, attempt-major records of `status || signature`. */
+    signatures: Uint8Array);
+    /**
+     * No transfers: the native binding returns a view backed by external/WASM
+     * memory that cannot be detached, so transferring it throws inside the worker.
+     */
+    getTransferList(): Transferable[];
+}
+//# sourceMappingURL=protocol.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/block-authorship/ticket-generator/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;GAEG;AACH,qBAAa,oBAAoB;IAE7B,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,EAAE,UAAU;IACjC,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,EAAE,WAAW;IACtC,+EAA+E;IAC/E,QAAQ,CAAC,eAAe,EAAE,UAAU;IACpC,uDAAuD;IACvD,QAAQ,CAAC,iBAAiB,EAAE,MAAM;IAClC,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,UAAU;IAC/B,gDAAgD;IAChD,QAAQ,CAAC,eAAe,EAAE,MAAM;;IAXhC,6DAA6D;IACpD,YAAY,EAAE,UAAU;IACjC,8DAA8D;IACrD,gBAAgB,EAAE,WAAW;IACtC,+EAA+E;IACtE,eAAe,EAAE,UAAU;IACpC,uDAAuD;IAC9C,iBAAiB,EAAE,MAAM;IAClC,gDAAgD;IACvC,UAAU,EAAE,UAAU;IAC/B,gDAAgD;IACvC,eAAe,EAAE,MAAM;IAGlC;;;OAGG;IACH,eAAe,IAAI,YAAY,EAAE;CAGlC;AAED,+FAA+F;AAC/F,qBAAa,oBAAoB;IAE7B,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,UAAU;;IAD/B,mFAAmF;IAC1E,UAAU,EAAE,UAAU;IAGjC;;;OAGG;IACH,eAAe,IAAI,YAAY,EAAE;CAGlC"}

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

@@ -0,0 +1,54 @@
+/**
+ * Parameters for a single ticket-generation shard sent to a worker thread.
+ */
+export class TicketGenShardParams {
+    ringKeysData;
+    proverKeyIndices;
+    secretSeedsData;
+    secretSeedDataLen;
+    inputsData;
+    vrfInputDataLen;
+    constructor(
+    /** Concatenated ring public keys (`ringSize * 32` bytes). */
+    ringKeysData, 
+    /** Index within the ring for each validator in this shard. */
+    proverKeyIndices, 
+    /** Concatenated validator secret seeds (`count * secretSeedDataLen` bytes). */
+    secretSeedsData, 
+    /** Length of each secret seed in `secretSeedsData`. */
+    secretSeedDataLen, 
+    /** Concatenated VRF inputs, one per attempt. */
+    inputsData, 
+    /** Length of each VRF input in `inputsData`. */
+    vrfInputDataLen) {
+        this.ringKeysData = ringKeysData;
+        this.proverKeyIndices = proverKeyIndices;
+        this.secretSeedsData = secretSeedsData;
+        this.secretSeedDataLen = secretSeedDataLen;
+        this.inputsData = inputsData;
+        this.vrfInputDataLen = vrfInputDataLen;
+    }
+    /**
+     * No transfers: `ringKeysData` and `inputsData` are shared across all shards,
+     * so transferring would detach them for the other shards.
+     */
+    getTransferList() {
+        return [];
+    }
+}
+/** Result of a ticket-generation shard: the raw `batchGenerateRingVrfForValidators` output. */
+export class TicketGenShardResult {
+    signatures;
+    constructor(
+    /** Raw output: validator-major, attempt-major records of `status || signature`. */
+    signatures) {
+        this.signatures = signatures;
+    }
+    /**
+     * No transfers: the native binding returns a view backed by external/WASM
+     * memory that cannot be detached, so transferring it throws inside the worker.
+     */
+    getTransferList() {
+        return [];
+    }
+}

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

@@ -16,6 +16,10 @@ export type ValidatorKey = {
  *
  * Each validator key produces `ticketsPerValidator` tickets using ring VRF proofs.
  * The ring keys define the anonymous set - only members can produce valid proofs.
+ *
+ * All resolved validators are generated in a single batched native call
+ * ({@link bandersnatchVrf.generateTickets}) which reuses the ring
+ * prover setup across the batch.
  */
 export declare function generateTickets(bandersnatch: BandernsatchWasm, ringKeys: BandersnatchKey[], validatorKeys: ValidatorKey[], entropy: EntropyHash, ticketsPerValidator: number): Promise<Result<SignedTicket[], TicketGeneratorError>>;
 //# sourceMappingURL=ticket-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ticket-generator.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/block-authorship/ticket-generator/ticket-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAGjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAI1C,oBAAY,oBAAoB;IAC9B,sBAAsB,2BAA2B;IACjD,kBAAkB,uBAAuB;CAC1C;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,YAAY,EAAE,gBAAgB,EAC9B,QAAQ,EAAE,eAAe,EAAE,EAC3B,aAAa,EAAE,YAAY,EAAE,EAC7B,OAAO,EAAE,WAAW,EACpB,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,EAAE,oBAAoB,CAAC,CAAC,CA2CvD"}

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

@@ -12,25 +12,35 @@ export var TicketGeneratorError;
  *
  * Each validator key produces `ticketsPerValidator` tickets using ring VRF proofs.
  * The ring keys define the anonymous set - only members can produce valid proofs.
+ *
+ * All resolved validators are generated in a single batched native call
+ * ({@link bandersnatchVrf.generateTickets}) which reuses the ring
+ * prover setup across the batch.
  */
 export async function generateTickets(bandersnatch, ringKeys, validatorKeys, entropy, ticketsPerValidator) {
-    const allTickets = [];
+    // Resolve each validator's index within the ring, skipping any that are not
+    // members (only ring members can produce valid proofs).
+    const proverKeyIndices = [];
+    const secrets = [];
     for (const validatorKey of validatorKeys) {
         const proverIndex = ringKeys.findIndex((k) => k.isEqualTo(validatorKey.public));
         if (proverIndex < 0) {
             logger.warn `Validator public key not found in the ring, skipping ticket generation for this key`;
             continue;
         }
-        const ticketResult = await bandersnatchVrf.generateTickets(bandersnatch, ringKeys, proverIndex, validatorKey.secret, entropy, ticketsPerValidator);
-        if (ticketResult.isOk) {
-            allTickets.push(...ticketResult.ok);
-        }
-        else {
-            logger.warn `Failed to generate tickets for validator, skipping`;
+        proverKeyIndices.push(proverIndex);
+        secrets.push(validatorKey.secret);
+    }
+    if (proverKeyIndices.length === 0) {
+        // No resolvable validators: an error if some were requested, else just empty.
+        if (validatorKeys.length > 0) {
+            return Result.error(TicketGeneratorError.TicketGenerationFailed, () => "Failed to generate tickets for all validators");
         }
+        return Result.ok([]);
     }
-    if (validatorKeys.length > 0 && allTickets.length === 0) {
+    const result = await bandersnatchVrf.generateTickets(bandersnatch, ringKeys, proverKeyIndices, secrets, entropy, ticketsPerValidator);
+    if (result.isError) {
         return Result.error(TicketGeneratorError.TicketGenerationFailed, () => "Failed to generate tickets for all validators");
     }
-    return Result.ok(allTickets);
+    return Result.ok(result.ok.flat());
 }

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

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

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

@@ -21,15 +21,19 @@ function createMockValidatorKeys(count) {
 describe("Ticket Generator", () => {
     beforeEach(async () => {
         await initWasm();
-        mock.method(bandersnatchVrf, "generateTickets", async (_bandersnatch, _ringKeys, _proverIndex, _key, _entropy, ticketsPerValidator) => {
-            const tickets = [];
-            for (let attempt = 0; attempt < ticketsPerValidator; attempt++) {
-                tickets.push({
-                    attempt: tryAsTicketAttempt(attempt),
-                    signature: Bytes.zero(784).asOpaque(),
-                });
-            }
-            return Result.ok(tickets);
+        mock.method(bandersnatchVrf, "generateTickets", async (_bandersnatch, _ringKeys, proverKeyIndices, _secrets, _entropy, ticketsPerValidator) => {
+            // One ticket list per resolved validator, in validator-major order.
+            const perValidator = proverKeyIndices.map(() => {
+                const tickets = [];
+                for (let attempt = 0; attempt < ticketsPerValidator; attempt++) {
+                    tickets.push({
+                        attempt: tryAsTicketAttempt(attempt),
+                        signature: Bytes.zero(784).asOpaque(),
+                    });
+                }
+                return tickets;
+            });
+            return Result.ok(perValidator);
         });
     });
     afterEach(() => {

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

@@ -0,0 +1,36 @@
+import type { EntropyHash } from "#@typeberry/block";
+import type { SignedTicket } from "#@typeberry/block/tickets.js";
+import { type BandersnatchKey } from "#@typeberry/crypto";
+import type { ValidatorKey } from "./ticket-generator.js";
+/**
+ * A pool of worker threads that generate ring-VRF tickets in parallel.
+ *
+ * Ring-VRF proof generation is a heavy, synchronous, CPU-bound native call
+ * (~0.7s per validator with a large ring). Running it on the authoring thread
+ * blocks block production; this pool shards the work across worker threads so
+ * the main thread stays free and wall-clock time drops ~linearly with cores.
+ *
+ * Uses `Executor` from `@typeberry/concurrent`.
+ */
+export declare class TicketGeneratorPool {
+    private readonly executor;
+    /** Number of worker threads in the pool. */
+    readonly workerCount: number;
+    private constructor();
+    /** Spawn `workerCount` worker threads (each initialises the native binding). */
+    static create(workerCount: number): Promise<TicketGeneratorPool>;
+    /** Terminate all worker threads. */
+    destroy(): Promise<void>;
+    /**
+     * Generate tickets for `validatorKeys`, sharded evenly across the pool.
+     *
+     * `onShardTickets` is invoked on the calling (main) thread as each shard's
+     * results arrive, so tickets can be pooled/distributed incrementally rather
+     * than waiting for the whole batch. Returns once every shard has settled.
+     *
+     * Validators whose public key is not in `ringKeys` are skipped (they cannot
+     * produce valid proofs).
+     */
+    generate(ringKeys: BandersnatchKey[], validatorKeys: ValidatorKey[], entropy: EntropyHash, ticketsPerValidator: number, onShardTickets: (tickets: SignedTicket[]) => Promise<void>): Promise<void>;
+}
+//# sourceMappingURL=worker-pool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"worker-pool.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/block-authorship/ticket-generator/worker-pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,EAAE,KAAK,eAAe,EAA0C,MAAM,mBAAmB,CAAC;AAIjG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAiB1D;;;;;;;;;GASG;AACH,qBAAa,mBAAmB;IAE5B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,4CAA4C;aAC5B,WAAW,EAAE,MAAM;IAHrC,OAAO;IAMP,gFAAgF;WACnE,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAQtE,oCAAoC;IAC9B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;;;;;;;;OASG;IACG,QAAQ,CACZ,QAAQ,EAAE,eAAe,EAAE,EAC3B,aAAa,EAAE,YAAY,EAAE,EAC7B,OAAO,EAAE,WAAW,EACpB,mBAAmB,EAAE,MAAM,EAC3B,cAAc,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GACzD,OAAO,CAAC,IAAI,CAAC;CA6DjB"}

package/packages/workers/block-authorship/ticket-generator/worker-pool.js

@@ -0,0 +1,111 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { Executor } from "#@typeberry/concurrent";
+import { SEED_SIZE } from "#@typeberry/crypto";
+import { Logger } from "#@typeberry/logger";
+import { buildTicketVrfInputs, parseTicketsBatchOutput } from "#@typeberry/safrole/bandersnatch-vrf.js";
+import { TicketGenShardParams } from "./protocol.js";
+const logger = Logger.new(import.meta.filename, "tickets-pool");
+/** `.mjs` bootstrap that `tsImport`s the worker entry (worker threads need it under tsx). */
+const WORKER_BOOTSTRAP = new URL("./bootstrap-ticket-generator.mjs", import.meta.url);
+/**
+ * Validators per shard.
+ *
+ * Kept small so tickets stream into the pool incrementally (and get included in
+ * blocks throughout the contest period) rather than arriving in one lump when
+ * generation finishes. The prover setup is re-done per shard, but that cost is
+ * tiny next to the per-proof time, so finer shards add only ~1-2% overhead.
+ */
+const TICKET_SHARD_SIZE = 16;
+/**
+ * A pool of worker threads that generate ring-VRF tickets in parallel.
+ *
+ * Ring-VRF proof generation is a heavy, synchronous, CPU-bound native call
+ * (~0.7s per validator with a large ring). Running it on the authoring thread
+ * blocks block production; this pool shards the work across worker threads so
+ * the main thread stays free and wall-clock time drops ~linearly with cores.
+ *
+ * Uses `Executor` from `@typeberry/concurrent`.
+ */
+export class TicketGeneratorPool {
+    executor;
+    workerCount;
+    constructor(executor, 
+    /** Number of worker threads in the pool. */
+    workerCount) {
+        this.executor = executor;
+        this.workerCount = workerCount;
+    }
+    /** Spawn `workerCount` worker threads (each initialises the native binding). */
+    static async create(workerCount) {
+        const executor = await Executor.initialize(WORKER_BOOTSTRAP, {
+            minWorkers: workerCount,
+            maxWorkers: workerCount,
+        });
+        return new TicketGeneratorPool(executor, workerCount);
+    }
+    /** Terminate all worker threads. */
+    async destroy() {
+        await this.executor.destroy();
+    }
+    /**
+     * Generate tickets for `validatorKeys`, sharded evenly across the pool.
+     *
+     * `onShardTickets` is invoked on the calling (main) thread as each shard's
+     * results arrive, so tickets can be pooled/distributed incrementally rather
+     * than waiting for the whole batch. Returns once every shard has settled.
+     *
+     * Validators whose public key is not in `ringKeys` are skipped (they cannot
+     * produce valid proofs).
+     */
+    async generate(ringKeys, validatorKeys, entropy, ticketsPerValidator, onShardTickets) {
+        // Resolve each validator's index within the ring (skip non-members).
+        const keyToIndex = new Map();
+        for (let i = 0; i < ringKeys.length; i++) {
+            keyToIndex.set(ringKeys[i].toString(), i);
+        }
+        const resolved = [];
+        for (const vk of validatorKeys) {
+            const idx = keyToIndex.get(vk.public.toString());
+            if (idx === undefined) {
+                continue;
+            }
+            resolved.push({ index: idx, secret: vk.secret });
+        }
+        if (resolved.length === 0) {
+            return;
+        }
+        const { inputsData, vrfInputDataLen } = buildTicketVrfInputs(entropy, ticketsPerValidator);
+        const ringKeysData = BytesBlob.blobFromParts(ringKeys.map((k) => k.raw)).raw;
+        const runShard = (shard) => {
+            const indices = Uint32Array.from(shard.map((r) => r.index));
+            const secretSeedsData = BytesBlob.blobFromParts(shard.map((r) => r.secret.raw)).raw;
+            const params = new TicketGenShardParams(ringKeysData, indices, secretSeedsData, SEED_SIZE, inputsData, vrfInputDataLen);
+            return this.executor
+                .run(params)
+                .then((result) => {
+                const parsed = parseTicketsBatchOutput(result.signatures, indices.length, ticketsPerValidator);
+                if (parsed.isError) {
+                    logger.warn `A ticket-generation shard returned an invalid proof: ${parsed.error}`;
+                    return;
+                }
+                return onShardTickets(parsed.ok.flat());
+            })
+                .catch((e) => {
+                logger.warn `A ticket-generation shard failed: ${e}`;
+            });
+        };
+        // Dispatch small shards in waves of `workerCount` so every worker stays busy
+        // and tickets are delivered incrementally (one wave at a time) without
+        // over-queuing the executor.
+        const shardSize = Math.min(resolved.length, TICKET_SHARD_SIZE);
+        const waveSize = shardSize * this.workerCount;
+        for (let waveStart = 0; waveStart < resolved.length; waveStart += waveSize) {
+            const wave = [];
+            const waveEnd = Math.min(waveStart + waveSize, resolved.length);
+            for (let start = waveStart; start < waveEnd; start += shardSize) {
+                wave.push(runShard(resolved.slice(start, start + shardSize)));
+            }
+            await Promise.all(wave);
+        }
+    }
+}

package/packages/workers/block-authorship/ticket-validator.d.ts

@@ -0,0 +1,31 @@
+import type { Epoch } from "#@typeberry/block";
+import type { SignedTicket } from "#@typeberry/block/tickets.js";
+import type { ChainSpec } from "#@typeberry/config";
+import type { BandernsatchWasm } from "#@typeberry/safrole/bandersnatch-wasm.js";
+import type { State } from "#@typeberry/state";
+import { type TicketValidator, ValidationError, type VerifiedTicket } from "#@typeberry/ticket-pool";
+import { Result } from "#@typeberry/utils";
+/**
+ * {@link TicketValidator} implementation that verifies a ticket against the ring
+ * commitment and current epoch entropy using bandersnatch.
+ *
+ * `getState` is a thunk because state advances continuously while validation is in
+ * flight; we want the latest available state for each call.
+ */
+export declare class BandersnatchTicketValidator implements TicketValidator {
+    private readonly chainSpec;
+    private readonly bandersnatch;
+    private readonly getState;
+    static new(chainSpec: ChainSpec, bandersnatch: BandernsatchWasm, getState: () => State): BandersnatchTicketValidator;
+    private constructor();
+    validate(epochIndex: Epoch, inTickets: SignedTicket[]): Promise<Result<VerifiedTicket[], ValidationError>>;
+    /**
+     * Returns the correct tickets entropy for verification given the current state.
+     *
+     * When `state` is from epoch E-1 (i.e. we haven't produced epoch E's first block yet),
+     * the ticket entropy for epoch E is at index 1 (not yet shifted). After the epoch
+     * transition it moves to index 2.
+     */
+    private getTicketEntropy;
+}
+//# sourceMappingURL=ticket-validator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ticket-validator.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/ticket-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,KAAK,eAAe,EAAE,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACpG,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C;;;;;;GAMG;AACH,qBAAa,2BAA4B,YAAW,eAAe;IAM/D,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAP3B,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,KAAK;IAItF,OAAO;IAMD,QAAQ,CAAC,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,EAAE,eAAe,CAAC,CAAC;IAwChH;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;CAIzB"}

package/packages/workers/block-authorship/ticket-validator.js

@@ -0,0 +1,59 @@
+import bandersnatchVrf from "#@typeberry/safrole/bandersnatch-vrf.js";
+import { ValidationError } from "#@typeberry/ticket-pool";
+import { Result } from "#@typeberry/utils";
+/**
+ * {@link TicketValidator} implementation that verifies a ticket against the ring
+ * commitment and current epoch entropy using bandersnatch.
+ *
+ * `getState` is a thunk because state advances continuously while validation is in
+ * flight; we want the latest available state for each call.
+ */
+export class BandersnatchTicketValidator {
+    chainSpec;
+    bandersnatch;
+    getState;
+    static new(chainSpec, bandersnatch, getState) {
+        return new BandersnatchTicketValidator(chainSpec, bandersnatch, getState);
+    }
+    constructor(chainSpec, bandersnatch, getState) {
+        this.chainSpec = chainSpec;
+        this.bandersnatch = bandersnatch;
+        this.getState = getState;
+    }
+    async validate(epochIndex, inTickets) {
+        const state = this.getState();
+        // Reject obviously invalid epochs up front: we only have the entropy to verify
+        // the current epoch (tickets being submitted now) and the next one (tickets at
+        // an epoch boundary). Anything else would only fail after the expensive proof
+        // check, so a peer could otherwise burn CPU with far-past/future batches.
+        const stateEpoch = Math.floor(state.timeslot / this.chainSpec.epochLength);
+        if (epochIndex < stateEpoch || epochIndex > stateEpoch + 1) {
+            return Result.error(ValidationError.InvalidProof, () => `ticket batch targets an invalid epoch ${epochIndex}`);
+        }
+        const entropy = this.getTicketEntropy(epochIndex, state);
+        // Batch verifier: a single `isValid` covers the whole batch
+        // and `tickets` holds the computed id per input ticket.
+        const { isValid, tickets } = await bandersnatchVrf.verifyTickets(this.bandersnatch, state.designatedValidatorData.length, state.epochRoot, inTickets, entropy);
+        if (tickets.length !== inTickets.length) {
+            return Result.error(ValidationError.ValidatorUnavailable, () => `io size mismatch got: ${tickets.length}, expected ${inTickets.length}`);
+        }
+        if (!isValid) {
+            return Result.error(ValidationError.InvalidProof, () => "bandersnatch proof rejected");
+        }
+        return Result.ok(inTickets.map((ticket, index) => {
+            const id = tickets[index];
+            return { ticket, id };
+        }));
+    }
+    /**
+     * Returns the correct tickets entropy for verification given the current state.
+     *
+     * When `state` is from epoch E-1 (i.e. we haven't produced epoch E's first block yet),
+     * the ticket entropy for epoch E is at index 1 (not yet shifted). After the epoch
+     * transition it moves to index 2.
+     */
+    getTicketEntropy(epochIndex, state) {
+        const stateEpoch = Math.floor(state.timeslot / this.chainSpec.epochLength);
+        return epochIndex > stateEpoch ? state.entropy[1] : state.entropy[2];
+    }
+}

package/packages/workers/comms-authorship-network/protocol.d.ts

@@ -1,5 +1,5 @@
 import { type Api, type Internal } from "#@typeberry/workers-api";
-import { ReceivedTicketMessage, TicketsMessage } from "./tickets-message.js";
+import { TicketsMessage } from "./tickets-message.js";
 /**
  * Port name for authorship-network direct communication.
  * Used when spawning jam-network worker to pass the port for receiving tickets.
@@ -21,14 +21,24 @@ export declare const protocol: import("@typeberry/workers-api").LousyProtocol<{
         }>>;
         response: import("@typeberry/codec").Descriptor<void, void>;
     };
+    replaceTicketPool: {
+        request: import("@typeberry/codec").Descriptor<TicketsMessage, import("@typeberry/codec").ViewOf<TicketsMessage, {
+            epochIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"Epoch">, import("@typeberry/bytes").Bytes<4>>;
+            tickets: import("@typeberry/codec").Descriptor<import("@typeberry/block").SignedTicket[], import("@typeberry/codec").SequenceView<import("@typeberry/block").SignedTicket, import("@typeberry/codec").ViewOf<import("@typeberry/block").SignedTicket, {
+                attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
+                signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<784> & import("@typeberry/utils").WithOpaque<"BandersnatchRingSignature">, import("@typeberry/bytes").Bytes<784>>;
+            }>>>;
+        }>>;
+        response: import("@typeberry/codec").Descriptor<void, void>;
+    };
 }, {
     receivedTickets: {
-        request: import("@typeberry/codec").Descriptor<ReceivedTicketMessage, import("@typeberry/codec").ViewOf<ReceivedTicketMessage, {
+        request: import("@typeberry/codec").Descriptor<TicketsMessage, import("@typeberry/codec").ViewOf<TicketsMessage, {
             epochIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"Epoch">, import("@typeberry/bytes").Bytes<4>>;
-            ticket: import("@typeberry/codec").Descriptor<import("@typeberry/block").SignedTicket, import("@typeberry/codec").ViewOf<import("@typeberry/block").SignedTicket, {
+            tickets: import("@typeberry/codec").Descriptor<import("@typeberry/block").SignedTicket[], import("@typeberry/codec").SequenceView<import("@typeberry/block").SignedTicket, import("@typeberry/codec").ViewOf<import("@typeberry/block").SignedTicket, {
                 attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
                 signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<784> & import("@typeberry/utils").WithOpaque<"BandersnatchRingSignature">, import("@typeberry/bytes").Bytes<784>>;
-            }>>;
+            }>>>;
         }>>;
         response: import("@typeberry/codec").Descriptor<boolean, boolean>;
     };

package/packages/workers/comms-authorship-network/protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/comms-authorship-network/protocol.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAAkB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE7E;;;GAGG;AACH,eAAO,MAAM,uBAAuB,uBAAuB,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;EAiBnB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC;AACnD,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,OAAO,QAAQ,CAAC,CAAC"}
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/comms-authorship-network/protocol.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAAkB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,uBAAuB,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBnB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC;AACnD,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,OAAO,QAAQ,CAAC,CAAC"}

package/packages/workers/comms-authorship-network/protocol.js

@@ -1,6 +1,6 @@
 import { codec } from "#@typeberry/codec";
 import { createProtocol } from "#@typeberry/workers-api";
-import { ReceivedTicketMessage, TicketsMessage } from "./tickets-message.js";
+import { TicketsMessage } from "./tickets-message.js";
 /**
  * Port name for authorship-network direct communication.
  * Used when spawning jam-network worker to pass the port for receiving tickets.
@@ -12,19 +12,25 @@ export const AUTHORSHIP_NETWORK_PORT = "authorship-network";
  * This bypasses the main thread for ticket distribution, reducing latency.
  */
 export const protocol = createProtocol("authorship-network", {
-    // Messages from block-authorship to jam-network
+    // Messages from block-authorship to jam-network.
     toWorker: {
+        // Newly generated own tickets; networking should add them to its redistribution pool.
         tickets: {
             request: TicketsMessage.Codec,
             response: codec.nothing,
         },
+        // Authoritative pool snapshot for the given epoch; networking replaces its local
+        // pool with these tickets (one-way, source of truth lives in block-authorship).
+        replaceTicketPool: {
+            request: TicketsMessage.Codec,
+            response: codec.nothing,
+        },
     },
-    // Messages from jam-network to block-authorship (one ticket per relay).
-    // Response indicates whether the ticket passed validation — used by jam-network
-    // to decide whether to redistribute the ticket to other peers.
+    // Messages from jam-network to block-authorship
+    // Response indicates whether all tickets in batch were valid (no per-ticket validity!)
     fromWorker: {
         receivedTickets: {
-            request: ReceivedTicketMessage.Codec,
+            request: TicketsMessage.Codec,
             response: codec.bool,
         },
     },

package/packages/workers/comms-authorship-network/tickets-message.d.ts

@@ -15,18 +15,4 @@ export declare class TicketsMessage extends WithDebug {
     static create({ epochIndex, tickets }: CodecRecord<TicketsMessage>): TicketsMessage;
     private constructor();
 }
-/** Single-ticket message sent from jam-network to block-authorship (one ticket per peer relay). */
-export declare class ReceivedTicketMessage extends WithDebug {
-    readonly epochIndex: Epoch;
-    readonly ticket: SignedTicket;
-    static Codec: import("@typeberry/codec").Descriptor<ReceivedTicketMessage, import("@typeberry/codec").ViewOf<ReceivedTicketMessage, {
-        epochIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"Epoch">, import("@typeberry/bytes").Bytes<4>>;
-        ticket: import("@typeberry/codec").Descriptor<SignedTicket, import("@typeberry/codec").ViewOf<SignedTicket, {
-            attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
-            signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<784> & import("@typeberry/utils").WithOpaque<"BandersnatchRingSignature">, import("@typeberry/bytes").Bytes<784>>;
-        }>>;
-    }>>;
-    static create({ epochIndex, ticket }: CodecRecord<ReceivedTicketMessage>): ReceivedTicketMessage;
-    private constructor();
-}
 //# sourceMappingURL=tickets-message.d.ts.map

package/packages/workers/comms-authorship-network/tickets-message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tickets-message.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/comms-authorship-network/tickets-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,KAAK,WAAW,EAAS,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,qBAAa,cAAe,SAAQ,SAAS;aAWzB,UAAU,EAAE,KAAK;aACjB,OAAO,EAAE,YAAY,EAAE;IAXzC,MAAM,CAAC,KAAK;;;;;;QAGT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,WAAW,CAAC,cAAc,CAAC;IAIlE,OAAO;CAMR;AAED,mGAAmG;AACnG,qBAAa,qBAAsB,SAAQ,SAAS;aAWhC,UAAU,EAAE,KAAK;aACjB,MAAM,EAAE,YAAY;IAXtC,MAAM,CAAC,KAAK;;;;;;QAGT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,WAAW,CAAC,qBAAqB,CAAC;IAIxE,OAAO;CAMR"}
+{"version":3,"file":"tickets-message.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/comms-authorship-network/tickets-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,KAAK,WAAW,EAAS,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,qBAAa,cAAe,SAAQ,SAAS;aAWzB,UAAU,EAAE,KAAK;aACjB,OAAO,EAAE,YAAY,EAAE;IAXzC,MAAM,CAAC,KAAK;;;;;;QAGT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,WAAW,CAAC,cAAc,CAAC;IAIlE,OAAO;CAMR"}