@web3auth/no-modal/dist/lib.cjs/providers/base-provider/baseProvider.js

Multi chain wallet aggregator for web3Auth

'use strict';

var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
var _defineProperty = require('@babel/runtime/helpers/defineProperty');
var baseControllers = require('@toruslabs/base-controllers');
var auth = require('@web3auth/auth');
require('@segment/analytics-next');
require('../../base/loglevel.js');
var index = require('../../base/errors/index.js');
require('../../base/wallet/index.js');
require('../../base/connector/connectorStatus.js');
require('../../base/connector/constants.js');
require('jwt-decode');
require('../../base/plugin/errors.js');
require('../../base/plugin/IPlugin.js');
require('@toruslabs/constants');
require('@toruslabs/http-helpers');
var utils = require('./utils.js');

class BaseProvider extends baseControllers.BaseController {
  constructor({
    config,
    state
  }) {
    super({
      config,
      state
    });
    // should be Assigned in setupProvider
    _defineProperty(this, "_providerEngineProxy", null);
    // set to true when the keyExportEnabled flag is set by code.
    // This is to prevent the flag from being overridden by the dashboard config.
    _defineProperty(this, "keyExportFlagSetByCode", false);
    const {
      chain
    } = config;
    if (!chain) throw index.WalletInitializationError.invalidProviderConfigError("Please provide chain");
    if (!chain.chainId) throw index.WalletInitializationError.invalidProviderConfigError("Please provide chainId inside chain");
    if (!chain.rpcTarget) throw index.WalletInitializationError.invalidProviderConfigError("Please provide rpcTarget inside chain");
    if (typeof config.keyExportEnabled === "boolean") this.keyExportFlagSetByCode = true;
    this.defaultState = {
      chainId: "loading"
    };
    this.defaultConfig = {
      chain: config.chain,
      chains: config.chains,
      keyExportEnabled: typeof config.keyExportEnabled === "boolean" ? config.keyExportEnabled : true
    };
    super.initialize();
  }
  get currentChain() {
    return this.config.chains.find(chain => chain.chainId === this.state.chainId);
  }
  get provider() {
    return this._providerEngineProxy;
  }
  get chainId() {
    return this.state.chainId;
  }
  set provider(_) {
    throw new Error("Method not implemented.");
  }
  async request(args) {
    var _this$provider;
    if (!args || typeof args !== "object" || Array.isArray(args)) {
      throw auth.rpcErrors.invalidRequest({
        message: index.WalletProviderError.invalidRequestArgs().message,
        data: _objectSpread(_objectSpread({}, args || {}), {}, {
          cause: index.WalletProviderError.invalidRequestArgs().message
        })
      });
    }
    const {
      method,
      params
    } = args;
    if (typeof method !== "string" || method.length === 0) {
      throw auth.rpcErrors.invalidRequest({
        message: index.WalletProviderError.invalidRequestMethod().message,
        data: _objectSpread(_objectSpread({}, args || {}), {}, {
          cause: index.WalletProviderError.invalidRequestMethod().message
        })
      });
    }
    if (params !== undefined && !Array.isArray(params) && (typeof params !== "object" || params === null)) {
      throw auth.rpcErrors.invalidRequest({
        message: index.WalletProviderError.invalidRequestParams().message,
        data: _objectSpread(_objectSpread({}, args || {}), {}, {
          cause: index.WalletProviderError.invalidRequestParams().message
        })
      });
    }
    return (_this$provider = this.provider) === null || _this$provider === void 0 ? void 0 : _this$provider.request(args);
  }
  sendAsync(req, callback) {
    if (callback) return this.send(req, callback);
    return this.request(req);
  }
  send(req, callback) {
    this.request(req).then(res => callback(null, {
      result: res
    })).catch(err => callback(err, null));
  }
  updateProviderEngineProxy(provider) {
    if (this._providerEngineProxy) {
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      this._providerEngineProxy.setTarget(provider);
      // we want events to propagate from Ethereum provider -> wrapper provider (e.g. CommonJRPC provider) -> SDK -> dapp
      // ensure that only one handler is added for each event
      const reEmitHandler = event => {
        // skip newListener event
        if (event === "newListener") return;
        // listen to the event from the Ethereum provider
        provider.on(event, (...args) => {
          // handle chainChanged event: update chainId state
          if (event === utils.EIP1193_EVENTS.CHAIN_CHANGED) {
            const chainId = args[0];
            this.update({
              chainId
            });
          }
          // re-emit the event
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          this.emit(event, ...args);
        });
      };
      // handle existing events
      this.eventNames().forEach(event => {
        reEmitHandler(event);
      });
      // handle when a new listener is added
      this.on("newListener", event => {
        // skip if the event already exists
        if (this.listenerCount(event) > 0) return;
        reEmitHandler(event);
      });
    } else {
      this._providerEngineProxy = baseControllers.createEventEmitterProxy(provider);
    }
  }
  setKeyExportFlag(flag) {
    if (!this.keyExportFlagSetByCode) {
      this.configure({
        keyExportEnabled: flag
      });
    }
  }
  getProviderEngineProxy() {
    return this._providerEngineProxy;
  }
  getChain(chainId) {
    return this.config.chains.find(chain => chain.chainId === chainId);
  }
}

exports.BaseProvider = BaseProvider;