@mocanetwork/airkit 0.5.0 → 1.0.0

package/dist/airkit.cjs.js

@@ -1,92 +1,115 @@
-/******/ (() => { // webpackBootstrap
-/******/ 	"use strict";
-/******/ 	// The require scope
-/******/ 	var __webpack_require__ = {};
-/******/ 	
-/************************************************************************/
-/******/ 	/* webpack/runtime/compat get default export */
-/******/ 	(() => {
-/******/ 		// getDefaultExport function for compatibility with non-harmony modules
-/******/ 		__webpack_require__.n = (module) => {
-/******/ 			var getter = module && module.__esModule ?
-/******/ 				() => (module['default']) :
-/******/ 				() => (module);
-/******/ 			__webpack_require__.d(getter, { a: getter });
-/******/ 			return getter;
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/define property getters */
-/******/ 	(() => {
-/******/ 		// define getter functions for harmony exports
-/******/ 		__webpack_require__.d = (exports, definition) => {
-/******/ 			for(var key in definition) {
-/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
-/******/ 				}
-/******/ 			}
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
-/******/ 	(() => {
-/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/make namespace object */
-/******/ 	(() => {
-/******/ 		// define __esModule on exports
-/******/ 		__webpack_require__.r = (exports) => {
-/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 			}
-/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/************************************************************************/
-var __webpack_exports__ = {};
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  AirInPageProvider: () => (/* reexport */ inPageProvider),
-  AirService: () => (/* reexport */ airService),
-  BUTTON_POSITION: () => (/* reexport */ BUTTON_POSITION),
-  CONFIRMATION_STRATEGY: () => (/* reexport */ base_controllers_namespaceObject.CONFIRMATION_STRATEGY),
-  EMBED_BUILD_ENV: () => (/* reexport */ EMBED_BUILD_ENV),
-  EXTERNAL_LOGIN_PROVIDER: () => (/* reexport */ EXTERNAL_LOGIN_PROVIDER),
-  RealmEmbed: () => (/* reexport */ src_embed)
-});
+'use strict';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function (d, b) {
+  extendStatics = Object.setPrototypeOf || {
+    __proto__: []
+  } instanceof Array && function (d, b) {
+    d.__proto__ = b;
+  } || function (d, b) {
+    for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator,
+    m = s && o[s],
+    i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function () {
+      if (o && i >= o.length) o = undefined;
+      return {
+        value: o && o[i++],
+        done: !o
+      };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+function __classPrivateFieldGet(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
 
-;// external "@babel/runtime/helpers/objectSpread2"
-const objectSpread2_namespaceObject = require("@babel/runtime/helpers/objectSpread2");
-var objectSpread2_default = /*#__PURE__*/__webpack_require__.n(objectSpread2_namespaceObject);
-;// external "@babel/runtime/helpers/classPrivateMethodInitSpec"
-const classPrivateMethodInitSpec_namespaceObject = require("@babel/runtime/helpers/classPrivateMethodInitSpec");
-var classPrivateMethodInitSpec_default = /*#__PURE__*/__webpack_require__.n(classPrivateMethodInitSpec_namespaceObject);
-;// external "@babel/runtime/helpers/classPrivateFieldInitSpec"
-const classPrivateFieldInitSpec_namespaceObject = require("@babel/runtime/helpers/classPrivateFieldInitSpec");
-var classPrivateFieldInitSpec_default = /*#__PURE__*/__webpack_require__.n(classPrivateFieldInitSpec_namespaceObject);
-;// external "@toruslabs/base-controllers"
-const base_controllers_namespaceObject = require("@toruslabs/base-controllers");
-;// ../common/src/realm/messaging/auth.js
 const AirAuthMessageTypes = {
-  SETUP_COMPLETED: "air_auth_setup_completed",
+  AUTH_SETUP_COMPLETED: "air_auth_setup_completed",
+  INITIALIZATION_REQUEST: "air_auth_initialization_request",
+  INITIALIZATION_RESPONSE: "air_auth_initialization_response",
   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",
@@ -96,19 +119,15 @@ const AirAuthMessageTypes = {
   LOGOUT_REQUEST: "air_auth_logout_request",
   LOGOUT_RESPONSE: "air_auth_logout_response"
 };
-;// external "@toruslabs/ethereum-controllers"
-const ethereum_controllers_namespaceObject = require("@toruslabs/ethereum-controllers");
-;// external "@web3auth/auth"
-const external_web3auth_auth_namespaceObject = require("@web3auth/auth");
-;// ../common/src/realm/messaging/types.js
+
 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",
+  SERVICE_STARTED: "air_service_started",
+  INITIALIZATION_REQUEST: "air_initialization_request",
+  INITIALIZATION_RESPONSE: "air_initialization_response",
   INIT_AUTH_COMMUNICATION: "air_init_auth_communication",
+  WALLET_INITIALIZED: "air_wallet_initialized",
+  CLAIM_ID_REQUEST: "air_claim_id_request",
+  CLAIM_ID_RESPONSE: "air_claim_id_response",
   DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
   DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response",
   GRANT_PERMISSIONS_REQUEST: "air_grant_permissions_request",
@@ -116,763 +135,750 @@ const AirMessageTypes = {
   EXECUTE_ACTION_REQUEST: "air_execute_action_request",
   EXECUTE_ACTION_RESPONSE: "air_execute_action_response",
   REVOKE_PERMISSIONS_REQUEST: "air_revoke_permissions_request",
-  REVOKE_PERMISSIONS_RESPONSE: "air_revoke_permissions_response"
-};
-const AirLoginClaimStates = {
-  CONNECTED: "connected",
-  LOGGED_IN: "logged_in",
-  CLAIM_FLOW_STARTED: "claim_flow_started",
-  CLAIM_FLOW_CANCELLED: "claim_flow_cancelled",
-  MINTING_STARTED: "minting_started",
-  MINTING_FAILED: "minting_failed"
-};
-;// external "@babel/runtime/helpers/defineProperty"
-const defineProperty_namespaceObject = require("@babel/runtime/helpers/defineProperty");
-var defineProperty_default = /*#__PURE__*/__webpack_require__.n(defineProperty_namespaceObject);
-;// external "pump"
-const external_pump_namespaceObject = require("pump");
-var external_pump_default = /*#__PURE__*/__webpack_require__.n(external_pump_namespaceObject);
-;// ./src/isStream.ts
-/* eslint-disable @typescript-eslint/no-explicit-any */
-function isStream(stream) {
-  return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
-}
-function isWritableStream(stream) {
-  return isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
-}
-function isReadableStream(stream) {
-  return isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
-}
-function isDuplexStream(stream) {
-  return isWritableStream(stream) && isReadableStream(stream);
-}
-;// ./src/messages.ts
-/* harmony default export */ const messages = ({
-  errors: {
-    disconnected: () => "Web3Auth: Lost connection to Web3Auth.",
-    permanentlyDisconnected: () => "Web3Auth: Disconnected from iframe. Page reload required.",
-    unsupportedSync: method => `Web3Auth: The Web3Auth Ethereum provider does not support synchronous methods like ${method} without a callback parameter.`,
-    invalidDuplexStream: () => "Must provide a Node.js-style duplex stream.",
-    invalidOptions: maxEventListeners => `Invalid options. Received: { maxEventListeners: ${maxEventListeners}}`,
-    invalidRequestArgs: () => `Expected a single, non-array, object argument.`,
-    invalidRequestMethod: () => `'args.method' must be a non-empty string.`,
-    invalidRequestParams: () => `'args.params' must be an object or array if provided.`,
-    invalidLoggerObject: () => `'args.logger' must be an object if provided.`,
-    invalidLoggerMethod: method => `'args.logger' must include required method '${method}'.`
-  },
-  info: {
-    connected: chainId => `Web3Auth: Connected to chain with ID "${chainId}".`
-  },
-  warnings: {}
-});
-;// ./src/interfaces.ts
-
-const EMBED_BUILD_ENV = {
-  PRODUCTION: "production",
-  STAGING: "staging",
-  DEVELOPMENT: "development",
-  TESTING: "testing"
+  REVOKE_PERMISSIONS_RESPONSE: "air_revoke_permissions_response",
+  WALLET_IFRAME_VISIBILITY_REQUEST: "air_wallet_iframe_visibility_request",
+  IS_SMART_ACCOUNT_DEPLOYED_REQUEST: "air_is_smart_account_deployed_request",
+  IS_SMART_ACCOUNT_DEPLOYED_RESPONSE: "air_is_smart_account_deployed_response",
+  LOGOUT_REQUEST: "air_logout_request",
+  LOGOUT_RESPONSE: "air_logout_response"
 };
-const BUTTON_POSITION = {
-  BOTTOM_LEFT: "bottom-left",
-  TOP_LEFT: "top-left",
-  BOTTOM_RIGHT: "bottom-right",
-  TOP_RIGHT: "top-right"
-};
-const EXTERNAL_LOGIN_PROVIDER = {
-  METAMASK: "metamask",
-  WALLET_CONNECT: "walletconnect",
-  WAGMI: "wagmi"
-};
-;// external "loglevel"
-const external_loglevel_namespaceObject = require("loglevel");
-var external_loglevel_default = /*#__PURE__*/__webpack_require__.n(external_loglevel_namespaceObject);
-;// ./src/loglevel.ts
-
-/* harmony default export */ const loglevel = (external_loglevel_default().getLogger("ws-embed"));
-;// ./src/utils.ts
 
+function isFunction(value) {
+  return typeof value === 'function';
+}
 
+function createErrorClass(createImpl) {
+  var _super = function (instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
 
+var UnsubscriptionError = createErrorClass(function (_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join('\n  ') : '';
+    this.name = 'UnsubscriptionError';
+    this.errors = errors;
+  };
+});
 
-const AIR_URLS = {
-  [EMBED_BUILD_ENV.TESTING]: {
-    authUrl: "http://localhost:8100",
-    walletUrl: "https://lrc-mocaverse.web3auth.io",
-    logLevel: "debug"
-  },
-  [EMBED_BUILD_ENV.DEVELOPMENT]: {
-    authUrl: "http://localhost:8100",
-    walletUrl: "https://localhost:4050",
-    logLevel: "debug"
-  },
-  [EMBED_BUILD_ENV.STAGING]: {
-    authUrl: "https://auth.staging.air3.com",
-    walletUrl: "https://account.staging.realmnetwork.io",
-    logLevel: "info"
-  },
-  [EMBED_BUILD_ENV.PRODUCTION]: {
-    authUrl: "https://auth.air3.com",
-    walletUrl: "https://account.realmnetwork.io",
-    logLevel: "error"
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
   }
-};
-const handleEvent = (handle, eventName, handler, ...handlerArgs) => {
-  const handlerWrapper = () => {
-    handler(...handlerArgs);
-    handle.removeEventListener(eventName, handlerWrapper);
-  };
-  handle.addEventListener(eventName, handlerWrapper);
-};
-const htmlToElement = html => {
-  const template = window.document.createElement("template");
-  const trimmedHtml = html.trim(); // Never return a text node of whitespace as the result
-  template.innerHTML = trimmedHtml;
-  return template.content.firstChild;
-};
-const isElement = element => element instanceof Element || element instanceof Document;
-
-/**
- * json-rpc-engine middleware that logs RPC errors and and validates req.method.
- *
- * @param log - The logging API to use.
- * @returns  json-rpc-engine middleware function
- */
-function createErrorMiddleware() {
-  return (req, res, next) => {
-    // json-rpc-engine will terminate the request when it notices this error
-    if (typeof req.method !== "string" || !req.method) {
-      res.error = external_web3auth_auth_namespaceObject.rpcErrors.invalidRequest({
-        message: `The request 'method' must be a non-empty string.`,
-        data: objectSpread2_default()(objectSpread2_default()({}, req || {}), {}, {
-          cause: `The request 'method' must be a non-empty string.`
-        })
-      });
+}
+
+var Subscription = function () {
+  function Subscription(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription.prototype.unsubscribe = function () {
+    var e_1, _a, e_2, _b;
+    var errors;
+    if (!this.closed) {
+      this.closed = true;
+      var _parentage = this._parentage;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = {
+              error: e_1_1
+            };
+          } finally {
+            try {
+              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        } else {
+          _parentage.remove(this);
+        }
+      }
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors !== null && errors !== void 0 ? errors : [];
+              if (err instanceof UnsubscriptionError) {
+                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+              } else {
+                errors.push(err);
+              }
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = {
+            error: e_2_1
+          };
+        } finally {
+          try {
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
     }
-    next(done => {
-      const {
-        error
-      } = res;
-      if (!error) {
-        return done();
+  };
+  Subscription.prototype.add = function (teardown) {
+    var _a;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof Subscription) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
+          }
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== undefined ? _a : []).push(teardown);
       }
-      loglevel.error(`Ws-Embed - RPC Error: ${error.message}`, error);
-      return done();
-    });
+    }
+  };
+  Subscription.prototype._hasParent = function (parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription.prototype._addParent = function (parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  };
+  Subscription.prototype._removeParent = function (parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription.prototype.remove = function (teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription) {
+      teardown._removeParent(this);
+    }
   };
+  Subscription.EMPTY = function () {
+    var empty = new Subscription();
+    empty.closed = true;
+    return empty;
+  }();
+  return Subscription;
+}();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription || value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
 }
-
-/**
- * Logs a stream disconnection error. Emits an 'error' if given an
- * EventEmitter that has listeners for the 'error' event.
- *
- * @param log - The logging API to use.
- * @param remoteLabel - The label of the disconnected stream.
- * @param error - The associated error to log.
- * @param emitter - The logging API to use.
- */
-function logStreamDisconnectWarning(remoteLabel, error, emitter) {
-  let warningMsg = `Web3Auth: Lost connection to "${remoteLabel}".`;
-  if (error !== null && error !== void 0 && error.stack) {
-    warningMsg += `\n${error.stack}`;
-  }
-  loglevel.warn(warningMsg);
-  if (emitter && emitter.listenerCount("error") > 0) {
-    emitter.emit("error", warningMsg);
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
   }
 }
-const EMITTED_NOTIFICATIONS = ["eth_subscription" // per eth-json-rpc-filters/subscriptionManager
-];
-;// ./src/baseProvider.ts
-
-
-
-
 
+var config = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: undefined,
+  useDeprecatedSynchronousErrorHandling: false,
+  useDeprecatedNextContext: false
+};
 
+var timeoutProvider = {
+  setTimeout: function (handler, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    return setTimeout.apply(undefined, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function (handle) {
+    return (clearTimeout)(handle);
+  },
+  delegate: undefined
+};
 
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function () {
+    {
+      throw err;
+    }
+  });
+}
 
+function noop() {}
 
-/**
- * @param connectionStream - A Node.js duplex stream
- * @param opts - An options bag
- */
-class BaseProvider extends external_web3auth_auth_namespaceObject.SafeEventEmitter {
-  constructor(connectionStream, {
-    maxEventListeners = 100,
-    jsonRpcStreamName = "provider"
-  }) {
-    super();
-    defineProperty_default()(this, "rpcEngine", void 0);
-    defineProperty_default()(this, "jsonRpcConnectionEvents", void 0);
-    /**
-     * Indicating that this provider is a Web3Auth provider.
-     */
-    defineProperty_default()(this, "isWeb3Auth", void 0);
-    defineProperty_default()(this, "state", void 0);
-    if (!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 external_web3auth_auth_namespaceObject.ObjectMultiplex();
-    external_pump_default()(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 = (0,external_web3auth_auth_namespaceObject.createStreamMiddleware)();
-    external_pump_default()(jsonRpcConnection.stream, mux.createStream(jsonRpcStreamName), jsonRpcConnection.stream, this.handleStreamDisconnect.bind(this, "Web3Auth RpcProvider"));
-
-    // handle RPC requests via dapp-side rpc engine
-    const rpcEngine = new external_web3auth_auth_namespaceObject.JRPCEngine();
-    rpcEngine.push((0,external_web3auth_auth_namespaceObject.createIdRemapMiddleware)());
-    rpcEngine.push(createErrorMiddleware());
-    rpcEngine.push((0,base_controllers_namespaceObject.createLoggerMiddleware)({
-      origin: location.origin
-    }));
-    rpcEngine.push(jsonRpcConnection.middleware);
-    this.rpcEngine = rpcEngine;
-    this.jsonRpcConnectionEvents = jsonRpcConnection.events;
+function errorContext(cb) {
+  {
+    cb();
   }
+}
 
-  /**
-   * 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 external_web3auth_auth_namespaceObject.rpcErrors.invalidRequest({
-        message: messages.errors.invalidRequestArgs(),
-        data: objectSpread2_default()(objectSpread2_default()({}, args || {}), {}, {
-          cause: messages.errors.invalidRequestArgs()
-        })
-      });
+var Subscriber = function (_super) {
+  __extends(Subscriber, _super);
+  function Subscriber(destination) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination) {
+      _this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(_this);
+      }
+    } else {
+      _this.destination = EMPTY_OBSERVER;
     }
-    const {
-      method,
-      params
-    } = args;
-    if (typeof method !== "string" || method.length === 0) {
-      throw external_web3auth_auth_namespaceObject.rpcErrors.invalidRequest({
-        message: messages.errors.invalidRequestMethod(),
-        data: objectSpread2_default()(objectSpread2_default()({}, args || {}), {}, {
-          cause: messages.errors.invalidRequestArgs()
-        })
-      });
+    return _this;
+  }
+  Subscriber.create = function (next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  };
+  Subscriber.prototype.next = function (value) {
+    if (this.isStopped) ; else {
+      this._next(value);
     }
-    if (params !== undefined && !Array.isArray(params) && (typeof params !== "object" || params === null)) {
-      throw external_web3auth_auth_namespaceObject.rpcErrors.invalidRequest({
-        message: messages.errors.invalidRequestParams(),
-        data: objectSpread2_default()(objectSpread2_default()({}, args || {}), {}, {
-          cause: messages.errors.invalidRequestArgs()
-        })
-      });
+  };
+  Subscriber.prototype.error = function (err) {
+    if (this.isStopped) ; else {
+      this.isStopped = true;
+      this._error(err);
     }
-    return new Promise((resolve, reject) => {
-      this.rpcRequest({
-        method,
-        params
-      }, (0,external_web3auth_auth_namespaceObject.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, (0,external_web3auth_auth_namespaceObject.getRpcPromiseCallback)(resolve, reject));
-    });
-  }
-
-  /**
-   * Called when connection is lost to critical streams.
-   *
-   * emits InpageProvider#disconnect
-   */
-  handleStreamDisconnect(streamName, error) {
-    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
-   */
-}
-/* harmony default export */ const baseProvider = (BaseProvider);
-;// ./src/PopupHandler.ts
-
-
-
-class PopupHandler extends external_web3auth_auth_namespaceObject.SafeEventEmitter {
-  constructor({
-    url,
-    target,
-    features,
-    timeout = 30000
-  }) {
-    super();
-    defineProperty_default()(this, "url", void 0);
-    defineProperty_default()(this, "target", void 0);
-    defineProperty_default()(this, "features", void 0);
-    defineProperty_default()(this, "window", void 0);
-    defineProperty_default()(this, "windowTimer", void 0);
-    defineProperty_default()(this, "iClosedWindow", void 0);
-    defineProperty_default()(this, "timeout", void 0);
-    this.url = url;
-    this.target = target || "_blank";
-    this.features = features || (0,base_controllers_namespaceObject.getPopupFeatures)(base_controllers_namespaceObject.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);
+  };
+  Subscriber.prototype.complete = function () {
+    if (this.isStopped) ; else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber.prototype.unsubscribe = function () {
+    if (!this.closed) {
+      this.isStopped = true;
+      _super.prototype.unsubscribe.call(this);
+      this.destination = null;
+    }
+  };
+  Subscriber.prototype._next = function (value) {
+    this.destination.next(value);
+  };
+  Subscriber.prototype._error = function (err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  Subscriber.prototype._complete = function () {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  return Subscriber;
+}(Subscription);
+var ConsumerObserver = function () {
+  function ConsumerObserver(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver.prototype.next = function (value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
       }
-      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);
+    }
+  };
+  ConsumerObserver.prototype.error = function (err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver.prototype.complete = function () {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  return ConsumerObserver;
+}();
+var SafeSubscriber = function (_super) {
+  __extends(SafeSubscriber, _super);
+  function SafeSubscriber(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== undefined ? observerOrNext : undefined,
+        error: error !== null && error !== undefined ? error : undefined,
+        complete: complete !== null && complete !== undefined ? complete : undefined
+      };
     } else {
-      window.location.href = this.url.href;
+      {
+        partialObserver = observerOrNext;
+      }
     }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber;
+}(Subscriber);
+function handleUnhandledError(error) {
+  {
+    reportUnhandledError(error);
   }
 }
-/* harmony default export */ const src_PopupHandler = (PopupHandler);
-;// ./src/communicationProvider.ts
-
-
-
-
-
-
-
-
-
-/**
- * @param connectionStream - A Node.js duplex stream
- * @param  opts - An options bag
- */
-class CommunicationProvider extends baseProvider {
-  constructor(connectionStream, {
-    maxEventListeners = 100,
-    jsonRpcStreamName = "provider"
-  }, state) {
-    super(connectionStream, {
-      maxEventListeners,
-      jsonRpcStreamName
-    });
-
-    // private state
-    defineProperty_default()(this, "tryWindowHandle", void 0);
-    defineProperty_default()(this, "onLoginStateHandle", void 0);
-    defineProperty_default()(this, "windowRefs", void 0);
-    defineProperty_default()(this, "iframeUrl", void 0);
-    defineProperty_default()(this, "iframeId", void 0);
-    this.state = objectSpread2_default()(objectSpread2_default()({}, CommunicationProvider.defaultState), state);
-
-    // public state
-    this.iframeUrl = "";
-    this.iframeId = "";
-    this.windowRefs = new Map();
+function defaultErrorHandler(err) {
+  throw err;
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
 
-    // setup own event listeners
+var observable = function () {
+  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+}();
 
-    // EIP-1193 connect
-    this.on("connect", () => {
-      this.state.isConnected = true;
-    });
-    const notificationHandler = payload => {
-      const {
-        method,
-        params
-      } = payload;
-      // create_window should never come here..
-      // we either pre-open from embed.
-      // if it's blocked, we communicate down that it's blocked and we show full screen iframe and open from iframe
-      if (method === base_controllers_namespaceObject.COMMUNICATION_NOTIFICATIONS.IFRAME_STATUS) {
-        const {
-          isFullScreen,
-          rid
-        } = params;
-        this.displayIframe({
-          isFull: isFullScreen,
-          rid: rid
-        }, true);
-      } else if (method === base_controllers_namespaceObject.COMMUNICATION_NOTIFICATIONS.CLOSE_WINDOW) {
-        this.handleCloseWindow(params);
-      } else if (method === base_controllers_namespaceObject.COMMUNICATION_NOTIFICATIONS.USER_LOGGED_IN) {
-        loglevel.info("[TEST METAMASK] User received notification ", base_controllers_namespaceObject.COMMUNICATION_NOTIFICATIONS.USER_LOGGED_IN);
-        const {
-          currentLoginProvider
-        } = params;
-        this.state.isLoggedIn = true;
-        this.state.currentLoginProvider = currentLoginProvider;
-        if (this.onLoginStateHandle) this.onLoginStateHandle(true);
-      } else if (method === base_controllers_namespaceObject.COMMUNICATION_NOTIFICATIONS.USER_LOGGED_OUT) {
-        this.state.isLoggedIn = false;
-        this.state.currentLoginProvider = null;
-        this.displayIframe();
-        if (this.onLoginStateHandle) this.onLoginStateHandle(false);
-      }
-    };
-    this.jsonRpcConnectionEvents.on("notification", notificationHandler);
-  }
-  get isLoggedIn() {
-    return this.state.isLoggedIn;
-  }
+function identity(x) {
+  return x;
+}
 
-  // e.g. Metamask, WalletConnect, etc.
-  get isExternalWallet() {
-    return !this.state.currentLoginProvider || this.state.currentLoginProvider === EXTERNAL_LOGIN_PROVIDER.METAMASK || this.state.currentLoginProvider === EXTERNAL_LOGIN_PROVIDER.WALLET_CONNECT || this.state.currentLoginProvider === EXTERNAL_LOGIN_PROVIDER.WAGMI;
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
   }
-  get isIFrameFullScreen() {
-    return this.state.isIFrameFullScreen;
-  }
-
-  /**
-   * Returns whether the inPage provider is connected to Torus.
-   */
-  isConnected() {
-    return this.state.isConnected;
+  if (fns.length === 1) {
+    return fns[0];
   }
-  async initializeState(params) {
-    try {
-      const {
-        torusUrl,
-        torusIframeId
-      } = params;
-      this.iframeUrl = torusUrl;
-      this.iframeId = torusIframeId;
-      const {
-        currentLoginProvider,
-        isLoggedIn
-      } = await this.request({
-        method: base_controllers_namespaceObject.COMMUNICATION_JRPC_METHODS.GET_PROVIDER_STATE,
-        params: []
-      });
+  return function piped(input) {
+    return fns.reduce(function (prev, fn) {
+      return fn(prev);
+    }, input);
+  };
+}
 
-      // indicate that we've connected, for EIP-1193 compliance
-      if (isLoggedIn) this.handleConnect(currentLoginProvider, isLoggedIn);
-    } catch (error) {
-      loglevel.error("Web3Auth: Failed to get initial state. Please report this bug.", error);
-    } finally {
-      loglevel.info("initialized communication state");
-      this.state.initialized = true;
+var Observable = function () {
+  function Observable(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
     }
   }
-  hideTorusButton() {
-    this.state.widgetVisibility = false;
-    this.displayIframe();
-  }
-  showTorusButton() {
-    this.state.widgetVisibility = true;
-    this.displayIframe();
-  }
-  moveToBackground() {
-    this.state.isBackground = true;
-    this.displayIframe({
-      isFull: this.state.isIFrameFullScreen
-    });
-  }
-  moveToForeground() {
-    this.state.isBackground = false;
-    this.displayIframe({
-      isFull: this.state.isIFrameFullScreen
+  Observable.prototype.lift = function (operator) {
+    var observable = new Observable();
+    observable.source = this;
+    observable.operator = operator;
+    return observable;
+  };
+  Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+    var _this = this;
+    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(function () {
+      var _a = _this,
+        operator = _a.operator,
+        source = _a.source;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
     });
-  }
-  setIframeVisibility({
-    isVisible
-  }) {
-    this.state.isBackground = !isVisible;
-  }
-  displayIframe({
-    isFull = false,
-    rid = ""
-  } = {}, walletRequest = false) {
-    const style = {};
-    // set phase
-    if (!isFull) {
-      style.display = this.state.widgetVisibility && !this.state.isBackground ? "block" : "none";
-      style.height = "70px";
-      style.width = "70px";
-      switch (this.state.buttonPosition) {
-        case BUTTON_POSITION.TOP_LEFT:
-          style.top = "0px";
-          style.left = "0px";
-          style.right = "auto";
-          style.bottom = "auto";
-          break;
-        case BUTTON_POSITION.TOP_RIGHT:
-          style.top = "0px";
-          style.right = "0px";
-          style.left = "auto";
-          style.bottom = "auto";
-          break;
-        case BUTTON_POSITION.BOTTOM_RIGHT:
-          style.bottom = "0px";
-          style.right = "0px";
-          style.top = "auto";
-          style.left = "auto";
-          break;
-        case BUTTON_POSITION.BOTTOM_LEFT:
-        default:
-          style.bottom = "0px";
-          style.left = "0px";
-          style.top = "auto";
-          style.right = "auto";
-          break;
-      }
-    } else {
-      style.display = this.state.isBackground ? "none" : "block";
-      style.width = "100%";
-      style.height = "100%";
-      style.top = "0px";
-      style.right = "0px";
-      style.left = "0px";
-      style.bottom = "0px";
-    }
-    const iframe = document.getElementById(this.iframeId);
-    Object.assign(iframe.style, style);
-    this.state.isIFrameFullScreen = isFull;
-    if (!walletRequest) {
-      this.request({
-        method: base_controllers_namespaceObject.COMMUNICATION_JRPC_METHODS.IFRAME_STATUS,
-        params: {
-          isIFrameFullScreen: isFull,
-          rid
-        }
-      });
+    return subscriber;
+  };
+  Observable.prototype._trySubscribe = function (sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
     }
-  }
-
-  /**
-   * Scenarios:
-   * - Login request or pre-open confirmation windows
-   * We try to open here or send a rpc request to iframe that window is blocked.
-   */
-  async handleWindow(windowId, {
-    url,
-    target,
-    features,
-    timeout
-  } = {}) {
-    const finalUrl = new URL(url || `${this.iframeUrl}/redirect?windowId=${windowId}&sessionNamespace=${window.location.hostname}`);
-    const handledWindow = new src_PopupHandler({
-      url: finalUrl,
-      target,
-      features,
-      timeout
-    });
-    handledWindow.open();
-    if (!handledWindow.window) {
-      this.displayIframe({
-        isFull: true
-      });
-      this.request({
-        method: base_controllers_namespaceObject.COMMUNICATION_JRPC_METHODS.WINDOW_BLOCKED,
-        params: {
-          windowId,
-          finalUrl: finalUrl.href
-        }
-      });
-      return;
-    }
-    // Add to collection only if window is opened
-    this.windowRefs.set(windowId, handledWindow);
-    handledWindow.once("close", () => {
-      // user closed the window
-      this.windowRefs.delete(windowId);
-      this.request({
-        method: base_controllers_namespaceObject.COMMUNICATION_JRPC_METHODS.CLOSED_WINDOW,
-        params: {
-          windowId
-        }
+  };
+  Observable.prototype.forEach = function (next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function (resolve, reject) {
+      var subscriber = new SafeSubscriber({
+        next: function (value) {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
       });
+      _this.subscribe(subscriber);
     });
-  }
-
-  /**
-   * Internal RPC method. Forwards requests to background via the RPC engine.
-   * Also remap ids inbound and outbound
-   */
-  rpcRequest(payload, callback) {
-    const cb = callback;
-    const _payload = payload;
-    if (!Array.isArray(_payload)) {
-      if (!_payload.jsonrpc) {
-        _payload.jsonrpc = "2.0";
-      }
+  };
+  Observable.prototype._subscribe = function (subscriber) {
+    var _a;
+    return (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber);
+  };
+  Observable.prototype[observable] = function () {
+    return this;
+  };
+  Observable.prototype.pipe = function () {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
     }
-    this.rpcEngine.handle(_payload, cb);
-  }
+    return pipeFromArray(operations)(this);
+  };
+  Observable.prototype.toPromise = function (promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function (resolve, reject) {
+      var value;
+      _this.subscribe(function (x) {
+        return value = x;
+      }, function (err) {
+        return reject(err);
+      }, function () {
+        return resolve(value);
+      });
+    });
+  };
+  Observable.create = function (subscribe) {
+    return new Observable(subscribe);
+  };
+  return Observable;
+}();
+function getPromiseCtor(promiseCtor) {
+  var _a;
+  return (_a = promiseCtor !== null && promiseCtor !== undefined ? promiseCtor : config.Promise) !== null && _a !== undefined ? _a : Promise;
+}
+function isObserver(value) {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+}
 
-  /**
-   * When the provider becomes connected, updates internal state and emits
-   * required events. Idempotent.
-   *
-   * @param currentLoginProvider - The login Provider
-   * emits TorusInpageProvider#connect
-   */
-  handleConnect(currentLoginProvider, isLoggedIn) {
-    if (!this.state.isConnected) {
-      this.state.isConnected = true;
-      this.emit("connect", {
-        currentLoginProvider,
-        isLoggedIn
+function hasLift(source) {
+  return isFunction(source === null || source === undefined ? undefined : source.lift);
+}
+function operate(init) {
+  return function (source) {
+    if (hasLift(source)) {
+      return source.lift(function (liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
       });
-      loglevel.debug(messages.info.connected(currentLoginProvider));
     }
-  }
+    throw new TypeError('Unable to lift unknown Observable type');
+  };
+}
 
-  /**
-   * 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 TorusInpageProvider#disconnect
-   */
-  handleDisconnect(isRecoverable, errorMessage) {
-    if (this.state.isConnected || !this.state.isPermanentlyDisconnected && !isRecoverable) {
-      this.state.isConnected = false;
-      let error;
-      if (isRecoverable) {
-        error = new external_web3auth_auth_namespaceObject.EthereumProviderError(1013,
-        // Try again later
-        errorMessage || messages.errors.disconnected());
-        loglevel.debug(error);
-      } else {
-        error = new external_web3auth_auth_namespaceObject.EthereumProviderError(1011,
-        // Internal error
-        errorMessage || messages.errors.permanentlyDisconnected());
-        loglevel.error(error);
-        this.state.currentLoginProvider = null;
-        this.state.isLoggedIn = false;
-        this.state.widgetVisibility = false;
-        this.state.isIFrameFullScreen = false;
-        this.state.isPermanentlyDisconnected = true;
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = function (_super) {
+  __extends(OperatorSubscriber, _super);
+  function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+    var _this = _super.call(this, destination) || this;
+    _this.onFinalize = onFinalize;
+    _this.shouldUnsubscribe = shouldUnsubscribe;
+    _this._next = onNext ? function (value) {
+      try {
+        onNext(value);
+      } catch (err) {
+        destination.error(err);
       }
-      this.emit("disconnect", error);
-    }
-  }
-  handleCloseWindow(params) {
-    const {
-      windowId
-    } = params;
-    if (this.windowRefs.has(windowId)) {
-      this.windowRefs.get(windowId).close();
-      this.windowRefs.delete(windowId);
+    } : _super.prototype._next;
+    _this._error = onError ? function (err) {
+      try {
+        onError(err);
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._error;
+    _this._complete = onComplete ? function () {
+      try {
+        onComplete();
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._complete;
+    return _this;
+  }
+  OperatorSubscriber.prototype.unsubscribe = function () {
+    var _a;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var closed_1 = this.closed;
+      _super.prototype.unsubscribe.call(this);
+      !closed_1 && ((_a = this.onFinalize) === null || _a === undefined ? undefined : _a.call(this));
     }
-  }
-}
-defineProperty_default()(CommunicationProvider, "defaultState", {
-  buttonPosition: "bottom-left",
-  currentLoginProvider: null,
-  isIFrameFullScreen: false,
-  isBackground: false,
-  widgetVisibility: false,
-  initialized: false,
-  isLoggedIn: false,
-  isPermanentlyDisconnected: false,
-  isConnected: false,
-  hasEmittedConnection: false
+  };
+  return OperatorSubscriber;
+}(Subscriber);
+
+var ObjectUnsubscribedError = createErrorClass(function (_super) {
+  return function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = 'ObjectUnsubscribedError';
+    this.message = 'object unsubscribed';
+  };
 });
-/* harmony default export */ const src_communicationProvider = (CommunicationProvider);
-;// ../common/src/error.js
-class BaseError extends Error {
-  constructor(name, message, options = {}) {
-    const {
-      cause,
-      context
-    } = options;
-    super(message || name);
+
+var Subject = function (_super) {
+  __extends(Subject, _super);
+  function Subject() {
+    var _this = _super.call(this) || this;
+    _this.closed = false;
+    _this.currentObservers = null;
+    _this.observers = [];
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject.prototype.lift = function (operator) {
+    var subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  };
+  Subject.prototype._throwIfClosed = function () {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+  };
+  Subject.prototype.next = function (value) {
+    var _this = this;
+    errorContext(function () {
+      var e_1, _a;
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        if (!_this.currentObservers) {
+          _this.currentObservers = Array.from(_this.observers);
+        }
+        try {
+          for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var observer = _c.value;
+            observer.next(value);
+          }
+        } catch (e_1_1) {
+          e_1 = {
+            error: e_1_1
+          };
+        } finally {
+          try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      }
+    });
+  };
+  Subject.prototype.error = function (err) {
+    var _this = this;
+    errorContext(function () {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.hasError = _this.isStopped = true;
+        _this.thrownError = err;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().error(err);
+        }
+      }
+    });
+  };
+  Subject.prototype.complete = function () {
+    var _this = this;
+    errorContext(function () {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.isStopped = true;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().complete();
+        }
+      }
+    });
+  };
+  Subject.prototype.unsubscribe = function () {
+    this.isStopped = this.closed = true;
+    this.observers = this.currentObservers = null;
+  };
+  Object.defineProperty(Subject.prototype, "observed", {
+    get: function () {
+      var _a;
+      return ((_a = this.observers) === null || _a === undefined ? undefined : _a.length) > 0;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Subject.prototype._trySubscribe = function (subscriber) {
+    this._throwIfClosed();
+    return _super.prototype._trySubscribe.call(this, subscriber);
+  };
+  Subject.prototype._subscribe = function (subscriber) {
+    this._throwIfClosed();
+    this._checkFinalizedStatuses(subscriber);
+    return this._innerSubscribe(subscriber);
+  };
+  Subject.prototype._innerSubscribe = function (subscriber) {
+    var _this = this;
+    var _a = this,
+      hasError = _a.hasError,
+      isStopped = _a.isStopped,
+      observers = _a.observers;
+    if (hasError || isStopped) {
+      return EMPTY_SUBSCRIPTION;
+    }
+    this.currentObservers = null;
+    observers.push(subscriber);
+    return new Subscription(function () {
+      _this.currentObservers = null;
+      arrRemove(observers, subscriber);
+    });
+  };
+  Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+    var _a = this,
+      hasError = _a.hasError,
+      thrownError = _a.thrownError,
+      isStopped = _a.isStopped;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped) {
+      subscriber.complete();
+    }
+  };
+  Subject.prototype.asObservable = function () {
+    var observable = new Observable();
+    observable.source = this;
+    return observable;
+  };
+  Subject.create = function (destination, source) {
+    return new AnonymousSubject(destination, source);
+  };
+  return Subject;
+}(Observable);
+var AnonymousSubject = function (_super) {
+  __extends(AnonymousSubject, _super);
+  function AnonymousSubject(destination, source) {
+    var _this = _super.call(this) || this;
+    _this.destination = destination;
+    _this.source = source;
+    return _this;
+  }
+  AnonymousSubject.prototype.next = function (value) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.next) === null || _b === undefined ? undefined : _b.call(_a, value);
+  };
+  AnonymousSubject.prototype.error = function (err) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.error) === null || _b === undefined ? undefined : _b.call(_a, err);
+  };
+  AnonymousSubject.prototype.complete = function () {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.complete) === null || _b === undefined ? undefined : _b.call(_a);
+  };
+  AnonymousSubject.prototype._subscribe = function (subscriber) {
+    var _a, _b;
+    return (_b = (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber)) !== null && _b !== undefined ? _b : EMPTY_SUBSCRIPTION;
+  };
+  return AnonymousSubject;
+}(Subject);
+
+var EmptyError = createErrorClass(function (_super) {
+  return function EmptyErrorImpl() {
+    _super(this);
+    this.name = 'EmptyError';
+    this.message = 'no elements in sequence';
+  };
+});
+
+function firstValueFrom(source, config) {
+  return new Promise(function (resolve, reject) {
+    var subscriber = new SafeSubscriber({
+      next: function (value) {
+        resolve(value);
+        subscriber.unsubscribe();
+      },
+      error: reject,
+      complete: function () {
+        {
+          reject(new EmptyError());
+        }
+      }
+    });
+    source.subscribe(subscriber);
+  });
+}
+
+function filter(predicate, thisArg) {
+  return operate(function (source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+      return predicate.call(thisArg, value, index++) && subscriber.next(value);
+    }));
+  });
+}
+
+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.stack = cause?.stack;
     this.cause = cause;
     this.context = context;
   }
@@ -885,1890 +891,1208 @@ class BaseError extends Error {
     };
   }
 }
-function ensureError(value) {
-  if (value instanceof Error) return value;
-  let stringified = "[Unable to stringify the thrown value]";
-  try {
-    stringified = JSON.stringify(value);
-  } catch {
-    // ignoring failed stringify
-  }
-  return new Error(`This value was not thrown as type Error: ${stringified}`);
-}
-;// ./src/error.ts
 
 class AirServiceError extends BaseError {
-  static from(error) {
-    if (error instanceof AirServiceError) {
-      return error;
-    } else if (error instanceof Object && "message" in error) {
-      if (error.message === "User cancelled login") {
-        return new AirServiceError("USER_CANCELLED", error.message);
-      }
-      return new AirServiceError("UNKNOWN_ERROR", error.message.toString());
+    static from(error) {
+        if (error instanceof AirServiceError) {
+            return error;
+        }
+        else if (error instanceof Object && "message" in error) {
+            if (error.message === "User cancelled login") {
+                return new AirServiceError("USER_CANCELLED", error.message);
+            }
+            return new AirServiceError("UNKNOWN_ERROR", error.message.toString());
+        }
+        return new AirServiceError("UNKNOWN_ERROR");
     }
-    return new AirServiceError("UNKNOWN_ERROR");
-  }
 }
-class RealmEmbedError extends AirServiceError {}
-;// external "fast-deep-equal"
-const external_fast_deep_equal_namespaceObject = require("fast-deep-equal");
-var external_fast_deep_equal_default = /*#__PURE__*/__webpack_require__.n(external_fast_deep_equal_namespaceObject);
-;// ./src/inPageProvider.ts
-
-
-
-
-
-
+class RealmEmbedError extends AirServiceError {
+}
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
 
+var loglevel$2 = {exports: {}};
+
+/*
+* loglevel - https://github.com/pimterry/loglevel
+*
+* Copyright (c) 2013 Tim Perry
+* Licensed under the MIT license.
+*/
+var loglevel$1 = loglevel$2.exports;
+var hasRequiredLoglevel;
+function requireLoglevel() {
+  if (hasRequiredLoglevel) return loglevel$2.exports;
+  hasRequiredLoglevel = 1;
+  (function (module) {
+    (function (root, definition) {
+
+      if (module.exports) {
+        module.exports = definition();
+      } else {
+        root.log = definition();
+      }
+    })(loglevel$1, function () {
+
+      // Slightly dubious tricks to cut down minimized file size
+      var noop = function () {};
+      var undefinedType = "undefined";
+      var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
+      var logMethods = ["trace", "debug", "info", "warn", "error"];
+      var _loggersByName = {};
+      var defaultLogger = null;
+
+      // Cross-browser bind equivalent that works at least back to IE6
+      function bindMethod(obj, methodName) {
+        var method = obj[methodName];
+        if (typeof method.bind === 'function') {
+          return method.bind(obj);
+        } else {
+          try {
+            return Function.prototype.bind.call(method, obj);
+          } catch (e) {
+            // Missing bind shim or IE8 + Modernizr, fallback to wrapping
+            return function () {
+              return Function.prototype.apply.apply(method, [obj, arguments]);
+            };
+          }
+        }
+      }
 
-/**
- * @param connectionStream - A Node.js duplex stream
- * @param opts - An options bag
- */
-class AirInPageProvider extends baseProvider {
-  constructor(connectionStream, {
-    maxEventListeners = 100,
-    jsonRpcStreamName = "provider"
-  }) {
-    super(connectionStream, {
-      maxEventListeners,
-      jsonRpcStreamName
-    });
+      // Trace() doesn't print the message in IE, so for that case we need to wrap it
+      function traceForIE() {
+        if (console.log) {
+          if (console.log.apply) {
+            console.log.apply(console, arguments);
+          } else {
+            // In old IE, native console methods themselves don't have apply().
+            Function.prototype.apply.apply(console.log, [console, arguments]);
+          }
+        }
+        if (console.trace) console.trace();
+      }
 
-    // private state
-    /**
-     * The chain ID of the currently connected EVM chain.
-     * See [chainId.network]{@link https://chainid.network} for more information.
-     */
-    defineProperty_default()(this, "chainId", void 0);
-    /**
-     * The user's currently selected EVM address.
-     * If null, Torus is either locked or the user has not permitted any
-     * addresses to be viewed.
-     */
-    defineProperty_default()(this, "selectedAddress", void 0);
-    defineProperty_default()(this, "tryWindowHandle", void 0);
-    this.state = objectSpread2_default()({}, AirInPageProvider.defaultState);
-
-    // public state
-    this.selectedAddress = null;
-    this.chainId = null;
-    this.handleAccountsChanged = this.handleAccountsChanged.bind(this);
-    this.handleChainChanged = this.handleChainChanged.bind(this);
-    this.handleUnlockStateChanged = this.handleUnlockStateChanged.bind(this);
-
-    // setup own event listeners
-
-    // EIP-1193 connect
-    this.on("connect", () => {
-      this.state.isConnected = true;
-    });
-    const jsonRpcNotificationHandler = payload => {
-      const {
-        method,
-        params
-      } = payload;
-      if (method === base_controllers_namespaceObject.PROVIDER_NOTIFICATIONS.ACCOUNTS_CHANGED) {
-        this.handleAccountsChanged(params);
-      } else if (method === base_controllers_namespaceObject.PROVIDER_NOTIFICATIONS.UNLOCK_STATE_CHANGED) {
-        this.handleUnlockStateChanged(params);
-      } else if (method === base_controllers_namespaceObject.PROVIDER_NOTIFICATIONS.CHAIN_CHANGED) {
-        this.handleChainChanged(params);
-      } else if (EMITTED_NOTIFICATIONS.includes(method)) {
-        this.emit("data", payload);
-        this.emit("notification", params.result);
-        this.emit("message", {
-          type: method,
-          data: params
-        });
+      // Build the best logging method possible for this env
+      // Wherever possible we want to bind, not wrap, to preserve stack traces
+      function realMethod(methodName) {
+        if (methodName === 'debug') {
+          methodName = 'log';
+        }
+        if (typeof console === undefinedType) {
+          return false; // No method possible, for now - fixed later by enableLoggingWhenConsoleArrives
+        } else if (methodName === 'trace' && isIE) {
+          return traceForIE;
+        } else if (console[methodName] !== undefined) {
+          return bindMethod(console, methodName);
+        } else if (console.log !== undefined) {
+          return bindMethod(console, 'log');
+        } else {
+          return noop;
+        }
       }
-    };
 
-    // json rpc notification listener
-    this.jsonRpcConnectionEvents.on("notification", jsonRpcNotificationHandler);
-  }
+      // These private functions always need `this` to be set properly
 
-  /**
-   * Returns whether the inpage provider is connected to Torus.
-   */
-  isConnected() {
-    return this.state.isConnected;
-  }
+      function replaceLoggingMethods() {
+        /*jshint validthis:true */
+        var level = this.getLevel();
 
-  // Private Methods
-  //= ===================
-  /**
-   * Constructor helper.
-   * Populates initial state by calling 'wallet_getProviderState' and emits
-   * necessary events.
-   */
-  async initializeState() {
-    try {
-      const {
-        accounts,
-        chainId,
-        isUnlocked
-      } = await this.request({
-        method: base_controllers_namespaceObject.PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE,
-        params: []
-      });
+        // Replace the actual methods.
+        for (var i = 0; i < logMethods.length; i++) {
+          var methodName = logMethods[i];
+          this[methodName] = i < level ? noop : this.methodFactory(methodName, level, this.name);
+        }
 
-      // indicate that we've connected, for EIP-1193 compliance
-      this.emit("connect", {
-        chainId
-      });
-      this.handleChainChanged({
-        chainId
-      });
-      this.handleUnlockStateChanged({
-        accounts,
-        isUnlocked
-      });
-      this.handleAccountsChanged(accounts);
-    } catch (error) {
-      loglevel.error("WsEmbed: Failed to get initial state. Please report this bug.", error);
-    } finally {
-      loglevel.info("initialized provider state");
-      this.state.initialized = true;
-    }
-  }
+        // Define log.log as an alias for log.debug
+        this.log = this.debug;
 
-  /**
-   * Internal RPC method. Forwards requests to background via the RPC engine.
-   * Also remap ids inbound and outbound
-   */
-  rpcRequest(payload, callback, isInternal = false) {
-    let cb = callback;
-    const _payload = payload;
-    if (!Array.isArray(_payload)) {
-      if (!_payload.jsonrpc) {
-        _payload.jsonrpc = "2.0";
+        // Return any important warnings.
+        if (typeof console === undefinedType && level < this.levels.SILENT) {
+          return "No console available for logging";
+        }
       }
-      if (_payload.method === "eth_accounts" || _payload.method === "eth_requestAccounts") {
-        // handle accounts changing
-        cb = (err, res) => {
-          this.handleAccountsChanged(res.result || [], _payload.method === "eth_accounts", isInternal);
-          callback(err, res);
+
+      // In old IE versions, the console isn't present until you first open it.
+      // We build realMethod() replacements here that regenerate logging methods
+      function enableLoggingWhenConsoleArrives(methodName) {
+        return function () {
+          if (typeof console !== undefinedType) {
+            replaceLoggingMethods.call(this);
+            this[methodName].apply(this, arguments);
+          }
         };
-      } else if (_payload.method === "wallet_getProviderState") {
-        this.rpcEngine.handle(payload, cb);
-        return;
       }
-    }
-    this.tryWindowHandle(_payload, cb);
-  }
-
-  /**
-   * When the provider becomes connected, updates internal state and emits
-   * required events. Idempotent.
-   *
-   * @param chainId - The ID of the newly connected chain.
-   * emits TorusInpageProvider#connect
-   */
-  handleConnect(chainId) {
-    if (!this.state.isConnected) {
-      this.state.isConnected = true;
-      this.emit("connect", {
-        chainId
-      });
-      loglevel.debug(messages.info.connected(chainId));
-    }
-  }
 
-  /**
-   * 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 TorusInpageProvider#disconnect
-   */
-  handleDisconnect(isRecoverable, errorMessage) {
-    if (this.state.isConnected || !this.state.isPermanentlyDisconnected && !isRecoverable) {
-      this.state.isConnected = false;
-      let error;
-      if (isRecoverable) {
-        error = new external_web3auth_auth_namespaceObject.EthereumProviderError(1013,
-        // Try again later
-        errorMessage || messages.errors.disconnected());
-        loglevel.debug(error);
-      } else {
-        error = new external_web3auth_auth_namespaceObject.EthereumProviderError(1011,
-        // Internal error
-        errorMessage || messages.errors.permanentlyDisconnected());
-        loglevel.error(error);
-        this.chainId = null;
-        this.state.accounts = null;
-        this.selectedAddress = null;
-        this.state.isUnlocked = false;
-        this.state.isPermanentlyDisconnected = true;
+      // By default, we use closely bound real methods wherever possible, and
+      // otherwise we wait for a console to appear, and then try again.
+      function defaultMethodFactory(methodName, _level, _loggerName) {
+        /*jshint validthis:true */
+        return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
       }
-      this.emit("disconnect", error);
-    }
-  }
+      function Logger(name, factory) {
+        // Private instance variables.
+        var self = this;
+        /**
+         * The level inherited from a parent logger (or a global default). We
+         * cache this here rather than delegating to the parent so that it stays
+         * in sync with the actual logging methods that we have installed (the
+         * parent could change levels but we might not have rebuilt the loggers
+         * in this child yet).
+         * @type {number}
+         */
+        var inheritedLevel;
+        /**
+         * The default level for this logger, if any. If set, this overrides
+         * `inheritedLevel`.
+         * @type {number|null}
+         */
+        var defaultLevel;
+        /**
+         * A user-specific level for this logger. If set, this overrides
+         * `defaultLevel`.
+         * @type {number|null}
+         */
+        var userLevel;
+        var storageKey = "loglevel";
+        if (typeof name === "string") {
+          storageKey += ":" + name;
+        } else if (typeof name === "symbol") {
+          storageKey = undefined;
+        }
+        function persistLevelIfPossible(levelNum) {
+          var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
+          if (typeof window === undefinedType || !storageKey) return;
 
-  /**
-   * Called when accounts may have changed.
-   */
-  handleAccountsChanged(accounts, isEthAccounts = false, isInternal = false) {
-    // defensive programming
-    let finalAccounts = accounts;
-    if (!Array.isArray(finalAccounts)) {
-      loglevel.error("WsEmbed: Received non-array accounts parameter. Please report this bug.", finalAccounts);
-      finalAccounts = [];
-    }
-    for (const account of accounts) {
-      if (typeof account !== "string") {
-        loglevel.error("WsEmbed: Received non-string account. Please report this bug.", accounts);
-        finalAccounts = [];
-        break;
-      }
-    }
+          // Use localStorage if available
+          try {
+            window.localStorage[storageKey] = levelName;
+            return;
+          } catch (ignore) {}
 
-    // emit accountsChanged if anything about the accounts array has changed
-    if (!external_fast_deep_equal_default()(this.state.accounts, finalAccounts)) {
-      // we should always have the correct accounts even before eth_accounts
-      // returns, except in cases where isInternal is true
-      if (isEthAccounts && Array.isArray(this.state.accounts) && this.state.accounts.length > 0 && !isInternal) {
-        loglevel.error('WsEmbed: "eth_accounts" unexpectedly updated accounts. Please report this bug.', finalAccounts);
-      }
-      this.state.accounts = finalAccounts;
-      this.emit("accountsChanged", finalAccounts);
-    }
+          // Use session cookie as fallback
+          try {
+            window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
+          } catch (ignore) {}
+        }
+        function getPersistedLevel() {
+          var storedLevel;
+          if (typeof window === undefinedType || !storageKey) return;
+          try {
+            storedLevel = window.localStorage[storageKey];
+          } catch (ignore) {}
+
+          // Fallback to cookies if local storage gives us nothing
+          if (typeof storedLevel === undefinedType) {
+            try {
+              var cookie = window.document.cookie;
+              var cookieName = encodeURIComponent(storageKey);
+              var location = cookie.indexOf(cookieName + "=");
+              if (location !== -1) {
+                storedLevel = /^([^;]+)/.exec(cookie.slice(location + cookieName.length + 1))[1];
+              }
+            } catch (ignore) {}
+          }
 
-    // handle selectedAddress
-    if (this.selectedAddress !== finalAccounts[0]) {
-      this.selectedAddress = finalAccounts[0] || null;
-    }
-  }
+          // If the stored level is not valid, treat it as if nothing was stored.
+          if (self.levels[storedLevel] === undefined) {
+            storedLevel = undefined;
+          }
+          return storedLevel;
+        }
+        function clearPersistedLevel() {
+          if (typeof window === undefinedType || !storageKey) return;
 
-  /**
-   * Upon receipt of a new chainId and networkVersion, emits corresponding
-   * events and sets relevant public state.
-   * Does nothing if neither the chainId nor the networkVersion are different
-   * from existing values.
-   *
-   * emits TorusInpageProvider#chainChanged
-   * @param networkInfo - An object with network info.
-   */
-  handleChainChanged({
-    chainId
-  } = {}) {
-    if (!chainId) {
-      loglevel.error("WsEmbed: Received invalid network parameters. Please report this bug.", {
-        chainId
-      });
-      return;
-    }
-    if (chainId === "loading") {
-      this.handleDisconnect(true);
-    } else {
-      this.handleConnect(chainId);
-      if (chainId !== this.chainId) {
-        this.chainId = chainId;
-        if (this.state.initialized) {
-          this.emit("chainChanged", this.chainId);
+          // Use localStorage if available
+          try {
+            window.localStorage.removeItem(storageKey);
+          } catch (ignore) {}
+
+          // Use session cookie as fallback
+          try {
+            window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+          } catch (ignore) {}
+        }
+        function normalizeLevel(input) {
+          var level = input;
+          if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
+            level = self.levels[level.toUpperCase()];
+          }
+          if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
+            return level;
+          } else {
+            throw new TypeError("log.setLevel() called with invalid level: " + input);
+          }
         }
-      }
-    }
-  }
 
-  /**
-   * Upon receipt of a new isUnlocked state, sets relevant public state.
-   * Calls the accounts changed handler with the received accounts, or an empty
-   * array.
-   *
-   * Does nothing if the received value is equal to the existing value.
-   * There are no lock/unlock events.
-   *
-   * @param opts - Options bag.
-   */
-  handleUnlockStateChanged({
-    accounts,
-    isUnlocked
-  } = {}) {
-    if (typeof isUnlocked !== "boolean") {
-      loglevel.error("WsEmbed: Received invalid isUnlocked parameter. Please report this bug.", {
-        isUnlocked
-      });
-      return;
-    }
-    if (isUnlocked !== this.state.isUnlocked) {
-      this.state.isUnlocked = isUnlocked;
-      this.handleAccountsChanged(accounts || []);
-    }
-  }
-}
-defineProperty_default()(AirInPageProvider, "defaultState", {
-  accounts: null,
-  isConnected: false,
-  isUnlocked: false,
-  initialized: false,
-  isPermanentlyDisconnected: false,
-  hasEmittedConnection: false
-});
-/* harmony default export */ const inPageProvider = (AirInPageProvider);
-class TorusInPageProvider extends AirInPageProvider {}
-;// external "rxjs"
-const external_rxjs_namespaceObject = require("rxjs");
-;// ./src/messageService.ts
+        /*
+         *
+         * Public logger API - see https://github.com/pimterry/loglevel for details
+         *
+         */
+
+        self.name = name;
+        self.levels = {
+          "TRACE": 0,
+          "DEBUG": 1,
+          "INFO": 2,
+          "WARN": 3,
+          "ERROR": 4,
+          "SILENT": 5
+        };
+        self.methodFactory = factory || defaultMethodFactory;
+        self.getLevel = function () {
+          if (userLevel != null) {
+            return userLevel;
+          } else if (defaultLevel != null) {
+            return defaultLevel;
+          } else {
+            return inheritedLevel;
+          }
+        };
+        self.setLevel = function (level, persist) {
+          userLevel = normalizeLevel(level);
+          if (persist !== false) {
+            // defaults to true
+            persistLevelIfPossible(userLevel);
+          }
 
-var _AirMessageService;
+          // NOTE: in v2, this should call rebuild(), which updates children.
+          return replaceLoggingMethods.call(self);
+        };
+        self.setDefaultLevel = function (level) {
+          defaultLevel = normalizeLevel(level);
+          if (!getPersistedLevel()) {
+            self.setLevel(level, false);
+          }
+        };
+        self.resetLevel = function () {
+          userLevel = null;
+          clearPersistedLevel();
+          replaceLoggingMethods.call(self);
+        };
+        self.enableAll = function (persist) {
+          self.setLevel(self.levels.TRACE, persist);
+        };
+        self.disableAll = function (persist) {
+          self.setLevel(self.levels.SILENT, persist);
+        };
+        self.rebuild = function () {
+          if (defaultLogger !== self) {
+            inheritedLevel = normalizeLevel(defaultLogger.getLevel());
+          }
+          replaceLoggingMethods.call(self);
+          if (defaultLogger === self) {
+            for (var childName in _loggersByName) {
+              _loggersByName[childName].rebuild();
+            }
+          }
+        };
 
+        // Initialize all the internal levels.
+        inheritedLevel = normalizeLevel(defaultLogger ? defaultLogger.getLevel() : "WARN");
+        var initialLevel = getPersistedLevel();
+        if (initialLevel != null) {
+          userLevel = normalizeLevel(initialLevel);
+        }
+        replaceLoggingMethods.call(self);
+      }
 
+      /*
+       *
+       * Top-level API
+       *
+       */
 
+      defaultLogger = new Logger();
+      defaultLogger.getLogger = function getLogger(name) {
+        if (typeof name !== "symbol" && typeof name !== "string" || name === "") {
+          throw new TypeError("You must supply a name when creating a logger.");
+        }
+        var logger = _loggersByName[name];
+        if (!logger) {
+          logger = _loggersByName[name] = new Logger(name, defaultLogger.methodFactory);
+        }
+        return logger;
+      };
 
+      // Grab the current global log variable in case of overwrite
+      var _log = typeof window !== undefinedType ? window.log : undefined;
+      defaultLogger.noConflict = function () {
+        if (typeof window !== undefinedType && window.log === defaultLogger) {
+          window.log = _log;
+        }
+        return defaultLogger;
+      };
+      defaultLogger.getLoggers = function getLoggers() {
+        return _loggersByName;
+      };
 
+      // ES6 default export, for compatibility
+      defaultLogger['default'] = defaultLogger;
+      return defaultLogger;
+    });
+  })(loglevel$2);
+  return loglevel$2.exports;
+}
 
-const REALM_EMBED_MESSAGES = [AirMessageTypes.LOGIN_CLAIM_STATE, AirMessageTypes.CLOSE_MODAL, AirMessageTypes.SERVICE_INITIALIZED, AirMessageTypes.SERVICE_INITIALIZED_ERROR, AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE, AirMessageTypes.EXECUTE_ACTION_RESPONSE, AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE, AirMessageTypes.GRANT_PERMISSIONS_RESPONSE];
-const AUTH_EMBED_MESSAGES = [AirAuthMessageTypes.LOGIN_RESPONSE, AirAuthMessageTypes.USER_INFO_RESPONSE, AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE, AirAuthMessageTypes.REFRESH_TOKEN_RESPONSE, AirAuthMessageTypes.INITIALIZATION_RESPONSE, AirAuthMessageTypes.LOGOUT_RESPONSE, AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST, AirAuthMessageTypes.SETUP_WALLET_REQUEST];
+var loglevelExports = requireLoglevel();
+var loglevel = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
+
+var log = loglevel.getLogger("airkit");
+
+var AirWalletProviderMessageTypes;
+(function (AirWalletProviderMessageTypes) {
+  AirWalletProviderMessageTypes["REQUEST"] = "JRPC_REQUEST";
+  AirWalletProviderMessageTypes["RESPONSE"] = "JRPC_RESPONSE";
+})(AirWalletProviderMessageTypes || (AirWalletProviderMessageTypes = {}));
+
+const ACCOUNT_MESSAGES = [
+    AirMessageTypes.INITIALIZATION_RESPONSE,
+    AirMessageTypes.WALLET_INITIALIZED,
+    AirMessageTypes.CLAIM_ID_RESPONSE,
+    AirMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_RESPONSE,
+    AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE,
+    AirMessageTypes.EXECUTE_ACTION_RESPONSE,
+    AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE,
+    AirMessageTypes.GRANT_PERMISSIONS_RESPONSE,
+    AirMessageTypes.WALLET_INITIALIZED,
+    AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST,
+    AirMessageTypes.LOGOUT_RESPONSE,
+];
+const AUTH_MESSAGES = [
+    AirAuthMessageTypes.INITIALIZATION_RESPONSE,
+    AirAuthMessageTypes.LOGIN_RESPONSE,
+    AirAuthMessageTypes.REFRESH_TOKEN_RESPONSE,
+    AirAuthMessageTypes.SETUP_WALLET_REQUEST,
+    AirAuthMessageTypes.LOGOUT_RESPONSE,
+    AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
+    AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
+];
 class AirMessageService {
-  constructor() {
-    defineProperty_default()(this, "airMessages$", void 0);
-    defineProperty_default()(this, "_loginState$", void 0);
-    defineProperty_default()(this, "_authMessage$", void 0);
-    defineProperty_default()(this, "_authIframe", null);
-    defineProperty_default()(this, "closeAuthMessageListeners", null);
-    defineProperty_default()(this, "closeRealmMessageListeners", null);
-  }
-  static get instance() {
-    if (!AirMessageService._instance) {
-      AirMessageService._instance = new AirMessageService();
+    constructor() {
+        this.closeAuthMessageListeners = null;
+        this.closeRealmMessageListeners = null;
+        this.closeWalletMessageListeners = null;
     }
-    return AirMessageService._instance;
-  }
-  get messages$() {
-    return this.airMessages$.asObservable();
-  }
-  get loginState$() {
-    return this._loginState$;
-  }
-  get authMessage$() {
-    return this._authMessage$.asObservable();
-  }
-  async openAuthObservables({
-    authIframeOrigin
-  }) {
-    this.closeAuthObservables();
-    this.setupAuthObservables();
-    const handleAuthMessage = async ev => {
-      if (ev.origin !== authIframeOrigin || !ev.data || !(ev.data instanceof Object)) return;
-      loglevel.debug("Embed auth message received from auth", ev.data);
-      if (AUTH_EMBED_MESSAGES.includes(ev.data.type)) {
-        this._authMessage$.next(ev.data);
-      }
-    };
-    window.addEventListener("message", handleAuthMessage);
-    this.closeAuthMessageListeners = () => {
-      window.removeEventListener("message", handleAuthMessage);
-    };
-  }
-  async openRealmObservables({
-    walletIframeOrigin
-  }) {
-    this.closeRealmObservables();
-    this.setupRealmObservables();
-    const handleMessage = async ev => {
-      if (ev.origin !== walletIframeOrigin || !ev.data || !(ev.data instanceof Object)) return;
-      // filter out torus and communication provider messages
-      if ("target" in ev.data && (ev.data.target === "embed_torus" || ev.data.target === "embed_communication")) return;
-      loglevel.debug("Embed realm message received from wallet", ev.data);
-      if (REALM_EMBED_MESSAGES.includes(ev.data.type)) {
-        this.airMessages$.next(ev.data);
-      }
-    };
-    window.addEventListener("message", handleMessage);
-    this.closeRealmMessageListeners = () => {
-      window.removeEventListener("message", handleMessage);
-    };
-  }
-
-  // Note: Only use when embed is needed in airAuth
-  setupAuthIframe(authIframe) {
-    this._authIframe = authIframe;
-  }
-  setupIframeCommunication(walletIframe) {
-    if (!this._authIframe) return;
-    const channel = new MessageChannel();
-    const authOrigin = new URL(this._authIframe.src).origin;
-    this._authIframe.contentWindow.postMessage({
-      type: AirAuthMessageTypes.INIT_WALLET_COMMUNICATION
-    }, authOrigin, [channel.port1]);
-    const walletOrigin = new URL(walletIframe.src).origin;
-    walletIframe.contentWindow.postMessage({
-      type: AirMessageTypes.INIT_AUTH_COMMUNICATION
-    }, walletOrigin, [channel.port2]);
-    this._authIframe = undefined;
-  }
-  onInitialized() {
-    return (0,external_rxjs_namespaceObject.firstValueFrom)(this.messages$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirMessageTypes.SERVICE_INITIALIZED)));
-  }
-  sendLoginRequest(walletIframe, payload) {
-    const response = (0,external_rxjs_namespaceObject.lastValueFrom)(this.loginState$.pipe((0,external_rxjs_namespaceObject.takeWhile)(msg => (!payload.skipClaimFlow || msg.payload.state !== "connected") && msg.payload.state !== "logged_in" && msg.payload.state !== "claim_flow_cancelled", true), (0,external_rxjs_namespaceObject.tap)(msg => {
-      switch (msg.payload.state) {
-        case "claim_flow_cancelled":
-          throw new RealmEmbedError(msg.payload.errorName, msg.payload.errorMessage);
-        default:
-          break;
-      }
-    })));
-    const {
-      origin
-    } = new URL(walletIframe.src);
-    walletIframe.contentWindow.postMessage({
-      type: AirMessageTypes.LOGIN_REQUEST,
-      payload
-    }, origin);
-    return response;
-  }
-  sendClaimRequest(walletIframe, options) {
-    const response = (0,external_rxjs_namespaceObject.lastValueFrom)((0,external_rxjs_namespaceObject.forkJoin)([this.loginState$.pipe((0,external_rxjs_namespaceObject.takeWhile)(msg => !["logged_in", "claim_flow_cancelled"].includes(msg.payload.state), true), (0,external_rxjs_namespaceObject.tap)(msg => {
-      if (msg.payload.state === "claim_flow_cancelled") {
-        throw new RealmEmbedError(msg.payload.errorName, msg.payload.errorMessage);
-      }
-    }), (0,external_rxjs_namespaceObject.last)()), this.messages$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirMessageTypes.CLOSE_MODAL), (0,external_rxjs_namespaceObject.first)())]));
-    const {
-      origin
-    } = new URL(walletIframe.src);
-    walletIframe.contentWindow.postMessage({
-      type: AirMessageTypes.CLAIM_REQUEST,
-      payload: {
-        token: options === null || options === void 0 ? void 0 : options.token,
-        claimInBackground: options === null || options === void 0 ? void 0 : options.background
-      }
-    }, origin);
-    return response;
-  }
-  async sendGrantPermissionRequest(walletIframe, policies) {
-    const response = (0,external_rxjs_namespaceObject.firstValueFrom)(this.messages$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
-    const {
-      origin
-    } = new URL(walletIframe.src);
-    walletIframe.contentWindow.postMessage({
-      type: AirMessageTypes.GRANT_PERMISSIONS_REQUEST,
-      payload: {
-        policies
-      }
-    }, origin);
-    const result = await response;
-    if (result.payload.success === false) {
-      throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+    static get instance() {
+        if (!AirMessageService._instance) {
+            AirMessageService._instance = new AirMessageService();
+        }
+        return AirMessageService._instance;
     }
-    return result.payload.sessionData;
-  }
-  async sendExecuteActionRequest(walletIframe, params) {
-    const response = (0,external_rxjs_namespaceObject.firstValueFrom)(this.messages$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirMessageTypes.EXECUTE_ACTION_RESPONSE)));
-    const {
-      origin
-    } = new URL(walletIframe.src);
-    walletIframe.contentWindow.postMessage({
-      type: AirMessageTypes.EXECUTE_ACTION_REQUEST,
-      payload: {
-        sessionData: params.sessionData,
-        call: {
-          to: params.call.to,
-          value: params.call.value,
-          data: params.call.data
-        },
-        sessionOwnerPrivateKey: params.sessionOwnerPrivateKey
-      }
-    }, origin);
-    const result = await response;
-    if (result.payload.success === false) {
-      throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+    get messages$() {
+        return this.airMessages$.asObservable();
     }
-    return result.payload.txHash;
-  }
-  async sendRevokePermissionsRequest(walletIframe, permissionId) {
-    const response = (0,external_rxjs_namespaceObject.firstValueFrom)(this.messages$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE)));
-    const {
-      origin
-    } = new URL(walletIframe.src);
-    walletIframe.contentWindow.postMessage({
-      type: AirMessageTypes.REVOKE_PERMISSIONS_REQUEST,
-      payload: {
-        permissionId
-      }
-    }, origin);
-    const result = await response;
-    if (result.payload.success === false) {
-      throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+    get authMessage$() {
+        return this._authMessage$.asObservable();
     }
-    return result.payload.txHash;
-  }
-  sendDeploySmartAccountRequest(walletIframe) {
-    const response = (0,external_rxjs_namespaceObject.firstValueFrom)(this.messages$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE)));
-    const {
-      origin
-    } = new URL(walletIframe.src);
-    walletIframe.contentWindow.postMessage({
-      type: AirMessageTypes.DEPLOY_SMART_ACCOUNT_REQUEST
-    }, origin);
-    return response;
-  }
-  async sendUserInfoRequest(authIframe) {
-    const response = (0,external_rxjs_namespaceObject.firstValueFrom)(this.authMessage$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirAuthMessageTypes.USER_INFO_RESPONSE)));
-    const {
-      origin
-    } = new URL(authIframe.src);
-    authIframe.contentWindow.postMessage({
-      type: AirAuthMessageTypes.USER_INFO_REQUEST
-    }, origin);
-    return response;
-  }
-  async sendPartnerUserInfoRequest(authIframe) {
-    const response = (0,external_rxjs_namespaceObject.firstValueFrom)(this.authMessage$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE)));
-    const {
-      origin
-    } = new URL(authIframe.src);
-    authIframe.contentWindow.postMessage({
-      type: AirAuthMessageTypes.PARTNER_USER_INFO_REQUEST
-    }, origin);
-    return response;
-  }
-  async sendAuthLoginRequest(authIframe, payload) {
-    const response = (0,external_rxjs_namespaceObject.firstValueFrom)(this.authMessage$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirAuthMessageTypes.LOGIN_RESPONSE)));
-    const {
-      origin
-    } = new URL(authIframe.src);
-    authIframe.contentWindow.postMessage({
-      type: AirAuthMessageTypes.LOGIN_REQUEST,
-      payload
-    }, origin);
-    return response;
-  }
-  async logoutAuth(authIframe) {
-    const response = (0,external_rxjs_namespaceObject.firstValueFrom)(this.authMessage$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirAuthMessageTypes.LOGOUT_RESPONSE)));
-    const {
-      origin
-    } = new URL(authIframe.src);
-    authIframe.contentWindow.postMessage({
-      type: AirAuthMessageTypes.LOGOUT_REQUEST
-    }, origin);
-    return response;
-  }
-  async waitForAuthInitialization() {
-    const response = await (0,external_rxjs_namespaceObject.firstValueFrom)(this._authMessage$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirAuthMessageTypes.INITIALIZATION_RESPONSE)));
-    if (response.payload.success === false) {
-      throw new RealmEmbedError(response.payload.errorName, response.payload.errorMessage);
+    get providerMessage$() {
+        return this._providerMessage$.asObservable();
     }
-    return response.payload;
-  }
-  async waitForWalletInitialization() {
-    const response = await (0,external_rxjs_namespaceObject.firstValueFrom)(this.messages$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirMessageTypes.SERVICE_INITIALIZED || msg.type === AirMessageTypes.SERVICE_INITIALIZED_ERROR)));
-    if (response.type === AirMessageTypes.SERVICE_INITIALIZED_ERROR) {
-      throw new RealmEmbedError(response.payload.errorName, response.payload.errorMessage);
+    async openAuthObservables({ authIframeOrigin }) {
+        this.closeAuthObservables();
+        this.setupAuthObservables();
+        const handleAuthMessage = async (ev) => {
+            if (ev.origin !== authIframeOrigin || !ev.data || !(ev.data instanceof Object))
+                return;
+            log.debug("Embed auth message received from auth", ev.data);
+            if (AUTH_MESSAGES.includes(ev.data.type)) {
+                this._authMessage$.next(ev.data);
+            }
+        };
+        window.addEventListener("message", handleAuthMessage);
+        this.closeAuthMessageListeners = () => {
+            window.removeEventListener("message", handleAuthMessage);
+        };
     }
-  }
-  closeAuthObservables() {
-    if (this._authMessage$ && !this._authMessage$.closed) this._authMessage$.complete();
-    if (this.closeAuthMessageListeners) this.closeAuthMessageListeners();
-  }
-  closeRealmObservables() {
-    if (this.airMessages$ && !this.airMessages$.closed) this.airMessages$.complete();
-    if (this.closeRealmMessageListeners) this.closeRealmMessageListeners();
-  }
-  setupAuthObservables() {
-    this._authMessage$ = new external_rxjs_namespaceObject.Subject();
-  }
-  setupRealmObservables() {
-    this.airMessages$ = new external_rxjs_namespaceObject.Subject();
-    this._loginState$ = this.airMessages$.pipe((0,external_rxjs_namespaceObject.filter)(msg => msg.type === AirMessageTypes.LOGIN_CLAIM_STATE), (0,external_rxjs_namespaceObject.distinctUntilChanged)((external_fast_deep_equal_default())));
-  }
-}
-_AirMessageService = AirMessageService;
-// eslint-disable-next-line no-use-before-define
-defineProperty_default()(AirMessageService, "_instance", void 0);
-/* harmony default export */ const messageService = (AirMessageService.instance);
-;// ./src/siteMetadata.ts
-/**
- * Returns whether the given image URL exists
- * @param url - the url of the image
- * @returns whether the image exists
- */
-function imgExists(url) {
-  return new Promise((resolve, reject) => {
-    try {
-      const img = document.createElement("img");
-      img.onload = () => resolve(true);
-      img.onerror = () => resolve(false);
-      img.src = url;
-    } catch (e) {
-      reject(e);
+    async openWalletObservables({ walletIframeOrigin }) {
+        this.closeAirObservables();
+        this.setupAirObservables();
+        const handleMessage = async (ev) => {
+            if (ev.origin !== walletIframeOrigin || !ev.data || !(ev.data instanceof Object))
+                return;
+            log.debug("Account messages received from wallet frontend", ev.data);
+            if (ACCOUNT_MESSAGES.includes(ev.data.type)) {
+                this.airMessages$.next(ev.data);
+            }
+        };
+        window.addEventListener("message", handleMessage);
+        this.closeRealmMessageListeners = () => {
+            window.removeEventListener("message", handleMessage);
+        };
+        this.closeWalletObservables();
+        this.setupWalletObservables();
+        const handleWalletMessage = async (ev) => {
+            if (ev.origin !== walletIframeOrigin || !ev.data || !(ev.data instanceof Object))
+                return;
+            log.debug("Wallet provider messages received from wallet frontend", ev.data);
+            if (ev.data.type === AirWalletProviderMessageTypes.RESPONSE) {
+                this._providerMessage$.next(ev.data);
+            }
+        };
+        window.addEventListener("message", handleWalletMessage);
+        this.closeWalletMessageListeners = () => {
+            window.removeEventListener("message", handleWalletMessage);
+        };
     }
-  });
-}
-
-/**
- * Extracts a name for the site from the DOM
- */
-const getSiteName = window => {
-  const {
-    document
-  } = window;
-  const siteName = document.querySelector('head > meta[property="og:site_name"]');
-  if (siteName) {
-    return siteName.content;
-  }
-  const metaTitle = document.querySelector('head > meta[name="title"]');
-  if (metaTitle) {
-    return metaTitle.content;
-  }
-  if (document.title && document.title.length > 0) {
-    return document.title;
-  }
-  return window.location.hostname;
-};
-
-/**
- * Extracts an icon for the site from the DOM
- */
-async function getSiteIcon(window) {
-  try {
-    const {
-      document
-    } = window;
-
-    // Use the site's favicon if it exists
-    let icon = document.querySelector('head > link[rel="shortcut icon"]');
-    if (icon && (await imgExists(icon.href))) {
-      return icon.href;
+    setupIframeCommunication(authIframe, walletIframe) {
+        const channel = new MessageChannel();
+        const authOrigin = new URL(authIframe.src).origin;
+        authIframe.contentWindow.postMessage({
+            type: AirAuthMessageTypes.INIT_WALLET_COMMUNICATION,
+        }, authOrigin, [channel.port1]);
+        const walletOrigin = new URL(walletIframe.src).origin;
+        walletIframe.contentWindow.postMessage({
+            type: AirMessageTypes.INIT_AUTH_COMMUNICATION,
+        }, walletOrigin, [channel.port2]);
     }
-
-    // Search through available icons in no particular order
-    icon = Array.from(document.querySelectorAll('head > link[rel="icon"]')).find(_icon => Boolean(_icon.href));
-    if (icon && (await imgExists(icon.href))) {
-      return icon.href;
+    async sendGrantPermissionRequest(walletIframe, policies) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
+        const { origin } = new URL(walletIframe.src);
+        walletIframe.contentWindow.postMessage({
+            type: AirMessageTypes.GRANT_PERMISSIONS_REQUEST,
+            payload: {
+                policies,
+            },
+        }, origin);
+        const result = await response;
+        if (result.payload.success === false) {
+            throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+        }
+        return result.payload.sessionData;
     }
-    return "";
-  } catch (error) {
-    return "";
-  }
-}
-
-/**
- * Gets site metadata and returns it
- *
- */
-const getSiteMetadata = async () => ({
-  name: getSiteName(window),
-  icon: await getSiteIcon(window)
-});
-/* harmony default export */ const siteMetadata = (getSiteMetadata);
-;// ./src/embed.ts
-
-
-
-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"); }
-
-
-
-
-
-
-
-
-
-
-
-
-
-// preload for iframe doesn't work https://bugs.chromium.org/p/chromium/issues/detail?id=593267
-(async function preLoadIframe() {
-  try {
-    if (typeof document === "undefined") return;
-    const airWalletIframeHtml = document.createElement("link");
-    const {
-      walletUrl: airWalletUrl
-    } = AIR_URLS.production;
-    airWalletIframeHtml.href = `${airWalletUrl}/frame`;
-    airWalletIframeHtml.crossOrigin = "anonymous";
-    airWalletIframeHtml.type = "text/html";
-    airWalletIframeHtml.rel = "prefetch";
-    if (airWalletIframeHtml.relList && airWalletIframeHtml.relList.supports) {
-      if (airWalletIframeHtml.relList.supports("prefetch")) {
-        document.head.appendChild(airWalletIframeHtml);
-      }
+    async sendExecuteActionRequest(walletIframe, params) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.EXECUTE_ACTION_RESPONSE)));
+        const { origin } = new URL(walletIframe.src);
+        walletIframe.contentWindow.postMessage({
+            type: AirMessageTypes.EXECUTE_ACTION_REQUEST,
+            payload: {
+                sessionData: params.sessionData,
+                call: {
+                    to: params.call.to,
+                    value: params.call.value,
+                    data: params.call.data,
+                },
+                sessionOwnerPrivateKey: params.sessionOwnerPrivateKey,
+            },
+        }, origin);
+        const result = await response;
+        if (result.payload.success === false) {
+            throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+        }
+        return result.payload.txHash;
     }
-  } catch (error) {
-    loglevel.warn(error);
-  }
-})();
-const COMMUNICATION_UNSAFE_METHODS = new Set([base_controllers_namespaceObject.COMMUNICATION_JRPC_METHODS.SET_PROVIDER]);
-const PROVIDER_UNSAFE_METHODS = new Set([ethereum_controllers_namespaceObject.METHOD_TYPES.ETH_SIGN, ethereum_controllers_namespaceObject.METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4, ethereum_controllers_namespaceObject.METHOD_TYPES.PERSONAL_SIGN, ethereum_controllers_namespaceObject.METHOD_TYPES.ETH_TRANSACTION, ethereum_controllers_namespaceObject.METHOD_TYPES.ADD_CHAIN, ethereum_controllers_namespaceObject.METHOD_TYPES.SWITCH_CHAIN]);
-const embedChainConfig = {
-  polygon: {
-    chainNamespace: base_controllers_namespaceObject.CHAIN_NAMESPACES.EIP155,
-    chainId: "0x89",
-    decimals: 18,
-    displayName: "Polygon",
-    blockExplorerUrl: "https://polygonscan.com",
-    logo: "https://cryptologos.cc/logos/polygon-matic-logo.png",
-    ticker: "MATIC",
-    tickerName: "Matic Network Token"
-  },
-  polygonAmoy: {
-    chainNamespace: base_controllers_namespaceObject.CHAIN_NAMESPACES.EIP155,
-    chainId: "0x13882",
-    decimals: 18,
-    displayName: "Polygon Amoy",
-    blockExplorerUrl: "https://amoy.polygonscan.com",
-    logo: "https://cryptologos.cc/logos/polygon-matic-logo.png",
-    ticker: "MATIC",
-    tickerName: "Matic Network Token",
-    isTestnet: true
-  }
-};
-const web3AuthClientId = "BANbxuTYFGeYi8HxUzaPQkvQlSAXiKRtUqb1vqsXbsZsZKrNr05PEPCM2J2PhUJZpIYl0XzQa6jxUjnYzSU9LXY";
-const web3AuthNetwork = external_web3auth_auth_namespaceObject.WEB3AUTH_NETWORK.SAPPHIRE_MAINNET;
-var _embedNonce = /*#__PURE__*/new WeakMap();
-var _provider = /*#__PURE__*/new WeakMap();
-var _isInitialized = /*#__PURE__*/new WeakMap();
-var _rehydrationState = /*#__PURE__*/new WeakMap();
-var _modalZIndex = /*#__PURE__*/new WeakMap();
-var _communicationProvider = /*#__PURE__*/new WeakMap();
-var _buttonPosition = /*#__PURE__*/new WeakMap();
-var _realmPartnerId = /*#__PURE__*/new WeakMap();
-var _web3AuthClientId = /*#__PURE__*/new WeakMap();
-var _web3AuthNetwork = /*#__PURE__*/new WeakMap();
-var _isPluginMode = /*#__PURE__*/new WeakMap();
-var _confirmationStrategy = /*#__PURE__*/new WeakMap();
-var _walletIframe = /*#__PURE__*/new WeakMap();
-var _buildEnv = /*#__PURE__*/new WeakMap();
-var _walletAddresses = /*#__PURE__*/new WeakMap();
-var _realmId = /*#__PURE__*/new WeakMap();
-var _loginToken = /*#__PURE__*/new WeakMap();
-var _sessionId = /*#__PURE__*/new WeakMap();
-var _embedListeners = /*#__PURE__*/new WeakMap();
-var _RealmEmbed_brand = /*#__PURE__*/new WeakSet();
-class RealmEmbed {
-  constructor({
-    modalZIndex = 99999,
-    partnerId
-  }) {
-    classPrivateMethodInitSpec_default()(this, _RealmEmbed_brand);
-    classPrivateFieldInitSpec_default()(this, _embedNonce, (0,base_controllers_namespaceObject.randomId)());
-    classPrivateFieldInitSpec_default()(this, _provider, void 0);
-    classPrivateFieldInitSpec_default()(this, _isInitialized, void 0);
-    classPrivateFieldInitSpec_default()(this, _rehydrationState, void 0);
-    classPrivateFieldInitSpec_default()(this, _modalZIndex, void 0);
-    classPrivateFieldInitSpec_default()(this, _communicationProvider, void 0);
-    classPrivateFieldInitSpec_default()(this, _buttonPosition, void 0);
-    classPrivateFieldInitSpec_default()(this, _realmPartnerId, void 0);
-    classPrivateFieldInitSpec_default()(this, _web3AuthClientId, void 0);
-    classPrivateFieldInitSpec_default()(this, _web3AuthNetwork, void 0);
-    classPrivateFieldInitSpec_default()(this, _isPluginMode, void 0);
-    classPrivateFieldInitSpec_default()(this, _confirmationStrategy, void 0);
-    classPrivateFieldInitSpec_default()(this, _walletIframe, void 0);
-    classPrivateFieldInitSpec_default()(this, _buildEnv, void 0);
-    classPrivateFieldInitSpec_default()(this, _walletAddresses, void 0);
-    classPrivateFieldInitSpec_default()(this, _realmId, void 0);
-    classPrivateFieldInitSpec_default()(this, _loginToken, void 0);
-    classPrivateFieldInitSpec_default()(this, _sessionId, void 0);
-    classPrivateFieldInitSpec_default()(this, _embedListeners, []);
-    _classPrivateFieldSet(_isInitialized, this, false); // init done
-    _classPrivateFieldSet(_modalZIndex, this, modalZIndex);
-    _classPrivateFieldSet(_realmPartnerId, this, partnerId);
-    _classPrivateFieldSet(_web3AuthClientId, this, web3AuthClientId);
-    _classPrivateFieldSet(_web3AuthNetwork, this, web3AuthNetwork);
-  }
-  get isConnected() {
-    return !!_classPrivateFieldGet(_walletAddresses, this) && _classPrivateFieldGet(_communicationProvider, this).isLoggedIn;
-  }
-  get isInitialized() {
-    return _classPrivateFieldGet(_isInitialized, this) && !!_classPrivateFieldGet(_rehydrationState, this);
-  }
-  get isLoggedIn() {
-    return !!_classPrivateFieldGet(_realmId, this) && this.isConnected;
-  }
-  get getBuildEnv() {
-    return _classPrivateFieldGet(_buildEnv, this);
-  }
-  get walletAddresses() {
-    var _classPrivateFieldGet2;
-    return (_classPrivateFieldGet2 = _classPrivateFieldGet(_walletAddresses, this)) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : null;
-  }
-  get sessionId() {
-    var _classPrivateFieldGet3;
-    return (_classPrivateFieldGet3 = _classPrivateFieldGet(_sessionId, this)) !== null && _classPrivateFieldGet3 !== void 0 ? _classPrivateFieldGet3 : null;
-  }
-  get realmId() {
-    var _classPrivateFieldGet4;
-    return (_classPrivateFieldGet4 = _classPrivateFieldGet(_realmId, this)) !== null && _classPrivateFieldGet4 !== void 0 ? _classPrivateFieldGet4 : null;
-  }
-  get provider() {
-    return _classPrivateFieldGet(_walletAddresses, this) ? _classPrivateFieldGet(_provider, this) : null;
-  }
-  async init({
-    buildEnv = EMBED_BUILD_ENV.PRODUCTION,
-    enableLogging = false,
-    skipRehydration = false
-    // confirmationStrategy = CONFIRMATION_STRATEGY.DEFAULT,
-  } = {}) {
-    if (_classPrivateFieldGet(_isInitialized, this)) throw new RealmEmbedError("ALREADY_INITIALISED", "Already initialized");
-    _classPrivateFieldSet(_buildEnv, this, buildEnv);
-    _classPrivateFieldSet(_confirmationStrategy, this, base_controllers_namespaceObject.CONFIRMATION_STRATEGY.DEFAULT);
-    _classPrivateFieldSet(_buttonPosition, this, base_controllers_namespaceObject.BUTTON_POSITION.BOTTOM_LEFT);
-    const {
-      walletUrl,
-      logLevel
-    } = AIR_URLS[buildEnv];
-    loglevel.info(walletUrl, "url loaded");
-    loglevel.setDefaultLevel(logLevel);
-    if (enableLogging) loglevel.enableAll();else loglevel.disableAll();
-    const walletIframeUrl = _assertClassBrand(_RealmEmbed_brand, this, _getWsIframeUrl).call(this);
-    const walletIframeOrigin = walletIframeUrl.origin;
-    messageService.openRealmObservables({
-      walletIframeOrigin
-    });
-    _classPrivateFieldSet(_walletIframe, this, htmlToElement(`<iframe
-        id="walletIframe-${_classPrivateFieldGet(_embedNonce, this)}"
-        class="walletIframe-${_classPrivateFieldGet(_embedNonce, this)}"
-        sandbox="allow-popups allow-scripts allow-same-origin allow-forms allow-modals allow-downloads"
-        src="${walletIframeUrl.href}"
-        style="display: none; position: fixed; top: 0; right: 0; width: 100%; color-scheme: none; border-width: 0px; height: 100%; border: none; border-radius: 0; z-index: ${_classPrivateFieldGet(_modalZIndex, this).toString()}"
-        allow="clipboard-write"
-      ></iframe>`));
-    messageService.messages$.subscribe(msg => {
-      switch (msg.type) {
-        case AirMessageTypes.SERVICE_INITIALIZED:
-          {
-            _classPrivateFieldSet(_rehydrationState, this, msg.payload.rehydration);
-            _assertClassBrand(_RealmEmbed_brand, this, _triggerInitializedEvent).call(this);
-            break;
-          }
-      }
-    });
-    messageService.loginState$.subscribe(async msg => {
-      switch (msg.payload.state) {
-        case "connected":
-          {
-            await _assertClassBrand(_RealmEmbed_brand, this, _onInitialized).call(this);
-            if (msg.payload.addresses && !this.isLoggedIn) {
-              _classPrivateFieldSet(_walletAddresses, this, msg.payload.addresses);
-              _classPrivateFieldSet(_loginToken, this, msg.payload.token);
-              _classPrivateFieldSet(_sessionId, this, msg.payload.sessionId);
-              _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
-                event: "connected",
-                result: {
-                  isLoggedIn: false,
-                  addresses: msg.payload.addresses,
-                  token: msg.payload.token,
-                  sessionId: msg.payload.sessionId
-                }
-              });
-            }
-            break;
-          }
-        case "logged_in":
-          {
-            await _assertClassBrand(_RealmEmbed_brand, this, _onInitialized).call(this);
-            const isNotConnectedYet = !_classPrivateFieldGet(_walletAddresses, this);
-            _classPrivateFieldSet(_realmId, this, msg.payload.airId);
-            _classPrivateFieldSet(_walletAddresses, this, msg.payload.addresses);
-            _classPrivateFieldSet(_loginToken, this, msg.payload.token);
-            _classPrivateFieldSet(_sessionId, this, msg.payload.sessionId);
-            if (isNotConnectedYet) {
-              _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
-                event: "connected",
-                result: {
-                  isLoggedIn: false,
-                  addresses: msg.payload.addresses,
-                  token: msg.payload.token,
-                  sessionId: msg.payload.sessionId
-                }
-              });
-            }
-            _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
-              event: "logged_in",
-              result: {
-                isLoggedIn: true,
-                realmId: msg.payload.airId,
-                addresses: msg.payload.addresses,
-                token: msg.payload.token,
-                sessionId: msg.payload.sessionId
-              }
-            });
-            break;
-          }
-        case "minting_started":
-          {
-            _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
-              event: "minting_started"
-            });
-            break;
-          }
-        case "minting_failed":
-          {
-            _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
-              event: "minting_failed",
-              errorMessage: msg.payload.errorMessage
-            });
-            break;
-          }
-      }
-    });
-    try {
-      // Handle wallet iframe message
-      window.document.body.appendChild(_classPrivateFieldGet(_walletIframe, this));
-      const initializeWalletService = new Promise((resolve, reject) => {
-        const handleMessage = async ev => {
-          try {
-            if (ev.origin !== walletIframeOrigin) return;
-            if (ev.data === base_controllers_namespaceObject.SETUP_COMPLETE) {
-              window.removeEventListener("message", handleMessage);
-              // send init params here
-              const dappMetadata = await siteMetadata();
-              _classPrivateFieldGet(_walletIframe, this).contentWindow.postMessage({
-                chainConfig: _classPrivateFieldGet(_buildEnv, this) === EMBED_BUILD_ENV.PRODUCTION ? embedChainConfig.polygon : embedChainConfig.polygonAmoy,
-                dappMetadata,
-                enableLogging,
-                skipRehydration,
-                realmPartnerId: _classPrivateFieldGet(_realmPartnerId, this),
-                web3AuthClientId: _classPrivateFieldGet(_web3AuthClientId, this),
-                web3AuthNetwork: _classPrivateFieldGet(_web3AuthNetwork, this),
-                confirmationStrategy: _classPrivateFieldGet(_confirmationStrategy, this)
-              }, walletIframeOrigin);
-              await _assertClassBrand(_RealmEmbed_brand, this, _setupWeb).call(this, {
-                torusUrl: walletUrl
-              });
-              _classPrivateFieldGet(_communicationProvider, this).onLoginStateHandle = async isLoggedIn => {
-                if (!isLoggedIn) {
-                  await _assertClassBrand(_RealmEmbed_brand, this, _logout).call(this);
-                }
-              };
-              resolve();
-            }
-          } catch (err) {
-            reject(err);
-          }
-        };
-        window.addEventListener("message", handleMessage);
-      });
-      const walletServiceInitialization = messageService.waitForWalletInitialization();
-      await Promise.all([initializeWalletService, walletServiceInitialization]);
-      messageService.setupIframeCommunication(_classPrivateFieldGet(_walletIframe, this));
-      _classPrivateFieldSet(_isInitialized, this, true);
-      _assertClassBrand(_RealmEmbed_brand, this, _triggerInitializedEvent).call(this);
-      loglevel.debug("Wallet service initialization resolved");
-    } catch (error) {
-      loglevel.debug("Wallet service initialization error", error);
-      _assertClassBrand(_RealmEmbed_brand, this, _clearInit).call(this, true);
-      throw error;
+    async sendRevokePermissionsRequest(walletIframe, permissionId) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE)));
+        const { origin } = new URL(walletIframe.src);
+        walletIframe.contentWindow.postMessage({
+            type: AirMessageTypes.REVOKE_PERMISSIONS_REQUEST,
+            payload: {
+                permissionId,
+            },
+        }, origin);
+        const result = await response;
+        if (result.payload.success === false) {
+            throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+        }
+        return result.payload.txHash;
     }
