@mocanetwork/airkit 1.2.0-beta.2 → 1.2.0-beta.3

package/dist/airkit.umd.js

@@ -131,7 +131,7 @@
       RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication"
     };
 
-    const AirMessageTypes = {
+    const AirWalletMessageTypes = {
       SERVICE_STARTED: "air_service_started",
       INITIALIZATION_REQUEST: "air_initialization_request",
       INITIALIZATION_RESPONSE: "air_initialization_response",
@@ -139,8 +139,8 @@
       WALLET_INITIALIZED: "air_wallet_initialized",
       WALLET_LOGIN_REQUEST: "air_wallet_login_request",
       WALLET_LOGIN_RESPONSE: "air_wallet_login_response",
-      SETUP_MFA_REQUEST: "air_setup_mfa_request",
-      SETUP_MFA_RESPONSE: "air_setup_mfa_response",
+      SETUP_OR_UPDATE_MFA_REQUEST: "air_setup_mfa_request",
+      SETUP_OR_UPDATE_MFA_RESPONSE: "air_setup_mfa_response",
       CLAIM_ID_REQUEST: "air_claim_id_request",
       CLAIM_ID_RESPONSE: "air_claim_id_response",
       DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
@@ -156,6 +156,8 @@
       WALLET_IFRAME_VISIBILITY_REQUEST: "air_wallet_iframe_visibility_request",
       OPEN_WINDOW_REQUEST: "air_open_window_request",
       OPEN_WINDOW_RESPONSE: "air_open_window_response",
+      OPEN_WINDOW_RETRY_REQUEST: "air_open_window_retry_request",
+      OPEN_WINDOW_RETRY_RESPONSE: "air_open_window_retry_response",
       WINDOW_CLOSED: "air_window_closed",
       IS_SMART_ACCOUNT_DEPLOYED_REQUEST: "air_is_smart_account_deployed_request",
       IS_SMART_ACCOUNT_DEPLOYED_RESPONSE: "air_is_smart_account_deployed_response",
@@ -195,6 +197,50 @@
       return new Error(`This value was not thrown as type Error: ${stringified}`);
     }
 
+    const BUILD_ENV = {
+        PRODUCTION: "production",
+        UAT: "uat",
+        STAGING: "staging",
+        DEVELOPMENT: "development",
+    };
+
+    const AIR_URLS = {
+        [BUILD_ENV.DEVELOPMENT]: {
+            authUrl: "http://localhost:8100",
+            walletUrl: "http://localhost:8200",
+        },
+        [BUILD_ENV.UAT]: {
+            authUrl: "https://auth.uat.air3.com",
+            walletUrl: "https://account.uat.air3.com",
+        },
+        [BUILD_ENV.STAGING]: {
+            authUrl: "https://auth.staging.air3.com",
+            walletUrl: "https://account.staging.air3.com",
+        },
+        [BUILD_ENV.PRODUCTION]: {
+            authUrl: "https://auth.air3.com",
+            walletUrl: "https://account.air3.com",
+        },
+    };
+    const isElement = (element) => element instanceof Element || element instanceof Document;
+    const randomId = () => Math.random().toString(36).slice(2);
+    const extractErrorHash = (message) => {
+        if (!message)
+            return "";
+        // Format: "reason: 0x..."
+        if (message.includes("reason:")) {
+            return message.split("reason:")[1].trim();
+        }
+        // Format: "UserOperation reverted during simulation with reason: 0x..."
+        if (message.includes("with reason:")) {
+            const match = message.match(/with reason: (0x[a-fA-F0-9]+)/);
+            return match ? match[1].trim() : "";
+        }
+        // Look for any 0x pattern that could be a hash
+        const hexMatch = message.match(/(0x[a-fA-F0-9]{8,})/);
+        return hexMatch ? hexMatch[1].trim() : "";
+    };
+
     class AirServiceError extends BaseError {
         static from(error) {
             if (error instanceof AirServiceError) {
@@ -212,6 +258,7 @@
     class ProviderRpcError extends Error {
         constructor(message) {
             super(message);
+            this.metaMessages = [];
         }
     }
     class UserRejectedRequestError extends ProviderRpcError {
@@ -257,10 +304,14 @@
         }
     }
     class TransactionRejectedRpcError extends ProviderRpcError {
-        constructor() {
-            super(...arguments);
+        constructor(message) {
+            // Remove the "Version: viem@x.x.x" suffix if present
+            const cleanMessage = message.replace(/\nVersion:.*$/, '');
+            super(cleanMessage);
             this.code = -32003;
             this.name = "TransactionRejectedRpcError";
+            // Parse the error hash from the message
+            this.metaMessages.push(extractErrorHash(cleanMessage));
         }
     }
     class InvalidRequestRpcError extends ProviderRpcError {
@@ -328,149 +379,480 @@
         return new InternalRpcError(`Invalid value for ProviderRpcError: ${stringified}`);
     }
 
-    function isFunction(value) {
-      return typeof value === 'function';
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
     }
 
-    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 loglevel$1 = {exports: {}};
 
-    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;
-      };
-    });
+    /*
+    * loglevel - https://github.com/pimterry/loglevel
+    *
+    * Copyright (c) 2013 Tim Perry
+    * Licensed under the MIT license.
+    */
+    var loglevel = loglevel$1.exports;
+    var hasRequiredLoglevel;
+    function requireLoglevel() {
+      if (hasRequiredLoglevel) return loglevel$1.exports;
+      hasRequiredLoglevel = 1;
+      (function (module) {
+        (function (root, definition) {
 
-    function arrRemove(arr, item) {
-      if (arr) {
-        var index = arr.indexOf(item);
-        0 <= index && arr.splice(index, 1);
-      }
-    }
+          if (module.exports) {
+            module.exports = definition();
+          } else {
+            root.log = definition();
+          }
+        })(loglevel, function () {
 
-    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)) {
+          // 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 {
-                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
+                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]);
                 };
-              } 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];
+
+          // 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();
           }
-          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;
-              }
+
+          // 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;
             }
           }
-          if (errors) {
-            throw new UnsubscriptionError(errors);
+
+          // These private functions always need `this` to be set properly
+
+          function replaceLoggingMethods() {
+            /*jshint validthis:true */
+            var level = this.getLevel();
+
+            // 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);
+            }
+
+            // Define log.log as an alias for log.debug
+            this.log = this.debug;
+
+            // Return any important warnings.
+            if (typeof console === undefinedType && level < this.levels.SILENT) {
+              return "No console available for logging";
+            }
           }
-        }
-      };
-      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;
+
+          // 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);
               }
-              teardown._addParent(this);
-            }
-            (this._finalizers = (_a = this._finalizers) !== null && _a !== undefined ? _a : []).push(teardown);
+            };
           }
