@mocanetwork/airkit 1.2.1 → 1.3.0-beta.0

package/dist/airkit.esm.js

@@ -118,14 +118,14 @@ const AirAuthMessageTypes = {
   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",
@@ -133,8 +133,8 @@ const AirWalletMessageTypes = {
   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",
@@ -150,8 +150,6 @@ const AirWalletMessageTypes = {
   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",
@@ -191,50 +189,6 @@ function ensureError(value) {
   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) {
@@ -252,7 +206,6 @@ class AirServiceError extends BaseError {
 class ProviderRpcError extends Error {
     constructor(message) {
         super(message);
-        this.metaMessages = [];
     }
 }
 class UserRejectedRequestError extends ProviderRpcError {
@@ -297,17 +250,6 @@ class SwitchChainError extends ProviderRpcError {
         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);
@@ -358,8 +300,6 @@ function ensureProviderRpcError(value) {
                     return new ChainDisconnectedError(value.errorMessage);
                 case 4902:
                     return new SwitchChainError(value.errorMessage);
-                case -32003:
-                    return new TransactionRejectedRpcError(value.errorMessage);
             }
         }
     }
@@ -373,461 +313,130 @@ function ensureProviderRpcError(value) {
     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);
       }
     }
   };
@@ -1145,533 +754,625 @@ var Observable = function () {
       });
     });
   };
-  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";
@@ -1679,54 +1380,418 @@ var AirWalletProviderMessageTypes;
   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: [],
@@ -1762,7 +1827,7 @@ class AirWalletProvider {
             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,
         });
@@ -1792,13 +1857,13 @@ class AirWalletProvider {
         }, "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);
         }
     });
 };
@@ -1829,7 +1894,6 @@ class IframeController {
         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;
@@ -1867,137 +1931,85 @@ IframeController.defaultState = {
     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 {
@@ -2016,59 +2028,37 @@ class WindowService {
         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);
@@ -2079,381 +2069,7 @@ class WindowService {
 }
 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);
@@ -2462,21 +2078,18 @@ class AirService {
         _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;
     }
@@ -2507,46 +2120,61 @@ class AirService {
             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);
@@ -2579,7 +2207,8 @@ class AirService {
             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) {
@@ -2587,7 +2216,7 @@ class AirService {
             __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.
@@ -2598,7 +2227,7 @@ class AirService {
         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);
             }
@@ -2617,9 +2246,7 @@ class AirService {
         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);
             }
@@ -2637,7 +2264,7 @@ class AirService {
             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);
             }
@@ -2656,7 +2283,7 @@ class AirService {
         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) {
@@ -2672,7 +2299,7 @@ class AirService {
         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) {
@@ -2687,7 +2314,7 @@ class AirService {
             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);
             }
@@ -2705,18 +2332,14 @@ class AirService {
     }
     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 };
         }
@@ -2725,7 +2348,7 @@ class AirService {
     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);
         }
@@ -2746,7 +2369,7 @@ class AirService {
             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);
         }
@@ -2754,20 +2377,6 @@ class AirService {
             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");
@@ -2775,7 +2384,7 @@ class AirService {
             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);
     }
@@ -2795,8 +2404,22 @@ class AirService {
     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)
@@ -2818,7 +2441,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     }
     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);
     }
@@ -2829,17 +2452,20 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     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();
@@ -2849,18 +2475,11 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
                     }
                 }
             };
-            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);
@@ -2877,43 +2496,37 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         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;
             }
@@ -2958,7 +2571,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     };
 }, _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)) {
@@ -2966,7 +2579,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         __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"))
@@ -2974,18 +2587,18 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     // 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");
 };
 
-export { AirService, AirServiceError, BUILD_ENV, ChainDisconnectedError, InternalRpcError, InvalidParamsRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, ProviderDisconnectedError, ProviderRpcError, SwitchChainError, TransactionRejectedRpcError, UnauthorizedProviderError, UnsupportedProviderMethodError, UserRejectedRequestError, ensureProviderRpcError };
+export { AirService, AirServiceError, BUILD_ENV, ChainDisconnectedError, InternalRpcError, InvalidParamsRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, ProviderDisconnectedError, SwitchChainError, UnauthorizedProviderError, UnsupportedProviderMethodError, UserRejectedRequestError, ensureProviderRpcError };