@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/jam/node/workers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workers.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/workers.ts"],"names":[],"mappings":"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"}

package/packages/jam/node/workers.js

@@ -0,0 +1,74 @@
+import * as blockAuthorship from "#@typeberry/block-authorship";
+import * as importer from "#@typeberry/importer";
+import * as jamNetwork from "#@typeberry/jam-network";
+import { startSameThread } from "#@typeberry/workers-api";
+import { spawnWorker } from "#@typeberry/workers-api-node";
+export async function spawnImporterWorker(config) {
+    const { api, workerFinished } = spawnWorker(importer.protocol, importer.WORKER, config, importer.ImporterConfig.Codec);
+    return {
+        importer: api,
+        finish: async () => {
+            await api.sendFinish();
+            api.destroy();
+            await workerFinished;
+        },
+    };
+}
+export async function startImporterDirect(config) {
+    const { api, internal } = startSameThread(importer.protocol);
+    const importerFinish = importer.main(config, internal);
+    return {
+        importer: api,
+        finish: async () => {
+            await api.sendFinish();
+            api.destroy();
+            await importerFinish;
+        },
+    };
+}
+export async function spawnNetworkWorker(config) {
+    const { api, workerFinished } = spawnWorker(jamNetwork.protocol, jamNetwork.WORKER, config, jamNetwork.NetworkingConfig.Codec);
+    return {
+        network: api,
+        finish: async () => {
+            await api.sendFinish();
+            api.destroy();
+            await workerFinished;
+        },
+    };
+}
+export async function startNetwork(config) {
+    const { api, internal } = startSameThread(jamNetwork.protocol);
+    const networkFinish = jamNetwork.main(config, internal);
+    return {
+        network: api,
+        finish: async () => {
+            await api.sendFinish();
+            api.destroy();
+            await networkFinish;
+        },
+    };
+}
+export async function spawnBlockGeneratorWorker(config) {
+    const { api, workerFinished } = spawnWorker(blockAuthorship.protocol, blockAuthorship.WORKER, config, blockAuthorship.BlockAuthorshipConfig.Codec);
+    return {
+        generator: api,
+        finish: async () => {
+            await api.sendFinish();
+            api.destroy();
+            await workerFinished;
+        },
+    };
+}
+export async function startBlockGenerator(config) {
+    const { api, internal } = startSameThread(blockAuthorship.protocol);
+    const finish = blockAuthorship.main(config, internal);
+    return {
+        generator: api,
+        finish: async () => {
+            await api.sendFinish();
+            api.destroy();
+            await finish;
+        },
+    };
+}

package/packages/jam/rpc-client/index.d.ts

