@aztec/foundation 0.0.0-test.0

package/dest/json-rpc/fixtures/test_state.js

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import { optional, schemas } from '../../schemas/index.js';
+import { sleep } from '../../sleep/index.js';
+/**
+ * Contrived example for JSON RPC tests.
+ */ export class TestNote {
+    data;
+    constructor(data){
+        this.data = data;
+    }
+    static get schema() {
+        return z.object({
+            data: z.string()
+        }).transform(({ data })=>new TestNote(data));
+    }
+    toJSON() {
+        return {
+            data: this.data
+        };
+    }
+    /**
+   * Create a string representation of this class.
+   * @returns The string representation.
+   */ toString() {
+        return this.data;
+    }
+    /**
+   * Creates a string representation of this class.
+   * @param data - The data.
+   * @returns The string representation.
+   */ static fromString(data) {
+        return new TestNote(data);
+    }
+}
+/**
+ * Represents a simple state management for TestNote instances.
+ * Provides functionality to get a note by index and add notes asynchronously.
+ * Primarily used for testing JSON RPC-related functionalities.
+ */ export class TestState {
+    notes;
+    constructor(notes){
+        this.notes = notes;
+    }
+    /**
+   * Retrieve the TestNote instance at the specified index from the notes array.
+   * This method allows getting a desired TestNote from the collection of notes
+   * maintained by the TestState instance using the provided index value.
+   *
+   * @param index - The index of the TestNote to be retrieved from the notes array.
+   * @returns The TestNote instance corresponding to the given index.
+   */ async getNote(index) {
+        await sleep(0.1);
+        return this.notes[index];
+    }
+    fail() {
+        throw new Error('Test state failed');
+    }
+    async count() {
+        await sleep(0.1);
+        return this.notes.length;
+    }
+    async getNotes(limit) {
+        await sleep(0.1);
+        return limit ? this.notes.slice(0, limit) : this.notes;
+    }
+    async getNotes2(limit) {
+        await sleep(0.1);
+        return limit ? this.notes.slice(0, Number(limit)) : this.notes;
+    }
+    async getNotes3(limit = 1) {
+        await sleep(0.1);
+        return limit ? this.notes.slice(0, Number(limit)) : this.notes;
+    }
+    async clear() {
+        await sleep(0.1);
+        this.notes = [];
+    }
+    /**
+   * Add an array of TestNote instances to the current TestState's notes.
+   * This function simulates asynchronous behavior by waiting for a duration
+   * equal to the number of notes being added. It then returns the updated
+   * list of TestNote instances in the TestState.
+   *
+   * @param notes - An array of TestNote instances to be added.
+   * @returns A Promise that resolves to an array of TestNote instances, including the newly added notes.
+   */ async addNotes(notes) {
+        for (const note of notes){
+            this.notes.push(note);
+        }
+        await sleep(notes.length);
+        return this.notes;
+    }
+    async forceClear() {
+        await sleep(0.1);
+        this.notes = [];
+    }
+    async getStatus() {
+        await sleep(0.1);
+        return {
+            status: 'ok',
+            count: BigInt(this.notes.length)
+        };
+    }
+    async getTuple() {
+        await sleep(0.1);
+        return [
+            'a',
+            undefined,
+            1
+        ];
+    }
+}
+export const TestStateSchema = {
+    getNote: z.function().args(z.number()).returns(TestNote.schema.optional()),
+    getNotes: z.function().args(optional(schemas.Integer)).returns(z.array(TestNote.schema)),
+    getNotes2: z.function().args(optional(schemas.BigInt)).returns(z.array(TestNote.schema)),
+    getNotes3: z.function().args(optional(schemas.Integer)).returns(z.array(TestNote.schema)),
+    clear: z.function().returns(z.void()),
+    addNotes: z.function().args(z.array(TestNote.schema)).returns(z.array(TestNote.schema)),
+    fail: z.function().returns(z.void()),
+    count: z.function().returns(z.number()),
+    getStatus: z.function().returns(z.object({
+        status: z.string(),
+        count: schemas.BigInt
+    })),
+    getTuple: z.function().returns(z.tuple([
+        z.string(),
+        optional(z.string()),
+        z.number()
+    ]))
+};