-        }
-      };
-      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);
-        }
-      };
+
+          // 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);
+          }
+          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;
+
+              // Use localStorage if available
+              try {
+                window.localStorage[storageKey] = levelName;
+                return;
+              } catch (ignore) {}
+
+              // 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) {}
+              }
+
+              // 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;
+
+              // 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);
+              }
+            }
+
+            /*
+             *
+             * 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);
+              }
+
+              // 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$1);
+      return loglevel$1.exports;
+    }
+
+    var loglevelExports = requireLoglevel();
+    var log = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
+
+    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;
+      };
+    });
+
+    function arrRemove(arr, item) {
+      if (arr) {
+        var index = arr.indexOf(item);
+        0 <= index && arr.splice(index, 1);
+      }
+    }
+
+    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);
+          }
+        }
+      };
+      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);
+          }
+        }
+      };
+      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);
@@ -633,1180 +1015,719 @@
         }
       };
       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 {
-          {
-            partialObserver = observerOrNext;
-          }
-        }
-        _this.destination = new ConsumerObserver(partialObserver);
-        return _this;
-      }
-      return SafeSubscriber;
-    }(Subscriber);
-    function handleUnhandledError(error) {
-      {
-        reportUnhandledError(error);
-      }
-    }
-    function defaultErrorHandler(err) {
-      throw err;
-    }
-    var EMPTY_OBSERVER = {
-      closed: true,
-      next: noop,
-      error: defaultErrorHandler,
-      complete: noop
-    };
-
-    var observable = function () {
-      return typeof Symbol === 'function' && Symbol.observable || '@@observable';
-    }();
-
-    function identity(x) {
-      return x;
-    }
-
-    function pipeFromArray(fns) {
-      if (fns.length === 0) {
-        return identity;
-      }
-      if (fns.length === 1) {
-        return fns[0];
-      }
-      return function piped(input) {
-        return fns.reduce(function (prev, fn) {
-          return fn(prev);
-        }, input);
-      };
-    }
-
-    var Observable = function () {
-      function Observable(subscribe) {
-        if (subscribe) {
-          this._subscribe = subscribe;
-        }
-      }
-      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));
-        });
-        return subscriber;
-      };
-      Observable.prototype._trySubscribe = function (sink) {
-        try {
-          return this._subscribe(sink);
-        } catch (err) {
-          sink.error(err);
-        }
-      };
-      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);
-        });
-      };
-      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];
-        }
-        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);
-    }
-
-    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);
-            }
-          });
-        }
-        throw new TypeError('Unable to lift unknown Observable type');
-      };
-    }
-
-    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);
-          }
-        } : _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();
+    }();
+    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 {
+          {
+            partialObserver = observerOrNext;
           }
-        } : _super.prototype._complete;
+        }
+        _this.destination = new ConsumerObserver(partialObserver);
         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));
-        }
-      };
-      return OperatorSubscriber;
+      return SafeSubscriber;
     }(Subscriber);
+    function handleUnhandledError(error) {
+      {
+        reportUnhandledError(error);
+      }
+    }
+    function defaultErrorHandler(err) {
+      throw err;
+    }
+    var EMPTY_OBSERVER = {
+      closed: true,
+      next: noop,
+      error: defaultErrorHandler,
+      complete: noop
+    };
 
-    var ObjectUnsubscribedError = createErrorClass(function (_super) {
-      return function ObjectUnsubscribedErrorImpl() {
-        _super(this);
-        this.name = 'ObjectUnsubscribedError';
-        this.message = 'object unsubscribed';
-      };
-    });
+    var observable = function () {
+      return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+    }();
 
-    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;
+    function identity(x) {
+      return x;
+    }
+
+    function pipeFromArray(fns) {
+      if (fns.length === 0) {
+        return identity;
       }
-      Subject.prototype.lift = function (operator) {
-        var subject = new AnonymousSubject(this, this);
-        subject.operator = operator;
-        return subject;
+      if (fns.length === 1) {
+        return fns[0];
+      }
+      return function piped(input) {
+        return fns.reduce(function (prev, fn) {
+          return fn(prev);
+        }, input);
       };
-      Subject.prototype._throwIfClosed = function () {
-        if (this.closed) {
-          throw new ObjectUnsubscribedError();
+    }
+
+    var Observable = function () {
+      function Observable(subscribe) {
+        if (subscribe) {
+          this._subscribe = subscribe;
         }
+      }
+      Observable.prototype.lift = function (operator) {
+        var observable = new Observable();
+        observable.source = this;
+        observable.operator = operator;
+        return observable;
       };
-      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 () {
+      Observable.prototype.subscribe = function (observerOrNext, error, complete) {
         var _this = this;
+        var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
         errorContext(function () {
-          _this._throwIfClosed();
-          if (!_this.isStopped) {
-            _this.isStopped = true;
-            var observers = _this.observers;
-            while (observers.length) {
-              observers.shift().complete();
-            }
-          }
+          var _a = _this,
+            operator = _a.operator,
+            source = _a.source;
+          subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
         });
+        return subscriber;
       };
-      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);
+      Observable.prototype._trySubscribe = function (sink) {
+        try {
+          return this._subscribe(sink);
+        } catch (err) {
+          sink.error(err);
+        }
       };
-      Subject.prototype._innerSubscribe = function (subscriber) {
+      Observable.prototype.forEach = function (next, promiseCtor) {
         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);
+        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);
         });
       };
-      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);
+      Observable.prototype._subscribe = function (subscriber) {
+        var _a;
+        return (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber);
       };
-      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);
+      Observable.prototype[observable] = function () {
+        return this;
       };
-      AnonymousSubject.prototype.complete = function () {
-        var _a, _b;
-        (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.complete) === null || _b === undefined ? undefined : _b.call(_a);
+      Observable.prototype.pipe = function () {
+        var operations = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          operations[_i] = arguments[_i];
+        }
+        return pipeFromArray(operations)(this);
       };
-      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;
+      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);
+          });
+        });
       };
-      return AnonymousSubject;
-    }(Subject);
-
-    var EmptyError = createErrorClass(function (_super) {
-      return function EmptyErrorImpl() {
-        _super(this);
-        this.name = 'EmptyError';
-        this.message = 'no elements in sequence';
+      Observable.create = function (subscribe) {
+        return new Observable(subscribe);
       };
-    });
-
-    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);
-      });
+      return Observable;
+    }();
+    function getPromiseCtor(promiseCtor) {
+      var _a;
+      return (_a = promiseCtor !== null && promiseCtor !== undefined ? promiseCtor : config.Promise) !== null && _a !== undefined ? _a : Promise;
     }
-
-    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);
-        }));
-      });
+    function isObserver(value) {
+      return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
     }
-
-    function getDefaultExportFromCjs (x) {
-    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    function isSubscriber(value) {
+      return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
     }
 
-    var loglevel$1 = {exports: {}};
-
-    /*
-    * loglevel - https://github.com/pimterry/loglevel
-    *
-    * Copyright (c) 2013 Tim Perry
-    * Licensed under the MIT license.
-    */
-    var loglevel = loglevel$1.exports;
-    var hasRequiredLoglevel;
-    function requireLoglevel() {
-      if (hasRequiredLoglevel) return loglevel$1.exports;
-      hasRequiredLoglevel = 1;
-      (function (module) {
-        (function (root, definition) {
-
-          if (module.exports) {
-            module.exports = definition();
-          } else {
-            root.log = definition();
-          }
-        })(loglevel, 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]);
-                };
-              }
-            }
-          }
-
-          // 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();
-          }
-
-          // 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;
-            }
-          }
-
-          // These private functions always need `this` to be set properly
-
-          function replaceLoggingMethods() {
-            /*jshint validthis:true */
-            var level = this.getLevel();
-
-            // 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);
-            }
-
-            // Define log.log as an alias for log.debug
-            this.log = this.debug;
-
-            // Return any important warnings.
-            if (typeof console === undefinedType && level < this.levels.SILENT) {
-              return "No console available for logging";
+    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);
             }
-          }
+          });
+        }
+        throw new TypeError('Unable to lift unknown Observable type');
+      };
+    }
 
-          // 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);
-              }
-            };
+    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);
           }
-
-          // 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);
+        } : _super.prototype._next;
+        _this._error = onError ? function (err) {
+          try {
+            onError(err);
+          } catch (err) {
+            destination.error(err);
+          } finally {
+            this.unsubscribe();
           }
-          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;
+        } : _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));
+        }
+      };
+      return OperatorSubscriber;
+    }(Subscriber);
 
-              // Use localStorage if available
-              try {
-                window.localStorage[storageKey] = levelName;
-                return;
-              } catch (ignore) {}
+    var ObjectUnsubscribedError = createErrorClass(function (_super) {
+      return function ObjectUnsubscribedErrorImpl() {
+        _super(this);
+        this.name = 'ObjectUnsubscribedError';
+        this.message = 'object unsubscribed';
+      };
+    });
 
-              // Use session cookie as fallback
-              try {
-                window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
-              } catch (ignore) {}
+    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);
             }
-            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) {}
+            try {
+              for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var observer = _c.value;
+                observer.next(value);
               }
-
-              // If the stored level is not valid, treat it as if nothing was stored.
-              if (self.levels[storedLevel] === undefined) {
-                storedLevel = undefined;
+            } 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;
               }
-              return storedLevel;
             }
-            function clearPersistedLevel() {
-              if (typeof window === undefinedType || !storageKey) return;
-
-              // 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) {}
+          }
+        });
+      };
+      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);
             }
-            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);
-              }
+          }
+        });
+      };
+      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);
 