-  }
-  moveToBackground() {
-    _classPrivateFieldGet(_communicationProvider, this).moveToBackground();
-  }
-  moveToForeground() {
-    _classPrivateFieldGet(_communicationProvider, this).moveToForeground();
-  }
-  async getUserInfo() {
-    if (!_classPrivateFieldGet(_realmId, this)) return null;
-    const userInfoResponse = await _classPrivateFieldGet(_communicationProvider, this).request({
-      method: base_controllers_namespaceObject.COMMUNICATION_JRPC_METHODS.USER_INFO,
-      params: []
-    });
-    return objectSpread2_default()(objectSpread2_default()({}, userInfoResponse), {}, {
-      realmId: _classPrivateFieldGet(_realmId, this)
-    });
-  }
-  async login(options) {
-    var _options$legacy;
-    return _assertClassBrand(_RealmEmbed_brand, this, _login).call(this, options, (_options$legacy = options === null || options === void 0 ? void 0 : options.legacy) !== null && _options$legacy !== void 0 ? _options$legacy : true);
-  }
-  async _deploySmartAccount() {
-    if (!this.isConnected) throw new RealmEmbedError("NOT_LOGGED_IN", "User needs to be connected first");
-    try {
-      await messageService.sendDeploySmartAccountRequest(_classPrivateFieldGet(_walletIframe, this));
-    } catch (error) {
-      throw RealmEmbedError.from(error);
+    sendDeploySmartAccountRequest(walletIframe) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE)));
+        const { origin } = new URL(walletIframe.src);
+        walletIframe.contentWindow.postMessage({
+            type: AirMessageTypes.DEPLOY_SMART_ACCOUNT_REQUEST,
+        }, origin);
+        return response;
     }
