@typeberry/lib 0.5.7 → 0.5.8-2073cb2

package/packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.d.ts

@@ -2,6 +2,7 @@ import type { Epoch } from "#@typeberry/block";
 import { SignedTicket } from "#@typeberry/block/tickets.js";
 import type { BytesBlob } from "#@typeberry/bytes";
 import { type CodecRecord } from "#@typeberry/codec";
+import type { ChainSpec } from "#@typeberry/config";
 import { WithDebug } from "#@typeberry/utils";
 import { type StreamHandler, type StreamId, type StreamMessageSender } from "./stream.js";
 /**
@@ -14,13 +15,17 @@ import { type StreamHandler, type StreamId, type StreamMessageSender } from "./s
 export declare const STREAM_KIND_GENERATOR_TO_PROXY: 131 & import("@typeberry/numbers").WithBytesRepresentation<1>;
 export declare const STREAM_KIND_PROXY_TO_ALL: 132 & import("@typeberry/numbers").WithBytesRepresentation<1>;
 type STREAM_KIND = typeof STREAM_KIND_GENERATOR_TO_PROXY | typeof STREAM_KIND_PROXY_TO_ALL;
+/**
+ * Network protocol message for distributing a single ticket.
+ * Used in CE-131/CE-132 streams.
+ */
 export declare class TicketDistributionRequest extends WithDebug {
     readonly epochIndex: Epoch;
     readonly ticket: SignedTicket;
     static Codec: import("@typeberry/codec").Descriptor<TicketDistributionRequest, import("@typeberry/codec").ViewOf<TicketDistributionRequest, {
         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[0|1|2]">, import("@typeberry/numbers").U8>;
+            attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U32>;
             signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<784> & import("@typeberry/utils").WithOpaque<"BandersnatchRingSignature">, import("@typeberry/bytes").Bytes<784>>;
         }>>;
     }>>;