-            /*
-             *
-             * 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);
-              }
-
-              // 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();
-                }
-              }
-            };
+    var EmptyError = createErrorClass(function (_super) {
+      return function EmptyErrorImpl() {
+        _super(this);
+        this.name = 'EmptyError';
+        this.message = 'no elements in sequence';
+      };
+    });
 
-            // Initialize all the internal levels.
-            inheritedLevel = normalizeLevel(defaultLogger ? defaultLogger.getLevel() : "WARN");
-            var initialLevel = getPersistedLevel();
-            if (initialLevel != null) {
-              userLevel = normalizeLevel(initialLevel);
+    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());
             }
-            replaceLoggingMethods.call(self);
           }
+        });
+        source.subscribe(subscriber);
+      });
+    }
 
-          /*
-           *
-           * 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;
-          };
+    function map(project, thisArg) {
+      return operate(function (source, subscriber) {
+        var index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+          subscriber.next(project.call(thisArg, value, index++));
+        }));
+      });
+    }
 
-          // ES6 default export, for compatibility
-          defaultLogger['default'] = defaultLogger;
-          return defaultLogger;
-        });
-      })(loglevel$1);
-      return loglevel$1.exports;
+    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);
+        }));
+      });
     }
 
-    var loglevelExports = requireLoglevel();
-    var log$1 = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
+    // refer to realm-network-api/src/common/enums/error-codes.enum.ts
+    /*** Authentication Errors ***/
+    var AuthErrorName;
+    (function (AuthErrorName) {
+      AuthErrorName["UNAUTHORIZED"] = "UNAUTHORIZED";
+      AuthErrorName["INVALID_TOKEN"] = "INVALID_TOKEN";
+      AuthErrorName["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+      AuthErrorName["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
+    })(AuthErrorName || (AuthErrorName = {}));
+    /*** Partner Access Token Errors ***/
+    var PartnerAccessTokenErrorName;
+    (function (PartnerAccessTokenErrorName) {
+      PartnerAccessTokenErrorName["PARTNER_ACCESS_TOKEN_INVALID"] = "PARTNER_ACCESS_TOKEN_INVALID";
+      PartnerAccessTokenErrorName["USER_MISMATCH"] = "USER_MISMATCH";
+    })(PartnerAccessTokenErrorName || (PartnerAccessTokenErrorName = {}));
+    /*** Realm ID Errors ***/
+    var RealmIDErrorName;
+    (function (RealmIDErrorName) {
+      RealmIDErrorName["REALM_ID_NOT_FOUND"] = "REALM_ID_NOT_FOUND";
+      RealmIDErrorName["REALM_ID_INVALID_NAME"] = "REALM_ID_INVALID_NAME";
+      RealmIDErrorName["REALM_ID_ALREADY_EXISTS"] = "REALM_ID_ALREADY_EXISTS";
+      RealmIDErrorName["REALM_ID_DUPLICATE_PARTNER_USER"] = "REALM_ID_DUPLICATE_PARTNER_USER";
+    })(RealmIDErrorName || (RealmIDErrorName = {}));
+    /*** Parameter Errors ***/
+    var ParameterErrorName;
+    (function (ParameterErrorName) {
+      ParameterErrorName["INVALID_PARAMETER"] = "INVALID_PARAMETER";
+    })(ParameterErrorName || (ParameterErrorName = {}));
+    /*** Server Errors ***/
+    var ServerErrorName;
+    (function (ServerErrorName) {
+      ServerErrorName["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+    })(ServerErrorName || (ServerErrorName = {}));
+    /*** Passkey Errors ***/
+    var PasskeyErrorName;
+    (function (PasskeyErrorName) {
+      PasskeyErrorName["PASSKEY_REGISTRATION_FAILED"] = "PASSKEY_REGISTRATION_FAILED";
+      PasskeyErrorName["PASSKEY_AUTHENTICATION_FAILED"] = "PASSKEY_AUTHENTICATION_FAILED";
+      PasskeyErrorName["PASSKEY_LIMIT_EXCEEDED"] = "PASSKEY_LIMIT_EXCEEDED";
+      PasskeyErrorName["PASSKEY_NOT_FOUND"] = "PASSKEY_NOT_FOUND";
+      PasskeyErrorName["PASSKEY_UNAUTHORIZED"] = "PASSKEY_UNAUTHORIZED";
+      PasskeyErrorName["PASSKEY_CHALLENGE_INVALID"] = "PASSKEY_CHALLENGE_INVALID";
+    })(PasskeyErrorName || (PasskeyErrorName = {}));
+    /*** Passwordless Authentication Errors ***/
+    var PasswordlessErrorName;
+    (function (PasswordlessErrorName) {
+      PasswordlessErrorName["PASSWORDLESS_CODE_EXPIRED"] = "PASSWORDLESS_CODE_EXPIRED";
+      PasswordlessErrorName["PASSWORDLESS_INVALID_CODE"] = "PASSWORDLESS_INVALID_CODE";
+      PasswordlessErrorName["PASSWORDLESS_MAX_ATTEMPTS"] = "PASSWORDLESS_MAX_ATTEMPTS";
+      PasswordlessErrorName["PASSWORDLESS_HOURLY_LIMIT"] = "PASSWORDLESS_HOURLY_LIMIT";
+      PasswordlessErrorName["PASSWORDLESS_LOCK_EXCEEDED"] = "PASSWORDLESS_LOCK_EXCEEDED";
+    })(PasswordlessErrorName || (PasswordlessErrorName = {}));
+    /*** Authentication Wallet Errors ***/
+    var AuthWalletErrorName;
+    (function (AuthWalletErrorName) {
+      AuthWalletErrorName["AUTH_WALLET_LOCK_EXCEEDED"] = "AUTH_WALLET_LOCK_EXCEEDED";
+      AuthWalletErrorName["AUTH_WALLET_NONCE_EXPIRED_OR_INVALID"] = "AUTH_WALLET_NONCE_EXPIRED_OR_INVALID";
+      AuthWalletErrorName["AUTH_WALLET_ADDRESS_MISMATCH"] = "AUTH_WALLET_ADDRESS_MISMATCH";
+      AuthWalletErrorName["AUTH_WALLET_SIGNATURE_VERIFICATION_FAILED"] = "AUTH_WALLET_SIGNATURE_VERIFICATION_FAILED";
+    })(AuthWalletErrorName || (AuthWalletErrorName = {}));
+    /*** Wallet Linking Errors ***/
+    var WalletLinkErrorName;
+    (function (WalletLinkErrorName) {
+      WalletLinkErrorName["LINK_WALLET_ALREADY_LINKED"] = "LINK_WALLET_ALREADY_LINKED";
+      WalletLinkErrorName["LINK_WALLET_LINKED_OTHER_ACCOUNT"] = "LINK_WALLET_LINKED_OTHER_ACCOUNT";
+      WalletLinkErrorName["LINK_EMAIL_LINKED_OTHER_ACCOUNT"] = "LINK_EMAIL_LINKED_OTHER_ACCOUNT";
+    })(WalletLinkErrorName || (WalletLinkErrorName = {}));
+    /*** Intent Errors ***/
+    var IntentErrorName;
+    (function (IntentErrorName) {
+      IntentErrorName["INTENT_INVALID"] = "INTENT_INVALID";
+      IntentErrorName["INTENT_LOCK_EXCEEDED"] = "INTENT_LOCK_EXCEEDED";
+      IntentErrorName["INTENT_REQUIRED"] = "INTENT_REQUIRED";
+      IntentErrorName["INTENT_UNSUPPORTED_TYPE"] = "INTENT_UNSUPPORTED_TYPE";
+    })(IntentErrorName || (IntentErrorName = {}));
+    /*** Privy Errors ***/
+    var PrivyErrorName;
+    (function (PrivyErrorName) {
+      PrivyErrorName["WALLET_PROVIDER_ERROR"] = "WALLET_PROVIDER_ERROR";
+    })(PrivyErrorName || (PrivyErrorName = {}));
+    /*** Air ID Errors ***/
+    var AirIDErrorName;
+    (function (AirIDErrorName) {
+      AirIDErrorName["AIR_ID_MINT_TRANSACTION_NOT_FOUND"] = "AIR_ID_MINT_TRANSACTION_NOT_FOUND";
+      AirIDErrorName["AIR_ID_ON_CHAIN_TRANSACTION_NOT_FOUND"] = "AIR_ID_ON_CHAIN_TRANSACTION_NOT_FOUND";
+      AirIDErrorName["AIR_ID_NOT_FOUND"] = "AIR_ID_NOT_FOUND";
+      AirIDErrorName["AIR_ID_INVALID_OR_DISABLED_CONFIGURATION"] = "AIR_ID_INVALID_OR_DISABLED_CONFIGURATION";
+      AirIDErrorName["AIR_ID_RPC_URL_NOT_CONFIGURED"] = "AIR_ID_RPC_URL_NOT_CONFIGURED";
+      AirIDErrorName["AIR_ID_INVALID_STATUS"] = "AIR_ID_INVALID_STATUS";
+      AirIDErrorName["AIR_ID_PARTNER_ELIGIBILITY_CHECK_FAILED"] = "AIR_ID_PARTNER_ELIGIBILITY_CHECK_FAILED";
+      AirIDErrorName["AIR_ID_PARTNER_ELIGIBILITY_CHECK_TIMEOUT"] = "AIR_ID_PARTNER_ELIGIBILITY_CHECK_TIMEOUT";
+      AirIDErrorName["AIR_ID_MULTIPLE_AIR_IDS_FOUND"] = "AIR_ID_MULTIPLE_AIR_IDS_FOUND";
+      AirIDErrorName["AIR_ID_NAME_RESERVED"] = "AIR_ID_NAME_RESERVED";
+      AirIDErrorName["AIR_ID_NAME_PROFANITY"] = "AIR_ID_NAME_PROFANITY";
+      AirIDErrorName["AIR_ID_USER_ALREADY_HAS_AIR_ID"] = "AIR_ID_USER_ALREADY_HAS_AIR_ID";
+      AirIDErrorName["AIR_ID_NAME_ALREADY_EXISTS"] = "AIR_ID_NAME_ALREADY_EXISTS";
+      AirIDErrorName["AIR_ID_INVALID_MINT_NAME"] = "AIR_ID_INVALID_MINT_NAME";
+      AirIDErrorName["AIR_ID_MINT_TRANSACTION_HASH_MISMATCH"] = "AIR_ID_MINT_TRANSACTION_HASH_MISMATCH";
+    })(AirIDErrorName || (AirIDErrorName = {}));
+    /*** Window Errors ***/
+    var WindowErrorName;
+    (function (WindowErrorName) {
+      WindowErrorName["WINDOW_BLOCKED"] = "WINDOW_BLOCKED";
+      WindowErrorName["WINDOW_CLOSED"] = "WINDOW_CLOSED";
+    })(WindowErrorName || (WindowErrorName = {}));
+    const Codes = {
+      ...AuthErrorName,
+      ...PartnerAccessTokenErrorName,
+      ...RealmIDErrorName,
+      ...ParameterErrorName,
+      ...ServerErrorName,
+      ...PasskeyErrorName,
+      ...PasswordlessErrorName,
+      ...AuthWalletErrorName,
+      ...WalletLinkErrorName,
+      ...IntentErrorName,
+      ...PrivyErrorName,
+      ...AirIDErrorName,
+      ...WindowErrorName
+    };
 
-    var log = log$1.getLogger("airkit");
+    const AirClientUserErrors = ["USER_CANCELLED", "CONFIG_ERROR", "CLIENT_ERROR", "UNKNOWN_ERROR", "PERMISSION_NOT_ENABLED", "SMART_ACCOUNT_NOT_DEPLOYED"];
 
-    var AirWalletProviderMessageTypes;
-    (function (AirWalletProviderMessageTypes) {
-      AirWalletProviderMessageTypes["REQUEST"] = "JRPC_REQUEST";
-      AirWalletProviderMessageTypes["RESPONSE"] = "JRPC_RESPONSE";
-      AirWalletProviderMessageTypes["EVENT"] = "JRPC_EVENT";
-    })(AirWalletProviderMessageTypes || (AirWalletProviderMessageTypes = {}));
+    class AirError extends BaseError {}
+    new Set(AirClientUserErrors);
+    new Set(Object.values(Codes));
 
-    const ACCOUNT_MESSAGES = [
-        AirMessageTypes.INITIALIZATION_RESPONSE,
-        AirMessageTypes.WALLET_INITIALIZED,
-        AirMessageTypes.WALLET_LOGIN_RESPONSE,
-        AirMessageTypes.SETUP_MFA_RESPONSE,
-        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.LIST_ALL_SESSION_KEY_SCOPES_RESPONSE,
-        AirMessageTypes.WALLET_INITIALIZED,
-        AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST,
-        AirMessageTypes.LOGOUT_RESPONSE,
-        AirMessageTypes.OPEN_WINDOW_REQUEST,
-    ];
-    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.CROSS_PARTNER_TOKEN_RESPONSE,
-        AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE,
-        AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
-    ];
-    class AirMessageService {
-        constructor() {
-            this.closeAuthMessageListeners = null;
-            this.closeRealmMessageListeners = null;
-            this.closeWalletMessageListeners = null;
-        }
-        static get instance() {
-            if (!AirMessageService._instance) {
-                AirMessageService._instance = new AirMessageService();
-            }
-            return AirMessageService._instance;
-        }
-        get messages$() {
-            return this.airMessages$.asObservable();
-        }
-        get authMessage$() {
-            return this._authMessage$.asObservable();
-        }
-        get providerMessage$() {
-            return this._providerMessage$.asObservable();
-        }
-        get providerEvent$() {
-            return this._providerEvent$.asObservable();
-        }
-        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);
-            };
-        }
-        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);
-                }
-                if (ev.data.type === AirWalletProviderMessageTypes.EVENT) {
-                    this._providerEvent$.next(ev.data);
-                }
-            };
-            window.addEventListener("message", handleWalletMessage);
-            this.closeWalletMessageListeners = () => {
-                window.removeEventListener("message", handleWalletMessage);
-            };
-        }
-        setupIframeCommunication(authIframe, walletIframe, skipWalletLogin) {
-            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,
-                payload: {
-                    skipWalletLogin,
-                },
-            }, walletOrigin, [channel.port2]);
-        }
-        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 AirServiceError(result.payload.errorName, result.payload.errorMessage);
-            }
-            return result.payload.sessionData;
-        }
-        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 AirServiceError(result.payload.errorName, result.payload.errorMessage);
-            }
-            return result.payload.txHash;
-        }
-        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 AirServiceError(result.payload.errorName, result.payload.errorMessage);
-            }
-            return result.payload.txHash;
-        }
-        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 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 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;
-        }
-        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 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;
-        }
-        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;
-        }
-        sendResetAuthServiceWalletCommunication(authIframe) {
-            const { origin: authOrigin } = new URL(authIframe.src);
-            authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.RESET_WALLET_COMMUNICATION }, authOrigin);
-        }
-        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;
-        }
-        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;
-        }
-        async sendCrossPartnerTokenRequest(authIframe, targetPartnerUrl) {
-            const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE)));
-            const { origin } = new URL(authIframe.src);
-            authIframe.contentWindow.postMessage({
-                type: AirAuthMessageTypes.CROSS_PARTNER_TOKEN_REQUEST,
-                payload: {
-                    targetPartnerUrl,
-                },
-            }, origin);
-            return response;
-        }
-        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;
-        }
-        async sendListAllSessionKeyScopesRequest(walletIframe) {
-            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_RESPONSE)));
-            const { origin } = new URL(walletIframe.src);
-            walletIframe.contentWindow.postMessage({ type: AirMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_REQUEST }, origin);
-            return response;
-        }
-        onWalletInitialized() {
-            return firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.WALLET_INITIALIZED)));
-        }
-        sendWalletLoginRequest(walletIframe) {
-            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.WALLET_LOGIN_RESPONSE)));
-            const { origin } = new URL(walletIframe.src);
-            walletIframe.contentWindow.postMessage({ type: AirMessageTypes.WALLET_LOGIN_REQUEST }, origin);
-            return response;
-        }
-        async sendSetupMfaRequest(walletIframe) {
-            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.SETUP_MFA_RESPONSE)));
-            const { origin } = new URL(walletIframe.src);
-            walletIframe.contentWindow.postMessage({ type: AirMessageTypes.SETUP_MFA_REQUEST }, origin);
-            return response;
+    class MessageServiceBase {
+      get events$() {
+        return this._events$;
+      }
+      get messages$() {
+        return this._messages$;
+      }
+      get isOpen() {
+        return !!this.closeListener;
+      }
+      constructor(name, allowedMessageTypes) {
+        this.name = name;
+        this.allowedMessageTypes = allowedMessageTypes;
+        this.closeListener = null;
+      }
+      async _open(target) {
+        await this.close();
+        this.eventSubject = new Subject();
+        this._events$ = this.eventSubject.asObservable();
+        this._messages$ = this.eventSubject.pipe(map(ev => ev.data));
+        this._events$.subscribe(event => {
+          const sentOrReceived = event.origin === window.origin ? "sent" : "received";
+          log.debug(`[${this.name}] Message ${sentOrReceived}:`, event.data);
+        });
+        const handleMessage = async ev => {
+          if (this.targetOrigin && ev.origin !== this.targetOrigin || !ev.data || !(ev.data instanceof Object)) return;
+          if (this.isMessageAllowed(ev.data)) {
+            await this.onBeforeEvent(ev);
+            this.eventSubject.next(ev);
+          }
+        };
+        if (target instanceof MessagePort) {
+          this.messagePort = target;
+          target.onmessage = handleMessage;
+          this.closeListener = async () => {
+            target.close();
+          };
+        } else {
+          this.targetWindow = target.window;
+          this.targetOrigin = target.origin;
+          window.addEventListener("message", handleMessage);
+          this.closeListener = async () => {
+            window.removeEventListener("message", handleMessage);
+          };
         }
-        sendOpenWindowSuccessResponse(walletIframe, windowId, port) {
-            const { origin: walletOrigin } = new URL(walletIframe.src);
-            walletIframe.contentWindow.postMessage({
-                type: AirMessageTypes.OPEN_WINDOW_RESPONSE,
-                payload: {
-                    success: true,
-                    windowId,
-                },
-            }, walletOrigin, [port]);
+      }
+      isMessageAllowed(message) {
+        return this.allowedMessageTypes.includes(message.type);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async onBeforeEvent(_event) {
+        // by default not used
+      }
+      async close() {
+        if (this.closeListener) {
+          await this.closeListener();
         }
-        sendOpenWindowErrorResponse(walletIframe, windowId, error) {
-            const { origin: walletOrigin } = new URL(walletIframe.src);
-            walletIframe.contentWindow.postMessage({
-                type: AirMessageTypes.OPEN_WINDOW_RESPONSE,
-                payload: {
-                    success: false,
-                    windowId,
-                    errorName: "UNKNOWN_ERROR",
-                    errorMessage: error.message,
-                },
-            }, walletOrigin);
+        if (this.eventSubject && !this.eventSubject.closed) {
+          this.eventSubject.complete();
         }
-        sendWindowClosed(walletIframe, windowId) {
-            const { origin: walletOrigin } = new URL(walletIframe.src);
-            walletIframe.contentWindow.postMessage({
-                type: AirMessageTypes.WINDOW_CLOSED,
-                payload: {
-                    windowId,
-                },
-            }, walletOrigin);
+      }
+      createErrorResponseMessage(type, error) {
+        return {
+          type,
+          payload: {
+            success: false,
+            errorName: error instanceof AirError ? error.name : "UNKNOWN_ERROR",
+            errorMessage: error.message
+          }
+        };
+      }
+      async sendMessage(message, transfer) {
+        // To prevent any non-cloneable objects causing errors in postMessage
+        const clonedMessage = this.deepClone(message);
+        if (this.messagePort) {
+          this.messagePort.postMessage(clonedMessage);
+          this.eventSubject.next(new MessageEvent("message", {
+            data: clonedMessage,
+            origin: window.origin
+          }));
+        } else if (this.targetWindow && this.targetOrigin) {
+          this.targetWindow.postMessage(clonedMessage, this.targetOrigin, transfer);
+          this.eventSubject.next(new MessageEvent("message", {
+            data: clonedMessage,
+            origin: window.origin
+          }));
+        } else {
+          log.debug(`[${this.name}] Not opened yet`);
         }
-        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;
+      }
+      deepClone(message) {
+        try {
+          return JSON.parse(JSON.stringify(message));
+        } catch (e) {
+          log.error("Error generating cloneable message", e);
+          return message;
         }
-        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({
+      }
+    }
+
+    var AirWalletProviderMessageTypes;
+    (function (AirWalletProviderMessageTypes) {
+      AirWalletProviderMessageTypes["REQUEST"] = "JRPC_REQUEST";
+      AirWalletProviderMessageTypes["RESPONSE"] = "JRPC_RESPONSE";
+      AirWalletProviderMessageTypes["EVENT"] = "JRPC_EVENT";
+    })(AirWalletProviderMessageTypes || (AirWalletProviderMessageTypes = {}));
+
+    var _a$2, _ProviderMessageService_instance;
+    const ALLOWED_PROVIDER_MESSAGES = [
+        AirWalletProviderMessageTypes.RESPONSE,
+        AirWalletProviderMessageTypes.EVENT,
+    ];
+    class ProviderMessageService extends MessageServiceBase {
+        static create() {
+            if (__classPrivateFieldGet(this, _a$2, "f", _ProviderMessageService_instance))
+                throw new Error("ProviderMessageService already created");
+            __classPrivateFieldSet(this, _a$2, new _a$2("Embed Service: Provider Channel", ALLOWED_PROVIDER_MESSAGES), "f", _ProviderMessageService_instance);
+            return __classPrivateFieldGet(this, _a$2, "f", _ProviderMessageService_instance);
+        }
+        async open(walletIframe) {
+            const origin = new URL(walletIframe.src).origin;
+            const window = walletIframe.contentWindow;
+            await super._open({ window, origin });
+        }
+        async sendWalletProviderRequest(payload) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletProviderMessageTypes.RESPONSE), filter((msg) => msg.payload.method === payload.method)));
+            await this.sendMessage({
                 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._providerEvent$ && !this._providerEvent$.closed)
-                this._providerEvent$.complete();
-            if (this.closeWalletMessageListeners)
-                this.closeWalletMessageListeners();
-        }
-        setupAuthObservables() {
-            this._authMessage$ = new Subject();
-        }
-        setupAirObservables() {
-            this.airMessages$ = new Subject();
-        }
-        setupWalletObservables() {
-            this._providerMessage$ = new Subject();
-            this._providerEvent$ = new Subject();
-        }
-        async sendPartnerAccessTokenRequest(authIframe) {
-            const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE)));
-            const { origin } = new URL(authIframe.src);
-            authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_REQUEST }, origin);
+            });
             return response;
         }
     }