-  }
-  async _grantPermission(policies) {
-    if (!this.isConnected) throw new RealmEmbedError("NOT_LOGGED_IN", "User needs to be connected first");
-    try {
-      return await messageService.sendGrantPermissionRequest(_classPrivateFieldGet(_walletIframe, this), policies);
-    } catch (error) {
-      throw RealmEmbedError.from(error);
+    async sendIsSmartAccountDeployedRequest(walletIframe) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_RESPONSE)));
+        const { origin } = new URL(walletIframe.src);
+        walletIframe.contentWindow.postMessage({
+            type: AirMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_REQUEST,
+        }, origin);
+        return response;
     }
-  }
-  async _executeAction(params) {
-    return messageService.sendExecuteActionRequest(_classPrivateFieldGet(_walletIframe, this), params);
-  }
-  async _revokePermission(permissionId) {
-    return messageService.sendRevokePermissionsRequest(_classPrivateFieldGet(_walletIframe, this), permissionId);
-  }
-
-  // async loginV2<T extends boolean>(options?: {
-  //   skipClaiming: T;
-  //   token?: string;
-  // }): Promise<T extends true ? RealmLoginResult | RealmConnectResult : RealmLoginResult> {
-  //   if (!this.#isInitialized) throw new Error("Call init() first");
-
-  //   const iframeController = this.#authIframeController;
-  //   iframeController.setIframeVisibility(true);
-  //   iframeController.updateIframeState();
-
-  //   const { payload } = await RealmMessageService.sendAuthLoginRequest(iframeController.iframeElement);
-
-  //   iframeController.setIframeVisibility(false);
-  //   iframeController.updateIframeState();
-
-  //   if (payload.success === true) {
-  //     return this.#login({
-  //       skipClaiming: options?.skipClaiming,
-  //       token: options?.token,
-  //     });
-  //   }
-  //   throw new RealmEmbedError(payload.errorName, payload.errorMessage);
-  // }
-
-  // This is for internal use only
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  async _loginWithSessionId(params) {
-    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Call init() first");
-    if (!params.sessionId) throw new Error("sessionId is required");
-    try {
-      const res = await _classPrivateFieldGet(_communicationProvider, this).request({
-        method: base_controllers_namespaceObject.COMMUNICATION_JRPC_METHODS.LOGIN_WITH_SESSION_ID,
-        params: [params.sessionId, ""]
-      });
-      loglevel.info("Login with session id", res);
-      return res.success;
-    } catch (error) {
-      loglevel.error("login with session id failed", error);
-      throw error;
+    async sendPartnerUserInfoRequest(authIframe) {
+        const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE)));
+        const { origin } = new URL(authIframe.src);
+        authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.PARTNER_USER_INFO_REQUEST }, origin);
+        return response;
     }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  async _showWalletWidget() {
-    _classPrivateFieldGet(_communicationProvider, this).showTorusButton();
-  }
-  async claimRealmId(options) {
-    if (!this.isConnected) throw new RealmEmbedError("NOT_CONNECTED", "User needs to be connected first");
-    try {
-      if (options !== null && options !== void 0 && options.background) {
-        _classPrivateFieldGet(_communicationProvider, this).setIframeVisibility({
-          isVisible: false
-        });
-      }
-      _classPrivateFieldGet(_communicationProvider, this).displayIframe({
-        isFull: true
-      });
-      const claimPromise = messageService.sendClaimRequest(_classPrivateFieldGet(_walletIframe, this), options);
-      loglevel.debug("before claimPromise");
-      await claimPromise;
-      loglevel.debug("after claimPromise");
-      return {
-        isLoggedIn: true,
-        realmId: _classPrivateFieldGet(_realmId, this),
-        addresses: _classPrivateFieldGet(_walletAddresses, this),
-        token: _classPrivateFieldGet(_loginToken, this),
-        sessionId: _classPrivateFieldGet(_sessionId, this)
-      };
-    } catch (e) {
-      throw RealmEmbedError.from(e);
-    } finally {
-      if (options !== null && options !== void 0 && options.background) {
-        _classPrivateFieldGet(_communicationProvider, this).setIframeVisibility({
-          isVisible: true
-        });
-      }
-      _classPrivateFieldGet(_communicationProvider, this).displayIframe({
-        isFull: false
-      });
+    async sendAuthLoginRequest(authIframe, payload) {
+        const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LOGIN_RESPONSE)));
+        const { origin } = new URL(authIframe.src);
+        authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.LOGIN_REQUEST, payload }, origin);
+        return response;
     }
