web-dc-api 0.0.60 → 0.0.62

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

@@ -0,0 +1,86 @@
+'use strict';
+
+var index = require('../../../../_virtual/index6.js');
+
+class Events {
+  __internal__eventemitter = (() => new index.default())();
+  emit(type) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    return this.__internal__eventemitter.emit(type, ...args);
+  }
+  /**
+   * @description Attach an eventemitter handler to listen to a specific event
+   *
+   * @param type The type of event to listen to. Available events are `connected`, `disconnected`, `ready` and `error`
+   * @param handler The callback to be called when the event fires. Depending on the event type, it could fire with additional arguments.
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * api.on('connected', (): void => {
+   *   console.log('API has been connected to the endpoint');
+   * });
+   *
+   * api.on('disconnected', (): void => {
+   *   console.log('API has been disconnected from the endpoint');
+   * });
+   * ```
+   */
+  on(type, handler) {
+    this.__internal__eventemitter.on(type, handler);
+    return this;
+  }
+  /**
+   * @description Remove the given eventemitter handler
+   *
+   * @param type The type of event the callback was attached to. Available events are `connected`, `disconnected`, `ready` and `error`
+   * @param handler The callback to unregister.
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * const handler = (): void => {
+   *  console.log('Connected !);
+   * };
+   *
+   * // Start listening
+   * api.on('connected', handler);
+   *
+   * // Stop listening
+   * api.off('connected', handler);
+   * ```
+   */
+  off(type, handler) {
+    this.__internal__eventemitter.removeListener(type, handler);
+    return this;
+  }
+  /**
+   * @description Attach an one-time eventemitter handler to listen to a specific event
+   *
+   * @param type The type of event to listen to. Available events are `connected`, `disconnected`, `ready` and `error`
+   * @param handler The callback to be called when the event fires. Depending on the event type, it could fire with additional arguments.
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * api.once('connected', (): void => {
+   *   console.log('API has been connected to the endpoint');
+   * });
+   *
+   * api.once('disconnected', (): void => {
+   *   console.log('API has been disconnected from the endpoint');
+   * });
+   * ```
+   */
+  once(type, handler) {
+    this.__internal__eventemitter.once(type, handler);
+    return this;
+  }
+}
+
+exports.Events = Events;

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

