@mocanetwork/airkit 0.5.0-beta.2

package/dist/airkit.umd.min.js.LICENSE.txt

@@ -0,0 +1,12 @@
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/dist/lib.cjs/common/src/error.js

@@ -0,0 +1,25 @@
+'use strict';
+
+class BaseError extends Error {
+  constructor(name, message, options = {}) {
+    const {
+      cause,
+      context
+    } = options;
+    super(message || name);
+    this.name = name;
+    this.stack = cause === null || cause === void 0 ? void 0 : cause.stack;
+    this.cause = cause;
+    this.context = context;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      context: this.context,
+      cause: this.cause
+    };
+  }
+}
+
+exports.BaseError = BaseError;

package/dist/lib.cjs/common/src/realm/messaging/auth.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const AirAuthMessageTypes = {
+  SETUP_COMPLETED: "air_auth_setup_completed",
+  LOGIN_REQUEST: "air_auth_login_request",
+  LOGIN_RESPONSE: "air_auth_login_response",
+  LOGIN_WALLET_RESPONSE: "air_auth_login_wallet_response",
+  USER_INFO_REQUEST: "air_auth_user_info_request",
+  USER_INFO_RESPONSE: "air_auth_user_info_response",
+  PARTNER_USER_INFO_REQUEST: "air_auth_partner_user_info_request",
+  PARTNER_USER_INFO_RESPONSE: "air_auth_partner_user_info_response",
+  REFRESH_TOKEN_REQUEST: "air_auth_refresh_token_request",
+  REFRESH_TOKEN_RESPONSE: "air_auth_refresh_token_response",
+  WALLET_TOKEN_REQUEST: "air_auth_wallet_token_request",
+  WALLET_TOKEN_RESPONSE: "air_auth_wallet_token_response",
+  INITIALIZATION_REQUEST: "air_auth_initialization_request",
+  INITIALIZATION_RESPONSE: "air_auth_initialization_response",
+  INIT_WALLET_COMMUNICATION: "air_auth_init_wallet_communication",
+  IFRAME_VISIBILITY_REQUEST: "air_auth_iframe_visibility_request",
+  SETUP_WALLET_REQUEST: "air_auth_setup_wallet_request",
+  SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_response",
+  SIGN_SIWE_MESSAGE_REQUEST: "air_auth_sign_siwe_message_request",
+  SIGN_SIWE_MESSAGE_RESPONSE: "air_auth_sign_siwe_message_response",
+  LOGOUT_REQUEST: "air_auth_logout_request",
+  LOGOUT_RESPONSE: "air_auth_logout_response"
+};
+
+exports.AirAuthMessageTypes = AirAuthMessageTypes;

package/dist/lib.cjs/common/src/realm/messaging/types.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const AirMessageTypes = {
+  SERVICE_INITIALIZED: "air_service_initialized",
+  SERVICE_INITIALIZED_ERROR: "air_service_initialized_error",
+  LOGIN_REQUEST: "air_login_request",
+  CLAIM_REQUEST: "air_claim_request",
+  LOGIN_CLAIM_STATE: "air_login_claim_state",
+  CLOSE_MODAL: "air_close_modal",
+  INIT_AUTH_COMMUNICATION: "air_init_auth_communication",
+  DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
+  DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response"
+};
+
+exports.AirMessageTypes = AirMessageTypes;

package/dist/lib.cjs/ws-embed/src/PopupHandler.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('@web3auth/auth');
+
+class PopupHandler extends auth.SafeEventEmitter {
+  constructor({
+    url,
+    target,
+    features,
+    timeout = 30000
+  }) {
+    super();
+    _defineProperty(this, "url", void 0);
+    _defineProperty(this, "target", void 0);
+    _defineProperty(this, "features", void 0);
+    _defineProperty(this, "window", void 0);
+    _defineProperty(this, "windowTimer", void 0);
+    _defineProperty(this, "iClosedWindow", void 0);
+    _defineProperty(this, "timeout", void 0);
+    this.url = url;
+    this.target = target || "_blank";
+    this.features = features || baseControllers.getPopupFeatures(baseControllers.FEATURES_DEFAULT_POPUP_WINDOW);
+    this.window = undefined;
+    this.windowTimer = undefined;
+    this.iClosedWindow = false;
+    this.timeout = timeout;
+    this._setupTimer();
+  }
+  _setupTimer() {
+    this.windowTimer = Number(setInterval(() => {
+      if (this.window && this.window.closed) {
+        clearInterval(this.windowTimer);
+        setTimeout(() => {
+          if (!this.iClosedWindow) {
+            this.emit("close");
+          }
+          this.iClosedWindow = false;
+          this.window = undefined;
+        }, this.timeout);
+      }
+      if (this.window === undefined) clearInterval(this.windowTimer);
+    }, 500));
+  }
+  open() {
+    var _this$window;
+    this.window = window.open(this.url.href, this.target, this.features);
+    if ((_this$window = this.window) !== null && _this$window !== void 0 && _this$window.focus) this.window.focus();
+  }
+  close() {
+    this.iClosedWindow = true;
+    if (this.window) this.window.close();
+  }
+  redirect(locationReplaceOnRedirect) {
+    if (locationReplaceOnRedirect) {
+      window.location.replace(this.url.href);
+    } else {
+      window.location.href = this.url.href;
+    }
+  }
+}
+
+module.exports = PopupHandler;

