@typeberry/lib 0.5.7 → 0.5.8

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"}

package/packages/jam/node/main.js

@@ -1,4 +1,5 @@
 import { isMainThread } from "node:worker_threads";
+import { AUTHORSHIP_NETWORK_PORT } from "#@typeberry/comms-authorship-network";
 import { PvmBackend } from "#@typeberry/config";
 import { initWasm } from "#@typeberry/crypto";
 import { deriveBandersnatchSecretKey, deriveEd25519SecretKey, trivialSeed, } from "#@typeberry/crypto/key-derivation.js";
@@ -8,8 +9,8 @@ import { NetworkingConfig } from "#@typeberry/jam-network";
 import { Listener } from "#@typeberry/listener";
 import { tryAsU16, tryAsU32 } from "#@typeberry/numbers";
 import { CURRENT_SUITE, CURRENT_VERSION, Result, version } from "#@typeberry/utils";
-import { DirectWorkerConfig } from "#@typeberry/workers-api";
-import { InMemWorkerConfig, LmdbWorkerConfig } from "#@typeberry/workers-api-node";
+import { DirectPort, DirectWorkerConfig } from "#@typeberry/workers-api";
+import { InMemWorkerConfig, LmdbWorkerConfig, ThreadPort } from "#@typeberry/workers-api-node";
 import { getChainSpec, getDatabasePath, initializeDatabase, logger } from "./common.js";
 import { initializeExtensions } from "./extensions.js";
 import * as metrics from "./metrics.js";
@@ -36,8 +37,8 @@ export async function main(config, withRelPath, telemetry) {
         }),
     };
     const importerConfig = isInMemory
-        ? { type: "inmem", config: InMemWorkerConfig.new(importerParams) }
-        : { type: "lmdb", config: LmdbWorkerConfig.new(importerParams) };
+        ? { isInMemory, config: InMemWorkerConfig.new(importerParams) }
+        : { isInMemory, config: LmdbWorkerConfig.new(importerParams) };
     // Initialize the database with genesis state and block if there isn't one.
     logger.info `🛢️ Opening database at ${dbPath}`;
     const rootDb = importerConfig.config.openDatabase({ readonly: false });
