@mocanetwork/airkit 1.3.0-beta.0 → 1.3.0

package/dist/airkit.esm.js

@@ -39,7 +39,7 @@ function __values(o) {
   if (m) return m.call(o);
   if (o && typeof o.length === "number") return {
     next: function () {
-      if (o && i >= o.length) o = undefined;
+      if (o && i >= o.length) o = void 0;
       return {
         value: o && o[i++],
         done: !o
@@ -118,14 +118,16 @@ 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",
-  GET_PARTNER_ACCESS_TOKEN_REQUEST: "air_auth_get_partner_access_token_request",
-  GET_PARTNER_ACCESS_TOKEN_RESPONSE: "air_auth_get_partner_access_token_response",
+  PARTNER_ACCESS_TOKEN_REQUEST: "air_auth_partner_access_token_request",
+  PARTNER_ACCESS_TOKEN_RESPONSE: "air_auth_partner_access_token_response",
+  CREDENTIAL_SALT_REQUEST: "air_auth_credential_salt_request",
+  CREDENTIAL_SALT_RESPONSE: "air_auth_credential_salt_response",
   LOGOUT_REQUEST: "air_auth_logout_request",
   LOGOUT_RESPONSE: "air_auth_logout_response",
   RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication"
 };
 
-const AirMessageTypes = {
+const AirWalletMessageTypes = {
   SERVICE_STARTED: "air_service_started",
   INITIALIZATION_REQUEST: "air_initialization_request",
   INITIALIZATION_RESPONSE: "air_initialization_response",
@@ -133,23 +135,17 @@ const AirMessageTypes = {
   WALLET_INITIALIZED: "air_wallet_initialized",
   WALLET_LOGIN_REQUEST: "air_wallet_login_request",
   WALLET_LOGIN_RESPONSE: "air_wallet_login_response",
-  SETUP_MFA_REQUEST: "air_setup_mfa_request",
-  SETUP_MFA_RESPONSE: "air_setup_mfa_response",
+  SETUP_OR_UPDATE_MFA_REQUEST: "air_setup_mfa_request",
+  SETUP_OR_UPDATE_MFA_RESPONSE: "air_setup_mfa_response",
   CLAIM_ID_REQUEST: "air_claim_id_request",
   CLAIM_ID_RESPONSE: "air_claim_id_response",
   DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
   DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response",
-  GRANT_PERMISSIONS_REQUEST: "air_grant_permissions_request",
-  GRANT_PERMISSIONS_RESPONSE: "air_grant_permissions_response",
-  EXECUTE_ACTION_REQUEST: "air_execute_action_request",
-  EXECUTE_ACTION_RESPONSE: "air_execute_action_response",
-  REVOKE_PERMISSIONS_REQUEST: "air_revoke_permissions_request",
-  REVOKE_PERMISSIONS_RESPONSE: "air_revoke_permissions_response",
-  LIST_ALL_SESSION_KEY_SCOPES_REQUEST: "air_list_all_session_key_scopes_request",
-  LIST_ALL_SESSION_KEY_SCOPES_RESPONSE: "air_list_all_session_key_scopes_response",
   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",
@@ -189,6 +185,50 @@ 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:8200/auth/",
+        walletUrl: "http://localhost:8200/wallet/",
+    },
+    [BUILD_ENV.UAT]: {
+        authUrl: "https://account.uat.air3.com/auth/",
+        walletUrl: "https://account.uat.air3.com/wallet/",
+    },
+    [BUILD_ENV.STAGING]: {
+        authUrl: "https://account.staging.air3.com/auth/",
+        walletUrl: "https://account.staging.air3.com/wallet/",
+    },
+    [BUILD_ENV.PRODUCTION]: {
+        authUrl: "https://account.air3.com/auth/",
+        walletUrl: "https://account.air3.com/wallet/",
+    },
+};
+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) {
@@ -206,6 +246,7 @@ class AirServiceError extends BaseError {
 class ProviderRpcError extends Error {
     constructor(message) {
         super(message);
+        this.metaMessages = [];
     }
 }
 class UserRejectedRequestError extends ProviderRpcError {
@@ -250,6 +291,17 @@ 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);
@@ -300,6 +352,8 @@ function ensureProviderRpcError(value) {
                     return new ChainDisconnectedError(value.errorMessage);
                 case 4902:
                     return new SwitchChainError(value.errorMessage);
+                case -32003:
+                    return new TransactionRejectedRpcError(value.errorMessage);
             }
         }
     }
@@ -313,1485 +367,1384 @@ function ensureProviderRpcError(value) {
     return new InternalRpcError(`Invalid value for ProviderRpcError: ${stringified}`);
 }
 
-function isFunction(value) {
-  return typeof value === 'function';
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-function createErrorClass(createImpl) {
-  var _super = function (instance) {
-    Error.call(instance);
-    instance.stack = new Error().stack;
-  };
-  var ctorFunc = createImpl(_super);
-  ctorFunc.prototype = Object.create(Error.prototype);
-  ctorFunc.prototype.constructor = ctorFunc;
-  return ctorFunc;
-}
+var loglevel$1 = {exports: {}};
 
-var UnsubscriptionError = createErrorClass(function (_super) {
-  return function UnsubscriptionErrorImpl(errors) {
-    _super(this);
-    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) {
-      return i + 1 + ") " + err.toString();
-    }).join('\n  ') : '';
-    this.name = 'UnsubscriptionError';
-    this.errors = errors;
-  };
-});
+/*
+* loglevel - https://github.com/pimterry/loglevel
+*
+* Copyright (c) 2013 Tim Perry
+* Licensed under the MIT license.
+*/
+var loglevel = loglevel$1.exports;
+var hasRequiredLoglevel;
+function requireLoglevel() {
+  if (hasRequiredLoglevel) return loglevel$1.exports;
+  hasRequiredLoglevel = 1;
+  (function (module) {
+    (function (root, definition) {
 
-function arrRemove(arr, item) {
-  if (arr) {
-    var index = arr.indexOf(item);
-    0 <= index && arr.splice(index, 1);
-  }
-}
+      if (module.exports) {
+        module.exports = definition();
+      } else {
+        root.log = definition();
+      }
+    })(loglevel, function () {
 
-var Subscription = function () {
-  function Subscription(initialTeardown) {
-    this.initialTeardown = initialTeardown;
-    this.closed = false;
-    this._parentage = null;
-    this._finalizers = null;
-  }
-  Subscription.prototype.unsubscribe = function () {
-    var e_1, _a, e_2, _b;
-    var errors;
-    if (!this.closed) {
-      this.closed = true;
-      var _parentage = this._parentage;
-      if (_parentage) {
-        this._parentage = null;
-        if (Array.isArray(_parentage)) {
+      // Slightly dubious tricks to cut down minimized file size
+      var noop = function () {};
+      var undefinedType = "undefined";
+      var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
+      var logMethods = ["trace", "debug", "info", "warn", "error"];
+      var _loggersByName = {};
+      var defaultLogger = null;
+
+      // Cross-browser bind equivalent that works at least back to IE6
+      function bindMethod(obj, methodName) {
+        var method = obj[methodName];
+        if (typeof method.bind === 'function') {
+          return method.bind(obj);
+        } else {
           try {
-            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
-              var parent_1 = _parentage_1_1.value;
-              parent_1.remove(this);
-            }
-          } catch (e_1_1) {
-            e_1 = {
-              error: e_1_1
+            return Function.prototype.bind.call(method, obj);
+          } catch (e) {
+            // Missing bind shim or IE8 + Modernizr, fallback to wrapping
+            return function () {
+              return Function.prototype.apply.apply(method, [obj, arguments]);
             };
-          } finally {
-            try {
-              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
-            } finally {
-              if (e_1) throw e_1.error;
-            }
           }
-        } else {
-          _parentage.remove(this);
-        }
-      }
-      var initialFinalizer = this.initialTeardown;
-      if (isFunction(initialFinalizer)) {
-        try {
-          initialFinalizer();
-        } catch (e) {
-          errors = e instanceof UnsubscriptionError ? e.errors : [e];
         }
       }
-      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;
+
+      // 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();
       }
-      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);
+
+      // 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;
         }
-        (this._finalizers = (_a = this._finalizers) !== null && _a !== undefined ? _a : []).push(teardown);
       }
-    }
-  };
-  Subscription.prototype._hasParent = function (parent) {
-    var _parentage = this._parentage;
-    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
-  };
-  Subscription.prototype._addParent = function (parent) {
-    var _parentage = this._parentage;
-    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
-  };
-  Subscription.prototype._removeParent = function (parent) {
-    var _parentage = this._parentage;
-    if (_parentage === parent) {
-      this._parentage = null;
-    } else if (Array.isArray(_parentage)) {
-      arrRemove(_parentage, parent);
-    }
-  };
-  Subscription.prototype.remove = function (teardown) {
-    var _finalizers = this._finalizers;
-    _finalizers && arrRemove(_finalizers, teardown);
-    if (teardown instanceof Subscription) {
-      teardown._removeParent(this);
-    }
-  };
-  Subscription.EMPTY = function () {
-    var empty = new Subscription();
-    empty.closed = true;
-    return empty;
-  }();
-  return Subscription;
-}();
-var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
-function isSubscription(value) {
-  return value instanceof Subscription || value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
-}
-function execFinalizer(finalizer) {
-  if (isFunction(finalizer)) {
-    finalizer();
-  } else {
-    finalizer.unsubscribe();
-  }
-}
 
-var config = {
-  onUnhandledError: null,
-  onStoppedNotification: null,
-  Promise: undefined,
-  useDeprecatedSynchronousErrorHandling: false,
-  useDeprecatedNextContext: false
-};
+      // These private functions always need `this` to be set properly
 
-var timeoutProvider = {
-  setTimeout: function (handler, timeout) {
-    var args = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-      args[_i - 2] = arguments[_i];
-    }
-    return setTimeout.apply(undefined, __spreadArray([handler, timeout], __read(args)));
-  },
-  clearTimeout: function (handle) {
-    return (clearTimeout)(handle);
-  },
-  delegate: undefined
-};
-
-function reportUnhandledError(err) {
-  timeoutProvider.setTimeout(function () {
-    {
-      throw err;
-    }
-  });
-}
+      function replaceLoggingMethods() {
+        /*jshint validthis:true */
+        var level = this.getLevel();
 
-function noop() {}
+        // 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);
+        }
 
-function errorContext(cb) {
-  {
-    cb();
-  }
-}
+        // Define log.log as an alias for log.debug
+        this.log = this.debug;
 
-var Subscriber = function (_super) {
-  __extends(Subscriber, _super);
-  function Subscriber(destination) {
-    var _this = _super.call(this) || this;
-    _this.isStopped = false;
-    if (destination) {
-      _this.destination = destination;
-      if (isSubscription(destination)) {
-        destination.add(_this);
-      }
-    } else {
-      _this.destination = EMPTY_OBSERVER;
-    }
-    return _this;
-  }
-  Subscriber.create = function (next, error, complete) {
-    return new SafeSubscriber(next, error, complete);
-  };
-  Subscriber.prototype.next = function (value) {
-    if (this.isStopped) ; else {
-      this._next(value);
-    }
-  };
-  Subscriber.prototype.error = function (err) {
-    if (this.isStopped) ; else {
-      this.isStopped = true;
-      this._error(err);
-    }
-  };
-  Subscriber.prototype.complete = function () {
-    if (this.isStopped) ; else {
-      this.isStopped = true;
-      this._complete();
-    }
-  };
-  Subscriber.prototype.unsubscribe = function () {
-    if (!this.closed) {
-      this.isStopped = true;
-      _super.prototype.unsubscribe.call(this);
-      this.destination = null;
-    }
-  };
-  Subscriber.prototype._next = function (value) {
-    this.destination.next(value);
-  };
-  Subscriber.prototype._error = function (err) {
-    try {
-      this.destination.error(err);
-    } finally {
-      this.unsubscribe();
-    }
-  };
-  Subscriber.prototype._complete = function () {
-    try {
-      this.destination.complete();
-    } finally {
-      this.unsubscribe();
-    }
-  };
-  return Subscriber;
-}(Subscription);
-var ConsumerObserver = function () {
-  function ConsumerObserver(partialObserver) {
-    this.partialObserver = partialObserver;
-  }
-  ConsumerObserver.prototype.next = function (value) {
-    var partialObserver = this.partialObserver;
-    if (partialObserver.next) {
-      try {
-        partialObserver.next(value);
-      } catch (error) {
-        handleUnhandledError(error);
-      }
-    }
-  };
-  ConsumerObserver.prototype.error = function (err) {
-    var partialObserver = this.partialObserver;
-    if (partialObserver.error) {
-      try {
-        partialObserver.error(err);
-      } catch (error) {
-        handleUnhandledError(error);
+        // Return any important warnings.
+        if (typeof console === undefinedType && level < this.levels.SILENT) {
+          return "No console available for logging";
+        }
       }
-    } else {
-      handleUnhandledError(err);
-    }
-  };
-  ConsumerObserver.prototype.complete = function () {
-    var partialObserver = this.partialObserver;
-    if (partialObserver.complete) {
-      try {
-        partialObserver.complete();
-      } catch (error) {
-        handleUnhandledError(error);
+
+      // 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);
+          }
+        };
       }
-    }
-  };
-  return ConsumerObserver;
-}();
-var SafeSubscriber = function (_super) {
-  __extends(SafeSubscriber, _super);
-  function SafeSubscriber(observerOrNext, error, complete) {
-    var _this = _super.call(this) || this;
-    var partialObserver;
-    if (isFunction(observerOrNext) || !observerOrNext) {
-      partialObserver = {
-        next: observerOrNext !== null && observerOrNext !== undefined ? observerOrNext : undefined,
-        error: error !== null && error !== undefined ? error : undefined,
-        complete: complete !== null && complete !== undefined ? complete : undefined
-      };
-    } else {
-      {
-        partialObserver = observerOrNext;
+
+      // By default, we use closely bound real methods wherever possible, and
+      // otherwise we wait for a console to appear, and then try again.
+      function defaultMethodFactory(methodName, _level, _loggerName) {
+        /*jshint validthis:true */
+        return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
       }
-    }
-    _this.destination = new ConsumerObserver(partialObserver);
-    return _this;
-  }
-  return SafeSubscriber;
-}(Subscriber);
-function handleUnhandledError(error) {
-  {
-    reportUnhandledError(error);
-  }
-}
-function defaultErrorHandler(err) {
-  throw err;
-}
-var EMPTY_OBSERVER = {
-  closed: true,
-  next: noop,
-  error: defaultErrorHandler,
-  complete: noop
-};
+      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;
 
-var observable = function () {
-  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
-}();
+          // Use localStorage if available
+          try {
+            window.localStorage[storageKey] = levelName;
+            return;
+          } catch (ignore) {}
 
-function identity(x) {
-  return x;
-}
+          // 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) {}
 
-function pipeFromArray(fns) {
-  if (fns.length === 0) {
-    return identity;
-  }
-  if (fns.length === 1) {
-    return fns[0];
-  }
-  return function piped(input) {
-    return fns.reduce(function (prev, fn) {
-      return fn(prev);
-    }, input);
-  };
-}
+          // 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) {}
+          }
 
-var Observable = function () {
-  function Observable(subscribe) {
-    if (subscribe) {
-      this._subscribe = subscribe;
-    }
-  }
-  Observable.prototype.lift = function (operator) {
-    var observable = new Observable();
-    observable.source = this;
-    observable.operator = operator;
-    return observable;
-  };
-  Observable.prototype.subscribe = function (observerOrNext, error, complete) {
-    var _this = this;
-    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
-    errorContext(function () {
-      var _a = _this,
-        operator = _a.operator,
-        source = _a.source;
-      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+          // 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;
     });
-    return subscriber;
+  })(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;
   };
-  Observable.prototype._trySubscribe = function (sink) {
-    try {
-      return this._subscribe(sink);
-    } catch (err) {
-      sink.error(err);
-    }
+  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;
   };
-  Observable.prototype.forEach = function (next, promiseCtor) {
-    var _this = this;
-    promiseCtor = getPromiseCtor(promiseCtor);
-    return new promiseCtor(function (resolve, reject) {
-      var subscriber = new SafeSubscriber({
-        next: function (value) {
+});
+
+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 {
-            next(value);
-          } catch (err) {
-            reject(err);
-            subscriber.unsubscribe();
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+          } finally {
+            if (e_2) throw e_2.error;
           }
-        },
-        error: reject,
-        complete: resolve
-      });
-      _this.subscribe(subscriber);
-    });
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
   };
