@pezkuwi/rpc-provider 16.5.5 → 16.5.8

package/cjs/coder/error.js

@@ -0,0 +1,53 @@
+"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/cjs/coder/index.d.ts

@@ -0,0 +1,8 @@
+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/cjs/coder/index.js

@@ -0,0 +1,63 @@
+"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/cjs/defaults.d.ts

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

package/cjs/defaults.js

@@ -0,0 +1,8 @@
+"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/cjs/http/index.d.ts

@@ -0,0 +1,81 @@
+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>;
+}

package/cjs/http/index.js

@@ -0,0 +1,196 @@
+"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;

package/cjs/http/types.d.ts

@@ -0,0 +1,7 @@
+import type { Logger } from '@pezkuwi/util/types';
+import type { RpcCoder } from '../coder/index.js';
+export interface HttpState {
+    coder: RpcCoder;
+    endpoint: string;
+    l: Logger;
+}

package/cjs/http/types.js

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

package/cjs/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("./packageDetect.js");
+tslib_1.__exportStar(require("./bundle.js"), exports);

package/cjs/lru.d.ts

@@ -0,0 +1,15 @@
+export declare const DEFAULT_CAPACITY = 1024;
+export declare const DEFAULT_TTL = 30000;
+export declare class LRUCache {
+    #private;
+    readonly capacity: number;
+    constructor(capacity?: number, ttl?: number | null);
+    get ttl(): number | null;
+    get length(): number;
+    get lengthData(): number;
+    get lengthRefs(): number;
+    entries(): [string, unknown][];
+    keys(): string[];
+    get<T>(key: string): T | null;
+    set<T>(key: string, value: T): void;
+}

package/cjs/lru.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUCache = exports.DEFAULT_TTL = exports.DEFAULT_CAPACITY = void 0;
+exports.DEFAULT_CAPACITY = 1024;
+exports.DEFAULT_TTL = 30000; // 30 seconds
+const MAX_TTL = 1800_000; // 30 minutes
+const DISABLED_TTL = 31_536_000_000;
+class LRUNode {
+    key;
+    #expires;
+    #ttl;
+    createdAt;
+    next;
+    prev;
+    constructor(key, ttl) {
+        this.key = key;
+        this.#ttl = ttl;
+        this.#expires = Date.now() + ttl;
+        this.createdAt = Date.now();
+        this.next = this.prev = this;
+    }
+    refresh() {
+        this.#expires = Date.now() + this.#ttl;
+    }
+    get expiry() {
+        return this.#expires;
+    }
+}
+class LRUCache {
+    capacity;
+    #data = new Map();
+    #refs = new Map();
+    #length = 0;
+    #head;
+    #tail;
+    #ttl;
+    constructor(capacity = exports.DEFAULT_CAPACITY, ttl = exports.DEFAULT_TTL) {
+        // Validate capacity
+        if (!Number.isInteger(capacity) || capacity < 0) {
+            throw new Error(`LRUCache initialization error: 'capacity' must be a non-negative integer. Received: ${capacity}`);
+        }
+        // Validate ttl
+        if (ttl !== null && (!Number.isFinite(ttl) || ttl < 0 || ttl > MAX_TTL)) {
+            throw new Error(`LRUCache initialization error: 'ttl' must be between 0 and ${MAX_TTL} ms or null to disable. Received: ${ttl}`);
+        }
+        this.capacity = capacity;
+        ttl ? this.#ttl = ttl : this.#ttl = DISABLED_TTL;
+        this.#head = this.#tail = new LRUNode('<empty>', this.#ttl);
+    }
+    get ttl() {
+        return this.#ttl;
+    }
+    get length() {
+        return this.#length;
+    }
+    get lengthData() {
+        return this.#data.size;
+    }
+    get lengthRefs() {
+        return this.#refs.size;
+    }
+    entries() {
+        const keys = this.keys();
+        const count = keys.length;
+        const entries = new Array(count);
+        for (let i = 0; i < count; i++) {
+            const key = keys[i];
+            entries[i] = [key, this.#data.get(key)];
+        }
+        return entries;
+    }
+    keys() {
+        const keys = [];
+        if (this.#length) {
+            let curr = this.#head;
+            while (curr !== this.#tail) {
+                keys.push(curr.key);
+                curr = curr.next;
+            }
+            keys.push(curr.key);
+        }
+        return keys;
+    }
+    get(key) {
+        const data = this.#data.get(key);
+        if (data) {
+            this.#toHead(key);
+            // Evict TTL once data is refreshed
+            this.#evictTTL();
+            return data;
+        }
+        this.#evictTTL();
+        return null;
+    }
+    set(key, value) {
+        if (this.#data.has(key)) {
+            this.#toHead(key);
+        }
+        else {
+            const node = new LRUNode(key, this.#ttl);
+            this.#refs.set(node.key, node);
+            if (this.length === 0) {
+                this.#head = this.#tail = node;
+            }
+            else {
+                this.#head.prev = node;
+                node.next = this.#head;
+                this.#head = node;
+            }
+            if (this.#length === this.capacity) {
+                this.#data.delete(this.#tail.key);
+                this.#refs.delete(this.#tail.key);
+                this.#tail = this.#tail.prev;
+                this.#tail.next = this.#head;
+            }
+            else {
+                this.#length += 1;
+            }
+        }
+        // Evict TTL once data is refreshed or added
+        this.#evictTTL();
+        this.#data.set(key, value);
+    }
+    #evictTTL() {
+        // Find last node to keep
+        // traverse map to find the expired nodes
+        while (this.#tail.expiry && this.#tail.expiry < Date.now() && this.#length > 0) {
+            this.#refs.delete(this.#tail.key);
+            this.#data.delete(this.#tail.key);
+            this.#length -= 1;
+            this.#tail = this.#tail.prev;
+            this.#tail.next = this.#head;
+        }
+        if (this.#length === 0) {
+            this.#head = this.#tail = new LRUNode('<empty>', this.#ttl);
+        }
+    }
+    #toHead(key) {
+        const ref = this.#refs.get(key);
+        if (ref && ref !== this.#head) {
+            ref.refresh();
+            ref.prev.next = ref.next;
+            ref.next.prev = ref.prev;
+            ref.next = this.#head;
+            this.#head.prev = ref;
+            this.#head = ref;
+        }
+    }
+}
+exports.LRUCache = LRUCache;

package/cjs/mock/index.d.ts

@@ -0,0 +1,35 @@
+import type { Registry } from '@pezkuwi/types/types';
+import type { ProviderInterface, ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '../types.js';
+import type { MockStateSubscriptions } from './types.js';
+/**
+ * A mock provider mainly used for testing.
+ * @return {ProviderInterface} The mock provider
+ * @internal
+ */
+export declare class MockProvider implements ProviderInterface {
+    private db;
+    private emitter;
+    private intervalId?;
+    isUpdating: boolean;
+    private registry;
+    private prevNumber;
+    private requests;
+    subscriptions: MockStateSubscriptions;
+    private subscriptionId;
+    private subscriptionMap;
+    constructor(registry: Registry);
+    get hasSubscriptions(): boolean;
+    clone(): MockProvider;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    get isClonable(): boolean;
+    get isConnected(): boolean;
+    on(type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void;
+    send<T = any>(method: string, params: unknown[]): Promise<T>;
+    subscribe(_type: string, method: string, ...params: unknown[]): Promise<number>;
+    unsubscribe(_type: string, _method: string, id: number): Promise<boolean>;
+    private init;
+    private makeBlockHeader;
+    private setStateBn;
+    private updateSubs;
+}