@typeberry/lib 0.5.1 → 0.5.2-03e1aed

package/packages/misc/benchmark/index.js

@@ -0,0 +1,167 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Logger } from "#@typeberry/logger";
+import chalk from "chalk";
+import { formatResults } from "./format.js";
+import { BENCHMARKS_DIR, DIST_DIR, EXPECTED_DIR_NAME, OUTPUT_DIR_NAME } from "./setup.js";
+const commitHash = process.env.GITHUB_SHA;
+const logger = Logger.new(import.meta.filename, "benchmarks");
+runAllBenchmarks().catch((e) => {
+    logger.error `${e.message}`;
+    logger.error `Cause: ${e.cause}`;
+    logger.error `Stack: ${e.stack ?? ""}`;
+    process.exit(-1);
+});
+async function runAllBenchmarks() {
+    // We are going to run all benchmarks in our benchmark folder.
+    const benchmarksPath = BENCHMARKS_DIR;
+    const distPath = path.resolve(`${DIST_DIR}/benchmarks`);
+    fs.mkdirSync(distPath, {
+        recursive: true,
+    });
+    const benchmarks = fs.readdirSync(benchmarksPath);
+    const results = new Map();
+    const promises = [];
+    for (const benchmark of benchmarks) {
+        const benchPath = `${benchmarksPath}/${benchmark}`;
+        if (fs.statSync(benchPath).isDirectory()) {
+            const files = fs.readdirSync(benchPath);
+            for (const file of files) {
+                const isTs = path.extname(file) === ".ts";
+                if (isTs) {
+                    promises.push(runBenchmark(benchPath, file).then((res) => {
+                        results.set(`${benchmark}/${file}`, res);
+                    }));
+                }
+                else {
+                    logger.warn `Ignoring ${benchPath}/${file}`;
+                }
+            }
+        }
+    }
+    await Promise.all(promises);
+    // dump raw JSON
+    fs.writeFileSync(`${distPath}/results.json`, JSON.stringify(Object.fromEntries(results.entries()), null, 2));
+    // create a textual summary (github comment)
+    const txt = formatResults(results, commitHash);
+    fs.writeFileSync(`${distPath}/results.txt`, txt);
+    // print summary
+    logger.log `Summary:`;
+    for (const [file, diffs] of results.entries()) {
+        for (const [idx, diff] of diffs.diff.entries()) {
+            logger.log `${file}[${idx}]: ${"err" in diff ? chalk.red.bold(diff.err) : chalk.green("OK")}`;
+        }
+    }
+    const errorKeys = [];
+    for (const [key, res] of Array.from(results.entries())) {
+        if (res.diff.find((e) => "err" in e) !== undefined) {
+            errorKeys.push(key);
+        }
+    }
+    const hasErrors = errorKeys.length > 0;
+    if (hasErrors) {
+        const error = new Error(`${errorKeys.length} errors while running benchmarks. Exiting.`);
+        error.cause = errorKeys.join(", ");
+        throw error;
+    }
+}
+async function runBenchmark(benchPath, fileName) {
+    const filePath = `${benchPath}/${fileName}`;
+    const fileNameNoExt = path.basename(fileName, path.extname(fileName));
+    logger.log `Running ${filePath}`;
+    const run = await import(path.resolve(filePath));
+    await run.default();
+    logger.log `Compare with expected results.`;
+    const outputPath = `${benchPath}/${OUTPUT_DIR_NAME}/${fileNameNoExt}.json`;
+    const expectedPath = `${benchPath}/${EXPECTED_DIR_NAME}/${fileNameNoExt}.json`;
+    const currentResults = JSON.parse(fs.readFileSync(outputPath).toString());
+    const expectedContent = tryReadFile(expectedPath);
+    if (expectedContent !== null) {
+        const previousResults = JSON.parse(expectedContent.toString());
+        return {
+            diff: compareResults(currentResults, previousResults),
+            current: currentResults,
+        };
+    }
+    // If the expected directory does not exist, just compare with itself.
+    return {
+        diff: compareResults(currentResults, currentResults),
+        current: currentResults,
+    };
+}
+function tryReadFile(p) {
+    try {
+        return fs.readFileSync(p);
+    }
+    catch {
+        return null;
+    }
+}
+function compareResults(currentResults, expectedResults) {
+    const curr = currentResults.results;
+    let prev = expectedResults.results;
+    // should not happen, since BennyResults always have some results.
+    if (curr === null) {
+        return [];
+    }
+    // if there is no expectation on the results, just check which case is the fastest.
+    prev = prev ?? curr;
+    const res = [];
+    const currMinOps = Math.min(...Array.from(curr.values()).map((x) => x.ops));
+    const prevMinOps = Math.min(...Array.from(prev.values()).map((x) => x.ops));
+    for (let i = 0; i < Math.max(curr.length, prev.length); i += 1) {
+        if (curr[i]?.name !== prev[i]?.name) {
+            res.push({
+                name: curr[i]?.name ?? prev[i]?.name,
+                err: `Mismatching name (current) "${curr[i]?.name}" vs "${prev[i]?.name}" (expected)`,
+            });
+            continue;
+        }
+        // we work on normalized results
+        const currNormalized = Math.sqrt(curr[i].ops / currMinOps);
+        const prevNormalized = Math.sqrt(prev[i].ops / prevMinOps);
+        // compare the difference between results
+        const diff = Math.abs(currNormalized - prevNormalized);
+        // be generous with the margin
+        const margin = 5 + curr[i].margin + prev[i].margin;
+        // but take the slower result to comparison.
+        const min = Math.min(currNormalized, prevNormalized);
+        if (diff > (min * margin) / 100) {
+            res.push({
+                name: curr[i].name,
+                err: errMsg(curr[i], prev[i], currNormalized, prevNormalized),
+                ops: [curr[i].ops, prev[i].ops],
+                margin: [curr[i].margin, prev[i].margin],
+            });
+        }
+        else {
+            res.push({
+                name: curr[i].name,
+                ok: true,
+                ops: [curr[i].ops, prev[i].ops],
+                margin: [curr[i].margin, prev[i].margin],
+            });
+        }
+    }
+    return [...res, ...compareFastest(currentResults, expectedResults)];
+}
+function compareFastest(currentResults, expectedResults) {
+    const current = Array.isArray(currentResults.fastest) ? currentResults.fastest[0] : currentResults.fastest;
+    const expected = Array.isArray(expectedResults.fastest) ? expectedResults.fastest : [expectedResults.fastest];
+    const expectedNames = [];
+    for (const e of expected) {
+        if (current.name === e.name && current.index === e.index) {
+            return [];
+        }
+        expectedNames.push(`${e.name}[${e.index}]`);
+    }
+    return [
+        {
+            name: current.name,
+            err: `Fastest result changed to (current) "${current.name}[${current.index}]" from "${expectedNames.join(" or ")}" (expected) ❌`,
+        },
+    ];
+}
+function errMsg(curr, prev, currNormalized, prevNormalized) {
+    return `Significant speed difference: (current) "${curr.ops} (${currNormalized}) ±${curr.margin}%" vs "${prev.ops} (${prevNormalized}) ± ${prev.margin}%" (previous)`;
+}

