@mocanetwork/airkit 1.2.1 → 1.3.0-beta.0

package/dist/airkit.umd.js

@@ -124,14 +124,14 @@
       SIGN_SIWE_MESSAGE_RESPONSE: "air_auth_sign_siwe_message_response",
       CROSS_PARTNER_TOKEN_REQUEST: "air_auth_cross_partner_token_request",
       CROSS_PARTNER_TOKEN_RESPONSE: "air_auth_cross_partner_token_response",
-      PARTNER_ACCESS_TOKEN_REQUEST: "air_auth_partner_access_token_request",
-      PARTNER_ACCESS_TOKEN_RESPONSE: "air_auth_partner_access_token_response",
+      GET_PARTNER_ACCESS_TOKEN_REQUEST: "air_auth_get_partner_access_token_request",
+      GET_PARTNER_ACCESS_TOKEN_RESPONSE: "air_auth_get_partner_access_token_response",
       LOGOUT_REQUEST: "air_auth_logout_request",
       LOGOUT_RESPONSE: "air_auth_logout_response",
       RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication"
     };
 
-    const AirWalletMessageTypes = {
+    const AirMessageTypes = {
       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_OR_UPDATE_MFA_REQUEST: "air_setup_mfa_request",
-      SETUP_OR_UPDATE_MFA_RESPONSE: "air_setup_mfa_response",
+      SETUP_MFA_REQUEST: "air_setup_mfa_request",
+      SETUP_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,8 +156,6 @@
       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",
@@ -197,50 +195,6 @@
       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) {
@@ -258,7 +212,6 @@
     class ProviderRpcError extends Error {
         constructor(message) {
             super(message);
-            this.metaMessages = [];
         }
     }
     class UserRejectedRequestError extends ProviderRpcError {
@@ -303,17 +256,6 @@
             this.name = "SwitchChainError";
         }
     }
-    class TransactionRejectedRpcError extends ProviderRpcError {
-        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 {
         constructor() {
             super(...arguments);
@@ -364,8 +306,6 @@
                         return new ChainDisconnectedError(value.errorMessage);
                     case 4902:
                         return new SwitchChainError(value.errorMessage);
-                    case -32003:
-                        return new TransactionRejectedRpcError(value.errorMessage);
                 }
             }
         }
@@ -379,461 +319,130 @@
         return new InternalRpcError(`Invalid value for ProviderRpcError: ${stringified}`);
     }
 
-    function getDefaultExportFromCjs (x) {
-    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    function isFunction(value) {
+      return typeof value === 'function';
     }
 
-    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) {
+    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;
+    }
 
-          if (module.exports) {
-            module.exports = definition();
-          } else {
-            root.log = definition();
-          }
-        })(loglevel, function () {
+    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;
+      };
+    });
 
-          // 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;
+    function arrRemove(arr, item) {
+      if (arr) {
+        var index = arr.indexOf(item);
+        0 <= index && arr.splice(index, 1);
+      }
+    }
 
-          // 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 {
+    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 {
-                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]);
+                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);
             }
           }
-
-          // 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]);
-              }
+          var initialFinalizer = this.initialTeardown;
+          if (isFunction(initialFinalizer)) {
+            try {
+              initialFinalizer();
+            } catch (e) {
+              errors = e instanceof UnsubscriptionError ? e.errors : [e];
             }
-            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;
+          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;
+              }
             }
           }
-
-          // 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";
-            }
+          if (errors) {
+            throw new UnsubscriptionError(errors);
           }
-
-          // 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);
+        }
+      };
+      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;
               }
-            };
-          }
-
-          // 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);
+              teardown._addParent(this);
+            }
+            (this._finalizers = (_a = this._finalizers) !== null && _a !== undefined ? _a : []).push(teardown);
           }
         }
       };
@@ -1151,533 +760,625 @@
           });
         });
       };