-  Observable.prototype._subscribe = function (subscriber) {
+  Subscription.prototype.add = function (teardown) {
     var _a;
-    return (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber);
+    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 !== void 0 ? _a : []).push(teardown);
+      }
+    }
   };
-  Observable.prototype[observable] = function () {
-    return this;
+  Subscription.prototype._hasParent = function (parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
   };
-  Observable.prototype.pipe = function () {
-    var operations = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      operations[_i] = arguments[_i];
-    }
-    return pipeFromArray(operations)(this);
+  Subscription.prototype._addParent = function (parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
   };
-  Observable.prototype.toPromise = function (promiseCtor) {
-    var _this = this;
-    promiseCtor = getPromiseCtor(promiseCtor);
-    return new promiseCtor(function (resolve, reject) {
-      var value;
-      _this.subscribe(function (x) {
-        return value = x;
-      }, function (err) {
-        return reject(err);
-      }, function () {
-        return resolve(value);
-      });
-    });
+  Subscription.prototype._removeParent = function (parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
   };
-  Observable.create = function (subscribe) {
-    return new Observable(subscribe);
+  Subscription.prototype.remove = function (teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription) {
+      teardown._removeParent(this);
+    }
   };
-  return Observable;
+  Subscription.EMPTY = function () {
+    var empty = new Subscription();
+    empty.closed = true;
+    return empty;
+  }();
+  return Subscription;
 }();
-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);
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription || value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
 }
-function isSubscriber(value) {
-  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
 }
 
-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);
-        }
-      });
+var config = {
+  Promise: undefined};
+
+var timeoutProvider = {
+  setTimeout: function (handler, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
     }
-    throw new TypeError('Unable to lift unknown Observable type');
-  };
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function (handle) {
+    return (clearTimeout)(handle);
+  },
+  delegate: undefined
+};
+
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function () {
+    {
+      throw err;
+    }
+  });
 }
 
