@pezkuwi/rpc-provider 16.5.8 → 16.5.9

package/build/cjs/bizinikiwi-connect/index.js

@@ -1,323 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScProvider = void 0;
-const eventemitter3_1 = require("eventemitter3");
-const util_1 = require("@pezkuwi/util");
-const index_js_1 = require("../coder/index.js");
-const Health_js_1 = require("./Health.js");
-const l = (0, util_1.logger)('api-bizinikiwi-connect');
-const subscriptionUnsubscriptionMethods = new Map([
-    ['author_submitAndWatchExtrinsic', 'author_unwatchExtrinsic'],
-    ['chain_subscribeAllHeads', 'chain_unsubscribeAllHeads'],
-    ['chain_subscribeFinalizedHeads', 'chain_unsubscribeFinalizedHeads'],
-    ['chain_subscribeFinalisedHeads', 'chain_subscribeFinalisedHeads'],
-    ['chain_subscribeNewHeads', 'chain_unsubscribeNewHeads'],
-    ['chain_subscribeNewHead', 'chain_unsubscribeNewHead'],
-    ['chain_subscribeRuntimeVersion', 'chain_unsubscribeRuntimeVersion'],
-    ['subscribe_newHead', 'unsubscribe_newHead'],
-    ['state_subscribeRuntimeVersion', 'state_unsubscribeRuntimeVersion'],
-    ['state_subscribeStorage', 'state_unsubscribeStorage']
-]);
-const scClients = new WeakMap();
-class ScProvider {
-    #Sc;
-    #coder = new index_js_1.RpcCoder();
-    #spec;
-    #sharedSandbox;
-    #subscriptions = new Map();
-    #resubscribeMethods = new Map();
-    #requests = new Map();
-    #wellKnownChains;
-    #eventemitter = new eventemitter3_1.EventEmitter();
-    #chain = null;
-    #isChainReady = false;
-    constructor(Sc, spec, sharedSandbox) {
-        if (!(0, util_1.isObject)(Sc) || !(0, util_1.isObject)(Sc.WellKnownChain) || !(0, util_1.isFunction)(Sc.createScClient)) {
-            throw new Error('Expected an @bizinikiwi/connect interface as first parameter to ScProvider');
-        }
-        this.#Sc = Sc;
-        this.#spec = spec;
-        this.#sharedSandbox = sharedSandbox;
-        this.#wellKnownChains = new Set(Object.values(Sc.WellKnownChain));
-    }
-    get hasSubscriptions() {
-        // Indicates that subscriptions are supported
-        return !!true;
-    }
-    get isClonable() {
-        return !!false;
-    }
-    get isConnected() {
-        return !!this.#chain && this.#isChainReady;
-    }
-    clone() {
-        throw new Error('clone() is not supported.');
-    }
-    // Config details can be found in @bizinikiwi/connect repo following the link:
-    // https://github.com/pezkuwichain/bizinikiwi-connect/blob/main/packages/connect/src/connector/index.ts
-    async connect(config, checkerFactory = Health_js_1.healthChecker) {
-        if (this.isConnected) {
-            throw new Error('Already connected!');
-        }
-        // it could happen that after emitting `disconnected` due to the fact that
-        // smoldot is syncing, the consumer tries to reconnect after a certain amount
-        // of time... In which case we want to make sure that we don't create a new
-        // chain.
-        if (this.#chain) {
-            await this.#chain;
-            return;
-        }
-        if (this.#sharedSandbox && !this.#sharedSandbox.isConnected) {
-            await this.#sharedSandbox.connect();
-        }
-        const client = this.#sharedSandbox
-            ? scClients.get(this.#sharedSandbox)
-            : this.#Sc.createScClient(config);
-        if (!client) {
-            throw new Error('Unknown ScProvider!');
-        }
-        scClients.set(this, client);
-        const hc = checkerFactory();
-        const onResponse = (res) => {
-            const hcRes = hc.responsePassThrough(res);
-            if (!hcRes) {
-                return;
-            }
-            const response = JSON.parse(hcRes);
-            let decodedResponse;
-            try {
-                decodedResponse = this.#coder.decodeResponse(response);
-            }
-            catch (e) {
-                decodedResponse = e;
-            }
-            // It's not a subscription message, but rather a standar RPC response
-            if (response.params?.subscription === undefined || !response.method) {
-                return this.#requests.get(response.id)?.(decodedResponse);
-            }
-            // We are dealing with a subscription message
-            const subscriptionId = `${response.method}::${response.params.subscription}`;
-            const callback = this.#subscriptions.get(subscriptionId)?.[0];
-            callback?.(decodedResponse);
-        };
-        const addChain = this.#sharedSandbox
-            ? (async (...args) => {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const source = this.#sharedSandbox;
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                return (await source.#chain).addChain(...args);
-            })
-            : this.#wellKnownChains.has(this.#spec)
-                ? client.addWellKnownChain
-                : client.addChain;
-        this.#chain = addChain(this.#spec).then((chain) => {
-            hc.setSendJsonRpc(chain.sendJsonRpc);
-            // Start async response processing loop
-            // This replaces the callback-based API from older @substrate/connect versions
-            (async () => {
-                try {
-                    for await (const res of chain.jsonRpcResponses) {
-                        onResponse(res);
-                    }
-                }
-                catch {
-                    // Chain was removed or connection closed - this is expected
-                }
-            })();
-            this.#isChainReady = false;
-            const cleanup = () => {
-                // If there are any callbacks left, we have to reject/error them.
-                // Otherwise, that would cause a memory leak.
-                const disconnectionError = new Error('Disconnected');
-                this.#requests.forEach((cb) => cb(disconnectionError));
-                this.#subscriptions.forEach(([cb]) => cb(disconnectionError));
-                this.#subscriptions.clear();
-            };
-            const staleSubscriptions = [];
-            const killStaleSubscriptions = () => {
-                if (staleSubscriptions.length === 0) {
-                    return;
-                }
-                const stale = staleSubscriptions.pop();
-                if (!stale) {
-                    throw new Error('Unable to get stale subscription');
-                }
-                const { id, unsubscribeMethod } = stale;
-                Promise
-                    .race([
-                    this.send(unsubscribeMethod, [id]).catch(util_1.noop),
-                    new Promise((resolve) => setTimeout(resolve, 500))
-                ])
-                    .then(killStaleSubscriptions)
-                    .catch(util_1.noop);
-            };
-            hc.start((health) => {
-                const isReady = !health.isSyncing && (health.peers > 0 || !health.shouldHavePeers);
-                // if it's the same as before, then nothing has changed and we are done
-                if (this.#isChainReady === isReady) {
-                    return;
-                }
-                this.#isChainReady = isReady;
-                if (!isReady) {
-                    // If we've reached this point, that means that the chain used to be "ready"
-                    // and now we are about to emit `disconnected`.
-                    //
-                    // This will cause the PezkuwiJs API think that the connection is
-                    // actually dead. In reality the smoldot chain is not dead, of course.
-                    // However, we have to cleanup all the existing callbacks because when
-                    // the smoldot chain stops syncing, then we will emit `connected` and
-                    // the PezkuwiJs API will try to re-create the previous
-                    // subscriptions and requests. Although, now is not a good moment
-                    // to be sending unsubscription messages to the smoldot chain, we
-                    // should wait until is no longer syncing to send the unsubscription
-                    // messages from the stale subscriptions of the previous connection.
-                    //
-                    // That's why -before we perform the cleanup of `this.#subscriptions`-
-                    // we keep the necessary information that we will need later on to
-                    // kill the stale subscriptions.
-                    [...this.#subscriptions.values()].forEach((s) => {
-                        staleSubscriptions.push(s[1]);
-                    });
-                    cleanup();
-                    this.#eventemitter.emit('disconnected');
-                }
-                else {
-                    killStaleSubscriptions();
-                    this.#eventemitter.emit('connected');
-                    if (this.#resubscribeMethods.size) {
-                        this.#resubscribe();
-                    }
-                }
-            });
-            return (0, util_1.objectSpread)({}, chain, {
-                remove: () => {
-                    hc.stop();
-                    chain.remove();
-                    cleanup();
-                },
-                sendJsonRpc: hc.sendJsonRpc.bind(hc)
-            });
-        });
-        try {
-            await this.#chain;
-        }
-        catch (e) {
-            this.#chain = null;
-            this.#eventemitter.emit('error', e);
-            throw e;
-        }
-    }
-    #resubscribe = () => {
-        const promises = [];
-        this.#resubscribeMethods.forEach((subDetails) => {
-            // only re-create subscriptions which are not in author (only area where
-            // transactions are created, i.e. submissions such as 'author_submitAndWatchExtrinsic'
-            // are not included (and will not be re-broadcast)
-            if (subDetails.type.startsWith('author_')) {
-                return;
-            }
-            try {
-                const promise = new Promise((resolve) => {
-                    this.subscribe(subDetails.type, subDetails.method, subDetails.params, subDetails.callback).catch((error) => console.log(error));
-                    resolve();
-                });
-                promises.push(promise);
-            }
-            catch (error) {
-                l.error(error);
-            }
-        });
-        Promise.all(promises).catch((err) => l.log(err));
-    };
-    async disconnect() {
-        if (!this.#chain) {
-            return;
-        }
-        const chain = await this.#chain;
-        this.#chain = null;
-        this.#isChainReady = false;
-        try {
-            chain.remove();
-        }
-        catch (_) { }
-        this.#eventemitter.emit('disconnected');
-    }
-    on(type, sub) {
-        // It's possible. Although, quite unlikely, that by the time that pezkuwi
-        // subscribes to the `connected` event, the Provider is already connected.
-        // In that case, we must emit to let the consumer know that we are connected.
-        if (type === 'connected' && this.isConnected) {
-            sub();
-        }
-        this.#eventemitter.on(type, sub);
-        return () => {
-            this.#eventemitter.removeListener(type, sub);
-        };
-    }
-    async send(method, params) {
-        if (!this.isConnected || !this.#chain) {
-            throw new Error('Provider is not connected');
-        }
-        const chain = await this.#chain;
-        const [id, json] = this.#coder.encodeJson(method, params);
-        const result = new Promise((resolve, reject) => {
-            this.#requests.set(id, (response) => {
-                ((0, util_1.isError)(response) ? reject : resolve)(response);
-            });
-            try {
-                chain.sendJsonRpc(json);
-            }
-            catch (e) {
-                this.#chain = null;
-                try {
-                    chain.remove();
-                }
-                catch (_) { }
-                this.#eventemitter.emit('error', e);
-            }
-        });
-        try {
-            return await result;
-        }
-        finally {
-            // let's ensure that once the Promise is resolved/rejected, then we remove
-            // remove its entry from the internal #requests
-            this.#requests.delete(id);
-        }
-    }
-    async subscribe(type, method, params, callback) {
-        if (!subscriptionUnsubscriptionMethods.has(method)) {
-            throw new Error(`Unsupported subscribe method: ${method}`);
-        }
-        const id = await this.send(method, params);
-        const subscriptionId = `${type}::${id}`;
-        const cb = (response) => {
-            if (response instanceof Error) {
-                callback(response, undefined);
-            }
-            else {
-                callback(null, response);
-            }
-        };
-        const unsubscribeMethod = subscriptionUnsubscriptionMethods.get(method);
-        if (!unsubscribeMethod) {
-            throw new Error('Invalid unsubscribe method found');
-        }
-        this.#resubscribeMethods.set(subscriptionId, { callback, method, params, type });
-        this.#subscriptions.set(subscriptionId, [cb, { id, unsubscribeMethod }]);
-        return id;
-    }
-    unsubscribe(type, method, id) {
-        if (!this.isConnected) {
-            throw new Error('Provider is not connected');
-        }
-        const subscriptionId = `${type}::${id}`;
-        if (!this.#subscriptions.has(subscriptionId)) {
-            return Promise.reject(new Error(`Unable to find active subscription=${subscriptionId}`));
-        }
-        this.#resubscribeMethods.delete(subscriptionId);
-        this.#subscriptions.delete(subscriptionId);
-        return this.send(method, [id]);
-    }
-}
-exports.ScProvider = ScProvider;

