@typeberry/lib 0.10.0 → 0.11.0-411c828

package/packages/jam/rpc/src/handlers/typeberry/refine-work-package.js

@@ -0,0 +1,68 @@
+import { tryAsCoreIndex } from "#@typeberry/block";
+import { WorkPackage } from "#@typeberry/block/work-package.js";
+import { WorkReport } from "#@typeberry/block/work-report.js";
+import { BytesBlob } from "#@typeberry/bytes";
+import { Decoder, Encoder } from "#@typeberry/codec";
+import { asKnownSize } from "#@typeberry/collections";
+import { WithHash } from "#@typeberry/hash";
+import { InCore } from "#@typeberry/in-core";
+import { Logger } from "#@typeberry/logger";
+import { RpcError, RpcErrorCode } from "#@typeberry/rpc-validation";
+const logger = Logger.new(import.meta.filename, "rpc");
+/**
+ * Simulate package refinement.
+ *
+ * https://github.com/polkadot-fellows/JIPs/blob/772ce90bfc33f4e1de9de3bbe10c561753cc0d41/JIP-2.md#submitworkpackagecore-package-extrinsics
+ */
+export const refineWorkPackage = async ([coreIndexRaw, workPackageBytes, extrinsicsRaw], { db, chainSpec, pvmBackend, blake2b }) => {
+    const coreIndex = tryAsCoreIndex(coreIndexRaw);
+    // Decode the work package
+    const workPackageBlob = BytesBlob.blobFrom(workPackageBytes);
+    const workPackage = Decoder.decodeObject(WorkPackage.Codec, workPackageBlob, chainSpec);
+    // Hash the work package
+    const workPackageHash = blake2b.hashBytes(workPackageBlob).asOpaque();
+    const workPackageAndHash = WithHash.new(workPackageHash, workPackage);
+    logger.info `Refining work package ${workPackageHash} to core ${coreIndex} with ${workPackage.items.length} items`;
+    // Convert extrinsics to the expected format (per work item)
+    // For now, we assume the extrinsics are provided in a flat array and need to be
+    // distributed to work items according to their extrinsic specs
+    const extrinsics = distributeExtrinsics(workPackage, extrinsicsRaw);
+    // For now, we don't have any imports - this would need to be fetched from DA layer
+    // TODO [ToDr] Fetch imported segments from DA layer based on work items' importSegments
+    const emptyImports = workPackage.items.map(() => []);
+    const imports = asKnownSize(emptyImports);
+    // Create in-core instance and process the work package
+    const inCore = InCore.new(chainSpec, db.states, pvmBackend, blake2b);
+    const result = await inCore.refine(workPackageAndHash, coreIndex, imports, extrinsics);
+    if (result.isError) {
+        throw new RpcError(RpcErrorCode.Other, `Refine error: ${result.details()}`);
+    }
+    logger.info `Work package ${workPackageHash} refined successfully on core ${coreIndex}`;
+    // encode report as response
+    const report = Encoder.encodeObject(WorkReport.Codec, result.ok.report, chainSpec);
+    // And concatenated all exports
+    const exports = BytesBlob.blobFromParts(result.ok.exports.flat().map((segment) => segment.raw));
+    return {
+        report: report.raw,
+        exports: exports.raw,
+    };
+};
+/**
+ * Distribute the flat array of extrinsics to work items based on their extrinsic specs.
+ */
+function distributeExtrinsics(workPackage, extrinsicsRaw) {
+    const result = [];
+    let extrinsicIndex = 0;
+    for (const item of workPackage.items) {
+        const itemExtrinsics = [];
+        for (let i = 0; i < item.extrinsic.length; i++) {
+            if (extrinsicIndex >= extrinsicsRaw.length) {
+                throw new RpcError(RpcErrorCode.Other, `Not enough extrinsics provided. Expected at least ${extrinsicIndex + 1}, got ${extrinsicsRaw.length}`);
+            }
+            itemExtrinsics.push(BytesBlob.blobFrom(extrinsicsRaw[extrinsicIndex]));
+            extrinsicIndex++;
+        }
+        result.push(itemExtrinsics);
+    }
+    return asKnownSize(result);
+}

