@polkadot/rpc-core 6.6.2-10 → 6.6.2-14

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 = {
@@ -113,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 {
   /**
@@ -129,29 +129,34 @@ class RpcCore {
    */
   constructor(instanceId, registry, provider) {
     let userRpc = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    Object.defineProperty(this, _instanceId, {
+
+    _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)
 
@@ -189,54 +194,50 @@ 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.push(...Object.keys(userRpc).filter(k => !this.sections.includes(k)));
 
-    this.sections.forEach(sectionName => {
-      var _ref3, _ref4;
+    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);
 
-      (_ref3 = this)[_ref4 = sectionName] || (_ref3[_ref4] = {});
-      const section = this[sectionName];
-      Object.entries(_objectSpread(_objectSpread({}, this._createInterface(sectionName, _types.rpcDefinitions[sectionName] || {})), this._createInterface(sectionName, userRpc[sectionName] || {}))).forEach(_ref5 => {
-        let [key, value] = _ref5;
-        section[key] || (section[key] = value);
-      });
-    });
+      for (let m = 0; m < methods.length; m++) {
+        const method = methods[m];
+        const def = defs[method];
+
+        if (!this.mapping.has(def.endpoint || `${section}_${method}`)) {
+          if (!this[section]) {
+            this[section] = {};
+          }
+
+          (0, _util.lazyMethod)(this[section], method, () => this._createInterface(section, method, def));
+        }
+      }
+    }
   }
 
-  _createInterface(section, methods) {
-    return Object.entries(methods).filter(_ref6 => {
-      let [method, {
-        endpoint
-      }] = _ref6;
-      return !this.mapping.has(endpoint || `${section}_${method}`);
-    }).reduce((exposed, _ref7) => {
-      let [method, {
-        endpoint
-      }] = _ref7;
-      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;
-    }, {});
+  _createInterface(section, method, def) {
+    const isSubscription = !!def.pubsub;
+    const jsonrpc = def.endpoint || `${section}_${method}`;
+    this.mapping.set(jsonrpc, { ...def,
+      isSubscription,
+      jsonrpc,
+      method,
+      section
+    });
+    return 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);
@@ -250,10 +251,10 @@ class RpcCore {
 
   _createMethodSend(section, method, def) {
     const rpcName = def.endpoint || `${section}_${method}`;
-    const hashIndex = def.params.findIndex(_ref8 => {
+    const hashIndex = def.params.findIndex(_ref3 => {
       let {
         isHistoric
-      } = _ref8;
+      } = _ref3;
       return isHistoric;
     });
     let memoized = null; // execute the RPC call, doing a registry swap for historic as applicable
@@ -262,8 +263,8 @@ class RpcCore {
       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);
@@ -303,13 +304,13 @@ class RpcCore {
   } // create a subscriptor, it subscribes once and resolves with the id as subscribe
 
 
-  _createSubscriber(_ref9, errorHandler) {
+  _createSubscriber(_ref4, errorHandler) {
     let {
       paramsJson,
       subName,
       subType,
       update
-    } = _ref9;
+    } = _ref4;
     return new Promise((resolve, reject) => {
       this.provider.subscribe(subType, subName, paramsJson, update).then(resolve).catch(error => {
         errorHandler(error);
@@ -335,8 +336,7 @@ class RpcCore {
       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);
@@ -388,10 +388,10 @@ class RpcCore {
   }
 
   _formatInputs(registry, blockHash, def, inputs) {
-    const reqArgCount = def.params.filter(_ref10 => {
+    const reqArgCount = def.params.filter(_ref5 => {
       let {
         isOptional
-      } = _ref10;
+      } = _ref5;
       return !isOptional;
     }).length;
     const optText = reqArgCount === def.params.length ? '' : ` (${def.params.length - reqArgCount} optional)`;
@@ -409,11 +409,11 @@ 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(_ref11 => {
+      const mapped = result.map(_ref6 => {
         let {
           block,
           changes
-        } = _ref11;
+        } = _ref6;
         return [registry.createType('Hash', block), this._formatStorageSet(registry, block, params[0], changes)];
       }); // we only query at a specific block, not a range - flatten
 
@@ -448,22 +448,21 @@ class RpcCore {
 
   _formatStorageSetEntry(registry, blockHash, key, changes, witCache, entryIndex) {
     const hexKey = key.toHex();
-    const found = changes.find(_ref12 => {
-      let [key] = _ref12;
+    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);
   }
 

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,7 +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;
+    addUserInterfaces(userRpc: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>): void;
     private _createInterface;
     private _memomize;
     private _formatResult;

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,50 @@ 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.push(...Object.keys(userRpc).filter(k => !this.sections.includes(k)));
 
-    this.sections.forEach(sectionName => {
-      var _ref, _ref2;
+    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);
 
-      (_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);
-      });
-    });
+      for (let m = 0; m < methods.length; m++) {
+        const method = methods[m];
+        const def = defs[method];
+
+        if (!this.mapping.has(def.endpoint || `${section}_${method}`)) {
+          if (!this[section]) {
+            this[section] = {};
+          }
+
+          lazyMethod(this[section], method, () => this._createInterface(section, method, def));
+        }
+      }
+    }
   }
 
-  _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;
-    }, {});
+  _createInterface(section, method, def) {
+    const isSubscription = !!def.pubsub;
+    const jsonrpc = def.endpoint || `${section}_${method}`;
+    this.mapping.set(jsonrpc, { ...def,
+      isSubscription,
+      jsonrpc,
+      method,
+      section
+    });
+    return 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 +187,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 +249,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 +360,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-10",
+  "version": "6.6.2-14",
   "main": "index.js",
   "dependencies": {
     "@babel/runtime": "^7.16.0",
-    "@polkadot/rpc-provider": "6.6.2-10",
-    "@polkadot/types": "6.6.2-10",
-    "@polkadot/util": "^7.7.1",
+    "@polkadot/rpc-provider": "6.6.2-14",
+    "@polkadot/types": "6.6.2-14",
+    "@polkadot/util": "^7.7.2-5",
     "rxjs": "^7.4.0"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^7.7.1"
+    "@polkadot/keyring": "^7.7.2-5"
   },
   "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-10'
+  version: '6.6.2-14'
 };
 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-10'
+  version: '6.6.2-14'
 };

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;
 };