@@ -0,0 +1,212 @@
+'use strict';
+
+var packageInfo = require('../packageInfo.js');
+var find = require('./find.js');
+var Init = require('./Init.js');
+
+function assertResult(value) {
+  if (value === undefined) {
+    throw new Error("Api interfaces needs to be initialized before using, wait for 'isReady'");
+  }
+  return value;
+}
+class Getters extends Init.Init {
+  /**
+   * @description Runtime call interfaces (currently untyped, only decorated via API options)
+   */
+  get call() {
+    return assertResult(this._call);
+  }
+  /**
+   * @description Contains the parameter types (constants) of all modules.
+   *
+   * The values are instances of the appropriate type and are accessible using `section`.`constantName`,
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * console.log(api.consts.democracy.enactmentPeriod.toString())
+   * ```
+   */
+  get consts() {
+    return assertResult(this._consts);
+  }
+  /**
+   * @description Derived results that are injected into the API, allowing for combinations of various query results.
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * api.derive.chain.bestNumber((number) => {
+   *   console.log('best number', number);
+   * });
+   * ```
+   */
+  get derive() {
+    return assertResult(this._derive);
+  }
+  /**
+   * @description Errors from metadata
+   */
+  get errors() {
+    return assertResult(this._errors);
+  }
+  /**
+   * @description Events from metadata
+   */
+  get events() {
+    return assertResult(this._events);
+  }
+  /**
+   * @description  Returns the version of extrinsics in-use on this chain
+   */
+  get extrinsicVersion() {
+    return this._extrinsicType;
+  }
+  /**
+   * @description Contains the genesis Hash of the attached chain. Apart from being useful to determine the actual chain, it can also be used to sign immortal transactions.
+   */
+  get genesisHash() {
+    return assertResult(this._genesisHash);
+  }
+  /**
+   * @description true is the underlying provider is connected
+   */
+  get isConnected() {
+    return this._isConnected.getValue();
+  }
+  /**
+   * @description The library information name & version (from package.json)
+   */
+  get libraryInfo() {
+    return `${packageInfo.packageInfo.name} v${packageInfo.packageInfo.version}`;
+  }
+  /**
+   * @description Contains all the chain state modules and their subsequent methods in the API. These are attached dynamically from the runtime metadata.
+   *
+   * All calls inside the namespace, is denoted by `section`.`method` and may take an optional query parameter. As an example, `api.query.timestamp.now()` (current block timestamp) does not take parameters, while `api.query.system.account(<accountId>)` (retrieving the associated nonce & balances for an account), takes the `AccountId` as a parameter.
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * api.query.system.account(<accountId>, ([nonce, balance]) => {
+   *   console.log('new free balance', balance.free, 'new nonce', nonce);
+   * });
+   * ```
+   */
+  get query() {
+    return assertResult(this._query);
+  }
+  /**
+   * @description Allows for the querying of multiple storage entries and the combination thereof into a single result. This is a very optimal way to make multiple queries since it only makes a single connection to the node and retrieves the data over one subscription.
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * const unsub = await api.queryMulti(
+   *   [
+   *     // you can include the storage without any parameters
+   *     api.query.balances.totalIssuance,
+   *     // or you can pass parameters to the storage query
+   *     [api.query.system.account, '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY']
+   *   ],
+   *   ([existential, [, { free }]]) => {
+   *     console.log(`You have ${free.sub(existential)} more than the existential deposit`);
+   *
+   *     unsub();
+   *   }
+   * );
+   * ```
+   */
+  get queryMulti() {
+    return assertResult(this._queryMulti);
+  }
+  /**
+   * @description Contains all the raw rpc sections and their subsequent methods in the API as defined by the jsonrpc interface definitions. Unlike the dynamic `api.query` and `api.tx` sections, these methods are fixed (although extensible with node upgrades) and not determined by the runtime.
+   *
+   * RPC endpoints available here allow for the query of chain, node and system information, in addition to providing interfaces for the raw queries of state (using known keys) and the submission of transactions.
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * api.rpc.chain.subscribeNewHeads((header) => {
+   *   console.log('new header', header);
+   * });
+   * ```
+   */
+  get rpc() {
+    return assertResult(this._rpc);
+  }
+  /**
+   * @description Contains the chain information for the current node.
+   */
+  get runtimeChain() {
+    return assertResult(this._runtimeChain);
+  }
+  /**
+   * @description Yields the current attached runtime metadata. Generally this is only used to construct extrinsics & storage, but is useful for current runtime inspection.
+   */
+  get runtimeMetadata() {
+    return assertResult(this._runtimeMetadata);
+  }
+  /**
+   * @description Contains the version information for the current runtime.
+   */
+  get runtimeVersion() {
+    return assertResult(this._runtimeVersion);
+  }
+  /**
+   * @description The underlying Rx API interface
+   */
+  get rx() {
+    return assertResult(this._rx);
+  }
+  /**
+   * @description Returns the underlying provider stats
+   */
+  get stats() {
+    return this._rpcCore.stats;
+  }
+  /**
+   * @description The type of this API instance, either 'rxjs' or 'promise'
+   */
+  get type() {
+    return this._type;
+  }
+  /**
+   * @description Contains all the extrinsic modules and their subsequent methods in the API. It allows for the construction of transactions and the submission thereof. These are attached dynamically from the runtime metadata.
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * api.tx.balances
+   *   .transferAllowDeath(<recipientId>, <balance>)
+   *   .signAndSend(<keyPair>, ({status}) => {
+   *     console.log('tx status', status.asFinalized.toHex());
+   *   });
+   * ```
+   */
+  get tx() {
+    return assertResult(this._extrinsics);
+  }
+  /**
+   * @description Finds the definition for a specific [[CallFunction]] based on the index supplied
+   */
+  findCall(callIndex) {
+    return find.findCall(this.registry, callIndex);
+  }
+  /**
+   * @description Finds the definition for a specific [[RegistryError]] based on the index supplied
+   */
+  findError(errorIndex) {
+    return find.findError(this.registry, errorIndex);
+  }
+}
+
+exports.Getters = Getters;

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

