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

package/bundle.cjs

@@ -201,44 +201,38 @@ class RpcCore {
 
   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 _ref3, _ref4;
-
-      (_ref3 = this)[_ref4 = sectionName] || (_ref3[_ref4] = {});
-      const section = this[sectionName];
-      Object.entries({ ...this._createInterface(sectionName, _types.rpcDefinitions[sectionName] || {}),
-        ...this._createInterface(sectionName, userRpc[sectionName] || {})
-      }).forEach(_ref5 => {
-        let [key, value] = _ref5;
-        section[key] || (section[key] = value);
-      });
-    });
+    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];
+
+        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, { ...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) {
@@ -257,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
@@ -310,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);
@@ -394,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)`;
@@ -415,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
 
@@ -454,8 +448,8 @@ 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

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

@@ -2,7 +2,7 @@
 // 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";
@@ -128,39 +128,38 @@ export class RpcCore {
 
   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({ ...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, { ...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) {

package/package.json

@@ -20,12 +20,12 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "6.6.2-13",
+  "version": "6.6.2-14",
   "main": "index.js",
   "dependencies": {
     "@babel/runtime": "^7.16.0",
-    "@polkadot/rpc-provider": "6.6.2-13",
-    "@polkadot/types": "6.6.2-13",
+    "@polkadot/rpc-provider": "6.6.2-14",
+    "@polkadot/types": "6.6.2-14",
     "@polkadot/util": "^7.7.2-5",
     "rxjs": "^7.4.0"
   },

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-13'
+  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-13'
+  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;
 };