package/packages/misc/benchmark/setup.d.ts

@@ -0,0 +1,9 @@
+export { add, complete, cycle, suite } from "benny";
+import type { Config } from "benny/lib/internal/common-types.js";
+export declare const DIST_DIR: string;
+export declare const BENCHMARKS_DIR: string;
+export declare const OUTPUT_DIR_NAME = "output";
+export declare const EXPECTED_DIR_NAME = "expected";
+export declare function configure(obj: Config): import("benny/lib/configure.js").ConfigureResult;
+export declare function save(benchmarkPath: string): ((config: Config) => Promise<(suiteObj: Suite) => Suite>)[];
+//# sourceMappingURL=setup.d.ts.map

package/packages/misc/benchmark/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../../packages/misc/benchmark/setup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAIpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oCAAoC,CAAC;AAEjE,eAAO,MAAM,QAAQ,QAAuD,CAAC;AAC7E,eAAO,MAAM,cAAc,QAA6D,CAAC;AACzF,eAAO,MAAM,eAAe,WAAW,CAAC;AACxC,eAAO,MAAM,iBAAiB,aAAa,CAAC;AAE5C,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,oDAGpC;AAED,wBAAgB,IAAI,CAAC,aAAa,EAAE,MAAM,+DAmBzC"}

package/packages/misc/benchmark/setup.js