-    var AirMessageService$1 = AirMessageService.instance;
-
-    const BUILD_ENV = {
-        PRODUCTION: "production",
-        UAT: "uat",
-        STAGING: "staging",
-        DEVELOPMENT: "development",
-    };
-
-    const AIR_URLS = {
-        [BUILD_ENV.DEVELOPMENT]: {
-            authUrl: "http://localhost:8100",
-            walletUrl: "http://localhost:8200",
-            logLevel: "debug",
-        },
-        [BUILD_ENV.UAT]: {
-            authUrl: "https://auth.uat.air3.com",
-            walletUrl: "https://account.uat.air3.com",
-            logLevel: "info",
-        },
-        [BUILD_ENV.STAGING]: {
-            authUrl: "https://auth.staging.air3.com",
-            walletUrl: "https://account.staging.air3.com",
-            logLevel: "info",
-        },
-        [BUILD_ENV.PRODUCTION]: {
-            authUrl: "https://auth.air3.com",
-            walletUrl: "https://account.air3.com",
-            logLevel: "error",
-        },
-    };
-    const isElement = (element) => element instanceof Element || element instanceof Document;
-    const randomId = () => Math.random().toString(36).slice(2);
-    const getWindowFeatures = (width, height) => {
-        const dualScreenLeft = window.screenLeft !== undefined ? window.screenLeft : window.screenX;
-        const dualScreenTop = window.screenTop !== undefined ? window.screenTop : window.screenY;
-        const w = window.innerWidth
-            ? window.innerWidth
-            : document.documentElement.clientWidth
-                ? document.documentElement.clientWidth
-                : window.screen.width;
-        const h = window.innerHeight
-            ? window.innerHeight
-            : document.documentElement.clientHeight
-                ? document.documentElement.clientHeight
-                : window.screen.height;
-        const systemZoom = 1; // No reliable estimate
-        const left = Math.abs((w - width) / 2 / systemZoom + dualScreenLeft);
-        const top = Math.abs((h - height) / 2 / systemZoom + dualScreenTop);
-        return `titlebar=0,toolbar=0,status=0,location=0,menubar=0,height=${height / systemZoom},width=${width / systemZoom},top=${top},left=${left}`;
-    };
+    _a$2 = ProviderMessageService;
+    _ProviderMessageService_instance = { value: undefined };
 