@@ -0,0 +1,35 @@
+import { type InputOf, type MethodName, type MethodWithNoArgsName, type OutputOf, type SubscribableMethodName } from "#@typeberry/rpc-validation";
+import { EventEmitter } from "eventemitter3";
+import WebSocket from "ws";
+export interface Subscription<M extends SubscribableMethodName> {
+    id: string;
+    method: M;
+    eventEmitter: SubscriptionEventEmitter;
+}
+type SubscriptionEventMap = {
+    data: [unknown];
+    error: [unknown];
+    end: [];
+};
+declare class SubscriptionEventEmitter extends EventEmitter<SubscriptionEventMap> {
+    readonly unsubscribe: () => Promise<void>;
+    constructor(unsubscribe: () => Promise<void>);
+}
+export declare class RpcClient {
+    private ws;
+    private messageQueue;
+    private subscriptions;
+    private nextId;
+    private connectionPromise;
+    constructor(url: string);
+    private setupWebSocket;
+    waitForConnection(): Promise<void>;
+    call<M extends MethodWithNoArgsName>(method: M, params?: InputOf<M>): Promise<OutputOf<M>>;
+    call<M extends MethodName>(method: M, params: InputOf<M>): Promise<OutputOf<M>>;
+    subscribe<M extends SubscribableMethodName>(method: M, params: InputOf<M>): Promise<SubscriptionEventEmitter>;
+    private unsubscribe;
+    close(): void;
+    getSocket(): WebSocket;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/packages/jam/rpc-client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/rpc-client/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EAKZ,KAAK,UAAU,EACf,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EAGb,KAAK,sBAAsB,EAE5B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,SAAS,MAAM,IAAI,CAAC;AAE3B,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,sBAAsB;IAC5D,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,CAAC,CAAC;IACV,YAAY,EAAE,wBAAwB,CAAC;CACxC;AAED,KAAK,oBAAoB,GAAG;IAC1B,IAAI,EAAE,CAAC,OAAO,CAAC,CAAC;IAChB,KAAK,EAAE,CAAC,OAAO,CAAC,CAAC;IACjB,GAAG,EAAE,EAAE,CAAC;CACT,CAAC;AAEF,cAAM,wBAAyB,SAAQ,YAAY,CAAC,oBAAoB,CAAC;IAC3D,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC;gBAAhC,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC;CAGtD;AAID,qBAAa,SAAS;IACpB,OAAO,CAAC,EAAE,CAAY;IACtB,OAAO,CAAC,YAAY,CAA+D;IACnF,OAAO,CAAC,aAAa,CAAgE;IACrF,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,iBAAiB,CAAgB;gBAE7B,GAAG,EAAE,MAAM;IAWvB,OAAO,CAAC,cAAc;IAgDhB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIlC,IAAI,CAAC,CAAC,SAAS,oBAAoB,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC1F,IAAI,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAqC/E,SAAS,CAAC,CAAC,SAAS,sBAAsB,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC;YAOrG,WAAW;IAqBzB,KAAK,IAAI,IAAI;IAIb,SAAS,IAAI,SAAS;CAGvB"}

package/packages/jam/rpc-client/index.js

@@ -0,0 +1,130 @@
+import { Logger } from "#@typeberry/logger";
+import { JSON_RPC_VERSION, SUBSCRIBABLE_METHODS, validation, } from "#@typeberry/rpc-validation";
+import { EventEmitter } from "eventemitter3";
+import WebSocket from "ws";
+class SubscriptionEventEmitter extends EventEmitter {
+    unsubscribe;
+    constructor(unsubscribe) {
+        super();
+        this.unsubscribe = unsubscribe;
+    }
+}
+const logger = Logger.new("rpc");
+export class RpcClient {
+    ws;
+    messageQueue = new Map();
+    subscriptions = new Map();
+    nextId = 1;
+    connectionPromise;
+    constructor(url) {
+        this.ws = new WebSocket(url);
+        this.connectionPromise = new Promise((resolve) => {
+            this.ws.once("open", () => {
+                logger.info `Connected to server`;
+                resolve();
+            });
+        });
+        this.setupWebSocket();
+    }
+    setupWebSocket() {
+        this.ws.on("message", (data) => {
+            const response = JSON.parse(data);
+            // todo [seko] this block of ifs shall be made cleaner once there's zod validation in place for the client
+            if (!("id" in response) &&
+                "params" in response &&
+                "subscriptionId" in response.params &&
+                "result" in response.params) {
+                const { subscriptionId, result } = response.params;
+                const subscription = this.subscriptions.get(subscriptionId);
+                if (subscription !== undefined) {
+                    subscription.eventEmitter.emit("data", result);
+                }
+            }
+            else if (!("id" in response) &&
+                "params" in response &&
+                "subscriptionId" in response.params &&
+                "error" in response.params) {
+                const { subscriptionId, error } = response.params;
+                const subscription = this.subscriptions.get(subscriptionId);
+                if (subscription !== undefined) {
+                    subscription.eventEmitter.emit("error", error);
+                }
+            }
+            else if ("id" in response && typeof response.id === "number") {
+                const callback = this.messageQueue.get(response.id);
+                if (callback !== undefined) {
+                    callback(response);
+                    this.messageQueue.delete(response.id);
+                }
+            }
+        });
+        this.ws.on("error", (error) => {
+            logger.error `WebSocket error: ${error}`;
+        });
+        this.ws.on("close", () => {
+            logger.info `Disconnected from server`;
+        });
+    }
+    async waitForConnection() {
+        return this.connectionPromise;
+    }
+    async call(method, params) {
+        if (!(method in validation.schemas)) {
+            throw new Error(`Method "${method}" not found. Request was not sent.`);
+        }
+        const { input } = validation.schemas[method];
+        return new Promise((resolve, reject) => {
+            const id = this.nextId++;
+            const request = {
+                jsonrpc: JSON_RPC_VERSION,
+                method,
+                params: input.encode(params ?? []),
+                id,
+            };
+            this.messageQueue.set(id, (response) => {
+                if ("error" in response) {
+                    reject(response.error);
+                }
+                else {
+                    const { output } = validation.schemas[method];
+                    const parseResult = output.safeParse(response.result);
+                    if (parseResult.success === false) {
+                        reject(new Error(`Received an invalid response for method "${method}": ${JSON.stringify(response.result)}`));
+                        return;
+                    }
+                    resolve(parseResult.data);
+                }
+            });
+            this.ws.send(JSON.stringify(request));
+        });
+    }
+    async subscribe(method, params) {
+        const subscriptionId = await this.call(method, params);
+        const eventEmitter = new SubscriptionEventEmitter(() => this.unsubscribe(subscriptionId));
+        this.subscriptions.set(subscriptionId, { id: subscriptionId, method, eventEmitter });
+        return eventEmitter;
+    }
+    async unsubscribe(subscriptionId) {
+        const subscription = this.subscriptions.get(subscriptionId);
+        if (subscription === undefined) {
+            throw new Error("Subscription not found. Unsubscribe request was not sent.");
+        }
+        const unsubscribeMethod = SUBSCRIBABLE_METHODS[subscription.method];
+        if (unsubscribeMethod === undefined) {
+            throw new Error(`Missing unsubscribe method mapping for "${subscription.method}". Unsubscribe request was not sent.`);
+        }
+        const result = await this.call(unsubscribeMethod, [subscriptionId]);
+        if (result === true) {
+            this.subscriptions.delete(subscriptionId);
+        }
+        else {
+            throw new Error("Server failed to terminate subscription.");
+        }
+    }
+    close() {
+        this.ws.close();
+    }
+    getSocket() {
+        return this.ws;
+    }
+}

package/packages/jam/rpc-validation/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./validation.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/jam/rpc-validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/rpc-validation/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}