-  }
-  async logout() {
-    if (!_classPrivateFieldGet(_communicationProvider, this).isLoggedIn) throw new RealmEmbedError("NOT_LOGGED_IN", "Not logged in");
-    await _assertClassBrand(_RealmEmbed_brand, this, _logout).call(this);
-  }
-  async cleanUp() {
-    var _classPrivateFieldGet5;
-    if ((_classPrivateFieldGet5 = _classPrivateFieldGet(_communicationProvider, this)) !== null && _classPrivateFieldGet5 !== void 0 && _classPrivateFieldGet5.isLoggedIn) {
-      await this.logout();
+    async logoutAuth(authIframe) {
+        const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LOGOUT_RESPONSE)));
+        const { origin } = new URL(authIframe.src);
+        authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.LOGOUT_REQUEST }, origin);
+        return response;
     }
-    await this.clearInit();
-  }
-  async clearInit() {
-    _assertClassBrand(_RealmEmbed_brand, this, _clearInit).call(this);
-  }
-  on(listener) {
-    if (_classPrivateFieldGet(_embedListeners, this).indexOf(listener) < 0) _classPrivateFieldGet(_embedListeners, this).push(listener);
-  }
-  off(listener) {
-    const index = _classPrivateFieldGet(_embedListeners, this).indexOf(listener);
-    if (index >= 0) _classPrivateFieldGet(_embedListeners, this).splice(index, 1);
-  }
-  clearEventListeners() {
-    _classPrivateFieldSet(_embedListeners, this, []);
-  }
-}
-function _getWsIframeUrl() {
-  const {
-    walletUrl
-  } = AIR_URLS[_classPrivateFieldGet(_buildEnv, this)];
-  const torusIframeUrl = new URL(walletUrl);
-  if (torusIframeUrl.pathname.endsWith("/")) torusIframeUrl.pathname += "frame";else torusIframeUrl.pathname += "/frame";
-  const hashParams = new URLSearchParams();
-  hashParams.append("origin", window.location.origin);
-  torusIframeUrl.hash = hashParams.toString();
-  return torusIframeUrl;
-}
-async function _login(options, isLegacyLogin) {
-  let loginResult;
-  if (this.isLoggedIn) {
-    loginResult = _assertClassBrand(_RealmEmbed_brand, this, _createLoginResult).call(this);
-  } else if (this.isConnected) {
-    if ((options === null || options === void 0 ? void 0 : options.skipClaiming) === true) {
-      loginResult = _assertClassBrand(_RealmEmbed_brand, this, _createLoginResult).call(this);
-    } else {
-      loginResult = await this.claimRealmId(options);
+    async logoutWallet(walletIframe) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.LOGOUT_RESPONSE)));
+        const { origin } = new URL(walletIframe.src);
+        walletIframe.contentWindow.postMessage({ type: AirMessageTypes.LOGOUT_REQUEST }, origin);
+        return response;
     }