-    var _AirWalletProvider_instances, _AirWalletProvider_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_getWalletIframeController, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
+    var _AirWalletProvider_instances, _AirWalletProvider_providerMessageService, _AirWalletProvider_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
     class AirWalletProvider {
-        constructor({ isLoggedIn, ensureWallet, getWalletIframeController, }) {
+        constructor({ isLoggedIn, ensureWallet, }) {
             _AirWalletProvider_instances.add(this);
+            _AirWalletProvider_providerMessageService.set(this, undefined);
             _AirWalletProvider_isLoggedIn.set(this, undefined);
             _AirWalletProvider_ensureWallet.set(this, undefined);
-            _AirWalletProvider_getWalletIframeController.set(this, undefined);
             _AirWalletProvider_eventListeners.set(this, undefined);
-            this.startEventMessageListening = () => {
-                AirMessageService$1.providerEvent$.subscribe((message) => {
+            this.startEventMessageListening = async (walletIframe) => {
+                await __classPrivateFieldGet(this, _AirWalletProvider_providerMessageService, "f").open(walletIframe);
+                __classPrivateFieldGet(this, _AirWalletProvider_providerMessageService, "f").messages$
+                    .pipe(filter((msg) => msg.type === AirWalletProviderMessageTypes.EVENT))
+                    .subscribe((message) => {
                     __classPrivateFieldGet(this, _AirWalletProvider_instances, "m", _AirWalletProvider_emit).call(this, message.payload.event, ...[message.payload.data]);
                 });
             };
+            __classPrivateFieldSet(this, _AirWalletProvider_providerMessageService, ProviderMessageService.create(), "f");
             __classPrivateFieldSet(this, _AirWalletProvider_isLoggedIn, isLoggedIn, "f");
             __classPrivateFieldSet(this, _AirWalletProvider_ensureWallet, ensureWallet, "f");
-            __classPrivateFieldSet(this, _AirWalletProvider_getWalletIframeController, getWalletIframeController, "f");
             __classPrivateFieldSet(this, _AirWalletProvider_eventListeners, {
                 connect: [],
                 disconnect: [],
@@ -1842,7 +1763,7 @@
                 throw ensureProviderRpcError(error);
             }
             const requestId = randomId();
-            const response = await AirMessageService$1.sendWalletProviderRequest(__classPrivateFieldGet(this, _AirWalletProvider_getWalletIframeController, "f").call(this).iframeElement, {
+            const response = await __classPrivateFieldGet(this, _AirWalletProvider_providerMessageService, "f").sendWalletProviderRequest({
                 requestId,
                 ...request,
             });
@@ -1872,13 +1793,13 @@
             }, "f");
         }
     }
-    _AirWalletProvider_isLoggedIn = new WeakMap(), _AirWalletProvider_ensureWallet = new WeakMap(), _AirWalletProvider_getWalletIframeController = new WeakMap(), _AirWalletProvider_eventListeners = new WeakMap(), _AirWalletProvider_instances = new WeakSet(), _AirWalletProvider_emit = function _AirWalletProvider_emit(eventName, ...args) {
+    _AirWalletProvider_providerMessageService = new WeakMap(), _AirWalletProvider_isLoggedIn = new WeakMap(), _AirWalletProvider_ensureWallet = new WeakMap(), _AirWalletProvider_eventListeners = new WeakMap(), _AirWalletProvider_instances = new WeakSet(), _AirWalletProvider_emit = function _AirWalletProvider_emit(eventName, ...args) {
         (__classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName] || []).forEach((listener) => {
             try {
                 return listener(...args);
             }
             catch (error) {
-                log$1.error(error);
+                log.warn(error);
             }
         });
     };
@@ -1946,85 +1867,137 @@
         isVisible: false,
     };
 
+    /**
+     * Creates a window features string for `window.open`, based on the current screen size.
+     * It tries to center the window and limits the size to the given max width and height.
+     * Slightly reduces the size to avoid browser auto-resizing.
+     */
+    const getWindowFeatures = (maxWidth, maxHeight) => {
+      const dualScreenLeft = window.screenLeft !== undefined ? window.screenLeft : window.screenX;
+      const dualScreenTop = window.screenTop !== undefined ? window.screenTop : window.screenY;
+      const w = window.innerWidth ? window.innerWidth : document.documentElement.clientWidth ? document.documentElement.clientWidth : window.screen.width;
+      const h = window.innerHeight ? window.innerHeight : document.documentElement.clientHeight ? document.documentElement.clientHeight : window.screen.height;
+      // 95% adjustment for mobile devices, some browser might resize the window
+      const finalWidth = Math.min(w, maxWidth) * 0.95;
+      const finalHeight = Math.min(h, maxHeight) * 0.95;
+      const systemZoom = 1; // No reliable estimate
+      const left = Math.abs((w - finalWidth) / 2 / systemZoom + dualScreenLeft);
+      const top = Math.abs((h - finalHeight) / 2 / systemZoom + dualScreenTop);
+      return `titlebar=0,toolbar=0,status=0,location=0,menubar=0,height=${finalHeight / systemZoom},width=${finalWidth / systemZoom},top=${top},left=${left}`;
+    };
+
     class WindowController {
-        get messages$() {
-            return this._messages$.asObservable();
-        }
-        constructor(windowUrl, windowId) {
-            this._windowInstance = null;
-            this._messageHandler = null;
-            this._messages$ = new Subject();
-            this.windowUrl = windowUrl;
-            this.windowOrigin = new URL(windowUrl).origin;
-            this.windowId = windowId;
-        }
-        get windowInstance() {
-            return this._windowInstance;
-        }
-        openWindow() {
-            if (this._windowInstance && !this._windowInstance.closed) {
-                this._windowInstance.focus();
-                return this._windowInstance;
-            }
-            const windowInstance = window.open(this.windowUrl, this.windowId, getWindowFeatures(425, 680));
-            if (!windowInstance) {
-                throw new Error("Failed to open window. Popup might be blocked by the browser.");
-            }
-            this._windowInstance = windowInstance;
-            this._messageHandler = (ev) => {
-                if (ev.source !== windowInstance ||
-                    ev.origin !== this.windowOrigin ||
-                    !ev.data ||
-                    !(ev.data instanceof Object)) {
-                    return;
-                }
-                this._messages$.next(ev);
-            };
-            window.addEventListener("message", this._messageHandler);
-            const checkWindow = setInterval(() => {
-                if (!this._windowInstance || this._windowInstance?.closed) {
-                    this.cleanup();
-                    clearInterval(checkWindow);
-                }
-            }, 500);
-            return windowInstance;
+      get messages$() {
+        return this._messages$.asObservable();
+      }
+      constructor(windowId, windowUrl) {
+        this._windowInstance = null;
+        this._messageHandler = null;
+        this._messages$ = new Subject();
+        this.windowId = windowId;
+        this.windowUrl = windowUrl;
+        this.windowOrigin = new URL(windowUrl).origin;
+        this._messageHandler = ev => {
+          if (ev.source !== this._windowInstance || ev.origin !== this.windowOrigin || !ev.data || !(ev.data instanceof Object)) {
+            return;
+          }
+          this._messages$.next(ev);
+        };
+        window.addEventListener("message", this._messageHandler);
+      }
+      get windowInstance() {
+        return this._windowInstance;
+      }
+      async openWindow(onRetry) {
+        let windowInstance = this.tryOpenWindow();
+        if (!windowInstance) {
+          await onRetry();
+          windowInstance = this.tryOpenWindow();
+          if (!windowInstance) {
+            throw new AirError(WindowErrorName.WINDOW_BLOCKED);
+          }
         }
-        postMessage(message, transfer) {
-            if (!this._windowInstance)
-                return;
-            this._windowInstance.postMessage(message, this.windowOrigin, transfer);
+        const pendingWindowOpenCheck = new Promise((resolve, reject) => {
+          setTimeout(() => {
+            if (this.isWindowOpen(windowInstance)) {
+              // only now are we scheduling the close event check since we're sure the window is open
+              this.scheduleWindowClosedChecks(windowInstance);
+              resolve("opened");
+            } else {
+              onRetry().then(() => {
+                windowInstance = this.tryOpenWindow();
+                if (windowInstance) {
+                  this._windowInstance = windowInstance;
+                  windowInstance.focus();
+                  this.scheduleWindowClosedChecks(windowInstance);
+                  resolve("retry");
+                } else {
+                  reject(new AirError(WindowErrorName.WINDOW_BLOCKED));
+                }
+              }).catch(reject);
+            }
+          }, 1000);
+        });
+        this._windowInstance = windowInstance;
+        windowInstance.focus();
+        return {
+          pendingWindowOpenCheck
+        };
+      }
+      postMessage(message, transfer) {
+        if (!this._windowInstance) return;
+        this._windowInstance.postMessage(message, this.windowOrigin, transfer);
+      }
+      onMessage(callback) {
+        const listener = ev => {
+          if (ev.source !== this._windowInstance || ev.origin !== this.windowOrigin) return;
+          callback(ev);
+        };
+        window.addEventListener("message", listener);
+        const close = () => window.removeEventListener("message", listener);
+        this.onClose(close);
+        return {
+          close
+        };
+      }
+      cleanup() {
+        if (this._windowInstance && !this._windowInstance.closed) {
+          this._windowInstance.close();
         }
-        onMessage(callback) {
-            const listener = (ev) => {
-                if (ev.source !== this._windowInstance)
-                    return;
-                callback(ev);
-            };
-            window.addEventListener("message", listener);
-            const close = () => window.removeEventListener("message", listener);
-            this.onClose(close);
-            return {
-                close,
-            };
+        this._windowInstance = null;
+        if (this._messageHandler) {
+          window.removeEventListener("message", this._messageHandler);
+          this._messageHandler = null;
         }
-        cleanup() {
-            if (this._windowInstance && !this._windowInstance.closed) {
-                this._windowInstance.close();
-            }
-            if (this._messageHandler) {
-                window.removeEventListener("message", this._messageHandler);
-                this._messageHandler = null;
-            }
-            if (this._messages$ && !this._messages$.closed) {
-                this._messages$.complete();
-            }
-            this._windowInstance = null;
+        if (this._messages$ && !this._messages$.closed) {
+          this._messages$.complete();
         }
-        onClose(callback) {
-            return this._messages$.subscribe({
-                complete: callback,
-            });
+      }
+      onClose(callback) {
+        return this._messages$.subscribe({
+          complete: callback
+        });
+      }
+      isWindowOpen(windowInstance) {
+        return !(!windowInstance || windowInstance.closed || typeof windowInstance.closed == "undefined");
+      }
+      tryOpenWindow() {
+        const windowInstance = window.open(this.windowUrl, this.windowId, getWindowFeatures(425, 680));
+        if (this.isWindowOpen(windowInstance)) {
+          return windowInstance;
         }
+        return null;
+      }
+      scheduleWindowClosedChecks(windowInstance) {
+        const checkWindow = setInterval(() => {
+          if (!windowInstance || windowInstance.closed) {
+            clearInterval(checkWindow);
+            if (windowInstance === this._windowInstance) {
+              this.cleanup();
+            }
+          }
+        }, 500);
+      }
     }
 
     class WindowService {
@@ -2043,37 +2016,58 @@
             if (!windowInstance) {
                 throw new Error("Window instance not found");
             }
-            const response = firstValueFrom(windowController.messages$.pipe(filter((event) => event.data.type === AirMessageTypes.INITIALIZATION_RESPONSE)));
-            windowController.postMessage({ type: AirMessageTypes.INITIALIZATION_REQUEST, payload }, [port]);
+            const response = firstValueFrom(windowController.messages$.pipe(filter((event) => event.data.type ===
+                AirWalletMessageTypes.INITIALIZATION_RESPONSE)));
+            windowController.postMessage({ type: AirWalletMessageTypes.INITIALIZATION_REQUEST, payload }, [
+                port,
+            ]);
             return (await response).data;
         }
-        async openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, port, }) {
+        async openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, onRetry, }) {
             if (this.windowControllers.has(windowId)) {
                 throw new Error("Window controller already exists");
             }
-            const windowController = new WindowController(url, windowId);
-            this.windowControllers.set(windowId, windowController);
-            windowController.openWindow();
+            const windowController = new WindowController(windowId, url);
+            const { pendingWindowOpenCheck } = await windowController.openWindow(onRetry);
             windowController.onClose(() => {
                 this.removeWindowController(windowId);
             });
-            await new Promise((resolve, reject) => {
-                windowController.onMessage(async (ev) => {
-                    if (ev.data === AirMessageTypes.SERVICE_STARTED) {
-                        const { payload } = await this.sendWindowInitializationRequest(windowId, {
-                            partnerId,
-                            enableLogging,
-                        }, port);
-                        if (payload.success === false) {
-                            reject(new AirServiceError(payload.errorName, payload.errorMessage));
-                        }
-                        else {
-                            resolve();
+            this.windowControllers.set(windowId, windowController);
+            let channel = null;
+            const initializeWindow = () => {
+                return new Promise((resolve, reject) => {
+                    windowController.onMessage(async (ev) => {
+                        if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
+                            try {
+                                channel = new MessageChannel();
+                                const { payload } = await this.sendWindowInitializationRequest(windowId, {
+                                    partnerId,
+                                    enableLogging,
+                                }, channel.port1);
+                                if (payload.success === false) {
+                                    reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                                }
+                                else {
+                                    resolve();
+                                }
+                            }
+                            catch (e) {
+                                reject(e);
+                            }
                         }
-                    }
+                    });
                 });
-            });
-            return windowController;
+            };
+            const initializeWindowPromise = initializeWindow();
+            const result = await pendingWindowOpenCheck;
+            if (result === "retry") {
+                // we can ignore previous initialization attempt since a new window was opened
+                await initializeWindow();
+            }
+            else {
+                await initializeWindowPromise;
+            }
+            return { windowController, port: channel.port2 };
         }
         getWindowController(windowId) {
             return this.windowControllers.get(windowId);
@@ -2084,7 +2078,380 @@
     }
     var WindowService$1 = WindowService.instance;
 
-    var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_walletLoggedInResult, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_subscribeToWalletEvents, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_createWalletInitializedResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
+    var _a$1, _AuthMessageService_instance;
+    const ALLOWED_AUTH_MESSAGES = [
+        AirAuthMessageTypes.INITIALIZATION_RESPONSE,
+        AirAuthMessageTypes.LOGIN_RESPONSE,
+        AirAuthMessageTypes.SETUP_WALLET_REQUEST,
+        AirAuthMessageTypes.LOGOUT_RESPONSE,
+        AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
+        AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE,
+        AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE,
+        AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
+    ];
+    class AuthMessageService extends MessageServiceBase {
+        static create() {
+            if (__classPrivateFieldGet(this, _a$1, "f", _AuthMessageService_instance))
+                throw new Error("AuthMessageService already created");
+            __classPrivateFieldSet(this, _a$1, new _a$1("Embed Service: Auth Channel", ALLOWED_AUTH_MESSAGES), "f", _AuthMessageService_instance);
+            return __classPrivateFieldGet(this, _a$1, "f", _AuthMessageService_instance);
+        }
+        async open(authIframe) {
+            const origin = new URL(authIframe.src).origin;
+            const window = authIframe.contentWindow;
+            await super._open({ window, origin });
+        }
+        async initWalletCommunication(port) {
+            await this.sendMessage({
+                type: AirAuthMessageTypes.INIT_WALLET_COMMUNICATION,
+            }, [port]);
+        }
+        async sendPartnerUserInfoRequest() {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE)));
+            await this.sendMessage({
+                type: AirAuthMessageTypes.PARTNER_USER_INFO_REQUEST,
+                payload: { allowCache: false },
+            });
+            return response;
+        }
+        async sendLoginRequest(payload) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LOGIN_RESPONSE)));
+            await this.sendMessage({ type: AirAuthMessageTypes.LOGIN_REQUEST, payload });
+            return response;
+        }
+        async logout() {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LOGOUT_RESPONSE)));
+            await this.sendMessage({ type: AirAuthMessageTypes.LOGOUT_REQUEST });
+            return response;
+        }
+        async resetWalletCommunication() {
+            await this.sendMessage({ type: AirAuthMessageTypes.RESET_WALLET_COMMUNICATION });
+        }
+        async sendInitializationRequest(payload) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.INITIALIZATION_RESPONSE)));
+            await this.sendMessage({ type: AirAuthMessageTypes.INITIALIZATION_REQUEST, payload });
+            return response;
+        }
+        async sendSetupWalletSuccessResponse() {
+            await this.sendMessage({
+                type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+                payload: {
+                    success: true,
+                },
+            });
+        }
+        async sendSetupWalletErrorResponse(error) {
+            await this.sendMessage(this.createErrorResponseMessage(AirAuthMessageTypes.SETUP_WALLET_RESPONSE, error));
+        }
+        async sendCrossPartnerTokenRequest(targetPartnerUrl) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE)));
+            await this.sendMessage({
+                type: AirAuthMessageTypes.CROSS_PARTNER_TOKEN_REQUEST,
+                payload: {
+                    targetPartnerUrl,
+                },
+            });
+            return response;
+        }
+        async sendPartnerAccessTokenRequest() {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE)));
+            await this.sendMessage({ type: AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_REQUEST });
+            return response;
+        }
+    }
+    _a$1 = AuthMessageService;
+    _AuthMessageService_instance = { value: undefined };
+
+    var _a, _WalletMessageService_instance;
+    const ALLOWED_WALLET_MESSAGES = [
+        AirWalletMessageTypes.INITIALIZATION_RESPONSE,
+        AirWalletMessageTypes.WALLET_INITIALIZED,
+        AirWalletMessageTypes.WALLET_LOGIN_RESPONSE,
+        AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_RESPONSE,
+        AirWalletMessageTypes.CLAIM_ID_RESPONSE,
+        AirWalletMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_RESPONSE,
+        AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE,
+        AirWalletMessageTypes.EXECUTE_ACTION_RESPONSE,
+        AirWalletMessageTypes.REVOKE_PERMISSIONS_RESPONSE,
+        AirWalletMessageTypes.GRANT_PERMISSIONS_RESPONSE,
+        AirWalletMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_RESPONSE,
+        AirWalletMessageTypes.WALLET_INITIALIZED,
+        AirWalletMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST,
+        AirWalletMessageTypes.LOGOUT_RESPONSE,
+        AirWalletMessageTypes.OPEN_WINDOW_REQUEST,
+        AirWalletMessageTypes.OPEN_WINDOW_RETRY_RESPONSE,
+    ];
+    class WalletMessageService extends MessageServiceBase {
+        static create() {
+            if (__classPrivateFieldGet(this, _a, "f", _WalletMessageService_instance))
+                throw new Error("WalletMessageService already created");
+            __classPrivateFieldSet(this, _a, new _a("Embed Service: Wallet Channel", ALLOWED_WALLET_MESSAGES), "f", _WalletMessageService_instance);
+            return __classPrivateFieldGet(this, _a, "f", _WalletMessageService_instance);
+        }
+        async open(walletIframe) {
+            const origin = new URL(walletIframe.src).origin;
+            const window = walletIframe.contentWindow;
+            await super._open({ window, origin });
+        }
+        async initAuthCommunication(skipWalletLogin, port) {
+            await this.sendMessage({
+                type: AirWalletMessageTypes.INIT_AUTH_COMMUNICATION,
+                payload: {
+                    skipWalletLogin,
+                },
+            }, [port]);
+        }
+        async sendGrantPermissionRequest(policies) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
+            await this.sendMessage({
+                type: AirWalletMessageTypes.GRANT_PERMISSIONS_REQUEST,
+                payload: {
+                    policies,
+                },
+            });
+            const result = await response;
+            if (result.payload.success === false) {
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+            }
+            return result.payload.sessionData;
+        }
+        async sendExecuteActionRequest(params) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.EXECUTE_ACTION_RESPONSE)));
+            await this.sendMessage({
+                type: AirWalletMessageTypes.EXECUTE_ACTION_REQUEST,
+                payload: {
+                    sessionData: params.sessionData,
+                    call: {
+                        to: params.call.to,
+                        value: params.call.value,
+                        data: params.call.data,
+                    },
+                    sessionOwnerPrivateKey: params.sessionOwnerPrivateKey,
+                },
+            });
+            const result = await response;
+            if (result.payload.success === false) {
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+            }
+            return result.payload.txHash;
+        }
+        async sendRevokePermissionsRequest(permissionId) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.REVOKE_PERMISSIONS_RESPONSE)));
+            await this.sendMessage({
+                type: AirWalletMessageTypes.REVOKE_PERMISSIONS_REQUEST,
+                payload: {
+                    permissionId,
+                },
+            });
+            const result = await response;
+            if (result.payload.success === false) {
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+            }
+            return result.payload.txHash;
+        }
+        async sendDeploySmartAccountRequest() {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE)));
+            await this.sendMessage({
+                type: AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_REQUEST,
+            });
+            return response;
+        }
+        async sendIsSmartAccountDeployedRequest() {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_RESPONSE)));
+            await this.sendMessage({
+                type: AirWalletMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_REQUEST,
+            });
+            return response;
+        }
+        async logout() {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.LOGOUT_RESPONSE)));
+            await this.sendMessage({ type: AirWalletMessageTypes.LOGOUT_REQUEST });
+            return response;
+        }
+        async sendInitializationRequest(payload) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.INITIALIZATION_RESPONSE)));
+            await this.sendMessage({ type: AirWalletMessageTypes.INITIALIZATION_REQUEST, payload });
+            return response;
+        }
+        async sendGrantPermissionsRequest(payload) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
+            await this.sendMessage({ type: AirWalletMessageTypes.GRANT_PERMISSIONS_REQUEST, payload });
+            return response;
+        }
+        async sendListAllSessionKeyScopesRequest() {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_RESPONSE)));
+            await this.sendMessage({ type: AirWalletMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_REQUEST });
+            return response;
+        }
+        onInitialized() {
+            return firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.WALLET_INITIALIZED)));
+        }
+        async sendLoginRequest() {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.WALLET_LOGIN_RESPONSE)));
+            await this.sendMessage({
+                type: AirWalletMessageTypes.WALLET_LOGIN_REQUEST,
+            });
+            return response;
+        }
+        async sendSetupMfaRequest() {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_RESPONSE)));
+            await this.sendMessage({
+                type: AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_REQUEST,
+            });
+            return response;
+        }
+        async sendOpenWindowSuccessResponse(windowId, port) {
+            await this.sendMessage({
+                type: AirWalletMessageTypes.OPEN_WINDOW_RESPONSE,
+                payload: {
+                    success: true,
+                    windowId,
+                },
+            }, [port]);
+        }
+        async sendOpenWindowErrorResponse(windowId, error) {
+            const errorResponse = this.createErrorResponseMessage(AirWalletMessageTypes.OPEN_WINDOW_RESPONSE, error);
+            await this.sendMessage({
+                ...errorResponse,
+                payload: { ...errorResponse.payload, windowId },
+            });
+        }
+        async sendOpenWindowRetryRequest(windowId) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.OPEN_WINDOW_RETRY_RESPONSE), filter((msg) => msg.payload.windowId === windowId)));
+            await this.sendMessage({
+                type: AirWalletMessageTypes.OPEN_WINDOW_RETRY_REQUEST,
+                payload: { windowId },
+            });
+            return response;
+        }
+        async sendWindowClosed(windowId) {
+            await this.sendMessage({
+                type: AirWalletMessageTypes.WINDOW_CLOSED,
+                payload: {
+                    windowId,
+                },
+            });
+        }
+        async sendClaimIdRequest(payload) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.CLAIM_ID_RESPONSE)));
+            await this.sendMessage({ type: AirWalletMessageTypes.CLAIM_ID_REQUEST, payload });
+            return response;
+        }
+    }
+    _a = WalletMessageService;
+    _WalletMessageService_instance = { value: undefined };
+
+    function getLevelName(levelNum) {
+      const levelNames = Object.keys(log.levels);
+      if (levelNum >= 0 && levelNum < levelNames.length) {
+        return levelNames[levelNum];
+      }
+      return "UNKNOWN";
+    }
+    const configureLogLevel = (environment, enableLogging) => {
+      let level = log.levels.ERROR;
+      if (environment === "development") {
+        level = enableLogging ? log.levels.TRACE : log.levels.DEBUG;
+      } else if (environment === "staging") {
+        level = enableLogging ? log.levels.DEBUG : log.levels.INFO;
+      } else if (environment === "uat") {
+        level = enableLogging ? log.levels.INFO : log.levels.WARN;
+      } else if (environment === "production") {
+        // Be cautious with enabling more than WARN in prod
+        level = enableLogging ? log.levels.WARN : log.levels.ERROR;
+      }
+      log.setLevel(level);
+      log.info(`[${window?.location?.origin}] Log level set to: ${getLevelName(log.getLevel())}`);
+    };
+
+    var name = "@mocanetwork/airkit";
+    var version = "1.2.0-beta.3";
+    var description = "Air kit to interact with the Moca Network";
+    var main = "dist/airkit.cjs.js";
+    var module = "dist/airkit.esm.js";
+    var unpkg = "dist/airkit.umd.min.js";
+    var jsdelivr = "dist/airkit.umd.min.js";
+    var types = "dist/types/index.d.ts";
+    var files = [
+    	"dist"
+    ];
+    var scripts = {
+    	build: "rollup --config",
+    	prepack: "npm run build && npm run postbuild",
+    	lint: "eslint --fix 'src/**/*.ts'",
+    	format: "prettier --write 'src/**/*.ts'",
+    	postbuild: "node scripts/copyAndAdjustDtsFiles.js '../common/src' 'common'"
+    };
+    var dependencies = {
+    	"fast-deep-equal": "^3.1.3",
+    	loglevel: "^1.9.2",
+    	pump: "^3.0.0",
+    	"readable-stream": "^4.5.2",
+    	rxjs: "^7.8.1"
+    };
+    var devDependencies = {
+    	"@babel/runtime": "^7.25.6",
+    	"@rushstack/eslint-patch": "^1.10.2",
+    	"@types/pump": "^1.1.3",
+    	"@types/readable-stream": "^4.0.15",
+    	"fs-extra": "^11.2.0",
+    	glob: "^11.0.0",
+    	process: "^0.11.10",
+    	"typescript-eslint": "^8.21.0"
+    };
+    var mocha = {
+    	timeout: 0
+    };
+    var keywords = [
+    	"airkit",
+    	"mocaverse",
+    	"wallet",
+    	"embed",
+    	"login",
+    	"OAuth",
+    	"crypto"
+    ];
+    var author = "Mocaverse";
+    var license = "ISC";
+    var engines = {
+    	node: ">=18.x",
+    	npm: ">=9.x"
+    };
+    var publishConfig = {
+    	access: "restricted"
+    };
+    var airkitPackage = {
+    	name: name,
+    	version: version,
+    	description: description,
+    	main: main,
+    	module: module,
+    	unpkg: unpkg,
+    	jsdelivr: jsdelivr,
+    	types: types,
+    	files: files,
+    	scripts: scripts,
+    	dependencies: dependencies,
+    	devDependencies: devDependencies,
+    	mocha: mocha,
+    	keywords: keywords,
+    	author: author,
+    	license: license,
+    	"lint-staged": {
+    	"!(*d).{js,ts}": [
+    		"eslint --cache --fix",
+    		"prettier --write"
+    	],
+    	"*.{json, md}": [
+    		"prettier --write"
+    	]
+    },
+    	engines: engines,
+    	publishConfig: publishConfig
+    };
+
+    var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authMessagingService, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletMessagingService, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_walletLoggedInResult, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_subscribeToWalletEvents, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_createWalletInitializedResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
+    const airKitVersion = airkitPackage.version;
     class AirService {
         constructor({ partnerId }) {
             _AirService_instances.add(this);
@@ -2093,18 +2460,21 @@
             _AirService_enableLogging.set(this, false);
             _AirService_partnerId.set(this, undefined);
             //#modalZIndex: number; TODO implement z index overwrite
+            _AirService_authMessagingService.set(this, undefined);
             _AirService_authIframeController.set(this, undefined);
             _AirService_isAuthInitialized.set(this, false);
             _AirService_airAuthListener.set(this, []);
+            _AirService_walletMessagingService.set(this, undefined);
             _AirService_walletIframeController.set(this, undefined);
             _AirService_walletInitialization.set(this, undefined);
             _AirService_walletLoggedInResult.set(this, undefined);
             _AirService_airWalletProvider.set(this, undefined);
             __classPrivateFieldSet(this, _AirService_partnerId, partnerId, "f");
+            __classPrivateFieldSet(this, _AirService_authMessagingService, AuthMessageService.create(), "f");
+            __classPrivateFieldSet(this, _AirService_walletMessagingService, WalletMessageService.create(), "f");
             __classPrivateFieldSet(this, _AirService_airWalletProvider, new AirWalletProvider({
                 isLoggedIn: () => this.isLoggedIn,
                 ensureWallet: __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).bind(this),
-                getWalletIframeController: () => __classPrivateFieldGet(this, _AirService_walletIframeController, "f"),
             }), "f");
             // this.#modalZIndex = modalZIndex ?? 99999;
         }
