@typeberry/lib 0.5.1 → 0.5.2-03e1aed

package/packages/core/utils/result.js

@@ -0,0 +1,74 @@
+import { check } from "./debug.js";
+/**
+ * A generic `OK` response to be used instead of some empty/null value.
+ *
+ * NOTE that generic error is not provided to rather have a more
+ * descriptive value.
+ */
+export const OK = Symbol("ok");
+class RichTaggedError {
+    kind;
+    error;
+    enumMapping;
+    constructor(kind, error, enumMapping) {
+        this.kind = kind;
+        this.error = error;
+        this.enumMapping = enumMapping;
+    }
+    toString() {
+        const readableKind = Object.keys(this.enumMapping).find((key) => this.enumMapping[key] === this.kind) ?? "?";
+        return `${readableKind} (${this.kind}) - ${maybeTaggedErrorToString(this.error)}`;
+    }
+}
+const isTaggedError = (e) => {
+    if (e !== null && typeof e === "object") {
+        if ("kind" in e && "error" in e) {
+            return true;
+        }
+    }
+    return false;
+};
+const maybeTaggedErrorToString = (err) => {
+    if (isTaggedError(err)) {
+        if (err instanceof RichTaggedError) {
+            return err.toString();
+        }
+        return `${err.kind} - ${maybeTaggedErrorToString(err.error)}`;
+    }
+    if (typeof err === "symbol") {
+        return err.toString();
+    }
+    return `${err}`;
+};
+export function resultToString(res) {
+    if (res.isOk) {
+        return `OK: ${typeof res.ok === "symbol" ? res.ok.toString() : res.ok}`;
+    }
+    return `${res.details()}\nError: ${maybeTaggedErrorToString(res.error)}`;
+}
+/** An indication of two possible outcomes returned from a function. */
+export const Result = {
+    /** Create new [`Result`] with `Ok` status. */
+    ok: (ok) => {
+        check `${ok !== undefined} 'ok' type cannot be undefined.`;
+        return {
+            isOk: true,
+            isError: false,
+            ok,
+        };
+    },
+    /** Create new [`Result`] with `Error` status. */
+    error: (error, details) => {
+        check `${error !== undefined} 'Error' type cannot be undefined.`;
+        return {
+            isOk: false,
+            isError: true,
+            error,
+            details,
+        };
+    },
+    /** Create new [`Result`] with `Error` coming from a nested error type. */
+    taggedError: (enumMapping, kind, nested) => {
+        return Result.error(new RichTaggedError(kind, nested.error, enumMapping), nested.details);
+    },
+};

package/packages/core/utils/safe-alloc-uint8array.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_LENGTH = 2145386496;
+export declare function safeAllocUint8Array(length: number): Uint8Array;
+//# sourceMappingURL=safe-alloc-uint8array.d.ts.map

package/packages/core/utils/safe-alloc-uint8array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-alloc-uint8array.d.ts","sourceRoot":"","sources":["../../../../../packages/core/utils/safe-alloc-uint8array.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,aAAa,CAAC;AAErC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAM9D"}

package/packages/core/utils/safe-alloc-uint8array.js

@@ -0,0 +1,12 @@
+// about 2GB, the maximum ArrayBuffer length on Chrome confirmed by several sources:
+// - https://issues.chromium.org/issues/40055619
+// - https://stackoverflow.com/a/72124984
+// - https://onnxruntime.ai/docs/tutorials/web/large-models.html#maximum-size-of-arraybuffer
+export const MAX_LENGTH = 2145386496;
+export function safeAllocUint8Array(length) {
+    if (length > MAX_LENGTH) {
+        // biome-ignore lint/suspicious/noConsole: can't have a dependency on logger here
+        console.warn(`Trying to allocate ${length} bytes, which is greater than the maximum of ${MAX_LENGTH}.`);
+    }
+    return new Uint8Array(Math.min(MAX_LENGTH, length));
+}

package/packages/core/utils/safe-alloc-uint8array.test.d.ts

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

package/packages/core/utils/safe-alloc-uint8array.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-alloc-uint8array.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/utils/safe-alloc-uint8array.test.ts"],"names":[],"mappings":""}