-  } else {
-    loginResult = await _assertClassBrand(_RealmEmbed_brand, this, _realmLogin).call(this, options, isLegacyLogin);
-  }
-  return loginResult;
-}
-function _createLoginResult() {
-  if (this.isLoggedIn) {
-    return {
-      isLoggedIn: true,
-      realmId: _classPrivateFieldGet(_realmId, this),
-      addresses: _classPrivateFieldGet(_walletAddresses, this),
-      token: _classPrivateFieldGet(_loginToken, this),
-      sessionId: _classPrivateFieldGet(_sessionId, this)
-    };
-  }
-  return {
-    isLoggedIn: false,
-    addresses: _classPrivateFieldGet(_walletAddresses, this),
-    token: _classPrivateFieldGet(_loginToken, this),
-    sessionId: _classPrivateFieldGet(_sessionId, this)
-  };
-}
-async function _authLogin(params = {}) {
-  try {
-    if (!params.loginProvider || params.loginProvider === EXTERNAL_LOGIN_PROVIDER.WALLET_CONNECT) {
-      _classPrivateFieldGet(_communicationProvider, this).displayIframe({
-        isFull: true
-      });
+    async sendAuthInitializationRequest(authIframe, payload) {
+        const response = firstValueFrom(this._authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.INITIALIZATION_RESPONSE)));
+        const { origin } = new URL(authIframe.src);
+        authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.INITIALIZATION_REQUEST, payload }, origin);
+        return response;
     }