@@ -0,0 +1,31 @@
+export { add, complete, cycle, suite } from "benny";
+import * as path from "node:path";
+import { configure as rawConfigure, save as rawSave } from "benny";
+export const DIST_DIR = path.resolve(`${import.meta.dirname}/../../../dist`);
+export const BENCHMARKS_DIR = path.resolve(`${import.meta.dirname}/../../../benchmarks`);
+export const OUTPUT_DIR_NAME = "output";
+export const EXPECTED_DIR_NAME = "expected";
+export function configure(obj) {
+    obj.minDisplayPrecision ??= 2;
+    return rawConfigure(obj);
+}
+export function save(benchmarkPath) {
+    const testPath = path.parse(benchmarkPath);
+    const testSuite = path.basename(testPath.dir);
+    const defaultParams = {
+        file: testPath.name,
+        folder: `${BENCHMARKS_DIR}/${testSuite}/${OUTPUT_DIR_NAME}`,
+    };
+    return [
+        rawSave({
+            ...defaultParams,
+            details: false,
+            format: "json",
+        }),
+        rawSave({
+            ...defaultParams,
+            details: true,
+            format: "chart.html",
+        }),
+    ];
+}

package/packages/misc/benchmark/types.d.ts

@@ -0,0 +1,39 @@
+export type Result = {
+    current: BennyResults;
+    diff: ComparisonResult;
+};
+export type ErrorResult = {
+    name: string;
+    err: string;
+};
+export type OkResult = {
+    ok: true;
+    name: string;
+    ops: [number, number];
+    margin: [number, number];
+};
+export type ComparisonResult = (ErrorResult | OkResult)[];
+export type BennyOps = {
+    name: string;
+    ops: number;
+    margin: number;
+    percentSlower?: number;
+};
+export type BennyResults = {
+    name: string;
+    date: string;
+    version: string | null;
+    results: BennyOps[] | null;
+    fastest: {
+        name: string;
+        index: number;
+    } | {
+        name: string;
+        index: number;
+    }[];
+    slowest: {
+        name: string;
+        index: number;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/packages/misc/benchmark/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../packages/misc/benchmark/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG;IACnB,OAAO,EAAE,YAAY,CAAC;IACtB,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,WAAW,GAAG,QAAQ,CAAC,EAAE,CAAC;AAE1D,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;IAC3B,OAAO,EACH;QACE,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,GACD;QACE,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,EAAE,CAAC;IACR,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;CACH,CAAC"}

package/packages/misc/benchmark/types.js

@@ -0,0 +1 @@
+export {};

package/packages/workers/api/channel.d.ts

@@ -0,0 +1,21 @@
+import type { Port } from "./port.js";
+import type { Destroy, Handlers, LousyProtocol, MessageCodecs, Rx, Senders, Tx } from "./types.js";
+/**
+ * Wraps a protocol definition and a communication port into a properly
+ * typed communication channel.
+ */
+export declare class Channel {
+    private readonly port;
+    /** Create receiving end of the channel (i.e. handling messages `toWorker`). */
+    static rx<To, From>(protocol: LousyProtocol<To, From>, port: Port): Rx<To, From>;
+    /** Create transmitting end of the channel (i.e. handling messages `fromWorker`). */
+    static tx<To, From>(protocol: LousyProtocol<To, From>, port: Port): Tx<To, From>;
+    static new<To, From>(protocol: LousyProtocol<To, From>, port: Port): Handlers<To> & Senders<From> & Destroy;
+    private nextResponseId;
+    private readonly pendingPromises;
+    private constructor();
+    _createRequestHandler(key: string, val: MessageCodecs<unknown, unknown>): (handler: (req: unknown) => Promise<unknown>) => void;
+    _createSender(key: string, val: MessageCodecs<unknown, unknown>): (data: unknown) => Promise<unknown>;
+    destroy(): void;
+}
+//# sourceMappingURL=channel.d.ts.map

package/packages/workers/api/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/api/channel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EACV,OAAO,EAEP,QAAQ,EACR,aAAa,EACb,aAAa,EACb,EAAE,EAEF,OAAO,EACP,EAAE,EACH,MAAM,YAAY,CAAC;AAIpB;;;GAGG;AACH,qBAAa,OAAO;IA+CE,OAAO,CAAC,QAAQ,CAAC,IAAI;IA9CzC,+EAA+E;IAC/E,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,aAAa,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,GAAG,EAAE,CAAC,EAAE,EAAE,IAAI,CAAC;IAIhF,oFAAoF;IACpF,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,aAAa,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,GAAG,EAAE,CAAC,EAAE,EAAE,IAAI,CAAC;IAKhF,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,aAAa,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,GAAG,QAAQ,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO;IAgC3G,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAwC;IAExE,OAAO;IAUP,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,IAG7D,SAAS,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC;IAuBrD,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,IACrD,MAAM,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;IAuB1C,OAAO;CAGR"}

package/packages/workers/api/channel.js

@@ -0,0 +1,116 @@
+import { Logger } from "#@typeberry/logger";
+import { check } from "#@typeberry/utils";
+const logger = Logger.new(import.meta.filename, "workers");
+/**
+ * Wraps a protocol definition and a communication port into a properly
+ * typed communication channel.
+ */
+export class Channel {
+    port;
+    /** Create receiving end of the channel (i.e. handling messages `toWorker`). */
+    static rx(protocol, port) {
+        return Channel.new(protocol, port);
+    }
+    /** Create transmitting end of the channel (i.e. handling messages `fromWorker`). */
+    static tx(protocol, port) {
+        const { name, toWorker, fromWorker } = protocol;
+        return Channel.new({ name, toWorker: fromWorker, fromWorker: toWorker }, port);
+    }
+    static new(protocol, port) {
+        const channel = new Channel(port);
+        // biome-ignore lint/suspicious/noExplicitAny: we dynamically add methods, so that's expected
+        const untyped = channel;
+        // create handlers for incoming requests
+        for (const [k, val] of Object.entries(protocol.toWorker)) {
+            const key = `${protocol.name}:${String(k)}`;
+            if (isMessageCodecs(val)) {
+                // NOTE: has to match `Handlers` type definition.
+                const typedKey = `setOn${capitalize(k)}`;
+                untyped[typedKey] = channel._createRequestHandler(key, val);
+            }
+            else {
+                throw new Error(`${key} does not contain message codecs.`);
+            }
+        }
+        // create sender methods for outgoing requests
+        for (const [k, val] of Object.entries(protocol.fromWorker)) {
+            const key = `${protocol.name}:${String(k)}`;
+            if (isMessageCodecs(val)) {
+                // NOTE: has to match `Senders` type definition.
+                const typedKey = `send${capitalize(k)}`;
+                untyped[typedKey] = channel._createSender(key, val);
+            }
+            else {
+                throw new Error(`${key} does not contain message codecs.`);
+            }
+        }
+        return untyped;
+    }
+    nextResponseId = 0;
+    pendingPromises = new Set();
+    constructor(port) {
+        this.port = port;
+        // add general error handler that will reject all pending promises.
+        port.onClose((e) => {
+            for (const pending of this.pendingPromises) {
+                pending(e);
+            }
+            this.pendingPromises.clear();
+        });
+    }
+    _createRequestHandler(key, val) {
+        let isAttached = false;
+        return (handler) => {
+            check `${isAttached === false} handler for ${key} can be added only once!`;
+            isAttached = true;
+            // listen to request incoming to worker
+            this.port.on(key, val.request, async ({ responseId, data }) => {
+                try {
+                    // handle them
+                    const response = await handler(data);
+                    // and send response back on dedicated event
+                    this.port.postMessage(responseId, val.response, {
+                        responseId,
+                        data: response,
+                    });
+                }
+                catch (e) {
+                    logger.error `Error while handling ${key} (${responseId}): ${e}`;
+                    throw e;
+                }
+            });
+        };
+    }
+    _createSender(key, val) {
+        return (data) => {
+            this.nextResponseId++;
+            const responseId = `${key}:${this.nextResponseId}`;
+            return new Promise((resolve, reject) => {
+                this.pendingPromises.add(reject);
+                // attach response listener first
+                this.port.once(responseId, val.response, (msg) => {
+                    // we got response, so will resolve
+                    this.pendingPromises.delete(reject);
+                    resolve(msg.data);
+                });
+                // send message to the port
+                this.port.postMessage(key, val.request, {
+                    responseId,
+                    data,
+                });
+            });
+        };
+    }
+    destroy() {
+        this.port.close();
+    }
+}
+function capitalize(k) {
+    if (k.length === 0) {
+        return k;
+    }
+    return (k.charAt(0).toUpperCase() + k.slice(1));
+}
+function isMessageCodecs(val) {
+    return val !== null && typeof val === "object" && "request" in val && "response" in val;
+}

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

@@ -0,0 +1,37 @@
+import type { ChainSpec } from "#@typeberry/config";
+import type { BlocksDb, RootDb, StatesDb } from "#@typeberry/database";
+/** Standardized worker config. */
+export interface WorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> {
+    /** Node name. */
+    readonly nodeName: string;
+    /** Chain spec. */
+    readonly chainSpec: ChainSpec;
+    /** Worker parameters. */
+    readonly workerParams: TParams;
+    /** Open database. */
+    openDatabase(options?: {
+        readonly: boolean;
+    }): RootDb<TBlocks, TStates>;
+}
+/**
+ * Worker config with in-thread database.
+ */
+export declare class DirectWorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> implements WorkerConfig<TParams, TBlocks, TStates> {
+    readonly nodeName: string;
+    readonly chainSpec: ChainSpec;
+    readonly workerParams: TParams;
+    private readonly blocksDb;
+    private readonly statesDb;
+    static new<T, B, S>({ nodeName, chainSpec, blocksDb, statesDb, workerParams: params, }: {
+        nodeName: string;
+        chainSpec: ChainSpec;
+        blocksDb: B;
+        statesDb: S;
+        workerParams: T;
+    }): DirectWorkerConfig<T, B, S>;
+    private constructor();
+    openDatabase(_options?: {
+        readonly: boolean;
+    }): RootDb<TBlocks, TStates>;
+}
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/api/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEtE,kCAAkC;AAClC,MAAM,WAAW,YAAY,CAAC,OAAO,GAAG,IAAI,EAAE,OAAO,GAAG,QAAQ,EAAE,OAAO,GAAG,QAAQ;IAClF,iBAAiB;IACjB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,kBAAkB;IAClB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,yBAAyB;IACzB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAE/B,qBAAqB;IACrB,YAAY,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;CACzE;AAED;;GAEG;AACH,qBAAa,kBAAkB,CAAC,OAAO,GAAG,IAAI,EAAE,OAAO,GAAG,QAAQ,EAAE,OAAO,GAAG,QAAQ,CACpF,YAAW,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC;aAmBhC,QAAQ,EAAE,MAAM;aAChB,SAAS,EAAE,SAAS;aACpB,YAAY,EAAE,OAAO;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IArB3B,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAClB,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,YAAY,EAAE,MAAM,GACrB,EAAE;QACD,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,SAAS,CAAC;QACrB,QAAQ,EAAE,CAAC,CAAC;QACZ,QAAQ,EAAE,CAAC,CAAC;QACZ,YAAY,EAAE,CAAC,CAAC;KACjB,GAAG,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAI/B,OAAO;IAQP,YAAY,CAAC,QAAQ,CAAC,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;CAOzE"}

package/packages/workers/api/config.js

@@ -0,0 +1,27 @@
+/**
+ * Worker config with in-thread database.
+ */
+export class DirectWorkerConfig {
+    nodeName;
+    chainSpec;
+    workerParams;
+    blocksDb;
+    statesDb;
+    static new({ nodeName, chainSpec, blocksDb, statesDb, workerParams: params, }) {
+        return new DirectWorkerConfig(nodeName, chainSpec, params, blocksDb, statesDb);
+    }
+    constructor(nodeName, chainSpec, workerParams, blocksDb, statesDb) {
+        this.nodeName = nodeName;
+        this.chainSpec = chainSpec;
+        this.workerParams = workerParams;
+        this.blocksDb = blocksDb;
+        this.statesDb = statesDb;
+    }
+    openDatabase(_options) {
+        return {
+            getBlocksDb: () => this.blocksDb,
+            getStatesDb: () => this.statesDb,
+            close: () => Promise.resolve(),
+        };
+    }
+}

package/packages/workers/api/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./channel.js";
+export * from "./config.js";
+export * from "./port.js";
+export * from "./protocol.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/workers/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/packages/workers/api/index.js

@@ -0,0 +1,5 @@
+export * from "./channel.js";
+export * from "./config.js";
+export * from "./port.js";
+export * from "./protocol.js";
+export * from "./types.js";

package/packages/workers/api/index.test.d.ts

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

package/packages/workers/api/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/api/index.test.ts"],"names":[],"mappings":""}

package/packages/workers/api/index.test.js

@@ -0,0 +1,53 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { codec } from "#@typeberry/codec";
+import { tryAsU64 } from "#@typeberry/numbers";
+import { Channel } from "./channel.js";
+import { DirectPort } from "./port.js";
+import { createProtocol } from "./protocol.js";
+const protocol = createProtocol("testproto", {
+    toWorker: {
+        finish: {
+            request: codec.nothing,
+            response: codec.nothing,
+        },
+    },
+    fromWorker: {
+        generatedBlock: {
+            request: codec.u64,
+            response: codec.bool,
+        },
+    },
+});
+describe("Workers Channels", () => {
+    it("should create connected channels and send on finished", async () => {
+        const [txPort, rxPort] = DirectPort.pair();
+        const rx = Channel.rx(protocol, rxPort);
+        let onFinishedReceived = 0;
+        rx.setOnFinish(async () => {
+            onFinishedReceived++;
+        });
+        const tx = Channel.tx(protocol, txPort);
+        assert.strictEqual(onFinishedReceived, 0);
+        // when
+        await tx.sendFinish();
+        // then
+        assert.strictEqual(onFinishedReceived, 1);
+    });
+    it("should create connected channels and send parameter", async () => {
+        const [txPort, rxPort] = DirectPort.pair();
+        const tx = Channel.tx(protocol, txPort);
+        const blocksReceived = [];
+        tx.setOnGeneratedBlock(async (block) => {
+            blocksReceived.push(block);
+            return true;
+        });
+        const rx = Channel.rx(protocol, rxPort);
+        assert.deepStrictEqual(blocksReceived, []);
+        // when
+        const response = await rx.sendGeneratedBlock(tryAsU64(15));
+        // then
+        assert.deepStrictEqual(blocksReceived, [15n]);
+        assert.strictEqual(response, true);
+    });
+});

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

@@ -0,0 +1,58 @@
+import type { Codec } from "#@typeberry/codec";
+/**
+ * Our specific message envelope.
+ *
+ * Since we will be implementing request-response protocol,
+ * we include an extra field of `responseId` event that
+ * should be used to listen to responses (if expected).
+ */
+export type Envelope<T> = {
+    responseId: string;
+    data: T;
+};
+/**
+ * Message passing abstraction using JAM-codec for serialization (when necessary).
+ *
+ * Can be used to communicate between worker threads.
+ */
+export interface Port {
+    /** Optional thread id. */
+    readonly threadId: number;
+    /** Attach a callback to be triggered when the port is being closed (via error or not). */
+    onClose(callback: (e: Error) => void): void;
+    /**
+     * Attach event listener for particular event.
+     *
+     * Returns a function that can be called to unsubscribe.
+     */
+    on<T>(event: string, codec: Codec<T>, callback: (msg: Envelope<T>) => void): () => void;
+    /**
+     * Attach one-time event listener for particular event.
+     *
+     * Returns a function that can be called to unsubscribe.
+     */
+    once<T>(event: string, codec: Codec<T>, callback: (msg: Envelope<T>) => void): () => void;
+    /** Post a message to the port that should be received on the other end. */
+    postMessage<T>(event: string, codec: Codec<T>, msg: Envelope<T>): void;
+    /** Destroy the communication channel. */
+    close(): void;
+}
+/**
+ * A message-passing port that is directly connected to another end.
+ *
+ * Direct connection means, that both `tx` and `rx` exist in the same worker thread,
+ * so there is no need for any serialization - we simply pass the data.
+ */
+export declare class DirectPort implements Port {
+    private readonly events;
+    readonly threadId = 0;
+    /** Create a pair of symmetrical inter-connected ports. */
+    static pair(): [DirectPort, DirectPort];
+    private constructor();
+    onClose(callback: (e: Error) => void): void;
+    on<T>(event: string, _codec: Codec<T>, callback: (msg: Envelope<T>) => void): () => void;
+    once<T>(event: string, _codec: Codec<T>, callback: (msg: Envelope<T>) => void): () => void;
+    postMessage<T>(event: string, _codec: Codec<T>, msg: Envelope<T>): void;
+    close(): void;
+}
+//# sourceMappingURL=port.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"port.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/api/port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAG9C;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,CAAC,CAAC;CACT,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,IAAI;IACnB,0BAA0B;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,0FAA0F;IAC1F,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAC;IAE5C;;;;OAIG;IACH,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,CAAC;IAExF;;;;OAIG;IACH,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,CAAC;IAE1F,2EAA2E;IAC3E,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEvE,yCAAyC;IACzC,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;;GAKG;AACH,qBAAa,UAAW,YAAW,IAAI;IASjB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAR3C,QAAQ,CAAC,QAAQ,KAAK;IAEtB,0DAA0D;IAC1D,MAAM,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC;IAKvC,OAAO;IAEP,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;IAI3C,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAYxF,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAY1F,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI;IAIvE,KAAK;CAIN"}

package/packages/workers/api/port.js

@@ -0,0 +1,49 @@
+import { EventEmitter } from "eventemitter3";
+/**
+ * A message-passing port that is directly connected to another end.
+ *
+ * Direct connection means, that both `tx` and `rx` exist in the same worker thread,
+ * so there is no need for any serialization - we simply pass the data.
+ */
+export class DirectPort {
+    events;
+    threadId = 0;
+    /** Create a pair of symmetrical inter-connected ports. */
+    static pair() {
+        const events = new EventEmitter();
+        return [new DirectPort(events), new DirectPort(events)];
+    }
+    constructor(events) {
+        this.events = events;
+    }
+    onClose(callback) {
+        this.events.on("error", callback);
+    }
+    on(event, _codec, callback) {
+        const trigger = (args) => {
+            // we simply cast the args, since there is no encoding involved.
+            callback(args);
+        };
+        this.events.on(event, trigger);
+        return () => {
+            this.events.off(event, trigger);
+        };
+    }
+    once(event, _codec, callback) {
+        const trigger = (args) => {
+            // we simply cast the args, since there is no encoding involved.
+            callback(args);
+        };
+        this.events.once(event, trigger);
+        return () => {
+            this.events.off(event, trigger);
+        };
+    }
+    postMessage(event, _codec, msg) {
+        this.events.emit(event, msg);
+    }
+    close() {
+        this.events.emit("error", new Error("closing channel"));
+        this.events.removeAllListeners();
+    }
+}