-function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
-  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+function noop() {}
+
+function errorContext(cb) {
+  {
+    cb();
+  }
 }
-var OperatorSubscriber = function (_super) {
-  __extends(OperatorSubscriber, _super);
-  function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
-    var _this = _super.call(this, destination) || this;
-    _this.onFinalize = onFinalize;
-    _this.shouldUnsubscribe = shouldUnsubscribe;
-    _this._next = onNext ? function (value) {
-      try {
-        onNext(value);
-      } catch (err) {
-        destination.error(err);
-      }
-    } : _super.prototype._next;
-    _this._error = onError ? function (err) {
-      try {
-        onError(err);
-      } catch (err) {
-        destination.error(err);
-      } finally {
-        this.unsubscribe();
-      }
-    } : _super.prototype._error;
-    _this._complete = onComplete ? function () {
-      try {
-        onComplete();
-      } catch (err) {
-        destination.error(err);
-      } finally {
-        this.unsubscribe();
+
+var Subscriber = function (_super) {
+  __extends(Subscriber, _super);
+  function Subscriber(destination) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination) {
+      _this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(_this);
       }
-    } : _super.prototype._complete;
+    } else {
+      _this.destination = EMPTY_OBSERVER;
+    }
     return _this;
   }
-  OperatorSubscriber.prototype.unsubscribe = function () {
-    var _a;
-    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
-      var closed_1 = this.closed;
+  Subscriber.create = function (next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  };
+  Subscriber.prototype.next = function (value) {
+    if (this.isStopped) ; else {
+      this._next(value);
+    }
+  };
+  Subscriber.prototype.error = function (err) {
+    if (this.isStopped) ; else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber.prototype.complete = function () {
+    if (this.isStopped) ; else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber.prototype.unsubscribe = function () {
+    if (!this.closed) {
+      this.isStopped = true;
       _super.prototype.unsubscribe.call(this);
-      !closed_1 && ((_a = this.onFinalize) === null || _a === undefined ? undefined : _a.call(this));
+      this.destination = null;
     }
   };
-  return OperatorSubscriber;
-}(Subscriber);
-
-var ObjectUnsubscribedError = createErrorClass(function (_super) {
-  return function ObjectUnsubscribedErrorImpl() {
-    _super(this);
-    this.name = 'ObjectUnsubscribedError';
-    this.message = 'object unsubscribed';
+  Subscriber.prototype._next = function (value) {
+    this.destination.next(value);
   };
-});
-
-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;
+  Subscriber.prototype._error = function (err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
   };
-  Subject.prototype._throwIfClosed = function () {
-    if (this.closed) {
-      throw new ObjectUnsubscribedError();
+  Subscriber.prototype._complete = function () {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
     }
   };
-  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;
-          }
-        }
+  return Subscriber;
+}(Subscription);
+var ConsumerObserver = function () {
+  function ConsumerObserver(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver.prototype.next = function (value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
       }
-    });
+    }
   };
-  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);
-        }
+  ConsumerObserver.prototype.error = function (err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
       }
-    });
+    } else {
+      handleUnhandledError(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();
-        }
+  ConsumerObserver.prototype.complete = function () {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
       }
-    });
-  };
-  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();
+  return ConsumerObserver;
+}();
+var SafeSubscriber = function (_super) {
+  __extends(SafeSubscriber, _super);
+  function SafeSubscriber(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined,
+        error: error !== null && error !== void 0 ? error : undefined,
+        complete: complete !== null && complete !== void 0 ? complete : undefined
+      };
+    } else {
+      {
+        partialObserver = observerOrNext;
+      }
     }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber;
