@pezkuwi/rpc-core 16.5.5

package/src/index.spec.ts

@@ -0,0 +1,55 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import type { ProviderInterface } from '@pezkuwi/rpc-provider/types';
+
+import { MockProvider } from '@pezkuwi/rpc-provider/mock';
+import { TypeRegistry } from '@pezkuwi/types/create';
+import { isFunction } from '@pezkuwi/util';
+
+import { RpcCore } from './index.js';
+
+describe('Api', (): void => {
+  const registry = new TypeRegistry();
+
+  it('requires a provider with a send method', (): void => {
+    expect(
+      () => new RpcCore('234', registry, { provider: {} as unknown as ProviderInterface })
+    ).toThrow(/Expected Provider/);
+  });
+
+  it('allows for the definition of user RPCs', async () => {
+    const provider = new MockProvider(registry);
+    const rpc = new RpcCore('567', registry, {
+      provider,
+      userRpc: {
+        testing: {
+          foo: {
+            description: 'foo',
+            params: [{ name: 'bar', type: 'u32' }],
+            type: 'Balance'
+          }
+        }
+      }
+    });
+
+    expect(isFunction((rpc as unknown as { testing: { foo: boolean } }).testing.foo)).toBe(true);
+    expect(rpc.sections.includes('testing')).toBe(true);
+    expect(rpc.mapping.get('testing_foo')).toEqual({
+      description: 'foo',
+      isSubscription: false,
+      jsonrpc: 'testing_foo',
+      method: 'foo',
+      params: [{
+        name: 'bar',
+        type: 'u32'
+      }],
+      section: 'testing',
+      type: 'Balance'
+    });
+
+    await provider.disconnect();
+  });
+});

package/src/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './packageDetect.js';
+
+export * from './bundle.js';

package/src/methodSend.spec.ts

@@ -0,0 +1,75 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import type { ProviderInterface } from '@pezkuwi/rpc-provider/types';
+import type { DefinitionRpc } from '@pezkuwi/types/types';
+
+import { TypeRegistry } from '@pezkuwi/types/create';
+
+import { RpcCore } from './index.js';
+
+describe('methodSend', (): void => {
+  const registry = new TypeRegistry();
+  let rpc: RpcCore;
+  let methods: { blah: DefinitionRpc; bleh: DefinitionRpc };
+  let provider: ProviderInterface;
+
+  beforeEach((): void => {
+    methods = {
+      blah: {
+        description: 'test',
+        params: [
+          { name: 'foo', type: 'Bytes' }
+        ],
+        type: 'Bytes'
+      },
+      bleh: {
+        description: 'test',
+        params: [],
+        type: 'Bytes'
+      }
+    };
+
+    provider = {
+      send: jest.fn((_method: string, params: unknown[]): Promise<unknown> =>
+        Promise.resolve(params[0])
+      )
+    } as unknown as ProviderInterface;
+
+    rpc = new RpcCore('987', registry, { provider });
+  });
+
+  it('checks for mismatched parameters', async (): Promise<void> => {
+    // private method
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const method = (rpc as any)._createMethodSend('test', 'bleh', methods.bleh);
+
+    await new Promise<boolean>((resolve) => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      method(1).subscribe(
+        (): void => undefined,
+        (error: Error): void => {
+          expect(error.message).toMatch(/parameters, 1 found instead/);
+          resolve(true);
+        });
+    });
+  });
+
+  it('calls the provider with the correct parameters', async (): Promise<void> => {
+    // private method
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const method = (rpc as any)._createMethodSend('test', 'blah', methods.blah);
+
+    await new Promise<boolean>((resolve) => {
+      // Args are length-prefixed, because it's a Bytes
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      method(new Uint8Array([2 << 2, 0x12, 0x34])).subscribe((): void => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        expect(provider.send).toHaveBeenCalledWith('test_blah', ['0x1234'], false);
+        resolve(true);
+      });
+    });
+  });
+});

package/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index.js';

package/src/packageDetect.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+// (packageInfo imports will be kept as-is, user-editable)
+
+import { packageInfo as providerInfo } from '@pezkuwi/rpc-provider/packageInfo';
+import { packageInfo as typesInfo } from '@pezkuwi/types/packageInfo';
+import { detectPackage } from '@pezkuwi/util';
+
+import { packageInfo } from './packageInfo.js';
+
+detectPackage(packageInfo, null, [providerInfo, typesInfo]);