-      Observable.create = function (subscribe) {
-        return new Observable(subscribe);
+      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();
+          }
+        } : _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);
+
+    var ObjectUnsubscribedError = createErrorClass(function (_super) {
+      return function ObjectUnsubscribedErrorImpl() {
+        _super(this);
+        this.name = 'ObjectUnsubscribedError';
+        this.message = 'object unsubscribed';
+      };
+    });
+
+    var Subject = function (_super) {
+      __extends(Subject, _super);
+      function Subject() {
+        var _this = _super.call(this) || this;
+        _this.closed = false;
+        _this.currentObservers = null;
+        _this.observers = [];
+        _this.isStopped = false;
+        _this.hasError = false;
+        _this.thrownError = null;
+        return _this;
+      }
+      Subject.prototype.lift = function (operator) {
+        var subject = new AnonymousSubject(this, this);
+        subject.operator = operator;
+        return subject;
+      };
+      Subject.prototype._throwIfClosed = function () {
+        if (this.closed) {
+          throw new ObjectUnsubscribedError();
+        }
+      };
+      Subject.prototype.next = function (value) {
+        var _this = this;
+        errorContext(function () {
+          var e_1, _a;
+          _this._throwIfClosed();
+          if (!_this.isStopped) {
+            if (!_this.currentObservers) {
+              _this.currentObservers = Array.from(_this.observers);
+            }
+            try {
+              for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var observer = _c.value;
+                observer.next(value);
+              }
+            } catch (e_1_1) {
+              e_1 = {
+                error: e_1_1
+              };
+            } finally {
+              try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+              } finally {
+                if (e_1) throw e_1.error;
+              }
+            }
+          }
+        });
+      };
+      Subject.prototype.error = function (err) {
+        var _this = this;
+        errorContext(function () {
+          _this._throwIfClosed();
+          if (!_this.isStopped) {
+            _this.hasError = _this.isStopped = true;
+            _this.thrownError = err;
+            var observers = _this.observers;
+            while (observers.length) {
+              observers.shift().error(err);
+            }
+          }
+        });
+      };
+      Subject.prototype.complete = function () {
+        var _this = this;
+        errorContext(function () {
+          _this._throwIfClosed();
+          if (!_this.isStopped) {
+            _this.isStopped = true;
+            var observers = _this.observers;
+            while (observers.length) {
+              observers.shift().complete();
+            }
+          }
+        });
+      };
+      Subject.prototype.unsubscribe = function () {
+        this.isStopped = this.closed = true;
+        this.observers = this.currentObservers = null;
+      };
+      Object.defineProperty(Subject.prototype, "observed", {
+        get: function () {
+          var _a;
+          return ((_a = this.observers) === null || _a === undefined ? undefined : _a.length) > 0;
+        },
+        enumerable: false,
+        configurable: true
+      });
+      Subject.prototype._trySubscribe = function (subscriber) {
+        this._throwIfClosed();
+        return _super.prototype._trySubscribe.call(this, subscriber);
+      };
+      Subject.prototype._subscribe = function (subscriber) {
+        this._throwIfClosed();
+        this._checkFinalizedStatuses(subscriber);
+        return this._innerSubscribe(subscriber);
+      };
+      Subject.prototype._innerSubscribe = function (subscriber) {
+        var _this = this;
+        var _a = this,
+          hasError = _a.hasError,
+          isStopped = _a.isStopped,
+          observers = _a.observers;
+        if (hasError || isStopped) {
+          return EMPTY_SUBSCRIPTION;
+        }
+        this.currentObservers = null;
+        observers.push(subscriber);
+        return new Subscription(function () {
+          _this.currentObservers = null;
+          arrRemove(observers, subscriber);
+        });
+      };
+      Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+        var _a = this,
+          hasError = _a.hasError,
+          thrownError = _a.thrownError,
+          isStopped = _a.isStopped;
+        if (hasError) {
+          subscriber.error(thrownError);
+        } else if (isStopped) {
+          subscriber.complete();
+        }
+      };
+      Subject.prototype.asObservable = function () {
+        var observable = new Observable();
+        observable.source = this;
+        return observable;
+      };
+      Subject.create = function (destination, source) {
+        return new AnonymousSubject(destination, source);
+      };
+      return Subject;
+    }(Observable);
+    var AnonymousSubject = function (_super) {
+      __extends(AnonymousSubject, _super);
+      function AnonymousSubject(destination, source) {
+        var _this = _super.call(this) || this;
+        _this.destination = destination;
+        _this.source = source;
+        return _this;
+      }
+      AnonymousSubject.prototype.next = function (value) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.next) === null || _b === undefined ? undefined : _b.call(_a, value);
+      };
+      AnonymousSubject.prototype.error = function (err) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.error) === null || _b === undefined ? undefined : _b.call(_a, err);
+      };
+      AnonymousSubject.prototype.complete = function () {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.complete) === null || _b === undefined ? undefined : _b.call(_a);
+      };
+      AnonymousSubject.prototype._subscribe = function (subscriber) {
+        var _a, _b;
+        return (_b = (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber)) !== null && _b !== undefined ? _b : EMPTY_SUBSCRIPTION;
       };
-      return 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);
+      return AnonymousSubject;
+    }(Subject);
+
+    var EmptyError = createErrorClass(function (_super) {
+      return function EmptyErrorImpl() {
+        _super(this);
+        this.name = 'EmptyError';
+        this.message = 'no elements in sequence';
+      };
+    });
+
+    function firstValueFrom(source, config) {
+      return new Promise(function (resolve, reject) {
+        var subscriber = new SafeSubscriber({
+          next: function (value) {
+            resolve(value);
+            subscriber.unsubscribe();
+          },
+          error: reject,
+          complete: function () {
+            {
+              reject(new EmptyError());
+            }
+          }
+        });
+        source.subscribe(subscriber);
+      });
     }