package/build/cjs/bizinikiwi-connect/types.d.ts

@@ -1,12 +0,0 @@
-export interface SmoldotHealth {
-    isSyncing: boolean;
-    peers: number;
-    shouldHavePeers: boolean;
-}
-export interface HealthChecker {
-    setSendJsonRpc(sendRequest: (request: string) => void): void;
-    start(healthCallback: (health: SmoldotHealth) => void): void;
-    stop(): void;
-    sendJsonRpc(request: string): void;
-    responsePassThrough(response: string): string | null;
-}

package/build/cjs/bizinikiwi-connect/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/bundle.d.ts

@@ -1,5 +0,0 @@
-export { ScProvider } from './bizinikiwi-connect/index.js';
-export { HttpProvider } from './http/index.js';
-export { DEFAULT_CAPACITY, LRUCache } from './lru.js';
-export { packageInfo } from './packageInfo.js';
-export { WsProvider } from './ws/index.js';

package/build/cjs/bundle.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WsProvider = exports.packageInfo = exports.LRUCache = exports.DEFAULT_CAPACITY = exports.HttpProvider = exports.ScProvider = void 0;
-var index_js_1 = require("./bizinikiwi-connect/index.js");
-Object.defineProperty(exports, "ScProvider", { enumerable: true, get: function () { return index_js_1.ScProvider; } });
-var index_js_2 = require("./http/index.js");
-Object.defineProperty(exports, "HttpProvider", { enumerable: true, get: function () { return index_js_2.HttpProvider; } });
-var lru_js_1 = require("./lru.js");
-Object.defineProperty(exports, "DEFAULT_CAPACITY", { enumerable: true, get: function () { return lru_js_1.DEFAULT_CAPACITY; } });
-Object.defineProperty(exports, "LRUCache", { enumerable: true, get: function () { return lru_js_1.LRUCache; } });
-var packageInfo_js_1 = require("./packageInfo.js");
-Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
-var index_js_3 = require("./ws/index.js");
-Object.defineProperty(exports, "WsProvider", { enumerable: true, get: function () { return index_js_3.WsProvider; } });