package/packages/core/utils/safe-alloc-uint8array.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { MAX_LENGTH, safeAllocUint8Array } from "./safe-alloc-uint8array.js";
+describe("safeAllocUint8Array", () => {
+    it("should allocate a Uint8Array with the given length", () => {
+        const length = 1000;
+        const arr = safeAllocUint8Array(length);
+        assert.equal(length, arr.length);
+    });
+    it("should clamp the length to the maximum length", () => {
+        const length = MAX_LENGTH + 100;
+        const arr = safeAllocUint8Array(length);
+        assert.equal(MAX_LENGTH, arr.length);
+    });
+});

package/packages/core/utils/test.d.ts

@@ -0,0 +1,36 @@
+/**
+ * If some object has this property set, it can override how it's being compared
+ * using [`deepEqual`].
+ * The value under that symbol should be a function to be invoked by `deepEqual`.
+ * Returned values will then be further compared recursively.
+ */
+export declare const TEST_COMPARE_USING: unique symbol;
+/** Equality comparison options. */
+export type DeepEqualOptions = {
+    /** Initial context, i.e. name of the variable we are comparing. */
+    context?: string | string[];
+    /** A list of ignored paths (for instance `result.details`). */
+    ignore?: string[];
+    /**
+     * Optional shared errors collector.
+     * It can be used to run multiple assertions instead of failing on the first one.
+     */
+    errorsCollector?: ErrorsCollector;
+};
+/** Deeply compare `actual` and `expected` values. */
+export declare function deepEqual<T>(actual: T | undefined, expected: T | undefined, { context, errorsCollector, ignore }?: DeepEqualOptions): ErrorsCollector | undefined;
+/** Attempt to invoke assertions and catch any errors. */
+export declare class ErrorsCollector {
+    readonly errors: {
+        context: string[];
+        e: unknown;
+    }[];
+    private nested;
+    /** We are going into a nested context, so calling `exitOrThrow` will not throw. */
+    enter(): void;
+    /** Execute the closure and catch any errors that may occur. */
+    tryAndCatch(cb: () => void, context: string[]): void;
+    /** Exit the previously entered nested context or throw collected errors if we are in top-level context. */
+    exitOrThrow(): this;
+}
+//# sourceMappingURL=test.d.ts.map

package/packages/core/utils/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/utils/test.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,OAAO,MAAgC,CAAC;AAazE,mCAAmC;AACnC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,+DAA+D;IAC/D,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;OAGG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AAIF,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,CAAC,EACzB,MAAM,EAAE,CAAC,GAAG,SAAS,EACrB,QAAQ,EAAE,CAAC,GAAG,SAAS,EACvB,EAAE,OAAY,EAAE,eAAe,EAAE,MAAW,EAAE,GAAE,gBAAqB,+BAqJtE;AAOD,yDAAyD;AACzD,qBAAa,eAAe;IAC1B,QAAQ,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,CAAC,EAAE,OAAO,CAAA;KAAE,EAAE,CAAM;IAC1D,OAAO,CAAC,MAAM,CAAK;IAEnB,mFAAmF;IACnF,KAAK;IAIL,+DAA+D;IAC/D,WAAW,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE;IAQ7C,2GAA2G;IAC3G,WAAW;CAsCZ"}

package/packages/core/utils/test.js