-    function isSubscriber(value) {
-      return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+
+    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 hasLift(source) {
-      return isFunction(source === null || source === undefined ? undefined : source.lift);
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
     }
-    function operate(init) {
-      return function (source) {
-        if (hasLift(source)) {
-          return source.lift(function (liftedSource) {
-            try {
-              return init(liftedSource, this);
-            } catch (err) {
-              this.error(err);
+
+    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]);
+                };
+              }
             }
-          });
-        }
-        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);
+          // 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();
           }
-        } : _super.prototype._next;
-        _this._error = onError ? function (err) {
-          try {
-            onError(err);
-          } catch (err) {
-            destination.error(err);
-          } finally {
-            this.unsubscribe();
+
+          // 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;
+            }
           }
-        } : _super.prototype._error;
-        _this._complete = onComplete ? function () {
-          try {
-            onComplete();
-          } catch (err) {
-            destination.error(err);
-          } finally {
-            this.unsubscribe();
+
+          // 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";
+            }
           }
-        } : _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);
 
-    var ObjectUnsubscribedError = createErrorClass(function (_super) {
-      return function ObjectUnsubscribedErrorImpl() {
-        _super(this);
-        this.name = 'ObjectUnsubscribedError';
-        this.message = 'object unsubscribed';
-      };
-    });
+          // 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);
+              }
+            };
+          }
+
+          // 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) {}
 
-    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);
+              // Use session cookie as fallback
+              try {
+                window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
+              } catch (ignore) {}
             }
-            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 {
+            function getPersistedLevel() {
+              var storedLevel;
+              if (typeof window === undefinedType || !storageKey) return;
               try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-              } finally {
-                if (e_1) throw e_1.error;
+                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;
             }
-          }
-        });
-      };
-      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 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.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();
+            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.unsubscribe = function () {
-        this.isStopped = this.closed = true;
-        this.observers = this.currentObservers = null;
-      };
-      Object.defineProperty(Subject.prototype, "observed", {
-        get: function () {
-          var _a;
-          return ((_a = this.observers) === null || _a === undefined ? undefined : _a.length) > 0;
-        },
-        enumerable: false,
-        configurable: true
-      });
-      Subject.prototype._trySubscribe = function (subscriber) {
-        this._throwIfClosed();
-        return _super.prototype._trySubscribe.call(this, subscriber);
-      };
-      Subject.prototype._subscribe = function (subscriber) {
-        this._throwIfClosed();
-        this._checkFinalizedStatuses(subscriber);
-        return this._innerSubscribe(subscriber);
-      };
-      Subject.prototype._innerSubscribe = function (subscriber) {
-        var _this = this;
-        var _a = this,
-          hasError = _a.hasError,
-          isStopped = _a.isStopped,
-          observers = _a.observers;
-        if (hasError || isStopped) {
-          return EMPTY_SUBSCRIPTION;
-        }
-        this.currentObservers = null;
-        observers.push(subscriber);
-        return new Subscription(function () {
-          _this.currentObservers = null;
-          arrRemove(observers, subscriber);
-        });
-      };
-      Subject.prototype._checkFinalizedStatuses = function (subscriber) {
-        var _a = this,
-          hasError = _a.hasError,
-          thrownError = _a.thrownError,
-          isStopped = _a.isStopped;
-        if (hasError) {
-          subscriber.error(thrownError);
-        } else if (isStopped) {
-          subscriber.complete();
-        }
-      };
-      Subject.prototype.asObservable = function () {
-        var observable = new Observable();
-        observable.source = this;
-        return observable;
-      };
-      Subject.create = function (destination, source) {
-        return new AnonymousSubject(destination, source);
-      };
-      return Subject;
-    }(Observable);
-    var AnonymousSubject = function (_super) {
-      __extends(AnonymousSubject, _super);
-      function AnonymousSubject(destination, source) {
-        var _this = _super.call(this) || this;
-        _this.destination = destination;
-        _this.source = source;
-        return _this;
-      }
-      AnonymousSubject.prototype.next = function (value) {
-        var _a, _b;
-        (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.next) === null || _b === undefined ? undefined : _b.call(_a, value);
-      };
-      AnonymousSubject.prototype.error = function (err) {
-        var _a, _b;
-        (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.error) === null || _b === undefined ? undefined : _b.call(_a, err);
-      };
-      AnonymousSubject.prototype.complete = function () {
-        var _a, _b;
-        (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.complete) === null || _b === undefined ? undefined : _b.call(_a);
-      };
-      AnonymousSubject.prototype._subscribe = function (subscriber) {
-        var _a, _b;
-        return (_b = (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber)) !== null && _b !== undefined ? _b : EMPTY_SUBSCRIPTION;
-      };
-      return AnonymousSubject;
-    }(Subject);
 
