@polkadot/rpc-core 10.4.1 → 10.6.1

package/bundle.d.ts

@@ -2,6 +2,11 @@ import type { ProviderInterface } from '@polkadot/rpc-provider/types';
 import type { AnyNumber, DefinitionRpc, DefinitionRpcExt, DefinitionRpcSub, Registry } from '@polkadot/types/types';
 export { packageInfo } from './packageInfo.js';
 export * from './util/index.js';
+interface Options {
+    isPedantic?: boolean;
+    provider: ProviderInterface;
+    userRpc?: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>;
+}
 /**
  * @name Rpc
  * @summary The API may use a HTTP or WebSockets provider.
@@ -32,10 +37,10 @@ export declare class RpcCore {
     readonly sections: string[];
     /**
      * @constructor
-     * Default constructor for the Api Object
-     * @param  {ProviderInterface} provider An API provider using HTTP or WebSocket
+     * Default constructor for the core RPC handler
+     * @param  {ProviderInterface} provider An API provider using any of the supported providers (HTTP, SC or WebSocket)
      */
-    constructor(instanceId: string, registry: Registry, provider: ProviderInterface, userRpc?: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>);
+    constructor(instanceId: string, registry: Registry, { isPedantic, provider, userRpc }: Options);
     /**
      * @description Returns the connected status of a provider
      */
