@typeberry/lib 0.5.7-a809a5e → 0.5.7-d496f70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typeberry/lib",
-  "version": "0.5.7-a809a5e",
+  "version": "0.5.7-d496f70",
   "description": "Typeberry Library",
   "main": "./bin/lib/index.js",
   "types": "./bin/lib/index.d.ts",
@@ -256,6 +256,8 @@
     "#@typeberry/workers-api-node/*": "./packages/workers/api-node/*",
     "#@typeberry/block-authorship": "./packages/workers/block-authorship/index.js",
     "#@typeberry/block-authorship/*": "./packages/workers/block-authorship/*",
+    "#@typeberry/comms-authorship-network": "./packages/workers/comms-authorship-network/index.js",
+    "#@typeberry/comms-authorship-network/*": "./packages/workers/comms-authorship-network/*",
     "#@typeberry/importer": "./packages/workers/importer/index.js",
     "#@typeberry/importer/*": "./packages/workers/importer/*",
     "#@typeberry/jam-network": "./packages/workers/jam-network/index.js",

package/packages/jam/jamnp-s/network.d.ts

@@ -6,12 +6,14 @@ import { type Network, type Peer } from "#@typeberry/networking";
 import { type Bootnode } from "./peers.js";
 import { StreamManager } from "./stream-manager.js";
 import { SyncTask } from "./tasks/sync.js";
+import { TicketDistributionTask } from "./tasks/ticket-distribution.js";
 export declare function setup(bind: {
     host: string;
     port: number;
 }, genesisHash: HeaderHash, key: ed25519.Ed25519Pair, bootnodes: Bootnode[], spec: ChainSpec, blocks: BlocksDb, onNewBlocks: (blocks: BlockView[]) => Promise<void>): Promise<{
     network: import("@typeberry/networking/quic-network.js").QuicNetwork;
     syncTask: SyncTask;
+    ticketTask: TicketDistributionTask;
     streamManager: StreamManager;
 }>;
 export declare function setupPeerListeners(syncTask: SyncTask, network: Network<Peer>, streamManager: StreamManager): void;

package/packages/jam/jamnp-s/network.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/jamnp-s/network.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,uBAAuB,CAAC;AAEtE,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,YAAY,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAK3C,wBAAsB,KAAK,CACzB,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACpC,WAAW,EAAE,UAAU,EACvB,GAAG,EAAE,OAAO,CAAC,WAAW,EACxB,SAAS,EAAE,QAAQ,EAAE,EACrB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,QAAQ,EAEhB,WAAW,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC;;;;GAuCpD;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,aAAa,QAmB1G"}
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/jamnp-s/network.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,uBAAuB,CAAC;AAEtE,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,YAAY,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAKxE,wBAAsB,KAAK,CACzB,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACpC,WAAW,EAAE,UAAU,EACvB,GAAG,EAAE,OAAO,CAAC,WAAW,EACxB,SAAS,EAAE,QAAQ,EAAE,EACrB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,QAAQ,EAEhB,WAAW,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC;;;;;GA0CpD;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,aAAa,QAmB1G"}

package/packages/jam/jamnp-s/network.js

@@ -6,6 +6,7 @@ import { OK } from "#@typeberry/utils";
 import { Connections } from "./peers.js";
 import { StreamManager } from "./stream-manager.js";
 import { SyncTask } from "./tasks/sync.js";
+import { TicketDistributionTask } from "./tasks/ticket-distribution.js";
 import { handleAsyncErrors } from "./utils.js";
 const logger = Logger.new(import.meta.filename, "jamnps");
 export async function setup(bind, genesisHash, key, bootnodes, spec, blocks, 
@@ -24,10 +25,12 @@ onNewBlocks) {
     const streamManager = new StreamManager();
     // start the networking tasks
     const syncTask = SyncTask.start(spec, blake2b, streamManager, connections, blocks, onNewBlocks);
+    const ticketTask = TicketDistributionTask.start(streamManager, connections);
     setImmediate(async () => {
         while (network.isRunning) {
             await setTimeout(3000);
             syncTask.maintainSync();
+            ticketTask.maintainDistribution();
         }
     });
     // TODO [ToDr] This design is a bit weird,
@@ -40,6 +43,7 @@ onNewBlocks) {
     return {
         network,
         syncTask,
+        ticketTask,
         streamManager,
     };
 }

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

