@pezkuwi/rpc-provider 16.5.20 → 16.5.21

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.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.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.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.js

@@ -1,196 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpProvider = void 0;
-const tslib_1 = require("tslib");
-const util_1 = require("@pezkuwi/util");
-const x_fetch_1 = require("@pezkuwi/x-fetch");
-const index_js_1 = require("../coder/index.js");
-const defaults_js_1 = tslib_1.__importDefault(require("../defaults.js"));
-const lru_js_1 = require("../lru.js");
-const ERROR_SUBSCRIBE = 'HTTP Provider does not have subscriptions, use WebSockets instead';
-const l = (0, util_1.logger)('api-http');
-/**
- * # @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]]
- */
-class HttpProvider {
-    #callCache;
-    #cacheCapacity;
-    #coder;
-    #endpoint;
-    #headers;
-    #stats;
-    #ttl;
-    /**
-     * @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 = defaults_js_1.default.HTTP_URL, headers = {}, cacheCapacity, cacheTtl) {
-        if (!/^(https|http):\/\//.test(endpoint)) {
-            throw new Error(`Endpoint should start with 'http://' or 'https://', received '${endpoint}'`);
-        }
-        this.#coder = new index_js_1.RpcCoder();
-        this.#endpoint = endpoint;
-        this.#headers = headers;
-        this.#cacheCapacity = cacheCapacity === 0 ? 0 : cacheCapacity || lru_js_1.DEFAULT_CAPACITY;
-        const ttl = cacheTtl === undefined ? lru_js_1.DEFAULT_TTL : cacheTtl;
-        this.#callCache = new lru_js_1.LRUCache(cacheCapacity === 0 ? 0 : cacheCapacity || lru_js_1.DEFAULT_CAPACITY, ttl);
-        this.#ttl = cacheTtl;
-        this.#stats = {
-            active: { requests: 0, subscriptions: 0 },
-            total: { bytesRecv: 0, bytesSent: 0, cached: 0, errors: 0, requests: 0, subscriptions: 0, timeout: 0 }
-        };
-    }
-    /**
-     * @summary `true` when this provider supports subscriptions
-     */
-    get hasSubscriptions() {
-        return !!false;
-    }
-    /**
-     * @description Returns a clone of the object
-     */
-    clone() {
-        return new HttpProvider(this.#endpoint, this.#headers);
-    }
-    /**
-     * @description Manually connect from the connection
-     */
-    async connect() {
-        // noop
-    }
-    /**
-     * @description Manually disconnect from the connection
-     */
-    async disconnect() {
-        // noop
-    }
-    /**
-     * @description Returns the connection stats
-     */
-    get stats() {
-        return this.#stats;
-    }
-    /**
-    * @description Returns the connection stats
-    */
-    get ttl() {
-        return this.#ttl;
-    }
-    /**
-     * @summary `true` when this provider supports clone()
-     */
-    get isClonable() {
-        return !!true;
-    }
-    /**
-     * @summary Whether the node is connected or not.
-     * @return {boolean} true if connected
-     */
-    get isConnected() {
-        return !!true;
-    }
-    /**
-     * @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, _sub) {
-        l.error('HTTP Provider does not have \'on\' emitters, use WebSockets instead');
-        return util_1.noop;
-    }
-    /**
-     * @summary Send HTTP POST Request with Body to configured HTTP Endpoint.
-     */
-    async send(method, params, isCacheable) {
-        this.#stats.total.requests++;
-        const [, body] = this.#coder.encodeJson(method, params);
-        if (this.#cacheCapacity === 0) {
-            return this.#send(body);
-        }
-        const cacheKey = isCacheable ? `${method}::${(0, util_1.stringify)(params)}` : '';
-        let resultPromise = isCacheable
-            ? this.#callCache.get(cacheKey)
-            : null;
-        if (!resultPromise) {
-            resultPromise = this.#send(body);
-            if (isCacheable) {
-                this.#callCache.set(cacheKey, resultPromise);
-            }
-        }
-        else {
-            this.#stats.total.cached++;
-        }
-        return resultPromise;
-    }
-    async #send(body) {
-        this.#stats.active.requests++;
-        this.#stats.total.bytesSent += body.length;
-        try {
-            const response = await (0, x_fetch_1.fetch)(this.#endpoint, {
-                body,
-                headers: {
-                    Accept: 'application/json',
-                    'Content-Length': `${body.length}`,
-                    'Content-Type': 'application/json',
-                    ...this.#headers
-                },
-                method: 'POST'
-            });
-            if (!response.ok) {
-                throw new Error(`[${response.status}]: ${response.statusText}`);
-            }
-            const result = await response.text();
-            this.#stats.total.bytesRecv += result.length;
-            const decoded = this.#coder.decodeResponse(JSON.parse(result));
-            this.#stats.active.requests--;
-            return decoded;
-        }
-        catch (e) {
-            this.#stats.active.requests--;
-            this.#stats.total.errors++;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const { method, params } = JSON.parse(body);
-            const rpcError = e;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const failedRequest = `\nFailed HTTP Request: ${JSON.stringify({ method, params })}`;
-            // Provide HTTP Request alongside the error
-            rpcError.message = `${rpcError.message}${failedRequest}`;
-            throw rpcError;
-        }
-    }
-    /**
-     * @summary Subscriptions are not supported with the HttpProvider, see [[WsProvider]].
-     */
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async subscribe(_types, _method, _params, _cb) {
-        l.error(ERROR_SUBSCRIBE);
-        throw new Error(ERROR_SUBSCRIBE);
-    }
-    /**
-     * @summary Subscriptions are not supported with the HttpProvider, see [[WsProvider]].
-     */
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async unsubscribe(_type, _method, _id) {
-        l.error(ERROR_SUBSCRIBE);
-        throw new Error(ERROR_SUBSCRIBE);
-    }
-}
-exports.HttpProvider = HttpProvider;