@pezkuwi/rpc-core 16.5.5

package/README.md

@@ -0,0 +1,3 @@
+# @pezkuwi/rpc-core
+
+This library provides a clean wrapper around all the methods exposed by a Pezkuwi network client. It is only used internally to the API.

package/build/bundle.d.ts

@@ -0,0 +1,91 @@
+import type { ProviderInterface } from '@pezkuwi/rpc-provider/types';
+import type { AnyNumber, DefinitionRpc, DefinitionRpcExt, DefinitionRpcSub, Registry } from '@pezkuwi/types/types';
+import type { RpcCoreStats } from './types/index.js';
+export { packageInfo } from './packageInfo.js';
+export * from './util/index.js';
+interface Options {
+    isPedantic?: boolean;
+    provider: ProviderInterface;
+    /**
+     * Custom size of the rpc LRUCache capacity. Defaults to `RPC_CORE_DEFAULT_CAPACITY` (1024 * 10 * 10)
+     */
+    rpcCacheCapacity?: number;
+    ttl?: number | null;
+    userRpc?: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>;
+}
+/**
+ * @name Rpc
+ * @summary The API may use a HTTP or WebSockets provider.
+ * @description It allows for querying a Polkadot Client Node.
+ * WebSockets provider is recommended since HTTP provider only supports basic querying.
+ *
+ * ```mermaid
+ * graph LR;
+ *   A[Api] --> |WebSockets| B[WsProvider];
+ *   B --> |endpoint| C[ws://127.0.0.1:9944]
+ * ```
+ *
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import Rpc from '@pezkuwi/rpc-core';
+ * import { WsProvider } from '@pezkuwi/rpc-provider/ws';
+ *
+ * const provider = new WsProvider('ws://127.0.0.1:9944');
+ * const rpc = new Rpc(provider);
+ * ```
+ */
+export declare class RpcCore {
+    #private;
+    readonly mapping: Map<string, DefinitionRpcExt>;
+    readonly provider: ProviderInterface;
+    readonly sections: string[];
+    /**
+     * @constructor
+     * Default constructor for the core RPC handler
+     * @param {Registry} registry Type Registry
+     * @param {ProviderInterface} options.provider An API provider using any of the supported providers (HTTP, SC or WebSocket)
+     * @param {number} [options.rpcCacheCapacity] Custom size of the rpc LRUCache capacity. Defaults to `RPC_CORE_DEFAULT_CAPACITY` (1024 * 10 * 10)
+     */
+    constructor(instanceId: string, registry: Registry, { isPedantic, provider, rpcCacheCapacity, ttl, userRpc }: Options);
+    /**
+     * @description Returns the connected status of a provider
+     */
+    get isConnected(): boolean;
+    /**
+     * @description Manually connect from the attached provider
+     */
+    connect(): Promise<void>;
+    /**
+     * @description Manually disconnect from the attached provider
+     */
+    disconnect(): Promise<void>;
+    /**
+     * @description Returns the underlying core stats, including those from teh provider
+     */
+    get stats(): RpcCoreStats | undefined;
+    /**
+     * @description Sets a registry swap (typically from Api)
+     */
+    setRegistrySwap(registrySwap: (blockHash: Uint8Array) => Promise<{
+        registry: Registry;
+    }>): void;
+    /**
+     * @description Sets a function to resolve block hash from block number
+     */
+    setResolveBlockHash(resolveBlockHash: (blockNumber: AnyNumber) => Promise<Uint8Array>): void;
+    addUserInterfaces(userRpc: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>): void;
+    private _memomize;
+    private _formatResult;
+    private _createMethodSend;
+    private _createSubscriber;
+    private _createMethodSubscribe;
+    private _formatParams;
+    private _formatOutput;
+    private _formatStorageData;
+    private _formatStorageSet;
+    private _formatStorageSetEntry;
+    private _setToCache;
+    private _newType;
+}

package/build/index.d.ts

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

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/types/base.d.ts

@@ -0,0 +1,22 @@
+import type { Observable } from 'rxjs';
+import type { ProviderInterface } from '@pezkuwi/rpc-provider/types';
+import type { AnyFunction, Codec, DefinitionRpc } from '@pezkuwi/types/types';
+export interface RpcInterfaceMethod {
+    <T extends Codec>(...params: unknown[]): Observable<T>;
+    raw(...params: unknown[]): Observable<unknown>;
+    meta: DefinitionRpc;
+}
+export type AugmentedRpc<F extends AnyFunction> = F & {
+    raw: <T>(...params: Parameters<F>) => Observable<T>;
+    meta: DefinitionRpc;
+};
+/** Stats from the rpc-core layer, including the provider stats */
+export interface RpcCoreStats extends NonNullable<ProviderInterface['stats']> {
+    /** Internal stats for the rpc-core layer */
+    core: {
+        /** The number of values retrieved from the core cache */
+        cacheHits: number;
+        /** The number of entries in the core cache */
+        cacheSize: number;
+    };
+}

package/build/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from '@pezkuwi/rpc-core/types/jsonrpc';
+export * from './base.js';

package/build/types/jsonrpc.d.ts

@@ -0,0 +1,2 @@
+export interface RpcInterface {
+}

package/build/util/drr.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+export type DrrResult = <T>(source$: Observable<T>) => Observable<T>;
+interface Options {
+    delay?: number;
+    skipChange?: boolean;
+    skipTimeout?: boolean;
+}
+/**
+ * Shorthand for distinctUntilChanged(), publishReplay(1) and refCount().
+ *
+ * @ignore
+ * @internal
+ */
+export declare function drr({ delay, skipChange, skipTimeout }?: Options): DrrResult;
+export {};

package/build/util/index.d.ts

@@ -0,0 +1,3 @@
+export * from './drr.js';
+export * from './memo.js';
+export * from './refCountDelay.js';

package/build/util/memo.d.ts

@@ -0,0 +1,6 @@
+import type { Memoized } from '@pezkuwi/util/types';
+import { Observable } from 'rxjs';
+type ObsFn<T> = (...params: unknown[]) => Observable<T>;
+/** @internal */
+export declare function memo<T>(instanceId: string, inner: Function): Memoized<ObsFn<T>>;
+export {};

package/build/util/refCountDelay.d.ts

@@ -0,0 +1,3 @@
+import type { MonoTypeOperatorFunction } from 'rxjs';
+/** @internal */
+export declare function refCountDelay<T>(delay?: number): MonoTypeOperatorFunction<T>;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues",
+  "description": "A JavaScript wrapper for the Polkadot JsonRPC interface",
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/rpc-core#readme",
+  "license": "Apache-2.0",
+  "name": "@pezkuwi/rpc-core",
+  "repository": {
+    "directory": "packages/rpc-core",
+    "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/rpc-augment": "16.5.5",
+    "@pezkuwi/rpc-provider": "16.5.5",
+    "@pezkuwi/types": "16.5.5",
+    "@pezkuwi/util": "14.0.5",
+    "rxjs": "^7.8.1",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@pezkuwi/keyring": "14.0.5",
+    "@pezkuwi/rpc-augment": "16.5.5"
+  }
+}