+}(Subscriber);
+function handleUnhandledError(error) {
+  {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+
+var observable = function () {
+  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+}();
+
+function identity(x) {
+  return x;
+}
+
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input) {
+    return fns.reduce(function (prev, fn) {
+      return fn(prev);
+    }, input);
   };
-  Subject.prototype.asObservable = function () {
+}
+
+var Observable = function () {
+  function Observable(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  Observable.prototype.lift = function (operator) {
     var observable = new Observable();
     observable.source = this;
+    observable.operator = operator;
     return observable;
   };
-  Subject.create = function (destination, source) {
-    return new AnonymousSubject(destination, source);
+  Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+    var _this = this;
+    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(function () {
+      var _a = _this,
+        operator = _a.operator,
+        source = _a.source;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+    });
+    return subscriber;
   };
-  return Subject;
-}(Observable);
-var AnonymousSubject = function (_super) {
-  __extends(AnonymousSubject, _super);
-  function AnonymousSubject(destination, source) {
-    var _this = _super.call(this) || this;
-    _this.destination = destination;
-    _this.source = source;
-    return _this;
-  }
-  AnonymousSubject.prototype.next = function (value) {
-    var _a, _b;
-    (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.next) === null || _b === undefined ? undefined : _b.call(_a, value);
+  Observable.prototype._trySubscribe = function (sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
   };
-  AnonymousSubject.prototype.error = function (err) {
-    var _a, _b;
-    (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.error) === null || _b === undefined ? undefined : _b.call(_a, err);
+  Observable.prototype.forEach = function (next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function (resolve, reject) {
+      var subscriber = new SafeSubscriber({
+        next: function (value) {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+      _this.subscribe(subscriber);
+    });
   };
-  AnonymousSubject.prototype.complete = function () {
-    var _a, _b;
-    (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.complete) === null || _b === undefined ? undefined : _b.call(_a);
+  Observable.prototype._subscribe = function (subscriber) {
+    var _a;
+    return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
   };
-  AnonymousSubject.prototype._subscribe = function (subscriber) {
-    var _a, _b;
-    return (_b = (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber)) !== null && _b !== undefined ? _b : EMPTY_SUBSCRIPTION;
+  Observable.prototype[observable] = function () {
+    return this;
   };
-  return AnonymousSubject;
-}(Subject);
-
-var EmptyError = createErrorClass(function (_super) {
-  return function EmptyErrorImpl() {
-    _super(this);
-    this.name = 'EmptyError';
-    this.message = 'no elements in sequence';
+  Observable.prototype.pipe = function () {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
+    }
+    return pipeFromArray(operations)(this);
   };
-});
-
-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());
-        }
-      }
+  Observable.prototype.toPromise = function (promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function (resolve, reject) {
+      var value;
+      _this.subscribe(function (x) {
+        return value = x;
+      }, function (err) {
+        return reject(err);
+      }, function () {
+        return resolve(value);
+      });
     });
-    source.subscribe(subscriber);
-  });
+  };
+  Observable.create = function (subscribe) {
+    return new Observable(subscribe);
+  };
+  return Observable;
+}();
+function getPromiseCtor(promiseCtor) {
+  var _a;
+  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
 }
-
-function filter(predicate, thisArg) {
-  return operate(function (source, subscriber) {
-    var index = 0;
-    source.subscribe(createOperatorSubscriber(subscriber, function (value) {
-      return predicate.call(thisArg, value, index++) && subscriber.next(value);
-    }));
-  });
+function isObserver(value) {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
 }
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+function isSubscriber(value) {
+  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
 }
 
-var loglevel$1 = {exports: {}};
-
-/*
-* loglevel - https://github.com/pimterry/loglevel
-*
-* Copyright (c) 2013 Tim Perry
-* Licensed under the MIT license.
-*/
-var loglevel = loglevel$1.exports;
-var hasRequiredLoglevel;
-function requireLoglevel() {
-  if (hasRequiredLoglevel) return loglevel$1.exports;
-  hasRequiredLoglevel = 1;
-  (function (module) {
-    (function (root, definition) {
-
-      if (module.exports) {
-        module.exports = definition();
-      } else {
-        root.log = definition();
-      }
-    })(loglevel, function () {
-
-      // Slightly dubious tricks to cut down minimized file size
-      var noop = function () {};
-      var undefinedType = "undefined";
-      var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
-      var logMethods = ["trace", "debug", "info", "warn", "error"];
-      var _loggersByName = {};
-      var defaultLogger = null;
-
-      // Cross-browser bind equivalent that works at least back to IE6
-      function bindMethod(obj, methodName) {
-        var method = obj[methodName];
-        if (typeof method.bind === 'function') {
-          return method.bind(obj);
-        } else {
-          try {
-            return Function.prototype.bind.call(method, obj);
-          } catch (e) {
-            // Missing bind shim or IE8 + Modernizr, fallback to wrapping
-            return function () {
-              return Function.prototype.apply.apply(method, [obj, arguments]);
-            };
-          }
-        }
-      }
-
-      // Trace() doesn't print the message in IE, so for that case we need to wrap it
-      function traceForIE() {
-        if (console.log) {
-          if (console.log.apply) {
-            console.log.apply(console, arguments);
-          } else {
-            // In old IE, native console methods themselves don't have apply().
-            Function.prototype.apply.apply(console.log, [console, arguments]);
-          }
-        }
-        if (console.trace) console.trace();
-      }
-
-      // Build the best logging method possible for this env
-      // Wherever possible we want to bind, not wrap, to preserve stack traces
-      function realMethod(methodName) {
-        if (methodName === 'debug') {
-          methodName = 'log';
-        }
-        if (typeof console === undefinedType) {
-          return false; // No method possible, for now - fixed later by enableLoggingWhenConsoleArrives
-        } else if (methodName === 'trace' && isIE) {
-          return traceForIE;
-        } else if (console[methodName] !== undefined) {
-          return bindMethod(console, methodName);
-        } else if (console.log !== undefined) {
-          return bindMethod(console, 'log');
-        } else {
-          return noop;
-        }
-      }
-
-      // These private functions always need `this` to be set properly
-
-      function replaceLoggingMethods() {
-        /*jshint validthis:true */
-        var level = this.getLevel();
-
-        // Replace the actual methods.
-        for (var i = 0; i < logMethods.length; i++) {
-          var methodName = logMethods[i];
-          this[methodName] = i < level ? noop : this.methodFactory(methodName, level, this.name);
+function hasLift(source) {
+  return isFunction(source === null || source === void 0 ? void 0 : 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');
+  };
+}
 
-        // Define log.log as an alias for log.debug
-        this.log = this.debug;
-
-        // Return any important warnings.
-        if (typeof console === undefinedType && level < this.levels.SILENT) {
-          return "No console available for logging";
-        }
+function 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);
       }
-
-      // 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);
-          }
-        };
+    } : _super.prototype._next;
+    _this._error = onError ? function (err) {
+      try {
+        onError(err);
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
       }
-
-      // By default, we use closely bound real methods wherever possible, and
-      // otherwise we wait for a console to appear, and then try again.
-      function defaultMethodFactory(methodName, _level, _loggerName) {
-        /*jshint validthis:true */
-        return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
+    } : _super.prototype._error;
+    _this._complete = onComplete ? function () {
+      try {
+        onComplete();
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
       }
-      function Logger(name, factory) {
-        // Private instance variables.
-        var self = this;
-        /**
-         * The level inherited from a parent logger (or a global default). We
-         * cache this here rather than delegating to the parent so that it stays
-         * in sync with the actual logging methods that we have installed (the
-         * parent could change levels but we might not have rebuilt the loggers
-         * in this child yet).
-         * @type {number}
-         */
-        var inheritedLevel;
-        /**
-         * The default level for this logger, if any. If set, this overrides
-         * `inheritedLevel`.
-         * @type {number|null}
-         */
-        var defaultLevel;
-        /**
-         * A user-specific level for this logger. If set, this overrides
-         * `defaultLevel`.
-         * @type {number|null}
-         */
-        var userLevel;
-        var storageKey = "loglevel";
-        if (typeof name === "string") {
-          storageKey += ":" + name;
-        } else if (typeof name === "symbol") {
-          storageKey = undefined;
-        }
-        function persistLevelIfPossible(levelNum) {
-          var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
-          if (typeof window === undefinedType || !storageKey) return;
+    } : _super.prototype._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 === void 0 ? void 0 : _a.call(this));
+    }
+  };
+  return OperatorSubscriber;
+}(Subscriber);
 
-          // Use localStorage if available
-          try {
-            window.localStorage[storageKey] = levelName;
-            return;
-          } catch (ignore) {}
+var ObjectUnsubscribedError = createErrorClass(function (_super) {
+  return function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = 'ObjectUnsubscribedError';
+    this.message = 'object unsubscribed';
+  };
+});
 
-          // Use session cookie as fallback
-          try {
-            window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
-          } catch (ignore) {}
+var Subject = function (_super) {
+  __extends(Subject, _super);
+  function Subject() {
+    var _this = _super.call(this) || this;
+    _this.closed = false;
+    _this.currentObservers = null;
+    _this.observers = [];
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject.prototype.lift = function (operator) {
+    var subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  };
+  Subject.prototype._throwIfClosed = function () {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+  };
+  Subject.prototype.next = function (value) {
+    var _this = this;
+    errorContext(function () {
+      var e_1, _a;
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        if (!_this.currentObservers) {
+          _this.currentObservers = Array.from(_this.observers);
         }
-        function getPersistedLevel() {
-          var storedLevel;
-          if (typeof window === undefinedType || !storageKey) return;
-          try {
-            storedLevel = window.localStorage[storageKey];
-          } catch (ignore) {}
-
-          // Fallback to cookies if local storage gives us nothing
-          if (typeof storedLevel === undefinedType) {
-            try {
-              var cookie = window.document.cookie;
-              var cookieName = encodeURIComponent(storageKey);
-              var location = cookie.indexOf(cookieName + "=");
-              if (location !== -1) {
-                storedLevel = /^([^;]+)/.exec(cookie.slice(location + cookieName.length + 1))[1];
-              }
-            } catch (ignore) {}
-          }
-
-          // If the stored level is not valid, treat it as if nothing was stored.
-          if (self.levels[storedLevel] === undefined) {
-            storedLevel = undefined;
+        try {
+          for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var observer = _c.value;
+            observer.next(value);
           }
-          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
+        } catch (e_1_1) {
+          e_1 = {
+            error: e_1_1
+          };
+        } finally {
           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);
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+          } finally {
+            if (e_1) throw e_1.error;
           }
         }
-
-        /*
-         *
-         * 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);
+      }
+    });
+  };
+  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);
         }
-        replaceLoggingMethods.call(self);
       }
+    });
+  };
+  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 === void 0 ? void 0 : _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 === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+  };
+  AnonymousSubject.prototype.error = function (err) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+  };
+  AnonymousSubject.prototype.complete = function () {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+  };
+  AnonymousSubject.prototype._subscribe = function (subscriber) {
+    var _a, _b;
+    return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+  };
+  return AnonymousSubject;
+}(Subject);
 
-      /*
-       *
-       * Top-level API
-       *
-       */
+var EmptyError = createErrorClass(function (_super) {
+  return function EmptyErrorImpl() {
+    _super(this);
+    this.name = 'EmptyError';
+    this.message = 'no elements in sequence';
+  };
+});
 
-      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);
+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());
         }
-        return logger;
-      };
+      }
+    });
+    source.subscribe(subscriber);
+  });
+}
 
-      // Grab the current global log variable in case of overwrite
-      var _log = typeof window !== undefinedType ? window.log : undefined;
-      defaultLogger.noConflict = function () {
-        if (typeof window !== undefinedType && window.log === defaultLogger) {
-          window.log = _log;
-        }
-        return defaultLogger;
-      };
-      defaultLogger.getLoggers = function getLoggers() {
-        return _loggersByName;
-      };
+function map(project, thisArg) {
+  return operate(function (source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+      subscriber.next(project.call(thisArg, value, index++));
+    }));
+  });
+}
 
-      // ES6 default export, for compatibility
-      defaultLogger['default'] = defaultLogger;
-      return defaultLogger;
-    });
-  })(loglevel$1);
-  return loglevel$1.exports;
+function filter(predicate, thisArg) {
+  return operate(function (source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+      return predicate.call(thisArg, value, index++) && subscriber.next(value);
+    }));
+  });
 }
 
