@polkadot/rpc-core 6.6.2-6 → 6.7.1

package/bundle.cjs

@@ -17,8 +17,6 @@ Object.defineProperty(exports, "packageInfo", {
   }
 });
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
 
 var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
@@ -45,10 +43,8 @@ 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 _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; }
-
+// Copyright 2017-2021 @polkadot/rpc-core authors & contributors
+// SPDX-License-Identifier: Apache-2.0
 const l = (0, _util.logger)('rpc-core');
 const EMPTY_META = {
   fallback: undefined,
@@ -67,15 +63,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}`);
 }
 
@@ -123,7 +123,8 @@ class RpcCore {
    * Default constructor for the Api Object
    * @param  {ProviderInterface} provider An API provider using HTTP or WebSocket
    */
-  constructor(instanceId, registry, provider, userRpc = {}) {
+  constructor(instanceId, registry, provider) {
+    let userRpc = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
     Object.defineProperty(this, _instanceId, {
       writable: true,
       value: void 0
@@ -191,37 +192,35 @@ 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 _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) {
@@ -240,9 +239,12 @@ 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) => {
@@ -259,7 +261,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 +292,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 +308,24 @@ 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, _classPrivateFieldLooseBase2.default)(_this, _registryDefault)[_registryDefault];
 
         const errorHandler = error => {
           logErrorMessage(method, def, error);
@@ -320,7 +333,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 +344,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 +367,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 +377,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 +398,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,7 +437,10 @@ 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
@@ -434,7 +456,8 @@ class RpcCore {
     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,10 @@
-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";
@@ -156,37 +150,35 @@ 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.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) {

package/package.json

@@ -20,17 +20,17 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "6.6.2-6",
+  "version": "6.7.1",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.15.4",
-    "@polkadot/rpc-provider": "6.6.2-6",
-    "@polkadot/types": "6.6.2-6",
-    "@polkadot/util": "^7.7.1",
+    "@babel/runtime": "^7.16.0",
+    "@polkadot/rpc-provider": "6.7.1",
+    "@polkadot/types": "6.7.1",
+    "@polkadot/util": "^7.8.2",
     "rxjs": "^7.4.0"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^7.7.1"
+    "@polkadot/keyring": "^7.8.2"
   },
   "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-6'
+  version: '6.7.1'
 };
 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-6'
+  version: '6.7.1'
 };

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