package/packages/jam/rpc/src/handlers/unsubscribe.d.ts

@@ -0,0 +1,4 @@
+import type { GenericHandler, validation } from "#@typeberry/rpc-validation";
+import type z from "zod";
+export declare const unsubscribe: GenericHandler<z.infer<typeof validation.unsubscribeSchema.input>, z.infer<typeof validation.unsubscribeSchema.output>>;
+//# sourceMappingURL=unsubscribe.d.ts.map

package/packages/jam/rpc/src/handlers/unsubscribe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsubscribe.d.ts","sourceRoot":"","sources":["../../../../../../../packages/jam/rpc/src/handlers/unsubscribe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,WAAW,EAAE,cAAc,CACtC,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAClD,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAGpD,CAAC"}

package/packages/jam/rpc/src/handlers/unsubscribe.js

@@ -0,0 +1,3 @@
+export const unsubscribe = async ([id], { subscription }) => {
+    return subscription.unsubscribe(id);
+};

package/packages/jam/rpc/src/handlers.d.ts

@@ -0,0 +1,3 @@
+import type { HandlerMap } from "#@typeberry/rpc-validation";
+export declare const handlers: HandlerMap;
+//# sourceMappingURL=handlers.d.ts.map

package/packages/jam/rpc/src/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/rpc/src/handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAuB5D,eAAO,MAAM,QAAQ,EAAE,UAsCtB,CAAC"}

package/packages/jam/rpc/src/handlers.js

@@ -0,0 +1,60 @@
+import { bestBlock } from "./handlers/best-block.js";
+import { finalizedBlock } from "./handlers/finalized-block.js";
+import { listServices } from "./handlers/list-services.js";
+import { notImplemented } from "./handlers/not-implemented.js";
+import { parameters } from "./handlers/parameters.js";
+import { parent } from "./handlers/parent.js";
+import { serviceData } from "./handlers/service-data.js";
+import { servicePreimage } from "./handlers/service-preimage.js";
+import { serviceRequest } from "./handlers/service-request.js";
+import { serviceValue } from "./handlers/service-value.js";
+import { stateRoot } from "./handlers/state-root.js";
+import { statistics } from "./handlers/statistics.js";
+import { subscribeBestBlock } from "./handlers/subscribe-best-block.js";
+import { subscribeFinalizedBlock } from "./handlers/subscribe-finalized-block.js";
+import { subscribeServiceData } from "./handlers/subscribe-service-data.js";
+import { subscribeServicePreimage } from "./handlers/subscribe-service-preimage.js";
+import { subscribeServiceRequest } from "./handlers/subscribe-service-request.js";
+import { subscribeServiceValue } from "./handlers/subscribe-service-value.js";
+import { subscribeStatistics } from "./handlers/subscribe-statistics.js";
+import { refineWorkPackage } from "./handlers/typeberry/refine-work-package.js";
+import { unsubscribe } from "./handlers/unsubscribe.js";
+export const handlers = {
+    typeberry_refineWorkPackage: refineWorkPackage,
+    beefyRoot: notImplemented,
+    bestBlock,
+    fetchSegments: notImplemented,
+    fetchWorkPackageSegments: notImplemented,
+    finalizedBlock,
+    listServices,
+    parameters,
+    parent,
+    serviceData,
+    servicePreimage,
+    serviceRequest,
+    serviceValue,
+    stateRoot,
+    statistics,
+    submitPreimage: notImplemented,
+    submitWorkPackage: notImplemented,
+    submitWorkPackageBundle: notImplemented,
+    subscribeBestBlock,
+    subscribeFinalizedBlock,
+    subscribeServiceData,
+    subscribeServicePreimage,
+    subscribeServiceRequest,
+    subscribeServiceValue,
+    subscribeStatistics,
+    subscribeSyncStatus: notImplemented,
+    subscribeWorkPackageStatus: notImplemented,
+    syncState: notImplemented,
+    unsubscribeBestBlock: unsubscribe,
+    unsubscribeFinalizedBlock: unsubscribe,
+    unsubscribeServiceData: unsubscribe,
+    unsubscribeServicePreimage: unsubscribe,
+    unsubscribeServiceRequest: unsubscribe,
+    unsubscribeServiceValue: unsubscribe,
+    unsubscribeStatistics: unsubscribe,
+    workPackageStatus: notImplemented,
+    workReport: notImplemented,
+};