-var loglevelExports = requireLoglevel();
-var log$1 = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
+const bigIntReplacer = (_key, value) => {
+  return typeof value === "bigint" ? value.toString() : value;
+};
+/**
+ * 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}`;
+};
 
-var log = log$1.getLogger("airkit");
+// 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
+};
 
-var AirWalletProviderMessageTypes;
-(function (AirWalletProviderMessageTypes) {
-  AirWalletProviderMessageTypes["REQUEST"] = "JRPC_REQUEST";
-  AirWalletProviderMessageTypes["RESPONSE"] = "JRPC_RESPONSE";
-  AirWalletProviderMessageTypes["EVENT"] = "JRPC_EVENT";
-})(AirWalletProviderMessageTypes || (AirWalletProviderMessageTypes = {}));
+const AirClientUserErrors = ["USER_CANCELLED", "CONFIG_ERROR", "CLIENT_ERROR", "UNKNOWN_ERROR", "PERMISSION_NOT_ENABLED", "SMART_ACCOUNT_NOT_DEPLOYED"];
 
-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 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);
+class AirError extends BaseError {}
+new Set(AirClientUserErrors);
+new Set(Object.values(Codes));
+
+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 () => {
+        this.messagePort?.close();
+        this.messagePort = undefined;
+      };
+    } else if (target instanceof BroadcastChannel) {
+      this.messageChannel = target;
+      target.onmessage = handleMessage;
+      this.closeListener = async () => {
+        this.messageChannel?.close();
+        this.messageChannel = undefined;
+      };
+    } else {
+      this.targetWindow = target.window;
+      this.targetOrigin = target.origin;
+      window.addEventListener("message", handleMessage);
+      this.closeListener = async () => {
+        window.removeEventListener("message", handleMessage);
+      };
     }
-    sendWindowClosed(walletIframe, windowId) {
-        const { origin: walletOrigin } = new URL(walletIframe.src);
-        walletIframe.contentWindow.postMessage({
-            type: AirMessageTypes.WINDOW_CLOSED,
-            payload: {
-                windowId,
-            },
-        }, walletOrigin);
+  }
+  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;
     }
-    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;
+    if (this.eventSubject && !this.eventSubject.closed) {
+      this.eventSubject.complete();
     }
-    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;
+  }
+  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);
+    } else if (this.messageChannel) {
+      this.messageChannel.postMessage(clonedMessage);
+    } else if (this.targetWindow && this.targetOrigin) {
+      this.targetWindow.postMessage(clonedMessage, this.targetOrigin, transfer);
+    } else {
+      log.debug(`[${this.name}] Not opened yet`);
+      return;
     }
-    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;
+    this.eventSubject.next(new MessageEvent("message", {
+      data: clonedMessage,
+      origin: window.origin
+    }));
+  }
+  deepClone(message) {
+    try {
+      return JSON.parse(JSON.stringify(message, bigIntReplacer));
+    } catch (e) {
+      log.warn("Error generating cloneable message", e);
+      return message;
     }
+  }
 }
-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_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_getWalletIframeController, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
+var AirWalletProviderMessageTypes;
+(function (AirWalletProviderMessageTypes) {
+  AirWalletProviderMessageTypes["REQUEST"] = "JRPC_REQUEST";
+  AirWalletProviderMessageTypes["RESPONSE"] = "JRPC_RESPONSE";
+  AirWalletProviderMessageTypes["EVENT"] = "JRPC_EVENT";
+})(AirWalletProviderMessageTypes || (AirWalletProviderMessageTypes = {}));
+
+var _a$2, _ProviderMessageService_instance;
+const ALLOWED_PROVIDER_MESSAGES = [
+    AirWalletProviderMessageTypes.RESPONSE,
+    AirWalletProviderMessageTypes.EVENT,
+];
+class ProviderMessageService extends MessageServiceBase {
+    static create() {
+        if (__classPrivateFieldGet(this, _a$2, "f", _ProviderMessageService_instance))
+            throw new Error("ProviderMessageService already created");
+        __classPrivateFieldSet(this, _a$2, new _a$2("Embed Service: Provider Channel", ALLOWED_PROVIDER_MESSAGES), "f", _ProviderMessageService_instance);
+        return __classPrivateFieldGet(this, _a$2, "f", _ProviderMessageService_instance);
+    }
+    async open(walletIframe) {
+        const origin = new URL(walletIframe.src).origin;
+        const window = walletIframe.contentWindow;
+        await super._open({ window, origin });
+    }
+    async sendWalletProviderRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletProviderMessageTypes.RESPONSE), filter((msg) => msg.payload.method === payload.method)));
+        await this.sendMessage({
+            type: AirWalletProviderMessageTypes.REQUEST,
+            payload,
+        });
+        return response;
+    }
+}
+_a$2 = ProviderMessageService;
+_ProviderMessageService_instance = { value: void 0 };
+
+var _AirWalletProvider_instances, _AirWalletProvider_providerMessageService, _AirWalletProvider_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
 class AirWalletProvider {
-    constructor({ isLoggedIn, ensureWallet, getWalletIframeController, }) {
+    constructor({ isLoggedIn, ensureWallet, }) {
         _AirWalletProvider_instances.add(this);
-        _AirWalletProvider_isLoggedIn.set(this, undefined);
-        _AirWalletProvider_ensureWallet.set(this, undefined);
-        _AirWalletProvider_getWalletIframeController.set(this, undefined);
-        _AirWalletProvider_eventListeners.set(this, undefined);
-        this.startEventMessageListening = () => {
-            AirMessageService$1.providerEvent$.subscribe((message) => {
+        _AirWalletProvider_providerMessageService.set(this, void 0);
+        _AirWalletProvider_isLoggedIn.set(this, void 0);
+        _AirWalletProvider_ensureWallet.set(this, void 0);
+        _AirWalletProvider_eventListeners.set(this, void 0);
+        this.startEventMessageListening = async (walletIframe) => {
+            await __classPrivateFieldGet(this, _AirWalletProvider_providerMessageService, "f").open(walletIframe);
+            __classPrivateFieldGet(this, _AirWalletProvider_providerMessageService, "f").messages$
+                .pipe(filter((msg) => msg.type === AirWalletProviderMessageTypes.EVENT))
+                .subscribe((message) => {
                 __classPrivateFieldGet(this, _AirWalletProvider_instances, "m", _AirWalletProvider_emit).call(this, message.payload.event, ...[message.payload.data]);
             });
         };
+        __classPrivateFieldSet(this, _AirWalletProvider_providerMessageService, ProviderMessageService.create(), "f");
         __classPrivateFieldSet(this, _AirWalletProvider_isLoggedIn, isLoggedIn, "f");
         __classPrivateFieldSet(this, _AirWalletProvider_ensureWallet, ensureWallet, "f");
-        __classPrivateFieldSet(this, _AirWalletProvider_getWalletIframeController, getWalletIframeController, "f");
         __classPrivateFieldSet(this, _AirWalletProvider_eventListeners, {
             connect: [],
             disconnect: [],
@@ -1820,14 +1773,20 @@ class AirWalletProvider {
         if (!__classPrivateFieldGet(this, _AirWalletProvider_isLoggedIn, "f").call(this)) {
             throw new UnauthorizedProviderError("User is not logged in");
         }
+        const skipWalletLoginMethods = ['eth_chainId'];
         try {
-            await __classPrivateFieldGet(this, _AirWalletProvider_ensureWallet, "f").call(this);
+            if (skipWalletLoginMethods.includes(method)) {
+                await __classPrivateFieldGet(this, _AirWalletProvider_ensureWallet, "f").call(this, { skipWalletLogin: true });
+            }
+            else {
+                await __classPrivateFieldGet(this, _AirWalletProvider_ensureWallet, "f").call(this);
+            }
         }
         catch (error) {
             throw ensureProviderRpcError(error);
         }
         const requestId = randomId();
-        const response = await AirMessageService$1.sendWalletProviderRequest(__classPrivateFieldGet(this, _AirWalletProvider_getWalletIframeController, "f").call(this).iframeElement, {
+        const response = await __classPrivateFieldGet(this, _AirWalletProvider_providerMessageService, "f").sendWalletProviderRequest({
             requestId,
             ...request,
         });
@@ -1857,13 +1816,13 @@ class AirWalletProvider {
         }, "f");
     }
 }
-_AirWalletProvider_isLoggedIn = new WeakMap(), _AirWalletProvider_ensureWallet = new WeakMap(), _AirWalletProvider_getWalletIframeController = new WeakMap(), _AirWalletProvider_eventListeners = new WeakMap(), _AirWalletProvider_instances = new WeakSet(), _AirWalletProvider_emit = function _AirWalletProvider_emit(eventName, ...args) {
+_AirWalletProvider_providerMessageService = new WeakMap(), _AirWalletProvider_isLoggedIn = new WeakMap(), _AirWalletProvider_ensureWallet = new WeakMap(), _AirWalletProvider_eventListeners = new WeakMap(), _AirWalletProvider_instances = new WeakSet(), _AirWalletProvider_emit = function _AirWalletProvider_emit(eventName, ...args) {
     (__classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName] || []).forEach((listener) => {
         try {
             return listener(...args);
         }
         catch (error) {
-            log$1.error(error);
+            log.warn(error);
         }
     });
 };
@@ -1894,6 +1853,7 @@ 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;
@@ -1932,84 +1892,117 @@ IframeController.defaultState = {
 };
 
 class WindowController {
-    get messages$() {
-        return this._messages$.asObservable();
-    }
-    constructor(windowUrl, windowId) {
-        this._windowInstance = null;
-        this._messageHandler = null;
-        this._messages$ = new Subject();
-        this.windowUrl = windowUrl;
-        this.windowOrigin = new URL(windowUrl).origin;
-        this.windowId = windowId;
-    }
-    get windowInstance() {
-        return this._windowInstance;
-    }
-    openWindow() {
-        if (this._windowInstance && !this._windowInstance.closed) {
-            this._windowInstance.focus();
-            return this._windowInstance;
-        }
-        const windowInstance = window.open(this.windowUrl, this.windowId, getWindowFeatures(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;
-            }
-            this._messages$.next(ev);
-        };
-        window.addEventListener("message", this._messageHandler);
-        const checkWindow = setInterval(() => {
-            if (!this._windowInstance || this._windowInstance?.closed) {
-                this.cleanup();
-                clearInterval(checkWindow);
-            }
-        }, 500);
-        return windowInstance;
+  get messages$() {
+    return this._messages$.asObservable();
+  }
+  constructor(windowId, windowUrl) {
+    this._windowInstance = null;
+    this._messageHandler = null;
+    this._messages$ = new Subject();
+    this.windowId = windowId;
+    this.windowUrl = windowUrl;
+    this.windowOrigin = new URL(windowUrl).origin;
+    this._messageHandler = ev => {
+      if (ev.source !== this._windowInstance || ev.origin !== this.windowOrigin || !ev.data || !(ev.data instanceof Object)) {
+        return;
+      }
+      this._messages$.next(ev);
+    };
+    window.addEventListener("message", this._messageHandler);
+  }
+  get windowInstance() {
+    return this._windowInstance;
+  }
+  async openWindow(onRetry) {
+    let windowInstance = this.tryOpenWindow();
+    if (!windowInstance) {
+      await onRetry();
+      windowInstance = this.tryOpenWindow();
+      if (!windowInstance) {
+        throw new AirError(WindowErrorName.WINDOW_BLOCKED);
+      }
     }
-    postMessage(message, transfer) {
-        if (!this._windowInstance)
-            return;
-        this._windowInstance.postMessage(message, this.windowOrigin, transfer);
+    const pendingWindowOpenCheck = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        if (this.isWindowOpen(windowInstance)) {
+          // only now are we scheduling the close event check since we're sure the window is open
+          this.scheduleWindowClosedChecks(windowInstance);
+          resolve("opened");
+        } else {
+          onRetry().then(() => {
+            windowInstance = this.tryOpenWindow();
+            if (windowInstance) {
+              this._windowInstance = windowInstance;
+              windowInstance.focus();
+              this.scheduleWindowClosedChecks(windowInstance);
+              resolve("retry");
+            } else {
+              reject(new AirError(WindowErrorName.WINDOW_BLOCKED));
+            }
+          }).catch(reject);
+        }
+      }, 1000);
+    });
+    this._windowInstance = windowInstance;
+    windowInstance.focus();
+    return {
+      pendingWindowOpenCheck
+    };
+  }
+  postMessage(message, transfer) {
+    if (!this._windowInstance) return;
+    this._windowInstance.postMessage(message, this.windowOrigin, transfer);
+  }
+  onMessage(callback) {
+    const listener = ev => {
+      if (ev.source !== this._windowInstance || ev.origin !== this.windowOrigin) return;
+      callback(ev);
+    };
+    window.addEventListener("message", listener);
+    const close = () => window.removeEventListener("message", listener);
+    this.onClose(close);
+    return {
+      close
+    };
+  }
+  cleanup() {
+    if (this._windowInstance && !this._windowInstance.closed) {
+      this._windowInstance.close();
     }
-    onMessage(callback) {
-        const listener = (ev) => {
-            if (ev.source !== this._windowInstance)
-                return;
-            callback(ev);
-        };
-        window.addEventListener("message", listener);
-        const close = () => window.removeEventListener("message", listener);
-        this.onClose(close);
-        return {
-            close,
-        };
+    this._windowInstance = null;
+    if (this._messageHandler) {
+      window.removeEventListener("message", this._messageHandler);
+      this._messageHandler = null;
     }
-    cleanup() {
-        if (this._windowInstance && !this._windowInstance.closed) {
-            this._windowInstance.close();
-        }
-        if (this._messageHandler) {
-            window.removeEventListener("message", this._messageHandler);
-            this._messageHandler = null;
-        }
-        if (this._messages$ && !this._messages$.closed) {
-            this._messages$.complete();
-        }
-        this._windowInstance = null;
+    if (this._messages$ && !this._messages$.closed) {
+      this._messages$.complete();
     }
-    onClose(callback) {
-        return this._messages$.subscribe({
-            complete: callback,
-        });
+  }
+  onClose(callback) {
+    return this._messages$.subscribe({
+      complete: callback
+    });
+  }
+  isWindowOpen(windowInstance) {
+    return !(!windowInstance || windowInstance.closed || typeof windowInstance.closed == "undefined");
+  }
+  tryOpenWindow() {
+    const windowInstance = window.open(this.windowUrl, this.windowId, getWindowFeatures(425, 680));
+    if (this.isWindowOpen(windowInstance)) {
+      return windowInstance;
     }
+    return null;
+  }
+  scheduleWindowClosedChecks(windowInstance) {
+    const checkWindow = setInterval(() => {
+      if (!windowInstance || windowInstance.closed) {
+        clearInterval(checkWindow);
+        if (windowInstance === this._windowInstance) {
+          this.cleanup();
+        }
+      }
+    }, 500);
+  }
 }
 
 class WindowService {
@@ -2028,37 +2021,60 @@ class WindowService {
         if (!windowInstance) {
             throw new Error("Window instance not found");
         }
-        const response = firstValueFrom(windowController.messages$.pipe(filter((event) => event.data.type === AirMessageTypes.INITIALIZATION_RESPONSE)));
-        windowController.postMessage({ type: AirMessageTypes.INITIALIZATION_REQUEST, payload }, [port]);
+        const response = firstValueFrom(windowController.messages$.pipe(filter((event) => event.data.type ===
+            AirWalletMessageTypes.INITIALIZATION_RESPONSE)));
+        windowController.postMessage({ type: AirWalletMessageTypes.INITIALIZATION_REQUEST, payload }, [
+            port,
+        ]);
         return (await response).data;
     }
-    async openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, port, }) {
+    async openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, onRetry, sdkVersion, enableAutomation, }) {
         if (this.windowControllers.has(windowId)) {
             throw new Error("Window controller already exists");
         }
-        const windowController = new WindowController(url, windowId);
-        this.windowControllers.set(windowId, windowController);
-        windowController.openWindow();
+        const windowController = new WindowController(windowId, url);
+        const { pendingWindowOpenCheck } = await windowController.openWindow(onRetry);
         windowController.onClose(() => {
             this.removeWindowController(windowId);
         });
-        await new Promise((resolve, reject) => {
-            windowController.onMessage(async (ev) => {
-                if (ev.data === AirMessageTypes.SERVICE_STARTED) {
-                    const { payload } = await this.sendWindowInitializationRequest(windowId, {
-                        partnerId,
-                        enableLogging,
-                    }, port);
-                    if (payload.success === false) {
-                        reject(new AirServiceError(payload.errorName, payload.errorMessage));
-                    }
-                    else {
-                        resolve();
+        this.windowControllers.set(windowId, windowController);
+        let channel = null;
+        const initializeWindow = () => {
+            return new Promise((resolve, reject) => {
+                windowController.onMessage(async (ev) => {
+                    if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
+                        try {
+                            channel = new MessageChannel();
+                            const { payload } = await this.sendWindowInitializationRequest(windowId, {
+                                partnerId,
+                                enableLogging,
+                                sdkVersion,
+                                enableAutomation,
+                            }, channel.port1);
+                            if (payload.success === false) {
+                                reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                            }
+                            else {
+                                resolve();
+                            }
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
                     }
-                }
+                });
             });
-        });
-        return windowController;
+        };
+        const initializeWindowPromise = initializeWindow();
+        const result = await pendingWindowOpenCheck;
+        if (result === "retry") {
+            // we can ignore previous initialization attempt since a new window was opened
+            await initializeWindow();
+        }
+        else {
+            await initializeWindowPromise;
+        }
+        return { windowController, port: channel.port2 };
     }
     getWindowController(windowId) {
         return this.windowControllers.get(windowId);
@@ -2069,27 +2085,265 @@ class WindowService {
 }
 var WindowService$1 = WindowService.instance;
 
-var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_walletLoggedInResult, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_subscribeToWalletEvents, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_createWalletInitializedResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
+var _a$1, _AuthMessageService_instance;
+const ALLOWED_AUTH_MESSAGES = [
+    AirAuthMessageTypes.INITIALIZATION_RESPONSE,
+    AirAuthMessageTypes.LOGIN_RESPONSE,
+    AirAuthMessageTypes.SETUP_WALLET_REQUEST,
+    AirAuthMessageTypes.LOGOUT_RESPONSE,
+    AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
+    AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE,
+    AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE,
+    AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
+    AirAuthMessageTypes.CREDENTIAL_SALT_RESPONSE,
+];
+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() {
+        await this.sendMessage({
+            type: AirAuthMessageTypes.INIT_WALLET_COMMUNICATION,
+        });
+    }
+    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;
+    }
+    async sendCredentialSaltRequest() {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.CREDENTIAL_SALT_RESPONSE)));
+        await this.sendMessage({ type: AirAuthMessageTypes.CREDENTIAL_SALT_REQUEST });
+        return response;
+    }
+}
+_a$1 = AuthMessageService;
+_AuthMessageService_instance = { value: void 0 };
+
+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.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) {
+        await this.sendMessage({
+            type: AirWalletMessageTypes.INIT_AUTH_COMMUNICATION,
+            payload: {
+                skipWalletLogin,
+            },
+        });
+    }
+    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;
+    }
+    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: void 0 };
+
+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?.href}] LogLevel: ${getLevelName(log.getLevel())}`);
+};
+
+var version = "1.3.0";
+var airkitPackage = {
+	version: version};
+
+var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authMessagingService, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletMessagingService, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_walletLoggedInResult, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_subscribeToWalletEvents, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_createWalletInitializedResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
+const airKitVersion = airkitPackage.version;
 class AirService {
     constructor({ partnerId }) {
         _AirService_instances.add(this);
-        _AirService_loginResult.set(this, undefined);
-        _AirService_buildEnv.set(this, undefined);
+        _AirService_loginResult.set(this, void 0);
+        _AirService_buildEnv.set(this, void 0);
         _AirService_enableLogging.set(this, false);
-        _AirService_partnerId.set(this, undefined);
+        _AirService_partnerId.set(this, void 0);
         //#modalZIndex: number; TODO implement z index overwrite
-        _AirService_authIframeController.set(this, undefined);
+        _AirService_authMessagingService.set(this, void 0);
+        _AirService_authIframeController.set(this, void 0);
         _AirService_isAuthInitialized.set(this, false);
         _AirService_airAuthListener.set(this, []);
-        _AirService_walletIframeController.set(this, undefined);
-        _AirService_walletInitialization.set(this, undefined);
-        _AirService_walletLoggedInResult.set(this, undefined);
-        _AirService_airWalletProvider.set(this, undefined);
+        _AirService_walletMessagingService.set(this, void 0);
+        _AirService_walletIframeController.set(this, void 0);
+        _AirService_walletInitialization.set(this, void 0);
+        _AirService_walletLoggedInResult.set(this, void 0);
+        _AirService_airWalletProvider.set(this, void 0);
         __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;
     }
@@ -2113,6 +2367,9 @@ class AirService {
             removeListener: provider.removeListener.bind(provider),
         };
     }
+    shouldEnableAutomation() {
+        return localStorage.getItem("automation") === "true" && __classPrivateFieldGet(this, _AirService_buildEnv, "f") !== "production";
+    }
     async init({ buildEnv = BUILD_ENV.PRODUCTION, enableLogging = false, skipRehydration = false, }) {
         if (!__classPrivateFieldGet(this, _AirService_partnerId, "f"))
             throw new Error("Partner ID is required to initialize auth service");
@@ -2120,61 +2377,48 @@ class AirService {
             return;
         __classPrivateFieldSet(this, _AirService_buildEnv, buildEnv, "f");
         __classPrivateFieldSet(this, _AirService_enableLogging, enableLogging, "f");
-        const { authUrl, logLevel } = AIR_URLS[buildEnv];
-        log.setDefaultLevel(logLevel);
-        if (__classPrivateFieldGet(this, _AirService_enableLogging, "f"))
-            log.enableAll();
-        else
-            log.disableAll();
+        const { authUrl } = AIR_URLS[buildEnv];
+        configureLogLevel(buildEnv, enableLogging);
         const authIframeOrigin = new URL(authUrl).origin;
-        await AirMessageService$1.openAuthObservables({ authIframeOrigin });
         __classPrivateFieldSet(this, _AirService_authIframeController, new IframeController(authUrl, `air-auth-${randomId()}`), "f");
-        AirMessageService$1.authMessage$.subscribe(async (msg) => {
-            switch (msg.type) {
-                case AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST: {
-                    const authIframeController = __classPrivateFieldGet(this, _AirService_authIframeController, "f");
-                    authIframeController.setIframeVisibility(msg.payload.visible);
-                    authIframeController.updateIframeState();
-                    break;
-                }
-                case AirAuthMessageTypes.SETUP_WALLET_REQUEST: {
-                    try {
-                        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, { skipWalletLogin: true });
-                        __classPrivateFieldGet(this, _AirService_authIframeController, "f").postMessage({
-                            type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
-                            payload: {
-                                success: true,
-                            },
-                        });
+        try {
+            __classPrivateFieldGet(this, _AirService_authIframeController, "f").createIframe();
+            log.info(authUrl, "url loaded");
+            await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").open(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+            __classPrivateFieldGet(this, _AirService_authMessagingService, "f").messages$.subscribe(async (msg) => {
+                switch (msg.type) {
+                    case AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST: {
+                        const authIframeController = __classPrivateFieldGet(this, _AirService_authIframeController, "f");
+                        authIframeController.setIframeVisibility(msg.payload.visible);
+                        authIframeController.updateIframeState();
+                        break;
                     }
-                    catch (err) {
-                        log.error("Error initializing wallet", err);
-                        const error = AirServiceError.from(err);
-                        __classPrivateFieldGet(this, _AirService_authIframeController, "f").postMessage({
-                            type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
-                            payload: {
-                                success: false,
-                                errorName: error.name ?? "UNKNOWN_ERROR",
-                                errorMessage: error.message ?? "Unknown error occurred",
-                            },
-                        });
+                    case AirAuthMessageTypes.SETUP_WALLET_REQUEST: {
+                        try {
+                            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, { skipWalletLogin: true });
+                            await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendSetupWalletSuccessResponse();
+                        }
+                        catch (err) {
+                            const error = ensureError(err);
+                            await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendSetupWalletErrorResponse(error);
+                        }
+                        break;
                     }
-                    break;
                 }
-            }
-        });
-        try {
-            __classPrivateFieldGet(this, _AirService_authIframeController, "f").createIframe();
+            });
             const result = await new Promise((resolve, reject) => {
                 const handleAuthMessage = async (ev) => {
                     if (ev.origin !== authIframeOrigin)
                         return;
                     if (ev.data === AirAuthMessageTypes.AUTH_SETUP_COMPLETED) {
                         window.removeEventListener("message", handleAuthMessage);
-                        const { payload } = await AirMessageService$1.sendAuthInitializationRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, {
+                        const { payload } = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendInitializationRequest({
                             partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                             skipRehydration,
                             partnerDAppUrl: window.location.href,
+                            sdkVersion: airKitVersion,
+                            enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
+                            enableAutomation: this.shouldEnableAutomation(),
                         });
                         if (payload.success === true) {
                             resolve(payload);
@@ -2207,8 +2451,7 @@ class AirService {
             throw new Error("Service is not initialized");
         if (__classPrivateFieldGet(this, _AirService_loginResult, "f"))
             return __classPrivateFieldGet(this, _AirService_loginResult, "f");
-        const iframeController = __classPrivateFieldGet(this, _AirService_authIframeController, "f");
-        const { payload } = await AirMessageService$1.sendAuthLoginRequest(iframeController.iframeElement, {
+        const { payload } = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendLoginRequest({
             partnerLoginToken: options?.authToken,
         });
         if (payload.success === true) {
@@ -2216,7 +2459,7 @@ class AirService {
             __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedIn).call(this);
             return __classPrivateFieldGet(this, _AirService_loginResult, "f");
         }
-        throw new AirServiceError("UNKNOWN_ERROR", "Unknown error occurred");
+        throw new AirServiceError(payload.errorName, payload.errorMessage);
     }
     /**
      * @experimental This method is experimental and will change in the future.
@@ -2227,7 +2470,7 @@ class AirService {
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
         try {
             log.info("deploySmartAccount");
-            const { payload } = await AirMessageService$1.sendDeploySmartAccountRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+            const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendDeploySmartAccountRequest();
             if (payload.success === false) {
                 throw new AirServiceError(payload.errorName, payload.errorMessage);
             }
@@ -2240,67 +2483,16 @@ class AirService {
     /**
      * @experimental This method is experimental and will change in the future.
      */
