@polkadot/rpc-core 6.6.2-2 → 6.6.2-23

package/bundle.cjs

@@ -19,9 +19,9 @@ Object.defineProperty(exports, "packageInfo", {
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+var _classPrivateFieldGet2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldGet"));
 
-var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+var _classPrivateFieldSet2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldSet"));
 
 var _rxjs = require("rxjs");
 
@@ -45,9 +45,9 @@ Object.keys(_index).forEach(function (key) {
 
 var _packageInfo = require("./packageInfo.cjs");
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
 
 const l = (0, _util.logger)('rpc-core');
 const EMPTY_META = {
@@ -67,15 +67,19 @@ const EMPTY_META = {
 
 /** @internal */
 
-function logErrorMessage(method, {
-  params,
-  type
-}, error) {
-  const inputs = params.map(({
-    isOptional,
-    name,
+function logErrorMessage(method, _ref, error) {
+  let {
+    params,
     type
-  }) => `${name}${isOptional ? '?' : ''}: ${type}`).join(', ');
+  } = _ref;
+  const inputs = params.map(_ref2 => {
+    let {
+      isOptional,
+      name,
+      type
+    } = _ref2;
+    return `${name}${isOptional ? '?' : ''}: ${type}`;
+  }).join(', ');
   l.error(`${method}(${inputs}): ${type}:: ${error.message}`);
 }
 
@@ -109,13 +113,13 @@ function isTreatAsHex(key) {
  */
 
 
-var _instanceId = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("instanceId");
+var _instanceId = /*#__PURE__*/new WeakMap();
 
-var _registryDefault = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("registryDefault");
+var _registryDefault = /*#__PURE__*/new WeakMap();
 
-var _getBlockRegistry = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("getBlockRegistry");
+var _getBlockRegistry = /*#__PURE__*/new WeakMap();
 
-var _storageCache = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("storageCache");
+var _storageCache = /*#__PURE__*/new WeakMap();
 
 class RpcCore {
   /**
@@ -123,30 +127,36 @@ class RpcCore {
    * Default constructor for the Api Object
    * @param  {ProviderInterface} provider An API provider using HTTP or WebSocket
    */
-  constructor(instanceId, registry, provider, userRpc = {}) {
-    Object.defineProperty(this, _instanceId, {
+  constructor(instanceId, registry, provider) {
+    let userRpc = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+    _classPrivateFieldInitSpec(this, _instanceId, {
       writable: true,
       value: void 0
     });
-    Object.defineProperty(this, _registryDefault, {
+
+    _classPrivateFieldInitSpec(this, _registryDefault, {
       writable: true,
       value: void 0
     });
-    Object.defineProperty(this, _getBlockRegistry, {
+
+    _classPrivateFieldInitSpec(this, _getBlockRegistry, {
       writable: true,
       value: void 0
     });
-    Object.defineProperty(this, _storageCache, {
+
+    _classPrivateFieldInitSpec(this, _storageCache, {
       writable: true,
       value: new Map()
     });
-    this.mapping = new Map();
-    this.provider = void 0;
-    this.sections = [];
+
+    (0, _defineProperty2.default)(this, "mapping", new Map());
+    (0, _defineProperty2.default)(this, "provider", void 0);
+    (0, _defineProperty2.default)(this, "sections", []);
     // eslint-disable-next-line @typescript-eslint/unbound-method
     (0, _util.assert)(provider && (0, _util.isFunction)(provider.send), 'Expected Provider to API create');
-    (0, _classPrivateFieldLooseBase2.default)(this, _instanceId)[_instanceId] = instanceId;
-    (0, _classPrivateFieldLooseBase2.default)(this, _registryDefault)[_registryDefault] = registry;
+    (0, _classPrivateFieldSet2.default)(this, _instanceId, instanceId);
+    (0, _classPrivateFieldSet2.default)(this, _registryDefault, registry);
     this.provider = provider;
     const sectionNames = Object.keys(_types.rpcDefinitions); // these are the base keys (i.e. part of jsonrpc)
 
@@ -184,49 +194,47 @@ class RpcCore {
 
 
   setRegistrySwap(registrySwap) {
-    (0, _classPrivateFieldLooseBase2.default)(this, _getBlockRegistry)[_getBlockRegistry] = (0, _util.memoize)(registrySwap, {
-      getInstanceId: () => (0, _classPrivateFieldLooseBase2.default)(this, _instanceId)[_instanceId]
-    });
+    (0, _classPrivateFieldSet2.default)(this, _getBlockRegistry, (0, _util.memoize)(registrySwap, {
+      getInstanceId: () => (0, _classPrivateFieldGet2.default)(this, _instanceId)
+    }));
   }
 
   addUserInterfaces(userRpc) {
     // add any extra user-defined sections
-    this.sections.push(...Object.keys(userRpc).filter(key => !this.sections.includes(key))); // decorate the sections with base and user methods
-
-    this.sections.forEach(sectionName => {
-      var _ref, _ref2;
-
-      (_ref = this)[_ref2 = sectionName] || (_ref[_ref2] = {});
-      const section = this[sectionName];
-      Object.entries(_objectSpread(_objectSpread({}, this._createInterface(sectionName, _types.rpcDefinitions[sectionName] || {})), this._createInterface(sectionName, userRpc[sectionName] || {}))).forEach(([key, value]) => {
-        section[key] || (section[key] = value);
-      });
-    });
-  }
-
-  _createInterface(section, methods) {
-    return Object.entries(methods).filter(([method, {
-      endpoint
-    }]) => !this.mapping.has(endpoint || `${section}_${method}`)).reduce((exposed, [method, {
-      endpoint
-    }]) => {
-      const def = methods[method];
-      const isSubscription = !!def.pubsub;
-      const jsonrpc = endpoint || `${section}_${method}`;
-      this.mapping.set(jsonrpc, _objectSpread(_objectSpread({}, def), {}, {
-        isSubscription,
-        jsonrpc,
-        method,
-        section
-      }));
-      exposed[method] = isSubscription ? this._createMethodSubscribe(section, method, def) : this._createMethodSend(section, method, def);
-      return exposed;
-    }, {});
+    this.sections.push(...Object.keys(userRpc).filter(k => !this.sections.includes(k)));
+
+    for (let s = 0; s < this.sections.length; s++) {
+      const section = this.sections[s];
+      const defs = (0, _util.objectSpread)({}, _types.rpcDefinitions[section], userRpc[section]);
+      const methods = Object.keys(defs);
+
+      for (let m = 0; m < methods.length; m++) {
+        const method = methods[m];
+        const def = defs[method];
+        const jsonrpc = def.endpoint || `${section}_${method}`;
+
+        if (!this.mapping.has(jsonrpc)) {
+          const isSubscription = !!def.pubsub;
+
+          if (!this[section]) {
+            this[section] = {};
+          }
+
+          this.mapping.set(jsonrpc, (0, _util.objectSpread)({}, def, {
+            isSubscription,
+            jsonrpc,
+            method,
+            section
+          }));
+          (0, _util.lazyMethod)(this[section], method, () => isSubscription ? this._createMethodSubscribe(section, method, def) : this._createMethodSend(section, method, def));
+        }
+      }
+    }
   }
 
   _memomize(creator, def) {
     const memoOpts = {
-      getInstanceId: () => (0, _classPrivateFieldLooseBase2.default)(this, _instanceId)[_instanceId]
+      getInstanceId: () => (0, _classPrivateFieldGet2.default)(this, _instanceId)
     };
     const memoized = (0, _util.memoize)(creator(true), memoOpts);
     memoized.raw = (0, _util.memoize)(creator(false), memoOpts);
@@ -240,17 +248,20 @@ class RpcCore {
 
   _createMethodSend(section, method, def) {
     const rpcName = def.endpoint || `${section}_${method}`;
-    const hashIndex = def.params.findIndex(({
-      isHistoric
-    }) => isHistoric);
+    const hashIndex = def.params.findIndex(_ref3 => {
+      let {
+        isHistoric
+      } = _ref3;
+      return isHistoric;
+    });
     let memoized = null; // execute the RPC call, doing a registry swap for historic as applicable
 
     const callWithRegistry = async (isScale, values) => {
       const blockHash = hashIndex === -1 ? null : values[hashIndex];
       const {
         registry
-      } = isScale && blockHash && (0, _classPrivateFieldLooseBase2.default)(this, _getBlockRegistry)[_getBlockRegistry] ? await (0, _classPrivateFieldLooseBase2.default)(this, _getBlockRegistry)[_getBlockRegistry]((0, _util.u8aToU8a)(blockHash)) : {
-        registry: (0, _classPrivateFieldLooseBase2.default)(this, _registryDefault)[_registryDefault]
+      } = isScale && blockHash && (0, _classPrivateFieldGet2.default)(this, _getBlockRegistry) ? await (0, _classPrivateFieldGet2.default)(this, _getBlockRegistry).call(this, (0, _util.u8aToU8a)(blockHash)) : {
+        registry: (0, _classPrivateFieldGet2.default)(this, _registryDefault)
       };
 
       const params = this._formatInputs(registry, null, def, values);
@@ -259,7 +270,11 @@ class RpcCore {
       return this._formatResult(isScale, registry, blockHash, method, def, params, result);
     };
 
-    const creator = isScale => (...values) => {
+    const creator = isScale => function () {
+      for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
+        values[_key] = arguments[_key];
+      }
+
       const isDelayed = isScale && hashIndex !== -1 && !!values[hashIndex];
       return new _rxjs.Observable(observer => {
         callWithRegistry(isScale, values).then(value => {
@@ -286,12 +301,13 @@ class RpcCore {
   } // create a subscriptor, it subscribes once and resolves with the id as subscribe
 
 
-  _createSubscriber({
-    paramsJson,
-    subName,
-    subType,
-    update
-  }, errorHandler) {
+  _createSubscriber(_ref4, errorHandler) {
+    let {
+      paramsJson,
+      subName,
+      subType,
+      update
+    } = _ref4;
     return new Promise((resolve, reject) => {
       this.provider.subscribe(subType, subName, paramsJson, update).then(resolve).catch(error => {
         errorHandler(error);
@@ -301,18 +317,23 @@ class RpcCore {
   }
 
   _createMethodSubscribe(section, method, def) {
+    var _this = this;
+
     const [updateType, subMethod, unsubMethod] = def.pubsub;
     const subName = `${section}_${subMethod}`;
     const unsubName = `${section}_${unsubMethod}`;
     const subType = `${section}_${updateType}`;
     let memoized = null;
 
-    const creator = isScale => (...values) => {
+    const creator = isScale => function () {
+      for (var _len2 = arguments.length, values = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        values[_key2] = arguments[_key2];
+      }
+
       return new _rxjs.Observable(observer => {
         // Have at least an empty promise, as used in the unsubscribe
         let subscriptionPromise = Promise.resolve(null);
-
-        const registry = (0, _classPrivateFieldLooseBase2.default)(this, _registryDefault)[_registryDefault];
+        const registry = (0, _classPrivateFieldGet2.default)(_this, _registryDefault);
 
         const errorHandler = error => {
           logErrorMessage(method, def, error);
@@ -320,7 +341,7 @@ class RpcCore {
         };
 
         try {
-          const params = this._formatInputs(registry, null, def, values);
+          const params = _this._formatInputs(registry, null, def, values);
 
           const paramsJson = params.map(p => p.toJSON());
 
@@ -331,13 +352,13 @@ class RpcCore {
             }
 
             try {
-              observer.next(this._formatResult(isScale, registry, null, method, def, params, result));
+              observer.next(_this._formatResult(isScale, registry, null, method, def, params, result));
             } catch (error) {
               observer.error(error);
             }
           };
 
-          subscriptionPromise = this._createSubscriber({
+          subscriptionPromise = _this._createSubscriber({
             paramsJson,
             subName,
             subType,
@@ -354,7 +375,7 @@ class RpcCore {
           // Delete from cache, so old results don't hang around
           (_memoized2 = memoized) === null || _memoized2 === void 0 ? void 0 : _memoized2.unmemoize(...values); // Unsubscribe from provider
 
-          subscriptionPromise.then(subscriptionId => (0, _util.isNull)(subscriptionId) ? Promise.resolve(false) : this.provider.unsubscribe(subType, unsubName, subscriptionId)).catch(error => logErrorMessage(method, def, error));
+          subscriptionPromise.then(subscriptionId => (0, _util.isNull)(subscriptionId) ? Promise.resolve(false) : _this.provider.unsubscribe(subType, unsubName, subscriptionId)).catch(error => logErrorMessage(method, def, error));
         };
       }).pipe((0, _index.drr)());
     };
@@ -364,9 +385,12 @@ class RpcCore {
   }
 
   _formatInputs(registry, blockHash, def, inputs) {
-    const reqArgCount = def.params.filter(({
-      isOptional
-    }) => !isOptional).length;
+    const reqArgCount = def.params.filter(_ref5 => {
+      let {
+        isOptional
+      } = _ref5;
+      return !isOptional;
+    }).length;
     const optText = reqArgCount === def.params.length ? '' : ` (${def.params.length - reqArgCount} optional)`;
     (0, _util.assert)(inputs.length >= reqArgCount && inputs.length <= def.params.length, () => `Expected ${def.params.length} parameters${optText}, ${inputs.length} found instead`);
     return inputs.map((input, index) => registry.createTypeUnsafe(def.params[index].type, [input], {
@@ -382,10 +406,13 @@ class RpcCore {
       const keys = params[0];
       return keys ? this._formatStorageSet(registry, result.block, keys, result.changes) : 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)]); // we only query at a specific block, not a range - flatten
+      const mapped = result.map(_ref6 => {
+        let {
+          block,
+          changes
+        } = _ref6;
+        return [registry.createType('Hash', 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] : mapped;
     }
@@ -418,23 +445,26 @@ class RpcCore {
 
   _formatStorageSetEntry(registry, blockHash, key, changes, witCache, entryIndex) {
     const hexKey = key.toHex();
-    const found = changes.find(([key]) => key === hexKey); // if we don't find the value, this is our fallback
+    const found = changes.find(_ref7 => {
+      let [key] = _ref7;
+      return key === hexKey;
+    }); // if we don't find the value, this is our fallback
     //   - in the case of an array of values, fill the hole from the cache
     //   - if a single result value, don't fill - it is not an update hole
     //   - fallback to an empty option in all cases
 
-    const value = (0, _util.isUndefined)(found) ? witCache && (0, _classPrivateFieldLooseBase2.default)(this, _storageCache)[_storageCache].get(hexKey) || null : found[1];
+    const value = (0, _util.isUndefined)(found) ? witCache && (0, _classPrivateFieldGet2.default)(this, _storageCache).get(hexKey) || null : found[1];
     const isEmpty = (0, _util.isNull)(value);
     const input = isEmpty || isTreatAsHex(key) ? value : (0, _util.u8aToU8a)(value); // 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.
 
-    (0, _classPrivateFieldLooseBase2.default)(this, _storageCache)[_storageCache].set(hexKey, value);
-
+    (0, _classPrivateFieldGet2.default)(this, _storageCache).set(hexKey, value);
     return this._newType(registry, blockHash, key, input, isEmpty, entryIndex);
   }
 
-  _newType(registry, blockHash, key, input, isEmpty, entryIndex = -1) {
+  _newType(registry, blockHash, key, input, isEmpty) {
+    let entryIndex = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : -1;
     // single return value (via state.getStorage), decode the value based on the
     // outputType that we have specified. Fallback to Raw on nothing
     const type = key.outputType || 'Raw';

package/bundle.d.ts

@@ -1,6 +1,5 @@
 import type { ProviderInterface } from '@polkadot/rpc-provider/types';
 import type { DefinitionRpc, DefinitionRpcExt, DefinitionRpcSub, Registry } from '@polkadot/types/types';
-import type { RpcInterface } from './types';
 export { packageInfo } from './packageInfo';
 export * from './util';
 /**
@@ -55,8 +54,7 @@ export declare class RpcCore {
     setRegistrySwap(registrySwap: (blockHash: Uint8Array) => Promise<{
         registry: Registry;
     }>): void;
-    addUserInterfaces<Section extends keyof RpcInterface>(userRpc: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>): void;
-    private _createInterface;
+    addUserInterfaces(userRpc: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>): void;
     private _memomize;
     private _formatResult;
     private _createMethodSend;

package/bundle.js

@@ -1,16 +1,8 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _classPrivateFieldLooseBase from "@babel/runtime/helpers/esm/classPrivateFieldLooseBase";
-import _classPrivateFieldLooseKey from "@babel/runtime/helpers/esm/classPrivateFieldLooseKey";
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
 // Copyright 2017-2021 @polkadot/rpc-core authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 import { Observable, publishReplay, refCount } from 'rxjs';
 import { rpcDefinitions } from '@polkadot/types';
-import { assert, hexToU8a, isFunction, isNull, isUndefined, logger, memoize, u8aToU8a } from '@polkadot/util';
+import { assert, hexToU8a, isFunction, isNull, isUndefined, lazyMethod, logger, memoize, objectSpread, u8aToU8a } from '@polkadot/util';
 import { drr, refCountDelay } from "./util/index.js";
 export { packageInfo } from "./packageInfo.js";
 export * from "./util/index.js";
@@ -74,44 +66,24 @@ function isTreatAsHex(key) {
  */
 
 
-var _instanceId = /*#__PURE__*/_classPrivateFieldLooseKey("instanceId");
-
-var _registryDefault = /*#__PURE__*/_classPrivateFieldLooseKey("registryDefault");
-
-var _getBlockRegistry = /*#__PURE__*/_classPrivateFieldLooseKey("getBlockRegistry");
-
-var _storageCache = /*#__PURE__*/_classPrivateFieldLooseKey("storageCache");
-
 export class RpcCore {
+  #instanceId;
+  #registryDefault;
+  #getBlockRegistry;
+  #storageCache = new Map();
+  mapping = new Map();
+  sections = [];
   /**
    * @constructor
    * Default constructor for the Api Object
    * @param  {ProviderInterface} provider An API provider using HTTP or WebSocket
    */
+
   constructor(instanceId, registry, provider, userRpc = {}) {
-    Object.defineProperty(this, _instanceId, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _registryDefault, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _getBlockRegistry, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _storageCache, {
-      writable: true,
-      value: new Map()
-    });
-    this.mapping = new Map();
-    this.provider = void 0;
-    this.sections = [];
     // eslint-disable-next-line @typescript-eslint/unbound-method
     assert(provider && isFunction(provider.send), 'Expected Provider to API create');
-    _classPrivateFieldLooseBase(this, _instanceId)[_instanceId] = instanceId;
-    _classPrivateFieldLooseBase(this, _registryDefault)[_registryDefault] = registry;
+    this.#instanceId = instanceId;
+    this.#registryDefault = registry;
     this.provider = provider;
     const sectionNames = Object.keys(rpcDefinitions); // these are the base keys (i.e. part of jsonrpc)
 
@@ -149,49 +121,47 @@ export class RpcCore {
 
 
   setRegistrySwap(registrySwap) {
-    _classPrivateFieldLooseBase(this, _getBlockRegistry)[_getBlockRegistry] = memoize(registrySwap, {
-      getInstanceId: () => _classPrivateFieldLooseBase(this, _instanceId)[_instanceId]
+    this.#getBlockRegistry = memoize(registrySwap, {
+      getInstanceId: () => this.#instanceId
     });
   }
 
   addUserInterfaces(userRpc) {
     // add any extra user-defined sections
-    this.sections.push(...Object.keys(userRpc).filter(key => !this.sections.includes(key))); // decorate the sections with base and user methods
-
-    this.sections.forEach(sectionName => {
-      var _ref, _ref2;
-
-      (_ref = this)[_ref2 = sectionName] || (_ref[_ref2] = {});
-      const section = this[sectionName];
-      Object.entries(_objectSpread(_objectSpread({}, this._createInterface(sectionName, rpcDefinitions[sectionName] || {})), this._createInterface(sectionName, userRpc[sectionName] || {}))).forEach(([key, value]) => {
-        section[key] || (section[key] = value);
-      });
-    });
-  }
-
-  _createInterface(section, methods) {
-    return Object.entries(methods).filter(([method, {
-      endpoint
-    }]) => !this.mapping.has(endpoint || `${section}_${method}`)).reduce((exposed, [method, {
-      endpoint
-    }]) => {
-      const def = methods[method];
-      const isSubscription = !!def.pubsub;
-      const jsonrpc = endpoint || `${section}_${method}`;
-      this.mapping.set(jsonrpc, _objectSpread(_objectSpread({}, def), {}, {
-        isSubscription,
-        jsonrpc,
-        method,
-        section
-      }));
-      exposed[method] = isSubscription ? this._createMethodSubscribe(section, method, def) : this._createMethodSend(section, method, def);
-      return exposed;
-    }, {});
+    this.sections.push(...Object.keys(userRpc).filter(k => !this.sections.includes(k)));
+
+    for (let s = 0; s < this.sections.length; 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++) {
+        const method = methods[m];
+        const def = defs[method];
+        const jsonrpc = def.endpoint || `${section}_${method}`;
+
+        if (!this.mapping.has(jsonrpc)) {
+          const isSubscription = !!def.pubsub;
+
+          if (!this[section]) {
+            this[section] = {};
+          }
+
+          this.mapping.set(jsonrpc, objectSpread({}, def, {
+            isSubscription,
+            jsonrpc,
+            method,
+            section
+          }));
+          lazyMethod(this[section], method, () => isSubscription ? this._createMethodSubscribe(section, method, def) : this._createMethodSend(section, method, def));
+        }
+      }
+    }
   }
 
   _memomize(creator, def) {
     const memoOpts = {
-      getInstanceId: () => _classPrivateFieldLooseBase(this, _instanceId)[_instanceId]
+      getInstanceId: () => this.#instanceId
     };
     const memoized = memoize(creator(true), memoOpts);
     memoized.raw = memoize(creator(false), memoOpts);
@@ -214,8 +184,8 @@ export class RpcCore {
       const blockHash = hashIndex === -1 ? null : values[hashIndex];
       const {
         registry
-      } = isScale && blockHash && _classPrivateFieldLooseBase(this, _getBlockRegistry)[_getBlockRegistry] ? await _classPrivateFieldLooseBase(this, _getBlockRegistry)[_getBlockRegistry](u8aToU8a(blockHash)) : {
-        registry: _classPrivateFieldLooseBase(this, _registryDefault)[_registryDefault]
+      } = isScale && blockHash && this.#getBlockRegistry ? await this.#getBlockRegistry(u8aToU8a(blockHash)) : {
+        registry: this.#registryDefault
       };
 
       const params = this._formatInputs(registry, null, def, values);
@@ -276,8 +246,7 @@ 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 = _classPrivateFieldLooseBase(this, _registryDefault)[_registryDefault];
+        const registry = this.#registryDefault;
 
         const errorHandler = error => {
           logErrorMessage(method, def, error);
@@ -388,14 +357,13 @@ 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
 
-    const value = isUndefined(found) ? witCache && _classPrivateFieldLooseBase(this, _storageCache)[_storageCache].get(hexKey) || null : found[1];
+    const value = isUndefined(found) ? witCache && this.#storageCache.get(hexKey) || null : found[1];
     const isEmpty = isNull(value);
     const input = isEmpty || isTreatAsHex(key) ? value : u8aToU8a(value); // 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.
 
-    _classPrivateFieldLooseBase(this, _storageCache)[_storageCache].set(hexKey, value);
-
+    this.#storageCache.set(hexKey, value);
     return this._newType(registry, blockHash, key, input, isEmpty, entryIndex);
   }
 

package/package.json

@@ -20,17 +20,17 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "6.6.2-2",
+  "version": "6.6.2-23",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.15.4",
-    "@polkadot/rpc-provider": "6.6.2-2",
-    "@polkadot/types": "6.6.2-2",
-    "@polkadot/util": "^7.7.1",
+    "@babel/runtime": "^7.16.0",
+    "@polkadot/rpc-provider": "6.6.2-23",
+    "@polkadot/types": "6.6.2-23",
+    "@polkadot/util": "^7.8.1",
     "rxjs": "^7.4.0"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^7.7.1"
+    "@polkadot/keyring": "^7.8.1"
   },
   "exports": {
     ".": {

package/packageInfo.cjs

@@ -9,6 +9,6 @@ exports.packageInfo = void 0;
 // Auto-generated by @polkadot/dev, do not edit
 const packageInfo = {
   name: '@polkadot/rpc-core',
-  version: '6.6.2-2'
+  version: '6.6.2-23'
 };
 exports.packageInfo = packageInfo;

package/packageInfo.js

@@ -3,5 +3,5 @@
 // Auto-generated by @polkadot/dev, do not edit
 export const packageInfo = {
   name: '@polkadot/rpc-core',
-  version: '6.6.2-2'
+  version: '6.6.2-23'
 };

package/types.jsonrpc.d.ts

@@ -1,7 +1,8 @@
 import type { Observable } from 'rxjs';
-import type { AnyFunction } from '@polkadot/types/types';
+import type { AnyFunction, DefinitionRpc } from '@polkadot/types/types';
 export interface RpcInterface {
 }
 export declare type AugmentedRpc<F extends AnyFunction> = F & {
     raw: <T>(...params: Parameters<F>) => Observable<T>;
+    meta: DefinitionRpc;
 };

package/util/drr.cjs

@@ -35,10 +35,13 @@ const NOOP = () => undefined;
  */
 
 
-const drr = ({
-  delay,
-  skipChange = false,
-  skipTimeout = false
-} = {}) => source$ => source$.pipe((0, _rxjs.catchError)(ERR), skipChange ? (0, _rxjs.tap)(NOOP) : (0, _rxjs.distinctUntilChanged)(CMP), (0, _rxjs.publishReplay)(1), skipTimeout ? (0, _rxjs.refCount)() : (0, _refCountDelay.refCountDelay)(delay));
+const drr = function () {
+  let {
+    delay,
+    skipChange = false,
+    skipTimeout = false
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return source$ => source$.pipe((0, _rxjs.catchError)(ERR), skipChange ? (0, _rxjs.tap)(NOOP) : (0, _rxjs.distinctUntilChanged)(CMP), (0, _rxjs.publishReplay)(1), skipTimeout ? (0, _rxjs.refCount)() : (0, _refCountDelay.refCountDelay)(delay));
+};
 
 exports.drr = drr;

package/util/memo.cjs

@@ -23,12 +23,18 @@ function memo(instanceId, inner) {
   const options = {
     getInstanceId: () => instanceId
   };
-  const cached = (0, _util.memoize)((...params) => new _rxjs.Observable(observer => {
-    const subscription = inner(...params).subscribe(observer);
-    return () => {
-      cached.unmemoize(...params);
-      subscription.unsubscribe();
-    };
-  }).pipe((0, _drr.drr)()), options);
+  const cached = (0, _util.memoize)(function () {
+    for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
+      params[_key] = arguments[_key];
+    }
+
+    return new _rxjs.Observable(observer => {
+      const subscription = inner(...params).subscribe(observer);
+      return () => {
+        cached.unmemoize(...params);
+        subscription.unsubscribe();
+      };
+    }).pipe((0, _drr.drr)());
+  }, options);
   return cached;
 }

package/util/refCountDelay.cjs

@@ -11,7 +11,8 @@ var _rxjs = require("rxjs");
 // SPDX-License-Identifier: Apache-2.0
 
 /** @internal */
-function refCountDelay(delay = 1750) {
+function refCountDelay() {
+  let delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1750;
   return source => {
     // state: 0 = disconnected, 1 = disconnecting, 2 = connecting, 3 = connected
     let [state, refCount, connection, scheduler] = [0, 0, _rxjs.Subscription.EMPTY, _rxjs.Subscription.EMPTY];