@typeberry/lib 0.5.11 → 0.6.0-7d1524a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typeberry/lib",
-  "version": "0.5.11",
+  "version": "0.6.0-7d1524a",
   "description": "Typeberry Library",
   "main": "./bin/lib/index.js",
   "types": "./bin/lib/index.d.ts",
@@ -264,7 +264,7 @@
     "#@typeberry/jam-network/*": "./packages/workers/jam-network/*"
   },
   "dependencies": {
-    "@fluffylabs/anan-as": "^1.1.5",
+    "@fluffylabs/anan-as": "^1.3.0",
     "@noble/ed25519": "2.2.3",
     "hash-wasm": "4.12.0",
     "@typeberry/native": "0.2.0-74dd7d7",

package/packages/core/pvm-interpreter-ananas/index.js

@@ -109,7 +109,7 @@ export class AnanasInterpreter {
         const programArr = lowerBytes(program);
         const argsArr = lowerBytes(args);
         this.gas.initialGas = gas;
-        this.instance.resetJAM(programArr, pc, BigInt(gas), argsArr, true);
+        this.instance.resetJAM(programArr, pc, BigInt(gas), argsArr, true, false);
     }
     resetGeneric(program, _pc, gas) {
         const programArr = lowerBytes(program);

package/packages/jam/jamnp-s/tasks/ticket-distribution.d.ts

@@ -29,6 +29,13 @@ export declare class TicketDistributionTask {
      * Deduplicates tickets based on signature.
      */
     addTicket(epochIndex: Epoch, ticket: SignedTicket): void;
+    private onTicketReceivedCallback;
+    /**
+     * Register a callback that validates a received ticket.
+     * The ticket is only added to the redistribution pool if the callback returns `true`.
+     * This prevents redistribution of invalid tickets (e.g. those with a tampered `attempt` field).
+     */
+    setOnTicketReceived(cb: (epochIndex: Epoch, ticket: SignedTicket) => Promise<boolean>): void;
     private onTicketReceived;
 }
 //# sourceMappingURL=ticket-distribution.d.ts.map

package/packages/jam/jamnp-s/tasks/ticket-distribution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ticket-distribution.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/tasks/ticket-distribution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGnD,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,aAAa,CAAC;AAExD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAe1D;;;;;;GAMG;AACH,qBAAa,sBAAsB;IAuB/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAvB9B,MAAM,CAAC,KAAK,CAAC,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS;IAgBzF,yDAAyD;IACzD,OAAO,CAAC,cAAc,CAA0D;IAChF,+DAA+D;IAC/D,OAAO,CAAC,YAAY,CAAsB;IAE1C,OAAO;IAKP;;OAEG;IACH,oBAAoB;IAkDpB;;;;OAIG;IACH,SAAS,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY;IAgCjD,OAAO,CAAC,gBAAgB;CAKzB"}
+{"version":3,"file":"ticket-distribution.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/tasks/ticket-distribution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGnD,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,aAAa,CAAC;AAExD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAe1D;;;;;;GAMG;AACH,qBAAa,sBAAsB;IAuB/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAvB9B,MAAM,CAAC,KAAK,CAAC,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS;IAgBzF,yDAAyD;IACzD,OAAO,CAAC,cAAc,CAA0D;IAChF,+DAA+D;IAC/D,OAAO,CAAC,YAAY,CAAsB;IAE1C,OAAO;IAKP;;OAEG;IACH,oBAAoB;IAkDpB;;;;OAIG;IACH,SAAS,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY;IAsCjD,OAAO,CAAC,wBAAwB,CAAgF;IAEhH;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,KAAK,OAAO,CAAC,OAAO,CAAC;IAIrF,OAAO,CAAC,gBAAgB;CAsBzB"}

package/packages/jam/jamnp-s/tasks/ticket-distribution.js

@@ -82,8 +82,13 @@ export class TicketDistributionTask {
      * Deduplicates tickets based on signature.
      */
     addTicket(epochIndex, ticket) {
-        // Check if epoch changed - if so, clear old tickets
-        if (this.currentEpoch !== null && this.currentEpoch !== epochIndex) {
+        // Drop tickets for older epochs (can happen when a delayed validation callback completes
+        // after the epoch has already advanced — accepting it would roll back currentEpoch).
+        if (this.currentEpoch !== null && epochIndex < this.currentEpoch) {
+            return;
+        }
+        // Epoch advanced — clear old tickets
+        if (this.currentEpoch !== null && epochIndex > this.currentEpoch) {
             logger.log `[addTicket] Epoch changed from ${this.currentEpoch} to ${epochIndex}, clearing ${this.pendingTickets.length} old tickets`;
             this.pendingTickets = [];
             // Note: We don't need to clear aux data for all peers here.
@@ -107,9 +112,37 @@ export class TicketDistributionTask {
             logger.info `[addTicket] Added ticket for epoch ${epochIndex}, total: ${this.pendingTickets.length}`;
         }
     }
+    onTicketReceivedCallback = null;
+    /**
+     * Register a callback that validates a received ticket.
+     * The ticket is only added to the redistribution pool if the callback returns `true`.
+     * This prevents redistribution of invalid tickets (e.g. those with a tampered `attempt` field).
+     */
+    setOnTicketReceived(cb) {
+        this.onTicketReceivedCallback = cb;
+    }
     onTicketReceived(epochIndex, ticket) {
         logger.trace `Received ticket for epoch ${epochIndex}, attempt ${ticket.attempt}`;
-        // Add to pending queue for potential re-distribution
-        this.addTicket(epochIndex, ticket);
+        if (this.onTicketReceivedCallback !== null) {
+            // Validate first; only redistribute if valid to avoid spreading tampered tickets.
+            // Wrap with Promise.resolve().then() to catch both sync throws and async rejections.
+            const cb = this.onTicketReceivedCallback;
+            Promise.resolve()
+                .then(() => cb(epochIndex, ticket))
+                .then((isValid) => {
+                if (isValid) {
+                    this.addTicket(epochIndex, ticket);
+                }
+                else {
+                    logger.warn `Dropping invalid ticket for epoch ${epochIndex} (validation failed)`;
+                }
+            })
+                .catch((error) => {
+                logger.error `Error validating ticket for epoch ${epochIndex}, attempt ${ticket.attempt}: ${error}`;
+            });
+        }
+        else {
+            this.addTicket(epochIndex, ticket);
+        }
     }
 }

package/packages/jam/jamnp-s/tasks/ticket-distribution.test.js

@@ -208,7 +208,7 @@ describe("TicketDistributionTask", () => {
         peer1.ticketTask.addTicket(TEST_EPOCH, ticket);
         peer1.ticketTask.maintainDistribution();
         await tick();
-        // Self receives the ticket (via onTicketReceived -> addTicket)
+        // Self receives the ticket (via onTicketReceived -> addTicket, no callback set)
         assert.strictEqual(self.receivedTickets.length, 1);
         // Self should re-distribute to peer2 (and peer1, but peer1 already has it)
         self.ticketTask.maintainDistribution();
@@ -217,4 +217,43 @@ describe("TicketDistributionTask", () => {
         assert.strictEqual(peer2.receivedTickets.length, 1);
         assert.deepStrictEqual(peer2.receivedTickets[0].ticket, ticket);
     });
+    it("should NOT redistribute ticket if validation callback returns false", async () => {
+        const self = await init("self");
+        const peer1 = await init("peer1");
+        const peer2 = await init("peer2");
+        self.openConnection(peer1);
+        self.openConnection(peer2);
+        await tick();
+        // Validation always rejects
+        self.ticketTask.setOnTicketReceived(async () => false);
+        const ticket = createTestTicket(0);
+        peer1.ticketTask.addTicket(TEST_EPOCH, ticket);
+        peer1.ticketTask.maintainDistribution();
+        await tick();
+        // self.addTicket was NOT called (callback returned false), so nothing to redistribute
+        assert.strictEqual(self.receivedTickets.length, 0);
+        self.ticketTask.maintainDistribution();
+        await tick();
+        assert.strictEqual(peer2.receivedTickets.length, 0);
+    });
+    it("should redistribute ticket if validation callback returns true", async () => {
+        const self = await init("self");
+        const peer1 = await init("peer1");
+        const peer2 = await init("peer2");
+        self.openConnection(peer1);
+        self.openConnection(peer2);
+        await tick();
+        // Validation always accepts
+        self.ticketTask.setOnTicketReceived(async () => true);
+        const ticket = createTestTicket(0);
+        peer1.ticketTask.addTicket(TEST_EPOCH, ticket);
+        peer1.ticketTask.maintainDistribution();
+        await tick();
+        // self.addTicket WAS called (callback returned true)
+        assert.strictEqual(self.receivedTickets.length, 1);
+        self.ticketTask.maintainDistribution();
+        await tick();
+        assert.strictEqual(peer2.receivedTickets.length, 1);
+        assert.deepStrictEqual(peer2.receivedTickets[0].ticket, ticket);
+    });
 });

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

@@ -1,5 +1,6 @@
-import { Block, type TimeSlot, type ValidatorIndex } from "#@typeberry/block";
+import { Block, type EntropyHash, type TimeSlot, type ValidatorIndex } from "#@typeberry/block";
 import { type BlockView } from "#@typeberry/block/block.js";
+import type { SignedTicket } from "#@typeberry/block/tickets.js";
 import { BytesBlob } from "#@typeberry/bytes";
 import type { ChainSpec } from "#@typeberry/config";
 import { type BandersnatchSecretSeed } from "#@typeberry/crypto";
@@ -38,7 +39,10 @@ export declare class Generator {
     static new(args: GeneratorArgs): Generator;
     private constructor();
     private getLastHeaderAndState;
-    nextBlockView(validatorIndex: ValidatorIndex, bandersnatchSecret: BandersnatchSecretSeed, sealPayload: BlockSealInput, timeSlot: TimeSlot): Promise<BlockView>;
+    nextBlockView(validatorIndex: ValidatorIndex, bandersnatchSecret: BandersnatchSecretSeed, sealPayload: BlockSealInput, timeSlot: TimeSlot, pendingTickets?: {
+        ticket: SignedTicket;
+        id: EntropyHash;
+    }[]): Promise<BlockView>;
     /**
      * Returns y(H_S) part of the VRF signature.
      *
@@ -50,6 +54,21 @@ export declare class Generator {
      * data (i.e. the `aux_data`) so we are able to compute it beforehand.
      */
     private getEntropyHash;
-    nextBlock(validatorIndex: ValidatorIndex, bandersnatchSecret: BandersnatchSecretSeed, sealPayload: BlockSealInput, timeSlot: TimeSlot): Promise<Block>;
+    /**
+     * Selects tickets to include in the extrinsic from the pending pool.
+     *
+     * Tickets were already verified at receipt time (IDs pre-computed). This method:
+     * 1. Filters out tickets whose IDs are already in `state.ticketsAccumulator` (already processed).
+     * 2. Sorts remaining tickets by ID ascending (required by Safrole).
+     * 3. Deduplicates by ID (pool dedup is best-effort; reorgs can produce duplicates).
+     * 4. Returns at most `chainSpec.maxTicketsPerExtrinsic` tickets.
+     *
+     * Called only during the contest period (slotInEpoch < contestLength).
+     */
+    private prepareTicketsExtrinsic;
+    nextBlock(validatorIndex: ValidatorIndex, bandersnatchSecret: BandersnatchSecretSeed, sealPayload: BlockSealInput, timeSlot: TimeSlot, pendingTickets?: {
+        ticket: SignedTicket;
+        id: EntropyHash;
+    }[]): Promise<Block>;
 }
 //# sourceMappingURL=generator.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAIL,KAAK,QAAQ,EACb,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,2BAA2B,CAAC;AAEtE,OAAO,EAAS,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,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,oDAAoD;AACpD,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,SAAS;IACpB,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,wDAAwD;IACxD,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,GACjB,OAAO,CAAC,SAAS,CAAC;IAKrB;;;;;;;;;OASG;YACW,cAAc;IAiBtB,SAAS,CACb,cAAc,EAAE,cAAc,EAC9B,kBAAkB,EAAE,sBAAsB,EAC1C,WAAW,EAAE,cAAc,EAC3B,QAAQ,EAAE,QAAQ;CAgGrB"}
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/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,oDAAoD;AACpD,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,SAAS;IACpB,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,wDAAwD;IACxD,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

@@ -2,6 +2,7 @@ import { Block, encodeUnsealedHeader, Header, reencodeAsView, } from "#@typeberr
 import { Extrinsic } from "#@typeberry/block/block.js";
 import { DisputesExtrinsic } from "#@typeberry/block/disputes.js";
 import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { HashSet } from "#@typeberry/collections/hash-set.js";
 import { BANDERSNATCH_VRF_SIGNATURE_BYTES } from "#@typeberry/crypto";
 import { Logger } from "#@typeberry/logger";
 import { Safrole } from "#@typeberry/safrole";
@@ -44,8 +45,8 @@ export class Generator {
             lastState,
         };
     }
-    async nextBlockView(validatorIndex, bandersnatchSecret, sealPayload, timeSlot) {
-        const newBlock = await this.nextBlock(validatorIndex, bandersnatchSecret, sealPayload, timeSlot);
+    async nextBlockView(validatorIndex, bandersnatchSecret, sealPayload, timeSlot, pendingTickets = []) {
+        const newBlock = await this.nextBlock(validatorIndex, bandersnatchSecret, sealPayload, timeSlot, pendingTickets);
         return reencodeAsView(Block.Codec, newBlock, this.chainSpec);
     }
     /**
@@ -65,7 +66,37 @@ export class Generator {
         }
         return entropyHashResult;
     }
-    async nextBlock(validatorIndex, bandersnatchSecret, sealPayload, timeSlot) {
+    /**
+     * Selects tickets to include in the extrinsic from the pending pool.
+     *
+     * Tickets were already verified at receipt time (IDs pre-computed). This method:
+     * 1. Filters out tickets whose IDs are already in `state.ticketsAccumulator` (already processed).
+     * 2. Sorts remaining tickets by ID ascending (required by Safrole).
+     * 3. Deduplicates by ID (pool dedup is best-effort; reorgs can produce duplicates).
+     * 4. Returns at most `chainSpec.maxTicketsPerExtrinsic` tickets.
+     *
+     * Called only during the contest period (slotInEpoch < contestLength).
+     */
+    prepareTicketsExtrinsic(pendingTickets, state) {
+        if (pendingTickets.length === 0) {
+            return [];
+        }
+        // Tickets are already verified at receipt time — just filter, sort and slice.
+        // Build a set of ticket IDs already in the state accumulator for fast lookup.
+        const accumulatedIds = HashSet.from(state.ticketsAccumulator.map((t) => t.id));
+        const filtered = pendingTickets.filter(({ id }) => !accumulatedIds.has(id));
+        // Sort by ID ascending
+        filtered.sort((a, b) => a.id.compare(b.id).value);
+        // Deduplicate by ID (pool dedup is best-effort; state may produce duplicates across reorgs)
+        const deduped = [];
+        for (const item of filtered) {
+            if (deduped.length === 0 || !deduped[deduped.length - 1].id.isEqualTo(item.id)) {
+                deduped.push(item);
+            }
+        }
+        return deduped.slice(0, this.chainSpec.maxTicketsPerExtrinsic).map(({ ticket }) => ticket);
+    }
+    async nextBlock(validatorIndex, bandersnatchSecret, sealPayload, timeSlot, pendingTickets = []) {
         this.metrics.recordBlockAuthoringStarted(timeSlot);
         const startTime = now();
         // fetch latest data from the db.
@@ -85,9 +116,12 @@ export class Generator {
         // retrieve data from previous block
         const hasher = TransitionHasher.new(this.keccakHasher, this.blake2b);
         const stateRoot = this.states.getStateRoot(lastState);
-        // TODO create extrinsic
+        const slotInEpoch = timeSlot % this.chainSpec.epochLength;
+        const isContestPeriod = slotInEpoch < this.chainSpec.contestLength;
+        // Include tickets only during contest period
+        const ticketsForExtrinsic = isContestPeriod ? await this.prepareTicketsExtrinsic(pendingTickets, lastState) : [];
         const extrinsic = Extrinsic.create({
-            tickets: asOpaqueType([]),
+            tickets: asOpaqueType(ticketsForExtrinsic),
             preimages: [],
             guarantees: asOpaqueType([]),
             assurances: asOpaqueType([]),

package/packages/workers/block-authorship/generator.test.js

@@ -1,9 +1,10 @@
 import { afterEach, beforeEach, describe, it, mock } from "node:test";
 import { Block, DisputesExtrinsic, EpochMarker, Extrinsic, Header, tryAsTimeSlot, tryAsValidatorIndex, ValidatorKeys, } from "#@typeberry/block";
+import { SignedTicket, Ticket, tryAsTicketAttempt } from "#@typeberry/block/tickets.js";
 import { Bytes, BytesBlob } from "#@typeberry/bytes";
 import { asKnownSize, FixedSizeArray } from "#@typeberry/collections";
 import { tinyChainSpec } from "#@typeberry/config";
-import { BANDERSNATCH_KEY_BYTES, BANDERSNATCH_VRF_SIGNATURE_BYTES, BLS_KEY_BYTES, ED25519_KEY_BYTES, initWasm, } from "#@typeberry/crypto";
+import { BANDERSNATCH_KEY_BYTES, BANDERSNATCH_PROOF_BYTES, BANDERSNATCH_VRF_SIGNATURE_BYTES, BLS_KEY_BYTES, ED25519_KEY_BYTES, initWasm, } from "#@typeberry/crypto";
 import { BANDERSNATCH_RING_ROOT_BYTES } from "#@typeberry/crypto/bandersnatch.js";
 import { Blake2b, HASH_SIZE, keccak } from "#@typeberry/hash";
 import bandersnatchVrf from "#@typeberry/safrole/bandersnatch-vrf.js";
@@ -174,6 +175,206 @@ describe("Generator", () => {
             });
             deepEqual(block, expectedBlock);
         });
+        it("should include sorted tickets during contest period", async () => {
+            // tinyChainSpec: contestLength = 10, so slot 1 is in contest period (1 < 10)
+            const state = createMockState(0);
+            const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
+            const statesDb = createMockStatesDb(state);
+            const generator = Generator.new({
+                chainSpec: tinyChainSpec,
+                bandersnatch,
+                keccakHasher,
+                blake2b,
+                blocks: blocksDb,
+                states: statesDb,
+            });
+            // Create two tickets with different signatures
+            const sig1 = Bytes.zero(BANDERSNATCH_PROOF_BYTES);
+            sig1.raw[0] = 1;
+            const sig2 = Bytes.zero(BANDERSNATCH_PROOF_BYTES);
+            sig2.raw[0] = 2;
+            const ticket1 = SignedTicket.create({
+                attempt: tryAsTicketAttempt(0),
+                signature: sig1.asOpaque(),
+            });
+            const ticket2 = SignedTicket.create({
+                attempt: tryAsTicketAttempt(0),
+                signature: sig2.asOpaque(),
+            });
+            // ticket2 gets smaller ID (0x01...) and ticket1 gets larger ID (0x02...)
+            // so the sorted order should be [ticket2, ticket1]
+            const id1 = Bytes.fill(HASH_SIZE, 0x02).asOpaque();
+            const id2 = Bytes.fill(HASH_SIZE, 0x01).asOpaque();
+            const validatorIndex = tryAsValidatorIndex(0);
+            // Slot 1 is in contest period (1 < contestLength=10)
+            const timeSlot = tryAsTimeSlot(1);
+            // IDs are now pre-computed before passing to nextBlock
+            const block = await generator.nextBlock(validatorIndex, MOCK_BANDERSNATCH_SECRET, MOCK_SEAL_PAYLOAD, timeSlot, [
+                { ticket: ticket1, id: id1 },
+                { ticket: ticket2, id: id2 },
+            ]);
+            // Tickets should be sorted by ID ascending: ticket2 (id=0x01) before ticket1 (id=0x02)
+            const tickets = block.extrinsic.tickets;
+            deepEqual(tickets.length, 2);
+            deepEqual(tickets[0].signature, sig2.asOpaque());
+            deepEqual(tickets[1].signature, sig1.asOpaque());
+        });
+        it("should exclude tickets outside contest period", async () => {
+            // tinyChainSpec: contestLength = 10, epochLength = 12
+            // Slot 10 is outside contest period (10 >= 10)
+            const state = createMockState(9);
+            const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
+            const statesDb = createMockStatesDb(state);
+            const generator = Generator.new({
+                chainSpec: tinyChainSpec,
+                bandersnatch,
+                keccakHasher,
+                blake2b,
+                blocks: blocksDb,
+                states: statesDb,
+            });
+            const sig1 = Bytes.zero(BANDERSNATCH_PROOF_BYTES);
+            const ticket1 = SignedTicket.create({
+                attempt: tryAsTicketAttempt(0),
+                signature: sig1.asOpaque(),
+            });
+            const validatorIndex = tryAsValidatorIndex(0);
+            // Slot 10 is NOT in contest period (10 >= contestLength=10)
+            const timeSlot = tryAsTimeSlot(10);
+            const mockId = Bytes.fill(HASH_SIZE, 0x01).asOpaque();
+            const block = await generator.nextBlock(validatorIndex, MOCK_BANDERSNATCH_SECRET, MOCK_SEAL_PAYLOAD, timeSlot, [
+                { ticket: ticket1, id: mockId },
+            ]);
+            // No tickets should be included outside contest period
+            const tickets = block.extrinsic.tickets;
+            deepEqual(tickets.length, 0);
+        });
+        it("should filter out tickets already in ticketsAccumulator", async () => {
+            // Build a state that already has ticket with id=0x01 in its accumulator
+            const accumulatedId = Bytes.fill(HASH_SIZE, 0x01).asOpaque();
+            const accumulatedTicket = Ticket.create({
+                id: accumulatedId,
+                attempt: tryAsTicketAttempt(0),
+            });
+            const state = {
+                ...createMockState(0),
+                ticketsAccumulator: asKnownSize([accumulatedTicket]),
+            };
+            const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
+            const statesDb = createMockStatesDb(state);
+            const generator = Generator.new({
+                chainSpec: tinyChainSpec,
+                bandersnatch,
+                keccakHasher,
+                blake2b,
+                blocks: blocksDb,
+                states: statesDb,
+            });
+            const sig1 = Bytes.zero(BANDERSNATCH_PROOF_BYTES);
+            sig1.raw[0] = 1;
+            const sig2 = Bytes.zero(BANDERSNATCH_PROOF_BYTES);
+            sig2.raw[0] = 2;
+            const ticketAlreadyAccumulated = SignedTicket.create({
+                attempt: tryAsTicketAttempt(0),
+                signature: sig1.asOpaque(),
+            });
+            const ticketNew = SignedTicket.create({
+                attempt: tryAsTicketAttempt(0),
+                signature: sig2.asOpaque(),
+            });
+            // id=0x01 is already in accumulator, id=0x02 is new
+            const idAccumulated = Bytes.fill(HASH_SIZE, 0x01).asOpaque();
+            const idNew = Bytes.fill(HASH_SIZE, 0x02).asOpaque();
+            const validatorIndex = tryAsValidatorIndex(0);
+            const timeSlot = tryAsTimeSlot(1); // inside contest period
+            const block = await generator.nextBlock(validatorIndex, MOCK_BANDERSNATCH_SECRET, MOCK_SEAL_PAYLOAD, timeSlot, [
+                { ticket: ticketAlreadyAccumulated, id: idAccumulated },
+                { ticket: ticketNew, id: idNew },
+            ]);
+            // Only the new ticket (not in accumulator) should be included
+            const tickets = block.extrinsic.tickets;
+            deepEqual(tickets.length, 1);
+            deepEqual(tickets[0].signature, sig2.asOpaque());
+        });
+        it("should deduplicate tickets by ID", async () => {
+            const state = createMockState(0);
+            const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
+            const statesDb = createMockStatesDb(state);
+            const generator = Generator.new({
+                chainSpec: tinyChainSpec,
+                bandersnatch,
+                keccakHasher,
+                blake2b,
+                blocks: blocksDb,
+                states: statesDb,
+            });
+            const sig1 = Bytes.zero(BANDERSNATCH_PROOF_BYTES);
+            sig1.raw[0] = 1;
+            const sig2 = Bytes.zero(BANDERSNATCH_PROOF_BYTES);
+            sig2.raw[0] = 2;
+            // Two different SignedTicket objects but with the same ID (e.g. duplicate from reorg)
+            const ticketA = SignedTicket.create({
+                attempt: tryAsTicketAttempt(0),
+                signature: sig1.asOpaque(),
+            });
+            const ticketB = SignedTicket.create({
+                attempt: tryAsTicketAttempt(0),
+                signature: sig2.asOpaque(),
+            });
+            const duplicateId = Bytes.fill(HASH_SIZE, 0x05).asOpaque();
+            const validatorIndex = tryAsValidatorIndex(0);
+            const timeSlot = tryAsTimeSlot(1);
+            const block = await generator.nextBlock(validatorIndex, MOCK_BANDERSNATCH_SECRET, MOCK_SEAL_PAYLOAD, timeSlot, [
+                { ticket: ticketA, id: duplicateId },
+                { ticket: ticketB, id: duplicateId }, // same ID — should be deduplicated
+            ]);
+            const tickets = block.extrinsic.tickets;
+            deepEqual(tickets.length, 1);
+            // First occurrence is kept after sort (both have same ID, ticketA comes first)
+            deepEqual(tickets[0].signature, sig1.asOpaque());
+        });
+        it("should include at most maxTicketsPerExtrinsic tickets", async () => {
+            // tinyChainSpec.maxTicketsPerExtrinsic = 3
+            const state = createMockState(0);
+            const blocksDb = createMockBlocksDb(MOCK_PARENT_HASH);
+            const statesDb = createMockStatesDb(state);
+            const generator = Generator.new({
+                chainSpec: tinyChainSpec,
+                bandersnatch,
+                keccakHasher,
+                blake2b,
+                blocks: blocksDb,
+                states: statesDb,
+            });
+            // Create 4 tickets — only 3 should be included (lowest IDs win)
+            const makeTicket = (sigByte, idByte) => {
+                const sig = Bytes.zero(BANDERSNATCH_PROOF_BYTES);
+                sig.raw[0] = sigByte;
+                return {
+                    ticket: SignedTicket.create({ attempt: tryAsTicketAttempt(0), signature: sig.asOpaque() }),
+                    id: Bytes.fill(HASH_SIZE, idByte).asOpaque(),
+                    sig: sig.asOpaque(),
+                };
+            };
+            const t1 = makeTicket(1, 0x01); // lowest ID
+            const t2 = makeTicket(2, 0x02);
+            const t3 = makeTicket(3, 0x03);
+            const t4 = makeTicket(4, 0x04); // highest ID — should be excluded
+            const validatorIndex = tryAsValidatorIndex(0);
+            const timeSlot = tryAsTimeSlot(1);
+            const block = await generator.nextBlock(validatorIndex, MOCK_BANDERSNATCH_SECRET, MOCK_SEAL_PAYLOAD, timeSlot, [
+                { ticket: t4.ticket, id: t4.id }, // pass out-of-order to verify sorting
+                { ticket: t2.ticket, id: t2.id },
+                { ticket: t3.ticket, id: t3.id },
+                { ticket: t1.ticket, id: t1.id },
+            ]);
+            const tickets = block.extrinsic.tickets;
+            deepEqual(tickets.length, 3); // maxTicketsPerExtrinsic = 3
+            // Should include the 3 lowest IDs, sorted ascending
+            deepEqual(tickets[0].signature, t1.sig);
+            deepEqual(tickets[1].signature, t2.sig);
+            deepEqual(tickets[2].signature, t3.sig);
+        });
         it("should create block with epoch marker at epoch boundary", async () => {
             // tinyChainSpec.epochLength = 12, so:
             // - timeslot 11 is last slot of epoch 0

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":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAgB3E,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;AAkBlD,wBAAsB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,iBAsPpG"}
+{"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"}

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

@@ -1,6 +1,7 @@
 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 { initWasm } from "#@typeberry/crypto";
 import { deriveBandersnatchPublicKey, deriveEd25519PublicKey, } from "#@typeberry/crypto/key-derivation.js";
@@ -8,10 +9,11 @@ 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 { asOpaqueType, assertNever, Result } from "#@typeberry/utils";
+import { asOpaqueType, Result } from "#@typeberry/utils";
 import { Generator } from "./generator.js";
 import { generateTickets } from "./ticket-generator.js";
 const logger = Logger.new(import.meta.filename, "author");
@@ -51,10 +53,22 @@ export async function main(config, comms, networkingComms) {
     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 initialKeys = await getSealingKeySeries(startTimeSlot % chainSpec.epochLength === 0, startTimeSlot, initialState);
+        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() {
@@ -63,14 +77,6 @@ export async function main(config, comms, networkingComms) {
         const slotDurationMs = BigInt(chainSpec.slotDuration * 1000);
         return tryAsU64(BigInt(startTimeSlot) * slotDurationMs + timeFromStart + slotDurationMs);
     }
-    function getKeyForCurrentSlot(sealingKeySeries, keys, timeSlot) {
-        if (sealingKeySeries.kind === SafroleSealingKeysKind.Keys) {
-            const indexForCurrentSlot = timeSlot % sealingKeySeries.keys.length;
-            const sealingKey = sealingKeySeries.keys[indexForCurrentSlot];
-            return keys.find((x) => x.bandersnatchPublic.isEqualTo(sealingKey)) ?? null;
-        }
-        throw new Error("Tickets mode is not supported yet");
-    }
     function getValidatorIndex(key, currentValidatorData) {
         const index = currentValidatorData.findIndex((data) => data.bandersnatch.isEqualTo(key.bandersnatchPublic));
         if (index < 0) {
@@ -78,14 +84,65 @@ export async function main(config, comms, networkingComms) {
         }
         return tryAsValidatorIndex(index);
     }
-    function getSealPayload(sealingKeySeries, entropy, attempt) {
+    /**
+     * 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;
+        }
+        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) });
+                }
+            }
+        }
+        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) {
-            return asOpaqueType(BytesBlob.blobFromParts(JAM_FALLBACK_SEAL, entropy.raw));
+            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;
+            }
+            return {
+                key,
+                sealPayload: getFallbackSealPayload(entropy),
+                logId: `key ${key.bandersnatchPublic}`,
+            };
         }
-        if (sealingKeySeries.kind === SafroleSealingKeysKind.Tickets) {
-            return asOpaqueType(BytesBlob.blobFromParts(JAM_TICKET_SEAL, entropy.raw, new Uint8Array([attempt ?? 0])));
+        // 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;
         }
-        assertNever(sealingKeySeries);
+        return { ...cached, logId: `ticket ${ticket.id} (attempt ${ticket.attempt})` };
     }
     function isEpochChanged(lastTimeslot, currentTimeslot) {
         const lastEpoch = Math.floor(lastTimeslot / chainSpec.epochLength);
@@ -93,11 +150,17 @@ export async function main(config, comms, networkingComms) {
         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 key = getKeyForCurrentSlot(sealingKeySeries, keys, tryAsTimeSlot(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}`;
@@ -118,13 +181,86 @@ export async function main(config, comms, networkingComms) {
         }
         return Result.ok(state.sealingKeySeries);
     }
+    // Ticket pool: epochIndex -> {ticket, id}[]
+    // IDs (entropyHash) are computed at receipt time via verifyTickets(), enabling O(1) dedup by ID.
+    const ticketPool = new Map();
+    const ticketIdSets = new Map();
+    /**
+     * Adds pre-verified tickets to the in-memory ticket pool for the given epoch.
+     *
+     * Clears the pool when the epoch changes (we only ever need tickets for one epoch at a time).
+     * Deduplicates by ticket ID using a HashSet for O(1) lookup — prevents double-counting
+     * tickets received from multiple peers or via both CE-131 and CE-132 paths.
+     */
+    function addToPool(epochIndex, verifiedTickets) {
+        if (ticketPool.size > 0 && !ticketPool.has(epochIndex)) {
+            ticketPool.clear();
+            ticketIdSets.clear();
+        }
+        const existing = ticketPool.get(epochIndex) ?? [];
+        let idSet = ticketIdSets.get(epochIndex) ?? null;
+        if (idSet === null) {
+            idSet = HashSet.new();
+            ticketIdSets.set(epochIndex, idSet);
+        }
+        for (const entry of verifiedTickets) {
+            if (!idSet.has(entry.id)) {
+                existing.push(entry);
+                idSet.insert(entry.id);
+            }
+        }
+        ticketPool.set(epochIndex, existing);
+    }
+    /**
+     * 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.
+     */
+    function getTicketEntropy(epochIndex, state) {
+        const stateEpoch = Math.floor(state.timeslot / chainSpec.epochLength);
+        return epochIndex > stateEpoch ? state.entropy[1] : state.entropy[2];
+    }
+    /**
+     * Verifies tickets against the ring commitment and current epoch entropy, then adds valid
+     * ones to the pool with their computed IDs.
+     *
+     * Called both for own generated tickets and for tickets relayed from peers.
+     * Verification computes the ticket ID (entropyHash) which is then used for
+     * deduplication in the pool and later when building the extrinsic.
+     */
+    async function verifyAndAddToPool(epochIndex, tickets, state) {
+        const results = await bandersnatchVrf.verifyTickets(bandersnatch, state.designatedValidatorData.length, state.epochRoot, tickets, getTicketEntropy(epochIndex, state));
+        if (results.length !== tickets.length) {
+            logger.error `verifyTickets returned ${results.length} results for ${tickets.length} tickets`;
+            return false;
+        }
+        const verified = tickets
+            .map((ticket, i) => ({ ticket, id: results[i].entropyHash }))
+            .filter((_, i) => results[i].isValid);
+        addToPool(epochIndex, verified);
+        return verified.length > 0;
+    }
+    // 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 hash = blocks.getBestHeaderHash();
+        const state = states.getState(hash);
+        if (state === null) {
+            logger.warn `Cannot verify received ticket: no state available`;
+            return false;
+        }
+        return await verifyAndAddToPool(epochIndex, [ticket], state);
+    });
     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;
+        const currentValidatorData = state?.currentValidatorData ?? null;
         if (state === null) {
             continue;
         }
@@ -165,6 +301,8 @@ export async function main(config, comms, networkingComms) {
                 }
                 else {
                     logger.log `Generated ${ticketsResult.ok.length} tickets for epoch ${epoch}. Distributing...`;
+                    // Verify own tickets to get IDs, then add to pool
+                    await verifyAndAddToPool(epoch, ticketsResult.ok, state);
                     // Send directly to network worker (bypasses main thread)
                     await networkingComms.sendTickets({ epochIndex: epoch, tickets: ticketsResult.ok });
                 }
@@ -175,19 +313,31 @@ export async function main(config, comms, networkingComms) {
         if (selingKeySeriesResult.isError) {
             continue;
         }
-        if (isNewEpoch) {
-            logEpochBlockCreation(epoch, selingKeySeriesResult.ok);
+        // 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);
+            }
+            await buildTicketAuthorshipCache(selingKeySeriesResult.ok, entropy);
         }
-        const key = getKeyForCurrentSlot(selingKeySeriesResult.ok, keys, timeSlot);
-        if (key !== null && currentValidatorData !== undefined) {
+        const sealData = getSealData(selingKeySeriesResult.ok, keys, timeSlot, entropy);
+        if (sealData !== null && currentValidatorData !== null) {
+            const { key, sealPayload } = sealData;
             const validatorIndex = getValidatorIndex(key, currentValidatorData);
             if (validatorIndex === null) {
                 continue;
             }
-            logger.log `Attempting to create a block using key ${key.bandersnatchPublic} located at validator index ${validatorIndex}.`;
-            const entropy = isNewEpoch ? state.entropy[2] : state.entropy[3];
-            const sealPayload = getSealPayload(selingKeySeriesResult.ok, entropy);
-            const newBlock = await generator.nextBlockView(validatorIndex, key.bandersnatchSecret, sealPayload, timeSlot);
+            logger.log `Attempting to create a block using ${sealData.logId} located at validator index ${validatorIndex}.`;
+            const currentEpochTickets = ticketPool.get(epoch) ?? [];
+            const newBlock = await generator.nextBlockView(validatorIndex, key.bandersnatchSecret, sealPayload, timeSlot, currentEpochTickets);
             counter += 1;
             lastGeneratedSlot = timeSlot;
             logger.trace `Sending block ${counter}`;

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

@@ -1,5 +1,5 @@
 import { type Api, type Internal } from "#@typeberry/workers-api";
-import { TicketsMessage } from "./tickets-message.js";
+import { ReceivedTicketMessage, 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,7 +21,18 @@ export declare const protocol: import("@typeberry/workers-api").LousyProtocol<{
         }>>;
         response: import("@typeberry/codec").Descriptor<void, void>;
     };
-}, {}>;
+}, {
+    receivedTickets: {
+        request: 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<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>;
+    };
+}>;
 export type NetworkingComms = Api<typeof protocol>;
 export type AuthorshipComms = Internal<typeof protocol>;
 //# sourceMappingURL=protocol.d.ts.map

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,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,uBAAuB,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;MAUnB,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,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"}

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

@@ -1,6 +1,6 @@
 import { codec } from "#@typeberry/codec";
 import { createProtocol } from "#@typeberry/workers-api";
-import { TicketsMessage } from "./tickets-message.js";
+import { ReceivedTicketMessage, 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.
@@ -19,6 +19,13 @@ export const protocol = createProtocol("authorship-network", {
             response: codec.nothing,
         },
     },
-    // Messages from jam-network to block-authorship (none for now)
-    fromWorker: {},
+    // 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.
+    fromWorker: {
+        receivedTickets: {
+            request: ReceivedTicketMessage.Codec,
+            response: codec.bool,
+        },
+    },
 });

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

@@ -15,4 +15,18 @@ 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"}
+{"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"}

package/packages/workers/comms-authorship-network/tickets-message.js

@@ -17,3 +17,20 @@ export class TicketsMessage extends WithDebug {
         this.tickets = tickets;
     }
 }
+/** Single-ticket message sent from jam-network to block-authorship (one ticket per peer relay). */
+export class ReceivedTicketMessage extends WithDebug {
+    epochIndex;
+    ticket;
+    static Codec = codec.Class(ReceivedTicketMessage, {
+        epochIndex: codec.u32.asOpaque(),
+        ticket: SignedTicket.Codec,
+    });
+    static create({ epochIndex, ticket }) {
+        return new ReceivedTicketMessage(epochIndex, ticket);
+    }
+    constructor(epochIndex, ticket) {
+        super();
+        this.epochIndex = epochIndex;
+        this.ticket = ticket;
+    }
+}

package/packages/workers/jam-network/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/jam-network/main.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAK3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAI1E;;;;;;GAMG;AACH,wBAAsB,IAAI,CACxB,MAAM,EAAE,YAAY,CAAC,gBAAgB,CAAC,EACtC,KAAK,EAAE,kBAAkB,EACzB,eAAe,EAAE,eAAe,iBAmDjC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/jam-network/main.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAK3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAI1E;;;;;;GAMG;AACH,wBAAsB,IAAI,CACxB,MAAM,EAAE,YAAY,CAAC,gBAAgB,CAAC,EACtC,KAAK,EAAE,kBAAkB,EACzB,eAAe,EAAE,eAAe,iBAyDjC"}

package/packages/workers/jam-network/main.js

@@ -38,6 +38,11 @@ export async function main(config, comms, authorshipComms) {
             network.ticketTask.addTicket(epochIndex, ticket);
         }
     });
+    // Relay tickets received from peers back to block-authorship (one ticket at a time).
+    // Returns the validation result so ticket-distribution knows whether to redistribute.
+    network.ticketTask.setOnTicketReceived(async (epochIndex, ticket) => {
+        return await authorshipComms.sendReceivedTickets({ epochIndex, ticket });
+    });
     await network.network.start();
     // stop the network when the worker is finishing.
     await waitForFinish;