@typeberry/lib 0.10.0-89fc6fa → 0.10.0-9e3af22

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,sBA6B/E"}

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

@@ -0,0 +1,32 @@
+import { PvmBackend } from "#@typeberry/config";
+import { loadConfig, NODE_DEFAULTS, RegularStateBackend } 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, LmdbWorkerConfig } 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 = nodeConfig.stateBackend === RegularStateBackend.Fjall
+        ? await FjallWorkerConfig.new(dbConfigParams).openDatabase({ readonly: true })
+        : await LmdbWorkerConfig.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":""}