@@ -0,0 +1,221 @@
+/**
+ * Utilities for tests.
+ */
+import assert from "node:assert";
+import { inspect } from "./debug.js";
+/**
+ * If some object has this property set, it can override how it's being compared
+ * using [`deepEqual`].
+ * The value under that symbol should be a function to be invoked by `deepEqual`.
+ * Returned values will then be further compared recursively.
+ */
+export const TEST_COMPARE_USING = Symbol("compare using");
+function callCompareFunction(object) {
+    if (object !== null && typeof object === "object" && TEST_COMPARE_USING in object) {
+        if (typeof object[TEST_COMPARE_USING] !== "function") {
+            throw new Error(`${String(TEST_COMPARE_USING)} of ${object} is not a function!`);
+        }
+        return object[TEST_COMPARE_USING]();
+    }
+    return object;
+}
+let oomWarningPrinted = false;
+/** Deeply compare `actual` and `expected` values. */
+export function deepEqual(actual, expected, { context = [], errorsCollector, ignore = [] } = {}) {
+    const ctx = Array.isArray(context) ? context : [context];
+    const errors = errorsCollector ?? new ErrorsCollector();
+    // ignore a field if it's on ignore list.
+    if (ignore.includes(ctx.join("."))) {
+        return;
+    }
+    errors.enter();
+    if (actual === null || expected === null || actual === undefined || expected === undefined) {
+        errors.tryAndCatch(() => {
+            /**
+             * There is a problem with memory in node 22.12.0+
+             *
+             * This workaround can be removed when this issue is resolved: https://github.com/nodejs/node/issues/57242
+             */
+            const [major, minor] = process.versions.node.split(".").map(Number);
+            const isOoMWorkaroundNeeded = major > 22 || (major === 22 && minor >= 12);
+            const message = isOoMWorkaroundNeeded ? new Error(`${actual} != ${expected}`) : undefined;
+            const actualDisp = actual === null || actual === undefined ? actual : `${inspect(actual)}`;
+            const expectedDisp = expected === null || expected === undefined ? expected : `${inspect(expected)}`;
+            try {
+                assert.strictEqual(actualDisp, expectedDisp, message);
+            }
+            catch (e) {
+                if (isOoMWorkaroundNeeded && !oomWarningPrinted) {
+                    // biome-ignore lint/suspicious/noConsole: warning
+                    console.warn([
+                        "Stacktrace may be crappy because of a problem in nodejs.",
+                        "Use older version than 22.12.0 or check this issue: https://github.com/nodejs/node/issues/57242",
+                        "Maybe we do not need it anymore",
+                    ].join("\n"));
+                    oomWarningPrinted = true;
+                }
+                throw e;
+            }
+        }, ctx);
+        return errors.exitOrThrow();
+    }
+    // special casing for customized comparison
+    if ((typeof actual === "object" && TEST_COMPARE_USING in actual) ||
+        (typeof expected === "object" && TEST_COMPARE_USING in expected)) {
+        deepEqual(callCompareFunction(actual), callCompareFunction(expected), {
+            context: ctx,
+            errorsCollector: errors,
+            ignore,
+        });
+        return errors.exitOrThrow();
+    }
+    if (isResult(actual) && isResult(expected)) {
+        if (actual.isOk && !expected.isOk) {
+            errors.tryAndCatch(() => {
+                throw new Error(`Got OK, expected ERROR: ${expected.error}: ${expected.details}`);
+            }, ctx);
+        }
+        if (!actual.isOk && expected.isOk) {
+            errors.tryAndCatch(() => {
+                throw new Error(`Expected OK, Got ERROR: ${actual.error}: ${actual.details}`);
+            }, ctx);
+        }
+        if (actual.isOk && expected.isOk) {
+            deepEqual(actual.ok, expected.ok, { context: ctx.concat(["ok"]), errorsCollector: errors, ignore });
+        }
+        if (actual.isError && expected.isError) {
+            deepEqual(actual.error, expected.error, { context: ctx.concat(["error"]), errorsCollector: errors, ignore });
+            deepEqual(actual.details(), expected.details(), {
+                context: ctx.concat(["details"]),
+                errorsCollector: errors,
+                // display details when error does not match
+                ignore: actual.error === expected.error ? ignore : [],
+            });
+        }
+        return errors.exitOrThrow();
+    }
+    if (Array.isArray(actual) && Array.isArray(expected)) {
+        errors.tryAndCatch(() => {
+            if (actual.length !== expected.length) {
+                throw new Error(`Invalid array length: ${actual.length} !== ${expected.length} ${ctx.join(".")}`);
+            }
+        }, ctx);
+        const len = Math.max(actual.length, expected.length);
+        for (let i = 0; i < len; i++) {
+            deepEqual(actual[i], expected[i], { context: ctx.concat([`[${i}]`]), errorsCollector: errors, ignore });
+        }
+        return errors.exitOrThrow();
+    }
+    // special casing for maps
+    if (actual instanceof Map && expected instanceof Map) {
+        const toArray = (input) => {
+            return Array.from(input.entries())
+                .map(([key, value]) => ({ key, value }))
+                .sort((a, b) => {
+                const aKey = `${a.key}`;
+                const bKey = `${b.key}`;
+                if (aKey < bKey) {
+                    return -1;
+                }
+                if (bKey < aKey) {
+                    return 1;
+                }
+                return 0;
+            });
+        };
+        deepEqual(toArray(actual), toArray(expected), {
+            context: ctx.concat(["[map]"]),
+            errorsCollector: errors,
+            ignore,
+        });
+        return errors.exitOrThrow();
+    }
+    if (typeof actual === "object" && typeof expected === "object") {
+        const actualKeys = Object.keys(actual);
+        const expectedKeys = Object.keys(expected);
+        actualKeys.sort();
+        expectedKeys.sort();
+        const allKeys = getAllKeysSorted(actualKeys, expectedKeys);
+        for (const key of allKeys) {
+            deepEqual(actual[key], expected[key], { context: ctx.concat([String(key)]), errorsCollector: errors, ignore });
+        }
+        deepEqual(actualKeys, expectedKeys, { context: ctx.concat(["[keys]"]), errorsCollector: errors, ignore });
+        return errors.exitOrThrow();
+    }
+    errors.tryAndCatch(() => {
+        // fallback
+        assert.strictEqual(actual, expected);
+    }, ctx);
+    return errors.exitOrThrow();
+}
+function getAllKeysSorted(a, b) {
+    const all = new Set(a.concat(b));
+    return Array.from(all).sort();
+}
+/** Attempt to invoke assertions and catch any errors. */
+export class ErrorsCollector {
+    errors = [];
+    nested = 0;
+    /** We are going into a nested context, so calling `exitOrThrow` will not throw. */
+    enter() {
+        this.nested += 1;
+    }
+    /** Execute the closure and catch any errors that may occur. */
+    tryAndCatch(cb, context) {
+        try {
+            cb();
+        }
+        catch (e) {
+            this.errors.push({ context, e });
+        }
+    }
+    /** Exit the previously entered nested context or throw collected errors if we are in top-level context. */
+    exitOrThrow() {
+        this.nested -= 1;
+        // don't throw any errors if we are just collecting errors from a nested context.
+        if (this.nested > 0) {
+            return this;
+        }
+        if (this.errors.length === 0) {
+            return this;
+        }
+        const addContext = (e, context) => {
+            const preamble = `❌  DATA MISMATCH @ ${context.join(".")}\n`;
+            if (e instanceof Error) {
+                if (context.length > 0) {
+                    e.stack = `${preamble}${e.stack}`;
+                }
+                return e;
+            }
+            return new Error(`${preamble}${e}`);
+        };
+        if (this.errors.length === 1) {
+            const { context, e } = this.errors[0];
+            throw addContext(e, context);
+        }
+        const noOfErrors = this.errors.length;
+        const stack = this.errors
+            .map(({ context, e }) => addContext(e, context))
+            .map((e, idx) => `===== ${idx + 1}/${noOfErrors} =====\n ${idx !== 0 ? trimStack(e.stack) : e.stack}`)
+            .join("\n");
+        const e = new Error();
+        e.stack = stack;
+        throw e;
+    }
+}
+function trimStack(stack = "") {
+    const firstAt = /([\s\S]+?)\s+at /;
+    const res = stack.match(firstAt);
+    if (res !== null) {
+        return res[1];
+    }
+    return stack;
+}
+function isResult(x) {
+    return (x !== null &&
+        typeof x === "object" &&
+        "isOk" in x &&
+        "isError" in x &&
+        typeof x.isOk === "boolean" &&
+        typeof x.isError === "boolean");
+}