@@ -2135,61 +2505,46 @@
                 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 { authUrl } = AIR_URLS[buildEnv];
+            configureLogLevel(buildEnv, enableLogging);
             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, { skipWalletLogin: true });
-                            __classPrivateFieldGet(this, _AirService_authIframeController, "f").postMessage({
-                                type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
-                                payload: {
-                                    success: true,
-                                },
-                            });
+            try {
+                __classPrivateFieldGet(this, _AirService_authIframeController, "f").createIframe();
+                await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").open(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+                __classPrivateFieldGet(this, _AirService_authMessagingService, "f").messages$.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;
                         }
-                        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",
-                                },
-                            });
+                        case AirAuthMessageTypes.SETUP_WALLET_REQUEST: {
+                            try {
+                                await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, { skipWalletLogin: true });
+                                await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendSetupWalletSuccessResponse();
+                            }
+                            catch (err) {
+                                const error = ensureError(err);
+                                await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendSetupWalletErrorResponse(error);
+                            }
+                            break;
                         }
-                        break;
                     }
-                }
-            });
-            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, {
+                            const { payload } = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendInitializationRequest({
                                 partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                                 skipRehydration,
                                 partnerDAppUrl: window.location.href,
+                                sdkVersion: airKitVersion,
+                                enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
                             });
                             if (payload.success === true) {
                                 resolve(payload);
@@ -2222,8 +2577,7 @@
                 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, {
+            const { payload } = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendLoginRequest({
                 partnerLoginToken: options?.authToken,
             });
             if (payload.success === true) {
@@ -2242,7 +2596,7 @@
             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);
+                const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendDeploySmartAccountRequest();
                 if (payload.success === false) {
                     throw new AirServiceError(payload.errorName, payload.errorMessage);
                 }
@@ -2261,7 +2615,9 @@
             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 });
+                const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendGrantPermissionsRequest({
+                    policies,
+                });
                 if (payload.success === false) {
                     throw new AirServiceError(payload.errorName, payload.errorMessage);
                 }
@@ -2279,7 +2635,7 @@
                 throw new Error("Service is not initialized");
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
             try {
-                const { payload } = await AirMessageService$1.sendListAllSessionKeyScopesRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+                const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendListAllSessionKeyScopesRequest();
                 if (payload.success === false) {
                     throw new AirServiceError(payload.errorName, payload.errorMessage);
                 }
@@ -2298,7 +2654,7 @@
             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);
+                const txHash = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendExecuteActionRequest(params);
                 return txHash;
             }
             catch (error) {
@@ -2314,7 +2670,7 @@
             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);
