@pezkuwi/rpc-provider 16.5.5

package/README.md

@@ -0,0 +1,68 @@
+# @pezkuwi/rpc-provider
+
+Generic transport providers to handle the transport of method calls to and from Pezkuwi clients from applications interacting with it. It provides an interface to making RPC calls and is generally, unless you are operating at a low-level and taking care of encoding and decoding of parameters/results, it won't be directly used, rather only passed to a higher-level interface.
+
+## Provider Selection
+
+There are three flavours of the providers provided, one allowing for using HTTP as a transport mechanism, the other using WebSockets, and the third one uses substrate light-client through @substrate/connect. It is generally recommended to use the [[WsProvider]] since in addition to standard calls, it allows for subscriptions where all changes to state can be pushed from the node to the client.
+
+All providers are usable (as is the API), in both browser-based and Node.js environments. Polyfills for unsupported functionality are automatically applied based on feature-detection.
+
+## Usage
+
+Installation -
+
+```
+yarn add @pezkuwi/rpc-provider
+```
+
+WebSocket Initialization -
+
+```javascript
+import { WsProvider } from '@pezkuwi/rpc-provider';
+
+// this is the actual default endpoint
+const provider = new WsProvider('ws://127.0.0.1:9944');
+const version = await provider.send('client_version', []);
+
+console.log('client version', version);
+```
+
+HTTP Initialization -
+
+```javascript
+import { HttpProvider } from '@pezkuwi/rpc-provider';
+
+// this is the actual default endpoint
+const provider = new HttpProvider('http://127.0.0.1:9933');
+const version = await provider.send('chain_getBlockHash', []);
+
+console.log('latest block Hash', hash);
+```
+
+@substrate/connect Initialization -
+
+Instantiating a Provider for the Pezkuwi Relay Chain:
+```javascript
+import { ScProvider } from '@pezkuwi/rpc-provider';
+import * as Sc from '@substrate/connect';
+
+const provider = new ScProvider(Sc, Sc.WellKnownChain.polkadot);
+
+await provider.connect();
+
+const version = await provider.send('chain_getBlockHash', []);
+```
+
+Instantiating a Provider for a Pezkuwi parachain:
+```javascript
+import { ScProvider } from '@pezkuwi/rpc-provider';
+import * as Sc from '@substrate/connect';
+
+const polkadotProvider = new ScProvider(Sc, Sc.WellKnownChain.polkadot);
+const parachainProvider = new ScProvider(Sc, parachainSpec, polkadotProvider);
+
+await parachainProvider.connect();
+
+const version = await parachainProvider.send('chain_getBlockHash', []);
+```

package/build/bundle.d.ts

@@ -0,0 +1,5 @@
+export { HttpProvider } from './http/index.js';
+export { DEFAULT_CAPACITY, LRUCache } from './lru.js';
+export { packageInfo } from './packageInfo.js';
+export { ScProvider } from './substrate-connect/index.js';
+export { WsProvider } from './ws/index.js';

package/build/coder/error.d.ts

@@ -0,0 +1,29 @@
+import type { RpcErrorInterface } from '../types.js';
+/**
+ * @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
+ * ```
+ */
+export default class RpcError<T = never> extends Error implements RpcErrorInterface<T> {
+    code: number;
+    data?: T;
+    message: string;
+    name: string;
+    stack: string;
+    constructor(message?: string, code?: number, data?: T);
+    static CODES: {
+        ASSERT: number;
+        INVALID_JSONRPC: number;
+        METHOD_NOT_FOUND: number;
+        UNKNOWN: number;
+    };
+}

package/build/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/build/defaults.d.ts

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

package/build/http/index.d.ts

@@ -0,0 +1,81 @@
+import type { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted, ProviderStats } from '../types.js';
+/**
+ * # @polkadot/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/build/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/build/index.d.ts

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

package/build/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/build/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;
+}

package/build/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/build/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/build/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/build/packageDetect.d.ts

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

package/build/packageInfo.d.ts

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

package/build/substrate-connect/Health.d.ts

@@ -0,0 +1,7 @@
+import type { HealthChecker } from './types.js';
+export declare function healthChecker(): HealthChecker;
+export declare class HealthCheckError extends Error {
+    #private;
+    getCause(): unknown;
+    constructor(response: unknown, message?: string);
+}

package/build/substrate-connect/index.d.ts

@@ -0,0 +1,22 @@
+import type * as ScType from '@substrate/connect';
+import type { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '../types.js';
+import { healthChecker } from './Health.js';
+interface SubstrateConnect {
+    WellKnownChain: typeof ScType['WellKnownChain'];
+    createScClient: typeof ScType['createScClient'];
+}
+export declare class ScProvider implements ProviderInterface {
+    #private;
+    constructor(Sc: SubstrateConnect, spec: string | ScType.WellKnownChain, sharedSandbox?: ScProvider);
+    get hasSubscriptions(): boolean;
+    get isClonable(): boolean;
+    get isConnected(): boolean;
+    clone(): ProviderInterface;
+    connect(config?: ScType.Config, checkerFactory?: typeof healthChecker): Promise<void>;
+    disconnect(): Promise<void>;
+    on(type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void;
+    send<T = any>(method: string, params: unknown[]): Promise<T>;
+    subscribe(type: string, method: string, params: any[], callback: ProviderInterfaceCallback): Promise<number | string>;
+    unsubscribe(type: string, method: string, id: number | string): Promise<boolean>;
+}
+export {};

package/build/substrate-connect/types.d.ts

@@ -0,0 +1,12 @@
+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/build/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/build/ws/errors.d.ts

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

package/build/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;
+}
+/**
+ * # @polkadot/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 {};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues",
+  "description": "Transport providers for the API",
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/rpc-provider#readme",
+  "license": "Apache-2.0",
+  "name": "@pezkuwi/rpc-provider",
+  "repository": {
+    "directory": "packages/rpc-provider",
+    "type": "git",
+    "url": "https://github.com/pezkuwichain/pezkuwi-api.git"
+  },
+  "sideEffects": [
+    "./packageDetect.js",
+    "./packageDetect.cjs"
+  ],
+  "type": "module",
+  "version": "16.5.5",
+  "main": "index.js",
+  "dependencies": {
+    "@pezkuwi/keyring": "14.0.5",
+    "@pezkuwi/types": "16.5.5",
+    "@pezkuwi/types-support": "16.5.5",
+    "@pezkuwi/util": "14.0.5",
+    "@pezkuwi/util-crypto": "14.0.5",
+    "@pezkuwi/x-fetch": "14.0.5",
+    "@pezkuwi/x-global": "14.0.5",
+    "@pezkuwi/x-ws": "14.0.5",
+    "eventemitter3": "^5.0.1",
+    "mock-socket": "^9.3.1",
+    "nock": "^13.5.5",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@substrate/connect": "0.8.11"
+  },
+  "optionalDependencies": {
+    "@substrate/connect": "0.8.11"
+  }
+}

package/src/bundle.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @polkadot/rpc-provider authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { HttpProvider } from './http/index.js';
+export { DEFAULT_CAPACITY, LRUCache } from './lru.js';
+export { packageInfo } from './packageInfo.js';
+export { ScProvider } from './substrate-connect/index.js';
+export { WsProvider } from './ws/index.js';