@@ -64,7 +69,7 @@ export declare class RpcCore {
     private _createMethodSend;
     private _createSubscriber;
     private _createMethodSubscribe;
-    private _formatInputs;
+    private _formatParams;
     private _formatOutput;
     private _formatStorageData;
     private _formatStorageSet;

package/bundle.js

@@ -1,5 +1,3 @@
-var _RpcCore_instanceId, _RpcCore_registryDefault, _RpcCore_getBlockRegistry, _RpcCore_getBlockHash, _RpcCore_storageCache;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { Observable, publishReplay, refCount } from 'rxjs';
 import { rpcDefinitions } from '@polkadot/types';
 import { hexToU8a, isFunction, isNull, isUndefined, lazyMethod, logger, memoize, objectSpread, u8aConcat, u8aToU8a } from '@polkadot/util';
@@ -20,8 +18,7 @@ function logErrorMessage(method, { noErrorLog, params, type }, error) {
     if (noErrorLog) {
         return;
     }
-    const inputs = params.map(({ isOptional, name, type }) => `${name}${isOptional ? '?' : ''}: ${type}`).join(', ');
-    l.error(`${method}(${inputs}): ${type}:: ${error.message}`);
+    l.error(`${method}(${params.map(({ isOptional, name, type }) => `${name}${isOptional ? '?' : ''}: ${type}`).join(', ')}): ${type}:: ${error.message}`);
 }
 function isTreatAsHex(key) {
     // :code is problematic - it does not have the length attached, which is
@@ -54,23 +51,20 @@ function isTreatAsHex(key) {
 export class RpcCore {
     /**
      * @constructor
-     * Default constructor for the Api Object
-     * @param  {ProviderInterface} provider An API provider using HTTP or WebSocket
+     * Default constructor for the core RPC handler
+     * @param  {ProviderInterface} provider An API provider using any of the supported providers (HTTP, SC or WebSocket)
      */
-    constructor(instanceId, registry, provider, userRpc = {}) {
-        _RpcCore_instanceId.set(this, void 0);
-        _RpcCore_registryDefault.set(this, void 0);
-        _RpcCore_getBlockRegistry.set(this, void 0);
-        _RpcCore_getBlockHash.set(this, void 0);
-        _RpcCore_storageCache.set(this, new Map());
+    constructor(instanceId, registry, { isPedantic = true, provider, userRpc = {} }) {
+        this.__internal__storageCache = new Map();
         this.mapping = new Map();
         this.sections = [];
         // eslint-disable-next-line @typescript-eslint/unbound-method
         if (!provider || !isFunction(provider.send)) {
             throw new Error('Expected Provider to API create');
         }
-        __classPrivateFieldSet(this, _RpcCore_instanceId, instanceId, "f");
-        __classPrivateFieldSet(this, _RpcCore_registryDefault, registry, "f");
+        this.__internal__instanceId = instanceId;
+        this.__internal__isPedantic = isPedantic;
+        this.__internal__registryDefault = registry;
         this.provider = provider;
         const sectionNames = Object.keys(rpcDefinitions);
         // these are the base keys (i.e. part of jsonrpc)
@@ -100,26 +94,26 @@ export class RpcCore {
      * @description Sets a registry swap (typically from Api)
      */
     setRegistrySwap(registrySwap) {
-        __classPrivateFieldSet(this, _RpcCore_getBlockRegistry, memoize(registrySwap, {
-            getInstanceId: () => __classPrivateFieldGet(this, _RpcCore_instanceId, "f")
-        }), "f");
+        this.__internal__getBlockRegistry = memoize(registrySwap, {
+            getInstanceId: () => this.__internal__instanceId
+        });
     }
     /**
      * @description Sets a function to resolve block hash from block number
      */
     setResolveBlockHash(resolveBlockHash) {
-        __classPrivateFieldSet(this, _RpcCore_getBlockHash, memoize(resolveBlockHash, {
-            getInstanceId: () => __classPrivateFieldGet(this, _RpcCore_instanceId, "f")
-        }), "f");
+        this.__internal__getBlockHash = memoize(resolveBlockHash, {
+            getInstanceId: () => this.__internal__instanceId
+        });
     }
     addUserInterfaces(userRpc) {
         // add any extra user-defined sections
         this.sections.push(...Object.keys(userRpc).filter((k) => !this.sections.includes(k)));
-        for (let s = 0; s < this.sections.length; s++) {
+        for (let s = 0, scount = this.sections.length; s < scount; s++) {
             const section = this.sections[s];
             const defs = objectSpread({}, rpcDefinitions[section], userRpc[section]);
             const methods = Object.keys(defs);
-            for (let m = 0; m < methods.length; m++) {
+            for (let m = 0, mcount = methods.length; m < mcount; m++) {
                 const method = methods[m];
                 const def = defs[method];
                 const jsonrpc = def.endpoint || `${section}_${method}`;
@@ -137,7 +131,7 @@ export class RpcCore {
         }
     }
     _memomize(creator, def) {
-        const memoOpts = { getInstanceId: () => __classPrivateFieldGet(this, _RpcCore_instanceId, "f") };
+        const memoOpts = { getInstanceId: () => this.__internal__instanceId };
         const memoized = memoize(creator(true), memoOpts);
         memoized.raw = memoize(creator(false), memoOpts);
         memoized.meta = def;
@@ -158,12 +152,12 @@ export class RpcCore {
                 ? null
                 : values[hashIndex];
             const blockHash = blockId && def.params[hashIndex].type === 'BlockNumber'
-                ? await __classPrivateFieldGet(this, _RpcCore_getBlockHash, "f")?.call(this, blockId)
+                ? await this.__internal__getBlockHash?.(blockId)
                 : blockId;
-            const { registry } = isScale && blockHash && __classPrivateFieldGet(this, _RpcCore_getBlockRegistry, "f")
-                ? await __classPrivateFieldGet(this, _RpcCore_getBlockRegistry, "f").call(this, u8aToU8a(blockHash))
-                : { registry: __classPrivateFieldGet(this, _RpcCore_registryDefault, "f") };
-            const params = this._formatInputs(registry, null, def, values);
+            const { registry } = isScale && blockHash && this.__internal__getBlockRegistry
+                ? await this.__internal__getBlockRegistry(u8aToU8a(blockHash))
+                : { registry: this.__internal__registryDefault };
+            const params = this._formatParams(registry, null, def, values);
             // only cache .at(<blockHash>) queries, e.g. where valid blockHash was supplied
             const result = await this.provider.send(rpcName, params.map((p) => p.toJSON()), !!blockHash);
             return this._formatResult(isScale, registry, blockHash, method, def, params, result);
@@ -223,14 +217,13 @@ export class RpcCore {
             return new Observable((observer) => {
                 // Have at least an empty promise, as used in the unsubscribe
                 let subscriptionPromise = Promise.resolve(null);
-                const registry = __classPrivateFieldGet(this, _RpcCore_registryDefault, "f");
+                const registry = this.__internal__registryDefault;
                 const errorHandler = (error) => {
                     logErrorMessage(method, def, error);
                     observer.error(error);
                 };
                 try {
-                    const params = this._formatInputs(registry, null, def, values);
-                    const paramsJson = params.map((p) => p.toJSON());
+                    const params = this._formatParams(registry, null, def, values);
                     const update = (error, result) => {
                         if (error) {
                             logErrorMessage(method, def, error);
@@ -243,7 +236,7 @@ export class RpcCore {
                             observer.error(error);
                         }
                     };
-                    subscriptionPromise = this._createSubscriber({ paramsJson, subName, subType, update }, errorHandler);
+                    subscriptionPromise = this._createSubscriber({ paramsJson: params.map((p) => p.toJSON()), subName, subType, update }, errorHandler);
                 }
                 catch (error) {
                     errorHandler(error);
@@ -269,15 +262,17 @@ export class RpcCore {
         memoized = this._memomize(creator, def);
         return memoized;
     }
-    _formatInputs(registry, blockHash, def, inputs) {
-        const reqArgCount = def.params.filter(({ isOptional }) => !isOptional).length;
-        const optText = reqArgCount === def.params.length
-            ? ''
-            : ` (${def.params.length - reqArgCount} optional)`;
-        if (inputs.length < reqArgCount || inputs.length > def.params.length) {
-            throw new Error(`Expected ${def.params.length} parameters${optText}, ${inputs.length} found instead`);
+    _formatParams(registry, blockHash, def, inputs) {
+        const count = inputs.length;
+        const reqCount = def.params.filter(({ isOptional }) => !isOptional).length;
+        if (count < reqCount || count > def.params.length) {
+            throw new Error(`Expected ${def.params.length} parameters${reqCount === def.params.length ? '' : ` (${def.params.length - reqCount} optional)`}, ${count} found instead`);
         }
-        return inputs.map((input, index) => registry.createTypeUnsafe(def.params[index].type, [input], { blockHash }));
+        const params = new Array(count);
+        for (let i = 0; i < count; i++) {
+            params[i] = registry.createTypeUnsafe(def.params[i].type, [inputs[i]], { blockHash });
+        }
+        return params;
     }
     _formatOutput(registry, blockHash, method, rpc, params, result) {
         if (rpc.type === 'StorageData') {
@@ -291,10 +286,16 @@ export class RpcCore {
                 : registry.createType('StorageChangeSet', result);
         }
         else if (rpc.type === 'Vec<StorageChangeSet>') {
-            const mapped = result.map(({ block, changes }) => [
-                registry.createType('Hash', block),
-                this._formatStorageSet(registry, block, params[0], changes)
-            ]);
+            const jsonSet = result;
+            const count = jsonSet.length;
+            const mapped = new Array(count);
+            for (let i = 0; i < count; i++) {
+                const { block, changes } = jsonSet[i];
+                mapped[i] = [
+                    registry.createType('BlockHash', block),
+                    this._formatStorageSet(registry, block, params[0], changes)
+                ];
+            }
             // we only query at a specific block, not a range - flatten
             return method === 'queryStorageAt'
                 ? mapped[0][1]
@@ -315,15 +316,15 @@ export class RpcCore {
     }
     _formatStorageSet(registry, blockHash, keys, changes) {
         // For StorageChangeSet, the changes has the [key, value] mappings
-        const withCache = keys.length !== 1;
-        // multiple return values (via state.storage subscription), decode the values
-        // one at a time, all based on the query types. Three values can be returned -
-        //   - Codec - There is a valid value, non-empty
-        //   - null - The storage key is empty
-        return keys.reduce((results, key, index) => {
-            results.push(this._formatStorageSetEntry(registry, blockHash, key, changes, withCache, index));
-            return results;
-        }, []);
+        const count = keys.length;
+        const withCache = count !== 1;
+        const values = new Array(count);
+        // multiple return values (via state.storage subscription), decode the
+        // values one at a time, all based on the supplied query types
+        for (let i = 0; i < count; i++) {
+            values[i] = this._formatStorageSetEntry(registry, blockHash, keys[i], changes, withCache, i);
+        }
+        return values;
     }
     _formatStorageSetEntry(registry, blockHash, key, changes, withCache, entryIndex) {
         const hexKey = key.toHex();
@@ -334,7 +335,7 @@ export class RpcCore {
         //   - if a single result value, don't fill - it is not an update hole
         //   - fallback to an empty option in all cases
         if (isNotFound && withCache) {
-            const cached = __classPrivateFieldGet(this, _RpcCore_storageCache, "f").get(hexKey);
+            const cached = this.__internal__storageCache.get(hexKey);
             if (cached) {
                 return cached;
             }
@@ -350,7 +351,7 @@ export class RpcCore {
         // store the retrieved result - the only issue with this cache is that there is no
         // clearing of it, so very long running processes (not just a couple of hours, longer)
         // will increase memory beyond what is allowed.
-        __classPrivateFieldGet(this, _RpcCore_storageCache, "f").set(hexKey, codec);
+        this.__internal__storageCache.set(hexKey, codec);
         return codec;
     }
     _newType(registry, blockHash, key, input, isEmpty, entryIndex = -1) {
@@ -371,13 +372,12 @@ export class RpcCore {
                             : hexToU8a(meta.fallback.toHex())
                         : undefined
                     : meta.modifier.isOptional
-                        ? registry.createTypeUnsafe(type, [input], { blockHash, isPedantic: true })
+                        ? registry.createTypeUnsafe(type, [input], { blockHash, isPedantic: this.__internal__isPedantic })
                         : input
-            ], { blockHash, isFallback: isEmpty && !!meta.fallback, isOptional: meta.modifier.isOptional, isPedantic: !meta.modifier.isOptional });
+            ], { blockHash, isFallback: isEmpty && !!meta.fallback, isOptional: meta.modifier.isOptional, isPedantic: this.__internal__isPedantic && !meta.modifier.isOptional });
         }
         catch (error) {
             throw new Error(`Unable to decode storage ${key.section || 'unknown'}.${key.method || 'unknown'}:${entryNum}: ${error.message}`);
         }
     }
 }
-_RpcCore_instanceId = new WeakMap(), _RpcCore_registryDefault = new WeakMap(), _RpcCore_getBlockRegistry = new WeakMap(), _RpcCore_getBlockHash = new WeakMap(), _RpcCore_storageCache = new WeakMap();

package/cjs/bundle.js

@@ -1,5 +1,4 @@
 "use strict";
-var _RpcCore_instanceId, _RpcCore_registryDefault, _RpcCore_getBlockRegistry, _RpcCore_getBlockHash, _RpcCore_storageCache;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcCore = exports.packageInfo = void 0;
 const tslib_1 = require("tslib");
@@ -24,8 +23,7 @@ function logErrorMessage(method, { noErrorLog, params, type }, error) {
     if (noErrorLog) {
         return;
     }
-    const inputs = params.map(({ isOptional, name, type }) => `${name}${isOptional ? '?' : ''}: ${type}`).join(', ');
-    l.error(`${method}(${inputs}): ${type}:: ${error.message}`);
+    l.error(`${method}(${params.map(({ isOptional, name, type }) => `${name}${isOptional ? '?' : ''}: ${type}`).join(', ')}): ${type}:: ${error.message}`);
 }
 function isTreatAsHex(key) {
     // :code is problematic - it does not have the length attached, which is
@@ -58,23 +56,20 @@ function isTreatAsHex(key) {
 class RpcCore {
     /**
      * @constructor
-     * Default constructor for the Api Object
-     * @param  {ProviderInterface} provider An API provider using HTTP or WebSocket
+     * Default constructor for the core RPC handler
+     * @param  {ProviderInterface} provider An API provider using any of the supported providers (HTTP, SC or WebSocket)
      */
-    constructor(instanceId, registry, provider, userRpc = {}) {
-        _RpcCore_instanceId.set(this, void 0);
-        _RpcCore_registryDefault.set(this, void 0);
-        _RpcCore_getBlockRegistry.set(this, void 0);
-        _RpcCore_getBlockHash.set(this, void 0);
-        _RpcCore_storageCache.set(this, new Map());
+    constructor(instanceId, registry, { isPedantic = true, provider, userRpc = {} }) {
+        this.__internal__storageCache = new Map();
         this.mapping = new Map();
         this.sections = [];
         // eslint-disable-next-line @typescript-eslint/unbound-method
         if (!provider || !(0, util_1.isFunction)(provider.send)) {
             throw new Error('Expected Provider to API create');
         }
-        tslib_1.__classPrivateFieldSet(this, _RpcCore_instanceId, instanceId, "f");
-        tslib_1.__classPrivateFieldSet(this, _RpcCore_registryDefault, registry, "f");
+        this.__internal__instanceId = instanceId;
+        this.__internal__isPedantic = isPedantic;
+        this.__internal__registryDefault = registry;
         this.provider = provider;
         const sectionNames = Object.keys(types_1.rpcDefinitions);
         // these are the base keys (i.e. part of jsonrpc)
@@ -104,26 +99,26 @@ class RpcCore {
      * @description Sets a registry swap (typically from Api)
      */
     setRegistrySwap(registrySwap) {
-        tslib_1.__classPrivateFieldSet(this, _RpcCore_getBlockRegistry, (0, util_1.memoize)(registrySwap, {
-            getInstanceId: () => tslib_1.__classPrivateFieldGet(this, _RpcCore_instanceId, "f")
-        }), "f");
+        this.__internal__getBlockRegistry = (0, util_1.memoize)(registrySwap, {
+            getInstanceId: () => this.__internal__instanceId
+        });
     }
     /**
      * @description Sets a function to resolve block hash from block number
      */
     setResolveBlockHash(resolveBlockHash) {
-        tslib_1.__classPrivateFieldSet(this, _RpcCore_getBlockHash, (0, util_1.memoize)(resolveBlockHash, {
-            getInstanceId: () => tslib_1.__classPrivateFieldGet(this, _RpcCore_instanceId, "f")
-        }), "f");
+        this.__internal__getBlockHash = (0, util_1.memoize)(resolveBlockHash, {
+            getInstanceId: () => this.__internal__instanceId
+        });
     }
     addUserInterfaces(userRpc) {
         // add any extra user-defined sections
         this.sections.push(...Object.keys(userRpc).filter((k) => !this.sections.includes(k)));
-        for (let s = 0; s < this.sections.length; s++) {
+        for (let s = 0, scount = this.sections.length; s < scount; s++) {
             const section = this.sections[s];
             const defs = (0, util_1.objectSpread)({}, types_1.rpcDefinitions[section], userRpc[section]);
             const methods = Object.keys(defs);
-            for (let m = 0; m < methods.length; m++) {
+            for (let m = 0, mcount = methods.length; m < mcount; m++) {
                 const method = methods[m];
                 const def = defs[method];
                 const jsonrpc = def.endpoint || `${section}_${method}`;
@@ -141,7 +136,7 @@ class RpcCore {
         }
     }
     _memomize(creator, def) {
-        const memoOpts = { getInstanceId: () => tslib_1.__classPrivateFieldGet(this, _RpcCore_instanceId, "f") };
+        const memoOpts = { getInstanceId: () => this.__internal__instanceId };
         const memoized = (0, util_1.memoize)(creator(true), memoOpts);
         memoized.raw = (0, util_1.memoize)(creator(false), memoOpts);
         memoized.meta = def;
@@ -162,12 +157,12 @@ class RpcCore {
                 ? null
                 : values[hashIndex];
             const blockHash = blockId && def.params[hashIndex].type === 'BlockNumber'
-                ? await tslib_1.__classPrivateFieldGet(this, _RpcCore_getBlockHash, "f")?.call(this, blockId)
+                ? await this.__internal__getBlockHash?.(blockId)
                 : blockId;
-            const { registry } = isScale && blockHash && tslib_1.__classPrivateFieldGet(this, _RpcCore_getBlockRegistry, "f")
-                ? await tslib_1.__classPrivateFieldGet(this, _RpcCore_getBlockRegistry, "f").call(this, (0, util_1.u8aToU8a)(blockHash))
-                : { registry: tslib_1.__classPrivateFieldGet(this, _RpcCore_registryDefault, "f") };
-            const params = this._formatInputs(registry, null, def, values);
+            const { registry } = isScale && blockHash && this.__internal__getBlockRegistry
+                ? await this.__internal__getBlockRegistry((0, util_1.u8aToU8a)(blockHash))
+                : { registry: this.__internal__registryDefault };
+            const params = this._formatParams(registry, null, def, values);
             // only cache .at(<blockHash>) queries, e.g. where valid blockHash was supplied
             const result = await this.provider.send(rpcName, params.map((p) => p.toJSON()), !!blockHash);
             return this._formatResult(isScale, registry, blockHash, method, def, params, result);
@@ -227,14 +222,13 @@ class RpcCore {
             return new rxjs_1.Observable((observer) => {
                 // Have at least an empty promise, as used in the unsubscribe
                 let subscriptionPromise = Promise.resolve(null);
-                const registry = tslib_1.__classPrivateFieldGet(this, _RpcCore_registryDefault, "f");
+                const registry = this.__internal__registryDefault;
                 const errorHandler = (error) => {
                     logErrorMessage(method, def, error);
                     observer.error(error);
                 };
                 try {
-                    const params = this._formatInputs(registry, null, def, values);
-                    const paramsJson = params.map((p) => p.toJSON());
+                    const params = this._formatParams(registry, null, def, values);
                     const update = (error, result) => {
                         if (error) {
                             logErrorMessage(method, def, error);
@@ -247,7 +241,7 @@ class RpcCore {
                             observer.error(error);
                         }
                     };
-                    subscriptionPromise = this._createSubscriber({ paramsJson, subName, subType, update }, errorHandler);
+                    subscriptionPromise = this._createSubscriber({ paramsJson: params.map((p) => p.toJSON()), subName, subType, update }, errorHandler);
                 }
                 catch (error) {
                     errorHandler(error);
@@ -273,15 +267,17 @@ class RpcCore {
         memoized = this._memomize(creator, def);
         return memoized;
     }
-    _formatInputs(registry, blockHash, def, inputs) {
-        const reqArgCount = def.params.filter(({ isOptional }) => !isOptional).length;
-        const optText = reqArgCount === def.params.length
-            ? ''
-            : ` (${def.params.length - reqArgCount} optional)`;
-        if (inputs.length < reqArgCount || inputs.length > def.params.length) {
-            throw new Error(`Expected ${def.params.length} parameters${optText}, ${inputs.length} found instead`);
+    _formatParams(registry, blockHash, def, inputs) {
+        const count = inputs.length;
+        const reqCount = def.params.filter(({ isOptional }) => !isOptional).length;
+        if (count < reqCount || count > def.params.length) {
+            throw new Error(`Expected ${def.params.length} parameters${reqCount === def.params.length ? '' : ` (${def.params.length - reqCount} optional)`}, ${count} found instead`);
         }
-        return inputs.map((input, index) => registry.createTypeUnsafe(def.params[index].type, [input], { blockHash }));
+        const params = new Array(count);
+        for (let i = 0; i < count; i++) {
+            params[i] = registry.createTypeUnsafe(def.params[i].type, [inputs[i]], { blockHash });
+        }
+        return params;
     }
     _formatOutput(registry, blockHash, method, rpc, params, result) {
         if (rpc.type === 'StorageData') {
@@ -295,10 +291,16 @@ class RpcCore {
                 : registry.createType('StorageChangeSet', result);
         }
         else if (rpc.type === 'Vec<StorageChangeSet>') {
-            const mapped = result.map(({ block, changes }) => [
-                registry.createType('Hash', block),
-                this._formatStorageSet(registry, block, params[0], changes)
-            ]);
+            const jsonSet = result;
+            const count = jsonSet.length;
+            const mapped = new Array(count);
+            for (let i = 0; i < count; i++) {
+                const { block, changes } = jsonSet[i];
+                mapped[i] = [
+                    registry.createType('BlockHash', block),
+                    this._formatStorageSet(registry, block, params[0], changes)
+                ];
+            }
             // we only query at a specific block, not a range - flatten
             return method === 'queryStorageAt'
                 ? mapped[0][1]
@@ -319,15 +321,15 @@ class RpcCore {
     }
     _formatStorageSet(registry, blockHash, keys, changes) {
         // For StorageChangeSet, the changes has the [key, value] mappings
-        const withCache = keys.length !== 1;
-        // multiple return values (via state.storage subscription), decode the values
-        // one at a time, all based on the query types. Three values can be returned -
-        //   - Codec - There is a valid value, non-empty
-        //   - null - The storage key is empty
-        return keys.reduce((results, key, index) => {
-            results.push(this._formatStorageSetEntry(registry, blockHash, key, changes, withCache, index));
-            return results;
-        }, []);
+        const count = keys.length;
+        const withCache = count !== 1;
+        const values = new Array(count);
+        // multiple return values (via state.storage subscription), decode the
+        // values one at a time, all based on the supplied query types
+        for (let i = 0; i < count; i++) {
+            values[i] = this._formatStorageSetEntry(registry, blockHash, keys[i], changes, withCache, i);
+        }
+        return values;
     }
     _formatStorageSetEntry(registry, blockHash, key, changes, withCache, entryIndex) {
         const hexKey = key.toHex();
@@ -338,7 +340,7 @@ class RpcCore {
         //   - if a single result value, don't fill - it is not an update hole
         //   - fallback to an empty option in all cases
         if (isNotFound && withCache) {
-            const cached = tslib_1.__classPrivateFieldGet(this, _RpcCore_storageCache, "f").get(hexKey);
+            const cached = this.__internal__storageCache.get(hexKey);
             if (cached) {
                 return cached;
             }
@@ -354,7 +356,7 @@ class RpcCore {
         // store the retrieved result - the only issue with this cache is that there is no
         // clearing of it, so very long running processes (not just a couple of hours, longer)
         // will increase memory beyond what is allowed.
-        tslib_1.__classPrivateFieldGet(this, _RpcCore_storageCache, "f").set(hexKey, codec);
+        this.__internal__storageCache.set(hexKey, codec);
         return codec;
     }
     _newType(registry, blockHash, key, input, isEmpty, entryIndex = -1) {
@@ -375,9 +377,9 @@ class RpcCore {
                             : (0, util_1.hexToU8a)(meta.fallback.toHex())
                         : undefined
                     : meta.modifier.isOptional
-                        ? registry.createTypeUnsafe(type, [input], { blockHash, isPedantic: true })
+                        ? registry.createTypeUnsafe(type, [input], { blockHash, isPedantic: this.__internal__isPedantic })
                         : input
-            ], { blockHash, isFallback: isEmpty && !!meta.fallback, isOptional: meta.modifier.isOptional, isPedantic: !meta.modifier.isOptional });
+            ], { blockHash, isFallback: isEmpty && !!meta.fallback, isOptional: meta.modifier.isOptional, isPedantic: this.__internal__isPedantic && !meta.modifier.isOptional });
         }
         catch (error) {
             throw new Error(`Unable to decode storage ${key.section || 'unknown'}.${key.method || 'unknown'}:${entryNum}: ${error.message}`);
@@ -385,4 +387,3 @@ class RpcCore {
     }
 }
 exports.RpcCore = RpcCore;
-_RpcCore_instanceId = new WeakMap(), _RpcCore_registryDefault = new WeakMap(), _RpcCore_getBlockRegistry = new WeakMap(), _RpcCore_getBlockHash = new WeakMap(), _RpcCore_storageCache = new WeakMap();

package/cjs/packageInfo.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.packageInfo = void 0;
-exports.packageInfo = { name: '@polkadot/rpc-core', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '10.4.1' };
+exports.packageInfo = { name: '@polkadot/rpc-core', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '10.6.1' };

package/package.json

@@ -18,7 +18,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "10.4.1",
+  "version": "10.6.1",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -96,11 +96,11 @@
     }
   },
   "dependencies": {
-    "@polkadot/rpc-augment": "10.4.1",
-    "@polkadot/rpc-provider": "10.4.1",
-    "@polkadot/types": "10.4.1",
-    "@polkadot/util": "^12.0.1",
-    "rxjs": "^7.8.0",
+    "@polkadot/rpc-augment": "10.6.1",
+    "@polkadot/rpc-provider": "10.6.1",
+    "@polkadot/types": "10.6.1",
+    "@polkadot/util": "^12.1.2",
+    "rxjs": "^7.8.1",
     "tslib": "^2.5.0"
   }
 }

package/packageInfo.js

@@ -1 +1 @@
-export const packageInfo = { name: '@polkadot/rpc-core', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '10.4.1' };
+export const packageInfo = { name: '@polkadot/rpc-core', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '10.6.1' };