+                const txHash = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendRevokePermissionsRequest(permissionId);
                 return txHash;
             }
             catch (error) {
@@ -2329,7 +2685,7 @@
                 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);
+                const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendIsSmartAccountDeployedRequest();
                 if (payload.success === false) {
                     throw new AirServiceError(payload.errorName, payload.errorMessage);
                 }
@@ -2347,14 +2703,18 @@
         }
         async setupOrUpdateMfa() {
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, { skipWalletLogin: true });
-            const result = await AirMessageService$1.sendSetupMfaRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+            const result = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendSetupMfaRequest();
             if (result.payload.success === false) {
                 throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
             }
+            __classPrivateFieldSet(this, _AirService_loginResult, {
+                ...__classPrivateFieldGet(this, _AirService_loginResult, "f"),
+                isMFASetup: true,
+            }, "f");
         }
         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 ?? {});
+            const result = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendClaimIdRequest(options ?? {});
             if (result.payload.success === true) {
                 return { airId: result.payload.airId };
             }
@@ -2363,7 +2723,7 @@
         async getUserInfo() {
             if (!this.isLoggedIn)
                 throw new Error("User not logged in");
-            const info = await AirMessageService$1.sendPartnerUserInfoRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+            const info = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendPartnerUserInfoRequest();
             if (info.payload.success === false) {
                 throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
             }
@@ -2384,7 +2744,7 @@
                 throw new Error("Service is not initialized");
             if (!this.isLoggedIn)
                 throw new Error("No active session to generate token");
-            const result = await AirMessageService$1.sendCrossPartnerTokenRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, partnerUrl);
+            const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendCrossPartnerTokenRequest(partnerUrl);
             if (result.payload.success === false) {
                 throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
             }