package/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+export const packageInfo = { name: '@pezkuwi/rpc-core', path: 'auto', type: 'auto', version: '16.5.5' };

package/src/replay.spec.ts

@@ -0,0 +1,73 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import type { RpcInterface } from './types/index.js';
+
+import { MockProvider } from '@pezkuwi/rpc-provider/mock';
+import { TypeRegistry } from '@pezkuwi/types/create';
+
+import { RpcCore } from './index.js';
+
+describe('replay', (): void => {
+  const registry = new TypeRegistry();
+  let rpc: RpcCore & RpcInterface;
+  let provider: MockProvider;
+
+  beforeEach((): void => {
+    provider = new MockProvider(registry);
+    rpc = new RpcCore('653', registry, { provider }) as (RpcCore & RpcInterface);
+  });
+
+  afterEach(async () => {
+    await provider.disconnect();
+  });
+
+  it('returns the observable value', async (): Promise<void> => {
+    await new Promise<boolean>((resolve) => {
+      rpc.system.chain().subscribe((value?: { toString: () => string }): void => {
+        if (value) {
+          // eslint-disable-next-line jest/no-conditional-expect
+          expect(value.toString()).toEqual('mockChain'); // Defined in MockProvider
+          resolve(true);
+        }
+      });
+    });
+  });
+
+  it('replay(1) works as expected', async (): Promise<void> => {
+    const observable = rpc.system.chain();
+    let a: any;
+
+    observable.subscribe((value?: unknown): void => {
+      a = value;
+    });
+
+    await new Promise<boolean>((resolve) => {
+      setTimeout((): void => {
+        // Subscribe again to the same observable, it should fire value immediately
+        observable.subscribe((value: any): void => {
+          expect(value).toEqual(a);
+          resolve(true);
+        });
+      }, 1000);
+    });
+  });
+
+  it('unsubscribes as required', async (): Promise<void> => {
+    rpc.provider.unsubscribe = jest.fn();
+
+    await new Promise<boolean>((resolve) => {
+      const subscription = rpc.chain.subscribeNewHeads().subscribe((): void => {
+        subscription.unsubscribe();
+
+        // There's a promise inside .unsubscribe(), wait a bit (> 2s)
+        setTimeout((): void => {
+          expect(rpc.provider.unsubscribe).toHaveBeenCalled();
+          resolve(true);
+        }, 3500);
+      });
+    });
+  });
+});

package/src/types/base.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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/src/types/index.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// augmented, do an augmentation export
+export * from '@pezkuwi/rpc-core/types/jsonrpc';
+
+// normal exports
+export * from './base.js';

package/src/types/jsonrpc.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface RpcInterface {
+  // augmented
+}

package/src/util/drr.spec.ts

@@ -0,0 +1,50 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { of, timer } from 'rxjs';
+
+import { drr } from './index.js';
+
+describe('drr', (): void => {
+  it('should not fire twice the same value', async (): Promise<void> => {
+    let count = 0;
+    const sub = of(1, 1).pipe(drr({ delay: 500 })).subscribe((): void => {
+      ++count;
+    });
+
+    await new Promise<boolean>((resolve) => {
+      setTimeout((): void => {
+        expect(count).toBe(1);
+        sub.unsubscribe();
+
+        setTimeout(() => {
+          resolve(true);
+        }, 2000);
+      }, 50);
+    });
+  });
+
+  it('should be a ReplaySubject(1)', async (): Promise<void> => {
+    const obs = timer(0, 100).pipe(drr({ delay: 500 })); // Starts at 0, increments every 100ms
+    const sub = obs.subscribe(); // Fire the observable
+
+    await new Promise<boolean>((resolve) => {
+      // Subscribe another time after some time, i.e. after the observable has fired
+      setTimeout((): void => {
+        const sub = obs.subscribe((value): void => {
+          expect(value > 1).toBe(true);
+
+          setTimeout(() => {
+            resolve(true);
+          }, 2000);
+        });
+
+        sub.unsubscribe();
+      }, 500);
+
+      sub.unsubscribe();
+    });
+  });
+});

package/src/util/drr.ts