package/packages/jam/rpc/src/server.d.ts

@@ -0,0 +1,31 @@
+import type { ChainSpec, PvmBackend } from "#@typeberry/config";
+import type { BlocksDb, RootDb, SerializedStatesDb } from "#@typeberry/database";
+import type { Blake2b } from "#@typeberry/hash";
+import { Logger } from "#@typeberry/logger";
+import { type GenericHandler, type HandlerMap, type SchemaMap } from "#@typeberry/rpc-validation";
+import type { WebSocket } from "ws";
+import type z from "zod";
+export declare class RpcServer {
+    private readonly rootDb;
+    private readonly chainSpec;
+    private readonly blake2b;
+    private readonly pvmBackend;
+    private readonly handlers;
+    private readonly schemas;
+    private readonly wss;
+    private readonly blocks;
+    private readonly states;
+    private readonly subscriptionManager;
+    private readonly logger;
+    static new(port: number, rootDb: RootDb<BlocksDb, SerializedStatesDb>, chainSpec: ChainSpec, blake2b: Blake2b, pvmBackend: PvmBackend, handlers: HandlerMap, schemas: SchemaMap): RpcServer;
+    private constructor();
+    private setupWebSocket;
+    private handleRequest;
+    private fulfillRequest;
+    private validateCall;
+    callHandler<I, O>(handler: GenericHandler<I, O>, validatedParams: I, outputSchema: z.ZodType<O>, ws: WebSocket): Promise<unknown>;
+    getLogger(): Logger;
+    getHandlers(): HandlerMap;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=server.d.ts.map

package/packages/jam/rpc/src/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/rpc/src/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAEL,KAAK,cAAc,EAGnB,KAAK,UAAU,EAWf,KAAK,SAAS,EAEf,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAEpC,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAqBzB,qBAAa,SAAS;IAqBlB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAzB1B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAsB;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC,MAAM,CAAC,GAAG,CACR,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,kBAAkB,CAAC,EAC5C,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,SAAS;IAKpB,OAAO;IAoBP,OAAO,CAAC,cAAc;YA+DR,aAAa;YAiCb,cAAc;IAY5B,OAAO,CAAC,YAAY;IASd,WAAW,CAAC,CAAC,EAAE,CAAC,EACpB,OAAO,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAC7B,eAAe,EAAE,CAAC,EAClB,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAC1B,EAAE,EAAE,SAAS,GACZ,OAAO,CAAC,OAAO,CAAC;IAiBnB,SAAS,IAAI,MAAM;IAKnB,WAAW,IAAI,UAAU;IAInB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAW7B"}

package/packages/jam/rpc/src/server.js

@@ -0,0 +1,179 @@
+import { Logger } from "#@typeberry/logger";
+import { JSON_RPC_VERSION, RpcError, validation, } from "#@typeberry/rpc-validation";
+import { WebSocketServer } from "ws";
+import { SubscriptionManager } from "./subscription-manager.js";
+const PING_INTERVAL_MS = 30000;
+function createErrorResponse(error, id) {
+    return {
+        jsonrpc: JSON_RPC_VERSION,
+        error: {
+            code: error.code,
+            message: error.message,
+            data: error.data,
+        },
+        id,
+    };
+}
+function createParamsParseErrorMessage(error) {
+    return `Invalid params:\n${error.issues.map((issue) => `[${issue.path.join(".")}] ${issue.message}`).join(",\n")}`;
+}
+export class RpcServer {
+    rootDb;
+    chainSpec;
+    blake2b;
+    pvmBackend;
+    handlers;
+    schemas;
+    wss;
+    blocks;
+    states;
+    subscriptionManager;
+    logger;
+    static new(port, rootDb, chainSpec, blake2b, pvmBackend, handlers, schemas) {
+        return new RpcServer(port, rootDb, chainSpec, blake2b, pvmBackend, handlers, schemas);
+    }
+    constructor(port, rootDb, chainSpec, blake2b, pvmBackend, handlers, schemas) {
+        this.rootDb = rootDb;
+        this.chainSpec = chainSpec;
+        this.blake2b = blake2b;
+        this.pvmBackend = pvmBackend;
+        this.handlers = handlers;
+        this.schemas = schemas;
+        this.logger = Logger.new(import.meta.filename, "rpc");
+        this.blocks = this.rootDb.getBlocksDb();
+        this.states = this.rootDb.getStatesDb();
+        this.wss = new WebSocketServer({ port });
+        this.setupWebSocket();
+        this.subscriptionManager = SubscriptionManager.new(this.callHandler.bind(this));
+    }
+    setupWebSocket() {
+        this.wss.on("error", (error) => {
+            this.logger.error `Server error: ${error}`;
+        });
+        this.wss.on("listening", () => {
+            this.logger.info `Server listening on port ${this.wss.options.port}`;
+        });
+        this.wss.on("connection", (ws) => {
+            let isAlive = true;
+            ws.on("pong", () => {
+                isAlive = true;
+            });
+            const pingInterval = setInterval(() => {
+                if (!isAlive) {
+                    ws.terminate();
+                }
+                isAlive = false;
+                ws.ping();
+                this.logger.info `Pinging client`;
+            }, PING_INTERVAL_MS);
+            ws.on("close", () => {
+                clearInterval(pingInterval);
+            });
+            ws.on("message", async (data) => {
+                let rawRequest;
+                try {
+                    rawRequest = JSON.parse(data);
+                }
+                catch {
+                    ws.send(JSON.stringify(createErrorResponse(new RpcError(-32700, "Parse error"), null)));
+                    return;
+                }
+                if (Array.isArray(rawRequest)) {
+                    if (rawRequest.length === 0) {
+                        ws.send(JSON.stringify(createErrorResponse(new RpcError(-32600, "Array must contain requests."), null)));
+                        return;
+                    }
+                    const responses = (await Promise.all(rawRequest.map((request) => this.handleRequest(request, ws)))).filter((response) => response !== null);
+                    if (responses.length > 0) {
+                        ws.send(JSON.stringify(responses));
+                    }
+                    return;
+                }
+                const response = await this.handleRequest(rawRequest, ws);
+                if (response !== null) {
+                    ws.send(JSON.stringify(response));
+                }
+            });
+        });
+    }
+    async handleRequest(request, ws) {
+        const requestParseResult = validation.jsonRpcRequest.safeParse(request);
+        if (requestParseResult.success === true) {
+            try {
+                return {
+                    jsonrpc: JSON_RPC_VERSION,
+                    result: await this.fulfillRequest(requestParseResult.data, ws),
+                    id: requestParseResult.data.id,
+                };
+            }
+            catch (error) {
+                const rpcError = error instanceof RpcError
+                    ? error
+                    : new RpcError(-32603, error instanceof Error ? error.message : "Internal error");
+                return createErrorResponse(rpcError, requestParseResult.data.id);
+            }
+        }
+        const notificationParseResult = validation.jsonRpcNotification.safeParse(request);
+        if (notificationParseResult.success === true) {
+            try {
+                await this.fulfillRequest(notificationParseResult.data, ws);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : "Unknown error";
+                this.logger.error `Notification ${JSON.stringify(notificationParseResult.data)} caused an error: ${msg}`;
+            }
+            return null;
+        }
+        return createErrorResponse(new RpcError(-32600, `Invalid request: ${JSON.stringify(request)}`), null);
+    }
+    async fulfillRequest(request, ws) {
+        const { method, params } = request;
+        if (!(method in this.schemas)) {
+            throw new RpcError(-32601, `Method not found: ${method}`);
+        }
+        const methodName = method;
+        const handler = this.handlers[methodName];
+        const validatedParams = this.validateCall(methodName, params ?? []);
+        return this.callHandler(handler, validatedParams, this.schemas[methodName].output, ws);
+    }
+    validateCall(method, params) {
+        const { input } = this.schemas[method];
+        const parseResult = input.safeParse(params);
+        if (parseResult.error !== undefined) {
+            throw new RpcError(-32602, createParamsParseErrorMessage(parseResult.error));
+        }
+        return parseResult.data;
+    }
+    async callHandler(handler, validatedParams, outputSchema, ws) {
+        const db = {
+            blocks: this.blocks,
+            states: this.states,
+        };
+        const context = {
+            db,
+            chainSpec: this.chainSpec,
+            pvmBackend: this.pvmBackend,
+            blake2b: this.blake2b,
+            subscription: this.subscriptionManager.getHandlerApi(ws),
+        };
+        return outputSchema.encode(await handler(validatedParams, context));
+    }
+    getLogger() {
+        return this.logger;
+    }
+    // for testing only
+    getHandlers() {
+        return this.handlers;
+    }
+    async close() {
+        this.logger.info `Cleaning up...`;
+        await new Promise((resolve) => {
+            for (const ws of this.wss.clients) {
+                ws.terminate();
+            }
+            this.wss.close(() => resolve());
+        });
+        this.subscriptionManager.destroy();
+        await this.rootDb.close();
+    }
+}

package/packages/jam/rpc/src/subscription-manager.d.ts

@@ -0,0 +1,20 @@
+import { type GenericHandler, type SubscriptionHandlerApi } from "#@typeberry/rpc-validation";
+import type WebSocket from "ws";
+import type z from "zod";
+type CallHandler = <I, O>(handler: GenericHandler<I, O>, validatedParams: I, outputSchema: z.ZodType<O>, ws: WebSocket) => Promise<unknown>;
+export declare class SubscriptionManager {
+    private callHandler;
+    private subscriptions;
+    private lastResults;
+    private pollInterval;
+    private nextId;
+    static new(callHandler: CallHandler): SubscriptionManager;
+    private constructor();
+    private pollSubscriptions;
+    private subscribe;
+    private unsubscribe;
+    getHandlerApi(ws: WebSocket): SubscriptionHandlerApi;
+    destroy(): void;
+}
+export {};
+//# sourceMappingURL=subscription-manager.d.ts.map

package/packages/jam/rpc/src/subscription-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription-manager.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/rpc/src/subscription-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAOnB,KAAK,sBAAsB,EAE5B,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,SAAS,MAAM,IAAI,CAAC;AAChC,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAIzB,KAAK,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC,EACtB,OAAO,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAC7B,eAAe,EAAE,CAAC,EAClB,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAC1B,EAAE,EAAE,SAAS,KACV,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB,qBAAa,mBAAmB;IAWV,OAAO,CAAC,WAAW;IATvC,OAAO,CAAC,aAAa,CAA8C;IACnE,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,MAAM,CAAS;IAEvB,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,WAAW;IAInC,OAAO;YAOO,iBAAiB;IAqC/B,OAAO,CAAC,SAAS;IAqBjB,OAAO,CAAC,WAAW;IAQnB,aAAa,CAAC,EAAE,EAAE,SAAS,GAAG,sBAAsB;IAOpD,OAAO,IAAI,IAAI;CAGhB"}

package/packages/jam/rpc/src/subscription-manager.js

@@ -0,0 +1,74 @@
+import { JSON_RPC_VERSION, RpcError, RpcErrorCode, } from "#@typeberry/rpc-validation";
+const POLL_INTERVAL_MS = 1000;
+export class SubscriptionManager {
+    callHandler;
+    // biome-ignore lint/suspicious/noExplicitAny: subscriptions must accept generic handlers
+    subscriptions;
+    lastResults;
+    pollInterval;
+    nextId;
+    static new(callHandler) {
+        return new SubscriptionManager(callHandler);
+    }
+    constructor(callHandler) {
+        this.callHandler = callHandler;
+        this.subscriptions = new Map();
+        this.lastResults = new Map();
+        this.pollInterval = setInterval(() => this.pollSubscriptions(), POLL_INTERVAL_MS);
+        this.nextId = 0;
+    }
+    async pollSubscriptions() {
+        for (const [subscriptionId, subscription] of this.subscriptions) {
+            const lastResult = this.lastResults.get(subscriptionId);
+            let notificationString;
+            try {
+                const result = await this.callHandler(subscription.handler, subscription.params, subscription.outputSchema, subscription.ws);
+                const notification = {
+                    jsonrpc: JSON_RPC_VERSION,
+                    method: subscription.method,
+                    params: { subscriptionId, result },
+                };
+                notificationString = JSON.stringify(notification);
+            }
+            catch (error) {
+                const notification = {
+                    jsonrpc: JSON_RPC_VERSION,
+                    method: subscription.method,
+                    params: { subscriptionId, error: `${error}` },
+                };
+                notificationString = JSON.stringify(notification);
+            }
+            if (notificationString !== lastResult) {
+                subscription.ws.send(notificationString);
+                this.lastResults.set(subscriptionId, notificationString);
+            }
+        }
+    }
+    subscribe(ws, method, handler, outputSchema, params) {
+        const id = this.nextId++;
+        const idHex = `0x${id.toString(16)}`;
+        this.subscriptions.set(idHex, { ws, method, handler, outputSchema, params });
+        ws.on("close", () => {
+            if (this.subscriptions.has(idHex)) {
+                this.unsubscribe(ws, idHex);
+            }
+        });
+        return idHex;
+    }
+    unsubscribe(ws, id) {
+        if (this.subscriptions.get(id)?.ws !== ws) {
+            throw new RpcError(RpcErrorCode.Other, "Subscription not found.");
+        }
+        this.lastResults.delete(id);
+        return this.subscriptions.delete(id);
+    }
+    getHandlerApi(ws) {
+        return {
+            subscribe: (method, handler, outputSchema, params) => this.subscribe(ws, method, handler, outputSchema, params),
+            unsubscribe: (id) => this.unsubscribe(ws, id),
+        };
+    }
+    destroy() {
+        clearInterval(this.pollInterval);
+    }
+}

package/packages/jam/rpc/test/e2e-server.d.ts

@@ -0,0 +1,3 @@
+import { RpcServer } from "../src/server.js";
+export declare function startTestRpcServer(configPath: string, port?: number): Promise<RpcServer>;
+//# sourceMappingURL=e2e-server.d.ts.map

package/packages/jam/rpc/test/e2e-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e-server.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/rpc/test/e2e-server.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,SAAe,sBA0B/E"}

package/packages/jam/rpc/test/e2e-server.js

@@ -0,0 +1,30 @@
+import { PvmBackend } from "#@typeberry/config";
+import { loadConfig, NODE_DEFAULTS } from "#@typeberry/config-node";
+import { Blake2b } from "#@typeberry/hash";
+import { getChainSpec, getDatabasePath } from "#@typeberry/node";
+import { validation } from "#@typeberry/rpc-validation";
+import { workspacePathFix } from "#@typeberry/utils";
+import { FjallWorkerConfig } from "#@typeberry/workers-api-node";
+import { handlers } from "../src/handlers.js";
+import { RpcServer } from "../src/server.js";
+const DEFAULT_PORT = 19800;
+const withRelPath = workspacePathFix(`${import.meta.dirname}/../../../..`);
+export async function startTestRpcServer(configPath, port = DEFAULT_PORT) {
+    const blake2b = await Blake2b.createHasher();
+    const nodeName = NODE_DEFAULTS.name;
+    const nodeConfig = loadConfig([configPath], withRelPath);
+    const spec = getChainSpec(nodeConfig.flavor);
+    if (nodeConfig.databaseBasePath === undefined) {
+        throw new Error("RPC server requires a persistent database path.");
+    }
+    const { dbPath } = getDatabasePath(blake2b, nodeName, nodeConfig.chainSpec.genesisHeader, withRelPath(nodeConfig.databaseBasePath));
+    const dbConfigParams = {
+        nodeName,
+        chainSpec: spec,
+        workerParams: undefined,
+        dbPath,
+        blake2b,
+    };
+    const rootDb = await FjallWorkerConfig.new(dbConfigParams).openDatabase({ readonly: true });
+    return RpcServer.new(port, rootDb, spec, blake2b, PvmBackend.Ananas, handlers, validation.schemas);
+}

package/packages/jam/rpc/test/e2e-setup.d.ts

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

package/packages/jam/rpc/test/e2e-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e-setup.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/rpc/test/e2e-setup.ts"],"names":[],"mappings":""}

package/packages/jam/rpc/test/e2e-setup.js

@@ -0,0 +1,126 @@
+// biome-ignore-all lint/suspicious/noConsole: bin file
+import { loadConfig, NODE_DEFAULTS } from "#@typeberry/config-node";
+import { Level, Logger } from "#@typeberry/logger";
+import { importBlocks, JamConfig, main as node } from "#@typeberry/node";
+import { workspacePathFix } from "#@typeberry/utils";
+Logger.configureAll(process.env.JAM_LOG ?? "", Level.LOG);
+const withRelPath = workspacePathFix(`${import.meta.dirname}/../../../..`);
+async function main() {
+    const nodeConfig = loadConfig([`${import.meta.dirname}/e2e.config.json`], withRelPath);
+    const jamConfig = JamConfig.new({
+        nodeName: NODE_DEFAULTS.name,
+        nodeConfig,
+        pvmBackend: NODE_DEFAULTS.pvm,
+    });
+    try {
+        const api = await node(jamConfig, withRelPath, null);
+        await importBlocks(api, blocksToImport);
+    }
+    catch (e) {
+        console.error(`${e}`);
+        process.exit(-1);
+    }
+}
+const blocksToImport = [
+    "test-vectors/w3f-davxy_072/traces/storage/00000001.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000002.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000003.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000004.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000005.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000006.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000007.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000008.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000009.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000010.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000011.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000012.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000013.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000014.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000015.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000016.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000017.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000018.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000019.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000020.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000021.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000022.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000023.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000024.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000025.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000026.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000027.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000028.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000029.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000030.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000031.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000032.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000033.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000034.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000035.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000036.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000037.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000038.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000039.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000040.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000041.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000042.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000043.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000044.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000045.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000046.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000047.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000048.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000049.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000050.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000051.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000052.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000053.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000054.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000055.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000056.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000057.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000058.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000059.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000060.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000061.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000062.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000063.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000064.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000065.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000066.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000067.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000068.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000069.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000070.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000071.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000072.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000073.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000074.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000075.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000076.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000077.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000078.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000079.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000080.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000081.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000082.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000083.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000084.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000085.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000086.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000087.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000088.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000089.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000090.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000091.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000092.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000093.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000094.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000095.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000096.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000097.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000098.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000099.json",
+    "test-vectors/w3f-davxy_072/traces/storage/00000100.json",
+].map(withRelPath);
+main();

package/packages/jam/rpc/test/e2e.d.ts

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

package/packages/jam/rpc/test/e2e.d.ts.map

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