@pezkuwi/rpc-provider 16.5.20 → 16.5.22

package/build-deno/http/index.ts

@@ -1,236 +0,0 @@
-
-import type RpcError from '../coder/error.ts';
-import type { JsonRpcResponse, ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted, ProviderStats } from '../types.ts';
-
-import { logger, noop, stringify } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { fetch } from 'https://deno.land/x/pezkuwi/x-fetch/mod.ts';
-
-import { RpcCoder } from '../coder/index.ts';
-import defaults from '../defaults.ts';
-import { DEFAULT_CAPACITY, DEFAULT_TTL, LRUCache } from '../lru.ts';
-
-const ERROR_SUBSCRIBE = 'HTTP Provider does not have subscriptions, use WebSockets instead';
-
-const l = 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 'https://deno.land/x/pezkuwi/api/promise/index.ts';
- * import { HttpProvider } from 'https://deno.land/x/pezkuwi/rpc-provider/mod.ts';
- *
- * const provider = new HttpProvider('http://127.0.0.1:9933');
- * const api = new Api(provider);
- * ```
- *
- * @see [[WsProvider]]
- */
-export class HttpProvider implements ProviderInterface {
-  readonly #callCache: LRUCache;
-  readonly #cacheCapacity: number;
-  readonly #coder: RpcCoder;
-  readonly #endpoint: string;
-  readonly #headers: Record<string, string>;
-  readonly #stats: ProviderStats;
-  readonly #ttl: number | null | undefined;
-
-  /**
-   * @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 = defaults.HTTP_URL, headers: Record<string, string> = {}, cacheCapacity?: number, cacheTtl?: number | null) {
-    if (!/^(https|http):\/\//.test(endpoint)) {
-      throw new Error(`Endpoint should start with 'http://' or 'https://', received '${endpoint}'`);
-    }
-
-    this.#coder = new RpcCoder();
-    this.#endpoint = endpoint;
-    this.#headers = headers;
-    this.#cacheCapacity = cacheCapacity === 0 ? 0 : cacheCapacity || DEFAULT_CAPACITY;
-
-    const ttl = cacheTtl === undefined ? DEFAULT_TTL : cacheTtl;
-
-    this.#callCache = new LRUCache(cacheCapacity === 0 ? 0 : cacheCapacity || 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
-   */
-  public get hasSubscriptions (): boolean {
-    return !!false;
-  }
-
-  /**
-   * @description Returns a clone of the object
-   */
-  public clone (): HttpProvider {
-    return new HttpProvider(this.#endpoint, this.#headers);
-  }
-
-  /**
-   * @description Manually connect from the connection
-   */
-  public async connect (): Promise<void> {
-    // noop
-  }
-
-  /**
-   * @description Manually disconnect from the connection
-   */
-  public async disconnect (): Promise<void> {
-    // noop
-  }
-
-  /**
-   * @description Returns the connection stats
-   */
-  public get stats (): ProviderStats {
-    return this.#stats;
-  }
-
-  /**
-  * @description Returns the connection stats
-  */
-  public get ttl (): number | null | undefined {
-    return this.#ttl;
-  }
-
-  /**
-   * @summary `true` when this provider supports clone()
-   */
-  public get isClonable (): boolean {
-    return !!true;
-  }
-
-  /**
-   * @summary Whether the node is connected or not.
-   * @return {boolean} true if connected
-   */
-  public get isConnected (): boolean {
-    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.
-   */
-  public on (_type: ProviderInterfaceEmitted, _sub: ProviderInterfaceEmitCb): () => void {
-    l.error('HTTP Provider does not have \'on\' emitters, use WebSockets instead');
-
-    return noop;
-  }
-
-  /**
-   * @summary Send HTTP POST Request with Body to configured HTTP Endpoint.
-   */
-  public async send <T> (method: string, params: unknown[], isCacheable?: boolean): Promise<T> {
-    this.#stats.total.requests++;
-
-    const [, body] = this.#coder.encodeJson(method, params);
-
-    if (this.#cacheCapacity === 0) {
-      return this.#send(body);
-    }
-
-    const cacheKey = isCacheable ? `${method}::${stringify(params)}` : '';
-    let resultPromise: Promise<T> | null = 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 <T> (body: string): Promise<T> {
-    this.#stats.active.requests++;
-    this.#stats.total.bytesSent += body.length;
-
-    try {
-      const response = await 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) as JsonRpcResponse<T>);
-
-      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: RpcError = e as RpcError;
-
-      // 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
-  public async subscribe (_types: string, _method: string, _params: unknown[], _cb: ProviderInterfaceCallback): Promise<number> {
-    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
-  public async unsubscribe (_type: string, _method: string, _id: number): Promise<boolean> {
-    l.error(ERROR_SUBSCRIBE);
-
-    throw new Error(ERROR_SUBSCRIBE);
-  }
-}

package/build-deno/http/types.ts

@@ -1,9 +0,0 @@
-
-import type { Logger } from 'https://deno.land/x/pezkuwi/util/types.ts';
-import type { RpcCoder } from '../coder/index.ts';
-
-export interface HttpState {
-  coder: RpcCoder;
-  endpoint: string;
-  l: Logger;
-}

package/build-deno/index.ts

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

package/build-deno/lru.ts

@@ -1,189 +0,0 @@
-
-
-export const DEFAULT_CAPACITY = 1024;
-export const DEFAULT_TTL = 30000; // 30 seconds
-const MAX_TTL = 1800_000; // 30 minutes
-
-const DISABLED_TTL = 31_536_000_000;
-
-class LRUNode {
-  readonly key: string;
-  #expires: number;
-  #ttl: number;
-  readonly createdAt: number;
-
-  public next: LRUNode;
-  public prev: LRUNode;
-
-  constructor (key: string, ttl: number) {
-    this.key = key;
-    this.#ttl = ttl;
-    this.#expires = Date.now() + ttl;
-    this.createdAt = Date.now();
-    this.next = this.prev = this;
-  }
-
-  public refresh (): void {
-    this.#expires = Date.now() + this.#ttl;
-  }
-
-  public get expiry (): number {
-    return this.#expires;
-  }
-}
-
-export class LRUCache {
-  readonly capacity: number;
-
-  readonly #data = new Map<string, unknown>();
-  readonly #refs = new Map<string, LRUNode>();
-
-  #length = 0;
-  #head: LRUNode;
-  #tail: LRUNode;
-
-  readonly #ttl: number;
-
-  constructor (capacity = DEFAULT_CAPACITY, ttl: number | null = 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 (): number | null {
-    return this.#ttl;
-  }
-
-  get length (): number {
-    return this.#length;
-  }
-
-  get lengthData (): number {
-    return this.#data.size;
-  }
-
-  get lengthRefs (): number {
-    return this.#refs.size;
-  }
-
-  entries (): [string, unknown][] {
-    const keys = this.keys();
-    const count = keys.length;
-    const entries = new Array<[string, unknown]>(count);
-
-    for (let i = 0; i < count; i++) {
-      const key = keys[i];
-
-      entries[i] = [key, this.#data.get(key)];
-    }
-
-    return entries;
-  }
-
-  keys (): string[] {
-    const keys: string[] = [];
-
-    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 <T> (key: string): T | null {
-    const data = this.#data.get(key);
-
-    if (data) {
-      this.#toHead(key);
-
-      // Evict TTL once data is refreshed
-      this.#evictTTL();
-
-      return data as T;
-    }
-
-    this.#evictTTL();
-
-    return null;
-  }
-
-  set <T> (key: string, value: T): void {
-    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: string): void {
-    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;
-    }
-  }
-}

package/build-deno/mock/index.ts

@@ -1,257 +0,0 @@
-
-/* eslint-disable camelcase */
-
-import type { Header } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
-import type { Codec, Registry } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
-import type { ProviderInterface, ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '../types.ts';
-import type { MockStateDb, MockStateSubscriptionCallback, MockStateSubscriptions } from './types.ts';
-
-import { EventEmitter } from 'https://esm.sh/eventemitter3@5.0.1';
-
-import { createTestKeyring } from 'https://deno.land/x/pezkuwi/keyring/testing.ts';
-import { decorateStorage, Metadata } from 'https://deno.land/x/pezkuwi/types/mod.ts';
-import jsonrpc from 'https://deno.land/x/pezkuwi/types/interfaces/jsonrpc.ts';
-import rpcHeader from 'https://deno.land/x/pezkuwi/json/Header.004.json' with { type: 'json' };
-import rpcSignedBlock from 'https://deno.land/x/pezkuwi/json/SignedBlock.004.immortal.json' with { type: 'json' };
-import rpcMetadata from 'https://deno.land/x/pezkuwi/types-support/metadata/static-bizinikiwi.ts';
-import { BN, bnToU8a, logger, u8aToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { randomAsU8a } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
-
-const INTERVAL = 1000;
-const SUBSCRIPTIONS: string[] = Array.prototype.concat.apply(
-  [],
-  Object.values(jsonrpc).map((section): string[] =>
-    Object
-      .values(section)
-      .filter(({ isSubscription }) => isSubscription)
-      .map(({ jsonrpc }) => jsonrpc)
-      .concat('chain_subscribeNewHead')
-  )
-) as string[];
-
-const keyring = createTestKeyring({ type: 'ed25519' });
-const l = logger('api-mock');
-
-/**
- * A mock provider mainly used for testing.
- * @return {ProviderInterface} The mock provider
- * @internal
- */
-export class MockProvider implements ProviderInterface {
-  private db: MockStateDb = {};
-
-  private emitter = new EventEmitter();
-
-  private intervalId?: ReturnType<typeof setInterval> | null;
-
-  public isUpdating = true;
-
-  private registry: Registry;
-
-  private prevNumber = new BN(-1);
-
-  private requests: Record<string, (...params: any[]) => unknown> = {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    chain_getBlock: () => this.registry.createType('SignedBlock', rpcSignedBlock.result).toJSON(),
-    chain_getBlockHash: () => '0x1234000000000000000000000000000000000000000000000000000000000000',
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    chain_getFinalizedHead: () => this.registry.createType('Header', rpcHeader.result).hash,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    chain_getHeader: () => this.registry.createType('Header', rpcHeader.result).toJSON(),
-    rpc_methods: () => this.registry.createType('RpcMethods').toJSON(),
-    state_getKeys: () => [],
-    state_getKeysPaged: () => [],
-    state_getMetadata: () => rpcMetadata,
-    state_getRuntimeVersion: () => this.registry.createType('RuntimeVersion').toHex(),
-    state_getStorage: (storage: MockStateDb, [key]: string[]) => 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: any) => params
-  };
-
-  public subscriptions: MockStateSubscriptions = SUBSCRIPTIONS.reduce((subs, name): MockStateSubscriptions => {
-    subs[name] = {
-      callbacks: {},
-      lastValue: null
-    };
-
-    return subs;
-  }, ({} as MockStateSubscriptions));
-
-  private subscriptionId = 0;
-
-  private subscriptionMap: Record<number, string> = {};
-
-  constructor (registry: Registry) {
-    this.registry = registry;
-
-    this.init();
-  }
-
-  public get hasSubscriptions (): boolean {
-    return !!true;
-  }
-
-  public clone (): MockProvider {
-    throw new Error('Unimplemented');
-  }
-
-  public async connect (): Promise<void> {
-    // noop
-  }
-
-  // eslint-disable-next-line @typescript-eslint/require-await
-  public async disconnect (): Promise<void> {
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-      this.intervalId = null;
-    }
-  }
-
-  public get isClonable (): boolean {
-    return !!false;
-  }
-
-  public get isConnected (): boolean {
-    return !!true;
-  }
-
-  public on (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void {
-    this.emitter.on(type, sub);
-
-    return (): void => {
-      this.emitter.removeListener(type, sub);
-    };
-  }
-
-  // eslint-disable-next-line @typescript-eslint/require-await
-  public async send <T = any> (method: string, params: unknown[]): Promise<T> {
-    l.debug(() => ['send', method, params]);
-
-    if (!this.requests[method]) {
-      throw new Error(`provider.send: Invalid method '${method}'`);
-    }
-
-    return this.requests[method](this.db, params) as T;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/require-await
-  public async subscribe (_type: string, method: string, ...params: unknown[]): Promise<number> {
-    l.debug(() => ['subscribe', method, params]);
-
-    if (!this.subscriptions[method]) {
-      throw new Error(`provider.subscribe: Invalid method '${method}'`);
-    }
-
-    const callback = params.pop() as MockStateSubscriptionCallback;
-    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
-  public async unsubscribe (_type: string, _method: string, id: number): Promise<boolean> {
-    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;
-  }
-
-  private init (): void {
-    const emitEvents: ProviderInterfaceEmitted[] = ['connected', 'disconnected'];
-    let emitIndex = 0;
-    let newHead = this.makeBlockHeader();
-    let counter = -1;
-
-    const metadata = new Metadata(this.registry, rpcMetadata);
-
-    this.registry.setMetadata(metadata);
-
-    const query = decorateStorage(this.registry, metadata.asLatest, metadata.version);
-
-    // Do something every 1 seconds
-    this.intervalId = setInterval((): void => {
-      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): void => {
-        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);
-  }
-
-  private makeBlockHeader (): Header {
-    const blockNumber = this.prevNumber.addn(1);
-    const header = this.registry.createType('Header', {
-      digest: {
-        logs: []
-      },
-      extrinsicsRoot: randomAsU8a(),
-      number: blockNumber,
-      parentHash: blockNumber.isZero()
-        ? new Uint8Array(32)
-        : bnToU8a(this.prevNumber, { bitLength: 256, isLe: false }),
-      stateRoot: bnToU8a(blockNumber, { bitLength: 256, isLe: false })
-    });
-
-    this.prevNumber = blockNumber;
-
-    return header as unknown as Header;
-  }
-
-  private setStateBn (key: Uint8Array, value: BN | number): void {
-    this.db[u8aToHex(key)] = bnToU8a(value, { bitLength: 64, isLe: true });
-  }
-
-  private updateSubs (method: string, value: Codec): void {
-    this.subscriptions[method].lastValue = value;
-
-    Object
-      .values(this.subscriptions[method].callbacks)
-      .forEach((cb): void => {
-        try {
-          cb(null, value.toJSON());
-        } catch (error) {
-          l.error(`Error on '${method}' subscription`, error);
-        }
-      });
-  }
-}