-    var EmptyError = createErrorClass(function (_super) {
-      return function EmptyErrorImpl() {
-        _super(this);
-        this.name = 'EmptyError';
-        this.message = 'no elements in sequence';
-      };
-    });
+            /*
+             *
+             * 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);
+              }
 
-    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());
+              // 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);
           }
-        });
-        source.subscribe(subscriber);
-      });
-    }
-
-    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++));
-        }));
-      });
-    }
-
-    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);
-        }));
-      });
-    }
-
-    // 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["CAPTCHA_TOKEN_VERIFICATION_FAILED"] = "CAPTCHA_TOKEN_VERIFICATION_FAILED";
-      PasswordlessErrorName["CAPTCHA_TOKEN_INVALID"] = "CAPTCHA_TOKEN_INVALID";
-      PasswordlessErrorName["CAPTCHA_SECRET_MISSING"] = "CAPTCHA_SECRET_MISSING";
-      PasswordlessErrorName["CAPTCHA_TOKEN_MISSING"] = "CAPTCHA_TOKEN_MISSING";
-    })(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
-    };
 
-    const AirClientUserErrors = ["USER_CANCELLED", "CONFIG_ERROR", "CLIENT_ERROR", "UNKNOWN_ERROR", "PERMISSION_NOT_ENABLED", "SMART_ACCOUNT_NOT_DEPLOYED"];
+          /*
+           *
+           * Top-level API
+           *
+           */
 
-    class AirError extends BaseError {}
-    new Set(AirClientUserErrors);
-    new Set(Object.values(Codes));
+          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;
+          };
 
-    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();
+          // 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;
           };
-        } else {
-          this.targetWindow = target.window;
-          this.targetOrigin = target.origin;
-          window.addEventListener("message", handleMessage);
-          this.closeListener = async () => {
-            window.removeEventListener("message", handleMessage);
+          defaultLogger.getLoggers = function getLoggers() {
+            return _loggersByName;
           };
-        }
-      }
-      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();
-          this.closeListener = null;
-        }
-        if (this.eventSubject && !this.eventSubject.closed) {
-          this.eventSubject.complete();
-        }
-      }
-      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`);
-        }
-      }
-      deepClone(message) {
-        try {
-          return JSON.parse(JSON.stringify(message));
-        } catch (e) {
-          log.warn("Error generating cloneable message", e);
-          return message;
-        }
-      }
+
+          // ES6 default export, for compatibility
+          defaultLogger['default'] = defaultLogger;
+          return defaultLogger;
+        });
+      })(loglevel$1);
+      return loglevel$1.exports;
     }
 
+    var loglevelExports = requireLoglevel();
+    var log$1 = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
+
+    var log = log$1.getLogger("airkit");
+
     var AirWalletProviderMessageTypes;
     (function (AirWalletProviderMessageTypes) {
       AirWalletProviderMessageTypes["REQUEST"] = "JRPC_REQUEST";
@@ -1685,54 +1386,418 @@
       AirWalletProviderMessageTypes["EVENT"] = "JRPC_EVENT";
     })(AirWalletProviderMessageTypes || (AirWalletProviderMessageTypes = {}));
 
-    var _a$2, _ProviderMessageService_instance;
-    const ALLOWED_PROVIDER_MESSAGES = [
-        AirWalletProviderMessageTypes.RESPONSE,
-        AirWalletProviderMessageTypes.EVENT,
+    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.GET_PARTNER_ACCESS_TOKEN_RESPONSE,
+        AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
     ];
-    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({
+    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;
+        }
+        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]);
+        }
+        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);
+        }
+        sendWindowClosed(walletIframe, windowId) {
+            const { origin: walletOrigin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.WINDOW_CLOSED,
+                payload: {
+                    windowId,
+                },
+            }, walletOrigin);
+        }
+        async sendClaimIdRequest(walletIframe, payload) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.CLAIM_ID_RESPONSE)));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({ type: AirMessageTypes.CLAIM_ID_REQUEST, payload }, origin);
+            return response;
+        }
+        async sendWalletProviderRequest(walletIframe, payload) {
+            const response = firstValueFrom(this.providerMessage$.pipe(filter((msg) => msg.type === AirWalletProviderMessageTypes.RESPONSE &&
+                msg.payload.requestId === payload.requestId)));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
                 type: AirWalletProviderMessageTypes.REQUEST,
                 payload,
-            });
+            }, origin);
+            return response;
+        }
+        closeAuthObservables() {
+            if (this._authMessage$ && !this._authMessage$.closed)
+                this._authMessage$.complete();
+            if (this.closeAuthMessageListeners)
+                this.closeAuthMessageListeners();
+        }
+        closeAirObservables() {
+            if (this.airMessages$ && !this.airMessages$.closed)
+                this.airMessages$.complete();
+            if (this.closeRealmMessageListeners)
+                this.closeRealmMessageListeners();
+        }
+        closeWalletObservables() {
+            if (this._providerMessage$ && !this._providerMessage$.closed)
+                this._providerMessage$.complete();
+            if (this._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 sendGetPartnerAccessTokenRequest(authIframe) {
+            const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.GET_PARTNER_ACCESS_TOKEN_RESPONSE)));
+            const { origin } = new URL(authIframe.src);
+            authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.GET_PARTNER_ACCESS_TOKEN_REQUEST }, origin);
             return response;
         }
     }
-    _a$2 = ProviderMessageService;
-    _ProviderMessageService_instance = { value: undefined };
+    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}`;
+    };
 