@@ -14,6 +14,10 @@ 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;

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

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;

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

@@ -0,0 +1,33 @@
+import type { Epoch } from "#@typeberry/block";
+import type { SignedTicket } from "#@typeberry/block/tickets.js";
+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): 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;AAGhE,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;IAgBnE,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) {
+        const task = new TicketDistributionTask(streamManager, connections);
+        // server mode: receive tickets from peers
+        streamManager.registerIncomingHandlers(new ce131.ServerHandler(ce131.STREAM_KIND_PROXY_TO_ALL, (epochIndex, ticket) => {
+            task.onTicketReceived(epochIndex, ticket);
+        }));
+        // client mode: send tickets to peers
+        streamManager.registerOutgoingHandlers(new ce131.ClientHandler(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,219 @@
+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 { 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),
+        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);
+        // 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 };
 };

package/packages/jam/node/workers.d.ts

@@ -1,9 +1,10 @@
+import type { Worker } from "node:worker_threads";
 import * as blockAuthorship from "#@typeberry/block-authorship";
 import type { BlocksDb, LeafDb, StatesDb } from "#@typeberry/database";
 import * as importer from "#@typeberry/importer";
 import * as jamNetwork from "#@typeberry/jam-network";
 import type { SerializedState } from "#@typeberry/state-merkleization";
-import { type DirectWorkerConfig } from "#@typeberry/workers-api";
+import { type DirectPort, type DirectWorkerConfig } from "#@typeberry/workers-api";
 import { type LmdbWorkerConfig } from "#@typeberry/workers-api-node";
 export declare function spawnImporterWorker(config: LmdbWorkerConfig<importer.ImporterConfig>): Promise<{
     importer: import("@typeberry/workers-api").Tx<{
@@ -858,9 +859,12 @@ export declare function spawnNetworkWorker(config: LmdbWorkerConfig<jamNetwork.N
             response: import("@typeberry/codec").Descriptor<void, void>;
         };
     }>;
+    worker: Worker;
     finish: () => Promise<void>;
 }>;
-export declare function startNetwork(config: DirectWorkerConfig<jamNetwork.NetworkingConfig>): ReturnType<typeof spawnNetworkWorker>;
+export declare function startNetwork(config: DirectWorkerConfig<jamNetwork.NetworkingConfig>, authorshipPort: DirectPort): Promise<Omit<Awaited<ReturnType<typeof spawnNetworkWorker>>, "worker"> & {
+    worker: Worker | null;
+}>;
 export declare function spawnBlockGeneratorWorker(config: LmdbWorkerConfig<blockAuthorship.BlockAuthorshipConfig>): Promise<{
     generator: import("@typeberry/workers-api").Tx<{
         finish: {
@@ -1121,7 +1125,10 @@ export declare function spawnBlockGeneratorWorker(config: LmdbWorkerConfig<block
             response: import("@typeberry/codec").Descriptor<void, void>;
         };
     }>;
+    worker: Worker;
     finish: () => Promise<void>;
 }>;
-export declare function startBlockGenerator(config: DirectWorkerConfig<blockAuthorship.BlockAuthorshipConfig>): ReturnType<typeof spawnBlockGeneratorWorker>;
+export declare function startBlockGenerator(config: DirectWorkerConfig<blockAuthorship.BlockAuthorshipConfig>, networkingPort: DirectPort): Promise<Omit<Awaited<ReturnType<typeof spawnBlockGeneratorWorker>>, "worker"> & {
+    worker: Worker | null;
+}>;
 //# sourceMappingURL=workers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"workers.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/workers.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"workers.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/workers.ts"],"names":[],"mappings":"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"}

package/packages/jam/node/workers.js

@@ -1,7 +1,8 @@
 import * as blockAuthorship from "#@typeberry/block-authorship";
+import { protocol } from "#@typeberry/comms-authorship-network";
 import * as importer from "#@typeberry/importer";
 import * as jamNetwork from "#@typeberry/jam-network";
-import { startSameThread } from "#@typeberry/workers-api";
+import { Channel, startSameThread } from "#@typeberry/workers-api";
 import { spawnWorker } from "#@typeberry/workers-api-node";
 export async function spawnImporterWorker(config) {
     const { api, workerFinished } = spawnWorker(importer.protocol, importer.WORKER, config, importer.ImporterConfig.Codec);
@@ -27,9 +28,10 @@ export async function startImporterDirect(config) {
     };
 }
 export async function spawnNetworkWorker(config) {
-    const { api, workerFinished } = spawnWorker(jamNetwork.protocol, jamNetwork.WORKER, config, jamNetwork.NetworkingConfig.Codec);
+    const { api, worker, workerFinished } = spawnWorker(jamNetwork.protocol, jamNetwork.WORKER, config, jamNetwork.NetworkingConfig.Codec);
     return {
         network: api,
+        worker,
         finish: async () => {
             await api.sendFinish();
             api.destroy();
@@ -37,22 +39,26 @@ export async function spawnNetworkWorker(config) {
         },
     };
 }
-export async function startNetwork(config) {
+export async function startNetwork(config, authorshipPort) {
     const { api, internal } = startSameThread(jamNetwork.protocol);
-    const networkFinish = jamNetwork.main(config, internal);
+    const authorshipComms = Channel.rx(protocol, authorshipPort);
+    const networkFinish = jamNetwork.main(config, internal, authorshipComms);
     return {
         network: api,
+        worker: null,
         finish: async () => {
             await api.sendFinish();
             api.destroy();
             await networkFinish;
+            authorshipComms.destroy();
         },
     };
 }
 export async function spawnBlockGeneratorWorker(config) {
-    const { api, workerFinished } = spawnWorker(blockAuthorship.protocol, blockAuthorship.WORKER, config, blockAuthorship.BlockAuthorshipConfig.Codec);
+    const { api, worker, workerFinished } = spawnWorker(blockAuthorship.protocol, blockAuthorship.WORKER, config, blockAuthorship.BlockAuthorshipConfig.Codec);
     return {
         generator: api,
+        worker,
         finish: async () => {
             await api.sendFinish();
             api.destroy();
@@ -60,15 +66,18 @@ export async function spawnBlockGeneratorWorker(config) {
         },
     };
 }
-export async function startBlockGenerator(config) {
+export async function startBlockGenerator(config, networkingPort) {
     const { api, internal } = startSameThread(blockAuthorship.protocol);
-    const finish = blockAuthorship.main(config, internal);
+    const networkingComms = Channel.tx(protocol, networkingPort);
+    const finish = blockAuthorship.main(config, internal, networkingComms);
     return {
         generator: api,
+        worker: null,
         finish: async () => {
             await api.sendFinish();
             api.destroy();
             await finish;
+            networkingComms.destroy();
         },
     };
 }

package/packages/workers/api-node/config.d.ts

@@ -3,6 +3,7 @@ import { ChainSpec } from "#@typeberry/config";
 import { type BlocksDb, type RootDb, type SerializedStatesDb } from "#@typeberry/database";
 import { Blake2b } from "#@typeberry/hash";
 import type { WorkerConfig } from "#@typeberry/workers-api";
+import { ThreadPort, type TransferablePort } from "./port.js";
 /** A worker config that's usable in node.js and uses LMDB database backend. */
 export declare class LmdbWorkerConfig<T = void> implements WorkerConfig<T, BlocksDb, SerializedStatesDb> {
     readonly nodeName: string;
@@ -10,12 +11,14 @@ export declare class LmdbWorkerConfig<T = void> implements WorkerConfig<T, Block
     readonly workerParams: T;
     readonly dbPath: string;
     readonly blake2b: Blake2b;
-    static new<T>({ nodeName, chainSpec, workerParams, dbPath, blake2b, }: {
+    readonly ports: Map<string, ThreadPort>;
+    static new<T>({ nodeName, chainSpec, workerParams, dbPath, blake2b, ports, }: {
         nodeName: string;
         chainSpec: ChainSpec;
         workerParams: T;
         dbPath: string;
         blake2b: Blake2b;
+        ports?: Map<string, ThreadPort>;
     }): LmdbWorkerConfig<T>;
     /** Restore node config from a transferable config object. */
     static fromTransferable<T>(decodeParams: Decode<T>, config: TransferableConfig): Promise<LmdbWorkerConfig<T>>;
@@ -32,6 +35,7 @@ export type TransferableConfig = {
     chainSpec: ChainSpec;
     workerParams: Uint8Array;
     dbPath: string;
+    workerPorts: [string, TransferablePort][];
 };
 /**
  * In-memory (direct) worker using serialized state database.

package/packages/workers/api-node/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/api-node/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAW,KAAK,MAAM,EAAW,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EACL,KAAK,QAAQ,EAGb,KAAK,MAAM,EACX,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,+EAA+E;AAC/E,qBAAa,gBAAgB,CAAC,CAAC,GAAG,IAAI,CAAE,YAAW,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,kBAAkB,CAAC;aAiC5E,QAAQ,EAAE,MAAM;aAChB,SAAS,EAAE,SAAS;aACpB,YAAY,EAAE,CAAC;aACf,MAAM,EAAE,MAAM;aACd,OAAO,EAAE,OAAO;IApClC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EACZ,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,MAAM,EACN,OAAO,GACR,EAAE;QACD,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,SAAS,CAAC;QACrB,YAAY,EAAE,CAAC,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,OAAO,CAAC;KAClB;IAID,6DAA6D;WAChD,gBAAgB,CAAC,CAAC,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,kBAAkB;IAcpF,OAAO;IAQP,YAAY,CAAC,OAAO,GAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAuB,GAAG,MAAM,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IAUvG,6DAA6D;IAC7D,gBAAgB,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,kBAAkB;CAQ7D;AAED,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,UAAU,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,iBAAiB,CAAC,CAAC,GAAG,SAAS,CAAE,YAAW,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,kBAAkB,CAAC;aAmBlF,QAAQ,EAAE,MAAM;aAChB,SAAS,EAAE,SAAS;aACpB,YAAY,EAAE,CAAC;aACf,OAAO,EAAE,OAAO;IArBlC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EACZ,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,OAAO,GACR,EAAE;QACD,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,SAAS,CAAC;QACrB,YAAY,EAAE,CAAC,CAAC;QAChB,OAAO,EAAE,OAAO,CAAC;KAClB;IAID,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAElD,OAAO;IAUP,YAAY,CAAC,QAAQ,GAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAuB,GAAG,MAAM,CAAC,QAAQ,EAAE,kBAAkB,CAAC;CAQzG"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/api-node/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAW,KAAK,MAAM,EAAW,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EACL,KAAK,QAAQ,EAGb,KAAK,MAAM,EACX,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE9D,+EAA+E;AAC/E,qBAAa,gBAAgB,CAAC,CAAC,GAAG,IAAI,CAAE,YAAW,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,kBAAkB,CAAC;aAuC5E,QAAQ,EAAE,MAAM;aAChB,SAAS,EAAE,SAAS;aACpB,YAAY,EAAE,CAAC;aACf,MAAM,EAAE,MAAM;aACd,OAAO,EAAE,OAAO;aAChB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC;IA3ChD,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EACZ,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,MAAM,EACN,OAAO,EACP,KAAiB,GAClB,EAAE;QACD,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,SAAS,CAAC;QACrB,YAAY,EAAE,CAAC,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,OAAO,CAAC;QACjB,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;KACjC;IAID,6DAA6D;WAChD,gBAAgB,CAAC,CAAC,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,kBAAkB;IAkBpF,OAAO;IASP,YAAY,CAAC,OAAO,GAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAuB,GAAG,MAAM,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IAUvG,6DAA6D;IAC7D,gBAAgB,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,kBAAkB;CAS7D;AAED,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,UAAU,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,CAAC;CAC3C,CAAC;AAEF;;;;GAIG;AACH,qBAAa,iBAAiB,CAAC,CAAC,GAAG,SAAS,CAAE,YAAW,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,kBAAkB,CAAC;aAmBlF,QAAQ,EAAE,MAAM;aAChB,SAAS,EAAE,SAAS;aACpB,YAAY,EAAE,CAAC;aACf,OAAO,EAAE,OAAO;IArBlC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EACZ,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,OAAO,GACR,EAAE;QACD,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,SAAS,CAAC;QACrB,YAAY,EAAE,CAAC,CAAC;QAChB,OAAO,EAAE,OAAO,CAAC;KAClB;IAID,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAElD,OAAO;IAUP,YAAY,CAAC,QAAQ,GAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAuB,GAAG,MAAM,CAAC,QAAQ,EAAE,kBAAkB,CAAC;CAQzG"}

package/packages/workers/api-node/config.js

@@ -3,6 +3,7 @@ import { ChainSpec } from "#@typeberry/config";
 import { InMemoryBlocks, InMemorySerializedStates, } from "#@typeberry/database";
 import { LmdbBlocks, LmdbRoot, LmdbStates } from "#@typeberry/database-lmdb";
 import { Blake2b } from "#@typeberry/hash";
+import { ThreadPort } from "./port.js";
 /** A worker config that's usable in node.js and uses LMDB database backend. */
 export class LmdbWorkerConfig {
     nodeName;
@@ -10,28 +11,32 @@ export class LmdbWorkerConfig {
     workerParams;
     dbPath;
     blake2b;
-    static new({ nodeName, chainSpec, workerParams, dbPath, blake2b, }) {
-        return new LmdbWorkerConfig(nodeName, chainSpec, workerParams, dbPath, blake2b);
+    ports;
+    static new({ nodeName, chainSpec, workerParams, dbPath, blake2b, ports = new Map(), }) {
+        return new LmdbWorkerConfig(nodeName, chainSpec, workerParams, dbPath, blake2b, ports);
     }
     /** Restore node config from a transferable config object. */
     static async fromTransferable(decodeParams, config) {
         const blake2b = await Blake2b.createHasher();
         const chainSpec = new ChainSpec(config.chainSpec);
         const workerParams = Decoder.decodeObject(decodeParams, config.workerParams, chainSpec);
+        const ports = new Map(config.workerPorts.map(([name, port]) => [name, ThreadPort.fromTransferable(chainSpec, port)]));
         return LmdbWorkerConfig.new({
             nodeName: config.nodeName,
             chainSpec,
             workerParams,
             dbPath: config.dbPath,
             blake2b,
+            ports,
         });
     }
-    constructor(nodeName, chainSpec, workerParams, dbPath, blake2b) {
+    constructor(nodeName, chainSpec, workerParams, dbPath, blake2b, ports) {
         this.nodeName = nodeName;
         this.chainSpec = chainSpec;
         this.workerParams = workerParams;
         this.dbPath = dbPath;
         this.blake2b = blake2b;
+        this.ports = ports;
     }
     openDatabase(options = { readonly: true }) {
         const lmdb = new LmdbRoot(this.dbPath, options.readonly);
@@ -48,6 +53,7 @@ export class LmdbWorkerConfig {
             chainSpec: this.chainSpec,
             workerParams: Encoder.encodeObject(paramsCodec, this.workerParams, this.chainSpec).raw,
             dbPath: this.dbPath,
+            workerPorts: Array.from(this.ports.entries()).map(([name, port]) => [name, port.intoTransferable()]),
         };
     }
 }

package/packages/workers/api-node/port.d.ts

@@ -7,12 +7,20 @@ export type Message = {
     responseId: string;
     data: Uint8Array;
 };
+/** Transferable representation of a `ThreadPort`. */
+export type TransferablePort = {
+    threadId: number;
+    port: MessagePort;
+};
 export declare class ThreadPort implements Port {
     private readonly spec;
     private readonly port;
+    static pair(spec: ChainSpec): [ThreadPort, ThreadPort];
     readonly threadId: number;
     private readonly events;
     constructor(spec: ChainSpec, port: MessagePort);
+    static fromTransferable(spec: ChainSpec, { port }: TransferablePort): ThreadPort;
+    intoTransferable(): TransferablePort;
     close(): void;
     private createListener;
     onClose(callback: (e: Error) => void): void;

package/packages/workers/api-node/port.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"port.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/api-node/port.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAA+B,MAAM,qBAAqB,CAAC;AACpF,OAAO,EAAE,KAAK,KAAK,EAAoB,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGnD,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,gCAAgC,CAAC;AAErE,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAKF,qBAAa,UAAW,YAAW,IAAI;IAKnC,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI;IALvB,SAAgB,QAAQ,SAAY;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;gBAG1B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,WAAW;IAcpC,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,cAAc;IAkBtB,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;IAI3C,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IASvF,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IASzF,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI;CAWvE"}
+{"version":3,"file":"port.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/api-node/port.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAA+B,MAAM,qBAAqB,CAAC;AACpF,OAAO,EAAE,KAAK,KAAK,EAAoB,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGnD,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,gCAAgC,CAAC;AAErE,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAIF,qDAAqD;AACrD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,WAAW,CAAC;CACnB,CAAC;AACF,qBAAa,UAAW,YAAW,IAAI;IAWnC,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAXvB,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC;IAMtD,SAAgB,QAAQ,SAAY;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;gBAG1B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,WAAW;IAcpC,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,EAAE,gBAAgB;IAInE,gBAAgB,IAAI,gBAAgB;IAIpC,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,cAAc;IAkBtB,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;IAI3C,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IASvF,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IASzF,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI;CAWvE"}

package/packages/workers/api-node/port.js

@@ -8,6 +8,10 @@ const logger = Logger.new(import.meta.filename, "workers/api");
 export class ThreadPort {
     spec;
     port;
+    static pair(spec) {
+        const { port1, port2 } = new MessageChannel();
+        return [new ThreadPort(spec, port1), new ThreadPort(spec, port2)];
+    }
     threadId = threadId;
     events = new EventEmitter();
     constructor(spec, port) {
@@ -23,6 +27,12 @@ export class ThreadPort {
             this.events.emit(eventName, responseId, data);
         });
     }
+    static fromTransferable(spec, { port }) {
+        return new ThreadPort(spec, port);
+    }
+    intoTransferable() {
+        return { threadId: this.threadId, port: this.port };
+    }
     close() {
         this.port.close();
     }

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

@@ -1,12 +1,19 @@
+import { AUTHORSHIP_NETWORK_PORT, protocol as networkProtocol } from "#@typeberry/comms-authorship-network";
 import { Telemetry } from "#@typeberry/telemetry";
+import { Channel } from "#@typeberry/workers-api";
 import { initWorker } from "#@typeberry/workers-api-node";
 import { main } from "./main.js";
-import { BlockAuthorshipConfig, protocol } from "./protocol.js";
-const { config, comms } = await initWorker(protocol, BlockAuthorshipConfig.Codec);
+import { BlockAuthorshipConfig, protocol as mainProtocol } from "./protocol.js";
+const { config, comms } = await initWorker(mainProtocol, BlockAuthorshipConfig.Codec);
 // Initialize OpenTelemetry for this worker
 const tele = Telemetry.initialize({
     worker: "generator",
     nodeName: config.nodeName,
 });
-await main(config, comms);
+const port = config.ports.get(AUTHORSHIP_NETWORK_PORT);
+if (port === undefined) {
+    throw new Error("Network port not found in config");
+}
+const networkingComms = Channel.tx(networkProtocol, port);
+await main(config, comms, networkingComms);
 await tele?.close();

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

@@ -1,6 +1,7 @@
+import type { NetworkingComms } from "#@typeberry/comms-authorship-network";
 import type { WorkerConfig } from "#@typeberry/workers-api";
 import type { BlockAuthorshipConfig, GeneratorInternal } from "./protocol.js";
 type Config = WorkerConfig<BlockAuthorshipConfig>;
-export declare function main(config: Config, comms: GeneratorInternal): Promise<void>;
+export declare function main(config: Config, comms: GeneratorInternal, networkingComms: NetworkingComms): Promise<void>;
 export {};
 //# sourceMappingURL=main.d.ts.map

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":"AA2BA,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,iBAyMlE"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/main.ts"],"names":[],"mappings":"AAYA,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,iBA2MpG"}

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

@@ -15,7 +15,7 @@ import { asOpaqueType, assertNever, Result } from "#@typeberry/utils";
 import { Generator } from "./generator.js";
 import { generateTickets } from "./ticket-generator.js";
 const logger = Logger.new(import.meta.filename, "author");
-export async function main(config, comms) {
+export async function main(config, comms, networkingComms) {
     await initWasm();
     logger.info `🎁 Block Authorship running`;
     const chainSpec = config.chainSpec;
@@ -134,8 +134,9 @@ export async function main(config, comms) {
                     logger.warn `Failed to generate tickets for epoch ${epoch}: ${ticketsResult.error}`;
                 }
                 else {
-                    logger.log `Generated ${ticketsResult.ok.length} tickets for epoch ${epoch}.`;
-                    // TODO [MaSi]: Sending out tickets
+                    logger.log `Generated ${ticketsResult.ok.length} tickets for epoch ${epoch}. Distributing...`;
+                    // Send directly to network worker (bypasses main thread)
+                    await networkingComms.sendTickets({ epochIndex: epoch, tickets: ticketsResult.ok });
                 }
             }
             ticketsGeneratedForEpoch = epoch;

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

@@ -0,0 +1,3 @@
+export * from "./protocol.js";
+export * from "./tickets-message.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/comms-authorship-network/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from "./protocol.js";
+export * from "./tickets-message.js";

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

@@ -0,0 +1,27 @@
+import { type Api, type Internal } from "#@typeberry/workers-api";
+import { TicketsMessage } from "./tickets-message.js";
+/**
+ * Port name for authorship-network direct communication.
+ * Used when spawning jam-network worker to pass the port for receiving tickets.
+ */
+export declare const AUTHORSHIP_NETWORK_PORT = "authorship-network";
+/**
+ * Protocol for direct communication between block-authorship and jam-network workers.
+ *
+ * This bypasses the main thread for ticket distribution, reducing latency.
+ */
+export declare const protocol: import("@typeberry/workers-api").LousyProtocol<{
+    tickets: {
+        request: import("@typeberry/codec").Descriptor<TicketsMessage, import("@typeberry/codec").ViewOf<TicketsMessage, {
+            epochIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"Epoch">, import("@typeberry/bytes").Bytes<4>>;
+            tickets: import("@typeberry/codec").Descriptor<import("@typeberry/block").SignedTicket[], import("@typeberry/codec").SequenceView<import("@typeberry/block").SignedTicket, import("@typeberry/codec").ViewOf<import("@typeberry/block").SignedTicket, {
+                attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U8>;
+                signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<784> & import("@typeberry/utils").WithOpaque<"BandersnatchRingSignature">, import("@typeberry/bytes").Bytes<784>>;
+            }>>>;
+        }>>;
+        response: import("@typeberry/codec").Descriptor<void, void>;
+    };
+}, {}>;
+export type NetworkingComms = Api<typeof protocol>;
+export type AuthorshipComms = Internal<typeof protocol>;
+//# sourceMappingURL=protocol.d.ts.map

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

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

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

@@ -0,0 +1,24 @@
+import { codec } from "#@typeberry/codec";
+import { createProtocol } from "#@typeberry/workers-api";
+import { TicketsMessage } from "./tickets-message.js";
+/**
+ * Port name for authorship-network direct communication.
+ * Used when spawning jam-network worker to pass the port for receiving tickets.
+ */
+export const AUTHORSHIP_NETWORK_PORT = "authorship-network";
+/**
+ * Protocol for direct communication between block-authorship and jam-network workers.
+ *
+ * This bypasses the main thread for ticket distribution, reducing latency.
+ */
+export const protocol = createProtocol("authorship-network", {
+    // Messages from block-authorship to jam-network
+    toWorker: {
+        tickets: {
+            request: TicketsMessage.Codec,
+            response: codec.nothing,
+        },
+    },
+    // Messages from jam-network to block-authorship (none for now)
+    fromWorker: {},
+});

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

@@ -0,0 +1,18 @@
+import type { Epoch } from "#@typeberry/block";
+import { SignedTicket } from "#@typeberry/block/tickets.js";
+import { type CodecRecord } from "#@typeberry/codec";
+import { WithDebug } from "#@typeberry/utils";
+export declare class TicketsMessage extends WithDebug {
+    readonly epochIndex: Epoch;
+    readonly tickets: SignedTicket[];
+    static Codec: import("@typeberry/codec").Descriptor<TicketsMessage, import("@typeberry/codec").ViewOf<TicketsMessage, {
+        epochIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"Epoch">, import("@typeberry/bytes").Bytes<4>>;
+        tickets: import("@typeberry/codec").Descriptor<SignedTicket[], import("@typeberry/codec").SequenceView<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>;
+            signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<784> & import("@typeberry/utils").WithOpaque<"BandersnatchRingSignature">, import("@typeberry/bytes").Bytes<784>>;
+        }>>>;
+    }>>;
+    static create({ epochIndex, tickets }: CodecRecord<TicketsMessage>): TicketsMessage;
+    private constructor();
+}
+//# sourceMappingURL=tickets-message.d.ts.map

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

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

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

@@ -0,0 +1,19 @@
+import { SignedTicket } from "#@typeberry/block/tickets.js";
+import { codec } from "#@typeberry/codec";
+import { WithDebug } from "#@typeberry/utils";
+export class TicketsMessage extends WithDebug {
+    epochIndex;
+    tickets;
+    static Codec = codec.Class(TicketsMessage, {
+        epochIndex: codec.u32.asOpaque(),
+        tickets: codec.sequenceVarLen(SignedTicket.Codec),
+    });
+    static create({ epochIndex, tickets }) {
+        return new TicketsMessage(epochIndex, tickets);
+    }
+    constructor(epochIndex, tickets) {
+        super();
+        this.epochIndex = epochIndex;
+        this.tickets = tickets;
+    }
+}

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

@@ -1,12 +1,19 @@
+import { AUTHORSHIP_NETWORK_PORT, protocol as authorshipProtocol } from "#@typeberry/comms-authorship-network";
 import { Telemetry } from "#@typeberry/telemetry";
+import { Channel } from "#@typeberry/workers-api";
 import { initWorker } from "#@typeberry/workers-api-node";
 import { main } from "./main.js";
-import { NetworkingConfig, protocol } from "./protocol.js";
-const { config, comms } = await initWorker(protocol, NetworkingConfig.Codec);
+import { protocol as mainProtocol, NetworkingConfig } from "./protocol.js";
+const { config, comms } = await initWorker(mainProtocol, NetworkingConfig.Codec);
 // Initialize OpenTelemetry for this worker
 const tele = Telemetry.initialize({
     nodeName: config.nodeName,
     worker: "network",
 });
-await main(config, comms);
+const port = config.ports.get(AUTHORSHIP_NETWORK_PORT);
+if (port === undefined) {
+    throw new Error("Authorship network port not found in config");
+}
+const networkingComms = Channel.rx(authorshipProtocol, port);
+await main(config, comms, networkingComms);
 await tele?.close();

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

@@ -1,3 +1,4 @@
+import type { AuthorshipComms } from "#@typeberry/comms-authorship-network";
 import type { WorkerConfig } from "#@typeberry/workers-api";
 import type { NetworkingConfig, NetworkingInternal } from "./protocol.js";
 /**
@@ -7,5 +8,5 @@ import type { NetworkingConfig, NetworkingInternal } from "./protocol.js";
  * (using `typeberry/networking` package) and adding relevant JAMNP-s
  * stream handlers.
  */
-export declare function main(config: WorkerConfig<NetworkingConfig>, comms: NetworkingInternal): Promise<void>;
+export declare function main(config: WorkerConfig<NetworkingConfig>, comms: NetworkingInternal, authorshipComms: AuthorshipComms): Promise<void>;
 //# sourceMappingURL=main.d.ts.map

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

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

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

@@ -10,7 +10,7 @@ const logger = Logger.new(import.meta.filename, "net");
  * (using `typeberry/networking` package) and adding relevant JAMNP-s
  * stream handlers.
  */
-export async function main(config, comms) {
+export async function main(config, comms, authorshipComms) {
     await initWasm();
     logger.trace `🛜 Network starting`;
     // Await the configuration object
@@ -31,6 +31,13 @@ export async function main(config, comms) {
     comms.setOnNewHeader(async (header) => {
         network.syncTask.broadcastHeader(header);
     });
+    // Handle tickets received directly from block-authorship (bypasses main thread)
+    authorshipComms.setOnTickets(async ({ epochIndex, tickets }) => {
+        logger.log `Received ${tickets.length} tickets directly from block-authorship for epoch ${epochIndex}`;
+        for (const ticket of tickets) {
+            network.ticketTask.addTicket(epochIndex, ticket);
+        }
+    });
     await network.network.start();
     // stop the network when the worker is finishing.
     await waitForFinish;