@@ -0,0 +1,52 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+
+import { catchError, distinctUntilChanged, publishReplay, refCount, tap } from 'rxjs';
+
+import { stringify } from '@pezkuwi/util';
+
+import { refCountDelay } from './refCountDelay.js';
+
+export type DrrResult = <T> (source$: Observable<T>) => Observable<T>;
+
+interface Options {
+  delay?: number;
+  skipChange?: boolean;
+  skipTimeout?: boolean;
+}
+
+function CMP (a: unknown, b: unknown): boolean {
+  return stringify({ t: a }) === stringify({ t: b });
+}
+
+function ERR (error: Error): Observable<never> {
+  throw error;
+}
+
+function NOOP (): void {
+  // empty
+}
+
+/**
+ * Shorthand for distinctUntilChanged(), publishReplay(1) and refCount().
+ *
+ * @ignore
+ * @internal
+ */
+export function drr ({ delay, skipChange = false, skipTimeout = false }: Options = {}): DrrResult {
+  return <T> (source$: Observable<T>): Observable<T> =>
+    source$.pipe(
+      catchError(ERR),
+      skipChange
+        ? tap(NOOP)
+        : distinctUntilChanged<T>(CMP),
+      // eslint-disable-next-line deprecation/deprecation
+      publishReplay(1),
+      skipTimeout
+        // eslint-disable-next-line deprecation/deprecation
+        ? refCount()
+        : refCountDelay(delay)
+    );
+}

package/src/util/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './drr.js';
+export * from './memo.js';
+export * from './refCountDelay.js';

package/src/util/memo.ts

@@ -0,0 +1,36 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observer, TeardownLogic } from 'rxjs';
+import type { Memoized } from '@pezkuwi/util/types';
+
+import { Observable } from 'rxjs';
+
+import { memoize } from '@pezkuwi/util';
+
+import { drr } from './drr.js';
+
+type ObsFn <T> = (...params: unknown[]) => Observable<T>;
+
+// Wraps a derive, doing 2 things to optimize calls -
+//   1. creates a memo of the inner fn -> Observable, removing when unsubscribed
+//   2. wraps the observable in a drr() (which includes an unsub delay)
+/** @internal */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function memo <T> (instanceId: string, inner: Function): Memoized<ObsFn<T>> {
+  const options = { getInstanceId: () => instanceId };
+  const cached = memoize(
+    (...params: unknown[]): Observable<T> =>
+      new Observable((observer: Observer<T>): TeardownLogic => {
+        const subscription = (inner as ObsFn<T>)(...params).subscribe(observer);
+
+        return (): void => {
+          cached.unmemoize(...params);
+          subscription.unsubscribe();
+        };
+      }).pipe(drr()),
+    options
+  );
+
+  return cached;
+}

package/src/util/refCountDelay.ts

@@ -0,0 +1,45 @@
+// Copyright 2017-2025 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ConnectableObservable, MonoTypeOperatorFunction, TeardownLogic } from 'rxjs';
+
+import { asapScheduler, Observable, Subscription } from 'rxjs';
+
+/** @internal */
+export function refCountDelay <T> (delay = 1750): MonoTypeOperatorFunction<T> {
+  return (source: Observable<T>): Observable<T> => {
+    // state: 0 = disconnected, 1 = disconnecting, 2 = connecting, 3 = connected
+    let [state, refCount, connection, scheduler] = [0, 0, Subscription.EMPTY, Subscription.EMPTY];
+
+    return new Observable((ob): TeardownLogic => {
+      source.subscribe(ob);
+
+      if (refCount++ === 0) {
+        if (state === 1) {
+          scheduler.unsubscribe();
+        } else {
+          // eslint-disable-next-line deprecation/deprecation
+          connection = (source as ConnectableObservable<T>).connect();
+        }
+
+        state = 3;
+      }
+
+      return (): void => {
+        if (--refCount === 0) {
+          if (state === 2) {
+            state = 0;
+            scheduler.unsubscribe();
+          } else {
+            // state === 3
+            state = 1;
+            scheduler = asapScheduler.schedule((): void => {
+              state = 0;
+              connection.unsubscribe();
+            }, delay);
+          }
+        }
+      };
+    });
+  };
+}

package/tsconfig.build.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "exclude": [
+    "**/checkTypes.manual.ts",
+    "**/mod.ts",
+    "**/*.spec.ts"
+  ],
+  "references": [
+    { "path": "../rpc-provider/tsconfig.build.json" },
+    { "path": "../types/tsconfig.build.json" }
+  ]
+}