@typeberry/lib 0.6.0 → 0.6.1-3e97e3e

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