web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/@polkadot/api/base/Decorate.js

@@ -0,0 +1,853 @@
+'use strict';
+
+var augmentObject = require('../util/augmentObject.js');
+var decorate = require('../util/decorate.js');
+var validate = require('../util/validate.js');
+var Events = require('./Events.js');
+var find = require('./find.js');
+var Extrinsic = require('../../types/extrinsic/Extrinsic.js');
+var registry = require('../../types/create/registry.js');
+var from = require('../../../rxjs/dist/esm5/internal/observable/from.js');
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var index = require('../../rpc-provider/ws/index.js');
+var bundle = require('../../rpc-core/bundle.js');
+var BehaviorSubject = require('../../../rxjs/dist/esm5/internal/BehaviorSubject.js');
+var createSubmittable = require('../submittable/createSubmittable.js');
+var index$1 = require('../../types/metadata/decorate/index.js');
+var lowerFirst = require('../../util/string/lowerFirst.js');
+var asU8a = require('../../util-crypto/blake2/asU8a.js');
+var util = require('../../types-known/util.js');
+var of = require('../../../rxjs/dist/esm5/internal/observable/of.js');
+var switchMap = require('../../../rxjs/dist/esm5/internal/operators/switchMap.js');
+var combineLatest = require('../../../rxjs/dist/esm5/internal/observable/combineLatest.js');
+var tap = require('../../../rxjs/dist/esm5/internal/operators/tap.js');
+var toArray = require('../../../rxjs/dist/esm5/internal/operators/toArray.js');
+var bundle$1 = require('../../api-derive/bundle.js');
+var definitions = require('../../types/interfaces/definitions.js');
+var bn = require('../../../../_virtual/bn.js');
+var logger = require('../../util/logger.js');
+var lazy = require('../../util/lazy.js');
+var spread = require('../../util/object/spread.js');
+var camelCase = require('../../util/string/camelCase.js');
+var concat = require('../../util/u8a/concat.js');
+var toHex = require('../../util/u8a/toHex.js');
+var stripLength = require('../../util/compact/stripLength.js');
+var memo = require('../../rpc-core/util/memo.js');
+var nextTick = require('../../util/nextTick.js');
+var chunk = require('../../util/array/chunk.js');
+var assert = require('../../util/assert.js');
+var flatten = require('../../util/array/flatten.js');
+
+const PAGE_SIZE_K = 1000; // limit aligned with the 1k on the node (trie lookups are heavy)
+const PAGE_SIZE_V = 250; // limited since the data may be > 16MB (e.g. misfiring elections)
+const PAGE_SIZE_Q = 50; // queue of pending storage queries (mapped together, next tick)
+const l = logger.logger('api/init');
+let instanceCounter = 0;
+function getAtQueryFn(api, _ref) {
+  let {
+    method,
+    section
+  } = _ref;
+  return assert.assertReturn(api.rx.query[section] && api.rx.query[section][method], () => `query.${section}.${method} is not available in this version of the metadata`);
+}
+class Decorate extends Events.Events {
+  __internal__instanceId;
+  __internal__runtimeLog = {};
+  __internal__registry;
+  __internal__storageGetQ = [];
+  __internal__storageSubQ = [];
+  // HACK Use BN import so decorateDerive works... yes, wtf.
+  __phantom = (() => new bn.default(0))();
+  _type;
+  _call = {};
+  _consts = {};
+  _derive;
+  _errors = {};
+  _events = {};
+  _extrinsics;
+  _extrinsicType = (() => Extrinsic.GenericExtrinsic.LATEST_EXTRINSIC_VERSION)();
+  _genesisHash;
+  _isConnected;
+  _isReady = false;
+  _query = {};
+  _queryMulti;
+  _rpc;
+  _rpcCore;
+  _runtimeMap = {};
+  _runtimeChain;
+  _runtimeMetadata;
+  _runtimeVersion;
+  _rx = {
+    call: {},
+    consts: {},
+    query: {},
+    tx: {}
+  };
+  _options;
+  /**
+   * This is the one and only method concrete children classes need to implement.
+   * It's a higher-order function, which takes one argument
+   * `method: Method extends (...args: any[]) => Observable<any>`
+   * (and one optional `options`), and should return the user facing method.
+   * For example:
+   * - For ApiRx, `decorateMethod` should just be identity, because the input
+   * function is already an Observable
+   * - For ApiPromise, `decorateMethod` should return a function that takes all
+   * the parameters from `method`, adds an optional `callback` argument, and
+   * returns a Promise.
+   *
+   * We could easily imagine other user-facing interfaces, which are simply
+   * implemented by transforming the Observable to Stream/Iterator/Kefir/Bacon
+   * via `decorateMethod`.
+   */
+  _decorateMethod;
+  /**
+   * @description Create an instance of the class
+   *
+   * @param options Options object to create API instance or a Provider instance
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * import Api from '@polkadot/api/promise';
+   *
+   * const api = new Api().isReady();
+   *
+   * api.rpc.subscribeNewHeads((header) => {
+   *   console.log(`new block #${header.number.toNumber()}`);
+   * });
+   * ```
+   */
+  constructor(options, type, decorateMethod) {
+    super();
+    this.__internal__instanceId = `${++instanceCounter}`;
+    this.__internal__registry = options.source?.registry || options.registry || new registry.TypeRegistry();
+    this._rx.callAt = (blockHash, knownVersion) => from.from(this.at(blockHash, knownVersion)).pipe(map.map(a => a.rx.call));
+    this._rx.queryAt = (blockHash, knownVersion) => from.from(this.at(blockHash, knownVersion)).pipe(map.map(a => a.rx.query));
+    this._rx.registry = this.__internal__registry;
+    this._decorateMethod = decorateMethod;
+    this._options = options;
+    this._type = type;
+    const provider = options.source ? options.source._rpcCore.provider.isClonable ? options.source._rpcCore.provider.clone() : options.source._rpcCore.provider : options.provider || new index.WsProvider();
+    // The RPC interface decorates the known interfaces on init
+    this._rpcCore = new bundle.RpcCore(this.__internal__instanceId, this.__internal__registry, {
+      isPedantic: this._options.isPedantic,
+      provider,
+      userRpc: this._options.rpc
+    });
+    this._isConnected = new BehaviorSubject.BehaviorSubject(this._rpcCore.provider.isConnected);
+    this._rx.hasSubscriptions = this._rpcCore.provider.hasSubscriptions;
+  }
+  /**
+   * @description Return the current used registry
+   */
+  get registry() {
+    return this.__internal__registry;
+  }
+  /**
+   * @description Creates an instance of a type as registered
+   */
+  createType(type) {
+    for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      params[_key - 1] = arguments[_key];
+    }
+    return this.__internal__registry.createType(type, ...params);
+  }
+  /**
+   * @description Register additional user-defined of chain-specific types in the type registry
+   */
+  registerTypes(types) {
+    types && this.__internal__registry.register(types);
+  }
+  /**
+   * @returns `true` if the API operates with subscriptions
+   */
+  get hasSubscriptions() {
+    return this._rpcCore.provider.hasSubscriptions;
+  }
+  /**
+   * @returns `true` if the API decorate multi-key queries
+   */
+  get supportMulti() {
+    return this._rpcCore.provider.hasSubscriptions || !!this._rpcCore.state.queryStorageAt;
+  }
+  _emptyDecorated(registry, blockHash) {
+    return {
+      call: {},
+      consts: {},
+      errors: {},
+      events: {},
+      query: {},
+      registry,
+      rx: {
+        call: {},
+        query: {}
+      },
+      tx: createSubmittable.createSubmittable(this._type, this._rx, this._decorateMethod, registry, blockHash)
+    };
+  }
+  _createDecorated(registry, fromEmpty, decoratedApi, blockHash) {
+    if (!decoratedApi) {
+      decoratedApi = this._emptyDecorated(registry.registry, blockHash);
+    }
+    if (fromEmpty || !registry.decoratedMeta) {
+      registry.decoratedMeta = index$1.expandMetadata(registry.registry, registry.metadata);
+    }
+    const runtime = this._decorateCalls(registry, this._decorateMethod, blockHash);
+    const runtimeRx = this._decorateCalls(registry, this._rxDecorateMethod, blockHash);
+    const storage = this._decorateStorage(registry.decoratedMeta, this._decorateMethod, blockHash);
+    const storageRx = this._decorateStorage(registry.decoratedMeta, this._rxDecorateMethod, blockHash);
+    augmentObject.augmentObject('consts', registry.decoratedMeta.consts, decoratedApi.consts, fromEmpty);
+    augmentObject.augmentObject('errors', registry.decoratedMeta.errors, decoratedApi.errors, fromEmpty);
+    augmentObject.augmentObject('events', registry.decoratedMeta.events, decoratedApi.events, fromEmpty);
+    augmentObject.augmentObject('query', storage, decoratedApi.query, fromEmpty);
+    augmentObject.augmentObject('query', storageRx, decoratedApi.rx.query, fromEmpty);
+    augmentObject.augmentObject('call', runtime, decoratedApi.call, fromEmpty);
+    augmentObject.augmentObject('call', runtimeRx, decoratedApi.rx.call, fromEmpty);
+    decoratedApi.findCall = callIndex => find.findCall(registry.registry, callIndex);
+    decoratedApi.findError = errorIndex => find.findError(registry.registry, errorIndex);
+    decoratedApi.queryMulti = blockHash ? this._decorateMultiAt(decoratedApi, this._decorateMethod, blockHash) : this._decorateMulti(this._decorateMethod);
+    decoratedApi.runtimeVersion = registry.runtimeVersion;
+    return {
+      createdAt: blockHash,
+      decoratedApi,
+      decoratedMeta: registry.decoratedMeta
+    };
+  }
+  _injectMetadata(registry) {
+    let fromEmpty = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    // clear the decoration, we are redoing it here
+    if (fromEmpty || !registry.decoratedApi) {
+      registry.decoratedApi = this._emptyDecorated(registry.registry);
+    }
+    const {
+      decoratedApi,
+      decoratedMeta
+    } = this._createDecorated(registry, fromEmpty, registry.decoratedApi);
+    this._call = decoratedApi.call;
+    this._consts = decoratedApi.consts;
+    this._errors = decoratedApi.errors;
+    this._events = decoratedApi.events;
+    this._query = decoratedApi.query;
+    this._rx.call = decoratedApi.rx.call;
+    this._rx.query = decoratedApi.rx.query;
+    const tx = this._decorateExtrinsics(decoratedMeta, this._decorateMethod);
+    const rxtx = this._decorateExtrinsics(decoratedMeta, this._rxDecorateMethod);
+    if (fromEmpty || !this._extrinsics) {
+      this._extrinsics = tx;
+      this._rx.tx = rxtx;
+    } else {
+      augmentObject.augmentObject('tx', tx, this._extrinsics, false);
+      augmentObject.augmentObject(null, rxtx, this._rx.tx, false);
+    }
+    augmentObject.augmentObject(null, decoratedMeta.consts, this._rx.consts, fromEmpty);
+    this.emit('decorated');
+  }
+  /**
+   * @deprecated
+   * backwards compatible endpoint for metadata injection, may be removed in the future (However, it is still useful for testing injection)
+   */
+  injectMetadata(metadata, fromEmpty, registry) {
+    this._injectMetadata({
+      counter: 0,
+      metadata,
+      registry: registry || this.__internal__registry,
+      runtimeVersion: this.__internal__registry.createType('RuntimeVersionPartial')
+    }, fromEmpty);
+  }
+  _decorateFunctionMeta(input, output) {
+    output.meta = input.meta;
+    output.method = input.method;
+    output.section = input.section;
+    output.toJSON = input.toJSON;
+    if (input.callIndex) {
+      output.callIndex = input.callIndex;
+    }
+    return output;
+  }
+  // Filter all RPC methods based on the results of the rpc_methods call. We do this in the following
+  // manner to cater for both old and new:
+  //   - when the number of entries are 0, only remove the ones with isOptional (account & contracts)
+  //   - when non-zero, remove anything that is not in the array (we don't do this)
+  _filterRpc(methods, additional) {
+    // add any specific user-base RPCs
+    if (Object.keys(additional).length !== 0) {
+      this._rpcCore.addUserInterfaces(additional);
+      // re-decorate, only adding any new additional interfaces
+      this._decorateRpc(this._rpcCore, this._decorateMethod, this._rpc);
+      this._decorateRpc(this._rpcCore, this._rxDecorateMethod, this._rx.rpc);
+    }
+    // extract the actual sections from the methods (this is useful when
+    // we try and create mappings to runtime names via a hash mapping)
+    const sectionMap = {};
+    for (let i = 0, count = methods.length; i < count; i++) {
+      const [section] = methods[i].split('_');
+      sectionMap[section] = true;
+    }
+    // convert the actual section names into an easy name lookup
+    const sections = Object.keys(sectionMap);
+    for (let i = 0, count = sections.length; i < count; i++) {
+      const nameA = lowerFirst.stringUpperFirst(sections[i]);
+      const nameB = `${nameA}Api`;
+      this._runtimeMap[asU8a.blake2AsHex(nameA, 64)] = nameA;
+      this._runtimeMap[asU8a.blake2AsHex(nameB, 64)] = nameB;
+    }
+    // finally we filter the actual methods to expose
+    this._filterRpcMethods(methods);
+  }
+  _filterRpcMethods(exposed) {
+    const hasResults = exposed.length !== 0;
+    const allKnown = [...this._rpcCore.mapping.entries()];
+    const allKeys = [];
+    const count = allKnown.length;
+    for (let i = 0; i < count; i++) {
+      const [, {
+        alias,
+        endpoint,
+        method,
+        pubsub,
+        section
+      }] = allKnown[i];
+      allKeys.push(`${section}_${method}`);
+      if (pubsub) {
+        allKeys.push(`${section}_${pubsub[1]}`);
+        allKeys.push(`${section}_${pubsub[2]}`);
+      }
+      if (alias) {
+        allKeys.push(...alias);
+      }
+      if (endpoint) {
+        allKeys.push(endpoint);
+      }
+    }
+    const unknown = exposed.filter(k => !allKeys.includes(k) && !k.includes('_unstable_'));
+    if (unknown.length && !this._options.noInitWarn) {
+      l.warn(`RPC methods not decorated: ${unknown.join(', ')}`);
+    }
+    // loop through all entries we have (populated in decorate) and filter as required
+    // only remove when we have results and method missing, or with no results if optional
+    for (let i = 0; i < count; i++) {
+      const [k, {
+        method,
+        section
+      }] = allKnown[i];
+      if (hasResults && !exposed.includes(k) && k !== 'rpc_methods') {
+        if (this._rpc[section]) {
+          delete this._rpc[section][method];
+          delete this._rx.rpc[section][method];
+        }
+      }
+    }
+  }
+  _rpcSubmitter(decorateMethod) {
+    var _this = this;
+    const method = function (method) {
+      for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        params[_key2 - 1] = arguments[_key2];
+      }
+      return from.from(_this._rpcCore.provider.send(method, params));
+    };
+    return decorateMethod(method);
+  }
+  _decorateRpc(rpc, decorateMethod) {
+    let input = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this._rpcSubmitter(decorateMethod);
+    const out = input;
+    const decorateFn = (section, method) => {
+      const source = rpc[section][method];
+      const fn = decorateMethod(source, {
+        methodName: method
+      });
+      fn.meta = source.meta;
+      fn.raw = decorateMethod(source.raw, {
+        methodName: method
+      });
+      return fn;
+    };
+    for (let s = 0, scount = rpc.sections.length; s < scount; s++) {
+      const section = rpc.sections[s];
+      if (!Object.prototype.hasOwnProperty.call(out, section)) {
+        const methods = Object.keys(rpc[section]);
+        const decorateInternal = method => decorateFn(section, method);
+        for (let m = 0, mcount = methods.length; m < mcount; m++) {
+          const method = methods[m];
+          //  skip subscriptions where we have a non-subscribe interface
+          if (this.hasSubscriptions || !(method.startsWith('subscribe') || method.startsWith('unsubscribe'))) {
+            if (!Object.prototype.hasOwnProperty.call(out, section)) {
+              out[section] = {};
+            }
+            lazy.lazyMethod(out[section], method, decorateInternal);
+          }
+        }
+      }
+    }
+    return out;
+  }
+  // add all definition entries
+  _addRuntimeDef(result, additional) {
+    if (!additional) {
+      return;
+    }
+    const entries = Object.entries(additional);
+    for (let j = 0, ecount = entries.length; j < ecount; j++) {
+      const [key, defs] = entries[j];
+      if (result[key]) {
+        // we have this one already, step through for new versions or
+        // new methods and add those as applicable
+        for (let k = 0, dcount = defs.length; k < dcount; k++) {
+          const def = defs[k];
+          const prev = result[key].find(_ref2 => {
+            let {
+              version
+            } = _ref2;
+            return def.version === version;
+          });
+          if (prev) {
+            // interleave the new methods with the old - last definition wins
+            spread.objectSpread(prev.methods, def.methods);
+          } else {
+            // we don't have this specific version, add it
+            result[key].push(def);
+          }
+        }
+      } else {
+        // we don't have this runtime definition, add it as-is
+        result[key] = defs;
+      }
+    }
+  }
+  // extract all runtime definitions
+  _getRuntimeDefs(registry, specName) {
+    let chain = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    const result = {};
+    const defValues = Object.values(definitions);
+    // options > chain/spec > built-in, apply in reverse order with
+    // methods overriding previous definitions (or interleave missing)
+    for (let i = 0, count = defValues.length; i < count; i++) {
+      this._addRuntimeDef(result, defValues[i].runtime);
+    }
+    this._addRuntimeDef(result, util.getSpecRuntime(registry, chain, specName));
+    this._addRuntimeDef(result, this._options.runtime);
+    return Object.entries(result);
+  }
+  // pre-metadata decoration
+  _decorateCalls(_ref3, decorateMethod, blockHash) {
+    let {
+      registry,
+      runtimeVersion: {
+        apis,
+        specName,
+        specVersion
+      }
+    } = _ref3;
+    const result = {};
+    const named = {};
+    const hashes = {};
+    const sections = this._getRuntimeDefs(registry, specName, this._runtimeChain);
+    const older = [];
+    const implName = `${specName.toString()}/${specVersion.toString()}`;
+    const hasLogged = this.__internal__runtimeLog[implName] || false;
+    this.__internal__runtimeLog[implName] = true;
+    for (let i = 0, scount = sections.length; i < scount; i++) {
+      const [_section, secs] = sections[i];
+      const sectionHash = asU8a.blake2AsHex(_section, 64);
+      const rtApi = apis.find(_ref4 => {
+        let [a] = _ref4;
+        return a.eq(sectionHash);
+      });
+      hashes[sectionHash] = true;
+      if (rtApi) {
+        const all = secs.map(_ref5 => {
+          let {
+            version
+          } = _ref5;
+          return version;
+        }).sort();
+        const sec = secs.find(_ref6 => {
+          let {
+            version
+          } = _ref6;
+          return rtApi[1].eq(version);
+        });
+        if (sec) {
+          const section = camelCase.stringCamelCase(_section);
+          const methods = Object.entries(sec.methods);
+          if (methods.length) {
+            if (!named[section]) {
+              named[section] = {};
+            }
+            for (let m = 0, mcount = methods.length; m < mcount; m++) {
+              const [_method, def] = methods[m];
+              const method = camelCase.stringCamelCase(_method);
+              named[section][method] = spread.objectSpread({
+                method,
+                name: `${_section}_${_method}`,
+                section,
+                sectionHash
+              }, def);
+            }
+          }
+        } else {
+          older.push(`${_section}/${rtApi[1].toString()} (${all.join('/')} known)`);
+        }
+      }
+    }
+    // find the runtimes that we don't have hashes for
+    const notFound = apis.map(_ref7 => {
+      let [a, v] = _ref7;
+      return [a.toHex(), v.toString()];
+    }).filter(_ref8 => {
+      let [a] = _ref8;
+      return !hashes[a];
+    }).map(_ref9 => {
+      let [a, v] = _ref9;
+      return `${this._runtimeMap[a] || a}/${v}`;
+    });
+    if (!this._options.noInitWarn && !hasLogged) {
+      if (older.length) {
+        l.warn(`${implName}: Not decorating runtime apis without matching versions: ${older.join(', ')}`);
+      }
+      if (notFound.length) {
+        l.warn(`${implName}: Not decorating unknown runtime apis: ${notFound.join(', ')}`);
+      }
+    }
+    const stateCall = blockHash ? (name, bytes) => this._rpcCore.state.call(name, bytes, blockHash) : (name, bytes) => this._rpcCore.state.call(name, bytes);
+    const lazySection = section => lazy.lazyMethods({}, Object.keys(named[section]), method => this._decorateCall(registry, named[section][method], stateCall, decorateMethod));
+    const modules = Object.keys(named);
+    for (let i = 0, count = modules.length; i < count; i++) {
+      lazy.lazyMethod(result, modules[i], lazySection);
+    }
+    return result;
+  }
+  _decorateCall(registry, def, stateCall, decorateMethod) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const decorated = decorateMethod(function () {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      if (args.length !== def.params.length) {
+        throw new Error(`${def.name}:: Expected ${def.params.length} arguments, found ${args.length}`);
+      }
+      const bytes = registry.createType('Raw', concat.u8aConcatStrict(args.map((a, i) => registry.createTypeUnsafe(def.params[i].type, [a]).toU8a())));
+      return stateCall(def.name, bytes).pipe(map.map(r => registry.createTypeUnsafe(def.type, [r])));
+    });
+    decorated.meta = def;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return decorated;
+  }
+  // only be called if supportMulti is true
+  _decorateMulti(decorateMethod) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return decorateMethod(keys => keys.length ? (this.hasSubscriptions ? this._rpcCore.state.subscribeStorage : this._rpcCore.state.queryStorageAt)(keys.map(args => Array.isArray(args) ? args[0].creator.meta.type.isPlain ? [args[0].creator] : args[0].creator.meta.type.asMap.hashers.length === 1 ? [args[0].creator, args.slice(1)] : [args[0].creator, ...args.slice(1)] : [args.creator])) : of.of([]));
+  }
+  _decorateMultiAt(atApi, decorateMethod, blockHash) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return decorateMethod(calls => calls.length ? this._rpcCore.state.queryStorageAt(calls.map(args => {
+      if (Array.isArray(args)) {
+        const {
+          creator
+        } = getAtQueryFn(atApi, args[0].creator);
+        return creator.meta.type.isPlain ? [creator] : creator.meta.type.asMap.hashers.length === 1 ? [creator, args.slice(1)] : [creator, ...args.slice(1)];
+      }
+      return [getAtQueryFn(atApi, args.creator).creator];
+    }), blockHash) : of.of([]));
+  }
+  _decorateExtrinsics(_ref0, decorateMethod) {
+    let {
+      tx
+    } = _ref0;
+    const result = createSubmittable.createSubmittable(this._type, this._rx, decorateMethod);
+    const lazySection = section => lazy.lazyMethods({}, Object.keys(tx[section]), method => method.startsWith('$') ? tx[section][method] : this._decorateExtrinsicEntry(tx[section][method], result));
+    const sections = Object.keys(tx);
+    for (let i = 0, count = sections.length; i < count; i++) {
+      lazy.lazyMethod(result, sections[i], lazySection);
+    }
+    return result;
+  }
+  _decorateExtrinsicEntry(method, creator) {
+    const decorated = function () {
+      return creator(method(...arguments));
+    };
+    // pass through the `.is`
+    decorated.is = other => method.is(other);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return this._decorateFunctionMeta(method, decorated);
+  }
+  _decorateStorage(_ref1, decorateMethod, blockHash) {
+    let {
+      query,
+      registry
+    } = _ref1;
+    const result = {};
+    const lazySection = section => lazy.lazyMethods({}, Object.keys(query[section]), method => blockHash ? this._decorateStorageEntryAt(registry, query[section][method], decorateMethod, blockHash) : this._decorateStorageEntry(query[section][method], decorateMethod));
+    const sections = Object.keys(query);
+    for (let i = 0, count = sections.length; i < count; i++) {
+      lazy.lazyMethod(result, sections[i], lazySection);
+    }
+    return result;
+  }
+  _decorateStorageEntry(creator, decorateMethod) {
+    var _this2 = this;
+    const getArgs = (args, registry) => validate.extractStorageArgs(registry || this.__internal__registry, creator, args);
+    const getQueryAt = blockHash => from.from(this.at(blockHash)).pipe(map.map(api => getAtQueryFn(api, creator)));
+    // Disable this where it occurs for each field we are decorating
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment */
+    const decorated = this._decorateStorageCall(creator, decorateMethod);
+    decorated.creator = creator;
+    // eslint-disable-next-line deprecation/deprecation
+    decorated.at = decorateMethod(function (blockHash) {
+      for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+        args[_key4 - 1] = arguments[_key4];
+      }
+      return getQueryAt(blockHash).pipe(switchMap.switchMap(q => q(...args)));
+    });
+    decorated.hash = decorateMethod(function () {
+      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+        args[_key5] = arguments[_key5];
+      }
+      return _this2._rpcCore.state.getStorageHash(getArgs(args));
+    });
+    decorated.is = key => key.section === creator.section && key.method === creator.method;
+    decorated.key = function () {
+      return toHex.u8aToHex(stripLength.compactStripLength(creator(...arguments))[1]);
+    };
+    decorated.keyPrefix = function () {
+      return toHex.u8aToHex(creator.keyPrefix(...arguments));
+    };
+    decorated.size = decorateMethod(function () {
+      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+        args[_key6] = arguments[_key6];
+      }
+      return _this2._rpcCore.state.getStorageSize(getArgs(args));
+    });
+    // eslint-disable-next-line deprecation/deprecation
+    decorated.sizeAt = decorateMethod(function (blockHash) {
+      for (var _len7 = arguments.length, args = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
+        args[_key7 - 1] = arguments[_key7];
+      }
+      return getQueryAt(blockHash).pipe(switchMap.switchMap(q => _this2._rpcCore.state.getStorageSize(getArgs(args, q.creator.meta.registry), blockHash)));
+    });
+    // .keys() & .entries() only available on map types
+    if (creator.iterKey && creator.meta.type.isMap) {
+      decorated.entries = decorateMethod(memo.memo(this.__internal__instanceId, function () {
+        for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+          args[_key8] = arguments[_key8];
+        }
+        return _this2._retrieveMapEntries(creator, null, args);
+      }));
+      // eslint-disable-next-line deprecation/deprecation
+      decorated.entriesAt = decorateMethod(memo.memo(this.__internal__instanceId, function (blockHash) {
+        for (var _len9 = arguments.length, args = new Array(_len9 > 1 ? _len9 - 1 : 0), _key9 = 1; _key9 < _len9; _key9++) {
+          args[_key9 - 1] = arguments[_key9];
+        }
+        return getQueryAt(blockHash).pipe(switchMap.switchMap(q => _this2._retrieveMapEntries(q.creator, blockHash, args)));
+      }));
+      decorated.entriesPaged = decorateMethod(memo.memo(this.__internal__instanceId, opts => this._retrieveMapEntriesPaged(creator, undefined, opts)));
+      decorated.keys = decorateMethod(memo.memo(this.__internal__instanceId, function () {
+        for (var _len0 = arguments.length, args = new Array(_len0), _key0 = 0; _key0 < _len0; _key0++) {
+          args[_key0] = arguments[_key0];
+        }
+        return _this2._retrieveMapKeys(creator, null, args);
+      }));
+      // eslint-disable-next-line deprecation/deprecation
+      decorated.keysAt = decorateMethod(memo.memo(this.__internal__instanceId, function (blockHash) {
+        for (var _len1 = arguments.length, args = new Array(_len1 > 1 ? _len1 - 1 : 0), _key1 = 1; _key1 < _len1; _key1++) {
+          args[_key1 - 1] = arguments[_key1];
+        }
+        return getQueryAt(blockHash).pipe(switchMap.switchMap(q => _this2._retrieveMapKeys(q.creator, blockHash, args)));
+      }));
+      decorated.keysPaged = decorateMethod(memo.memo(this.__internal__instanceId, opts => this._retrieveMapKeysPaged(creator, undefined, opts)));
+    }
+    if (this.supportMulti && creator.meta.type.isMap) {
+      // When using double map storage function, user need to pass double map key as an array
+      decorated.multi = decorateMethod(args => creator.meta.type.asMap.hashers.length === 1 ? this._retrieveMulti(args.map(a => [creator, [a]])) : this._retrieveMulti(args.map(a => [creator, a])));
+    }
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment */
+    return this._decorateFunctionMeta(creator, decorated);
+  }
+  _decorateStorageEntryAt(registry, creator, decorateMethod, blockHash) {
+    var _this3 = this;
+    const getArgs = args => validate.extractStorageArgs(registry, creator, args);
+    // Disable this where it occurs for each field we are decorating
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment */
+    const decorated = decorateMethod(function () {
+      for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
+        args[_key10] = arguments[_key10];
+      }
+      return _this3._rpcCore.state.getStorage(getArgs(args), blockHash);
+    });
+    decorated.creator = creator;
+    decorated.hash = decorateMethod(function () {
+      for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
+        args[_key11] = arguments[_key11];
+      }
+      return _this3._rpcCore.state.getStorageHash(getArgs(args), blockHash);
+    });
+    decorated.is = key => key.section === creator.section && key.method === creator.method;
+    decorated.key = function () {
+      return toHex.u8aToHex(stripLength.compactStripLength(creator(...arguments))[1]);
+    };
+    decorated.keyPrefix = function () {
+      return toHex.u8aToHex(creator.keyPrefix(...arguments));
+    };
+    decorated.size = decorateMethod(function () {
+      for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
+        args[_key12] = arguments[_key12];
+      }
+      return _this3._rpcCore.state.getStorageSize(getArgs(args), blockHash);
+    });
+    // .keys() & .entries() only available on map types
+    if (creator.iterKey && creator.meta.type.isMap) {
+      decorated.entries = decorateMethod(memo.memo(this.__internal__instanceId, function () {
+        for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
+          args[_key13] = arguments[_key13];
+        }
+        return _this3._retrieveMapEntries(creator, blockHash, args);
+      }));
+      decorated.entriesPaged = decorateMethod(memo.memo(this.__internal__instanceId, opts => this._retrieveMapEntriesPaged(creator, blockHash, opts)));
+      decorated.keys = decorateMethod(memo.memo(this.__internal__instanceId, function () {
+        for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
+          args[_key14] = arguments[_key14];
+        }
+        return _this3._retrieveMapKeys(creator, blockHash, args);
+      }));
+      decorated.keysPaged = decorateMethod(memo.memo(this.__internal__instanceId, opts => this._retrieveMapKeysPaged(creator, blockHash, opts)));
+    }
+    if (this.supportMulti && creator.meta.type.isMap) {
+      // When using double map storage function, user need to pass double map key as an array
+      decorated.multi = decorateMethod(args => creator.meta.type.asMap.hashers.length === 1 ? this._retrieveMulti(args.map(a => [creator, [a]]), blockHash) : this._retrieveMulti(args.map(a => [creator, a]), blockHash));
+    }
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment */
+    return this._decorateFunctionMeta(creator, decorated);
+  }
+  _queueStorage(call, queue) {
+    const query = queue === this.__internal__storageSubQ ? this._rpcCore.state.subscribeStorage : this._rpcCore.state.queryStorageAt;
+    let queueIdx = queue.length - 1;
+    let valueIdx = 0;
+    let valueObs;
+    // if we don't have queue entries yet,
+    // or the current queue has fired (see from below),
+    // or the current queue has the max entries,
+    // then we create a new queue
+    if (queueIdx === -1 || !queue[queueIdx] || queue[queueIdx][1].length === PAGE_SIZE_Q) {
+      queueIdx++;
+      valueObs = from.from(
+      // we delay the execution until the next tick, this allows
+      // any queries made in this timeframe to be added to the same
+      // queue for a single query
+      new Promise(resolve => {
+        nextTick.nextTick(() => {
+          // get all the calls in this instance, resolve with it
+          // and then clear the queue so we don't add more
+          // (anything after this will be added to a new queue)
+          const calls = queue[queueIdx][1];
+          delete queue[queueIdx];
+          resolve(calls);
+        });
+      })).pipe(switchMap.switchMap(calls => query(calls)));
+      queue.push([valueObs, [call]]);
+    } else {
+      valueObs = queue[queueIdx][0];
+      valueIdx = queue[queueIdx][1].length;
+      queue[queueIdx][1].push(call);
+    }
+    return valueObs.pipe(
+    // return the single value at this index
+    map.map(values => values[valueIdx]));
+  }
+  // Decorate the base storage call. In the case or rxjs or promise-without-callback (await)
+  // we make a subscription, alternatively we push this through a single-shot query
+  _decorateStorageCall(creator, decorateMethod) {
+    var _this4 = this;
+    const memoed = memo.memo(this.__internal__instanceId, function () {
+      for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
+        args[_key15] = arguments[_key15];
+      }
+      const call = validate.extractStorageArgs(_this4.__internal__registry, creator, args);
+      if (!_this4.hasSubscriptions) {
+        return _this4._rpcCore.state.getStorage(call);
+      }
+      return _this4._queueStorage(call, _this4.__internal__storageSubQ);
+    });
+    return decorateMethod(memoed, {
+      methodName: creator.method,
+      overrideNoSub: function () {
+        for (var _len16 = arguments.length, args = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {
+          args[_key16] = arguments[_key16];
+        }
+        return _this4._queueStorage(validate.extractStorageArgs(_this4.__internal__registry, creator, args), _this4.__internal__storageGetQ);
+      }
+    });
+  }
+  // retrieve a set of values for a specific set of keys - here we chunk the keys into PAGE_SIZE sizes
+  _retrieveMulti(keys, blockHash) {
+    if (!keys.length) {
+      return of.of([]);
+    }
+    const query = this.hasSubscriptions && !blockHash ? this._rpcCore.state.subscribeStorage : this._rpcCore.state.queryStorageAt;
+    if (keys.length <= PAGE_SIZE_V) {
+      return blockHash ? query(keys, blockHash) : query(keys);
+    }
+    return combineLatest.combineLatest(chunk.arrayChunk(keys, PAGE_SIZE_V).map(k => blockHash ? query(k, blockHash) : query(k))).pipe(map.map(flatten.arrayFlatten));
+  }
+  _retrieveMapKeys(_ref10, at, args) {
+    let {
+      iterKey,
+      meta,
+      method,
+      section
+    } = _ref10;
+    if (!iterKey || !meta.type.isMap) {
+      throw new Error('keys can only be retrieved on maps');
+    }
+    const headKey = iterKey(...args).toHex();
+    const startSubject = new BehaviorSubject.BehaviorSubject(headKey);
+    const query = at ? startKey => this._rpcCore.state.getKeysPaged(headKey, PAGE_SIZE_K, startKey, at) : startKey => this._rpcCore.state.getKeysPaged(headKey, PAGE_SIZE_K, startKey);
+    const setMeta = key => key.setMeta(meta, section, method);
+    return startSubject.pipe(switchMap.switchMap(query), map.map(keys => keys.map(setMeta)), tap.tap(keys => nextTick.nextTick(() => {
+      keys.length === PAGE_SIZE_K ? startSubject.next(keys[PAGE_SIZE_K - 1].toHex()) : startSubject.complete();
+    })), toArray.toArray(),
+    // toArray since we want to startSubject to be completed
+    map.map(flatten.arrayFlatten));
+  }
+  _retrieveMapKeysPaged(_ref11, at, opts) {
+    let {
+      iterKey,
+      meta,
+      method,
+      section
+    } = _ref11;
+    if (!iterKey || !meta.type.isMap) {
+      throw new Error('keys can only be retrieved on maps');
+    }
+    const setMeta = key => key.setMeta(meta, section, method);
+    const query = at ? headKey => this._rpcCore.state.getKeysPaged(headKey, opts.pageSize, opts.startKey || headKey, at) : headKey => this._rpcCore.state.getKeysPaged(headKey, opts.pageSize, opts.startKey || headKey);
+    return query(iterKey(...opts.args).toHex()).pipe(map.map(keys => keys.map(setMeta)));
+  }
+  _retrieveMapEntries(entry, at, args) {
+    const query = at ? keys => this._rpcCore.state.queryStorageAt(keys, at) : keys => this._rpcCore.state.queryStorageAt(keys);
+    return this._retrieveMapKeys(entry, at, args).pipe(switchMap.switchMap(keys => keys.length ? combineLatest.combineLatest(chunk.arrayChunk(keys, PAGE_SIZE_V).map(query)).pipe(map.map(valsArr => flatten.arrayFlatten(valsArr).map((value, index) => [keys[index], value]))) : of.of([])));
+  }
+  _retrieveMapEntriesPaged(entry, at, opts) {
+    const query = at ? keys => this._rpcCore.state.queryStorageAt(keys, at) : keys => this._rpcCore.state.queryStorageAt(keys);
+    return this._retrieveMapKeysPaged(entry, at, opts).pipe(switchMap.switchMap(keys => keys.length ? query(keys).pipe(map.map(valsArr => valsArr.map((value, index) => [keys[index], value]))) : of.of([])));
+  }
+  _decorateDeriveRx(decorateMethod) {
+    const specName = this._runtimeVersion?.specName.toString();
+    // Pull in derive from api-derive
+    const available = bundle$1.getAvailableDerives(this.__internal__instanceId, this._rx, spread.objectSpread({}, this._options.derives, this._options.typesBundle?.spec?.[specName || '']?.derives));
+    return decorate.decorateDeriveSections(decorateMethod, available);
+  }
+  _decorateDerive(decorateMethod) {
+    return decorate.decorateDeriveSections(decorateMethod, this._rx.derive);
+  }
+  /**
+   * Put the `this.onCall` function of ApiRx here, because it is needed by
+   * `api._rx`.
+   */
+  _rxDecorateMethod = method => {
+    return method;
+  };
+}
+
+exports.Decorate = Decorate;