-    async grantPermission(policies) {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("AirAuth is not initialized");
-        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
-        try {
-            log.info("grantPermission", policies);
-            const { payload } = await AirMessageService$1.sendGrantPermissionsRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, { policies });
-            if (payload.success === false) {
-                throw new AirServiceError(payload.errorName, payload.errorMessage);
-            }
-            return payload.sessionData;
-        }
-        catch (error) {
-            throw AirServiceError.from(error);
-        }
-    }
-    /**
-     * @experimental This method is experimental and will change in the future.
-     */
-    async listAllSessionKeyScopes() {
+    async isSmartAccountDeployed() {
         if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
             throw new Error("Service is not initialized");
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
         try {
-            const { payload } = await AirMessageService$1.sendListAllSessionKeyScopesRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+            const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendIsSmartAccountDeployedRequest();
             if (payload.success === false) {
                 throw new AirServiceError(payload.errorName, payload.errorMessage);
             }
-            return payload.sessionKeyScopes;
-        }
-        catch (error) {
-            throw AirServiceError.from(error);
-        }
-    }
-    /**
-     * @experimental This method is experimental and will change in the future.
-     */
-    async executeAction(params) {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
-        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
-        try {
-            log.info("executeAction", params);
-            const txHash = await AirMessageService$1.sendExecuteActionRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, params);
-            return txHash;
-        }
-        catch (error) {
-            throw AirServiceError.from(error);
-        }
-    }
-    /**
-     * @experimental This method is experimental and will change in the future.
-     */
-    async revokePermission(permissionId) {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
-        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
-        try {
-            log.info("revokePermission", permissionId);
-            const txHash = await AirMessageService$1.sendRevokePermissionsRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, permissionId);
-            return txHash;
+            return payload.isDeployed;
         }
         catch (error) {
             throw AirServiceError.from(error);
@@ -2309,20 +2501,18 @@ class AirService {
     /**
      * @experimental This method is experimental and will change in the future.
      */
-    async isSmartAccountDeployed() {
+    async getCredentialSalt() {
         if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
             throw new Error("Service is not initialized");
-        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
-        try {
-            const { payload } = await AirMessageService$1.sendIsSmartAccountDeployedRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
-            if (payload.success === false) {
-                throw new AirServiceError(payload.errorName, payload.errorMessage);
-            }
-            return payload.isDeployed;
-        }
-        catch (error) {
-            throw AirServiceError.from(error);
+        if (!this.isLoggedIn)
+            throw new Error("No active session to get partner access token");
+        const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendCredentialSaltRequest();
+        if (result.payload.success === false) {
+            throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
         }
+        return {
+            credentialSalt: result.payload.credentialSalt,
+        };
     }
     getProvider() {
         return this.provider;
@@ -2332,14 +2522,18 @@ class AirService {
     }
     async setupOrUpdateMfa() {
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, { skipWalletLogin: true });
-        const result = await AirMessageService$1.sendSetupMfaRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+        const result = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendSetupMfaRequest();
         if (result.payload.success === false) {
             throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
         }
+        __classPrivateFieldSet(this, _AirService_loginResult, {
+            ...__classPrivateFieldGet(this, _AirService_loginResult, "f"),
+            isMFASetup: true,
+        }, "f");
     }
     async claimAirId(options) {
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
-        const result = await AirMessageService$1.sendClaimIdRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, options ?? {});
+        const result = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendClaimIdRequest(options ?? {});
         if (result.payload.success === true) {
             return { airId: result.payload.airId };
         }
@@ -2348,7 +2542,7 @@ class AirService {
     async getUserInfo() {
         if (!this.isLoggedIn)
             throw new Error("User not logged in");
-        const info = await AirMessageService$1.sendPartnerUserInfoRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+        const info = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendPartnerUserInfoRequest();
         if (info.payload.success === false) {
             throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
         }
@@ -2369,7 +2563,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 AirMessageService$1.sendCrossPartnerTokenRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, partnerUrl);
+        const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendCrossPartnerTokenRequest(partnerUrl);
         if (result.payload.success === false) {
             throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
         }
@@ -2377,6 +2571,20 @@ 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");
@@ -2384,7 +2592,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 AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").logout();
         __classPrivateFieldSet(this, _AirService_loginResult, undefined, "f");
         __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedOut).call(this);
     }
@@ -2404,22 +2612,8 @@ 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_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airAuthListener = new WeakMap(), _AirService_walletIframeController = new WeakMap(), _AirService_walletInitialization = new WeakMap(), _AirService_walletLoggedInResult = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet(option) {
+_AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_authMessagingService = new WeakMap(), _AirService_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airAuthListener = new WeakMap(), _AirService_walletMessagingService = new WeakMap(), _AirService_walletIframeController = new WeakMap(), _AirService_walletInitialization = new WeakMap(), _AirService_walletLoggedInResult = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet(option) {
     if (!this.isInitialized)
         throw new Error("Service not initialized");
     if (!this.isLoggedIn && !option?.skipWalletLogin)
@@ -2441,7 +2635,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     }
     if (__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f"))
         return __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f");
-    const walletLoginResult = await AirMessageService$1.sendWalletLoginRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+    const walletLoginResult = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendLoginRequest();
     if (walletLoginResult.payload.success !== true) {
         throw new AirServiceError(walletLoginResult.payload.errorName, walletLoginResult.payload.errorMessage);
     }
@@ -2450,22 +2644,19 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     if (__classPrivateFieldGet(this, _AirService_walletInitialization, "f"))
         throw new Error("Already initializing");
     const { walletUrl } = AIR_URLS[__classPrivateFieldGet(this, _AirService_buildEnv, "f")];
-    log.info(walletUrl, "url loaded");
     const walletIframeOrigin = new URL(walletUrl).origin;
-    await AirMessageService$1.openWalletObservables({ walletIframeOrigin });
     try {
-        __classPrivateFieldSet(this, _AirService_walletIframeController, new IframeController(walletUrl, `air-wallet-${randomId()}`), "f");
-        __classPrivateFieldGet(this, _AirService_walletIframeController, "f").createIframe();
-        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_subscribeToWalletEvents).call(this);
-        await new Promise((resolve, reject) => {
-            const handleAuthMessage = async (ev) => {
+        const walletInitRequestPromise = new Promise((resolve, reject) => {
+            const handleWalletMessage = async (ev) => {
                 if (ev.origin !== walletIframeOrigin)
                     return;
-                if (ev.data === AirMessageTypes.SERVICE_STARTED) {
-                    window.removeEventListener("message", handleAuthMessage);
-                    const { payload } = await AirMessageService$1.sendWalletInitializationRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, {
+                if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
+                    window.removeEventListener("message", handleWalletMessage);
+                    const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendInitializationRequest({
                         partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                         enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
+                        sdkVersion: airKitVersion,
+                        enableAutomation: this.shouldEnableAutomation(),
                     });
                     if (payload.success === true) {
                         resolve();
@@ -2475,11 +2666,18 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
                     }
                 }
             };
-            window.addEventListener("message", handleAuthMessage);
+            window.addEventListener("message", handleWalletMessage);
         });
-        __classPrivateFieldGet(this, _AirService_airWalletProvider, "f").startEventMessageListening();
-        const walletInitPromise = AirMessageService$1.onWalletInitialized();
-        AirMessageService$1.setupIframeCommunication(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, __classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, option?.skipWalletLogin ?? false);
+        __classPrivateFieldSet(this, _AirService_walletIframeController, new IframeController(walletUrl, `air-wallet-${randomId()}`), "f");
+        __classPrivateFieldGet(this, _AirService_walletIframeController, "f").createIframe();
+        log.info(walletUrl, "url loaded");
+        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;
+        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").initWalletCommunication();
+        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").initAuthCommunication(option?.skipWalletLogin ?? false);
         const walletInitResult = await walletInitPromise;
         if (walletInitResult.payload.success !== true) {
             throw new AirServiceError(walletInitResult.payload.errorName, walletInitResult.payload.errorMessage);
@@ -2496,37 +2694,44 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         throw error;
     }
 }, _AirService_subscribeToWalletEvents = function _AirService_subscribeToWalletEvents() {
-    AirMessageService$1.messages$.subscribe(async (msg) => {
+    __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").messages$.subscribe(async (msg) => {
         switch (msg.type) {
-            case AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST: {
+            case AirWalletMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST: {
                 const walletIframeController = __classPrivateFieldGet(this, _AirService_walletIframeController, "f");
                 walletIframeController.setIframeVisibility(msg.payload.visible);
                 walletIframeController.updateIframeState();
                 break;
             }
-            case AirMessageTypes.WALLET_LOGIN_RESPONSE: {
+            case AirWalletMessageTypes.WALLET_LOGIN_RESPONSE: {
                 if (msg.payload.success === true && !__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f")) {
                     __classPrivateFieldSet(this, _AirService_walletLoggedInResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, msg.payload), "f");
                     __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerWalletInitialized).call(this, __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f"));
                 }
                 break;
             }
-            case AirMessageTypes.OPEN_WINDOW_REQUEST: {
+            case AirWalletMessageTypes.OPEN_WINDOW_REQUEST: {
                 try {
-                    const channel = new MessageChannel();
-                    const windowController = await WindowService$1.openAndInitializeWalletServiceWindow({
+                    const onRetry = async () => {
+                        const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendOpenWindowRetryRequest(msg.payload.windowId);
+                        if (payload.success === false) {
+                            throw new AirServiceError(payload.errorName, payload.errorMessage);
+                        }
+                    };
+                    const { windowController, port } = await WindowService$1.openAndInitializeWalletServiceWindow({
                         url: msg.payload.url,
                         windowId: msg.payload.windowId,
                         partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                         enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
-                        port: channel.port1,
+                        sdkVersion: airKitVersion,
+                        enableAutomation: this.shouldEnableAutomation(),
+                        onRetry,
                     });
-                    windowController.onClose(() => AirMessageService$1.sendWindowClosed(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, msg.payload.windowId));
-                    AirMessageService$1.sendOpenWindowSuccessResponse(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, msg.payload.windowId, channel.port2);
+                    windowController.onClose(async () => await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendWindowClosed(msg.payload.windowId));
+                    await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendOpenWindowSuccessResponse(msg.payload.windowId, port);
                 }
                 catch (err) {
                     const error = ensureError(err);
-                    AirMessageService$1.sendOpenWindowErrorResponse(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, msg.payload.windowId, error);
+                    await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendOpenWindowErrorResponse(msg.payload.windowId, error);
                 }
                 break;
             }
@@ -2571,7 +2776,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     };
 }, _AirService_cleanUpAuth = async function _AirService_cleanUpAuth() {
     // Logout auth session
-    await AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+    await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").logout();
     // Destroy the auth iframe
     const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
     if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
@@ -2579,7 +2784,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         __classPrivateFieldSet(this, _AirService_authIframeController, undefined, "f");
     }
     // Close the message service
-    AirMessageService$1.closeAuthObservables();
+    await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").close();
     __classPrivateFieldSet(this, _AirService_isAuthInitialized, false, "f");
 }, _AirService_cleanUpWallet = async function _AirService_cleanUpWallet() {
     if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
@@ -2587,18 +2792,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 AirMessageService$1.logoutWallet(walletIframeElement);
+        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").logout();
         __classPrivateFieldGet(this, _AirService_walletIframeController, "f").destroy();
         __classPrivateFieldSet(this, _AirService_walletIframeController, undefined, "f");
     }
     const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
     if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
-        AirMessageService$1.sendResetAuthServiceWalletCommunication(authIframeElement);
+        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").resetWalletCommunication();
     }
     // Close the message service
-    AirMessageService$1.closeAirObservables();
+    await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").close();
     __classPrivateFieldSet(this, _AirService_walletLoggedInResult, undefined, "f");
     __classPrivateFieldSet(this, _AirService_walletInitialization, undefined, "f");
 };
 
-export { AirService, AirServiceError, BUILD_ENV, ChainDisconnectedError, InternalRpcError, InvalidParamsRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, ProviderDisconnectedError, SwitchChainError, UnauthorizedProviderError, UnsupportedProviderMethodError, UserRejectedRequestError, ensureProviderRpcError };
+export { AirService, AirServiceError, BUILD_ENV, ChainDisconnectedError, InternalRpcError, InvalidParamsRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, ProviderDisconnectedError, ProviderRpcError, SwitchChainError, TransactionRejectedRpcError, UnauthorizedProviderError, UnsupportedProviderMethodError, UserRejectedRequestError, ensureProviderRpcError };