package/packages/extensions/ipc/index.d.ts

@@ -0,0 +1,28 @@
+import { type BlockView, type Header, type HeaderHash, type HeaderView, type StateRootHash, type TimeSlot } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import { v1 } from "#@typeberry/fuzz-proto";
+import { type WithHash } from "#@typeberry/hash";
+import { Listener } from "#@typeberry/listener";
+import { StateEntries } from "#@typeberry/state-merkleization";
+import { Result } from "#@typeberry/utils";
+export interface ExtensionApi {
+    nodeName: string;
+    chainSpec: ChainSpec;
+    bestHeader: Listener<WithHash<HeaderHash, HeaderView>>;
+}
+export declare function startExtension(api: ExtensionApi): () => void;
+export declare enum FuzzVersion {
+    V1 = 1
+}
+export interface FuzzTargetApi {
+    nodeName: string;
+    nodeVersion: v1.Version;
+    gpVersion: v1.Version;
+    chainSpec: ChainSpec;
+    importBlock: (block: BlockView) => Promise<Result<StateRootHash, string>>;
+    resetState: (header: Header, state: StateEntries, ancestry: [HeaderHash, TimeSlot][]) => Promise<StateRootHash>;
+    getPostSerializedState: (hash: HeaderHash) => Promise<StateEntries | null>;
+    getBestStateRootHash(): Promise<StateRootHash>;
+}
+export declare function startFuzzTarget(version: FuzzVersion, socket: string | null, api: FuzzTargetApi): () => void;
+//# sourceMappingURL=index.d.ts.map

