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

Multi chain wallet aggregator for web3Auth

import _objectSpread from '@babel/runtime/helpers/objectSpread2';
import _defineProperty from '@babel/runtime/helpers/defineProperty';
import { BaseController } from '@toruslabs/base-controllers';
import { rpcErrors } from '@web3auth/auth';
import { EIP1193_EVENTS } from './utils.js';
import { WalletInitializationError, WalletProviderError } from '../../base/errors/index.js';

class BaseProvider extends 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);
    _defineProperty(this, "providerEventBridges", new Map());
    _defineProperty(this, "providerListenerBridgeRegistered", false);
    const {
      chain
    } = config;
    if (!chain) throw WalletInitializationError.invalidProviderConfigError("Please provide chain");
    if (!chain.chainId) throw WalletInitializationError.invalidProviderConfigError("Please provide chainId inside chain");
    if (!chain.rpcTarget) throw 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 rpcErrors.invalidRequest({
        message: WalletProviderError.invalidRequestArgs().message,
        data: _objectSpread(_objectSpread({}, args || {}), {}, {
          cause: WalletProviderError.invalidRequestArgs().message
        })
      });
    }
    const {
      method,
      params
    } = args;
    if (typeof method !== "string" || method.length === 0) {
      throw rpcErrors.invalidRequest({
        message: WalletProviderError.invalidRequestMethod().message,
        data: _objectSpread(_objectSpread({}, args || {}), {}, {
          cause: WalletProviderError.invalidRequestMethod().message
        })
      });
    }
    if (params !== undefined && !Array.isArray(params) && (typeof params !== "object" || params === null)) {
      throw rpcErrors.invalidRequest({
        message: WalletProviderError.invalidRequestParams().message,
        data: _objectSpread(_objectSpread({}, args || {}), {}, {
          cause: 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 === provider) return;
    if (this._providerEngineProxy) {
      // remove all event bridges from the previous provider
      this.detachProviderEventBridges(this._providerEngineProxy);
    }

    // attach all event bridges to the new provider
    this._providerEngineProxy = provider;
    this.ensureProviderListenerBridge();
    this.eventNames().forEach(event => {
      this.ensureProviderEventBridge(event);
    });
    this.attachProviderEventBridges(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);
  }
  ensureProviderListenerBridge() {
    if (this.providerListenerBridgeRegistered) return;
    this.providerListenerBridgeRegistered = true;
    this.on("newListener", event => {
      this.ensureProviderEventBridge(event);
    });
  }
  ensureProviderEventBridge(event) {
    if (event === "newListener" || event === "removeListener" || this.providerEventBridges.has(event)) return;
    const bridge = {
      handler: (...args) => {
        if (event === EIP1193_EVENTS.CHAIN_CHANGED) {
          const chainId = args[0];
          this.update({
            chainId
          });
        }

        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        this.emit(event, ...args);
      }
    };
    this.providerEventBridges.set(event, bridge);
    if (!this._providerEngineProxy) return;
    bridge.detach = this.attachProviderEventBridge(this._providerEngineProxy, event, bridge.handler);
  }
  attachProviderEventBridges(provider) {
    this.providerEventBridges.forEach((bridge, event) => {
      if (bridge.detach) return;
      bridge.detach = this.attachProviderEventBridge(provider, event, bridge.handler);
    });
  }
  attachProviderEventBridge(provider, event, handler) {
    const removableProvider = provider;
    const maybeDetach = removableProvider.on(event, handler);
    return typeof maybeDetach === "function" ? () => {
      maybeDetach();
    } : undefined;
  }
  detachProviderEventBridges(provider) {
    this.providerEventBridges.forEach((bridge, event) => {
      if (bridge.detach) {
        bridge.detach();
      } else {
        const removableProvider = provider;
        if (typeof removableProvider.removeListener === "function") {
          removableProvider.removeListener(event, bridge.handler);
        } else if (typeof removableProvider.off === "function") {
          removableProvider.off(event, bridge.handler);
        }
      }
      bridge.detach = undefined;
    });
  }
}

export { BaseProvider };