@@ -2397,7 +2757,7 @@
                 throw new Error("Service is not initialized");
             if (!this.isLoggedIn)
                 throw new Error("No active session to get partner access token");
-            const result = await AirMessageService$1.sendPartnerAccessTokenRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+            const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendPartnerAccessTokenRequest();
             if (result.payload.success !== true) {
                 throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
             }
@@ -2413,7 +2773,7 @@
                 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);
+            await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").logout();
             __classPrivateFieldSet(this, _AirService_loginResult, undefined, "f");
             __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedOut).call(this);
         }
@@ -2434,7 +2794,7 @@
             __classPrivateFieldSet(this, _AirService_airAuthListener, [], "f");
         }
     }
-    _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_walletLoggedInResult = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet(option) {
+    _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_authMessagingService = new WeakMap(), _AirService_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airAuthListener = new WeakMap(), _AirService_walletMessagingService = new WeakMap(), _AirService_walletIframeController = new WeakMap(), _AirService_walletInitialization = new WeakMap(), _AirService_walletLoggedInResult = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet(option) {
         if (!this.isInitialized)
             throw new Error("Service not initialized");
         if (!this.isLoggedIn && !option?.skipWalletLogin)
@@ -2456,7 +2816,7 @@
         }
         if (__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f"))
             return __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f");
-        const walletLoginResult = await AirMessageService$1.sendWalletLoginRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+        const walletLoginResult = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendLoginRequest();
         if (walletLoginResult.payload.success !== true) {
             throw new AirServiceError(walletLoginResult.payload.errorName, walletLoginResult.payload.errorMessage);
         }
@@ -2467,20 +2827,17 @@
         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();
-            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_subscribeToWalletEvents).call(this);
-            await new Promise((resolve, reject) => {
-                const handleAuthMessage = async (ev) => {
+            const walletInitRequestPromise = new Promise((resolve, reject) => {
+                const handleWalletMessage = 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, {
+                    if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
+                        window.removeEventListener("message", handleWalletMessage);
+                        const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendInitializationRequest({
                             partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                             enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
+                            sdkVersion: airKitVersion,
                         });
                         if (payload.success === true) {
                             resolve();
@@ -2490,11 +2847,18 @@
                         }
                     }
                 };
-                window.addEventListener("message", handleAuthMessage);
+                window.addEventListener("message", handleWalletMessage);
             });
-            __classPrivateFieldGet(this, _AirService_airWalletProvider, "f").startEventMessageListening();
-            const walletInitPromise = AirMessageService$1.onWalletInitialized();
-            AirMessageService$1.setupIframeCommunication(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, __classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, option?.skipWalletLogin ?? false);
+            __classPrivateFieldSet(this, _AirService_walletIframeController, new IframeController(walletUrl, `air-wallet-${randomId()}`), "f");
+            __classPrivateFieldGet(this, _AirService_walletIframeController, "f").createIframe();
+            await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").open(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_subscribeToWalletEvents).call(this);
+            await __classPrivateFieldGet(this, _AirService_airWalletProvider, "f").startEventMessageListening(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+            const walletInitPromise = __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").onInitialized();
+            await walletInitRequestPromise;
+            const channel = new MessageChannel();
+            await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").initWalletCommunication(channel.port1);
+            await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").initAuthCommunication(option?.skipWalletLogin ?? false, channel.port2);
             const walletInitResult = await walletInitPromise;
             if (walletInitResult.payload.success !== true) {
                 throw new AirServiceError(walletInitResult.payload.errorName, walletInitResult.payload.errorMessage);
@@ -2511,37 +2875,42 @@
             throw error;
         }
     }, _AirService_subscribeToWalletEvents = function _AirService_subscribeToWalletEvents() {
-        AirMessageService$1.messages$.subscribe(async (msg) => {
+        __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").messages$.subscribe(async (msg) => {
             switch (msg.type) {
-                case AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST: {
+                case AirWalletMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST: {
                     const walletIframeController = __classPrivateFieldGet(this, _AirService_walletIframeController, "f");
                     walletIframeController.setIframeVisibility(msg.payload.visible);
                     walletIframeController.updateIframeState();
                     break;
                 }
-                case AirMessageTypes.WALLET_LOGIN_RESPONSE: {
+                case AirWalletMessageTypes.WALLET_LOGIN_RESPONSE: {
                     if (msg.payload.success === true && !__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f")) {
                         __classPrivateFieldSet(this, _AirService_walletLoggedInResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, msg.payload), "f");
                         __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerWalletInitialized).call(this, __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f"));
                     }
                     break;
                 }
-                case AirMessageTypes.OPEN_WINDOW_REQUEST: {
+                case AirWalletMessageTypes.OPEN_WINDOW_REQUEST: {
                     try {
-                        const channel = new MessageChannel();
-                        const windowController = await WindowService$1.openAndInitializeWalletServiceWindow({
+                        const onRetry = async () => {
+                            const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendOpenWindowRetryRequest(msg.payload.windowId);
+                            if (payload.success === false) {
+                                throw new AirServiceError(payload.errorName, payload.errorMessage);
+                            }
+                        };
+                        const { windowController, port } = await WindowService$1.openAndInitializeWalletServiceWindow({
                             url: msg.payload.url,
                             windowId: msg.payload.windowId,
                             partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                             enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
-                            port: channel.port1,
+                            onRetry,
                         });
-                        windowController.onClose(() => AirMessageService$1.sendWindowClosed(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, msg.payload.windowId));
-                        AirMessageService$1.sendOpenWindowSuccessResponse(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, msg.payload.windowId, channel.port2);
+                        windowController.onClose(async () => await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendWindowClosed(msg.payload.windowId));
+                        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendOpenWindowSuccessResponse(msg.payload.windowId, port);
                     }
                     catch (err) {
                         const error = ensureError(err);
-                        AirMessageService$1.sendOpenWindowErrorResponse(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, msg.payload.windowId, error);
+                        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendOpenWindowErrorResponse(msg.payload.windowId, error);
                     }
                     break;
                 }
@@ -2586,7 +2955,7 @@
         };
     }, _AirService_cleanUpAuth = async function _AirService_cleanUpAuth() {
         // Logout auth session
-        await AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").logout();
         // Destroy the auth iframe
         const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
         if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
@@ -2594,7 +2963,7 @@
             __classPrivateFieldSet(this, _AirService_authIframeController, undefined, "f");
         }
         // Close the message service
-        AirMessageService$1.closeAuthObservables();
+        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").close();
         __classPrivateFieldSet(this, _AirService_isAuthInitialized, false, "f");
     }, _AirService_cleanUpWallet = async function _AirService_cleanUpWallet() {
         if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
@@ -2602,16 +2971,16 @@
         // 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);
+            await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").logout();
             __classPrivateFieldGet(this, _AirService_walletIframeController, "f").destroy();
             __classPrivateFieldSet(this, _AirService_walletIframeController, undefined, "f");
         }
         const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
         if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
-            AirMessageService$1.sendResetAuthServiceWalletCommunication(authIframeElement);
+            await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").resetWalletCommunication();
         }
         // Close the message service
-        AirMessageService$1.closeAirObservables();
+        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").close();
         __classPrivateFieldSet(this, _AirService_walletLoggedInResult, undefined, "f");
         __classPrivateFieldSet(this, _AirService_walletInitialization, undefined, "f");
     };
@@ -2625,6 +2994,7 @@
     exports.InvalidRequestRpcError = InvalidRequestRpcError;
     exports.MethodNotFoundRpcError = MethodNotFoundRpcError;
     exports.ProviderDisconnectedError = ProviderDisconnectedError;
+    exports.ProviderRpcError = ProviderRpcError;
     exports.SwitchChainError = SwitchChainError;
     exports.TransactionRejectedRpcError = TransactionRejectedRpcError;
     exports.UnauthorizedProviderError = UnauthorizedProviderError;