package/packages/extensions/ipc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/extensions/ipc/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,MAAM,EACX,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAC3C,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAG/C,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAe,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAIvD,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;CACxD;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,cAE/C;AAED,oBAAY,WAAW;IACrB,EAAE,IAAI;CACP;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,EAAE,CAAC,OAAO,CAAC;IACxB,SAAS,EAAE,EAAE,CAAC,OAAO,CAAC;IACtB,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1E,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAE,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;IAChH,sBAAsB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAC3E,oBAAoB,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;CAChD;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,aAAa,cAQ9F"}

package/packages/extensions/ipc/index.js

@@ -0,0 +1,94 @@
+import { tryAsTimeSlot, } from "#@typeberry/block";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { v1 } from "#@typeberry/fuzz-proto";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { ce129, up0 } from "#@typeberry/jamnp-s";
+import { Listener } from "#@typeberry/listener";
+import { Logger } from "#@typeberry/logger";
+import { tryAsU32 } from "#@typeberry/numbers";
+import { StateEntries } from "#@typeberry/state-merkleization";
+import { assertNever, Result } from "#@typeberry/utils";
+import { startJamnpIpcServer } from "./jamnp/server.js";
+import { startIpcServer } from "./server.js";
+export function startExtension(api) {
+    return startJamnpExtension(api);
+}
+export var FuzzVersion;
+(function (FuzzVersion) {
+    FuzzVersion[FuzzVersion["V1"] = 1] = "V1";
+})(FuzzVersion || (FuzzVersion = {}));
+export function startFuzzTarget(version, socket, api) {
+    const socketName = socket ?? "jam_target.sock";
+    if (version === FuzzVersion.V1) {
+        return startIpcServer(socketName, (sender) => new v1.FuzzTarget(new FuzzHandler(api), sender, api.chainSpec));
+    }
+    assertNever(version);
+}
+function startJamnpExtension(api) {
+    const announcements = new Listener();
+    let bestBlock = null;
+    api.bestHeader.on((headerWithHash) => {
+        const header = headerWithHash.data.materialize();
+        const hash = headerWithHash.hash;
+        const final = up0.HashAndSlot.create({ hash, slot: header.timeSlotIndex });
+        bestBlock = final;
+        announcements.emit(up0.Announcement.create({ header, final }));
+    });
+    const getHandshake = () => {
+        const final = bestBlock ?? up0.HashAndSlot.create({ hash: Bytes.zero(HASH_SIZE).asOpaque(), slot: tryAsTimeSlot(0) });
+        return up0.Handshake.create({ final, leafs: [] });
+    };
+    const getBoundaryNodes = () => {
+        return [];
+    };
+    const getKeyValuePairs = (_hash, startKey) => {
+        const value = BytesBlob.blobFromNumbers([255, 255, 0, 0]);
+        return [new ce129.KeyValuePair(startKey, value)];
+    };
+    return startJamnpIpcServer(api.nodeName, api.chainSpec, announcements, getHandshake, getBoundaryNodes, getKeyValuePairs);
+}
+const logger = Logger.new(import.meta.filename, "ext-ipc");
+class FuzzHandler {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    async getSerializedState(value) {
+        const state = await this.api.getPostSerializedState(value);
+        if (state === null) {
+            logger.warn `Fuzzer requested non-existing state for: ${value}`;
+            return [];
+        }
+        return Array.from(state).map(([key, value]) => {
+            return {
+                key,
+                value,
+            };
+        });
+    }
+    initialize(value) {
+        const { keyvals, header, ancestry } = value;
+        const entries = StateEntries.fromEntriesUnsafe(keyvals.map(({ key, value }) => [key.asOpaque(), value]));
+        const root = this.api.resetState(header, entries, ancestry.map((x) => [x.headerHash, x.slot]));
+        return root;
+    }
+    async importBlock(value) {
+        const res = await this.api.importBlock(value);
+        if (res.isOk) {
+            return res;
+        }
+        logger.log `Rejecting block with error: ${res.error}. ${res.details()}`;
+        return Result.error(v1.ErrorMessage.create({ message: res.error }), res.details);
+    }
+    async getPeerInfo(value) {
+        logger.info `Fuzzer ${value} connected.`;
+        return v1.PeerInfo.create({
+            name: this.api.nodeName,
+            appVersion: this.api.nodeVersion,
+            jamVersion: this.api.gpVersion,
+            fuzzVersion: value.fuzzVersion,
+            // Safe to convert: Features are small enum values that fit in U32 range
+            features: tryAsU32(v1.Features.Ancestry | v1.Features.Fork),
+        });
+    }
+}