package/dist/lib.cjs/ws-embed/src/airService.js

@@ -0,0 +1,364 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _classPrivateMethodInitSpec = require('@babel/runtime/helpers/classPrivateMethodInitSpec');
+var _classPrivateFieldInitSpec = require('@babel/runtime/helpers/classPrivateFieldInitSpec');
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('../../common/src/realm/messaging/auth.js');
+var embed = require('./embed.js');
+var error = require('./error.js');
+var iframeController = require('./iframeController.js');
+var interfaces = require('./interfaces.js');
+var loglevel = require('./loglevel.js');
+var messageService = require('./messageService.js');
+var utils = require('./utils.js');
+
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var _authIframeController = /*#__PURE__*/new WeakMap();
+var _loginResult = /*#__PURE__*/new WeakMap();
+var _buildEnv = /*#__PURE__*/new WeakMap();
+var _embedNonce = /*#__PURE__*/new WeakMap();
+var _enableLogging = /*#__PURE__*/new WeakMap();
+var _isInitialized = /*#__PURE__*/new WeakMap();
+var _partnerId = /*#__PURE__*/new WeakMap();
+var _realmEmbed = /*#__PURE__*/new WeakMap();
+var _walletInitialization = /*#__PURE__*/new WeakMap();
+var _airAuthListener = /*#__PURE__*/new WeakMap();
+var _AirService_brand = /*#__PURE__*/new WeakSet();
+class AirService {
+  constructor({
+    partnerId
+  }) {
+    _classPrivateMethodInitSpec(this, _AirService_brand);
+    _classPrivateFieldInitSpec(this, _authIframeController, void 0);
+    _classPrivateFieldInitSpec(this, _loginResult, void 0);
+    _classPrivateFieldInitSpec(this, _buildEnv, void 0);
+    _classPrivateFieldInitSpec(this, _embedNonce, baseControllers.randomId());
+    _classPrivateFieldInitSpec(this, _enableLogging, false);
+    _classPrivateFieldInitSpec(this, _isInitialized, false);
+    _classPrivateFieldInitSpec(this, _partnerId, void 0);
+    // Realm Embed related
+    _classPrivateFieldInitSpec(this, _realmEmbed, void 0);
+    _classPrivateFieldInitSpec(this, _walletInitialization, void 0);
+    _classPrivateFieldInitSpec(this, _airAuthListener, []);
+    _classPrivateFieldSet(_partnerId, this, partnerId);
+    _classPrivateFieldSet(_realmEmbed, this, new embed.default({
+      partnerId: _classPrivateFieldGet(_partnerId, this)
+    }));
+  }
+  get buildEnv() {
+    return _classPrivateFieldGet(_buildEnv, this);
+  }
+  get isAirAuth() {
+    return true;
+  }
+  get isInitialized() {
+    return _classPrivateFieldGet(_isInitialized, this);
+  }
+  get isLoggedIn() {
+    return !!_classPrivateFieldGet(_loginResult, this);
+  }
+  get isWalletLoaded() {
+    var _classPrivateFieldGet2;
+    return (_classPrivateFieldGet2 = _classPrivateFieldGet(_realmEmbed, this)) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.isInitialized;
+  }
+  async init({
+    buildEnv = interfaces.EMBED_BUILD_ENV.PRODUCTION,
+    enableLogging = false,
+    skipRehydration = false
+  }) {
+    if (!_classPrivateFieldGet(_partnerId, this)) throw new Error("Partner ID is required to initialize auth service");
+    if (_classPrivateFieldGet(_isInitialized, this)) return;
+    _classPrivateFieldSet(_buildEnv, this, buildEnv);
+    _classPrivateFieldSet(_enableLogging, this, enableLogging);
+    const {
+      authUrl,
+      logLevel
+    } = utils.AIR_URLS[buildEnv];
+    loglevel.setDefaultLevel(logLevel);
+    if (_classPrivateFieldGet(_enableLogging, this)) loglevel.enableAll();else loglevel.disableAll();
+    const authIframeOrigin = new URL(authUrl).origin;
+    await messageService.openAuthObservables({
+      authIframeOrigin
+    });
+    _classPrivateFieldSet(_authIframeController, this, new iframeController.IframeController(authUrl, `air-login-${_classPrivateFieldGet(_embedNonce, this)}`));
+    messageService.authMessage$.subscribe(async msg => {
+      switch (msg.type) {
+        case auth.AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST:
+          {
+            const authIframeController = _classPrivateFieldGet(_authIframeController, this);
+            authIframeController.setIframeVisibility(msg.payload.visible);
+            authIframeController.updateIframeState();
+            break;
+          }
+        case auth.AirAuthMessageTypes.SETUP_WALLET_REQUEST:
+          {
+            await _assertClassBrand(_AirService_brand, this, _initializeWallet).call(this);
+            break;
+          }
+      }
+    });
+    try {
+      _classPrivateFieldGet(_authIframeController, this).createIframe();
+      const initializationPromise = new Promise((resolve, reject) => {
+        const handleAuthMessage = ev => {
+          try {
+            if (ev.origin !== authIframeOrigin) return;
+            if (ev.data === auth.AirAuthMessageTypes.SETUP_COMPLETED) {
+              window.removeEventListener("message", handleAuthMessage);
+              _classPrivateFieldGet(_authIframeController, this).postMessage({
+                type: auth.AirAuthMessageTypes.INITIALIZATION_REQUEST,
+                payload: {
+                  partnerId: _classPrivateFieldGet(_partnerId, this),
+                  skipRehydration
+                }
+              });
+              resolve();
+            }
+          } catch (err) {
+            reject(err);
+          }
+        };
+        window.addEventListener("message", handleAuthMessage);
+      });
+      const authServiceInitialization = messageService.waitForAuthInitialization();
+      const result = await Promise.all([initializationPromise, authServiceInitialization]);
+      _classPrivateFieldSet(_isInitialized, this, true);
+      _assertClassBrand(_AirService_brand, this, _triggerAirAuthInitialized).call(this);
+      _assertClassBrand(_AirService_brand, this, _prepareRealmEmbedListeners).call(this);
+
+      // rehydrated auth session
+      if (result[1].rehydrated) {
+        _classPrivateFieldSet(_loginResult, this, _assertClassBrand(_AirService_brand, this, _createLoginResult).call(this, result[1]));
+        _assertClassBrand(_AirService_brand, this, _triggerAirAuthLoggedIn).call(this);
+        return _classPrivateFieldGet(_loginResult, this);
+      }
+    } catch (error) {
+      loglevel.debug("Error initializing auth service", error);
+      await this.cleanUp();
+      throw error;
+    }
+    return null;
+  }
+  async cleanUp() {
+    var _classPrivateFieldGet3;
+    // Clear up wallet service iframe if exists
+    await _assertClassBrand(_AirService_brand, this, _cleanUpWallet).call(this);
+
+    // Logout auth session
+    await messageService.logoutAuth(_classPrivateFieldGet(_authIframeController, this).iframeElement);
+
+    // Destroy the auth iframe
+    const authIframeElement = (_classPrivateFieldGet3 = _classPrivateFieldGet(_authIframeController, this)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.iframeElement;
+    if (utils.isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
+      _classPrivateFieldGet(_authIframeController, this).destroy();
+      _classPrivateFieldSet(_authIframeController, this, undefined);
+    }
+
+    // Close the message service
+    messageService.closeAuthObservables();
+    this.clearEventListeners();
+    _classPrivateFieldSet(_isInitialized, this, false);
+  }
+  async login(options) {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Service is not initialized");
+    if (_classPrivateFieldGet(_loginResult, this)) return _classPrivateFieldGet(_loginResult, this);
+    const iframeController = _classPrivateFieldGet(_authIframeController, this);
+    const {
+      payload
+    } = await messageService.sendAuthLoginRequest(iframeController.iframeElement, {
+      partnerLoginToken: options === null || options === void 0 ? void 0 : options.authToken
+    });
+    if (payload.success === true) {
+      _classPrivateFieldSet(_loginResult, this, _assertClassBrand(_AirService_brand, this, _createLoginResult).call(this, payload));
+      _assertClassBrand(_AirService_brand, this, _triggerAirAuthLoggedIn).call(this);
+      return _classPrivateFieldGet(_loginResult, this);
+    }
+    throw new error.AirServiceError("UNKNOWN_ERROR", "Unknown error occurred");
+  }
+  async deploySmartAccount() {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Service is not initialized");
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this)._deploySmartAccount();
+  }
+  async logout() {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Service is not initialized");
+    if (!this.isLoggedIn) throw new Error("No active session to logout");
+
+    // Clear up wallet
+    await _assertClassBrand(_AirService_brand, this, _cleanUpWallet).call(this);
+    await messageService.logoutAuth(_classPrivateFieldGet(_authIframeController, this).iframeElement);
+    _classPrivateFieldSet(_loginResult, this, undefined);
+    _assertClassBrand(_AirService_brand, this, _triggerAirAuthLoggedOut).call(this);
+  }
+  async getProvider() {
+    if (!this.isLoggedIn) return null;
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this).provider;
+  }
+  async preloadWallet() {
+    return _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+  }
+  async claimAirId(options) {
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this).claimRealmId(options);
+  }
+  async getUserInfo() {
+    if (!this.isLoggedIn) throw new Error("User not logged in");
+    const info = await messageService.sendUserInfoRequest(_classPrivateFieldGet(_authIframeController, this).iframeElement);
+    if (info.payload.success === false) {
+      throw new error.AirServiceError(info.payload.errorName, info.payload.errorMessage);
+    }
+    return {
+      id: info.payload.id,
+      abstractAccountAddress: info.payload.abstractAccountAddress,
+      email: info.payload.email,
+      airIds: info.payload.airIds
+    };
+  }
+  async getPartnerUserInfo() {
+    if (!this.isLoggedIn) throw new Error("User not logged in");
+    const info = await messageService.sendPartnerUserInfoRequest(_classPrivateFieldGet(_authIframeController, this).iframeElement);
+    if (info.payload.success === false) {
+      throw new error.AirServiceError(info.payload.errorName, info.payload.errorMessage);
+    }
+    return {
+      partnerId: info.payload.partnerId,
+      partnerUserId: info.payload.partnerUserId,
+      airId: info.payload.airId
+    };
+  }
+  on(listener) {
+    if (_classPrivateFieldGet(_airAuthListener, this).indexOf(listener) < 0) _classPrivateFieldGet(_airAuthListener, this).push(listener);
+  }
+  off(listener) {
+    if (_classPrivateFieldGet(_airAuthListener, this).indexOf(listener) >= 0) _classPrivateFieldGet(_airAuthListener, this).splice(_classPrivateFieldGet(_airAuthListener, this).indexOf(listener), 1);
+  }
+  clearEventListeners() {
+    _classPrivateFieldSet(_airAuthListener, this, []);
+  }
+
+  // This is for internal use only
+  // @ts-expect-error for unused function
+  async _showWalletWidget() {
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return _classPrivateFieldGet(_realmEmbed, this)._showWalletWidget();
+  }
+}
+async function _createWallet() {
+  return _classPrivateFieldGet(_realmEmbed, this).login({
+    skipClaiming: true,
+    legacy: false
+  });
+}
+async function _ensureWallet() {
+  if (!this.isLoggedIn) throw new Error("No active session to create wallet");
+  if (!_classPrivateFieldGet(_walletInitialization, this)) {
+    messageService.setupAuthIframe(_classPrivateFieldGet(_authIframeController, this).iframeElement);
+    _classPrivateFieldSet(_walletInitialization, this, (async () => {
+      try {
+        await _assertClassBrand(_AirService_brand, this, _initializeWallet).call(this);
+        return await _assertClassBrand(_AirService_brand, this, _createWallet).call(this);
+      } catch (error) {
+        loglevel.error("Error initializing wallet", error);
+        throw error;
+      }
+    })());
+  }
+  return _classPrivateFieldGet(_walletInitialization, this);
+}
+async function _cleanUpWallet() {
+  if (_classPrivateFieldGet(_walletInitialization, this) || _classPrivateFieldGet(_realmEmbed, this)) {
+    await _classPrivateFieldGet(_walletInitialization, this);
+    await _classPrivateFieldGet(_realmEmbed, this).cleanUp();
+    _classPrivateFieldSet(_walletInitialization, this, undefined);
+  }
+}
+async function _initializeWallet() {
+  if (!_classPrivateFieldGet(_realmEmbed, this).isInitialized) {
+    try {
+      await _classPrivateFieldGet(_realmEmbed, this).init({
+        buildEnv: _classPrivateFieldGet(_buildEnv, this),
+        skipRehydration: true,
+        enableLogging: _classPrivateFieldGet(_enableLogging, this) || false
+      });
+      _classPrivateFieldGet(_authIframeController, this).postMessage({
+        type: auth.AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+        payload: {
+          success: true
+        }
+      });
+    } catch (error) {
+      loglevel.error("Error initializing wallet", error);
+      _classPrivateFieldGet(_authIframeController, this).postMessage({
+        type: auth.AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+        payload: {
+          success: false,
+          errorName: "UNKNOWN_ERROR",
+          errorMessage: "Unknown error occurred"
+        }
+      });
+      throw error;
+    }
+  }
+}
+async function _triggerEventListeners(data) {
+  _classPrivateFieldGet(_airAuthListener, this).forEach(listener => {
+    listener(data);
+  });
+}
+async function _triggerAirAuthInitialized() {
+  await _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+    event: "initialized"
+  });
+}
+async function _triggerAirAuthLoggedIn() {
+  await _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+    event: "logged_in",
+    result: _classPrivateFieldGet(_loginResult, this)
+  });
+}
+async function _triggerAirAuthLoggedOut() {
+  await _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+    event: "logged_out"
+  });
+}
+function _createLoginResult(payload) {
+  return {
+    isLoggedIn: true,
+    id: payload.id,
+    abstractAccountAddress: payload.abstractAccountAddress,
+    token: payload.partnerAccessToken
+  };
+}
+async function _prepareRealmEmbedListeners() {
+  _classPrivateFieldGet(_realmEmbed, this).on(data => {
+    if (data.event === "connected" || data.event === "logged_in") {
+      var _data$result$addresse;
+      const result = _objectSpread(_objectSpread({}, data.result), {}, {
+        addresses: {
+          eoa: data.result.addresses.eoa,
+          aa: (_data$result$addresse = data.result.addresses.aa) !== null && _data$result$addresse !== void 0 ? _data$result$addresse : ""
+        }
+      });
+      _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+        event: "wallet_loaded",
+        result
+      });
+    } else if (data.event === "minting_started") {
+      _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+        event: "minting_started"
+      });
+    } else if (data.event === "minting_failed") {
+      _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+        event: "minting_failed",
+        errorMessage: data.errorMessage
+      });
+    }
+  });
+}
+
+module.exports = AirService;