@@ -28,15 +33,17 @@ export declare class TicketDistributionRequest extends WithDebug {
     private constructor();
 }
 export declare class ServerHandler<T extends STREAM_KIND> implements StreamHandler<T> {
+    private readonly chainSpec;
     readonly kind: T;
     private readonly onTicketReceived;
-    constructor(kind: T, onTicketReceived: (epochIndex: Epoch, ticket: SignedTicket) => void);
+    constructor(chainSpec: ChainSpec, kind: T, onTicketReceived: (epochIndex: Epoch, ticket: SignedTicket) => void);
     onStreamMessage(sender: StreamMessageSender, message: BytesBlob): void;
     onClose(_streamId: StreamId): void;
 }
 export declare class ClientHandler<T extends STREAM_KIND> implements StreamHandler<T> {
+    private readonly chainSpec;
     readonly kind: T;
-    constructor(kind: T);
+    constructor(chainSpec: ChainSpec, kind: T);
     onStreamMessage(sender: StreamMessageSender): void;
     onClose(_streamId: StreamId): void;
     sendTicket(sender: StreamMessageSender, epochIndex: Epoch, ticket: SignedTicket): void;

package/packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ce-131-ce-132-safrole-ticket-distribution.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,KAAK,WAAW,EAA2B,MAAM,kBAAkB,CAAC;AAE7E,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAmB,MAAM,aAAa,CAAC;AAE3G;;;;;;GAMG;AAEH,eAAO,MAAM,8BAA8B,+DAAuB,CAAC;AACnE,eAAO,MAAM,wBAAwB,+DAAuB,CAAC;AAE7D,KAAK,WAAW,GAAG,OAAO,8BAA8B,GAAG,OAAO,wBAAwB,CAAC;AAE3F,qBAAa,yBAA0B,SAAQ,SAAS;aAWpC,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,yBAAyB,CAAC;IAI5E,OAAO;CAMR;AAID,qBAAa,aAAa,CAAC,CAAC,SAAS,WAAW,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;aAEzD,IAAI,EAAE,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBADjB,IAAI,EAAE,CAAC,EACN,gBAAgB,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI;IAGtF,eAAe,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI;IAOtE,OAAO,CAAC,SAAS,EAAE,QAAQ;CAC5B;AAED,qBAAa,aAAa,CAAC,CAAC,SAAS,WAAW,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;aAC/C,IAAI,EAAE,CAAC;gBAAP,IAAI,EAAE,CAAC;IAEnC,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI;IAKlD,OAAO,CAAC,SAAS,EAAE,QAAQ;IAE3B,UAAU,CAAC,MAAM,EAAE,mBAAmB,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY;CAKhF"}
+{"version":3,"file":"ce-131-ce-132-safrole-ticket-distribution.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,KAAK,WAAW,EAA2B,MAAM,kBAAkB,CAAC;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAmB,MAAM,aAAa,CAAC;AAE3G;;;;;;GAMG;AAEH,eAAO,MAAM,8BAA8B,+DAAuB,CAAC;AACnE,eAAO,MAAM,wBAAwB,+DAAuB,CAAC;AAE7D,KAAK,WAAW,GAAG,OAAO,8BAA8B,GAAG,OAAO,wBAAwB,CAAC;AAE3F;;;GAGG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;aAWpC,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,yBAAyB,CAAC;IAI5E,OAAO;CAMR;AAID,qBAAa,aAAa,CAAC,CAAC,SAAS,WAAW,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IAEzE,OAAO,CAAC,QAAQ,CAAC,SAAS;aACV,IAAI,EAAE,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBAFhB,SAAS,EAAE,SAAS,EACrB,IAAI,EAAE,CAAC,EACN,gBAAgB,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI;IAGtF,eAAe,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI;IAOtE,OAAO,CAAC,SAAS,EAAE,QAAQ;CAC5B;AAED,qBAAa,aAAa,CAAC,CAAC,SAAS,WAAW,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IAEzE,OAAO,CAAC,QAAQ,CAAC,SAAS;aACV,IAAI,EAAE,CAAC;gBADN,SAAS,EAAE,SAAS,EACrB,IAAI,EAAE,CAAC;IAGzB,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI;IAKlD,OAAO,CAAC,SAAS,EAAE,QAAQ;IAE3B,UAAU,CAAC,MAAM,EAAE,mBAAmB,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY;CAKhF"}

package/packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.js

@@ -12,6 +12,10 @@ import { tryAsStreamKind } from "./stream.js";
  */
 export const STREAM_KIND_GENERATOR_TO_PROXY = tryAsStreamKind(131);
 export const STREAM_KIND_PROXY_TO_ALL = tryAsStreamKind(132);
+/**
+ * Network protocol message for distributing a single ticket.
+ * Used in CE-131/CE-132 streams.
+ */
 export class TicketDistributionRequest extends WithDebug {
     epochIndex;
     ticket;
@@ -30,14 +34,16 @@ export class TicketDistributionRequest extends WithDebug {
 }
 const logger = Logger.new(import.meta.filename, "protocol/ce-131-ce-132");
 export class ServerHandler {
+    chainSpec;
     kind;
     onTicketReceived;
-    constructor(kind, onTicketReceived) {
+    constructor(chainSpec, kind, onTicketReceived) {
+        this.chainSpec = chainSpec;
         this.kind = kind;
         this.onTicketReceived = onTicketReceived;
     }
     onStreamMessage(sender, message) {
-        const ticketDistribution = Decoder.decodeObject(TicketDistributionRequest.Codec, message);
+        const ticketDistribution = Decoder.decodeObject(TicketDistributionRequest.Codec, message, this.chainSpec);
         logger.log `[${sender.streamId}][ce-${this.kind}] Received ticket for epoch ${ticketDistribution.epochIndex}`;
         this.onTicketReceived(ticketDistribution.epochIndex, ticketDistribution.ticket);
         sender.close();
@@ -45,8 +51,10 @@ export class ServerHandler {
     onClose(_streamId) { }
 }
 export class ClientHandler {
+    chainSpec;
     kind;
-    constructor(kind) {
+    constructor(chainSpec, kind) {
+        this.chainSpec = chainSpec;
         this.kind = kind;
     }
     onStreamMessage(sender) {
@@ -56,7 +64,7 @@ export class ClientHandler {
     onClose(_streamId) { }
     sendTicket(sender, epochIndex, ticket) {
         const request = TicketDistributionRequest.create({ epochIndex, ticket });
-        sender.bufferAndSend(Encoder.encodeObject(TicketDistributionRequest.Codec, request));
+        sender.bufferAndSend(Encoder.encodeObject(TicketDistributionRequest.Codec, request, this.chainSpec));
         sender.close();
     }
 }

package/packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.test.js

@@ -3,25 +3,26 @@ import { describe, it } from "node:test";
 import { tryAsEpoch } from "#@typeberry/block";
 import { SignedTicket, tryAsTicketAttempt } from "#@typeberry/block/tickets.js";
 import { Bytes } from "#@typeberry/bytes";
+import { tinyChainSpec } from "#@typeberry/config";
 import { BANDERSNATCH_PROOF_BYTES } from "#@typeberry/crypto";
 import { OK } from "#@typeberry/utils";
 import { ClientHandler, ServerHandler, STREAM_KIND_GENERATOR_TO_PROXY, } from "./ce-131-ce-132-safrole-ticket-distribution.js";
 import { testClientServer } from "./test-utils.js";
 const TEST_EPOCH = tryAsEpoch(1);
 const TEST_TICKET = SignedTicket.create({
-    attempt: tryAsTicketAttempt(0),
+    attempt: tryAsTicketAttempt(0, tinyChainSpec),
     signature: Bytes.zero(BANDERSNATCH_PROOF_BYTES).asOpaque(),
 });
 describe("CE 131 and CE 132: Safrole Ticket Distribution", () => {
     it("Client sends a ticket distribution request and the server receives it", async () => {
         const handlers = testClientServer();
         await new Promise((resolve) => {
-            handlers.server.registerHandlers(new ServerHandler(STREAM_KIND_GENERATOR_TO_PROXY, (epochIndex, ticket) => {
+            handlers.server.registerHandlers(new ServerHandler(tinyChainSpec, STREAM_KIND_GENERATOR_TO_PROXY, (epochIndex, ticket) => {
                 assert.strictEqual(epochIndex, TEST_EPOCH);
                 assert.deepStrictEqual(ticket, TEST_TICKET);
                 resolve(undefined);
             }));
-            handlers.client.registerHandlers(new ClientHandler(STREAM_KIND_GENERATOR_TO_PROXY));
+            handlers.client.registerHandlers(new ClientHandler(tinyChainSpec, STREAM_KIND_GENERATOR_TO_PROXY));
             handlers.client.withNewStream(STREAM_KIND_GENERATOR_TO_PROXY, (handler, sender) => {
                 handler.sendTicket(sender, TEST_EPOCH, TEST_TICKET);
                 return OK;

package/packages/jam/jamnp-s/protocol/up-0-block-announcement.d.ts

@@ -69,7 +69,7 @@ export declare class Announcement extends WithDebug {
             ticketsMarker: import("@typeberry/codec").Descriptor<import("@typeberry/block").TicketsMarker | null, import("@typeberry/codec").ViewOf<import("@typeberry/block").TicketsMarker, {
                 tickets: import("@typeberry/codec").Descriptor<readonly import("@typeberry/block").Ticket[] & import("@typeberry/utils").WithOpaque<"EpochLength">, import("@typeberry/codec").SequenceView<import("@typeberry/block").Ticket, import("@typeberry/codec").ViewOf<import("@typeberry/block").Ticket, {
                     id: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
-                    attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U8>;
+                    attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U32>;
                 }>>>;
             }> | null>;
             bandersnatchBlockAuthorIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"ValidatorIndex[u16]">, import("@typeberry/bytes").Bytes<2>>;

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

@@ -0,0 +1,34 @@
+import type { Epoch } from "#@typeberry/block";
+import type { SignedTicket } from "#@typeberry/block/tickets.js";
+import type { ChainSpec } from "#@typeberry/config";
+import type { Connections } from "../peers.js";
+import type { StreamManager } from "../stream-manager.js";
+/**
+ * Manages distribution of Safrole tickets to connected peers.
+ *
+ * Uses CE-132 (proxy-to-all) for direct broadcast to all peers.
+ * Implements a maintain pattern similar to SyncTask: tickets are collected
+ * and periodically distributed to peers that haven't received them yet.
+ */
+export declare class TicketDistributionTask {
+    private readonly streamManager;
+    private readonly connections;
+    static start(streamManager: StreamManager, connections: Connections, chainSpec: ChainSpec): TicketDistributionTask;
+    /** Pending tickets waiting to be distributed to peers */
+    private pendingTickets;
+    /** Current epoch being tracked (cleared when epoch changes) */
+    private currentEpoch;
+    private constructor();
+    /**
+     * Should be called periodically to distribute pending tickets to connected peers.
+     */
+    maintainDistribution(): void;
+    /**
+     * Add a ticket to the pending queue for distribution.
+     * Clears pending tickets when epoch changes.
+     * Deduplicates tickets based on signature.
+     */
+    addTicket(epochIndex: Epoch, ticket: SignedTicket): void;
+    private onTicketReceived;
+}
+//# sourceMappingURL=ticket-distribution.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,115 @@
+import { Logger } from "#@typeberry/logger";
+import { OK } from "#@typeberry/utils";
+import { ce131 } from "../protocol/index.js";
+const logger = Logger.new(import.meta.filename, "net:tickets");
+/** Aux data to track which tickets have been sent to each peer (using indices) */
+const TICKET_AUX = {
+    id: Symbol("tickets"),
+};
+/**
+ * Manages distribution of Safrole tickets to connected peers.
+ *
+ * Uses CE-132 (proxy-to-all) for direct broadcast to all peers.
+ * Implements a maintain pattern similar to SyncTask: tickets are collected
+ * and periodically distributed to peers that haven't received them yet.
+ */
+export class TicketDistributionTask {
+    streamManager;
+    connections;
+    static start(streamManager, connections, chainSpec) {
+        const task = new TicketDistributionTask(streamManager, connections);
+        // server mode: receive tickets from peers
+        streamManager.registerIncomingHandlers(new ce131.ServerHandler(chainSpec, ce131.STREAM_KIND_PROXY_TO_ALL, (epochIndex, ticket) => {
+            task.onTicketReceived(epochIndex, ticket);
+        }));
+        // client mode: send tickets to peers
+        streamManager.registerOutgoingHandlers(new ce131.ClientHandler(chainSpec, ce131.STREAM_KIND_PROXY_TO_ALL));
+        return task;
+    }
+    /** Pending tickets waiting to be distributed to peers */
+    pendingTickets = [];
+    /** Current epoch being tracked (cleared when epoch changes) */
+    currentEpoch = null;
+    constructor(streamManager, connections) {
+        this.streamManager = streamManager;
+        this.connections = connections;
+    }
+    /**
+     * Should be called periodically to distribute pending tickets to connected peers.
+     */
+    maintainDistribution() {
+        if (this.currentEpoch === null) {
+            return; // No tickets to distribute yet
+        }
+        /** `this` is mutable and TS can't narrow this.currentEpoch inside the callback closure */
+        const currentEpoch = this.currentEpoch;
+        // Iterate through all pending tickets
+        for (let ticketIdx = 0; ticketIdx < this.pendingTickets.length; ticketIdx++) {
+            const { epochIndex, ticket } = this.pendingTickets[ticketIdx];
+            // Try to send to each connected peer
+            for (const peerInfo of this.connections.getConnectedPeers()) {
+                this.connections.withAuxData(peerInfo.peerId, TICKET_AUX, (maybeAux) => {
+                    const shouldReset = maybeAux === undefined || maybeAux.epoch !== currentEpoch;
+                    const aux = shouldReset ? { epoch: currentEpoch, seen: new Set() } : maybeAux;
+                    if (peerInfo.peerRef === null) {
+                        return aux;
+                    }
+                    // Check if we already sent this ticket to this peer
+                    if (aux.seen.has(ticketIdx)) {
+                        return aux; // Already sent
+                    }
+                    // Send the ticket - only mark as sent after successful send
+                    try {
+                        this.streamManager.withNewStream(peerInfo.peerRef, ce131.STREAM_KIND_PROXY_TO_ALL, (handler, sender) => {
+                            logger.trace `[${peerInfo.peerId}] <-- Sending ticket for epoch ${epochIndex}`;
+                            handler.sendTicket(sender, epochIndex, ticket);
+                            return OK;
+                        });
+                        // Mark as sent only after successful send, so failed sends will be retried
+                        aux.seen.add(ticketIdx);
+                    }
+                    catch (e) {
+                        logger.warn `[${peerInfo.peerId}] Failed to send ticket for epoch ${epochIndex}: ${e}`;
+                    }
+                    return aux;
+                });
+            }
+        }
+    }
+    /**
+     * Add a ticket to the pending queue for distribution.
+     * Clears pending tickets when epoch changes.
+     * Deduplicates tickets based on signature.
+     */
+    addTicket(epochIndex, ticket) {
+        // Check if epoch changed - if so, clear old tickets
+        if (this.currentEpoch !== null && this.currentEpoch !== epochIndex) {
+            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.
+            // The aux data contains the epoch, so maintainDistribution will lazily
+            // reset it when it detects an epoch mismatch. This handles both connected
+            // and disconnected peers correctly.
+        }
+        this.currentEpoch = epochIndex;
+        /**
+         * Deduplicate: check if a ticket with the same signature already exists
+         *
+         * Here we are risking "poisoning" the local pendingTickets - i.e:
+         *  1. The adversary sees a signature and swaps the ticket attempt to something different.
+         *  2. This creates an invalid ticket, but prevents a valid ticket with the same signature from being included and distributed.
+         *
+         * TODO [MaSi]: The poisoning risk should be fixed during implementation of ticket validation.
+         */
+        const isDuplicate = this.pendingTickets.some((pending) => pending.epochIndex === epochIndex && pending.ticket.signature.isEqualTo(ticket.signature));
+        if (!isDuplicate) {
+            this.pendingTickets.push({ epochIndex, ticket });
+            logger.info `[addTicket] Added ticket for epoch ${epochIndex}, total: ${this.pendingTickets.length}`;
+        }
+    }
+    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);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ticket-distribution.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/tasks/ticket-distribution.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,220 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { setTimeout } from "node:timers/promises";
+import { tryAsEpoch } from "#@typeberry/block";
+import { SignedTicket, tryAsTicketAttempt } from "#@typeberry/block/tickets.js";
+import { Bytes } from "#@typeberry/bytes";
+import { tinyChainSpec } from "#@typeberry/config";
+import { BANDERSNATCH_PROOF_BYTES } from "#@typeberry/crypto";
+import { Logger } from "#@typeberry/logger";
+import { createTestPeerPair, MockNetwork } from "#@typeberry/networking/testing.js";
+import { OK } from "#@typeberry/utils";
+import { Connections } from "../peers.js";
+import { StreamManager } from "../stream-manager.js";
+import { TicketDistributionTask } from "./ticket-distribution.js";
+const logger = Logger.new(import.meta.filename, "test:tickets");
+const TEST_EPOCH = tryAsEpoch(42);
+const OTHER_EPOCH = tryAsEpoch(43);
+function createTestTicket(attempt, signatureByte = 0) {
+    const signatureBytes = Bytes.zero(BANDERSNATCH_PROOF_BYTES);
+    // Make signature unique based on attempt and signatureByte
+    signatureBytes.raw[0] = attempt;
+    signatureBytes.raw[1] = signatureByte;
+    return SignedTicket.create({
+        attempt: tryAsTicketAttempt(attempt, tinyChainSpec),
+        signature: signatureBytes.asOpaque(),
+    });
+}
+describe("TicketDistributionTask", () => {
+    async function init(name) {
+        const network = new MockNetwork(name);
+        const streamManager = new StreamManager();
+        const connections = new Connections(network);
+        // Track received tickets for verification
+        const receivedTickets = [];
+        // Use real TicketDistributionTask
+        const ticketTask = TicketDistributionTask.start(streamManager, connections, tinyChainSpec);
+        // Intercept received tickets by wrapping onTicketReceived behavior
+        // The task already adds received tickets to pending queue via addTicket,
+        // so we can track them by checking the pending queue growth or by
+        // hooking into the CE-131 server handler directly
+        const originalAddTicket = ticketTask.addTicket.bind(ticketTask);
+        ticketTask.addTicket = (epochIndex, ticket) => {
+            receivedTickets.push({ epochIndex, ticket });
+            originalAddTicket(epochIndex, ticket);
+        };
+        // Setup peer listeners for incoming streams
+        network.peers.onPeerConnected((peer) => {
+            peer.addOnIncomingStream((stream) => {
+                streamManager.onIncomingStream(peer, stream);
+                return OK;
+            });
+            return OK;
+        });
+        let connectionIdx = 0;
+        const openConnection = (other) => {
+            const [self, peer] = createTestPeerPair(connectionIdx++, name, other.name);
+            network._peers.peerConnected(peer);
+            other.network._peers.peerConnected(self);
+            return [self, peer];
+        };
+        return {
+            name,
+            ticketTask,
+            network,
+            connections,
+            streamManager,
+            openConnection,
+            receivedTickets,
+        };
+    }
+    async function tick() {
+        logger.log `tick`;
+        await setTimeout(10);
+    }
+    it("should distribute ticket to all connected peers via maintainDistribution", async () => {
+        const self = await init("self");
+        const peer1 = await init("peer1");
+        const peer2 = await init("peer2");
+        self.openConnection(peer1);
+        self.openConnection(peer2);
+        await tick();
+        const ticket = createTestTicket(0);
+        self.ticketTask.addTicket(TEST_EPOCH, ticket);
+        self.ticketTask.maintainDistribution();
+        await tick();
+        // Both peers should have received the ticket
+        assert.strictEqual(peer1.receivedTickets.length, 1);
+        assert.strictEqual(peer1.receivedTickets[0].epochIndex, TEST_EPOCH);
+        assert.deepStrictEqual(peer1.receivedTickets[0].ticket, ticket);
+        assert.strictEqual(peer2.receivedTickets.length, 1);
+        assert.strictEqual(peer2.receivedTickets[0].epochIndex, TEST_EPOCH);
+        assert.deepStrictEqual(peer2.receivedTickets[0].ticket, ticket);
+    });
+    it("should receive tickets from peers", async () => {
+        const self = await init("self");
+        const peer1 = await init("peer1");
+        self.openConnection(peer1);
+        await tick();
+        const ticket = createTestTicket(1);
+        peer1.ticketTask.addTicket(TEST_EPOCH, ticket);
+        peer1.ticketTask.maintainDistribution();
+        await tick();
+        assert.strictEqual(self.receivedTickets.length, 1);
+        assert.strictEqual(self.receivedTickets[0].epochIndex, TEST_EPOCH);
+        assert.deepStrictEqual(self.receivedTickets[0].ticket, ticket);
+    });
+    it("should handle multiple tickets", async () => {
+        const self = await init("self");
+        const peer1 = await init("peer1");
+        self.openConnection(peer1);
+        await tick();
+        const ticket0 = createTestTicket(0);
+        const ticket1 = createTestTicket(1);
+        self.ticketTask.addTicket(TEST_EPOCH, ticket0);
+        self.ticketTask.addTicket(TEST_EPOCH, ticket1);
+        self.ticketTask.maintainDistribution();
+        await tick();
+        assert.strictEqual(peer1.receivedTickets.length, 2);
+        assert.deepStrictEqual(peer1.receivedTickets[0].ticket, ticket0);
+        assert.deepStrictEqual(peer1.receivedTickets[1].ticket, ticket1);
+    });
+    it("should handle no connected peers gracefully", async () => {
+        const self = await init("self");
+        const ticket = createTestTicket(0);
+        // Should not throw
+        self.ticketTask.addTicket(TEST_EPOCH, ticket);
+        self.ticketTask.maintainDistribution();
+        await tick();
+    });
+    it("should deduplicate tickets with same signature", async () => {
+        const self = await init("self");
+        const peer1 = await init("peer1");
+        self.openConnection(peer1);
+        await tick();
+        const ticket = createTestTicket(0);
+        // Add same ticket twice
+        self.ticketTask.addTicket(TEST_EPOCH, ticket);
+        self.ticketTask.addTicket(TEST_EPOCH, ticket);
+        self.ticketTask.maintainDistribution();
+        await tick();
+        // Peer should only receive it once
+        assert.strictEqual(peer1.receivedTickets.length, 1);
+    });
+    it("should not send same ticket to same peer twice", async () => {
+        const self = await init("self");
+        const peer1 = await init("peer1");
+        self.openConnection(peer1);
+        await tick();
+        const ticket = createTestTicket(0);
+        self.ticketTask.addTicket(TEST_EPOCH, ticket);
+        // Call maintainDistribution twice
+        self.ticketTask.maintainDistribution();
+        await tick();
+        self.ticketTask.maintainDistribution();
+        await tick();
+        // Peer should only receive the ticket once (aux data tracks sent indices)
+        assert.strictEqual(peer1.receivedTickets.length, 1);
+    });
+    it("should clear tickets when epoch changes", async () => {
+        const self = await init("self");
+        const peer1 = await init("peer1");
+        self.openConnection(peer1);
+        await tick();
+        const ticket1 = createTestTicket(0);
+        const ticket2 = createTestTicket(1);
+        // Add ticket for first epoch
+        self.ticketTask.addTicket(TEST_EPOCH, ticket1);
+        // Change epoch - this should clear old tickets
+        self.ticketTask.addTicket(OTHER_EPOCH, ticket2);
+        self.ticketTask.maintainDistribution();
+        await tick();
+        // Peer should only receive the second ticket (first was cleared on epoch change)
+        assert.strictEqual(peer1.receivedTickets.length, 1);
+        assert.strictEqual(peer1.receivedTickets[0].epochIndex, OTHER_EPOCH);
+        assert.deepStrictEqual(peer1.receivedTickets[0].ticket, ticket2);
+    });
+    it("should send new tickets to newly connected peers", async () => {
+        const self = await init("self");
+        const peer1 = await init("peer1");
+        const peer2 = await init("peer2");
+        // Connect peer1 first
+        self.openConnection(peer1);
+        await tick();
+        const ticket = createTestTicket(0);
+        self.ticketTask.addTicket(TEST_EPOCH, ticket);
+        self.ticketTask.maintainDistribution();
+        await tick();
+        // Now connect peer2 after ticket was already distributed to peer1
+        self.openConnection(peer2);
+        await tick();
+        // Run maintainDistribution again - peer2 should get the ticket
+        self.ticketTask.maintainDistribution();
+        await tick();
+        assert.strictEqual(peer1.receivedTickets.length, 1);
+        assert.strictEqual(peer2.receivedTickets.length, 1);
+        assert.deepStrictEqual(peer2.receivedTickets[0].ticket, ticket);
+    });
+    it("should re-distribute received tickets to other peers", async () => {
+        const self = await init("self");
+        const peer1 = await init("peer1");
+        const peer2 = await init("peer2");
+        // Self connects to both peers
+        self.openConnection(peer1);
+        self.openConnection(peer2);
+        await tick();
+        // peer1 sends a ticket to self
+        const ticket = createTestTicket(0);
+        peer1.ticketTask.addTicket(TEST_EPOCH, ticket);
+        peer1.ticketTask.maintainDistribution();
+        await tick();
+        // Self receives the ticket (via onTicketReceived -> addTicket)
+        assert.strictEqual(self.receivedTickets.length, 1);
+        // Self should re-distribute to peer2 (and peer1, but peer1 already has it)
+        self.ticketTask.maintainDistribution();
+        await tick();
+        // peer2 should now have received the ticket from self
+        assert.strictEqual(peer2.receivedTickets.length, 1);
+        assert.deepStrictEqual(peer2.receivedTickets[0].ticket, ticket);
+    });
+});

package/packages/jam/node/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/main.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAc,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACzF,OAAO,EAAE,KAAK,SAAS,EAAc,MAAM,mBAAmB,CAAC;AAe/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAkC,MAAM,EAAW,MAAM,kBAAkB,CAAC;AAKnF,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,iBAAiB,CAAC;AAWhE,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAChE,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAC;IACtE,oBAAoB,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IAC/C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,wBAAsB,IAAI,CACxB,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAClC,SAAS,EAAE,SAAS,GAAG,IAAI,GAC1B,OAAO,CAAC,OAAO,CAAC,CAuJlB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/main.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAc,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEzF,OAAO,EAAE,KAAK,SAAS,EAAc,MAAM,mBAAmB,CAAC;AAe/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAkC,MAAM,EAAW,MAAM,kBAAkB,CAAC;AAKnF,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,iBAAiB,CAAC;AAWhE,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAChE,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAC;IACtE,oBAAoB,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IAC/C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,wBAAsB,IAAI,CACxB,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAClC,SAAS,EAAE,SAAS,GAAG,IAAI,GAC1B,OAAO,CAAC,OAAO,CAAC,CAuKlB"}