package/packages/extensions/ipc/jamnp/handler.d.ts

@@ -0,0 +1,42 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import type { IpcHandler } from "#@typeberry/fuzz-proto";
+import type { StreamHandler, StreamId, StreamKindOf, StreamMessageSender } from "#@typeberry/jamnp-s";
+import type { IpcSender } from "../server.js";
+import { NewStream } from "./stream.js";
+export type ResponseHandler = (err: Error | null, response?: BytesBlob) => void;
+export declare class JamnpIpcHandler implements IpcHandler {
+    private readonly sender;
+    /** already initiated streams */
+    private readonly streams;
+    /** streams awaiting confirmation from the other side. */
+    private readonly pendingStreams;
+    /** a collection of handlers for particular stream kind */
+    private readonly streamHandlers;
+    /** termination promise + resolvers */
+    private readonly onEnd;
+    constructor(sender: IpcSender);
+    /** Register stream handlers. */
+    registerStreamHandlers(...handlers: StreamHandler[]): void;
+    /** Re-use an existing stream of given kind if present. */
+    withStreamOfKind<THandler extends StreamHandler>(streamKind: StreamKindOf<THandler>, work: (handler: THandler, sender: EnvelopeSender) => void): void;
+    /** Open a new stream of given kind. */
+    withNewStream<THandler extends StreamHandler>(kind: StreamKindOf<THandler>, work: (handler: THandler, sender: EnvelopeSender) => void): void;
+    /** Handle incoming message on that socket. */
+    onSocketMessage(msg: Uint8Array): Promise<void>;
+    /** Notify about termination of the underlying socket. */
+    onClose({ error }: {
+        error?: Error;
+    }): void;
+    /** Wait for the handler to be finished either via close or error. */
+    waitForEnd(): Promise<void>;
+}
+declare class EnvelopeSender implements StreamMessageSender {
+    readonly streamId: StreamId;
+    private readonly sender;
+    constructor(streamId: StreamId, sender: IpcSender);
+    open(newStream: NewStream): void;
+    bufferAndSend(msg: BytesBlob): boolean;
+    close(): void;
+}
+export {};
+//# sourceMappingURL=handler.d.ts.map

package/packages/extensions/ipc/jamnp/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../../../../../packages/extensions/ipc/jamnp/handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAc,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAEjH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAsC,MAAM,aAAa,CAAC;AAE5E,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,IAAI,CAAC;AAWhF,qBAAa,eAAgB,YAAW,UAAU;IAUpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IATnC,gCAAgC;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2C;IACnE,yDAAyD;IACzD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqC;IACpE,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;IAC5E,sCAAsC;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;gBAED,MAAM,EAAE,SAAS;IAe9C,gCAAgC;IAChC,sBAAsB,CAAC,GAAG,QAAQ,EAAE,aAAa,EAAE;IAMnD,0DAA0D;IAC1D,gBAAgB,CAAC,QAAQ,SAAS,aAAa,EAC7C,UAAU,EAAE,YAAY,CAAC,QAAQ,CAAC,EAClC,IAAI,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,KAAK,IAAI,GACxD,IAAI;IAWP,uCAAuC;IACvC,aAAa,CAAC,QAAQ,SAAS,aAAa,EAC1C,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,EAC5B,IAAI,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,KAAK,IAAI,GACxD,IAAI;IA2BP,8CAA8C;IACxC,eAAe,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAkDrD,yDAAyD;IACzD,OAAO,CAAC,EAAE,KAAK,EAAE,EAAE;QAAE,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE;IAiBpC,qEAAqE;IACrE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAI5B;AAED,cAAM,cAAe,YAAW,mBAAmB;aAE/B,QAAQ,EAAE,QAAQ;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADP,QAAQ,EAAE,QAAQ,EACjB,MAAM,EAAE,SAAS;IAGpC,IAAI,CAAC,SAAS,EAAE,SAAS;IAUzB,aAAa,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO;IAWtC,KAAK,IAAI,IAAI;CAYd"}