package/packages/jam/rpc-validation/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./validation.js";

package/packages/jam/rpc-validation/types.d.ts

@@ -0,0 +1,88 @@
+import type { ChainSpec } from "#@typeberry/config";
+import type { BlocksDb, StatesDb } from "#@typeberry/database";
+import type { EnumerableState, State } from "#@typeberry/state";
+import type WebSocket from "ws";
+import type { z } from "zod";
+import type { JSON_RPC_VERSION, SUBSCRIBABLE_METHODS, validation } from "./validation.js";
+export type JsonRpcResult = unknown;
+export type JsonRpcRequest = z.infer<typeof validation.jsonRpcRequest>;
+export type JsonRpcNotification = z.infer<typeof validation.jsonRpcNotification>;
+export type JsonRpcId = JsonRpcRequest["id"];
+export interface JsonRpcSuccessResponse {
+    jsonrpc: typeof JSON_RPC_VERSION;
+    result: unknown;
+    id: JsonRpcId;
+}
+export interface JsonRpcErrorResponse {
+    jsonrpc: typeof JSON_RPC_VERSION;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+    id: JsonRpcId;
+}
+interface JsonRpcSubscriptionResultNotification extends JsonRpcNotification {
+    params: {
+        subscriptionId: SubscriptionId;
+        result: JsonRpcResult;
+    };
+}
+interface JsonRpcSubscriptionErrorNotification extends JsonRpcNotification {
+    params: {
+        subscriptionId: SubscriptionId;
+        error: unknown;
+    };
+}
+export type JsonRpcSubscriptionNotification = JsonRpcSubscriptionResultNotification | JsonRpcSubscriptionErrorNotification;
+export type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
+export declare class RpcError extends Error {
+    code: number;
+    data?: unknown | undefined;
+    constructor(code: number, message: string, data?: unknown | undefined);
+}
+export declare enum RpcErrorCode {
+    BlockUnavailable = 1,
+    WorkReportUnavailable = 2,
+    DASegmentUnavailable = 3,
+    Other = 0
+}
+export interface DatabaseContext {
+    blocks: BlocksDb;
+    states: StatesDb<State & EnumerableState>;
+}
+export type SchemaMap = typeof validation.schemas;
+export type MethodName = keyof SchemaMap;
+export type MethodWithNoArgsName = keyof {
+    [K in keyof SchemaMap as SchemaMap[K]["input"] extends z.ZodTuple<[]> ? K : never]: SchemaMap[K];
+};
+export type SchemaMapUnknown = Record<MethodName, {
+    input: z.ZodTypeAny;
+    output: z.ZodTypeAny;
+}>;
+export type InputOf<M extends MethodName> = z.infer<SchemaMap[M]["input"]>;
+export type OutputOf<M extends MethodName> = z.infer<SchemaMap[M]["output"]>;
+export type GenericHandler<I, O> = (input: I, context: {
+    db: DatabaseContext;
+    chainSpec: ChainSpec;
+    subscription: SubscriptionHandlerApi;
+}) => Promise<O>;
+export type Handler<M extends MethodName> = GenericHandler<InputOf<M>, OutputOf<M>>;
+export type HandlerMap = {
+    [N in MethodName]: Handler<N>;
+};
+export type Subscription<I, O> = {
+    ws: WebSocket;
+    method: SubscribableMethodName;
+    handler: GenericHandler<I, O>;
+    outputSchema: z.ZodType<O>;
+    params: I;
+};
+export type SubscriptionId = string;
+export type SubscriptionHandlerApi = {
+    subscribe: <I, O>(method: SubscribableMethodName, handler: GenericHandler<I, O>, outputSchema: z.ZodType<O>, params: I) => SubscriptionId;
+    unsubscribe: (id: SubscriptionId) => boolean;
+};
+export type SubscribableMethodName = keyof typeof SUBSCRIBABLE_METHODS;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/packages/jam/rpc-validation/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/rpc-validation/types.ts"],"names":[],"mappings":"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"}

