@pezkuwi/rpc-provider 16.5.5 → 16.5.6

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

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

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.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.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.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.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.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.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.4' };

package/cjs/types.js

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

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)';
+}