@@ -50,7 +51,7 @@ export async function main(config, withRelPath, telemetry) {
     // Start block importer
     let importer;
     let closeImporter;
-    if (importerConfig.type === "inmem") {
+    if (importerConfig.isInMemory) {
         ({ importer, finish: closeImporter } = await startImporterDirect(DirectWorkerConfig.new({
             ...importerConfig.config,
             blocksDb: rootDb.getBlocksDb(),
@@ -91,9 +92,24 @@ export async function main(config, withRelPath, telemetry) {
                 },
             ],
     };
-    const closeAuthorship = await initAuthorship(importer, config.isAuthoring, config.isFastForward, rootDb, baseConfig, authorshipKeys, isInMemory);
-    // Networking initialization
-    const closeNetwork = await initNetwork(importer, rootDb, baseConfig, genesisHeaderHash, config.network, bestHeader, isInMemory);
+    const { networkingParams, authorshipParams } = isInMemory
+        ? (() => {
+            const [tx, rx] = DirectPort.pair();
+            return {
+                networkingParams: { isInMemory, rootDb, authorshipPort: tx },
+                authorshipParams: { isInMemory, rootDb, networkingPort: rx },
+            };
+        })()
+        : (() => {
+            const [tx, rx] = ThreadPort.pair(chainSpec);
+            return {
+                networkingParams: { isInMemory, rootDb, authorshipPort: tx },
+                authorshipParams: { isInMemory, rootDb, networkingPort: rx },
+            };
+        })();
+    // Networking initialization (before authorship so we can relay tickets)
+    const { closeNetwork } = await initNetwork(importer, networkingParams, baseConfig, genesisHeaderHash, config.network, bestHeader);
+    const { closeAuthorship } = await initAuthorship(importer, config.isAuthoring, config.isFastForward, authorshipParams, baseConfig, authorshipKeys);
     const api = {
         chainSpec,
         async importBlock(block) {
@@ -110,14 +126,14 @@ export async function main(config, withRelPath, telemetry) {
             return importer.sendGetBestStateRootHash();
         },
         async close() {
-            logger.log `[main] ☠️ Closing the importer`;
-            await closeImporter();
-            logger.log `[main] ☠️  Closing the extensions`;
-            closeExtensions();
             logger.log `[main] ☠️  Closing the authorship module`;
             await closeAuthorship();
             logger.log `[main] ☠️  Closing the networking module`;
             await closeNetwork();
+            logger.log `[main] ☠️ Closing the importer`;
+            await closeImporter();
+            logger.log `[main] ☠️  Closing the extensions`;
+            closeExtensions();
             logger.log `[main] 🛢️ Closing the database`;
             await rootDb.close();
             logger.log `[main] 📳 Closing telemetry`;
@@ -127,35 +143,48 @@ export async function main(config, withRelPath, telemetry) {
     };
     return api;
 }
-const initAuthorship = async (importer, isAuthoring, isFastForward, rootDb, baseConfig, authorshipKeys, isInMemory) => {
+const initAuthorship = async (importer, isAuthoring, isFastForward, params, baseConfig, authorshipKeys) => {
     if (!isAuthoring) {
         logger.log `✍️  Authorship off: disabled`;
-        return () => Promise.resolve();
+        return {
+            closeAuthorship: () => {
+                params.networkingPort.close();
+                return Promise.resolve();
+            },
+            authorshipWorker: null,
+        };
     }
     logger.info `✍️  Starting block generator.`;
     const workerParams = { ...authorshipKeys, isFastForward };
-    const { generator, finish } = isInMemory
+    const { generator, worker, finish } = params.isInMemory
         ? await startBlockGenerator(DirectWorkerConfig.new({
             ...baseConfig,
-            blocksDb: rootDb.getBlocksDb(),
-            statesDb: rootDb.getStatesDb(),
+            blocksDb: params.rootDb.getBlocksDb(),
+            statesDb: params.rootDb.getStatesDb(),
             workerParams,
-        }))
+        }), params.networkingPort)
         : await spawnBlockGeneratorWorker(LmdbWorkerConfig.new({
             ...baseConfig,
             workerParams,
+            ports: new Map([[AUTHORSHIP_NETWORK_PORT, params.networkingPort]]),
         }));
     // relay blocks from generator to importer
     generator.setOnBlock(async (block) => {
         logger.log `✍️  Produced block at ${block.header.view().timeSlotIndex.materialize()}`;
         await importer.sendImportBlock(block);
     });
-    return finish;
+    return { closeAuthorship: finish, authorshipWorker: worker };
 };
-const initNetwork = async (importer, rootDb, baseConfig, genesisHeaderHash, networkConfig, bestHeader, isInMemory) => {
+const initNetwork = async (importer, params, baseConfig, genesisHeaderHash, networkConfig, bestHeader) => {
     if (networkConfig === null) {
         logger.log `🛜 Networking off: no config`;
-        return () => Promise.resolve();
+        return {
+            closeNetwork: async () => {
+                params.authorshipPort.close();
+            },
+            networkApi: null,
+            networkWorker: null,
+        };
     }
     const { key, host, port, bootnodes } = networkConfig;
     const networkingConfig = NetworkingConfig.create({
@@ -165,16 +194,17 @@ const initNetwork = async (importer, rootDb, baseConfig, genesisHeaderHash, netw
         port: tryAsU16(port),
         bootnodes: bootnodes.map((node) => node.toString()),
     });
-    const { network, finish } = isInMemory
+    const { network, worker, finish } = params.isInMemory
         ? await startNetwork(DirectWorkerConfig.new({
             ...baseConfig,
-            blocksDb: rootDb.getBlocksDb(),
-            statesDb: rootDb.getStatesDb(),
+            blocksDb: params.rootDb.getBlocksDb(),
+            statesDb: params.rootDb.getStatesDb(),
             workerParams: networkingConfig,
-        }))
+        }), params.authorshipPort)
         : await spawnNetworkWorker(LmdbWorkerConfig.new({
             ...baseConfig,
             workerParams: networkingConfig,
+            ports: new Map([[AUTHORSHIP_NETWORK_PORT, params.authorshipPort]]),
         }));
     // relay blocks from networking to importer
     network.setOnBlocks(async (newBlocks) => {
@@ -186,5 +216,5 @@ const initNetwork = async (importer, rootDb, baseConfig, genesisHeaderHash, netw
     bestHeader.on((header) => {
         network.sendNewHeader(header);
     });
-    return finish;
+    return { closeNetwork: finish, networkApi: network, networkWorker: worker };
 };