package/dist/lib.cjs/ws-embed/src/baseProvider.js

@@ -0,0 +1,178 @@
+'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');
+var pump = require('pump');
+var isStream = require('./isStream.js');
+var messages = require('./messages.js');
+var utils = require('./utils.js');
+
+/**
+ * @param connectionStream - A Node.js duplex stream
+ * @param opts - An options bag
+ */
+class BaseProvider extends auth.SafeEventEmitter {
+  constructor(connectionStream, {
+    maxEventListeners = 100,
+    jsonRpcStreamName = "provider"
+  }) {
+    super();
+    _defineProperty(this, "rpcEngine", void 0);
+    _defineProperty(this, "jsonRpcConnectionEvents", void 0);
+    /**
+     * Indicating that this provider is a Web3Auth provider.
+     */
+    _defineProperty(this, "isWeb3Auth", void 0);
+    _defineProperty(this, "state", void 0);
+    if (!isStream.isDuplexStream(connectionStream)) {
+      throw new Error(messages.errors.invalidDuplexStream());
+    }
+    this.isWeb3Auth = true;
+    this.setMaxListeners(maxEventListeners);
+    this.handleConnect = this.handleConnect.bind(this);
+    this.handleDisconnect = this.handleDisconnect.bind(this);
+    this.handleStreamDisconnect = this.handleStreamDisconnect.bind(this);
+    this.rpcRequest = this.rpcRequest.bind(this);
+    this.initializeState = this.initializeState.bind(this);
+    this.request = this.request.bind(this);
+    this.sendAsync = this.sendAsync.bind(this);
+    this.send = this.send.bind(this);
+    // this.enable = this.enable.bind(this);
+
+    // setup connectionStream multiplexing
+    const mux = new auth.ObjectMultiplex();
+    pump(connectionStream, mux, connectionStream, this.handleStreamDisconnect.bind(this, "Web3Auth"));
+
+    // ignore phishing warning message (handled elsewhere)
+    mux.ignoreStream("phishing");
+
+    // setup own event listeners
+    // connect to async provider
+
+    const jsonRpcConnection = auth.createStreamMiddleware();
+    pump(jsonRpcConnection.stream, mux.createStream(jsonRpcStreamName), jsonRpcConnection.stream, this.handleStreamDisconnect.bind(this, "Web3Auth RpcProvider"));
+
+    // handle RPC requests via dapp-side rpc engine
+    const rpcEngine = new auth.JRPCEngine();
+    rpcEngine.push(auth.createIdRemapMiddleware());
+    rpcEngine.push(utils.createErrorMiddleware());
+    rpcEngine.push(baseControllers.createLoggerMiddleware({
+      origin: location.origin
+    }));
+    rpcEngine.push(jsonRpcConnection.middleware);
+    this.rpcEngine = rpcEngine;
+    this.jsonRpcConnectionEvents = jsonRpcConnection.events;
+  }
+
+  /**
+   * Submits an RPC request for the given method, with the given params.
+   * Resolves with the result of the method call, or rejects on error.
+   *
+   * @param args - The RPC request arguments.
+   * @returns A Promise that resolves with the result of the RPC method,
+   * or rejects if an error is encountered.
+   */
+  async request(args) {
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+      throw auth.rpcErrors.invalidRequest({
+        message: messages.errors.invalidRequestArgs(),
+        data: _objectSpread(_objectSpread({}, args || {}), {}, {
+          cause: messages.errors.invalidRequestArgs()
+        })
+      });
+    }
+    const {
+      method,
+      params
+    } = args;
+    if (typeof method !== "string" || method.length === 0) {
+      throw auth.rpcErrors.invalidRequest({
+        message: messages.errors.invalidRequestMethod(),
+        data: _objectSpread(_objectSpread({}, args || {}), {}, {
+          cause: messages.errors.invalidRequestArgs()
+        })
+      });
+    }
+    if (params !== undefined && !Array.isArray(params) && (typeof params !== "object" || params === null)) {
+      throw auth.rpcErrors.invalidRequest({
+        message: messages.errors.invalidRequestParams(),
+        data: _objectSpread(_objectSpread({}, args || {}), {}, {
+          cause: messages.errors.invalidRequestArgs()
+        })
+      });
+    }
+    return new Promise((resolve, reject) => {
+      this.rpcRequest({
+        method,
+        params
+      }, auth.getRpcPromiseCallback(resolve, reject));
+    });
+  }
+  /**
+   * Submits an RPC request per the given JSON-RPC request object.
+   *
+   * @param payload - The RPC request object.
+   * @param cb - The callback function.
+   */
+  send(payload, callback) {
+    this.rpcRequest(payload, callback);
+  }
+  /**
+   * Submits an RPC request per the given JSON-RPC request object.
+   *
+   * @param payload - The RPC request object.
+   * @param cb - The callback function.
+   */
+  sendAsync(payload) {
+    return new Promise((resolve, reject) => {
+      this.rpcRequest(payload, auth.getRpcPromiseCallback(resolve, reject));
+    });
+  }
+
+  /**
+   * Called when connection is lost to critical streams.
+   *
+   * emits InpageProvider#disconnect
+   */
+  handleStreamDisconnect(streamName, error) {
+    utils.logStreamDisconnectWarning(streamName, error, this);
+    this.handleDisconnect(false, error ? error.message : undefined);
+  }
+
+  // Private Methods
+  //= ===================
+  /**
+   * Constructor helper.
+   * Populates initial state by calling 'wallet_getProviderState' and emits
+   * necessary events.
+   */
+
+  /**
+   * Internal RPC method. Forwards requests to background via the RPC engine.
+   * Also remap ids inbound and outbound
+   */
+
+  /**
+   * When the provider becomes connected, updates internal state and emits
+   * required events. Idempotent.
+   *
+   * @param chainId - The ID of the newly connected chain.
+   * emits InPageProvider#connect
+   */
+
+  /**
+   * When the provider becomes disconnected, updates internal state and emits
+   * required events. Idempotent with respect to the isRecoverable parameter.
+   *
+   * Error codes per the CloseEvent status codes as required by EIP-1193:
+   * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+   *
+   * @param isRecoverable - Whether the disconnection is recoverable.
+   * @param errorMessage - A custom error message.
+   * emits InpageProvider#disconnect
+   */
+}
+
+module.exports = BaseProvider;