package/build/cjs/coder/error.d.ts

@@ -1,29 +0,0 @@
-import type { RpcErrorInterface } from '../types.js';
-/**
- * @name RpcError
- * @summary Extension to the basic JS Error.
- * @description
- * The built-in JavaScript Error class is extended by adding a code to allow for Error categorization. In addition to the normal `stack`, `message`, the numeric `code` and `data` (any types) parameters are available on the object.
- * @example
- * <BR>
- *
- * ```javascript
- * const { RpcError } from '@pezkuwi/util');
- *
- * throw new RpcError('some message', RpcError.CODES.METHOD_NOT_FOUND); // => error.code = -32601
- * ```
- */
-export default class RpcError<T = never> extends Error implements RpcErrorInterface<T> {
-    code: number;
-    data?: T;
-    message: string;
-    name: string;
-    stack: string;
-    constructor(message?: string, code?: number, data?: T);
-    static CODES: {
-        ASSERT: number;
-        INVALID_JSONRPC: number;
-        METHOD_NOT_FOUND: number;
-        UNKNOWN: number;
-    };
-}

package/build/cjs/coder/error.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("@pezkuwi/util");
-const UNKNOWN = -99999;
-function extend(that, name, value) {
-    Object.defineProperty(that, name, {
-        configurable: true,
-        enumerable: false,
-        value
-    });
-}
-/**
- * @name RpcError
- * @summary Extension to the basic JS Error.
- * @description
- * The built-in JavaScript Error class is extended by adding a code to allow for Error categorization. In addition to the normal `stack`, `message`, the numeric `code` and `data` (any types) parameters are available on the object.
- * @example
- * <BR>
- *
- * ```javascript
- * const { RpcError } from '@pezkuwi/util');
- *
- * throw new RpcError('some message', RpcError.CODES.METHOD_NOT_FOUND); // => error.code = -32601
- * ```
- */
-class RpcError extends Error {
-    code;
-    data;
-    message;
-    name;
-    stack;
-    constructor(message = '', code = UNKNOWN, data) {
-        super();
-        extend(this, 'message', String(message));
-        extend(this, 'name', this.constructor.name);
-        extend(this, 'data', data);
-        extend(this, 'code', code);
-        if ((0, util_1.isFunction)(Error.captureStackTrace)) {
-            Error.captureStackTrace(this, this.constructor);
-        }
-        else {
-            const { stack } = new Error(message);
-            stack && extend(this, 'stack', stack);
-        }
-    }
-    static CODES = {
-        ASSERT: -90009,
-        INVALID_JSONRPC: -99998,
-        METHOD_NOT_FOUND: -32601, // Rust client
-        UNKNOWN
-    };
-}
-exports.default = RpcError;

