@typeberry/lib 0.5.6 → 0.5.7-d496f70

package/packages/jam/node/main-importer.js

@@ -3,15 +3,14 @@ import { PvmBackend } from "#@typeberry/config";
 import { bandersnatch, initWasm } from "#@typeberry/crypto";
 import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
 import { createImporter } from "#@typeberry/importer";
-import { CURRENT_SUITE, CURRENT_VERSION, Result, resultToString } from "#@typeberry/utils";
+import { CURRENT_SUITE, CURRENT_VERSION, Result, resultToString, version } from "#@typeberry/utils";
 import { InMemWorkerConfig, LmdbWorkerConfig } from "#@typeberry/workers-api-node";
 import { getChainSpec, getDatabasePath, initializeDatabase, logger } from "./common.js";
-import packageJson from "./package.json" with { type: "json" };
 const zeroHash = Bytes.zero(HASH_SIZE).asOpaque();
 export async function mainImporter(config, withRelPath, options = {}) {
     await initWasm();
     const bandesnatchNative = bandersnatch.checkNativeBindings();
-    logger.info `🫐 Typeberry ${packageJson.version}. GP: ${CURRENT_VERSION} (${CURRENT_SUITE})`;
+    logger.info `🫐 Typeberry ${version}. GP: ${CURRENT_VERSION} (${CURRENT_SUITE})`;
     logger.info `🎸 Starting importer: ${config.nodeName}.`;
     logger.info `🖥️ PVM Backend: ${PvmBackend[config.pvmBackend]}.`;
     logger.info `🐇 Bandersnatch ${bandesnatchNative.isOk ? "native 🚀" : `using wasm: ${bandesnatchNative.error}`}`;

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,EAAE,MAAM,kBAAkB,CAAC;AAK1E,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,iBAAiB,CAAC;AAYhE,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";
@@ -7,13 +8,12 @@ import { ImporterConfig } from "#@typeberry/importer";
 import { NetworkingConfig } from "#@typeberry/jam-network";
 import { Listener } from "#@typeberry/listener";
 import { tryAsU16, tryAsU32 } from "#@typeberry/numbers";
-import { CURRENT_SUITE, CURRENT_VERSION, Result } from "#@typeberry/utils";
-import { DirectWorkerConfig } from "#@typeberry/workers-api";
-import { InMemWorkerConfig, LmdbWorkerConfig } from "#@typeberry/workers-api-node";
+import { CURRENT_SUITE, CURRENT_VERSION, Result, version } from "#@typeberry/utils";
+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";
-import packageJson from "./package.json" with { type: "json" };
 import { spawnBlockGeneratorWorker, spawnImporterWorker, spawnNetworkWorker, startBlockGenerator, startImporterDirect, startNetwork, } from "./workers.js";
 export async function main(config, withRelPath, telemetry) {
     if (!isMainThread) {
@@ -21,7 +21,7 @@ export async function main(config, withRelPath, telemetry) {
     }
     await initWasm();
     const nodeMetrics = metrics.createMetrics();
-    logger.info `🫐 Typeberry ${packageJson.version}. GP: ${CURRENT_VERSION} (${CURRENT_SUITE})`;
+    logger.info `🫐 Typeberry ${version}. GP: ${CURRENT_VERSION} (${CURRENT_SUITE})`;
     logger.info `🎸 Starting node: ${config.nodeName}.`;
     logger.info `🖥️ PVM Backend: ${PvmBackend[config.pvmBackend]}.`;
     const chainSpec = getChainSpec(config.node.flavor);
@@ -37,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 });
@@ -51,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(),
@@ -92,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) {
@@ -111,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`;
@@ -128,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({
@@ -166,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) => {
@@ -187,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/metrics.js

@@ -1,12 +1,12 @@
 import { metrics } from "@opentelemetry/api";
-import packageJson from "./package.json" with { type: "json" };
+import { version } from "#@typeberry/utils";
 /**
  * Node-level metrics for JAM implementation.
  *
  * https://github.com/polkadot-fellows/JIPs/blob/main/JIP-3.md#status-events
  */
 export function createMetrics() {
-    const meter = metrics.getMeter(packageJson.name, packageJson.version);
+    const meter = metrics.getMeter("@typeberry/node", version);
     // JIP-3
     // 11
     const bestBlockChangedCounter = meter.createCounter("jam.jip3.best_block_changed", {

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/block-authorship/metrics.js

@@ -1,12 +1,12 @@
 import { metrics } from "@opentelemetry/api";
-import packageJson from "./package.json" with { type: "json" };
+import { version } from "#@typeberry/utils";
 /**
  * Block authoring metrics for JAM implementation.
  *
  * https://github.com/polkadot-fellows/JIPs/blob/main/JIP-3.md#block-authoringimporting-events
  */
 export function createMetrics() {
-    const meter = metrics.getMeter(packageJson.name, packageJson.version);
+    const meter = metrics.getMeter("@typeberry/block-authorship", version);
     const blockAuthoringDuration = meter.createHistogram("jam.blockAuthoringTime", {
         description: "Duration of block authoring process",
         unit: "ms",

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