@pezkuwi/rpc-provider 16.5.5 → 16.5.6

package/src/substrate-connect/index.ts

@@ -1,415 +0,0 @@
-// Copyright 2017-2025 @polkadot/rpc-provider authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type * as ScType from '@substrate/connect';
-import type { JsonRpcResponse, ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '../types.js';
-
-import { EventEmitter } from 'eventemitter3';
-
-import { isError, isFunction, isObject, logger, noop, objectSpread } from '@pezkuwi/util';
-
-import { RpcCoder } from '../coder/index.js';
-import { healthChecker } from './Health.js';
-
-type ResponseCallback = (response: string | Error) => void;
-
-// We define the interface with items we use - this means that we don't really
-// need to be passed a full `import * as Sc from '@ubstrate/connect'`, but can
-// also make do with a { WellKnownChain, createScClient } interface
-interface SubstrateConnect {
-  WellKnownChain: typeof ScType['WellKnownChain'];
-  createScClient: typeof ScType['createScClient'];
-}
-
-const l = logger('api-substrate-connect');
-
-// These methods have been taken from:
-// https://github.com/paritytech/smoldot/blob/17425040ddda47d539556eeaf62b88c4240d1d42/src/json_rpc/methods.rs#L338-L462
-// It's important to take into account that smoldot is adding support to the new
-// json-rpc-interface https://paritytech.github.io/json-rpc-interface-spec/
-// However, at the moment this list only includes methods that belong to the "old" API
-const subscriptionUnsubscriptionMethods = new Map<string, string>([
-  ['author_submitAndWatchExtrinsic', 'author_unwatchExtrinsic'],
-  ['chain_subscribeAllHeads', 'chain_unsubscribeAllHeads'],
-  ['chain_subscribeFinalizedHeads', 'chain_unsubscribeFinalizedHeads'],
-  ['chain_subscribeFinalisedHeads', 'chain_subscribeFinalisedHeads'],
-  ['chain_subscribeNewHeads', 'chain_unsubscribeNewHeads'],
-  ['chain_subscribeNewHead', 'chain_unsubscribeNewHead'],
-  ['chain_subscribeRuntimeVersion', 'chain_unsubscribeRuntimeVersion'],
-  ['subscribe_newHead', 'unsubscribe_newHead'],
-  ['state_subscribeRuntimeVersion', 'state_unsubscribeRuntimeVersion'],
-  ['state_subscribeStorage', 'state_unsubscribeStorage']
-]);
-
-const scClients = new WeakMap<ScProvider, ScType.ScClient>();
-
-interface ActiveSubs {
-  type: string,
-  method: string,
-  params: any[],
-  callback: ProviderInterfaceCallback
-}
-
-export class ScProvider implements ProviderInterface {
-  readonly #Sc: SubstrateConnect;
-  readonly #coder: RpcCoder = new RpcCoder();
-  readonly #spec: string | ScType.WellKnownChain;
-  readonly #sharedSandbox?: ScProvider | undefined;
-  readonly #subscriptions = new Map<string, [ResponseCallback, { unsubscribeMethod: string; id: string | number }]>();
-  readonly #resubscribeMethods = new Map<string, ActiveSubs>();
-  readonly #requests = new Map<number, ResponseCallback>();
-  readonly #wellKnownChains: Set<ScType.WellKnownChain>;
-  readonly #eventemitter: EventEmitter = new EventEmitter();
-
-  #chain: Promise<ScType.Chain> | null = null;
-  #isChainReady = false;
-
-  public constructor (Sc: SubstrateConnect, spec: string | ScType.WellKnownChain, sharedSandbox?: ScProvider) {
-    if (!isObject(Sc) || !isObject(Sc.WellKnownChain) || !isFunction(Sc.createScClient)) {
-      throw new Error('Expected an @substrate/connect interface as first parameter to ScProvider');
-    }
-
-    this.#Sc = Sc;
-    this.#spec = spec;
-    this.#sharedSandbox = sharedSandbox;
-    this.#wellKnownChains = new Set(Object.values(Sc.WellKnownChain));
-  }
-
-  public get hasSubscriptions (): boolean {
-    // Indicates that subscriptions are supported
-    return !!true;
-  }
-
-  public get isClonable (): boolean {
-    return !!false;
-  }
-
-  public get isConnected (): boolean {
-    return !!this.#chain && this.#isChainReady;
-  }
-
-  public clone (): ProviderInterface {
-    throw new Error('clone() is not supported.');
-  }
-
-  // Config details can be found in @substrate/connect repo following the link:
-  // https://github.com/paritytech/substrate-connect/blob/main/packages/connect/src/connector/index.ts
-  async connect (config?: ScType.Config, checkerFactory = healthChecker): Promise<void> {
-    if (this.isConnected) {
-      throw new Error('Already connected!');
-    }
-
-    // it could happen that after emitting `disconnected` due to the fact that
-    // smoldot is syncing, the consumer tries to reconnect after a certain amount
-    // of time... In which case we want to make sure that we don't create a new
-    // chain.
-    if (this.#chain) {
-      await this.#chain;
-
-      return;
-    }
-
-    if (this.#sharedSandbox && !this.#sharedSandbox.isConnected) {
-      await this.#sharedSandbox.connect();
-    }
-
-    const client = this.#sharedSandbox
-      ? scClients.get(this.#sharedSandbox)
-      : this.#Sc.createScClient(config);
-
-    if (!client) {
-      throw new Error('Unknown ScProvider!');
-    }
-
-    scClients.set(this, client);
-
-    const hc = checkerFactory();
-
-    const onResponse = (res: string): void => {
-      const hcRes = hc.responsePassThrough(res);
-
-      if (!hcRes) {
-        return;
-      }
-
-      const response = JSON.parse(hcRes) as JsonRpcResponse<string>;
-      let decodedResponse: string | Error;
-
-      try {
-        decodedResponse = this.#coder.decodeResponse(response);
-      } catch (e) {
-        decodedResponse = e as Error;
-      }
-
-      // It's not a subscription message, but rather a standar RPC response
-      if (response.params?.subscription === undefined || !response.method) {
-        return this.#requests.get(response.id)?.(decodedResponse);
-      }
-
-      // We are dealing with a subscription message
-      const subscriptionId = `${response.method}::${response.params.subscription}`;
-
-      const callback = this.#subscriptions.get(subscriptionId)?.[0];
-
-      callback?.(decodedResponse);
-    };
-
-    const addChain = this.#sharedSandbox
-      ? (async (...args) => {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const source = this.#sharedSandbox!;
-
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return (await source.#chain)!.addChain(...args);
-      }) as ScType.AddChain
-      : this.#wellKnownChains.has(this.#spec as ScType.WellKnownChain)
-        ? client.addWellKnownChain
-        : client.addChain;
-
-    this.#chain = addChain(this.#spec as ScType.WellKnownChain, onResponse).then((chain) => {
-      hc.setSendJsonRpc(chain.sendJsonRpc);
-
-      this.#isChainReady = false;
-
-      const cleanup = () => {
-        // If there are any callbacks left, we have to reject/error them.
-        // Otherwise, that would cause a memory leak.
-        const disconnectionError = new Error('Disconnected');
-
-        this.#requests.forEach((cb) => cb(disconnectionError));
-        this.#subscriptions.forEach(([cb]) => cb(disconnectionError));
-        this.#subscriptions.clear();
-      };
-
-      const staleSubscriptions: {
-        unsubscribeMethod: string
-        id: number | string
-      }[] = [];
-
-      const killStaleSubscriptions = () => {
-        if (staleSubscriptions.length === 0) {
-          return;
-        }
-
-        const stale = staleSubscriptions.pop();
-
-        if (!stale) {
-          throw new Error('Unable to get stale subscription');
-        }
-
-        const { id, unsubscribeMethod } = stale;
-
-        Promise
-          .race([
-            this.send(unsubscribeMethod, [id]).catch(noop),
-            new Promise((resolve) => setTimeout(resolve, 500))
-          ])
-          .then(killStaleSubscriptions)
-          .catch(noop);
-      };
-
-      hc.start((health) => {
-        const isReady =
-          !health.isSyncing && (health.peers > 0 || !health.shouldHavePeers);
-
-        // if it's the same as before, then nothing has changed and we are done
-        if (this.#isChainReady === isReady) {
-          return;
-        }
-
-        this.#isChainReady = isReady;
-
-        if (!isReady) {
-          // If we've reached this point, that means that the chain used to be "ready"
-          // and now we are about to emit `disconnected`.
-          //
-          // This will cause the PolkadotJs API think that the connection is
-          // actually dead. In reality the smoldot chain is not dead, of course.
-          // However, we have to cleanup all the existing callbacks because when
-          // the smoldot chain stops syncing, then we will emit `connected` and
-          // the PolkadotJs API will try to re-create the previous
-          // subscriptions and requests. Although, now is not a good moment
-          // to be sending unsubscription messages to the smoldot chain, we
-          // should wait until is no longer syncing to send the unsubscription
-          // messages from the stale subscriptions of the previous connection.
-          //
-          // That's why -before we perform the cleanup of `this.#subscriptions`-
-          // we keep the necessary information that we will need later on to
-          // kill the stale subscriptions.
-          [...this.#subscriptions.values()].forEach((s) => {
-            staleSubscriptions.push(s[1]);
-          });
-          cleanup();
-
-          this.#eventemitter.emit('disconnected');
-        } else {
-          killStaleSubscriptions();
-
-          this.#eventemitter.emit('connected');
-
-          if (this.#resubscribeMethods.size) {
-            this.#resubscribe();
-          }
-        }
-      });
-
-      return objectSpread({}, chain, {
-        remove: () => {
-          hc.stop();
-          chain.remove();
-          cleanup();
-        },
-        sendJsonRpc: hc.sendJsonRpc.bind(hc)
-      });
-    });
-
-    try {
-      await this.#chain;
-    } catch (e) {
-      this.#chain = null;
-      this.#eventemitter.emit('error', e);
-      throw e;
-    }
-  }
-
-  #resubscribe = (): void => {
-    const promises: any[] = [];
-
-    this.#resubscribeMethods.forEach((subDetails: ActiveSubs): void => {
-      // only re-create subscriptions which are not in author (only area where
-      // transactions are created, i.e. submissions such as 'author_submitAndWatchExtrinsic'
-      // are not included (and will not be re-broadcast)
-      if (subDetails.type.startsWith('author_')) {
-        return;
-      }
-
-      try {
-        const promise = new Promise<void>((resolve) => {
-          this.subscribe(subDetails.type, subDetails.method, subDetails.params, subDetails.callback).catch((error) => console.log(error));
-          resolve();
-        });
-
-        promises.push(promise);
-      } catch (error) {
-        l.error(error);
-      }
-    });
-
-    Promise.all(promises).catch((err) => l.log(err));
-  };
-
-  async disconnect (): Promise<void> {
-    if (!this.#chain) {
-      return;
-    }
-
-    const chain = await this.#chain;
-
-    this.#chain = null;
-    this.#isChainReady = false;
-
-    try {
-      chain.remove();
-    } catch (_) {}
-
-    this.#eventemitter.emit('disconnected');
-  }
-
-  public on (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void {
-    // It's possible. Although, quite unlikely, that by the time that polkadot
-    // subscribes to the `connected` event, the Provider is already connected.
-    // In that case, we must emit to let the consumer know that we are connected.
-    if (type === 'connected' && this.isConnected) {
-      sub();
-    }
-
-    this.#eventemitter.on(type, sub);
-
-    return (): void => {
-      this.#eventemitter.removeListener(type, sub);
-    };
-  }
-
-  public async send<T = any> (method: string, params: unknown[]): Promise<T> {
-    if (!this.isConnected || !this.#chain) {
-      throw new Error('Provider is not connected');
-    }
-
-    const chain = await this.#chain;
-    const [id, json] = this.#coder.encodeJson(method, params);
-
-    const result = new Promise<T>((resolve, reject): void => {
-      this.#requests.set(id, (response) => {
-        (isError(response) ? reject : resolve)(response as unknown as T);
-      });
-
-      try {
-        chain.sendJsonRpc(json);
-      } catch (e) {
-        this.#chain = null;
-
-        try {
-          chain.remove();
-        } catch (_) {}
-
-        this.#eventemitter.emit('error', e);
-      }
-    });
-
-    try {
-      return await result;
-    } finally {
-      // let's ensure that once the Promise is resolved/rejected, then we remove
-      // remove its entry from the internal #requests
-      this.#requests.delete(id);
-    }
-  }
-
-  public async subscribe (type: string, method: string, params: any[], callback: ProviderInterfaceCallback): Promise<number | string> {
-    if (!subscriptionUnsubscriptionMethods.has(method)) {
-      throw new Error(`Unsupported subscribe method: ${method}`);
-    }
-
-    const id = await this.send<number | string>(method, params);
-    const subscriptionId = `${type}::${id}`;
-
-    const cb = (response: Error | string) => {
-      if (response instanceof Error) {
-        callback(response, undefined);
-      } else {
-        callback(null, response);
-      }
-    };
-
-    const unsubscribeMethod = subscriptionUnsubscriptionMethods.get(method);
-
-    if (!unsubscribeMethod) {
-      throw new Error('Invalid unsubscribe method found');
-    }
-
-    this.#resubscribeMethods.set(subscriptionId, { callback, method, params, type });
-
-    this.#subscriptions.set(subscriptionId, [cb, { id, unsubscribeMethod }]);
-
-    return id;
-  }
-
-  public unsubscribe (type: string, method: string, id: number | string): Promise<boolean> {
-    if (!this.isConnected) {
-      throw new Error('Provider is not connected');
-    }
-
-    const subscriptionId = `${type}::${id}`;
-
-    if (!this.#subscriptions.has(subscriptionId)) {
-      return Promise.reject(
-        new Error(`Unable to find active subscription=${subscriptionId}`)
-      );
-    }
-
-    this.#resubscribeMethods.delete(subscriptionId);
-    this.#subscriptions.delete(subscriptionId);
-
-    return this.send(method, [id]);
-  }
-}