-
-    // If user is already logged in, we assume they have given access to the website
-    const res = await new Promise((resolve, reject) => {
-      // We use this method because we want to update inPage provider state with account info
-      _classPrivateFieldGet(_provider, this).rpcRequest({
-        method: "eth_requestAccounts",
-        params: [params.loginProvider, params.login_hint]
-      }, (0,external_web3auth_auth_namespaceObject.getRpcPromiseCallback)(resolve, reject));
-    });
-    loglevel.debug("check: res", res);
-    if (Array.isArray(res) && res.length > 0) {
-      if (_classPrivateFieldGet(_confirmationStrategy, this) === base_controllers_namespaceObject.CONFIRMATION_STRATEGY.AUTO_APPROVE) loglevel.warn("Confirmation strategy auto approve is not allowed on Embed Mode, using Default instead.");
-      return res;
+    async sendWalletInitializationRequest(walletIframe, payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.INITIALIZATION_RESPONSE)));
+        const { origin } = new URL(walletIframe.src);
+        walletIframe.contentWindow.postMessage({ type: AirMessageTypes.INITIALIZATION_REQUEST, payload }, origin);
+        return response;
     }
-    // This would never happen, but just in case
-    throw new Error("Login failed");
-  } catch (error) {
-    loglevel.error("login failed", error);
-    throw error;
-  }
-}
-async function _realmLogin(options, isLegacyLogin) {
-  const skipClaimFlow = (options === null || options === void 0 ? void 0 : options.skipClaiming) === true;
-  try {
-    if (options !== null && options !== void 0 && options.authToken) {
-      _classPrivateFieldGet(_communicationProvider, this).setIframeVisibility({
-        isVisible: false
-      });
+    async sendGrantPermissionsRequest(walletIframe, payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
+        const { origin } = new URL(walletIframe.src);
+        walletIframe.contentWindow.postMessage({ type: AirMessageTypes.GRANT_PERMISSIONS_REQUEST, payload }, origin);
+        return response;
     }
-    const loginPromise = Promise.all([_assertClassBrand(_RealmEmbed_brand, this, _authLogin).call(this), messageService.sendLoginRequest(_classPrivateFieldGet(_walletIframe, this), {
-      skipClaimFlow,
-      token: options === null || options === void 0 ? void 0 : options.token,
-      customAuthToken: options === null || options === void 0 ? void 0 : options.authToken,
-      isLegacyLogin: !!isLegacyLogin
-    })]);
-    loglevel.debug("start logging in...");
-    await loginPromise;
-    loglevel.debug("login ended");
-    return _assertClassBrand(_RealmEmbed_brand, this, _createLoginResult).call(this);
-  } catch (e) {
-    await _assertClassBrand(_RealmEmbed_brand, this, _logout).call(this);
-    throw RealmEmbedError.from(e);
-  } finally {
-    if (options !== null && options !== void 0 && options.authToken) {
-      _classPrivateFieldGet(_communicationProvider, this).setIframeVisibility({
-        isVisible: true
-      });
+    onWalletInitialized() {
+        return firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.WALLET_INITIALIZED)));
+    }
+    async sendClaimIdRequest(walletIframe, payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.CLAIM_ID_RESPONSE)));
+        const { origin } = new URL(walletIframe.src);
+        walletIframe.contentWindow.postMessage({ type: AirMessageTypes.CLAIM_ID_REQUEST, payload }, origin);
+        return response;
+    }
+    async sendWalletProviderRequest(walletIframe, payload) {
+        const response = firstValueFrom(this.providerMessage$.pipe(filter((msg) => msg.type === AirWalletProviderMessageTypes.RESPONSE &&
+            msg.payload.requestId === payload.requestId)));
+        const { origin } = new URL(walletIframe.src);
+        walletIframe.contentWindow.postMessage({
+            type: AirWalletProviderMessageTypes.REQUEST,
+            payload,
+        }, origin);
+        return response;
+    }
+    closeAuthObservables() {
+        if (this._authMessage$ && !this._authMessage$.closed)
+            this._authMessage$.complete();
+        if (this.closeAuthMessageListeners)
+            this.closeAuthMessageListeners();
+    }
+    closeAirObservables() {
+        if (this.airMessages$ && !this.airMessages$.closed)
+            this.airMessages$.complete();
+        if (this.closeRealmMessageListeners)
+            this.closeRealmMessageListeners();
+    }
+    closeWalletObservables() {
+        if (this._providerMessage$ && !this._providerMessage$.closed)
+            this._providerMessage$.complete();
+        if (this.closeWalletMessageListeners)
+            this.closeWalletMessageListeners();
+    }
+    setupAuthObservables() {
+        this._authMessage$ = new Subject();
+    }
+    setupAirObservables() {
+        this.airMessages$ = new Subject();
+    }
+    setupWalletObservables() {
+        this._providerMessage$ = new Subject();
     }
-    _classPrivateFieldGet(_communicationProvider, this).displayIframe({
-      isFull: false
-    });
-  }
-}
-async function _logout() {
-  var _classPrivateFieldGet6;
-  const silent = !_classPrivateFieldGet(_walletAddresses, this);
-  if ((_classPrivateFieldGet6 = _classPrivateFieldGet(_communicationProvider, this)) !== null && _classPrivateFieldGet6 !== void 0 && _classPrivateFieldGet6.isLoggedIn) {
-    await _classPrivateFieldGet(_communicationProvider, this).request({
-      method: base_controllers_namespaceObject.COMMUNICATION_JRPC_METHODS.LOGOUT,
-      params: []
-    });
-  }
-  if (_classPrivateFieldGet(_communicationProvider, this)) _classPrivateFieldGet(_communicationProvider, this).onLoginStateHandle = undefined;
-  _classPrivateFieldSet(_walletAddresses, this, undefined);
-  _classPrivateFieldSet(_realmId, this, undefined);
-  if (!silent) {
-    _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
-      event: "logged_out"
-    });
-  }
 }
-async function _clearInit(isSilent) {
-  function isElement(element) {
-    return element instanceof Element || element instanceof Document;
-  }
-  if (isElement(_classPrivateFieldGet(_walletIframe, this)) && window.document.body.contains(_classPrivateFieldGet(_walletIframe, this))) {
-    _classPrivateFieldGet(_walletIframe, this).remove();
-    _classPrivateFieldSet(_walletIframe, this, undefined);
+var AirMessageService$1 = AirMessageService.instance;
+
+class ProviderRpcError extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
   }
-  messageService.closeRealmObservables();
-  _classPrivateFieldSet(_isInitialized, this, false);
-  _classPrivateFieldSet(_walletAddresses, this, undefined);
-  _classPrivateFieldSet(_realmId, this, undefined);
-  if (isSilent === true) _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
-    event: "reset"
-  });
 }