package/dest/json-rpc/index.d.ts

@@ -0,0 +1,2 @@
+export { jsonStringify, jsonParseWithSchema, jsonParseWithSchemaSync, tryJsonStringify } from './convert.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/json-rpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/json-rpc/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/dest/json-rpc/index.js

@@ -0,0 +1 @@
+export { jsonStringify, jsonParseWithSchema, jsonParseWithSchemaSync, tryJsonStringify } from './convert.js';

package/dest/json-rpc/js_utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Does this own the property?
+ * @param obj - An object.
+ * @param method - A property name.
+ */
+export declare const hasOwnProperty: (obj: any, propertyName: string) => boolean;
+/**
+ * Helper function to assert a condition is truthy
+ * @param x - A boolean condition to assert.
+ * @param err - Error message to throw if x isn't met.
+ */
+export declare function assert(x: any, err: string): asserts x;
+//# sourceMappingURL=js_utils.d.ts.map

package/dest/json-rpc/js_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"js_utils.d.ts","sourceRoot":"","sources":["../../src/json-rpc/js_utils.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAS,GAAG,gBAAgB,MAAM,YACJ,CAAC;AAE1D;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAIrD"}

package/dest/json-rpc/js_utils.js

@@ -0,0 +1,16 @@
+// Make sure this property was not inherited
+// TODO(palla): Delete this file
+/**
+ * Does this own the property?
+ * @param obj - An object.
+ * @param method - A property name.
+ */ export const hasOwnProperty = (obj, propertyName)=>Object.prototype.hasOwnProperty.call(obj, propertyName);
+/**
+ * Helper function to assert a condition is truthy
+ * @param x - A boolean condition to assert.
+ * @param err - Error message to throw if x isn't met.
+ */ export function assert(x, err) {
+    if (!x) {
+        throw new Error(err);
+    }
+}

package/dest/json-rpc/server/index.d.ts

@@ -0,0 +1,2 @@
+export * from './safe_json_rpc_server.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/json-rpc/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/server/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dest/json-rpc/server/index.js

@@ -0,0 +1 @@
+export * from './safe_json_rpc_server.js';

package/dest/json-rpc/server/safe_json_rpc_server.d.ts