package/packages/jam/rpc-validation/types.js

@@ -0,0 +1,16 @@
+export class RpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+export var RpcErrorCode;
+(function (RpcErrorCode) {
+    RpcErrorCode[RpcErrorCode["BlockUnavailable"] = 1] = "BlockUnavailable";
+    RpcErrorCode[RpcErrorCode["WorkReportUnavailable"] = 2] = "WorkReportUnavailable";
+    RpcErrorCode[RpcErrorCode["DASegmentUnavailable"] = 3] = "DASegmentUnavailable";
+    RpcErrorCode[RpcErrorCode["Other"] = 0] = "Other";
+})(RpcErrorCode || (RpcErrorCode = {}));

package/packages/jam/rpc-validation/validation.d.ts

@@ -0,0 +1,279 @@
+import z from "zod";
+export declare const JSON_RPC_VERSION = "2.0";
+export declare namespace validation {
+    const hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+    const slot: z.ZodNumber;
+    const blobArray: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+    const serviceId: z.ZodNumber;
+    const preimageLength: z.ZodNumber;
+    const noArgs: z.ZodTuple<[], null>;
+    const blockDescriptor: z.ZodObject<{
+        header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+        slot: z.ZodNumber;
+    }, z.z.core.$strip>;
+    const parameters: z.ZodObject<{
+        V1: z.ZodObject<{
+            deposit_per_account: z.ZodNumber;
+            deposit_per_item: z.ZodNumber;
+            deposit_per_byte: z.ZodNumber;
+            min_turnaround_period: z.ZodNumber;
+            epoch_period: z.ZodNumber;
+            max_accumulate_gas: z.ZodNumber;
+            max_is_authorized_gas: z.ZodNumber;
+            max_refine_gas: z.ZodNumber;
+            block_gas_limit: z.ZodNumber;
+            recent_block_count: z.ZodNumber;
+            max_work_items: z.ZodNumber;
+            max_dependencies: z.ZodNumber;
+            max_tickets_per_block: z.ZodNumber;
+            max_lookup_anchor_age: z.ZodNumber;
+            tickets_attempts_number: z.ZodNumber;
+            auth_window: z.ZodNumber;
+            auth_queue_len: z.ZodNumber;
+            rotation_period: z.ZodNumber;
+            max_extrinsics: z.ZodNumber;
+            availability_timeout: z.ZodNumber;
+            val_count: z.ZodNumber;
+            max_input: z.ZodNumber;
+            max_refine_code_size: z.ZodNumber;
+            basic_piece_len: z.ZodNumber;
+            max_imports: z.ZodNumber;
+            max_is_authorized_code_size: z.ZodNumber;
+            max_exports: z.ZodNumber;
+            max_refine_memory: z.ZodNumber;
+            max_is_authorized_memory: z.ZodNumber;
+            segment_piece_count: z.ZodNumber;
+            max_report_elective_data: z.ZodNumber;
+            transfer_memo_size: z.ZodNumber;
+            epoch_tail_start: z.ZodNumber;
+            core_count: z.ZodNumber;
+            slot_period_sec: z.ZodNumber;
+            max_authorizer_code_size: z.ZodNumber;
+            max_service_code_size: z.ZodNumber;
+        }, z.z.core.$strip>;
+    }, z.z.core.$strip>;
+    const notImplementedSchema: {
+        input: z.ZodTuple<[], null>;
+        output: z.ZodAny;
+    };
+    const unsubscribeSchema: {
+        input: z.ZodTuple<[z.ZodString], null>;
+        output: z.ZodBoolean;
+    };
+    const schemas: {
+        readonly beefyRoot: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly submitPreimage: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly submitWorkPackage: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly workReport: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly submitWorkPackageBundle: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly workPackageStatus: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly subscribeWorkPackageStatus: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly fetchWorkPackageSegments: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly fetchSegments: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly syncState: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly subscribeSyncStatus: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        readonly bestBlock: {
+            readonly input: z.ZodTuple<[], null>;
+            readonly output: z.ZodObject<{
+                header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+                slot: z.ZodNumber;
+            }, z.z.core.$strip>;
+        };
+        readonly finalizedBlock: {
+            readonly input: z.ZodTuple<[], null>;
+            readonly output: z.ZodObject<{
+                header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+                slot: z.ZodNumber;
+            }, z.z.core.$strip>;
+        };
+        readonly listServices: {
+            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            readonly output: z.ZodArray<z.ZodNumber>;
+        };
+        readonly parameters: {
+            readonly input: z.ZodTuple<[], null>;
+            readonly output: z.ZodObject<{
+                V1: z.ZodObject<{
+                    deposit_per_account: z.ZodNumber;
+                    deposit_per_item: z.ZodNumber;
+                    deposit_per_byte: z.ZodNumber;
+                    min_turnaround_period: z.ZodNumber;
+                    epoch_period: z.ZodNumber;
+                    max_accumulate_gas: z.ZodNumber;
+                    max_is_authorized_gas: z.ZodNumber;
+                    max_refine_gas: z.ZodNumber;
+                    block_gas_limit: z.ZodNumber;
+                    recent_block_count: z.ZodNumber;
+                    max_work_items: z.ZodNumber;
+                    max_dependencies: z.ZodNumber;
+                    max_tickets_per_block: z.ZodNumber;
+                    max_lookup_anchor_age: z.ZodNumber;
+                    tickets_attempts_number: z.ZodNumber;
+                    auth_window: z.ZodNumber;
+                    auth_queue_len: z.ZodNumber;
+                    rotation_period: z.ZodNumber;
+                    max_extrinsics: z.ZodNumber;
+                    availability_timeout: z.ZodNumber;
+                    val_count: z.ZodNumber;
+                    max_input: z.ZodNumber;
+                    max_refine_code_size: z.ZodNumber;
+                    basic_piece_len: z.ZodNumber;
+                    max_imports: z.ZodNumber;
+                    max_is_authorized_code_size: z.ZodNumber;
+                    max_exports: z.ZodNumber;
+                    max_refine_memory: z.ZodNumber;
+                    max_is_authorized_memory: z.ZodNumber;
+                    segment_piece_count: z.ZodNumber;
+                    max_report_elective_data: z.ZodNumber;
+                    transfer_memo_size: z.ZodNumber;
+                    epoch_tail_start: z.ZodNumber;
+                    core_count: z.ZodNumber;
+                    slot_period_sec: z.ZodNumber;
+                    max_authorizer_code_size: z.ZodNumber;
+                    max_service_code_size: z.ZodNumber;
+                }, z.z.core.$strip>;
+            }, z.z.core.$strip>;
+        };
+        readonly parent: {
+            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            readonly output: z.ZodObject<{
+                header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+                slot: z.ZodNumber;
+            }, z.z.core.$strip>;
+        };
+        readonly serviceData: {
+            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber], null>;
+            readonly output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
+        };
+        readonly servicePreimage: {
+            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            readonly output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
+        };
+        readonly serviceRequest: {
+            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber], null>;
+            readonly output: z.ZodUnion<readonly [z.ZodReadonly<z.ZodArray<z.ZodNumber>>, z.ZodNull]>;
+        };
+        readonly serviceValue: {
+            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            readonly output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
+        };
+        readonly stateRoot: {
+            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            readonly output: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+        };
+        readonly statistics: {
+            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            readonly output: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+        };
+        readonly subscribeBestBlock: {
+            readonly input: z.ZodTuple<[], null>;
+            readonly output: z.ZodString;
+        };
+        readonly subscribeFinalizedBlock: {
+            readonly input: z.ZodTuple<[], null>;
+            readonly output: z.ZodString;
+        };
+        readonly subscribeServiceData: {
+            readonly input: z.ZodTuple<[z.ZodNumber, z.ZodBoolean], null>;
+            readonly output: z.ZodString;
+        };
+        readonly subscribeServicePreimage: {
+            readonly input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodBoolean], null>;
+            readonly output: z.ZodString;
+        };
+        readonly subscribeServiceRequest: {
+            readonly input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodBoolean], null>;
+            readonly output: z.ZodString;
+        };
+        readonly subscribeServiceValue: {
+            readonly input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodBoolean], null>;
+            readonly output: z.ZodString;
+        };
+        readonly subscribeStatistics: {
+            readonly input: z.ZodTuple<[z.ZodBoolean], null>;
+            readonly output: z.ZodString;
+        };
+        readonly unsubscribeBestBlock: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        readonly unsubscribeFinalizedBlock: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        readonly unsubscribeServiceData: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        readonly unsubscribeServicePreimage: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        readonly unsubscribeServiceRequest: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        readonly unsubscribeServiceValue: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        readonly unsubscribeStatistics: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+    };
+    const jsonRpcRequest: z.ZodObject<{
+        jsonrpc: z.ZodLiteral<"2.0">;
+        method: z.ZodString;
+        params: z.ZodOptional<z.ZodUnknown>;
+        id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    }, z.z.core.$strip>;
+    const jsonRpcNotification: z.ZodObject<{
+        params: z.ZodOptional<z.ZodUnknown>;
+        jsonrpc: z.ZodLiteral<"2.0">;
+        method: z.ZodString;
+    }, z.z.core.$strip>;
+}
+export declare const SUBSCRIBABLE_METHODS: {
+    readonly subscribeBestBlock: "unsubscribeBestBlock";
+    readonly subscribeFinalizedBlock: "unsubscribeFinalizedBlock";
+    readonly subscribeServiceData: "unsubscribeServiceData";
+    readonly subscribeServicePreimage: "unsubscribeServicePreimage";
+    readonly subscribeServiceRequest: "unsubscribeServiceRequest";
+    readonly subscribeServiceValue: "unsubscribeServiceValue";
+    readonly subscribeStatistics: "unsubscribeStatistics";
+};
+//# sourceMappingURL=validation.d.ts.map

package/packages/jam/rpc-validation/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/rpc-validation/validation.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,gBAAgB,QAAQ,CAAC;AACtC,yBAAiB,UAAU,CAAC;IAInB,MAAM,IAAI,gGAOhB,CAAC;IACK,MAAM,IAAI,aAAM,CAAC;IACjB,MAAM,SAAS,gGAGpB,CAAC;IACI,MAAM,SAAS,aAAM,CAAC;IACtB,MAAM,cAAc,aAAM,CAAC;IAC3B,MAAM,MAAM,sBAAc,CAAC;IAC3B,MAAM,eAAe;;;uBAG1B,CAAC;IAEI,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAwCrB,CAAC;IAEI,MAAM,oBAAoB;;;KAGhC,CAAC;IAEK,MAAM,iBAAiB;;;KAG7B,CAAC;IAEK,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2F8D,CAAC;IAE5E,MAAM,cAAc;;;;;uBAKzB,CAAC;IAEI,MAAM,mBAAmB;;;;uBAAoC,CAAC;CACtE;AAED,eAAO,MAAM,oBAAoB;;;;;;;;CAQqE,CAAC"}