-function _getConfirmationStrategyFinal(payload, communicationProvider) {
-  // for external wallets, we'll show the modal and don't need to open a new window
-  let confirmationStrategyFinal = _classPrivateFieldGet(_confirmationStrategy, this);
-  if (!Array.isArray(payload) && PROVIDER_UNSAFE_METHODS.has(payload.method) && _classPrivateFieldGet(_confirmationStrategy, this) !== base_controllers_namespaceObject.CONFIRMATION_STRATEGY.MODAL && !_classPrivateFieldGet(_isPluginMode, this) && !communicationProvider.isExternalWallet) {
-    confirmationStrategyFinal = base_controllers_namespaceObject.CONFIRMATION_STRATEGY.POPUP;
+new ProviderRpcError("Invalid JSON", -32700);
+const ProviderRpcInvalidRequestError = new ProviderRpcError("Invalid request", -32600);
+const ProviderRpcMethodNotFoundError = new ProviderRpcError("Method not found", -32601);
+const ProviderRpcInvalidParamsError = new ProviderRpcError("Invalid params", -32602);
+new ProviderRpcError("Internal error", -32603);
+new ProviderRpcError("User rejected request", 4001);
+new ProviderRpcError("Unauthorized", 4100);
+new ProviderRpcError("Unsupported method", 4200);
+new ProviderRpcError("Disconnected", 4900);
+new ProviderRpcError("Chain Disconnected", 4901);
+function ensureProviderRpcError(value) {
+  if (value instanceof ProviderRpcError) return value;
+  let stringified = "[Unable to stringify the thrown value]";
+  try {
+    stringified = JSON.stringify(value);
+  } catch {
+    // ignoring failed stringify
   }
-  return confirmationStrategyFinal;
+  return new ProviderRpcError(`This value was not thrown as type ProviderRpcError: ${stringified}`, -32603);
 }
-async function _setupWeb(providerParams) {
-  loglevel.debug("setup embed communication...");
-  // setup background connection
-  const providerStream = new external_web3auth_auth_namespaceObject.BasePostMessageStream({
-    name: "embed_torus",
-    target: "iframe_torus",
-    targetWindow: _classPrivateFieldGet(_walletIframe, this).contentWindow,
-    targetOrigin: new URL(providerParams.torusUrl).origin
-  });
 
-  // We create another LocalMessageDuplexStream for communication between dapp <> iframe
-  const communicationStream = new external_web3auth_auth_namespaceObject.BasePostMessageStream({
-    name: "embed_communication",
-    target: "iframe_communication",
-    targetWindow: _classPrivateFieldGet(_walletIframe, this).contentWindow,
-    targetOrigin: new URL(providerParams.torusUrl).origin
-  });
+const BUILD_ENV = {
+    PRODUCTION: "production",
+    STAGING: "staging",
+    DEVELOPMENT: "development",
+};
 
-  // compose the inPage provider
-  const inPageProvider = new TorusInPageProvider(providerStream, {});
-  const communicationProvider = new src_communicationProvider(communicationStream, {}, {
-    buttonPosition: _classPrivateFieldGet(_buttonPosition, this)
-  });
-  inPageProvider.tryWindowHandle = (payload, cb) => {
-    const _payload = payload;
-    const confirmationStrategyFinal = _assertClassBrand(_RealmEmbed_brand, this, _getConfirmationStrategyFinal).call(this, payload, communicationProvider);
-    if (confirmationStrategyFinal === base_controllers_namespaceObject.CONFIRMATION_STRATEGY.POPUP) {
-      const windowId = (0,base_controllers_namespaceObject.randomId)();
-      communicationProvider.handleWindow(windowId, {
-        target: "_blank",
-        features: (0,base_controllers_namespaceObject.getPopupFeatures)(base_controllers_namespaceObject.FEATURES_CONFIRM_WINDOW),
-        timeout: 500
-      });
-      // for inPageProvider methods sending windowId in request instead of params
-      // as params might be positional.
-      _payload.windowId = windowId;
-    }
-    inPageProvider.rpcEngine.handle(_payload, cb);
-  };
-  communicationProvider.tryWindowHandle = (payload, cb) => {
-    const _payload = payload;
-    const confirmationStrategyFinal = _assertClassBrand(_RealmEmbed_brand, this, _getConfirmationStrategyFinal).call(this, payload, communicationProvider);
-    if (confirmationStrategyFinal === base_controllers_namespaceObject.CONFIRMATION_STRATEGY.POPUP) {
-      const windowId = (0,base_controllers_namespaceObject.randomId)();
-      communicationProvider.handleWindow(windowId, {
-        target: "_blank",
-        features: (0,base_controllers_namespaceObject.getPopupFeatures)(base_controllers_namespaceObject.FEATURES_PROVIDER_CHANGE_WINDOW),
-        // todo: are these features generic for all
-        timeout: 500
-      });
-      // for communication methods sending window id in jrpc req params
-      _payload.params.windowId = windowId;
+const AIR_URLS = {
+    [BUILD_ENV.DEVELOPMENT]: {
+        authUrl: "http://localhost:8100",
+        walletUrl: "http://localhost:8200",
+        legacyWalletUrl: "https://localhost:4050",
+        logLevel: "debug",
+    },
+    [BUILD_ENV.STAGING]: {
+        authUrl: "https://auth.staging.air3.com",
+        walletUrl: "https://account.staging.air3.com",
+        legacyWalletUrl: "https://account.staging.realmnetwork.io",
+        logLevel: "info",
+    },
+    [BUILD_ENV.PRODUCTION]: {
+        authUrl: "https://auth.air3.com",
+        walletUrl: "https://account.air3.com",
+        legacyWalletUrl: "https://account.realmnetwork.io",
+        logLevel: "error",
+    },
+};
+const isElement = (element) => element instanceof Element || element instanceof Document;
+const randomId = () => Math.random().toString(36).slice(2);
+
+var _AirWalletProvider_walletIframe;
+class AirWalletProvider {
+    constructor(walletIframe) {
+        _AirWalletProvider_walletIframe.set(this, undefined);
+        __classPrivateFieldSet(this, _AirWalletProvider_walletIframe, walletIframe, "f");
     }
-    communicationProvider.rpcEngine.handle(_payload, cb);
-  };
-
-  // detect eth_requestAccounts and pipe to enable for now
-  const detectAccountRequestPrototypeModifier = m => {
-    const originalMethod = inPageProvider[m];
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    inPageProvider[m] = function providerFunc(request, cb) {
-      const {
-        method,
-        params = []
-      } = request;
-      if (method === "eth_requestAccounts") {
-        let login = _assertClassBrand(_RealmEmbed_brand, self, _authLogin).call(self, {
-          loginProvider: params[0]
-        });
-        if (cb) {
-          login = login.then(res => cb(null, res)).catch(err => cb(err));
+    async request(request) {
+        // Check if the request is valid
+        if (!request || typeof request !== "object" || Array.isArray(request)) {
+            throw ProviderRpcInvalidRequestError;
         }
-        return login.finally(() => {
-          _classPrivateFieldGet(_communicationProvider, self).displayIframe({
-            isFull: false
-          });
+        const { method, params } = request;
+        // Check if the method is valid
+        if (typeof method !== "string" || method.length === 0) {
+            throw ProviderRpcMethodNotFoundError;
+        }
+        // Check if the params are valid
+        if (params !== undefined &&
+            !Array.isArray(params) &&
+            (typeof params !== "object" || params === null)) {
+            throw ProviderRpcInvalidParamsError;
+        }
+        const requestId = randomId();
+        const response = await AirMessageService$1.sendWalletProviderRequest(__classPrivateFieldGet(this, _AirWalletProvider_walletIframe, "f"), {
+            requestId,
+            ...request,
         });
-      }
-      return originalMethod.apply(this, [request, cb]);
-    };
-  };
-
-  // Detects call to eth_requestAccounts in request & sendAsync and passes to login
-  detectAccountRequestPrototypeModifier("request");
-  detectAccountRequestPrototypeModifier("sendAsync");
-  detectAccountRequestPrototypeModifier("send");
-  const proxiedInPageProvider = new Proxy(inPageProvider, {
-    // straight up lie that we deleted the property so that it doesn't
-    // throw an error in strict mode
-    deleteProperty: () => true
-  });
-  const proxiedCommunicationProvider = new Proxy(communicationProvider, {
-    // straight up lie that we deleted the property so that it doesn't
-    // throw an error in strict mode
-    deleteProperty: () => true
-  });
-  _classPrivateFieldSet(_provider, this, proxiedInPageProvider);
-  _classPrivateFieldSet(_communicationProvider, this, proxiedCommunicationProvider);
-  await Promise.all([inPageProvider.initializeState(), communicationProvider.initializeState(objectSpread2_default()(objectSpread2_default()({}, providerParams), {}, {
-    torusIframeId: _classPrivateFieldGet(_walletIframe, this).id
-  }))]);
-  loglevel.debug("embed communication setup ended");
-}
-function _triggerEvent(data) {
-  const listenersCopy = [..._classPrivateFieldGet(_embedListeners, this)];
-  listenersCopy.forEach(listener => {
-    try {
-      listener(data);
-    } catch (error) {
-      loglevel.error(error);
-    }
-  });
-}
-function _triggerInitializedEvent() {
-  if (_classPrivateFieldGet(_isInitialized, this) && _classPrivateFieldGet(_rehydrationState, this)) {
-    _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
-      event: "initialized",
-      result: {
-        rehydration: _classPrivateFieldGet(_rehydrationState, this)
-      }
-    });
-  }
-}
-function _onInitialized() {
-  return new Promise(resolve => {
-    if (!_classPrivateFieldGet(_isInitialized, this) || !_classPrivateFieldGet(_rehydrationState, this)) {
-      const sub = event => {
-        loglevel.debug("onInitialized:", event);
-        if (event.event === "initialized") {
-          this.off(sub);
-          resolve();
+        if (!response.success) {
+            const error = ensureProviderRpcError(response.payload);
+            throw error;
         }
-      };
-      this.on(sub);
-    } else {
-      resolve();
+        return response.payload.response;
+    }
+    on(eventName, listener) {
+        console.log("on", eventName, listener);
+    }
+    removeListener(eventName, listener) {
+        console.log("removeListener", eventName, listener);
     }
-  });
 }
-/* harmony default export */ const src_embed = (RealmEmbed);
-;// ./src/iframeController.ts
-
+_AirWalletProvider_walletIframe = new WeakMap();
 
 class IframeController {
-  constructor(iframeUrl, iframeId, state) {
-    defineProperty_default()(this, "state", void 0);
-    defineProperty_default()(this, "_iframeElement", null);
-    defineProperty_default()(this, "iframeUrl", void 0);
-    defineProperty_default()(this, "iframeId", void 0);
-    this.state = objectSpread2_default()(objectSpread2_default()({}, IframeController.defaultState), state);
-    this.iframeUrl = iframeUrl;
-    this.iframeId = iframeId;
-  }
-  get iframeElement() {
-    return this._iframeElement;
-  }
-  createIframe() {
-    if (this._iframeElement) return this._iframeElement;
-    const iframe = document.createElement("iframe");
-    iframe.id = this.iframeId;
-    iframe.allow = "publickey-credentials-get *; publickey-credentials-create *";
-    iframe.src = this.iframeUrl;
-    iframe.style.position = "fixed";
-    iframe.style.zIndex = "999999";
-    iframe.style.border = "none";
-    iframe.style.margin = "0";
-    iframe.style.padding = "0";
-    iframe.style.display = "none";
-    document.body.appendChild(iframe);
-    this._iframeElement = iframe;
-    return iframe;
-  }
-  setIframeVisibility(isVisible) {
-    this.state.isVisible = isVisible;
-  }
-  updateIframeState() {
-    if (!this.iframeElement) return;
-    const style = {};
-    style.display = this.state.isVisible ? "block" : "none";
-    style.width = "100%";
-    style.height = "100%";
-    style.top = "0px";
-    style.right = "0px";
-    style.left = "0px";
-    style.bottom = "0px";
-    Object.assign(this.iframeElement.style, style);
-  }
-  destroy() {
-    if (this.iframeElement) {
-      this.iframeElement.remove();
-      this._iframeElement = null;
+    constructor(iframeUrl, iframeId, state) {
+        this._iframeElement = null;
+        this.state = {
+            ...IframeController.defaultState,
+            ...state,
+        };
+        this.iframeUrl = iframeUrl;
+        this.iframeId = iframeId;
+    }
+    get iframeElement() {
+        return this._iframeElement;
+    }
+    createIframe() {
+        if (this._iframeElement)
+            return this._iframeElement;
+        const iframe = document.createElement("iframe");
+        iframe.id = this.iframeId;
+        iframe.allow = "publickey-credentials-get *; publickey-credentials-create *";
+        iframe.src = this.iframeUrl;
+        iframe.style.position = "fixed";
+        iframe.style.zIndex = "999999";
+        iframe.style.border = "none";
+        iframe.style.margin = "0";
+        iframe.style.padding = "0";
+        iframe.style.display = "none";
+        document.body.appendChild(iframe);
+        this._iframeElement = iframe;
+        return iframe;
+    }
+    setIframeVisibility(isVisible) {
+        this.state.isVisible = isVisible;
+    }
+    updateIframeState() {
+        if (!this.iframeElement)
+            return;
+        const style = {};
+        style.display = this.state.isVisible ? "block" : "none";
+        style.width = "100%";
+        style.height = "100%";
+        style.top = "0px";
+        style.right = "0px";
+        style.left = "0px";
+        style.bottom = "0px";
+        Object.assign(this.iframeElement.style, style);
+    }
+    destroy() {
+        if (this.iframeElement) {
+            this.iframeElement.remove();
+            this._iframeElement = null;
+        }
+    }
+    postMessage(message) {
+        if (!this.iframeElement)
+            return;
+        const { origin } = new URL(this.iframeElement.src);
+        this.iframeElement.contentWindow.postMessage(message, origin);
     }
-  }
-  postMessage(message) {
-    if (!this.iframeElement) return;
-    const {
-      origin
-    } = new URL(this.iframeElement.src);
-    this.iframeElement.contentWindow.postMessage(message, origin);
-  }
 }
-defineProperty_default()(IframeController, "defaultState", {
-  isVisible: false
-});
-;// ./src/airService.ts
-
-
-
-function airService_classPrivateFieldGet(s, a) { return s.get(airService_assertClassBrand(s, a)); }
-function airService_classPrivateFieldSet(s, a, r) { return s.set(airService_assertClassBrand(s, a), r), r; }
-function airService_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"); }
-
-
-
-
-
-
-
-
+IframeController.defaultState = {
+    isVisible: false,
+};
 
-var _authIframeController = /*#__PURE__*/new WeakMap();
-var _loginResult = /*#__PURE__*/new WeakMap();
-var airService_buildEnv = /*#__PURE__*/new WeakMap();
-var airService_embedNonce = /*#__PURE__*/new WeakMap();
-var _enableLogging = /*#__PURE__*/new WeakMap();
-var airService_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();
+var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_isWalletInitialized, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
 class AirService {
-  constructor({
-    partnerId
-  }) {
-    classPrivateMethodInitSpec_default()(this, _AirService_brand);
-    classPrivateFieldInitSpec_default()(this, _authIframeController, void 0);
-    classPrivateFieldInitSpec_default()(this, _loginResult, void 0);
-    classPrivateFieldInitSpec_default()(this, airService_buildEnv, void 0);
-    classPrivateFieldInitSpec_default()(this, airService_embedNonce, (0,base_controllers_namespaceObject.randomId)());
-    classPrivateFieldInitSpec_default()(this, _enableLogging, false);
-    classPrivateFieldInitSpec_default()(this, airService_isInitialized, false);
-    classPrivateFieldInitSpec_default()(this, _partnerId, void 0);
-    // Realm Embed related
-    classPrivateFieldInitSpec_default()(this, _realmEmbed, void 0);
-    classPrivateFieldInitSpec_default()(this, _walletInitialization, void 0);
-    classPrivateFieldInitSpec_default()(this, _airAuthListener, []);
-    airService_classPrivateFieldSet(_partnerId, this, partnerId);
-    airService_classPrivateFieldSet(_realmEmbed, this, new src_embed({
-      partnerId: airService_classPrivateFieldGet(_partnerId, this)
-    }));
-  }
-  get buildEnv() {
-    return airService_classPrivateFieldGet(airService_buildEnv, this);
-  }
-  get isAirAuth() {
-    return true;
-  }
-  get isInitialized() {
-    return airService_classPrivateFieldGet(airService_isInitialized, this);
-  }
-  get isLoggedIn() {
-    return !!airService_classPrivateFieldGet(_loginResult, this);
-  }
-  get isWalletLoaded() {
-    var _classPrivateFieldGet2;
-    return (_classPrivateFieldGet2 = airService_classPrivateFieldGet(_realmEmbed, this)) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.isInitialized;
-  }
-  async init({
-    buildEnv = EMBED_BUILD_ENV.PRODUCTION,
-    enableLogging = false,
-    skipRehydration = false
-  }) {
-    if (!airService_classPrivateFieldGet(_partnerId, this)) throw new Error("Partner ID is required to initialize auth service");
-    if (airService_classPrivateFieldGet(airService_isInitialized, this)) return;
-    airService_classPrivateFieldSet(airService_buildEnv, this, buildEnv);
-    airService_classPrivateFieldSet(_enableLogging, this, enableLogging);
-    const {
-      authUrl,
-      logLevel
-    } = AIR_URLS[buildEnv];
-    loglevel.setDefaultLevel(logLevel);
-    if (airService_classPrivateFieldGet(_enableLogging, this)) loglevel.enableAll();else loglevel.disableAll();
-    const authIframeOrigin = new URL(authUrl).origin;
-    await messageService.openAuthObservables({
-      authIframeOrigin
-    });
-    airService_classPrivateFieldSet(_authIframeController, this, new IframeController(authUrl, `air-login-${airService_classPrivateFieldGet(airService_embedNonce, this)}`));
-    messageService.authMessage$.subscribe(async msg => {
-      switch (msg.type) {
-        case AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST:
-          {
-            const authIframeController = airService_classPrivateFieldGet(_authIframeController, this);
-            authIframeController.setIframeVisibility(msg.payload.visible);
-            authIframeController.updateIframeState();
-            break;
-          }
-        case AirAuthMessageTypes.SETUP_WALLET_REQUEST:
-          {
-            await airService_assertClassBrand(_AirService_brand, this, _initializeWallet).call(this);
-            break;
-          }
-      }
-    });
-    try {
-      airService_classPrivateFieldGet(_authIframeController, this).createIframe();
-      const initializationPromise = new Promise((resolve, reject) => {
-        const handleAuthMessage = ev => {
-          try {
-            if (ev.origin !== authIframeOrigin) return;
-            if (ev.data === AirAuthMessageTypes.SETUP_COMPLETED) {
-              window.removeEventListener("message", handleAuthMessage);
-              airService_classPrivateFieldGet(_authIframeController, this).postMessage({
-                type: AirAuthMessageTypes.INITIALIZATION_REQUEST,
-                payload: {
-                  partnerId: airService_classPrivateFieldGet(_partnerId, this),
-                  skipRehydration
+    // #walletRehydrationState: AirRehydrationResult;
+    constructor({ partnerId }) {
+        _AirService_instances.add(this);
+        _AirService_loginResult.set(this, undefined);
+        _AirService_buildEnv.set(this, undefined);
+        _AirService_enableLogging.set(this, false);
+        _AirService_partnerId.set(this, undefined);
+        //#modalZIndex: number; TODO implement z index overwrite
+        _AirService_authIframeController.set(this, undefined);
+        _AirService_isAuthInitialized.set(this, false);
+        _AirService_airAuthListener.set(this, []);
+        _AirService_walletIframeController.set(this, undefined);
+        _AirService_walletInitialization.set(this, undefined);
+        _AirService_isWalletInitialized.set(this, false);
+        _AirService_airWalletProvider.set(this, undefined);
+        __classPrivateFieldSet(this, _AirService_partnerId, partnerId, "f");
+        // this.#modalZIndex = modalZIndex ?? 99999;
+    }
+    get buildEnv() {
+        return __classPrivateFieldGet(this, _AirService_buildEnv, "f");
+    }
+    get isInitialized() {
+        return __classPrivateFieldGet(this, _AirService_isAuthInitialized, "f");
+    }
+    get isLoggedIn() {
+        return !!__classPrivateFieldGet(this, _AirService_loginResult, "f");
+    }
+    get isWalletInitialized() {
+        return __classPrivateFieldGet(this, _AirService_isWalletInitialized, "f");
+    }
+    async init({ buildEnv = BUILD_ENV.PRODUCTION, enableLogging = false, skipRehydration = false, }) {
+        if (!__classPrivateFieldGet(this, _AirService_partnerId, "f"))
+            throw new Error("Partner ID is required to initialize auth service");
+        if (__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+            return;
+        __classPrivateFieldSet(this, _AirService_buildEnv, buildEnv, "f");
+        __classPrivateFieldSet(this, _AirService_enableLogging, enableLogging, "f");
+        const { authUrl, logLevel } = AIR_URLS[buildEnv];
+        log.setDefaultLevel(logLevel);
+        if (__classPrivateFieldGet(this, _AirService_enableLogging, "f"))
+            log.enableAll();
+        else
+            log.disableAll();
+        const authIframeOrigin = new URL(authUrl).origin;
+        await AirMessageService$1.openAuthObservables({ authIframeOrigin });
+        __classPrivateFieldSet(this, _AirService_authIframeController, new IframeController(authUrl, `air-auth-${randomId()}`), "f");
+        AirMessageService$1.authMessage$.subscribe(async (msg) => {
+            switch (msg.type) {
+                case AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST: {
+                    const authIframeController = __classPrivateFieldGet(this, _AirService_authIframeController, "f");
+                    authIframeController.setIframeVisibility(msg.payload.visible);
+                    authIframeController.updateIframeState();
+                    break;
+                }
+                case AirAuthMessageTypes.SETUP_WALLET_REQUEST: {
+                    try {
+                        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+                        __classPrivateFieldGet(this, _AirService_authIframeController, "f").postMessage({
+                            type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+                            payload: {
+                                success: true,
+                            },
+                        });
+                    }
+                    catch (err) {
+                        log.error("Error initializing wallet", err);
+                        const error = AirServiceError.from(err);
+                        __classPrivateFieldGet(this, _AirService_authIframeController, "f").postMessage({
+                            type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+                            payload: {
+                                success: false,
+                                errorName: error.name ?? "UNKNOWN_ERROR",
+                                errorMessage: error.message ?? "Unknown error occurred",
+                            },
+                        });
+                    }
+                    break;
                 }
-              });
-              resolve();
             }
-          } catch (err) {
-            reject(err);
-          }
+        });
+        try {
+            __classPrivateFieldGet(this, _AirService_authIframeController, "f").createIframe();
+            const result = await new Promise((resolve, reject) => {
+                const handleAuthMessage = async (ev) => {
+                    if (ev.origin !== authIframeOrigin)
+                        return;
+                    if (ev.data === AirAuthMessageTypes.AUTH_SETUP_COMPLETED) {
+                        window.removeEventListener("message", handleAuthMessage);
+                        const { payload } = await AirMessageService$1.sendAuthInitializationRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, {
+                            partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
+                            skipRehydration,
+                        });
+                        if (payload.success === true) {
+                            resolve(payload);
+                        }
+                        else {
+                            reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                        }
+                    }
+                };
+                window.addEventListener("message", handleAuthMessage);
+            });
+            __classPrivateFieldSet(this, _AirService_isAuthInitialized, true, "f");
+            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthInitialized).call(this, { rehydrated: result.rehydrated });
+            // rehydrated auth session
+            if (result.rehydrated) {
+                __classPrivateFieldSet(this, _AirService_loginResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createLoginResult).call(this, result), "f");
+                __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedIn).call(this);
+                return __classPrivateFieldGet(this, _AirService_loginResult, "f");
+            }
+        }
+        catch (error) {
+            log.debug("Error initializing auth service", error);
+            await this.cleanUp();
+            throw error;
+        }
+        return null;
+    }
+    async cleanUp() {
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpAuth).call(this);
+        this.clearEventListeners();
+    }
+    async login(options) {
+        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+            throw new Error("Service is not initialized");
+        if (__classPrivateFieldGet(this, _AirService_loginResult, "f"))
+            return __classPrivateFieldGet(this, _AirService_loginResult, "f");
+        const iframeController = __classPrivateFieldGet(this, _AirService_authIframeController, "f");
+        const { payload } = await AirMessageService$1.sendAuthLoginRequest(iframeController.iframeElement, {
+            partnerLoginToken: options?.authToken,
+        });
+        if (payload.success === true) {
+            __classPrivateFieldSet(this, _AirService_loginResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createLoginResult).call(this, payload), "f");
+            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedIn).call(this);
+            return __classPrivateFieldGet(this, _AirService_loginResult, "f");
+        }
+        throw new AirServiceError("UNKNOWN_ERROR", "Unknown error occurred");
+    }
+    /**
+     * @experimental This method is experimental and will change in the future.
+     */
+    async deploySmartAccount() {
+        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+            throw new Error("Service is not initialized");
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+        try {
+            log.info("deploySmartAccount");
+            const { payload } = await AirMessageService$1.sendDeploySmartAccountRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+            if (payload.success === false) {
+                throw new AirServiceError(payload.errorName, payload.errorMessage);
+            }
+            return { txHash: payload.txHash };
+        }
+        catch (error) {
+            throw AirServiceError.from(error);
+        }
+    }
+    /**
+     * @experimental This method is experimental and will change in the future.
+     */
+    async grantPermission(policies) {
+        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+            throw new Error("AirAuth is not initialized");
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+        try {
+            log.info("grantPermission", policies);
+            const { payload } = await AirMessageService$1.sendGrantPermissionsRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, { policies });
+            if (payload.success === false) {
+                throw new AirServiceError(payload.errorName, payload.errorMessage);
+            }
+            return payload.sessionData;
+        }
+        catch (error) {
+            throw AirServiceError.from(error);
+        }
+    }
+    /**
+     * @experimental This method is experimental and will change in the future.
+     */
+    async executeAction(params) {
+        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+            throw new Error("Service is not initialized");
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+        try {
+            log.info("executeAction", params);
+            const txHash = await AirMessageService$1.sendExecuteActionRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, params);
+            return txHash;
+        }
+        catch (error) {
+            throw AirServiceError.from(error);
+        }
+    }
+    /**
+     * @experimental This method is experimental and will change in the future.
+     */
+    async revokePermission(permissionId) {
+        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+            throw new Error("Service is not initialized");
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+        try {
+            log.info("revokePermission", permissionId);
+            const txHash = await AirMessageService$1.sendRevokePermissionsRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, permissionId);
+            return txHash;
+        }
+        catch (error) {
+            throw AirServiceError.from(error);
+        }
+    }
+    /**
+     * @experimental This method is experimental and will change in the future.
+     */
+    async isSmartAccountDeployed() {
+        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+            throw new Error("Service is not initialized");
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+        try {
+            const { payload } = await AirMessageService$1.sendIsSmartAccountDeployedRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+            if (payload.success === false) {
+                throw new AirServiceError(payload.errorName, payload.errorMessage);
+            }
+            return payload.isDeployed;
+        }
+        catch (error) {
+            throw AirServiceError.from(error);
+        }
+    }
+    async logout() {
+        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+            throw new Error("Service is not initialized");
+        if (!this.isLoggedIn)
+            throw new Error("No active session to logout");
+        // Clear up wallet
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+        await AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+        __classPrivateFieldSet(this, _AirService_loginResult, undefined, "f");
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedOut).call(this);
+    }
+    async getProvider() {
+        if (!this.isLoggedIn)
+            return null;
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+        return __classPrivateFieldGet(this, _AirService_airWalletProvider, "f");
+    }
+    async preloadWallet() {
+        return __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+    }
+    async claimAirId(options) {
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+        const result = await AirMessageService$1.sendClaimIdRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, options ?? {});
+        if (result.payload.success === true) {
+            return { airId: result.payload.airId };
+        }
+        throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+    }
+    async getUserInfo() {
+        if (!this.isLoggedIn)
+            throw new Error("User not logged in");
+        const info = await AirMessageService$1.sendPartnerUserInfoRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+        if (info.payload.success === false) {
+            throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
+        }
+        return {
+            partnerId: info.payload.partnerId,
+            partnerUserId: info.payload.partnerUserId,
+            airId: info.payload.airId,
+            user: {
+                id: info.payload.user.id,
+                abstractAccountAddress: info.payload.user.abstractAccountAddress,
+                email: info.payload.user.email,
+            },
         };
-        window.addEventListener("message", handleAuthMessage);
-      });
-      const authServiceInitialization = messageService.waitForAuthInitialization();
-      const result = await Promise.all([initializationPromise, authServiceInitialization]);
-      airService_classPrivateFieldSet(airService_isInitialized, this, true);
-      airService_assertClassBrand(_AirService_brand, this, _triggerAirAuthInitialized).call(this, {
-        rehydrated: result[1].rehydrated
-      });
-      airService_assertClassBrand(_AirService_brand, this, _prepareRealmEmbedListeners).call(this);
-
-      // rehydrated auth session
-      if (result[1].rehydrated) {
-        airService_classPrivateFieldSet(_loginResult, this, airService_assertClassBrand(_AirService_brand, this, airService_createLoginResult).call(this, result[1]));
-        airService_assertClassBrand(_AirService_brand, this, _triggerAirAuthLoggedIn).call(this);
-        return airService_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 airService_assertClassBrand(_AirService_brand, this, _cleanUpWallet).call(this);
-
-    // Logout auth session
-    await messageService.logoutAuth(airService_classPrivateFieldGet(_authIframeController, this).iframeElement);
-
-    // Destroy the auth iframe
-    const authIframeElement = (_classPrivateFieldGet3 = airService_classPrivateFieldGet(_authIframeController, this)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.iframeElement;
-    if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
-      airService_classPrivateFieldGet(_authIframeController, this).destroy();
-      airService_classPrivateFieldSet(_authIframeController, this, undefined);
+    on(listener) {
+        if (__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener) < 0)
+            __classPrivateFieldGet(this, _AirService_airAuthListener, "f").push(listener);
     }
-
-    // Close the message service
-    messageService.closeAuthObservables();
-    this.clearEventListeners();
-    airService_classPrivateFieldSet(airService_isInitialized, this, false);
-  }
-  async login(options) {
-    if (!airService_classPrivateFieldGet(airService_isInitialized, this)) throw new Error("Service is not initialized");
-    if (airService_classPrivateFieldGet(_loginResult, this)) return airService_classPrivateFieldGet(_loginResult, this);
-    const iframeController = airService_classPrivateFieldGet(_authIframeController, this);
-    const {
-      payload
-    } = await messageService.sendAuthLoginRequest(iframeController.iframeElement, {
-      partnerLoginToken: options === null || options === void 0 ? void 0 : options.authToken
-    });
-    if (payload.success === true) {
-      airService_classPrivateFieldSet(_loginResult, this, airService_assertClassBrand(_AirService_brand, this, airService_createLoginResult).call(this, payload));
-      airService_assertClassBrand(_AirService_brand, this, _triggerAirAuthLoggedIn).call(this);
-      return airService_classPrivateFieldGet(_loginResult, this);
+    off(listener) {
+        if (__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener) >= 0)
+            __classPrivateFieldGet(this, _AirService_airAuthListener, "f").splice(__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener), 1);
     }
-    throw new AirServiceError("UNKNOWN_ERROR", "Unknown error occurred");
-  }
-
-  /**
-   * @experimental This method is experimental and will change in the future.
-   */
-  async deploySmartAccount() {
-    if (!airService_classPrivateFieldGet(airService_isInitialized, this)) throw new Error("Service is not initialized");
-    await airService_assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
-    return airService_classPrivateFieldGet(_realmEmbed, this)._deploySmartAccount();
-  }
-
-  /**
-   * @experimental This method is experimental and will change in the future.
-   */
-  async grantPermission(policies) {
-    if (!airService_classPrivateFieldGet(airService_isInitialized, this)) throw new Error("AirAuth is not initialized");
-    await airService_assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
-    return airService_classPrivateFieldGet(_realmEmbed, this)._grantPermission(policies);
-  }
-
-  /**
-   * @experimental This method is experimental and will change in the future.
-   */
-  async executeAction(params) {
-    if (!airService_classPrivateFieldGet(airService_isInitialized, this)) throw new Error("AirAuth is not initialized");
-    await airService_assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
-    return airService_classPrivateFieldGet(_realmEmbed, this)._executeAction(params);
-  }
-
-  /**
-   * @experimental This method is experimental and will change in the future.
-   */
-  async revokePermission(permissionId) {
-    if (!airService_classPrivateFieldGet(airService_isInitialized, this)) throw new Error("AirAuth is not initialized");
-    await airService_assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
-    return airService_classPrivateFieldGet(_realmEmbed, this)._revokePermission(permissionId);
-  }
-  async logout() {
-    if (!airService_classPrivateFieldGet(airService_isInitialized, this)) throw new Error("Service is not initialized");
-    if (!this.isLoggedIn) throw new Error("No active session to logout");
-
-    // Clear up wallet
-    await airService_assertClassBrand(_AirService_brand, this, _cleanUpWallet).call(this);
-    await messageService.logoutAuth(airService_classPrivateFieldGet(_authIframeController, this).iframeElement);
-    airService_classPrivateFieldSet(_loginResult, this, undefined);
-    airService_assertClassBrand(_AirService_brand, this, _triggerAirAuthLoggedOut).call(this);
-  }
-  async getProvider() {
-    if (!this.isLoggedIn) return null;
-    await airService_assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
-    return airService_classPrivateFieldGet(_realmEmbed, this).provider;
-  }
-  async preloadWallet() {
-    return airService_assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
-  }
-  async claimAirId(options) {
-    await airService_assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
-    return airService_classPrivateFieldGet(_realmEmbed, this).claimRealmId(options);
-  }
-  async getUserInfo() {
-    if (!this.isLoggedIn) throw new Error("User not logged in");
-    const info = await messageService.sendUserInfoRequest(airService_classPrivateFieldGet(_authIframeController, this).iframeElement);
-    if (info.payload.success === false) {
-      throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
+    clearEventListeners() {
+        __classPrivateFieldSet(this, _AirService_airAuthListener, [], "f");
     }
-    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(airService_classPrivateFieldGet(_authIframeController, this).iframeElement);
-    if (info.payload.success === false) {
-      throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
+    // This is for internal use only
+    // @ts-expect-error for unused function
+    async _showWalletWidget() {
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+        // return (this.#realmEmbed as any)._showWalletWidget();
+        log.info("_showWalletWidget");
+        return null;
     }
-    return {
-      partnerId: info.payload.partnerId,
-      partnerUserId: info.payload.partnerUserId,
-      airId: info.payload.airId
-    };
-  }
-  on(listener) {
-    if (airService_classPrivateFieldGet(_airAuthListener, this).indexOf(listener) < 0) airService_classPrivateFieldGet(_airAuthListener, this).push(listener);
-  }
-  off(listener) {
-    if (airService_classPrivateFieldGet(_airAuthListener, this).indexOf(listener) >= 0) airService_classPrivateFieldGet(_airAuthListener, this).splice(airService_classPrivateFieldGet(_airAuthListener, this).indexOf(listener), 1);
-  }
-  clearEventListeners() {
-    airService_classPrivateFieldSet(_airAuthListener, this, []);
-  }
-
-  // This is for internal use only
-  // @ts-expect-error for unused function
-  async _showWalletWidget() {
-    await airService_assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return airService_classPrivateFieldGet(_realmEmbed, this)._showWalletWidget();
-  }
-}
-async function _createWallet() {
-  return airService_classPrivateFieldGet(_realmEmbed, this).login({
-    skipClaiming: true,
-    legacy: false
-  });
-}
-async function _ensureWallet() {
-  if (!this.isLoggedIn) throw new Error("No active session to create wallet");
-  if (!airService_classPrivateFieldGet(_walletInitialization, this)) {
-    messageService.setupAuthIframe(airService_classPrivateFieldGet(_authIframeController, this).iframeElement);
-    airService_classPrivateFieldSet(_walletInitialization, this, (async () => {
-      try {
-        await airService_assertClassBrand(_AirService_brand, this, _initializeWallet).call(this);
-        return await airService_assertClassBrand(_AirService_brand, this, _createWallet).call(this);
-      } catch (error) {
-        loglevel.error("Error initializing wallet", error);
-        throw error;
-      }
-    })());
-  }
-  return airService_classPrivateFieldGet(_walletInitialization, this);
-}
-async function _cleanUpWallet() {
-  if (airService_classPrivateFieldGet(_walletInitialization, this) || airService_classPrivateFieldGet(_realmEmbed, this)) {
-    await airService_classPrivateFieldGet(_walletInitialization, this);
-    await airService_classPrivateFieldGet(_realmEmbed, this).cleanUp();
-    airService_classPrivateFieldSet(_walletInitialization, this, undefined);
-  }
 }
-async function _initializeWallet() {
-  if (!airService_classPrivateFieldGet(_realmEmbed, this).isInitialized) {
-    try {
-      await airService_classPrivateFieldGet(_realmEmbed, this).init({
-        buildEnv: airService_classPrivateFieldGet(airService_buildEnv, this),
-        skipRehydration: true,
-        enableLogging: airService_classPrivateFieldGet(_enableLogging, this) || false
-      });
-      airService_classPrivateFieldGet(_authIframeController, this).postMessage({
-        type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
-        payload: {
-          success: true
+_AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airAuthListener = new WeakMap(), _AirService_walletIframeController = new WeakMap(), _AirService_walletInitialization = new WeakMap(), _AirService_isWalletInitialized = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet() {
+    if (!this.isInitialized)
+        throw new Error("Service not initialized");
+    if (!__classPrivateFieldGet(this, _AirService_walletInitialization, "f")) {
+        try {
+            __classPrivateFieldSet(this, _AirService_walletInitialization, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_initializeWallet).call(this), "f");
+            return await __classPrivateFieldGet(this, _AirService_walletInitialization, "f");
         }
-      });
-    } catch (error) {
-      loglevel.error("Error initializing wallet", error);
-      airService_classPrivateFieldGet(_authIframeController, this).postMessage({
-        type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
-        payload: {
-          success: false,
-          errorName: "UNKNOWN_ERROR",
-          errorMessage: "Unknown error occurred"
+        catch (error) {
+            __classPrivateFieldSet(this, _AirService_walletInitialization, null, "f");
+            log.error("Error initializing wallet", error);
+            throw error;
         }
-      });
-      throw error;
     }
-  }
-}
-async function _triggerEventListeners(data) {
-  airService_classPrivateFieldGet(_airAuthListener, this).forEach(listener => {
-    listener(data);
-  });
-}
-async function _triggerAirAuthInitialized(result) {
-  await airService_assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
-    event: "initialized",
-    result
-  });
-}
-async function _triggerAirAuthLoggedIn() {
-  await airService_assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
-    event: "logged_in",
-    result: airService_classPrivateFieldGet(_loginResult, this)
-  });
-}
-async function _triggerAirAuthLoggedOut() {
-  await airService_assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
-    event: "logged_out"
-  });
-}
-function airService_createLoginResult(payload) {
-  return {
-    isLoggedIn: true,
-    id: payload.id,
-    abstractAccountAddress: payload.abstractAccountAddress,
-    token: payload.partnerAccessToken
-  };
-}
-async function _prepareRealmEmbedListeners() {
-  airService_classPrivateFieldGet(_realmEmbed, this).on(data => {
-    if (data.event === "connected" || data.event === "logged_in") {
-      var _data$result$addresse;
-      const result = objectSpread2_default()(objectSpread2_default()({}, 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 : ""
+    else {
+        return __classPrivateFieldGet(this, _AirService_walletInitialization, "f");
+    }
+}, _AirService_initializeWallet = async function _AirService_initializeWallet() {
+    if (__classPrivateFieldGet(this, _AirService_isWalletInitialized, "f"))
+        throw new AirServiceError("ALREADY_INITIALISED", "Already initialized");
+    const { walletUrl } = AIR_URLS[__classPrivateFieldGet(this, _AirService_buildEnv, "f")];
+    log.info(walletUrl, "url loaded");
+    const walletIframeOrigin = new URL(walletUrl).origin;
+    await AirMessageService$1.openWalletObservables({ walletIframeOrigin });
+    try {
+        __classPrivateFieldSet(this, _AirService_walletIframeController, new IframeController(walletUrl, `air-wallet-${randomId()}`), "f");
+        __classPrivateFieldGet(this, _AirService_walletIframeController, "f").createIframe();
+        AirMessageService$1.messages$.subscribe(async (msg) => {
+            switch (msg.type) {
+                case AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST: {
+                    const walletIframeController = __classPrivateFieldGet(this, _AirService_walletIframeController, "f");
+                    walletIframeController.setIframeVisibility(msg.payload.visible);
+                    walletIframeController.updateIframeState();
+                    break;
+                }
+            }
+        });
+        await new Promise((resolve, reject) => {
+            const handleAuthMessage = async (ev) => {
+                if (ev.origin !== walletIframeOrigin)
+                    return;
+                if (ev.data === AirMessageTypes.SERVICE_STARTED) {
+                    window.removeEventListener("message", handleAuthMessage);
+                    const { payload } = await AirMessageService$1.sendWalletInitializationRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, {
+                        partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
+                        enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
+                    });
+                    if (payload.success === true) {
+                        resolve();
+                    }
+                    else {
+                        reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                    }
+                }
+            };
+            window.addEventListener("message", handleAuthMessage);
+        });
+        const walletInitPromise = AirMessageService$1.onWalletInitialized();
+        AirMessageService$1.setupIframeCommunication(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, __classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+        const walletInitResult = await walletInitPromise;
+        if (walletInitResult.payload.success !== true) {
+            throw new AirServiceError(walletInitResult.payload.errorName, walletInitResult.payload.errorMessage);
         }
-      });
-      airService_assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
-        event: "wallet_loaded",
-        result
-      });
-    } else if (data.event === "minting_started") {
-      airService_assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
-        event: "minting_started"
-      });
-    } else if (data.event === "minting_failed") {
-      airService_assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
-        event: "minting_failed",
-        errorMessage: data.errorMessage
-      });
+        __classPrivateFieldSet(this, _AirService_airWalletProvider, new AirWalletProvider(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement), "f");
+        const result = {
+            abstractAccountAddress: walletInitResult.payload.addresses.aa,
+        };
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerWalletInitialized).call(this, result);
+        return result;
     }