package/src/substrate-connect/types.ts

@@ -1,16 +0,0 @@
-// Copyright 2017-2025 @polkadot/rpc-provider authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export interface SmoldotHealth {
-  isSyncing: boolean
-  peers: number
-  shouldHavePeers: boolean
-}
-
-export interface HealthChecker {
-  setSendJsonRpc(sendRequest: (request: string) => void): void
-  start(healthCallback: (health: SmoldotHealth) => void): void
-  stop(): void
-  sendJsonRpc(request: string): void
-  responsePassThrough(response: string): string | null
-}

package/src/types.ts

@@ -1,101 +0,0 @@
-// Copyright 2017-2025 @polkadot/rpc-provider authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-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;
-}

package/src/ws/connect.spec.ts

@@ -1,167 +0,0 @@
-// Copyright 2017-2025 @polkadot/rpc-provider authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import type { Mock } from '../mock/types.js';
-
-import { mockWs } from '../mock/mockWs.js';
-import { WsProvider } from './index.js';
-
-const TEST_WS_URL = 'ws://localhost-connect.spec.ts:9988';
-
-function sleep (ms = 100): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-describe('onConnect', (): void => {
-  let mocks: Mock[];
-  let provider: WsProvider | null;
-
-  beforeEach((): void => {
-    mocks = [mockWs([], TEST_WS_URL)];
-  });
-
-  afterEach(async () => {
-    if (provider) {
-      await provider.disconnect();
-      await sleep();
-
-      provider = null;
-    }
-
-    await Promise.all(mocks.map((m) => m.done()));
-    await sleep();
-  });
-
-  it('Does not connect when autoConnect is false', async () => {
-    provider = new WsProvider(TEST_WS_URL, 0);
-
-    await sleep();
-
-    expect(provider.isConnected).toBe(false);
-
-    await provider.connect();
-    await sleep();
-
-    expect(provider.isConnected).toBe(true);
-
-    await provider.disconnect();
-    await sleep();
-
-    expect(provider.isConnected).toBe(false);
-  });
-
-  it('Does connect when autoConnect is true', async () => {
-    provider = new WsProvider(TEST_WS_URL, 1);
-
-    await sleep();
-
-    expect(provider.isConnected).toBe(true);
-  });
-
-  it('Creates a new WebSocket instance by calling the connect() method', async () => {
-    provider = new WsProvider(TEST_WS_URL, false);
-
-    expect(provider.isConnected).toBe(false);
-    expect(mocks[0].server.clients().length).toBe(0);
-
-    await provider.connect();
-    await sleep();
-
-    expect(provider.isConnected).toBe(true);
-    expect(mocks[0].server.clients()).toHaveLength(1);
-  });
-
-  it('Connects to first endpoint when an array is given', async () => {
-    provider = new WsProvider([TEST_WS_URL], 1);
-
-    await sleep();
-
-    expect(provider.isConnected).toBe(true);
-    expect(mocks[0].server.clients()).toHaveLength(1);
-  });
-
-  it('Does not allow connect() on already-connected', async () => {
-    provider = new WsProvider([TEST_WS_URL], 1);
-
-    await sleep();
-
-    expect(provider.isConnected).toBe(true);
-
-    await expect(
-      provider.connect()
-    ).rejects.toThrow(/already connected/);
-  });
-
-  it('Connects to the second endpoint when the first is unreachable', async () => {
-    const endpoints: string[] = ['ws://localhost-unreachable-connect.spec.ts:9956', TEST_WS_URL];
-
-    provider = new WsProvider(endpoints, 1);
-
-    await sleep();
-
-    expect(mocks[0].server.clients()).toHaveLength(1);
-    expect(provider.isConnected).toBe(true);
-  });
-
-  it('Connects to the second endpoint when the first is dropped', async () => {
-    const endpoints: string[] = [TEST_WS_URL, 'ws://localhost-connect.spec.ts:9957'];
-
-    mocks.push(mockWs([], endpoints[1]));
-
-    provider = new WsProvider(endpoints, 1);
-
-    await sleep();
-
-    // Check that first server is connected
-    expect(mocks[0].server.clients()).toHaveLength(1);
-    expect(mocks[1].server.clients()).toHaveLength(0);
-
-    // Close connection from first server
-    mocks[0].server.clients()[0].close();
-
-    await sleep();
-
-    // Check that second server is connected
-    expect(mocks[1].server.clients()).toHaveLength(1);
-    expect(provider.isConnected).toBe(true);
-  });
-
-  it('Round-robin of endpoints on WsProvider', async () => {
-    const endpoints: string[] = [
-      TEST_WS_URL,
-      'ws://localhost-connect.spec.ts:9956',
-      'ws://localhost-connect.spec.ts:9957',
-      'ws://invalid-connect.spec.ts:9956',
-      'ws://localhost-connect.spec.ts:9958'
-    ];
-
-    mocks.push(mockWs([], endpoints[1]));
-    mocks.push(mockWs([], endpoints[2]));
-    mocks.push(mockWs([], endpoints[4]));
-
-    const mockNext = [
-      mocks[1],
-      mocks[2],
-      mocks[3],
-      mocks[0]
-    ];
-
-    provider = new WsProvider(endpoints, 1);
-
-    for (let round = 0; round < 2; round++) {
-      for (let mock = 0; mock < mocks.length; mock++) {
-        await sleep();
-
-        // Wwe are connected, the current mock has the connection and the next doesn't
-        expect(provider.isConnected).toBe(true);
-        expect(mocks[mock].server.clients()).toHaveLength(1);
-        expect(mockNext[mock].server.clients()).toHaveLength(0);
-
-        // Close connection from first server
-        mocks[mock].server.clients()[0].close();
-      }
-    }
-  });
-});