package/build/cjs/coder/index.d.ts

@@ -1,8 +0,0 @@
-import type { JsonRpcRequest, JsonRpcResponse } from '../types.js';
-/** @internal */
-export declare class RpcCoder {
-    #private;
-    decodeResponse<T>(response?: JsonRpcResponse<T>): T;
-    encodeJson(method: string, params: unknown[]): [number, string];
-    encodeObject(method: string, params: unknown[]): [number, JsonRpcRequest];
-}

package/build/cjs/coder/index.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcCoder = void 0;
-const tslib_1 = require("tslib");
-const util_1 = require("@pezkuwi/util");
-const error_js_1 = tslib_1.__importDefault(require("./error.js"));
-function formatErrorData(data) {
-    if ((0, util_1.isUndefined)(data)) {
-        return '';
-    }
-    const formatted = `: ${(0, util_1.isString)(data)
-        ? data.replace(/Error\("/g, '').replace(/\("/g, '(').replace(/"\)/g, ')').replace(/\(/g, ', ').replace(/\)/g, '')
-        : (0, util_1.stringify)(data)}`;
-    // We need some sort of cut-off here since these can be very large and
-    // very nested, pick a number and trim the result display to it
-    return formatted.length <= 256
-        ? formatted
-        : `${formatted.substring(0, 255)}…`;
-}
-function checkError(error) {
-    if (error) {
-        const { code, data, message } = error;
-        throw new error_js_1.default(`${code}: ${message}${formatErrorData(data)}`, code, data);
-    }
-}
-/** @internal */
-class RpcCoder {
-    #id = 0;
-    decodeResponse(response) {
-        if (!response || response.jsonrpc !== '2.0') {
-            throw new Error('Invalid jsonrpc field in decoded object');
-        }
-        const isSubscription = !(0, util_1.isUndefined)(response.params) && !(0, util_1.isUndefined)(response.method);
-        if (!(0, util_1.isNumber)(response.id) &&
-            (!isSubscription || (!(0, util_1.isNumber)(response.params.subscription) &&
-                !(0, util_1.isString)(response.params.subscription)))) {
-            throw new Error('Invalid id field in decoded object');
-        }
-        checkError(response.error);
-        if (response.result === undefined && !isSubscription) {
-            throw new Error('No result found in jsonrpc response');
-        }
-        if (isSubscription) {
-            checkError(response.params.error);
-            return response.params.result;
-        }
-        return response.result;
-    }
-    encodeJson(method, params) {
-        const [id, data] = this.encodeObject(method, params);
-        return [id, (0, util_1.stringify)(data)];
-    }
-    encodeObject(method, params) {
-        const id = ++this.#id;
-        return [id, {
-                id,
-                jsonrpc: '2.0',
-                method,
-                params
-            }];
-    }
-}
-exports.RpcCoder = RpcCoder;