-  });
-}
-/* harmony default export */ const airService = (AirService);
-;// ./src/index.ts
-
-
-
+    catch (error) {
+        log.error("Error initializing wallet", error);
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+        throw error;
+    }
+}, _AirService_triggerEventListeners = function _AirService_triggerEventListeners(data) {
+    __classPrivateFieldGet(this, _AirService_airAuthListener, "f").forEach((listener) => {
+        listener(data);
+    });
+}, _AirService_triggerAirAuthInitialized = function _AirService_triggerAirAuthInitialized(result) {
+    __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, { event: "initialized", result });
+}, _AirService_triggerAirAuthLoggedIn = function _AirService_triggerAirAuthLoggedIn() {
+    __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, {
+        event: "logged_in",
+        result: __classPrivateFieldGet(this, _AirService_loginResult, "f"),
+    });
+}, _AirService_triggerAirAuthLoggedOut = function _AirService_triggerAirAuthLoggedOut() {
+    __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, { event: "logged_out" });
+}, _AirService_triggerWalletInitialized = function _AirService_triggerWalletInitialized(result) {
+    __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, {
+        event: "wallet_initialized",
+        result,
+    });
+}, _AirService_createLoginResult = function _AirService_createLoginResult(payload) {
+    return {
+        isLoggedIn: true,
+        id: payload.id,
+        abstractAccountAddress: payload.abstractAccountAddress,
+        token: payload.partnerAccessToken,
+    };
+}, _AirService_cleanUpAuth = async function _AirService_cleanUpAuth() {
+    // Logout auth session
+    await AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+    // Destroy the auth iframe
+    const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
+    if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
+        __classPrivateFieldGet(this, _AirService_authIframeController, "f").destroy();
+        __classPrivateFieldSet(this, _AirService_authIframeController, undefined, "f");
+    }
+    // Close the message service
+    AirMessageService$1.closeAuthObservables();
+    __classPrivateFieldSet(this, _AirService_isAuthInitialized, false, "f");
+}, _AirService_cleanUpWallet = async function _AirService_cleanUpWallet() {
+    if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+        return;
+    // Logout wallet and destroy the wallet iframe
+    const walletIframeElement = __classPrivateFieldGet(this, _AirService_walletIframeController, "f")?.iframeElement;
+    if (isElement(walletIframeElement) && window.document.body.contains(walletIframeElement)) {
+        await AirMessageService$1.logoutWallet(walletIframeElement);
+        __classPrivateFieldGet(this, _AirService_walletIframeController, "f").destroy();
+        __classPrivateFieldSet(this, _AirService_walletIframeController, undefined, "f");
+    }
+    // Close the message service
+    AirMessageService$1.closeAirObservables();
+    __classPrivateFieldSet(this, _AirService_walletInitialization, null, "f");
+    __classPrivateFieldSet(this, _AirService_isWalletInitialized, false, "f");
+};
 
-module.exports = __webpack_exports__;
-/******/ })()
-;
+exports.AirService = AirService;
+exports.AirServiceError = AirServiceError;
+exports.AirWalletProvider = AirWalletProvider;
+exports.BUILD_ENV = BUILD_ENV;
+exports.RealmEmbedError = RealmEmbedError;