@@ -0,0 +1,140 @@
+/// <reference types="node" resolution-mode="require"/>
+import http from 'http';
+import { type default as Application } from 'koa';
+import Router from 'koa-router';
+import { type Logger } from '../../log/index.js';
+import { type ApiSchemaFor } from '../../schemas/index.js';
+export type DiagnosticsData = {
+    id: number | string | null;
+    method: string;
+    params: any[];
+    headers: http.IncomingHttpHeaders;
+};
+export type DiagnosticsMiddleware = (ctx: DiagnosticsData, next: () => Promise<void>) => Promise<void>;
+export declare class SafeJsonRpcServer {
+    /** The proxy object to delegate requests to. */
+    private readonly proxy;
+    /**
+     *  Return an HTTP 200 status code on errors, but include an error object
+     *  as per the JSON RPC spec
+     */
+    private http200OnError;
+    /** Health check function */
+    private readonly healthCheck;
+    /** Additional middlewares */
+    private extraMiddlewares;
+    /** Logger */
+    private log;
+    /**
+     * The HTTP server accepting remote requests.
+     * This member field is initialized when the server is started.
+     */
+    private httpServer?;
+    constructor(
+    /** The proxy object to delegate requests to. */
+    proxy: Proxy, 
+    /**
+     *  Return an HTTP 200 status code on errors, but include an error object
+     *  as per the JSON RPC spec
+     */
+    http200OnError?: boolean, 
+    /** Health check function */
+    healthCheck?: StatusCheckFn, 
+    /** Additional middlewares */
+    extraMiddlewares?: Application.Middleware[], 
+    /** Logger */
+    log?: Logger);
+    isHealthy(): boolean | Promise<boolean>;
+    /**
+     * Get an express app object.
+     * @param prefix - Our server prefix.
+     * @returns The app object.
+     */
+    getApp(prefix?: string): Application<Application.DefaultState, Application.DefaultContext>;
+    /**
+     * Get a router object wrapping our RPC class.
+     * @param prefix - The server prefix.
+     * @returns The router object.
+     */
+    private getRouter;
+    /**
+     * Start this server with koa.
+     * @param port - Port number.
+     * @param prefix - Prefix string.
+     */
+    start(port: number, prefix?: string): void;
+    /**
+     * Stops the HTTP server
+     */
+    stop(): Promise<void>;
+    /**
+     * Explicitly calls an RPC method.
+     * @param methodName - The RPC method.
+     * @param jsonParams - The RPC parameters.
+     * @returns The remote result.
+     */
+    call(methodName: string, jsonParams?: any[]): Promise<any>;
+}
+export type StatusCheckFn = () => boolean | Promise<boolean>;
+interface Proxy {
+    hasMethod(methodName: string): boolean;
+    call(methodName: string, jsonParams?: any[]): Promise<any>;
+}
+/**
+ * Forwards calls to a handler. Relies on a schema definition to validate and convert inputs
+ * before forwarding calls, and then converts outputs into JSON using default conversions.
+ */
+export declare class SafeJsonProxy<T extends object = any> implements Proxy {
+    private handler;
+    private log;
+    private schema;
+    constructor(handler: T, schema: ApiSchemaFor<T>);
+    /**
+     * Call an RPC method.
+     * @param methodName - The RPC method.
+     * @param jsonParams - The RPC parameters.
+     * @returns The remote result.
+     */
+    call(methodName: string, jsonParams?: any[]): Promise<any>;
+    hasMethod(methodName: string): boolean;
+}
+export type NamespacedApiHandlers = Record<string, ApiHandler>;
+export type ApiHandler<T extends object = any> = [T, ApiSchemaFor<T>, StatusCheckFn?];
+export declare function makeHandler<T extends object>(handler: T, schema: ApiSchemaFor<T>): ApiHandler<T>;
+export type SafeJsonRpcServerOptions = {
+    http200OnError: boolean;
+    healthCheck?: StatusCheckFn;
+    log?: Logger;
+    middlewares?: Application.Middleware[];
+};
+/**
+ * Creates a single SafeJsonRpcServer from multiple handlers.
+ * @param servers - List of handlers to be combined.
+ * @returns A single JsonRpcServer with namespaced methods.
+ */
+export declare function createNamespacedSafeJsonRpcServer(handlers: NamespacedApiHandlers, options?: Partial<Omit<SafeJsonRpcServerOptions, 'healthcheck'>>): SafeJsonRpcServer;
+export declare function createSafeJsonRpcServer<T extends object = any>(handler: T, schema: ApiSchemaFor<T>, options?: Partial<SafeJsonRpcServerOptions>): SafeJsonRpcServer;
+/**
+ * Creates a router for handling a plain status request that will return 200 status when running.
+ * @param getCurrentStatus - List of health check functions to run.
+ * @param apiPrefix - The prefix to use for all api requests
+ * @returns - The router for handling status requests.
+ */
+export declare function createStatusRouter(getCurrentStatus: StatusCheckFn, apiPrefix?: string): Router<any, {}>;
+/**
+ * Wraps a JsonRpcServer in a nodejs http server and starts it.
+ * Installs a status router that calls to the isHealthy method to the server.
+ * Returns once starts listening unless noWait is set.
+ * @returns A running http server.
+ */
+export declare function startHttpRpcServer(rpcServer: Pick<SafeJsonRpcServer, 'getApp' | 'isHealthy'>, options?: {
+    host?: string;
+    port?: number | string;
+    apiPrefix?: string;
+    timeoutMs?: number;
+    noWait?: boolean;
+}): Promise<http.Server & {
+    port: number;
+}>;
+export {};
+//# sourceMappingURL=safe_json_rpc_server.d.ts.map

package/dest/json-rpc/server/safe_json_rpc_server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe_json_rpc_server.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/server/safe_json_rpc_server.ts"],"names":[],"mappings":"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"}