-    var _AirWalletProvider_instances, _AirWalletProvider_providerMessageService, _AirWalletProvider_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
+    var _AirWalletProvider_instances, _AirWalletProvider_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_getWalletIframeController, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
     class AirWalletProvider {
-        constructor({ isLoggedIn, ensureWallet, }) {
+        constructor({ isLoggedIn, ensureWallet, getWalletIframeController, }) {
             _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 = 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) => {
+            this.startEventMessageListening = () => {
+                AirMessageService$1.providerEvent$.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: [],
@@ -1768,7 +1833,7 @@
                 throw ensureProviderRpcError(error);
             }
             const requestId = randomId();
-            const response = await __classPrivateFieldGet(this, _AirWalletProvider_providerMessageService, "f").sendWalletProviderRequest({
+            const response = await AirMessageService$1.sendWalletProviderRequest(__classPrivateFieldGet(this, _AirWalletProvider_getWalletIframeController, "f").call(this).iframeElement, {
                 requestId,
                 ...request,
             });
@@ -1798,13 +1863,13 @@
             }, "f");
         }
     }
-    _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) {
+    _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) {
         (__classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName] || []).forEach((listener) => {
             try {
                 return listener(...args);
             }
             catch (error) {
-                log.warn(error);
+                log$1.error(error);
             }
         });
     };
@@ -1835,7 +1900,6 @@
             iframe.style.margin = "0";
             iframe.style.padding = "0";
             iframe.style.display = "none";
-            iframe.style.colorScheme = "auto";
             document.body.appendChild(iframe);
             this._iframeElement = iframe;
             return iframe;
@@ -1873,137 +1937,85 @@
         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(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);
-          }
-        }
-        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));
+        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(400, 600));
+            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;
                 }
-              }).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();
-        }
-        this._windowInstance = null;
-        if (this._messageHandler) {
-          window.removeEventListener("message", this._messageHandler);
-          this._messageHandler = null;
+                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;
         }
-        if (this._messages$ && !this._messages$.closed) {
-          this._messages$.complete();
+        postMessage(message, transfer) {
+            if (!this._windowInstance)
+                return;
+            this._windowInstance.postMessage(message, this.windowOrigin, transfer);
         }
-      }
-      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;
+        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,
+            };
         }
-        return null;
-      }
-      scheduleWindowClosedChecks(windowInstance) {
-        const checkWindow = setInterval(() => {
-          if (!windowInstance || windowInstance.closed) {
-            clearInterval(checkWindow);
-            if (windowInstance === this._windowInstance) {
-              this.cleanup();
+        cleanup() {
+            if (this._windowInstance && !this._windowInstance.closed) {
+                this._windowInstance.close();
             }
-          }
-        }, 500);
-      }
+            if (this._messageHandler) {
+                window.removeEventListener("message", this._messageHandler);
+                this._messageHandler = null;
+            }
+            if (this._messages$ && !this._messages$.closed) {
+                this._messages$.complete();
+            }
+            this._windowInstance = null;
+        }
+        onClose(callback) {
+            return this._messages$.subscribe({
+                complete: callback,
+            });
+        }
     }
 
     class WindowService {
@@ -2022,59 +2034,37 @@
             if (!windowInstance) {
                 throw new Error("Window instance not found");
             }
-            const response = firstValueFrom(windowController.messages$.pipe(filter((event) => event.data.type ===
-                AirWalletMessageTypes.INITIALIZATION_RESPONSE)));
-            windowController.postMessage({ type: AirWalletMessageTypes.INITIALIZATION_REQUEST, payload }, [
-                port,
-            ]);
+            const response = firstValueFrom(windowController.messages$.pipe(filter((event) => event.data.type === AirMessageTypes.INITIALIZATION_RESPONSE)));
+            windowController.postMessage({ type: AirMessageTypes.INITIALIZATION_REQUEST, payload }, [port]);
             return (await response).data;
         }