package/build/cjs/defaults.d.ts

@@ -1,5 +0,0 @@
-declare const _default: {
-    HTTP_URL: string;
-    WS_URL: string;
-};
-export default _default;

package/build/cjs/defaults.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const HTTP_URL = 'http://127.0.0.1:9933';
-const WS_URL = 'ws://127.0.0.1:9944';
-exports.default = {
-    HTTP_URL,
-    WS_URL
-};

package/build/cjs/http/index.d.ts

@@ -1,81 +0,0 @@
-import type { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted, ProviderStats } from '../types.js';
-/**
- * # @pezkuwi/rpc-provider
- *
- * @name HttpProvider
- *
- * @description The HTTP Provider allows sending requests using HTTP to a HTTP RPC server TCP port. It does not support subscriptions so you won't be able to listen to events such as new blocks or balance changes. It is usually preferable using the [[WsProvider]].
- *
- * @example
- * <BR>
- *
- * ```javascript
- * import Api from '@pezkuwi/api/promise';
- * import { HttpProvider } from '@pezkuwi/rpc-provider';
- *
- * const provider = new HttpProvider('http://127.0.0.1:9933');
- * const api = new Api(provider);
- * ```
- *
- * @see [[WsProvider]]
- */
-export declare class HttpProvider implements ProviderInterface {
-    #private;
-    /**
-     * @param {string} endpoint The endpoint url starting with http://
-     * @param {Record<string, string>} headers The headers provided to the underlying Http Endpoint
-     * @param {number} [cacheCapacity] Custom size of the HttpProvider LRUCache. Defaults to `DEFAULT_CAPACITY` (1024)
-     * @param {number} [cacheTtl] Custom TTL of the HttpProvider LRUCache. Determines how long an object can live in the cache. Defaults to `DEFAULT_TTL` (30000)
-     */
-    constructor(endpoint?: string, headers?: Record<string, string>, cacheCapacity?: number, cacheTtl?: number | null);
-    /**
-     * @summary `true` when this provider supports subscriptions
-     */
-    get hasSubscriptions(): boolean;
-    /**
-     * @description Returns a clone of the object
-     */
-    clone(): HttpProvider;
-    /**
-     * @description Manually connect from the connection
-     */
-    connect(): Promise<void>;
-    /**
-     * @description Manually disconnect from the connection
-     */
-    disconnect(): Promise<void>;
-    /**
-     * @description Returns the connection stats
-     */
-    get stats(): ProviderStats;
-    /**
-    * @description Returns the connection stats
-    */
-    get ttl(): number | null | undefined;
-    /**
-     * @summary `true` when this provider supports clone()
-     */
-    get isClonable(): boolean;
-    /**
-     * @summary Whether the node is connected or not.
-     * @return {boolean} true if connected
-     */
-    get isConnected(): boolean;
-    /**
-     * @summary Events are not supported with the HttpProvider, see [[WsProvider]].
-     * @description HTTP Provider does not have 'on' emitters. WebSockets should be used instead.
-     */
-    on(_type: ProviderInterfaceEmitted, _sub: ProviderInterfaceEmitCb): () => void;
-    /**
-     * @summary Send HTTP POST Request with Body to configured HTTP Endpoint.
-     */
-    send<T>(method: string, params: unknown[], isCacheable?: boolean): Promise<T>;
-    /**
-     * @summary Subscriptions are not supported with the HttpProvider, see [[WsProvider]].
-     */
-    subscribe(_types: string, _method: string, _params: unknown[], _cb: ProviderInterfaceCallback): Promise<number>;
-    /**
-     * @summary Subscriptions are not supported with the HttpProvider, see [[WsProvider]].
-     */
-    unsubscribe(_type: string, _method: string, _id: number): Promise<boolean>;
-}