@pezkuwi/rpc-provider 16.5.5 → 16.5.8

package/cjs/mock/index.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockProvider = void 0;
+const tslib_1 = require("tslib");
+const eventemitter3_1 = require("eventemitter3");
+const testing_1 = require("@pezkuwi/keyring/testing");
+const types_1 = require("@pezkuwi/types");
+const jsonrpc_1 = tslib_1.__importDefault(require("@pezkuwi/types/interfaces/jsonrpc"));
+const Header_004_json_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/json/Header.004.json"));
+const SignedBlock_004_immortal_json_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/json/SignedBlock.004.immortal.json"));
+const static_bizinikiwi_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/static-bizinikiwi"));
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+const INTERVAL = 1000;
+const SUBSCRIPTIONS = Array.prototype.concat.apply([], Object.values(jsonrpc_1.default).map((section) => Object
+    .values(section)
+    .filter(({ isSubscription }) => isSubscription)
+    .map(({ jsonrpc }) => jsonrpc)
+    .concat('chain_subscribeNewHead')));
+const keyring = (0, testing_1.createTestKeyring)({ type: 'ed25519' });
+const l = (0, util_1.logger)('api-mock');
+/**
+ * A mock provider mainly used for testing.
+ * @return {ProviderInterface} The mock provider
+ * @internal
+ */
+class MockProvider {
+    db = {};
+    emitter = new eventemitter3_1.EventEmitter();
+    intervalId;
+    isUpdating = true;
+    registry;
+    prevNumber = new util_1.BN(-1);
+    requests = {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        chain_getBlock: () => this.registry.createType('SignedBlock', SignedBlock_004_immortal_json_1.default.result).toJSON(),
+        chain_getBlockHash: () => '0x1234000000000000000000000000000000000000000000000000000000000000',
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        chain_getFinalizedHead: () => this.registry.createType('Header', Header_004_json_1.default.result).hash,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        chain_getHeader: () => this.registry.createType('Header', Header_004_json_1.default.result).toJSON(),
+        rpc_methods: () => this.registry.createType('RpcMethods').toJSON(),
+        state_getKeys: () => [],
+        state_getKeysPaged: () => [],
+        state_getMetadata: () => static_bizinikiwi_1.default,
+        state_getRuntimeVersion: () => this.registry.createType('RuntimeVersion').toHex(),
+        state_getStorage: (storage, [key]) => (0, util_1.u8aToHex)(storage[key]),
+        system_chain: () => 'mockChain',
+        system_health: () => ({}),
+        system_name: () => 'mockClient',
+        system_properties: () => ({ ss58Format: 42 }),
+        system_upgradedToTripleRefCount: () => this.registry.createType('bool', true),
+        system_version: () => '9.8.7',
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, sort-keys
+        dev_echo: (_, params) => params
+    };
+    subscriptions = SUBSCRIPTIONS.reduce((subs, name) => {
+        subs[name] = {
+            callbacks: {},
+            lastValue: null
+        };
+        return subs;
+    }, {});
+    subscriptionId = 0;
+    subscriptionMap = {};
+    constructor(registry) {
+        this.registry = registry;
+        this.init();
+    }
+    get hasSubscriptions() {
+        return !!true;
+    }
+    clone() {
+        throw new Error('Unimplemented');
+    }
+    async connect() {
+        // noop
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async disconnect() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    get isClonable() {
+        return !!false;
+    }
+    get isConnected() {
+        return !!true;
+    }
+    on(type, sub) {
+        this.emitter.on(type, sub);
+        return () => {
+            this.emitter.removeListener(type, sub);
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async send(method, params) {
+        l.debug(() => ['send', method, params]);
+        if (!this.requests[method]) {
+            throw new Error(`provider.send: Invalid method '${method}'`);
+        }
+        return this.requests[method](this.db, params);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async subscribe(_type, method, ...params) {
+        l.debug(() => ['subscribe', method, params]);
+        if (!this.subscriptions[method]) {
+            throw new Error(`provider.subscribe: Invalid method '${method}'`);
+        }
+        const callback = params.pop();
+        const id = ++this.subscriptionId;
+        this.subscriptions[method].callbacks[id] = callback;
+        this.subscriptionMap[id] = method;
+        if (this.subscriptions[method].lastValue !== null) {
+            callback(null, this.subscriptions[method].lastValue);
+        }
+        return id;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async unsubscribe(_type, _method, id) {
+        const sub = this.subscriptionMap[id];
+        l.debug(() => ['unsubscribe', id, sub]);
+        if (!sub) {
+            throw new Error(`Unable to find subscription for ${id}`);
+        }
+        delete this.subscriptionMap[id];
+        delete this.subscriptions[sub].callbacks[id];
+        return true;
+    }
+    init() {
+        const emitEvents = ['connected', 'disconnected'];
+        let emitIndex = 0;
+        let newHead = this.makeBlockHeader();
+        let counter = -1;
+        const metadata = new types_1.Metadata(this.registry, static_bizinikiwi_1.default);
+        this.registry.setMetadata(metadata);
+        const query = (0, types_1.decorateStorage)(this.registry, metadata.asLatest, metadata.version);
+        // Do something every 1 seconds
+        this.intervalId = setInterval(() => {
+            if (!this.isUpdating) {
+                return;
+            }
+            // create a new header (next block)
+            newHead = this.makeBlockHeader();
+            // increment the balances and nonce for each account
+            keyring.getPairs().forEach(({ publicKey }, index) => {
+                this.setStateBn(query['system']['account'](publicKey), newHead.number.toBn().addn(index));
+            });
+            // set the timestamp for the current block
+            this.setStateBn(query['timestamp']['now'](), Math.floor(Date.now() / 1000));
+            this.updateSubs('chain_subscribeNewHead', newHead);
+            // We emit connected/disconnected at intervals
+            if (++counter % 2 === 1) {
+                if (++emitIndex === emitEvents.length) {
+                    emitIndex = 0;
+                }
+                this.emitter.emit(emitEvents[emitIndex]);
+            }
+        }, INTERVAL);
+    }
+    makeBlockHeader() {
+        const blockNumber = this.prevNumber.addn(1);
+        const header = this.registry.createType('Header', {
+            digest: {
+                logs: []
+            },
+            extrinsicsRoot: (0, util_crypto_1.randomAsU8a)(),
+            number: blockNumber,
+            parentHash: blockNumber.isZero()
+                ? new Uint8Array(32)
+                : (0, util_1.bnToU8a)(this.prevNumber, { bitLength: 256, isLe: false }),
+            stateRoot: (0, util_1.bnToU8a)(blockNumber, { bitLength: 256, isLe: false })
+        });
+        this.prevNumber = blockNumber;
+        return header;
+    }
+    setStateBn(key, value) {
+        this.db[(0, util_1.u8aToHex)(key)] = (0, util_1.bnToU8a)(value, { bitLength: 64, isLe: true });
+    }
+    updateSubs(method, value) {
+        this.subscriptions[method].lastValue = value;
+        Object
+            .values(this.subscriptions[method].callbacks)
+            .forEach((cb) => {
+            try {
+                cb(null, value.toJSON());
+            }
+            catch (error) {
+                l.error(`Error on '${method}' subscription`, error);
+            }
+        });
+    }
+}
+exports.MockProvider = MockProvider;

package/cjs/mock/mockHttp.d.ts

@@ -0,0 +1,9 @@
+import type { Mock } from './types.js';
+interface Request {
+    code?: number;
+    method: string;
+    reply?: Record<string, unknown>;
+}
+export declare const TEST_HTTP_URL = "http://localhost:9944";
+export declare function mockHttp(requests: Request[]): Mock;
+export {};

package/cjs/mock/mockHttp.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_HTTP_URL = void 0;
+exports.mockHttp = mockHttp;
+const tslib_1 = require("tslib");
+const nock_1 = tslib_1.__importDefault(require("nock"));
+exports.TEST_HTTP_URL = 'http://localhost:9944';
+function mockHttp(requests) {
+    nock_1.default.cleanAll();
+    return requests.reduce((scope, request) => scope
+        .post('/')
+        .reply(request.code || 200, (_uri, body) => {
+        scope.body = scope.body || {};
+        scope.body[request.method] = body;
+        return Object.assign({ id: body.id, jsonrpc: '2.0' }, request.reply || {});
+    }), (0, nock_1.default)(exports.TEST_HTTP_URL));
+}

package/cjs/mock/mockWs.d.ts

@@ -0,0 +1,26 @@
+import { Server } from 'mock-socket';
+interface Scope {
+    body: Record<string, Record<string, unknown>>;
+    requests: number;
+    server: Server;
+    done: any;
+}
+interface ErrorDef {
+    id: number;
+    error: {
+        code: number;
+        message: string;
+    };
+}
+interface ReplyDef {
+    id: number;
+    reply: {
+        result: unknown;
+    };
+}
+export type Request = {
+    method: string;
+} & (ErrorDef | ReplyDef);
+export declare const TEST_WS_URL = "ws://localhost:9955";
+export declare function mockWs(requests: Request[], wsUrl?: string): Scope;
+export {};

package/cjs/mock/mockWs.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_WS_URL = void 0;
+exports.mockWs = mockWs;
+const mock_socket_1 = require("mock-socket");
+const util_1 = require("@pezkuwi/util");
+global.WebSocket = mock_socket_1.WebSocket;
+exports.TEST_WS_URL = 'ws://localhost:9955';
+function createError({ error: { code, message }, id }) {
+    return {
+        error: {
+            code,
+            message
+        },
+        id,
+        jsonrpc: '2.0'
+    };
+}
+function createReply({ id, reply: { result } }) {
+    return {
+        id,
+        jsonrpc: '2.0',
+        result
+    };
+}
+function mockWs(requests, wsUrl = exports.TEST_WS_URL) {
+    const server = new mock_socket_1.Server(wsUrl);
+    let requestCount = 0;
+    const scope = {
+        body: {},
+        done: () => new Promise((resolve) => server.stop(resolve)),
+        requests: 0,
+        server
+    };
+    server.on('connection', (socket) => {
+        socket.on('message', (body) => {
+            const request = requests[requestCount];
+            const response = request.error
+                ? createError(request)
+                : createReply(request);
+            scope.body[request.method] = body;
+            requestCount++;
+            socket.send((0, util_1.stringify)(response));
+        });
+    });
+    return scope;
+}

package/cjs/mock/types.d.ts

@@ -0,0 +1,23 @@
+import type { Server } from 'mock-socket';
+export type Global = typeof globalThis & {
+    WebSocket: typeof WebSocket;
+    fetch: any;
+};
+export interface Mock {
+    body: Record<string, Record<string, unknown>>;
+    requests: number;
+    server: Server;
+    done: () => Promise<void>;
+}
+export type MockStateSubscriptionCallback = (error: Error | null, value: any) => void;
+export interface MockStateSubscription {
+    callbacks: Record<number, MockStateSubscriptionCallback>;
+    lastValue: any;
+}
+export interface MockStateSubscriptions {
+    chain_subscribeNewHead: MockStateSubscription;
+    state_subscribeStorage: MockStateSubscription;
+    [key: string]: MockStateSubscription;
+}
+export type MockStateDb = Record<string, Uint8Array>;
+export type MockStateRequests = Record<string, (db: MockStateDb, params: any[]) => string>;

package/cjs/mock/types.js

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

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/cjs/packageDetect.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageInfo_1 = require("@pezkuwi/types/cjs/packageInfo");
+const util_1 = require("@pezkuwi/util");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_1.packageInfo]);

package/cjs/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/cjs/packageInfo.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: '@pezkuwi/rpc-provider', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.8' };

package/cjs/types.d.ts

@@ -0,0 +1,85 @@
+export interface JsonRpcObject {
+    id: number;
+    jsonrpc: '2.0';
+}
+export interface JsonRpcRequest extends JsonRpcObject {
+    method: string;
+    params: unknown[];
+}
+export interface JsonRpcResponseBaseError {
+    code: number;
+    data?: number | string;
+    message: string;
+}
+export interface RpcErrorInterface<T> {
+    code: number;
+    data?: T;
+    message: string;
+    stack: string;
+}
+interface JsonRpcResponseSingle<T> {
+    error?: JsonRpcResponseBaseError;
+    result: T;
+}
+interface JsonRpcResponseSubscription<T> {
+    method?: string;
+    params: {
+        error?: JsonRpcResponseBaseError;
+        result: T;
+        subscription: number | string;
+    };
+}
+export type JsonRpcResponseBase<T> = JsonRpcResponseSingle<T> & JsonRpcResponseSubscription<T>;
+export type JsonRpcResponse<T> = JsonRpcObject & JsonRpcResponseBase<T>;
+export type ProviderInterfaceCallback = (error: Error | null, result: any) => void;
+export type ProviderInterfaceEmitted = 'connected' | 'disconnected' | 'error';
+export type ProviderInterfaceEmitCb = (value?: any) => any;
+export interface ProviderInterface {
+    /** true if the provider supports subscriptions (not available for HTTP) */
+    readonly hasSubscriptions: boolean;
+    /** true if the clone() functionality is available on the provider */
+    readonly isClonable: boolean;
+    /** true if the provider is currently connected (ws/sc has connection logic) */
+    readonly isConnected: boolean;
+    /** (optional) stats for the provider with connections/bytes */
+    readonly stats?: ProviderStats;
+    /** (optional) stats for the provider with connections/bytes */
+    readonly ttl?: number | null;
+    clone(): ProviderInterface;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    on(type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void;
+    send<T = any>(method: string, params: unknown[], isCacheable?: boolean): Promise<T>;
+    subscribe(type: string, method: string, params: unknown[], cb: ProviderInterfaceCallback): Promise<number | string>;
+    unsubscribe(type: string, method: string, id: number | string): Promise<boolean>;
+}
+/** Stats for a specific endpoint */
+export interface EndpointStats {
+    /** The total number of bytes sent */
+    bytesRecv: number;
+    /** The total number of bytes received */
+    bytesSent: number;
+    /** The number of cached/in-progress requests made */
+    cached: number;
+    /** The number of errors found */
+    errors: number;
+    /** The number of requests */
+    requests: number;
+    /** The number of subscriptions */
+    subscriptions: number;
+    /** The number of request timeouts */
+    timeout: number;
+}
+/** Overall stats for the provider */
+export interface ProviderStats {
+    /** Details for the active/open requests */
+    active: {
+        /** Number of active requests */
+        requests: number;
+        /** Number of active subscriptions */
+        subscriptions: number;
+    };
+    /** The total requests that have been made */
+    total: EndpointStats;
+}
+export {};

package/cjs/types.js

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

package/cjs/ws/errors.d.ts

@@ -0,0 +1 @@
+export declare function getWSErrorString(code: number): string;

package/cjs/ws/errors.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWSErrorString = getWSErrorString;
+const known = {
+    1000: 'Normal Closure',
+    1001: 'Going Away',
+    1002: 'Protocol Error',
+    1003: 'Unsupported Data',
+    1004: '(For future)',
+    1005: 'No Status Received',
+    1006: 'Abnormal Closure',
+    1007: 'Invalid frame payload data',
+    1008: 'Policy Violation',
+    1009: 'Message too big',
+    1010: 'Missing Extension',
+    1011: 'Internal Error',
+    1012: 'Service Restart',
+    1013: 'Try Again Later',
+    1014: 'Bad Gateway',
+    1015: 'TLS Handshake'
+};
+function getWSErrorString(code) {
+    if (code >= 0 && code <= 999) {
+        return '(Unused)';
+    }
+    else if (code >= 1016) {
+        if (code <= 1999) {
+            return '(For WebSocket standard)';
+        }
+        else if (code <= 2999) {
+            return '(For WebSocket extensions)';
+        }
+        else if (code <= 3999) {
+            return '(For libraries and frameworks)';
+        }
+        else if (code <= 4999) {
+            return '(For applications)';
+        }
+    }
+    return known[code] || '(Unknown)';
+}

package/cjs/ws/index.d.ts

@@ -0,0 +1,121 @@
+import type { EndpointStats, ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted, ProviderStats } from '../types.js';
+interface SubscriptionHandler {
+    callback: ProviderInterfaceCallback;
+    type: string;
+}
+/**
+ * # @pezkuwi/rpc-provider/ws
+ *
+ * @name WsProvider
+ *
+ * @description The WebSocket Provider allows sending requests using WebSocket to a WebSocket RPC server TCP port. Unlike the [[HttpProvider]], it does support subscriptions and allows listening to events such as new blocks or balance changes.
+ *
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import Api from '@pezkuwi/api/promise';
+ * import { WsProvider } from '@pezkuwi/rpc-provider/ws';
+ *
+ * const provider = new WsProvider('ws://127.0.0.1:9944');
+ * const api = new Api(provider);
+ * ```
+ *
+ * @see [[HttpProvider]]
+ */
+export declare class WsProvider implements ProviderInterface {
+    #private;
+    /**
+     * @param {string | string[]} endpoint The endpoint url. Usually `ws://ip:9944` or `wss://ip:9944`, may provide an array of endpoint strings.
+     * @param {number | false} autoConnectMs Whether to connect automatically or not (default). Provided value is used as a delay between retries.
+     * @param {Record<string, string>} headers The headers provided to the underlying WebSocket
+     * @param {number} [timeout] Custom timeout value used per request . Defaults to `DEFAULT_TIMEOUT_MS`
+     * @param {number} [cacheCapacity] Custom size of the WsProvider LRUCache. Defaults to `DEFAULT_CAPACITY` (1024)
+     * @param {number} [cacheTtl] Custom TTL of the WsProvider LRUCache. Determines how long an object can live in the cache. Defaults to DEFAULT_TTL` (30000)
+     */
+    constructor(endpoint?: string | string[], autoConnectMs?: number | false, headers?: Record<string, string>, timeout?: number, cacheCapacity?: number, cacheTtl?: number | null);
+    /**
+     * @summary `true` when this provider supports subscriptions
+     */
+    get hasSubscriptions(): boolean;
+    /**
+     * @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;
+    /**
+     * @description Promise that resolves the first time we are connected and loaded
+     */
+    get isReady(): Promise<WsProvider>;
+    get endpoint(): string;
+    /**
+     * @description Returns a clone of the object
+     */
+    clone(): WsProvider;
+    protected selectEndpointIndex(endpoints: string[]): number;
+    /**
+     * @summary Manually connect
+     * @description The [[WsProvider]] connects automatically by default, however if you decided otherwise, you may
+     * connect manually using this method.
+     */
+    connect(): Promise<void>;
+    /**
+     * @description Connect, never throwing an error, but rather forcing a retry
+     */
+    connectWithRetry(): Promise<void>;
+    /**
+     * @description Manually disconnect from the connection, clearing auto-connect logic
+     */
+    disconnect(): Promise<void>;
+    /**
+     * @description Returns the connection stats
+     */
+    get stats(): ProviderStats;
+    /**
+    * @description Returns the connection stats
+    */
+    get ttl(): number | null | undefined;
+    get endpointStats(): EndpointStats;
+    /**
+     * @summary Listens on events after having subscribed using the [[subscribe]] function.
+     * @param  {ProviderInterfaceEmitted} type Event
+     * @param  {ProviderInterfaceEmitCb}  sub  Callback
+     * @return unsubscribe function
+     */
+    on(type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void;
+    /**
+     * @summary Send JSON data using WebSockets to configured HTTP Endpoint or queue.
+     * @param method The RPC methods to execute
+     * @param params Encoded parameters as applicable for the method
+     * @param subscription Subscription details (internally used)
+     */
+    send<T = any>(method: string, params: unknown[], isCacheable?: boolean, subscription?: SubscriptionHandler): Promise<T>;
+    /**
+     * @name subscribe
+     * @summary Allows subscribing to a specific event.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * const provider = new WsProvider('ws://127.0.0.1:9944');
+     * const rpc = new Rpc(provider);
+     *
+     * rpc.state.subscribeStorage([[storage.system.account, <Address>]], (_, values) => {
+     *   console.log(values)
+     * }).then((subscriptionId) => {
+     *   console.log('balance changes subscription id: ', subscriptionId)
+     * })
+     * ```
+     */
+    subscribe(type: string, method: string, params: unknown[], callback: ProviderInterfaceCallback): Promise<number | string>;
+    /**
+     * @summary Allows unsubscribing to subscriptions made with [[subscribe]].
+     */
+    unsubscribe(type: string, method: string, id: number | string): Promise<boolean>;
+}
+export {};