-        async openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, onRetry, sdkVersion, }) {
+        async openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, port, }) {
             if (this.windowControllers.has(windowId)) {
                 throw new Error("Window controller already exists");
             }
-            const windowController = new WindowController(windowId, url);
-            const { pendingWindowOpenCheck } = await windowController.openWindow(onRetry);
+            const windowController = new WindowController(url, windowId);
+            this.windowControllers.set(windowId, windowController);
+            windowController.openWindow();
             windowController.onClose(() => {
                 this.removeWindowController(windowId);
             });
-            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,
-                                    sdkVersion,
-                                }, channel.port1);
-                                if (payload.success === false) {
-                                    reject(new AirServiceError(payload.errorName, payload.errorMessage));
-                                }
-                                else {
-                                    resolve();
-                                }
-                            }
-                            catch (e) {
-                                reject(e);
-                            }
+            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();
                         }
-                    });
+                    }
                 });
-            };
-            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 };
+            });
+            return windowController;
         }
         getWindowController(windowId) {
             return this.windowControllers.get(windowId);
@@ -2085,381 +2075,7 @@
     }
     var WindowService$1 = WindowService.instance;
 
-    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 };
-
-    const 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.INFO;
-      } 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}] LogLevel: ${getLevelName(log.getLevel())}`);
-    };
-
-    var name = "@mocanetwork/airkit";
-    var version = "1.2.1";
-    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 = {
-    	"@mocanetwork/airkit-connector": "^1.2.0",
-    	"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;
+    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;
     class AirService {
         constructor({ partnerId }) {
             _AirService_instances.add(this);
@@ -2468,21 +2084,18 @@
             _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;
         }
@@ -2513,46 +2126,61 @@
                 return;
             __classPrivateFieldSet(this, _AirService_buildEnv, buildEnv, "f");
             __classPrivateFieldSet(this, _AirService_enableLogging, enableLogging, "f");
-            const { authUrl } = AIR_URLS[buildEnv];
-            configureLogLevel(buildEnv, enableLogging);
+            const { authUrl, logLevel } = AIR_URLS[buildEnv];
+            log.setDefaultLevel(logLevel);
+            if (__classPrivateFieldGet(this, _AirService_enableLogging, "f"))
+                log.enableAll();
+            else
+                log.disableAll();
             const authIframeOrigin = new URL(authUrl).origin;
+            await AirMessageService$1.openAuthObservables({ authIframeOrigin });
             __classPrivateFieldSet(this, _AirService_authIframeController, new IframeController(authUrl, `air-auth-${randomId()}`), "f");
-            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;
+            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,
+                                },
+                            });
                         }
-                        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;
+                        catch (err) {
+                            log.error("Error initializing wallet", err);
+                            const error = AirServiceError.from(err);
+                            __classPrivateFieldGet(this, _AirService_authIframeController, "f").postMessage({
+                                type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+                                payload: {
+                                    success: false,
+                                    errorName: error.name ?? "UNKNOWN_ERROR",
+                                    errorMessage: error.message ?? "Unknown error occurred",
+                                },
+                            });
                         }
+                        break;
                     }
-                });
+                }
+            });
+            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 __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendInitializationRequest({
+                            const { payload } = await AirMessageService$1.sendAuthInitializationRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, {
                                 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);
@@ -2585,7 +2213,8 @@
                 throw new Error("Service is not initialized");
             if (__classPrivateFieldGet(this, _AirService_loginResult, "f"))
                 return __classPrivateFieldGet(this, _AirService_loginResult, "f");
-            const { payload } = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendLoginRequest({
+            const iframeController = __classPrivateFieldGet(this, _AirService_authIframeController, "f");
+            const { payload } = await AirMessageService$1.sendAuthLoginRequest(iframeController.iframeElement, {
                 partnerLoginToken: options?.authToken,
             });
             if (payload.success === true) {
@@ -2593,7 +2222,7 @@
                 __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedIn).call(this);
                 return __classPrivateFieldGet(this, _AirService_loginResult, "f");
             }
-            throw new AirServiceError(payload.errorName, payload.errorMessage);
+            throw new AirServiceError("UNKNOWN_ERROR", "Unknown error occurred");
         }
         /**
          * @experimental This method is experimental and will change in the future.
@@ -2604,7 +2233,7 @@
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
             try {
                 log.info("deploySmartAccount");
-                const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendDeploySmartAccountRequest();
+                const { payload } = await AirMessageService$1.sendDeploySmartAccountRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
                 if (payload.success === false) {
                     throw new AirServiceError(payload.errorName, payload.errorMessage);
                 }
@@ -2623,9 +2252,7 @@
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
             try {
                 log.info("grantPermission", policies);
-                const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendGrantPermissionsRequest({
-                    policies,
-                });
+                const { payload } = await AirMessageService$1.sendGrantPermissionsRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, { policies });
                 if (payload.success === false) {
                     throw new AirServiceError(payload.errorName, payload.errorMessage);
                 }
@@ -2643,7 +2270,7 @@
                 throw new Error("Service is not initialized");
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
             try {
-                const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendListAllSessionKeyScopesRequest();
+                const { payload } = await AirMessageService$1.sendListAllSessionKeyScopesRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
                 if (payload.success === false) {
                     throw new AirServiceError(payload.errorName, payload.errorMessage);
                 }
@@ -2662,7 +2289,7 @@
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
             try {
                 log.info("executeAction", params);
-                const txHash = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendExecuteActionRequest(params);
+                const txHash = await AirMessageService$1.sendExecuteActionRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, params);
                 return txHash;
             }
             catch (error) {
@@ -2678,7 +2305,7 @@
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
             try {
                 log.info("revokePermission", permissionId);
-                const txHash = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendRevokePermissionsRequest(permissionId);
+                const txHash = await AirMessageService$1.sendRevokePermissionsRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, permissionId);
                 return txHash;
             }
             catch (error) {
@@ -2693,7 +2320,7 @@
                 throw new Error("Service is not initialized");
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
             try {
-                const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendIsSmartAccountDeployedRequest();
+                const { payload } = await AirMessageService$1.sendIsSmartAccountDeployedRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
                 if (payload.success === false) {
                     throw new AirServiceError(payload.errorName, payload.errorMessage);
                 }
@@ -2711,18 +2338,14 @@
         }
         async setupOrUpdateMfa() {
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, { skipWalletLogin: true });
-            const result = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendSetupMfaRequest();
+            const result = await AirMessageService$1.sendSetupMfaRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
             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 __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendClaimIdRequest(options ?? {});
+            const result = await AirMessageService$1.sendClaimIdRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, options ?? {});
             if (result.payload.success === true) {
                 return { airId: result.payload.airId };
             }
@@ -2731,7 +2354,7 @@
         async getUserInfo() {
             if (!this.isLoggedIn)
                 throw new Error("User not logged in");
-            const info = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendPartnerUserInfoRequest();
+            const info = await AirMessageService$1.sendPartnerUserInfoRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
             if (info.payload.success === false) {
                 throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
             }
@@ -2752,7 +2375,7 @@
                 throw new Error("Service is not initialized");
             if (!this.isLoggedIn)
                 throw new Error("No active session to generate token");
-            const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendCrossPartnerTokenRequest(partnerUrl);
+            const result = await AirMessageService$1.sendCrossPartnerTokenRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, partnerUrl);
             if (result.payload.success === false) {
                 throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
             }
@@ -2760,20 +2383,6 @@
                 urlWithToken: result.payload.urlWithToken,
             };
         }
-        async getAccessToken() {
-            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-                throw new Error("Service is not initialized");
-            if (!this.isLoggedIn)
-                throw new Error("No active session to get partner access token");
-            const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendPartnerAccessTokenRequest();
-            if (result.payload.success !== true) {
-                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
-            }
-            if (!result.payload.partnerAccessToken) {
-                throw new Error("Partner access token not found in response");
-            }
-            return { token: result.payload.partnerAccessToken };
-        }
         async logout() {
             if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
                 throw new Error("Service is not initialized");
@@ -2781,7 +2390,7 @@
                 throw new Error("No active session to logout");
             // Clear up wallet
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
-            await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").logout();
+            await AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
             __classPrivateFieldSet(this, _AirService_loginResult, undefined, "f");
             __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedOut).call(this);
         }
@@ -2801,8 +2410,22 @@
         clearEventListeners() {
             __classPrivateFieldSet(this, _AirService_airAuthListener, [], "f");
         }
+        async getPartnerAccessToken() {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                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.sendGetPartnerAccessTokenRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+            if (result.payload.success === false) {
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+            }
+            if (!result.payload.partnerAccessToken) {
+                throw new Error("Partner access token not found in response");
+            }
+            return result.payload.partnerAccessToken;
+        }
     }
-    _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) {
+    _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) {
         if (!this.isInitialized)
             throw new Error("Service not initialized");
         if (!this.isLoggedIn && !option?.skipWalletLogin)
@@ -2824,7 +2447,7 @@
         }
         if (__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f"))
             return __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f");
-        const walletLoginResult = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendLoginRequest();
+        const walletLoginResult = await AirMessageService$1.sendWalletLoginRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
         if (walletLoginResult.payload.success !== true) {
             throw new AirServiceError(walletLoginResult.payload.errorName, walletLoginResult.payload.errorMessage);
         }
@@ -2835,17 +2458,20 @@
         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 {
-            const walletInitRequestPromise = new Promise((resolve, reject) => {
-                const handleWalletMessage = async (ev) => {
+            __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) => {
                     if (ev.origin !== walletIframeOrigin)
                         return;
-                    if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
-                        window.removeEventListener("message", handleWalletMessage);
-                        const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendInitializationRequest({
+                    if (ev.data === AirMessageTypes.SERVICE_STARTED) {
+                        window.removeEventListener("message", handleAuthMessage);
+                        const { payload } = await AirMessageService$1.sendWalletInitializationRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, {
                             partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                             enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
-                            sdkVersion: airKitVersion,
                         });
                         if (payload.success === true) {
                             resolve();
@@ -2855,18 +2481,11 @@
                         }
                     }
                 };
-                window.addEventListener("message", handleWalletMessage);
+                window.addEventListener("message", handleAuthMessage);
             });
-            __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);
+            __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);
             const walletInitResult = await walletInitPromise;
             if (walletInitResult.payload.success !== true) {
                 throw new AirServiceError(walletInitResult.payload.errorName, walletInitResult.payload.errorMessage);
@@ -2883,43 +2502,37 @@
             throw error;
         }
     }, _AirService_subscribeToWalletEvents = function _AirService_subscribeToWalletEvents() {
-        __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").messages$.subscribe(async (msg) => {
+        AirMessageService$1.messages$.subscribe(async (msg) => {
             switch (msg.type) {
-                case AirWalletMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST: {
+                case AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST: {
                     const walletIframeController = __classPrivateFieldGet(this, _AirService_walletIframeController, "f");
                     walletIframeController.setIframeVisibility(msg.payload.visible);
                     walletIframeController.updateIframeState();
                     break;
                 }
-                case AirWalletMessageTypes.WALLET_LOGIN_RESPONSE: {
+                case AirMessageTypes.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 AirWalletMessageTypes.OPEN_WINDOW_REQUEST: {
+                case AirMessageTypes.OPEN_WINDOW_REQUEST: {
                     try {
-                        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({
+                        const channel = new MessageChannel();
+                        const windowController = await WindowService$1.openAndInitializeWalletServiceWindow({
                             url: msg.payload.url,
                             windowId: msg.payload.windowId,
                             partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                             enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
-                            sdkVersion: airKitVersion,
-                            onRetry,
+                            port: channel.port1,
                         });
-                        windowController.onClose(async () => await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendWindowClosed(msg.payload.windowId));
-                        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendOpenWindowSuccessResponse(msg.payload.windowId, port);
+                        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);
                     }
                     catch (err) {
                         const error = ensureError(err);
-                        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendOpenWindowErrorResponse(msg.payload.windowId, error);
+                        AirMessageService$1.sendOpenWindowErrorResponse(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, msg.payload.windowId, error);
                     }
                     break;
                 }
@@ -2964,7 +2577,7 @@
         };
     }, _AirService_cleanUpAuth = async function _AirService_cleanUpAuth() {
         // Logout auth session
-        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").logout();
+        await AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
         // Destroy the auth iframe
         const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
         if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
@@ -2972,7 +2585,7 @@
             __classPrivateFieldSet(this, _AirService_authIframeController, undefined, "f");
         }
         // Close the message service
-        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").close();
+        AirMessageService$1.closeAuthObservables();
         __classPrivateFieldSet(this, _AirService_isAuthInitialized, false, "f");
     }, _AirService_cleanUpWallet = async function _AirService_cleanUpWallet() {
         if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
@@ -2980,16 +2593,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 __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").logout();
+            await AirMessageService$1.logoutWallet(walletIframeElement);
             __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)) {
-            await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").resetWalletCommunication();
+            AirMessageService$1.sendResetAuthServiceWalletCommunication(authIframeElement);
         }
         // Close the message service
-        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").close();
+        AirMessageService$1.closeAirObservables();
         __classPrivateFieldSet(this, _AirService_walletLoggedInResult, undefined, "f");
         __classPrivateFieldSet(this, _AirService_walletInitialization, undefined, "f");
     };
@@ -3003,9 +2616,7 @@
     exports.InvalidRequestRpcError = InvalidRequestRpcError;
     exports.MethodNotFoundRpcError = MethodNotFoundRpcError;
     exports.ProviderDisconnectedError = ProviderDisconnectedError;
-    exports.ProviderRpcError = ProviderRpcError;
     exports.SwitchChainError = SwitchChainError;
-    exports.TransactionRejectedRpcError = TransactionRejectedRpcError;
     exports.UnauthorizedProviderError = UnauthorizedProviderError;
     exports.UnsupportedProviderMethodError = UnsupportedProviderMethodError;
     exports.UserRejectedRequestError = UserRejectedRequestError;