@@ -0,0 +1,356 @@
+'use strict';
+
+var Decorate = require('./Decorate.js');
+var firstValueFrom = require('../../../rxjs/dist/esm5/internal/firstValueFrom.js');
+var util = require('../../types-known/util.js');
+var Metadata = require('../../types/metadata/Metadata.js');
+var switchMap = require('../../../rxjs/dist/esm5/internal/operators/switchMap.js');
+var crypto = require('../../util-crypto/crypto.js');
+var of = require('../../../rxjs/dist/esm5/internal/observable/of.js');
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var logger = require('../../util/logger.js');
+var noop = require('../../util/noop.js');
+var spread = require('../../util/object/spread.js');
+var assert = require('../../util/assert.js');
+var toU8a = require('../../util/u8a/toU8a.js');
+var toHex = require('../../util/u8a/toHex.js');
+var registry = require('../../types/create/registry.js');
+var _undefined = require('../../util/is/undefined.js');
+var consts = require('../../util/bn/consts.js');
+var eq = require('../../util/u8a/eq.js');
+
+const KEEPALIVE_INTERVAL = 10000;
+const l = logger.logger('api/init');
+function textToString(t) {
+  return t.toString();
+}
+class Init extends Decorate.Decorate {
+  __internal__atLast = null;
+  __internal__healthTimer = null;
+  __internal__registries = [];
+  __internal__updateSub = null;
+  __internal__waitingRegistries = {};
+  constructor(options, type, decorateMethod) {
+    super(options, type, decorateMethod);
+    // all injected types added to the registry for overrides
+    this.registry.setKnownTypes(options);
+    // We only register the types (global) if this is not a cloned instance.
+    // Do right up-front, so we get in the user types before we are actually
+    // doing anything on-chain, this ensures we have the overrides in-place
+    if (!options.source) {
+      this.registerTypes(options.types);
+    } else {
+      this.__internal__registries = options.source.__internal__registries;
+    }
+    this._rpc = this._decorateRpc(this._rpcCore, this._decorateMethod);
+    this._rx.rpc = this._decorateRpc(this._rpcCore, this._rxDecorateMethod);
+    if (this.supportMulti) {
+      this._queryMulti = this._decorateMulti(this._decorateMethod);
+      this._rx.queryMulti = this._decorateMulti(this._rxDecorateMethod);
+    }
+    this._rx.signer = options.signer;
+    this._rpcCore.setRegistrySwap(blockHash => this.getBlockRegistry(blockHash));
+    this._rpcCore.setResolveBlockHash(blockNumber => firstValueFrom.firstValueFrom(this._rpcCore.chain.getBlockHash(blockNumber)));
+    if (this.hasSubscriptions) {
+      this._rpcCore.provider.on('disconnected', () => this.__internal__onProviderDisconnect());
+      this._rpcCore.provider.on('error', e => this.__internal__onProviderError(e));
+      this._rpcCore.provider.on('connected', () => this.__internal__onProviderConnect());
+    } else if (!this._options.noInitWarn) {
+      l.warn('Api will be available in a limited mode since the provider does not support subscriptions');
+    }
+    // If the provider was instantiated earlier, and has already emitted a
+    // 'connected' event, then the `on('connected')` won't fire anymore. To
+    // cater for this case, we call manually `this._onProviderConnect`.
+    if (this._rpcCore.provider.isConnected) {
+      this.__internal__onProviderConnect().catch(noop.noop);
+    }
+  }
+  /**
+   * @description Decorates a registry based on the runtime version
+   */
+  _initRegistry(registry, chain, version, metadata, chainProps) {
+    registry.clearCache();
+    registry.setChainProperties(chainProps || this.registry.getChainProperties());
+    registry.setKnownTypes(this._options);
+    registry.register(util.getSpecTypes(registry, chain, version.specName, version.specVersion));
+    registry.setHasher(util.getSpecHasher(registry, chain, version.specName));
+    // for bundled types, pull through the aliases defined
+    if (registry.knownTypes.typesBundle) {
+      registry.knownTypes.typesAlias = util.getSpecAlias(registry, chain, version.specName);
+    }
+    registry.setMetadata(metadata, undefined, spread.objectSpread({}, util.getSpecExtensions(registry, chain, version.specName), this._options.signedExtensions), this._options.noInitWarn);
+  }
+  /**
+   * @description Returns the default versioned registry
+   */
+  _getDefaultRegistry() {
+    return assert.assertReturn(this.__internal__registries.find(_ref => {
+      let {
+        isDefault
+      } = _ref;
+      return isDefault;
+    }), 'Initialization error, cannot find the default registry');
+  }
+  /**
+   * @description Returns a decorated API instance at a specific point in time
+   */
+  async at(blockHash, knownVersion) {
+    const u8aHash = toU8a.u8aToU8a(blockHash);
+    const u8aHex = toHex.u8aToHex(u8aHash);
+    const registry = await this.getBlockRegistry(u8aHash, knownVersion);
+    if (!this.__internal__atLast || this.__internal__atLast[0] !== u8aHex) {
+      // always create a new decoration - since we are pointing to a specific hash, this
+      // means that all queries needs to use that hash (not a previous one already existing)
+      this.__internal__atLast = [u8aHex, this._createDecorated(registry, true, null, u8aHash).decoratedApi];
+    }
+    return this.__internal__atLast[1];
+  }
+  async _createBlockRegistry(blockHash, header, version) {
+    const registry$1 = new registry.TypeRegistry(blockHash);
+    const metadata = new Metadata.Metadata(registry$1, await firstValueFrom.firstValueFrom(this._rpcCore.state.getMetadata.raw(header.parentHash)));
+    const runtimeChain = this._runtimeChain;
+    if (!runtimeChain) {
+      throw new Error('Invalid initializion order, runtimeChain is not available');
+    }
+    this._initRegistry(registry$1, runtimeChain, version, metadata);
+    // add our new registry
+    const result = {
+      counter: 0,
+      lastBlockHash: blockHash,
+      metadata,
+      registry: registry$1,
+      runtimeVersion: version
+    };
+    this.__internal__registries.push(result);
+    return result;
+  }
+  _cacheBlockRegistryProgress(key, creator) {
+    // look for waiting resolves
+    let waiting = this.__internal__waitingRegistries[key];
+    if (_undefined.isUndefined(waiting)) {
+      // nothing waiting, construct new
+      waiting = this.__internal__waitingRegistries[key] = new Promise((resolve, reject) => {
+        creator().then(registry => {
+          delete this.__internal__waitingRegistries[key];
+          resolve(registry);
+        }).catch(error => {
+          delete this.__internal__waitingRegistries[key];
+          reject(error);
+        });
+      });
+    }
+    return waiting;
+  }
+  _getBlockRegistryViaVersion(blockHash, version) {
+    if (version) {
+      // check for pre-existing registries. We also check specName, e.g. it
+      // could be changed like in Westmint with upgrade from shell -> westmint
+      const existingViaVersion = this.__internal__registries.find(_ref2 => {
+        let {
+          runtimeVersion: {
+            specName,
+            specVersion
+          }
+        } = _ref2;
+        return specName.eq(version.specName) && specVersion.eq(version.specVersion);
+      });
+      if (existingViaVersion) {
+        existingViaVersion.counter++;
+        existingViaVersion.lastBlockHash = blockHash;
+        return existingViaVersion;
+      }
+    }
+    return null;
+  }
+  async _getBlockRegistryViaHash(blockHash) {
+    // ensure we have everything required
+    if (!this._genesisHash || !this._runtimeVersion) {
+      throw new Error('Cannot retrieve data on an uninitialized chain');
+    }
+    // We have to assume that on the RPC layer the calls used here does not call back into
+    // the registry swap, so getHeader & getRuntimeVersion should not be historic
+    const header = this.registry.createType('HeaderPartial', this._genesisHash.eq(blockHash) ? {
+      number: consts.BN_ZERO,
+      parentHash: this._genesisHash
+    } : await firstValueFrom.firstValueFrom(this._rpcCore.chain.getHeader.raw(blockHash)));
+    if (header.parentHash.isEmpty) {
+      throw new Error('Unable to retrieve header and parent from supplied hash');
+    }
+    // get the runtime version, either on-chain or via an known upgrade history
+    util.getUpgradeVersion(this._genesisHash, header.number);
+    const version = this.registry.createType('RuntimeVersionPartial', await firstValueFrom.firstValueFrom(this._rpcCore.state.getRuntimeVersion.raw(header.parentHash)));
+    return (
+      // try to find via version
+      this._getBlockRegistryViaVersion(blockHash, version) || (
+      // return new or in-flight result
+      await this._cacheBlockRegistryProgress(version.toHex(), () => this._createBlockRegistry(blockHash, header, version)))
+    );
+  }
+  /**
+   * @description Sets up a registry based on the block hash defined
+   */
+  async getBlockRegistry(blockHash, knownVersion) {
+    return (
+      // try to find via blockHash
+      this.__internal__registries.find(_ref3 => {
+        let {
+          lastBlockHash
+        } = _ref3;
+        return lastBlockHash && eq.u8aEq(lastBlockHash, blockHash);
+      }) ||
+      // try to find via version
+      this._getBlockRegistryViaVersion(blockHash, knownVersion) || (
+      // return new or in-flight result
+      await this._cacheBlockRegistryProgress(toHex.u8aToHex(blockHash), () => this._getBlockRegistryViaHash(blockHash)))
+    );
+  }
+  async _loadMeta() {
+    // on re-connection to the same chain, we don't want to re-do everything from chain again
+    if (this._isReady) {
+      return true;
+    }
+    this._unsubscribeUpdates();
+    // only load from on-chain if we are not a clone (default path), alternatively
+    // just use the values from the source instance provided
+    [this._genesisHash, this._runtimeMetadata] = this._options.source?._isReady ? await this._metaFromSource(this._options.source) : await this._metaFromChain(this._options.metadata);
+    return this._initFromMeta(this._runtimeMetadata);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async _metaFromSource(source) {
+    this._extrinsicType = source.extrinsicVersion;
+    this._runtimeChain = source.runtimeChain;
+    this._runtimeVersion = source.runtimeVersion;
+    // manually build a list of all available methods in this RPC, we are
+    // going to filter on it to align the cloned RPC without making a call
+    const sections = Object.keys(source.rpc);
+    const rpcs = [];
+    for (let s = 0, scount = sections.length; s < scount; s++) {
+      const section = sections[s];
+      const methods = Object.keys(source.rpc[section]);
+      for (let m = 0, mcount = methods.length; m < mcount; m++) {
+        rpcs.push(`${section}_${methods[m]}`);
+      }
+    }
+    this._filterRpc(rpcs, util.getSpecRpc(this.registry, source.runtimeChain, source.runtimeVersion.specName));
+    return [source.genesisHash, source.runtimeMetadata];
+  }
+  // subscribe to metadata updates, inject the types on changes
+  _subscribeUpdates() {
+    if (this.__internal__updateSub || !this.hasSubscriptions) {
+      return;
+    }
+    this.__internal__updateSub = this._rpcCore.state.subscribeRuntimeVersion().pipe(switchMap.switchMap(version =>
+    // only retrieve the metadata when the on-chain version has been changed
+    this._runtimeVersion?.specVersion.eq(version.specVersion) ? of.of(false) : this._rpcCore.state.getMetadata().pipe(map.map(metadata => {
+      l.log(`Runtime version updated to spec=${version.specVersion.toString()}, tx=${version.transactionVersion.toString()}`);
+      this._runtimeMetadata = metadata;
+      this._runtimeVersion = version;
+      this._rx.runtimeVersion = version;
+      // update the default registry version
+      const thisRegistry = this._getDefaultRegistry();
+      const runtimeChain = this._runtimeChain;
+      if (!runtimeChain) {
+        throw new Error('Invalid initializion order, runtimeChain is not available');
+      }
+      // setup the data as per the current versions
+      thisRegistry.metadata = metadata;
+      thisRegistry.runtimeVersion = version;
+      this._initRegistry(this.registry, runtimeChain, version, metadata);
+      this._injectMetadata(thisRegistry, true);
+      return true;
+    })))).subscribe();
+  }
+  async _metaFromChain(optMetadata) {
+    const [genesisHash, runtimeVersion, chain, chainProps, rpcMethods, chainMetadata] = await Promise.all([firstValueFrom.firstValueFrom(this._rpcCore.chain.getBlockHash(0)), firstValueFrom.firstValueFrom(this._rpcCore.state.getRuntimeVersion()), firstValueFrom.firstValueFrom(this._rpcCore.system.chain()), firstValueFrom.firstValueFrom(this._rpcCore.system.properties()), firstValueFrom.firstValueFrom(this._rpcCore.rpc.methods()), optMetadata ? Promise.resolve(null) : firstValueFrom.firstValueFrom(this._rpcCore.state.getMetadata())]);
+    // set our chain version & genesisHash as returned
+    this._runtimeChain = chain;
+    this._runtimeVersion = runtimeVersion;
+    this._rx.runtimeVersion = runtimeVersion;
+    // retrieve metadata, either from chain  or as pass-in via options
+    const metadataKey = `${genesisHash.toHex() || '0x'}-${runtimeVersion.specVersion.toString()}`;
+    const metadata = chainMetadata || (optMetadata?.[metadataKey] ? new Metadata.Metadata(this.registry, optMetadata[metadataKey]) : await firstValueFrom.firstValueFrom(this._rpcCore.state.getMetadata()));
+    // initializes the registry & RPC
+    this._initRegistry(this.registry, chain, runtimeVersion, metadata, chainProps);
+    this._filterRpc(rpcMethods.methods.map(textToString), util.getSpecRpc(this.registry, chain, runtimeVersion.specName));
+    this._subscribeUpdates();
+    // setup the initial registry, when we have none
+    if (!this.__internal__registries.length) {
+      this.__internal__registries.push({
+        counter: 0,
+        isDefault: true,
+        metadata,
+        registry: this.registry,
+        runtimeVersion
+      });
+    }
+    // get unique types & validate
+    metadata.getUniqTypes(this._options.throwOnUnknown || false);
+    return [genesisHash, metadata];
+  }
+  _initFromMeta(metadata) {
+    const runtimeVersion = this._runtimeVersion;
+    if (!runtimeVersion) {
+      throw new Error('Invalid initializion order, runtimeVersion is not available');
+    }
+    this._extrinsicType = metadata.asLatest.extrinsic.version.toNumber();
+    this._rx.extrinsicType = this._extrinsicType;
+    this._rx.genesisHash = this._genesisHash;
+    this._rx.runtimeVersion = runtimeVersion;
+    // inject metadata and adjust the types as detected
+    this._injectMetadata(this._getDefaultRegistry(), true);
+    // derive is last, since it uses the decorated rx
+    this._rx.derive = this._decorateDeriveRx(this._rxDecorateMethod);
+    this._derive = this._decorateDerive(this._decorateMethod);
+    return true;
+  }
+  _subscribeHealth() {
+    this._unsubscribeHealth();
+    // Only enable the health keepalive on WS, not needed on HTTP
+    this.__internal__healthTimer = this.hasSubscriptions ? setInterval(() => {
+      firstValueFrom.firstValueFrom(this._rpcCore.system.health.raw()).catch(noop.noop);
+    }, KEEPALIVE_INTERVAL) : null;
+  }
+  _unsubscribeHealth() {
+    if (this.__internal__healthTimer) {
+      clearInterval(this.__internal__healthTimer);
+      this.__internal__healthTimer = null;
+    }
+  }
+  _unsubscribeUpdates() {
+    if (this.__internal__updateSub) {
+      this.__internal__updateSub.unsubscribe();
+      this.__internal__updateSub = null;
+    }
+  }
+  _unsubscribe() {
+    this._unsubscribeHealth();
+    this._unsubscribeUpdates();
+  }
+  async __internal__onProviderConnect() {
+    this._isConnected.next(true);
+    this.emit('connected');
+    try {
+      const cryptoReady = this._options.initWasm === false ? true : await crypto.cryptoWaitReady();
+      const hasMeta = await this._loadMeta();
+      this._subscribeHealth();
+      if (hasMeta && !this._isReady && cryptoReady) {
+        this._isReady = true;
+        this.emit('ready', this);
+      }
+    } catch (_error) {
+      const error = new Error(`FATAL: Unable to initialize the API: ${_error.message}`);
+      l.error(error);
+      this.emit('error', error);
+    }
+  }
+  __internal__onProviderDisconnect() {
+    this._isConnected.next(false);
+    this._unsubscribe();
+    this.emit('disconnected');
+  }
+  __internal__onProviderError(error) {
+    this.emit('error', error);
+  }
+}
+
+exports.Init = Init;

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var toU8a = require('../../util/u8a/toU8a.js');
+
+function findCall(registry, callIndex) {
+  return registry.findMetaCall(toU8a.u8aToU8a(callIndex));
+}
+function findError(registry, errorIndex) {
+  return registry.findMetaError(toU8a.u8aToU8a(errorIndex));
+}
+
+exports.findCall = findCall;
+exports.findError = findError;