package/dest/json-rpc/server/safe_json_rpc_server.js

@@ -0,0 +1,346 @@
+import cors from '@koa/cors';
+import http from 'http';
+import { default as Koa } from 'koa';
+import bodyParser from 'koa-bodyparser';
+import compress from 'koa-compress';
+import Router from 'koa-router';
+import { format, inspect } from 'util';
+import { ZodError } from 'zod';
+import { createLogger } from '../../log/index.js';
+import { promiseWithResolvers } from '../../promise/utils.js';
+import { parseWithOptionals, schemaHasMethod } from '../../schemas/index.js';
+import { jsonStringify } from '../convert.js';
+import { assert } from '../js_utils.js';
+export class SafeJsonRpcServer {
+    proxy;
+    http200OnError;
+    healthCheck;
+    extraMiddlewares;
+    log;
+    /**
+   * The HTTP server accepting remote requests.
+   * This member field is initialized when the server is started.
+   */ httpServer;
+    constructor(/** The proxy object to delegate requests to. */ proxy, /**
+     *  Return an HTTP 200 status code on errors, but include an error object
+     *  as per the JSON RPC spec
+     */ http200OnError = false, /** Health check function */ healthCheck = ()=>true, /** Additional middlewares */ extraMiddlewares = [], /** Logger */ log = createLogger('json-rpc:server')){
+        this.proxy = proxy;
+        this.http200OnError = http200OnError;
+        this.healthCheck = healthCheck;
+        this.extraMiddlewares = extraMiddlewares;
+        this.log = log;
+    }
+    isHealthy() {
+        return this.healthCheck();
+    }
+    /**
+   * Get an express app object.
+   * @param prefix - Our server prefix.
+   * @returns The app object.
+   */ getApp(prefix = '') {
+        const router = this.getRouter(prefix);
+        const exceptionHandler = async (ctx, next)=>{
+            try {
+                await next();
+            } catch (err) {
+                const method = ctx.request.body?.method ?? 'unknown';
+                this.log.warn(`Error in JSON RPC server call ${method}: ${inspect(err)}`);
+                if (err instanceof SyntaxError) {
+                    ctx.status = 400;
+                    ctx.body = {
+                        jsonrpc: '2.0',
+                        id: null,
+                        error: {
+                            code: -32700,
+                            message: `Parse error: ${err.message}`
+                        }
+                    };
+                } else if (err instanceof ZodError) {
+                    const message = err.issues.map((e)=>`${e.message} (${e.path.join('.')})`).join('. ') || 'Validation error';
+                    ctx.status = 400;
+                    ctx.body = {
+                        jsonrpc: '2.0',
+                        id: null,
+                        error: {
+                            code: -32701,
+                            message
+                        }
+                    };
+                } else if (this.http200OnError) {
+                    ctx.body = {
+                        jsonrpc: '2.0',
+                        id: null,
+                        error: {
+                            code: err.code || -32600,
+                            data: err.data,
+                            message: err.message
+                        }
+                    };
+                } else {
+                    ctx.status = 500;
+                    ctx.body = {
+                        jsonrpc: '2.0',
+                        id: null,
+                        error: {
+                            code: -32600,
+                            message: err.message ?? 'Internal error'
+                        }
+                    };
+                }
+            }
+        };
+        const jsonResponse = async (ctx, next)=>{
+            try {
+                await next();
+                if (ctx.body && typeof ctx.body === 'object') {
+                    ctx.body = jsonStringify(ctx.body);
+                }
+            } catch (err) {
+                ctx.status = 500;
+                ctx.body = {
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32700,
+                        message: `Unable to serialize response: ${err.message}`
+                    }
+                };
+            }
+        };
+        const app = new Koa();
+        app.on('error', (error)=>{
+            this.log.error(`Error on API handler: ${error}`);
+        });
+        app.use(compress({
+            br: false
+        }));
+        app.use(jsonResponse);
+        for (const middleware of this.extraMiddlewares){
+            app.use(middleware);
+        }
+        app.use(exceptionHandler);
+        app.use(bodyParser({
+            jsonLimit: '50mb',
+            enableTypes: [
+                'json'
+            ],
+            detectJSON: ()=>true
+        }));
+        app.use(cors());
+        app.use(router.routes());
+        app.use(router.allowedMethods());
+        return app;
+    }
+    /**
+   * Get a router object wrapping our RPC class.
+   * @param prefix - The server prefix.
+   * @returns The router object.
+   */ getRouter(prefix) {
+        const router = new Router({
+            prefix
+        });
+        // "JSON RPC mode" where a single endpoint is used and the method is given in the request body
+        router.post('/', async (ctx)=>{
+            const { params = [], jsonrpc, id, method } = ctx.request.body;
+            // Fail if not a registered function in the proxy
+            if (typeof method !== 'string' || method === 'constructor' || !this.proxy.hasMethod(method)) {
+                ctx.status = 400;
+                const code = -32601;
+                const message = `Method not found: ${method}`;
+                ctx.body = {
+                    jsonrpc,
+                    id,
+                    error: {
+                        code,
+                        message
+                    }
+                };
+            } else {
+                ctx.status = 200;
+                const result = await this.proxy.call(method, params);
+                ctx.body = {
+                    jsonrpc,
+                    id,
+                    result
+                };
+            }
+        });
+        return router;
+    }
+    /**
+   * Start this server with koa.
+   * @param port - Port number.
+   * @param prefix - Prefix string.
+   */ start(port, prefix = '') {
+        if (this.httpServer) {
+            throw new Error('Server is already listening');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this.httpServer = http.createServer(this.getApp(prefix).callback());
+        this.httpServer.listen(port);
+    }
+    /**
+   * Stops the HTTP server
+   */ stop() {
+        if (!this.httpServer) {
+            return Promise.resolve();
+        }
+        const { promise, resolve, reject } = promiseWithResolvers();
+        this.httpServer.close((err)=>{
+            if (err) {
+                reject(err);
+            } else {
+                resolve();
+            }
+        });
+        return promise;
+    }
+    /**
+   * Explicitly calls an RPC method.
+   * @param methodName - The RPC method.
+   * @param jsonParams - The RPC parameters.
+   * @returns The remote result.
+   */ async call(methodName, jsonParams = []) {
+        return await this.proxy.call(methodName, jsonParams);
+    }
+}
+/**
+ * Forwards calls to a handler. Relies on a schema definition to validate and convert inputs
+ * before forwarding calls, and then converts outputs into JSON using default conversions.
+ */ export class SafeJsonProxy {
+    handler;
+    log;
+    schema;
+    constructor(handler, schema){
+        this.handler = handler;
+        this.log = createLogger('json-rpc:proxy');
+        this.schema = schema;
+    }
+    /**
+   * Call an RPC method.
+   * @param methodName - The RPC method.
+   * @param jsonParams - The RPC parameters.
+   * @returns The remote result.
+   */ async call(methodName, jsonParams = []) {
+        this.log.debug(format(`request`, methodName, jsonParams));
+        assert(Array.isArray(jsonParams), `Params to ${methodName} is not an array: ${jsonParams}`);
+        assert(schemaHasMethod(this.schema, methodName), `Method ${methodName} not found in schema`);
+        const method = this.handler[methodName];
+        assert(typeof method === 'function', `Method ${methodName} is not a function`);
+        const args = await parseWithOptionals(jsonParams, this.schema[methodName].parameters());
+        const ret = await method.apply(this.handler, args);
+        this.log.debug(format('response', methodName, ret));
+        return ret;
+    }
+    hasMethod(methodName) {
+        return schemaHasMethod(this.schema, methodName) && typeof this.handler[methodName] === 'function';
+    }
+}
+class NamespacedSafeJsonProxy {
+    proxies = {};
+    constructor(handlers){
+        for (const [namespace, [handler, schema]] of Object.entries(handlers)){
+            this.proxies[namespace] = new SafeJsonProxy(handler, schema);
+        }
+    }
+    call(namespacedMethodName, jsonParams = []) {
+        const [namespace, methodName] = namespacedMethodName.split('_', 2);
+        assert(namespace && methodName, `Invalid namespaced method name: ${namespacedMethodName}`);
+        const handler = this.proxies[namespace];
+        assert(handler, `Namespace not found: ${namespace}`);
+        return handler.call(methodName, jsonParams);
+    }
+    hasMethod(namespacedMethodName) {
+        const [namespace, methodName] = namespacedMethodName.split('_', 2);
+        const handler = this.proxies[namespace];
+        return handler?.hasMethod(methodName);
+    }
+}
+export function makeHandler(handler, schema) {
+    return [
+        handler,
+        schema
+    ];
+}
+function makeAggregateHealthcheck(namedHandlers, log) {
+    return async ()=>{
+        try {
+            const results = await Promise.all(Object.entries(namedHandlers).map(([name, [, , healthCheck]])=>[
+                    name,
+                    healthCheck ? healthCheck() : true
+                ]));
+            const failed = results.filter(([_, result])=>!result);
+            if (failed.length > 0) {
+                log?.warn(`Health check failed for ${failed.map(([name])=>name).join(', ')}`);
+                return false;
+            }
+            return true;
+        } catch (err) {
+            log?.error(`Error during health check`, err);
+            return false;
+        }
+    };
+}
+/**
+ * Creates a single SafeJsonRpcServer from multiple handlers.
+ * @param servers - List of handlers to be combined.
+ * @returns A single JsonRpcServer with namespaced methods.
+ */ export function createNamespacedSafeJsonRpcServer(handlers, options = {
+    log: createLogger('json-rpc:server')
+}) {
+    const { middlewares, http200OnError, log } = options;
+    const proxy = new NamespacedSafeJsonProxy(handlers);
+    const healthCheck = makeAggregateHealthcheck(handlers, log);
+    return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, middlewares, log);
+}
+export function createSafeJsonRpcServer(handler, schema, options = {}) {
+    const { http200OnError, log, healthCheck, middlewares: extraMiddlewares } = options;
+    const proxy = new SafeJsonProxy(handler, schema);
+    return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, extraMiddlewares, log);
+}
+/**
+ * Creates a router for handling a plain status request that will return 200 status when running.
+ * @param getCurrentStatus - List of health check functions to run.
+ * @param apiPrefix - The prefix to use for all api requests
+ * @returns - The router for handling status requests.
+ */ export function createStatusRouter(getCurrentStatus, apiPrefix = '') {
+    const router = new Router({
+        prefix: `${apiPrefix}`
+    });
+    router.get('/status', async (ctx)=>{
+        let ok;
+        try {
+            ok = await getCurrentStatus() === true;
+        } catch (err) {
+            ok = false;
+        }
+        ctx.status = ok ? 200 : 500;
+    });
+    return router;
+}
+/**
+ * Wraps a JsonRpcServer in a nodejs http server and starts it.
+ * Installs a status router that calls to the isHealthy method to the server.
+ * Returns once starts listening unless noWait is set.
+ * @returns A running http server.
+ */ export async function startHttpRpcServer(rpcServer, options = {}) {
+    const app = rpcServer.getApp(options.apiPrefix);
+    const statusRouter = createStatusRouter(rpcServer.isHealthy.bind(rpcServer), options.apiPrefix);
+    app.use(statusRouter.routes()).use(statusRouter.allowedMethods());
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    const httpServer = http.createServer(app.callback());
+    if (options.timeoutMs) {
+        httpServer.timeout = options.timeoutMs;
+    }
+    const { promise, resolve } = promiseWithResolvers();
+    const listenPort = options.port ? typeof options.port === 'string' ? parseInt(options.port) : options.port : 0;
+    httpServer.listen(listenPort, options.host, ()=>resolve());
+    // Wait until listen callback is called
+    if (!options.noWait) {
+        await promise;
+    }
+    const port = httpServer.address().port;
+    return Object.assign(httpServer, {
+        port
+    });
+}

package/dest/json-rpc/server/telemetry.d.ts

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