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

package/dist/airkitConnector.cjs.js

@@ -1,6 +1,2962 @@
 'use strict';
 
-var airkit = require('@mocanetwork/airkit');
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function (d, b) {
+  extendStatics = Object.setPrototypeOf || {
+    __proto__: []
+  } instanceof Array && function (d, b) {
+    d.__proto__ = b;
+  } || function (d, b) {
+    for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator,
+    m = s && o[s],
+    i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function () {
+      if (o && i >= o.length) o = undefined;
+      return {
+        value: o && o[i++],
+        done: !o
+      };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to, from, pack) {
+  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+function __classPrivateFieldGet$1(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return f ? f.value = value : state.set(receiver, value), value;
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+const AirAuthMessageTypes = {
+  AUTH_SETUP_COMPLETED: "air_auth_setup_completed",
+  INITIALIZATION_REQUEST: "air_auth_initialization_request",
+  INITIALIZATION_RESPONSE: "air_auth_initialization_response",
+  LOGIN_REQUEST: "air_auth_login_request",
+  LOGIN_RESPONSE: "air_auth_login_response",
+  LOGIN_WALLET_RESPONSE: "air_auth_login_wallet_response",
+  USER_INFO_REQUEST: "air_auth_user_info_request",
+  USER_INFO_RESPONSE: "air_auth_user_info_response",
+  PARTNER_USER_INFO_REQUEST: "air_auth_partner_user_info_request",
+  PARTNER_USER_INFO_RESPONSE: "air_auth_partner_user_info_response",
+  REFRESH_TOKEN_REQUEST: "air_auth_refresh_token_request",
+  REFRESH_TOKEN_RESPONSE: "air_auth_refresh_token_response",
+  WALLET_TOKEN_REQUEST: "air_auth_wallet_token_request",
+  WALLET_TOKEN_RESPONSE: "air_auth_wallet_token_response",
+  INIT_WALLET_COMMUNICATION: "air_auth_init_wallet_communication",
+  IFRAME_VISIBILITY_REQUEST: "air_auth_iframe_visibility_request",
+  SETUP_WALLET_REQUEST: "air_auth_setup_wallet_request",
+  SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_response",
+  SIGN_SIWE_MESSAGE_REQUEST: "air_auth_sign_siwe_message_request",
+  SIGN_SIWE_MESSAGE_RESPONSE: "air_auth_sign_siwe_message_response",
+  CROSS_PARTNER_TOKEN_REQUEST: "air_auth_cross_partner_token_request",
+  CROSS_PARTNER_TOKEN_RESPONSE: "air_auth_cross_partner_token_response",
+  PARTNER_ACCESS_TOKEN_REQUEST: "air_auth_partner_access_token_request",
+  PARTNER_ACCESS_TOKEN_RESPONSE: "air_auth_partner_access_token_response",
+  LOGOUT_REQUEST: "air_auth_logout_request",
+  LOGOUT_RESPONSE: "air_auth_logout_response",
+  RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication"
+};
+const AirWalletMessageTypes = {
+  SERVICE_STARTED: "air_service_started",
+  INITIALIZATION_REQUEST: "air_initialization_request",
+  INITIALIZATION_RESPONSE: "air_initialization_response",
+  INIT_AUTH_COMMUNICATION: "air_init_auth_communication",
+  WALLET_INITIALIZED: "air_wallet_initialized",
+  WALLET_LOGIN_REQUEST: "air_wallet_login_request",
+  WALLET_LOGIN_RESPONSE: "air_wallet_login_response",
+  SETUP_OR_UPDATE_MFA_REQUEST: "air_setup_mfa_request",
+  SETUP_OR_UPDATE_MFA_RESPONSE: "air_setup_mfa_response",
+  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",
+  LOGOUT_REQUEST: "air_logout_request",
+  LOGOUT_RESPONSE: "air_logout_response"
+};
+let BaseError$2 = class BaseError extends Error {
+  constructor(name, message, options = {}) {
+    const {
+      cause,
+      context
+    } = options;
+    super(message || name);
+    this.name = name;
+    this.stack = cause?.stack;
+    this.cause = cause;
+    this.context = context;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      context: this.context,
+      cause: this.cause
+    };
+  }
+};
+function ensureError(value) {
+  if (value instanceof Error) return value;
+  let stringified = "[Unable to stringify the thrown value]";
+  try {
+    stringified = JSON.stringify(value);
+  } catch {
+    // ignoring failed stringify
+  }
+  return new Error(`This value was not thrown as type Error: ${stringified}`);
+}
+const BUILD_ENV = {
+  PRODUCTION: "production",
+  UAT: "uat",
+  STAGING: "staging",
+  DEVELOPMENT: "development"
+};
+const AIR_URLS = {
+  [BUILD_ENV.DEVELOPMENT]: {
+    authUrl: "http://localhost:8100",
+    walletUrl: "http://localhost:8200"
+  },
+  [BUILD_ENV.UAT]: {
+    authUrl: "https://auth.uat.air3.com",
+    walletUrl: "https://account.uat.air3.com"
+  },
+  [BUILD_ENV.STAGING]: {
+    authUrl: "https://auth.staging.air3.com",
+    walletUrl: "https://account.staging.air3.com"
+  },
+  [BUILD_ENV.PRODUCTION]: {
+    authUrl: "https://auth.air3.com",
+    walletUrl: "https://account.air3.com"
+  }
+};
+const isElement = element => element instanceof Element || element instanceof Document;
+const randomId = () => Math.random().toString(36).slice(2);
+const extractErrorHash = message => {
+  if (!message) return "";
+  // Format: "reason: 0x..."
+  if (message.includes("reason:")) {
+    return message.split("reason:")[1].trim();
+  }
+  // Format: "UserOperation reverted during simulation with reason: 0x..."
+  if (message.includes("with reason:")) {
+    const match = message.match(/with reason: (0x[a-fA-F0-9]+)/);
+    return match ? match[1].trim() : "";
+  }
+  // Look for any 0x pattern that could be a hash
+  const hexMatch = message.match(/(0x[a-fA-F0-9]{8,})/);
+  return hexMatch ? hexMatch[1].trim() : "";
+};
+class AirServiceError extends BaseError$2 {
+  static from(error) {
+    if (error instanceof AirServiceError) {
+      return error;
+    } else if (error instanceof Object && "message" in error) {
+      if (error.message === "User cancelled login") {
+        return new AirServiceError("USER_CANCELLED", error.message);
+      }
+      return new AirServiceError("UNKNOWN_ERROR", error.message.toString());
+    }
+    return new AirServiceError("UNKNOWN_ERROR");
+  }
+}
+let ProviderRpcError$1 = class ProviderRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.metaMessages = [];
+  }
+};
+let UserRejectedRequestError$1 = class UserRejectedRequestError extends ProviderRpcError$1 {
+  constructor() {
+    super(...arguments);
+    this.code = 4001;
+    this.name = "UserRejectedRequestError";
+  }
+};
+class UnauthorizedProviderError extends ProviderRpcError$1 {
+  constructor() {
+    super(...arguments);
+    this.code = 4100;
+    this.name = "UnauthorizedProviderError";
+  }
+}
+class UnsupportedProviderMethodError extends ProviderRpcError$1 {
+  constructor() {
+    super(...arguments);
+    this.code = 4200;
+    this.name = "UnsupportedProviderMethodError";
+  }
+}
+class ProviderDisconnectedError extends ProviderRpcError$1 {
+  constructor() {
+    super(...arguments);
+    this.code = 4900;
+    this.name = "ProviderDisconnectedError";
+  }
+}
+class ChainDisconnectedError extends ProviderRpcError$1 {
+  constructor() {
+    super(...arguments);
+    this.code = 4901;
+    this.name = "ChainDisconnectedError";
+  }
+}
+let SwitchChainError$1 = class SwitchChainError extends ProviderRpcError$1 {
+  constructor() {
+    super(...arguments);
+    this.code = 4902;
+    this.name = "SwitchChainError";
+  }
+};
+class TransactionRejectedRpcError extends ProviderRpcError$1 {
+  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$1 {
+  constructor() {
+    super(...arguments);
+    this.code = -32600;
+    this.name = "InvalidRequestRpcError";
+  }
+}
+class MethodNotFoundRpcError extends ProviderRpcError$1 {
+  constructor() {
+    super(...arguments);
+    this.code = -32601;
+    this.name = "MethodNotFoundRpcError";
+  }
+}
+class InvalidParamsRpcError extends ProviderRpcError$1 {
+  constructor() {
+    super(...arguments);
+    this.code = -32602;
+    this.name = "InvalidParamsRpcError";
+  }
+}
+class InternalRpcError extends ProviderRpcError$1 {
+  constructor() {
+    super(...arguments);
+    this.code = -32603;
+    this.name = "InternalRpcError";
+  }
+}
+function ensureProviderRpcError(value) {
+  if (value instanceof ProviderRpcError$1) {
+    return value;
+  }
+  if (typeof value === "object" && value !== null && "errorCode" in value && "errorMessage" in value) {
+    if (typeof value.errorCode === "number" && typeof value.errorMessage === "string") {
+      switch (value.errorCode) {
+        case 4001:
+          return new UserRejectedRequestError$1(value.errorMessage);
+        case 4100:
+          return new UnauthorizedProviderError(value.errorMessage);
+        case 4200:
+          return new UnsupportedProviderMethodError(value.errorMessage);
+        case 4900:
+          return new ProviderDisconnectedError(value.errorMessage);
+        case 4901:
+          return new ChainDisconnectedError(value.errorMessage);
+        case 4902:
+          return new SwitchChainError$1(value.errorMessage);
+        case -32003:
+          return new TransactionRejectedRpcError(value.errorMessage);
+      }
+    }
+  }
+  let stringified = "[Unable to stringify the thrown value]";
+  try {
+    stringified = JSON.stringify(value);
+  } catch {
+    // ignoring failed stringify
+  }
+  return new InternalRpcError(`Invalid value for ProviderRpcError: ${stringified}`);
+}
+function getDefaultExportFromCjs$1(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+var loglevel$1$1 = {
+  exports: {}
+};
+
+/*
+* loglevel - https://github.com/pimterry/loglevel
+*
+* Copyright (c) 2013 Tim Perry
+* Licensed under the MIT license.
+*/
+var loglevel$2 = loglevel$1$1.exports;
+var hasRequiredLoglevel$1;
+function requireLoglevel$1() {
+  if (hasRequiredLoglevel$1) return loglevel$1$1.exports;
+  hasRequiredLoglevel$1 = 1;
+  (function (module) {
+    (function (root, definition) {
+      if (module.exports) {
+        module.exports = definition();
+      } else {
+        root.log = definition();
+      }
+    })(loglevel$2, function () {
+      // Slightly dubious tricks to cut down minimized file size
+      var noop = function () {};
+      var undefinedType = "undefined";
+      var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
+      var logMethods = ["trace", "debug", "info", "warn", "error"];
+      var _loggersByName = {};
+      var defaultLogger = null;
+
+      // Cross-browser bind equivalent that works at least back to IE6
+      function bindMethod(obj, methodName) {
+        var method = obj[methodName];
+        if (typeof method.bind === 'function') {
+          return method.bind(obj);
+        } else {
+          try {
+            return Function.prototype.bind.call(method, obj);
+          } catch (e) {
+            // Missing bind shim or IE8 + Modernizr, fallback to wrapping
+            return function () {
+              return Function.prototype.apply.apply(method, [obj, arguments]);
+            };
+          }
+        }
+      }
+
+      // Trace() doesn't print the message in IE, so for that case we need to wrap it
+      function traceForIE() {
+        if (console.log) {
+          if (console.log.apply) {
+            console.log.apply(console, arguments);
+          } else {
+            // In old IE, native console methods themselves don't have apply().
+            Function.prototype.apply.apply(console.log, [console, arguments]);
+          }
+        }
+        if (console.trace) console.trace();
+      }
+
+      // Build the best logging method possible for this env
+      // Wherever possible we want to bind, not wrap, to preserve stack traces
+      function realMethod(methodName) {
+        if (methodName === 'debug') {
+          methodName = 'log';
+        }
+        if (typeof console === undefinedType) {
+          return false; // No method possible, for now - fixed later by enableLoggingWhenConsoleArrives
+        } else if (methodName === 'trace' && isIE) {
+          return traceForIE;
+        } else if (console[methodName] !== undefined) {
+          return bindMethod(console, methodName);
+        } else if (console.log !== undefined) {
+          return bindMethod(console, 'log');
+        } else {
+          return noop;
+        }
+      }
+
+      // These private functions always need `this` to be set properly
+
+      function replaceLoggingMethods() {
+        /*jshint validthis:true */
+        var level = this.getLevel();
+
+        // Replace the actual methods.
+        for (var i = 0; i < logMethods.length; i++) {
+          var methodName = logMethods[i];
+          this[methodName] = i < level ? noop : this.methodFactory(methodName, level, this.name);
+        }
+
+        // Define log.log as an alias for log.debug
+        this.log = this.debug;
+
+        // Return any important warnings.
+        if (typeof console === undefinedType && level < this.levels.SILENT) {
+          return "No console available for logging";
+        }
+      }
+
+      // In old IE versions, the console isn't present until you first open it.
+      // We build realMethod() replacements here that regenerate logging methods
+      function enableLoggingWhenConsoleArrives(methodName) {
+        return function () {
+          if (typeof console !== undefinedType) {
+            replaceLoggingMethods.call(this);
+            this[methodName].apply(this, arguments);
+          }
+        };
+      }
+
+      // By default, we use closely bound real methods wherever possible, and
+      // otherwise we wait for a console to appear, and then try again.
+      function defaultMethodFactory(methodName, _level, _loggerName) {
+        /*jshint validthis:true */
+        return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
+      }
+      function Logger(name, factory) {
+        // Private instance variables.
+        var self = this;
+        /**
+         * The level inherited from a parent logger (or a global default). We
+         * cache this here rather than delegating to the parent so that it stays
+         * in sync with the actual logging methods that we have installed (the
+         * parent could change levels but we might not have rebuilt the loggers
+         * in this child yet).
+         * @type {number}
+         */
+        var inheritedLevel;
+        /**
+         * The default level for this logger, if any. If set, this overrides
+         * `inheritedLevel`.
+         * @type {number|null}
+         */
+        var defaultLevel;
+        /**
+         * A user-specific level for this logger. If set, this overrides
+         * `defaultLevel`.
+         * @type {number|null}
+         */
+        var userLevel;
+        var storageKey = "loglevel";
+        if (typeof name === "string") {
+          storageKey += ":" + name;
+        } else if (typeof name === "symbol") {
+          storageKey = undefined;
+        }
+        function persistLevelIfPossible(levelNum) {
+          var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
+          if (typeof window === undefinedType || !storageKey) return;
+
+          // Use localStorage if available
+          try {
+            window.localStorage[storageKey] = levelName;
+            return;
+          } catch (ignore) {}
+
+          // Use session cookie as fallback
+          try {
+            window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
+          } catch (ignore) {}
+        }
+        function getPersistedLevel() {
+          var storedLevel;
+          if (typeof window === undefinedType || !storageKey) return;
+          try {
+            storedLevel = window.localStorage[storageKey];
+          } catch (ignore) {}
+
+          // Fallback to cookies if local storage gives us nothing
+          if (typeof storedLevel === undefinedType) {
+            try {
+              var cookie = window.document.cookie;
+              var cookieName = encodeURIComponent(storageKey);
+              var location = cookie.indexOf(cookieName + "=");
+              if (location !== -1) {
+                storedLevel = /^([^;]+)/.exec(cookie.slice(location + cookieName.length + 1))[1];
+              }
+            } catch (ignore) {}
+          }
+
+          // If the stored level is not valid, treat it as if nothing was stored.
+          if (self.levels[storedLevel] === undefined) {
+            storedLevel = undefined;
+          }
+          return storedLevel;
+        }
+        function clearPersistedLevel() {
+          if (typeof window === undefinedType || !storageKey) return;
+
+          // Use localStorage if available
+          try {
+            window.localStorage.removeItem(storageKey);
+          } catch (ignore) {}
+
+          // Use session cookie as fallback
+          try {
+            window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+          } catch (ignore) {}
+        }
+        function normalizeLevel(input) {
+          var level = input;
+          if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
+            level = self.levels[level.toUpperCase()];
+          }
+          if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
+            return level;
+          } else {
+            throw new TypeError("log.setLevel() called with invalid level: " + input);
+          }
+        }
+
+        /*
+         *
+         * Public logger API - see https://github.com/pimterry/loglevel for details
+         *
+         */
+
+        self.name = name;
+        self.levels = {
+          "TRACE": 0,
+          "DEBUG": 1,
+          "INFO": 2,
+          "WARN": 3,
+          "ERROR": 4,
+          "SILENT": 5
+        };
+        self.methodFactory = factory || defaultMethodFactory;
+        self.getLevel = function () {
+          if (userLevel != null) {
+            return userLevel;
+          } else if (defaultLevel != null) {
+            return defaultLevel;
+          } else {
+            return inheritedLevel;
+          }
+        };
+        self.setLevel = function (level, persist) {
+          userLevel = normalizeLevel(level);
+          if (persist !== false) {
+            // defaults to true
+            persistLevelIfPossible(userLevel);
+          }
+
+          // NOTE: in v2, this should call rebuild(), which updates children.
+          return replaceLoggingMethods.call(self);
+        };
+        self.setDefaultLevel = function (level) {
+          defaultLevel = normalizeLevel(level);
+          if (!getPersistedLevel()) {
+            self.setLevel(level, false);
+          }
+        };
+        self.resetLevel = function () {
+          userLevel = null;
+          clearPersistedLevel();
+          replaceLoggingMethods.call(self);
+        };
+        self.enableAll = function (persist) {
+          self.setLevel(self.levels.TRACE, persist);
+        };
+        self.disableAll = function (persist) {
+          self.setLevel(self.levels.SILENT, persist);
+        };
+        self.rebuild = function () {
+          if (defaultLogger !== self) {
+            inheritedLevel = normalizeLevel(defaultLogger.getLevel());
+          }
+          replaceLoggingMethods.call(self);
+          if (defaultLogger === self) {
+            for (var childName in _loggersByName) {
+              _loggersByName[childName].rebuild();
+            }
+          }
+        };
+
+        // Initialize all the internal levels.
+        inheritedLevel = normalizeLevel(defaultLogger ? defaultLogger.getLevel() : "WARN");
+        var initialLevel = getPersistedLevel();
+        if (initialLevel != null) {
+          userLevel = normalizeLevel(initialLevel);
+        }
+        replaceLoggingMethods.call(self);
+      }
+
+      /*
+       *
+       * Top-level API
+       *
+       */
+
+      defaultLogger = new Logger();
+      defaultLogger.getLogger = function getLogger(name) {
+        if (typeof name !== "symbol" && typeof name !== "string" || name === "") {
+          throw new TypeError("You must supply a name when creating a logger.");
+        }
+        var logger = _loggersByName[name];
+        if (!logger) {
+          logger = _loggersByName[name] = new Logger(name, defaultLogger.methodFactory);
+        }
+        return logger;
+      };
+
+      // Grab the current global log variable in case of overwrite
+      var _log = typeof window !== undefinedType ? window.log : undefined;
+      defaultLogger.noConflict = function () {
+        if (typeof window !== undefinedType && window.log === defaultLogger) {
+          window.log = _log;
+        }
+        return defaultLogger;
+      };
+      defaultLogger.getLoggers = function getLoggers() {
+        return _loggersByName;
+      };
+
+      // ES6 default export, for compatibility
+      defaultLogger['default'] = defaultLogger;
+      return defaultLogger;
+    });
+  })(loglevel$1$1);
+  return loglevel$1$1.exports;
+}
+var loglevelExports$1 = requireLoglevel$1();
+var log$1 = /*@__PURE__*/getDefaultExportFromCjs$1(loglevelExports$1);
+function isFunction(value) {
+  return typeof value === 'function';
+}
+function createErrorClass(createImpl) {
+  var _super = function (instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+var UnsubscriptionError = createErrorClass(function (_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join('\n  ') : '';
+    this.name = 'UnsubscriptionError';
+    this.errors = errors;
+  };
+});
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+var Subscription = function () {
+  function Subscription(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription.prototype.unsubscribe = function () {
+    var e_1, _a, e_2, _b;
+    var errors;
+    if (!this.closed) {
+      this.closed = true;
+      var _parentage = this._parentage;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = {
+              error: e_1_1
+            };
+          } finally {
+            try {
+              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        } else {
+          _parentage.remove(this);
+        }
+      }
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors !== null && errors !== void 0 ? errors : [];
+              if (err instanceof UnsubscriptionError) {
+                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+              } else {
+                errors.push(err);
+              }
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = {
+            error: e_2_1
+          };
+        } finally {
+          try {
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
+  };
+  Subscription.prototype.add = function (teardown) {
+    var _a;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof Subscription) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
+          }
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== undefined ? _a : []).push(teardown);
+      }
+    }
+  };
+  Subscription.prototype._hasParent = function (parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription.prototype._addParent = function (parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  };
+  Subscription.prototype._removeParent = function (parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription.prototype.remove = function (teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    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
+};
+var timeoutProvider = {
+  setTimeout: function (handler, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    return setTimeout.apply(undefined, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function (handle) {
+    return clearTimeout(handle);
+  },
+  delegate: undefined
+};
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function () {
+    {
+      throw err;
+    }
+  });
+}
+function noop() {}
+function errorContext(cb) {
+  {
+    cb();
+  }
+}
+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);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver.prototype.complete = function () {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  return ConsumerObserver;
+}();
+var SafeSubscriber = function (_super) {
+  __extends(SafeSubscriber, _super);
+  function SafeSubscriber(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== undefined ? observerOrNext : undefined,
+        error: error !== null && error !== undefined ? error : undefined,
+        complete: complete !== null && complete !== undefined ? complete : undefined
+      };
+    } else {
+      {
+        partialObserver = observerOrNext;
+      }
+    }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber;
+}(Subscriber);
+function handleUnhandledError(error) {
+  {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+var observable = function () {
+  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+}();
+function identity(x) {
+  return x;
+}
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input) {
+    return fns.reduce(function (prev, fn) {
+      return fn(prev);
+    }, input);
+  };
+}
+var Observable = function () {
+  function Observable(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  Observable.prototype.lift = function (operator) {
+    var observable = new Observable();
+    observable.source = this;
+    observable.operator = operator;
+    return observable;
+  };
+  Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+    var _this = this;
+    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(function () {
+      var _a = _this,
+        operator = _a.operator,
+        source = _a.source;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+    });
+    return subscriber;
+  };
+  Observable.prototype._trySubscribe = function (sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
+  };
+  Observable.prototype.forEach = function (next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function (resolve, reject) {
+      var subscriber = new SafeSubscriber({
+        next: function (value) {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+      _this.subscribe(subscriber);
+    });
+  };
+  Observable.prototype._subscribe = function (subscriber) {
+    var _a;
+    return (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber);
+  };
+  Observable.prototype[observable] = function () {
+    return this;
+  };
+  Observable.prototype.pipe = function () {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
+    }
+    return pipeFromArray(operations)(this);
+  };
+  Observable.prototype.toPromise = function (promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function (resolve, reject) {
+      var value;
+      _this.subscribe(function (x) {
+        return value = x;
+      }, function (err) {
+        return reject(err);
+      }, function () {
+        return resolve(value);
+      });
+    });
+  };
+  Observable.create = function (subscribe) {
+    return new Observable(subscribe);
+  };
+  return Observable;
+}();
+function getPromiseCtor(promiseCtor) {
+  var _a;
+  return (_a = promiseCtor !== null && promiseCtor !== undefined ? promiseCtor : config.Promise) !== null && _a !== undefined ? _a : Promise;
+}
+function isObserver(value) {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+}
+function hasLift(source) {
+  return isFunction(source === null || source === undefined ? undefined : source.lift);
+}
+function operate(init) {
+  return function (source) {
+    if (hasLift(source)) {
+      return source.lift(function (liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
+    }
+    throw new TypeError('Unable to lift unknown Observable type');
+  };
+}
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = function (_super) {
+  __extends(OperatorSubscriber, _super);
+  function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+    var _this = _super.call(this, destination) || this;
+    _this.onFinalize = onFinalize;
+    _this.shouldUnsubscribe = shouldUnsubscribe;
+    _this._next = onNext ? function (value) {
+      try {
+        onNext(value);
+      } catch (err) {
+        destination.error(err);
+      }
+    } : _super.prototype._next;
+    _this._error = onError ? function (err) {
+      try {
+        onError(err);
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._error;
+    _this._complete = onComplete ? function () {
+      try {
+        onComplete();
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._complete;
+    return _this;
+  }
+  OperatorSubscriber.prototype.unsubscribe = function () {
+    var _a;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var closed_1 = this.closed;
+      _super.prototype.unsubscribe.call(this);
+      !closed_1 && ((_a = this.onFinalize) === null || _a === undefined ? undefined : _a.call(this));
+    }
+  };
+  return OperatorSubscriber;
+}(Subscriber);
+var ObjectUnsubscribedError = createErrorClass(function (_super) {
+  return function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = 'ObjectUnsubscribedError';
+    this.message = 'object unsubscribed';
+  };
+});
+var Subject = function (_super) {
+  __extends(Subject, _super);
+  function Subject() {
+    var _this = _super.call(this) || this;
+    _this.closed = false;
+    _this.currentObservers = null;
+    _this.observers = [];
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject.prototype.lift = function (operator) {
+    var subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  };
+  Subject.prototype._throwIfClosed = function () {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+  };
+  Subject.prototype.next = function (value) {
+    var _this = this;
+    errorContext(function () {
+      var e_1, _a;
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        if (!_this.currentObservers) {
+          _this.currentObservers = Array.from(_this.observers);
+        }
+        try {
+          for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var observer = _c.value;
+            observer.next(value);
+          }
+        } catch (e_1_1) {
+          e_1 = {
+            error: e_1_1
+          };
+        } finally {
+          try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      }
+    });
+  };
+  Subject.prototype.error = function (err) {
+    var _this = this;
+    errorContext(function () {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.hasError = _this.isStopped = true;
+        _this.thrownError = err;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().error(err);
+        }
+      }
+    });
+  };
+  Subject.prototype.complete = function () {
+    var _this = this;
+    errorContext(function () {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.isStopped = true;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().complete();
+        }
+      }
+    });
+  };
+  Subject.prototype.unsubscribe = function () {
+    this.isStopped = this.closed = true;
+    this.observers = this.currentObservers = null;
+  };
+  Object.defineProperty(Subject.prototype, "observed", {
+    get: function () {
+      var _a;
+      return ((_a = this.observers) === null || _a === undefined ? undefined : _a.length) > 0;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Subject.prototype._trySubscribe = function (subscriber) {
+    this._throwIfClosed();
+    return _super.prototype._trySubscribe.call(this, subscriber);
+  };
+  Subject.prototype._subscribe = function (subscriber) {
+    this._throwIfClosed();
+    this._checkFinalizedStatuses(subscriber);
+    return this._innerSubscribe(subscriber);
+  };
+  Subject.prototype._innerSubscribe = function (subscriber) {
+    var _this = this;
+    var _a = this,
+      hasError = _a.hasError,
+      isStopped = _a.isStopped,
+      observers = _a.observers;
+    if (hasError || isStopped) {
+      return EMPTY_SUBSCRIPTION;
+    }
+    this.currentObservers = null;
+    observers.push(subscriber);
+    return new Subscription(function () {
+      _this.currentObservers = null;
+      arrRemove(observers, subscriber);
+    });
+  };
+  Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+    var _a = this,
+      hasError = _a.hasError,
+      thrownError = _a.thrownError,
+      isStopped = _a.isStopped;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped) {
+      subscriber.complete();
+    }
+  };
+  Subject.prototype.asObservable = function () {
+    var observable = new Observable();
+    observable.source = this;
+    return observable;
+  };
+  Subject.create = function (destination, source) {
+    return new AnonymousSubject(destination, source);
+  };
+  return Subject;
+}(Observable);
+var AnonymousSubject = function (_super) {
+  __extends(AnonymousSubject, _super);
+  function AnonymousSubject(destination, source) {
+    var _this = _super.call(this) || this;
+    _this.destination = destination;
+    _this.source = source;
+    return _this;
+  }
+  AnonymousSubject.prototype.next = function (value) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.next) === null || _b === undefined ? undefined : _b.call(_a, value);
+  };
+  AnonymousSubject.prototype.error = function (err) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.error) === null || _b === undefined ? undefined : _b.call(_a, err);
+  };
+  AnonymousSubject.prototype.complete = function () {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === undefined ? undefined : _a.complete) === null || _b === undefined ? undefined : _b.call(_a);
+  };
+  AnonymousSubject.prototype._subscribe = function (subscriber) {
+    var _a, _b;
+    return (_b = (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber)) !== null && _b !== undefined ? _b : EMPTY_SUBSCRIPTION;
+  };
+  return AnonymousSubject;
+}(Subject);
+var EmptyError = createErrorClass(function (_super) {
+  return function EmptyErrorImpl() {
+    _super(this);
+    this.name = 'EmptyError';
+    this.message = 'no elements in sequence';
+  };
+});
+function firstValueFrom(source, config) {
+  return new Promise(function (resolve, reject) {
+    var subscriber = new SafeSubscriber({
+      next: function (value) {
+        resolve(value);
+        subscriber.unsubscribe();
+      },
+      error: reject,
+      complete: function () {
+        {
+          reject(new EmptyError());
+        }
+      }
+    });
+    source.subscribe(subscriber);
+  });
+}
+function map(project, thisArg) {
+  return operate(function (source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+      subscriber.next(project.call(thisArg, value, index++));
+    }));
+  });
+}
+function filter(predicate, thisArg) {
+  return operate(function (source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+      return predicate.call(thisArg, value, index++) && subscriber.next(value);
+    }));
+  });
+}
+
+// refer to realm-network-api/src/common/enums/error-codes.enum.ts
+/*** Authentication Errors ***/
+var AuthErrorName;
+(function (AuthErrorName) {
+  AuthErrorName["UNAUTHORIZED"] = "UNAUTHORIZED";
+  AuthErrorName["INVALID_TOKEN"] = "INVALID_TOKEN";
+  AuthErrorName["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+  AuthErrorName["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
+})(AuthErrorName || (AuthErrorName = {}));
+/*** Partner Access Token Errors ***/
+var PartnerAccessTokenErrorName;
+(function (PartnerAccessTokenErrorName) {
+  PartnerAccessTokenErrorName["PARTNER_ACCESS_TOKEN_INVALID"] = "PARTNER_ACCESS_TOKEN_INVALID";
+  PartnerAccessTokenErrorName["USER_MISMATCH"] = "USER_MISMATCH";
+})(PartnerAccessTokenErrorName || (PartnerAccessTokenErrorName = {}));
+/*** Realm ID Errors ***/
+var RealmIDErrorName;
+(function (RealmIDErrorName) {
+  RealmIDErrorName["REALM_ID_NOT_FOUND"] = "REALM_ID_NOT_FOUND";
+  RealmIDErrorName["REALM_ID_INVALID_NAME"] = "REALM_ID_INVALID_NAME";
+  RealmIDErrorName["REALM_ID_ALREADY_EXISTS"] = "REALM_ID_ALREADY_EXISTS";
+  RealmIDErrorName["REALM_ID_DUPLICATE_PARTNER_USER"] = "REALM_ID_DUPLICATE_PARTNER_USER";
+})(RealmIDErrorName || (RealmIDErrorName = {}));
+/*** Parameter Errors ***/
+var ParameterErrorName;
+(function (ParameterErrorName) {
+  ParameterErrorName["INVALID_PARAMETER"] = "INVALID_PARAMETER";
+})(ParameterErrorName || (ParameterErrorName = {}));
+/*** Server Errors ***/
+var ServerErrorName;
+(function (ServerErrorName) {
+  ServerErrorName["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+})(ServerErrorName || (ServerErrorName = {}));
+/*** Passkey Errors ***/
+var PasskeyErrorName;
+(function (PasskeyErrorName) {
+  PasskeyErrorName["PASSKEY_REGISTRATION_FAILED"] = "PASSKEY_REGISTRATION_FAILED";
+  PasskeyErrorName["PASSKEY_AUTHENTICATION_FAILED"] = "PASSKEY_AUTHENTICATION_FAILED";
+  PasskeyErrorName["PASSKEY_LIMIT_EXCEEDED"] = "PASSKEY_LIMIT_EXCEEDED";
+  PasskeyErrorName["PASSKEY_NOT_FOUND"] = "PASSKEY_NOT_FOUND";
+  PasskeyErrorName["PASSKEY_UNAUTHORIZED"] = "PASSKEY_UNAUTHORIZED";
+  PasskeyErrorName["PASSKEY_CHALLENGE_INVALID"] = "PASSKEY_CHALLENGE_INVALID";
+})(PasskeyErrorName || (PasskeyErrorName = {}));
+/*** Passwordless Authentication Errors ***/
+var PasswordlessErrorName;
+(function (PasswordlessErrorName) {
+  PasswordlessErrorName["PASSWORDLESS_CODE_EXPIRED"] = "PASSWORDLESS_CODE_EXPIRED";
+  PasswordlessErrorName["PASSWORDLESS_INVALID_CODE"] = "PASSWORDLESS_INVALID_CODE";
+  PasswordlessErrorName["PASSWORDLESS_MAX_ATTEMPTS"] = "PASSWORDLESS_MAX_ATTEMPTS";
+  PasswordlessErrorName["PASSWORDLESS_HOURLY_LIMIT"] = "PASSWORDLESS_HOURLY_LIMIT";
+  PasswordlessErrorName["PASSWORDLESS_LOCK_EXCEEDED"] = "PASSWORDLESS_LOCK_EXCEEDED";
+  PasswordlessErrorName["CAPTCHA_TOKEN_VERIFICATION_FAILED"] = "CAPTCHA_TOKEN_VERIFICATION_FAILED";
+  PasswordlessErrorName["CAPTCHA_TOKEN_INVALID"] = "CAPTCHA_TOKEN_INVALID";
+  PasswordlessErrorName["CAPTCHA_SECRET_MISSING"] = "CAPTCHA_SECRET_MISSING";
+  PasswordlessErrorName["CAPTCHA_TOKEN_MISSING"] = "CAPTCHA_TOKEN_MISSING";
+})(PasswordlessErrorName || (PasswordlessErrorName = {}));
+/*** Authentication Wallet Errors ***/
+var AuthWalletErrorName;
+(function (AuthWalletErrorName) {
+  AuthWalletErrorName["AUTH_WALLET_LOCK_EXCEEDED"] = "AUTH_WALLET_LOCK_EXCEEDED";
+  AuthWalletErrorName["AUTH_WALLET_NONCE_EXPIRED_OR_INVALID"] = "AUTH_WALLET_NONCE_EXPIRED_OR_INVALID";
+  AuthWalletErrorName["AUTH_WALLET_ADDRESS_MISMATCH"] = "AUTH_WALLET_ADDRESS_MISMATCH";
+  AuthWalletErrorName["AUTH_WALLET_SIGNATURE_VERIFICATION_FAILED"] = "AUTH_WALLET_SIGNATURE_VERIFICATION_FAILED";
+})(AuthWalletErrorName || (AuthWalletErrorName = {}));
+/*** Wallet Linking Errors ***/
+var WalletLinkErrorName;
+(function (WalletLinkErrorName) {
+  WalletLinkErrorName["LINK_WALLET_ALREADY_LINKED"] = "LINK_WALLET_ALREADY_LINKED";
+  WalletLinkErrorName["LINK_WALLET_LINKED_OTHER_ACCOUNT"] = "LINK_WALLET_LINKED_OTHER_ACCOUNT";
+  WalletLinkErrorName["LINK_EMAIL_LINKED_OTHER_ACCOUNT"] = "LINK_EMAIL_LINKED_OTHER_ACCOUNT";
+})(WalletLinkErrorName || (WalletLinkErrorName = {}));
+/*** Intent Errors ***/
+var IntentErrorName;
+(function (IntentErrorName) {
+  IntentErrorName["INTENT_INVALID"] = "INTENT_INVALID";
+  IntentErrorName["INTENT_LOCK_EXCEEDED"] = "INTENT_LOCK_EXCEEDED";
+  IntentErrorName["INTENT_REQUIRED"] = "INTENT_REQUIRED";
+  IntentErrorName["INTENT_UNSUPPORTED_TYPE"] = "INTENT_UNSUPPORTED_TYPE";
+})(IntentErrorName || (IntentErrorName = {}));
+/*** Privy Errors ***/
+var PrivyErrorName;
+(function (PrivyErrorName) {
+  PrivyErrorName["WALLET_PROVIDER_ERROR"] = "WALLET_PROVIDER_ERROR";
+})(PrivyErrorName || (PrivyErrorName = {}));
+/*** Air ID Errors ***/
+var AirIDErrorName;
+(function (AirIDErrorName) {
+  AirIDErrorName["AIR_ID_MINT_TRANSACTION_NOT_FOUND"] = "AIR_ID_MINT_TRANSACTION_NOT_FOUND";
+  AirIDErrorName["AIR_ID_ON_CHAIN_TRANSACTION_NOT_FOUND"] = "AIR_ID_ON_CHAIN_TRANSACTION_NOT_FOUND";
+  AirIDErrorName["AIR_ID_NOT_FOUND"] = "AIR_ID_NOT_FOUND";
+  AirIDErrorName["AIR_ID_INVALID_OR_DISABLED_CONFIGURATION"] = "AIR_ID_INVALID_OR_DISABLED_CONFIGURATION";
+  AirIDErrorName["AIR_ID_RPC_URL_NOT_CONFIGURED"] = "AIR_ID_RPC_URL_NOT_CONFIGURED";
+  AirIDErrorName["AIR_ID_INVALID_STATUS"] = "AIR_ID_INVALID_STATUS";
+  AirIDErrorName["AIR_ID_PARTNER_ELIGIBILITY_CHECK_FAILED"] = "AIR_ID_PARTNER_ELIGIBILITY_CHECK_FAILED";
+  AirIDErrorName["AIR_ID_PARTNER_ELIGIBILITY_CHECK_TIMEOUT"] = "AIR_ID_PARTNER_ELIGIBILITY_CHECK_TIMEOUT";
+  AirIDErrorName["AIR_ID_MULTIPLE_AIR_IDS_FOUND"] = "AIR_ID_MULTIPLE_AIR_IDS_FOUND";
+  AirIDErrorName["AIR_ID_NAME_RESERVED"] = "AIR_ID_NAME_RESERVED";
+  AirIDErrorName["AIR_ID_NAME_PROFANITY"] = "AIR_ID_NAME_PROFANITY";
+  AirIDErrorName["AIR_ID_USER_ALREADY_HAS_AIR_ID"] = "AIR_ID_USER_ALREADY_HAS_AIR_ID";
+  AirIDErrorName["AIR_ID_NAME_ALREADY_EXISTS"] = "AIR_ID_NAME_ALREADY_EXISTS";
+  AirIDErrorName["AIR_ID_INVALID_MINT_NAME"] = "AIR_ID_INVALID_MINT_NAME";
+  AirIDErrorName["AIR_ID_MINT_TRANSACTION_HASH_MISMATCH"] = "AIR_ID_MINT_TRANSACTION_HASH_MISMATCH";
+})(AirIDErrorName || (AirIDErrorName = {}));
+/*** Window Errors ***/
+var WindowErrorName;
+(function (WindowErrorName) {
+  WindowErrorName["WINDOW_BLOCKED"] = "WINDOW_BLOCKED";
+  WindowErrorName["WINDOW_CLOSED"] = "WINDOW_CLOSED";
+})(WindowErrorName || (WindowErrorName = {}));
+const Codes = {
+  ...AuthErrorName,
+  ...PartnerAccessTokenErrorName,
+  ...RealmIDErrorName,
+  ...ParameterErrorName,
+  ...ServerErrorName,
+  ...PasskeyErrorName,
+  ...PasswordlessErrorName,
+  ...AuthWalletErrorName,
+  ...WalletLinkErrorName,
+  ...IntentErrorName,
+  ...PrivyErrorName,
+  ...AirIDErrorName,
+  ...WindowErrorName
+};
+const AirClientUserErrors = ["USER_CANCELLED", "CONFIG_ERROR", "CLIENT_ERROR", "UNKNOWN_ERROR", "PERMISSION_NOT_ENABLED", "SMART_ACCOUNT_NOT_DEPLOYED"];
+class AirError extends BaseError$2 {}
+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$1.debug(`[${this.name}] Message ${sentOrReceived}:`, event.data);
+    });
+    const handleMessage = async ev => {
+      if (this.targetOrigin && ev.origin !== this.targetOrigin || !ev.data || !(ev.data instanceof Object)) return;
+      if (this.isMessageAllowed(ev.data)) {
+        await this.onBeforeEvent(ev);
+        this.eventSubject.next(ev);
+      }
+    };
+    if (target instanceof MessagePort) {
+      this.messagePort = target;
+      target.onmessage = handleMessage;
+      this.closeListener = async () => {
+        target.close();
+      };
+    } else {
+      this.targetWindow = target.window;
+      this.targetOrigin = target.origin;
+      window.addEventListener("message", handleMessage);
+      this.closeListener = async () => {
+        window.removeEventListener("message", handleMessage);
+      };
+    }
+  }
+  isMessageAllowed(message) {
+    return this.allowedMessageTypes.includes(message.type);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async onBeforeEvent(_event) {
+    // by default not used
+  }
+  async close() {
+    if (this.closeListener) {
+      await this.closeListener();
+      this.closeListener = null;
+    }
+    if (this.eventSubject && !this.eventSubject.closed) {
+      this.eventSubject.complete();
+    }
+  }
+  createErrorResponseMessage(type, error) {
+    return {
+      type,
+      payload: {
+        success: false,
+        errorName: error instanceof AirError ? error.name : "UNKNOWN_ERROR",
+        errorMessage: error.message
+      }
+    };
+  }
+  async sendMessage(message, transfer) {
+    // To prevent any non-cloneable objects causing errors in postMessage
+    const clonedMessage = this.deepClone(message);
+    if (this.messagePort) {
+      this.messagePort.postMessage(clonedMessage);
+      this.eventSubject.next(new MessageEvent("message", {
+        data: clonedMessage,
+        origin: window.origin
+      }));
+    } else if (this.targetWindow && this.targetOrigin) {
+      this.targetWindow.postMessage(clonedMessage, this.targetOrigin, transfer);
+      this.eventSubject.next(new MessageEvent("message", {
+        data: clonedMessage,
+        origin: window.origin
+      }));
+    } else {
+      log$1.debug(`[${this.name}] Not opened yet`);
+    }
+  }
+  deepClone(message) {
+    try {
+      return JSON.parse(JSON.stringify(message));
+    } catch (e) {
+      log$1.warn("Error generating cloneable message", e);
+      return message;
+    }
+  }
+}
+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$1(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$1(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: undefined
+};
+var _AirWalletProvider_instances, _AirWalletProvider_providerMessageService, _AirWalletProvider_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
+class AirWalletProvider {
+  constructor({
+    isLoggedIn,
+    ensureWallet
+  }) {
+    _AirWalletProvider_instances.add(this);
+    _AirWalletProvider_providerMessageService.set(this, undefined);
+    _AirWalletProvider_isLoggedIn.set(this, undefined);
+    _AirWalletProvider_ensureWallet.set(this, undefined);
+    _AirWalletProvider_eventListeners.set(this, undefined);
+    this.startEventMessageListening = async walletIframe => {
+      await __classPrivateFieldGet$1(this, _AirWalletProvider_providerMessageService, "f").open(walletIframe);
+      __classPrivateFieldGet$1(this, _AirWalletProvider_providerMessageService, "f").messages$.pipe(filter(msg => msg.type === AirWalletProviderMessageTypes.EVENT)).subscribe(message => {
+        __classPrivateFieldGet$1(this, _AirWalletProvider_instances, "m", _AirWalletProvider_emit).call(this, message.payload.event, ...[message.payload.data]);
+      });
+    };
+    __classPrivateFieldSet(this, _AirWalletProvider_providerMessageService, ProviderMessageService.create());
+    __classPrivateFieldSet(this, _AirWalletProvider_isLoggedIn, isLoggedIn);
+    __classPrivateFieldSet(this, _AirWalletProvider_ensureWallet, ensureWallet);
+    __classPrivateFieldSet(this, _AirWalletProvider_eventListeners, {
+      connect: [],
+      disconnect: [],
+      accountsChanged: [],
+      chainChanged: [],
+      message: []
+    });
+  }
+  async request(request) {
+    // Check if the request is valid
+    if (!request || typeof request !== "object" || Array.isArray(request)) {
+      throw new InvalidRequestRpcError("Invalid request");
+    }
+    const {
+      method,
+      params
+    } = request;
+    // Check if the method is valid
+    if (typeof method !== "string" || method.length === 0) {
+      throw new MethodNotFoundRpcError("Invalid method");
+    }
+    // Check if the params are valid
+    if (params !== undefined && !Array.isArray(params) && (typeof params !== "object" || params === null)) {
+      throw new InvalidParamsRpcError("Invalid params");
+    }
+    // Check if the user is logged in
+    if (!__classPrivateFieldGet$1(this, _AirWalletProvider_isLoggedIn, "f").call(this)) {
+      throw new UnauthorizedProviderError("User is not logged in");
+    }
+    try {
+      await __classPrivateFieldGet$1(this, _AirWalletProvider_ensureWallet, "f").call(this);
+    } catch (error) {
+      throw ensureProviderRpcError(error);
+    }
+    const requestId = randomId();
+    const response = await __classPrivateFieldGet$1(this, _AirWalletProvider_providerMessageService, "f").sendWalletProviderRequest({
+      requestId,
+      ...request
+    });
+    if (!response.success) {
+      throw ensureProviderRpcError(response.payload);
+    }
+    return response.payload.response;
+  }
+  on(eventName, listener) {
+    __classPrivateFieldGet$1(this, _AirWalletProvider_eventListeners, "f")[eventName] = __classPrivateFieldGet$1(this, _AirWalletProvider_eventListeners, "f")[eventName] || [];
+    __classPrivateFieldGet$1(this, _AirWalletProvider_eventListeners, "f")[eventName].push(listener);
+  }
+  removeListener(eventName, listener) {
+    __classPrivateFieldGet$1(this, _AirWalletProvider_eventListeners, "f")[eventName] = __classPrivateFieldGet$1(this, _AirWalletProvider_eventListeners, "f")[eventName] || [];
+    const index = __classPrivateFieldGet$1(this, _AirWalletProvider_eventListeners, "f")[eventName].indexOf(listener);
+    if (index >= 0) {
+      __classPrivateFieldGet$1(this, _AirWalletProvider_eventListeners, "f")[eventName].splice(index, 1);
+    }
+  }
+  removeAllListeners() {
+    __classPrivateFieldSet(this, _AirWalletProvider_eventListeners, {
+      connect: [],
+      disconnect: [],
+      accountsChanged: [],
+      chainChanged: [],
+      message: []
+    });
+  }
+}
+_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$1(this, _AirWalletProvider_eventListeners, "f")[eventName] || []).forEach(listener => {
+    try {
+      return listener(...args);
+    } catch (error) {
+      log$1.warn(error);
+    }
+  });
+};
+class IframeController {
+  constructor(iframeUrl, iframeId, state) {
+    this._iframeElement = null;
+    this.state = {
+      ...IframeController.defaultState,
+      ...state
+    };
+    this.iframeUrl = iframeUrl;
+    this.iframeId = iframeId;
+  }
+  get iframeElement() {
+    return this._iframeElement;
+  }
+  createIframe() {
+    if (this._iframeElement) return this._iframeElement;
+    const iframe = document.createElement("iframe");
+    iframe.id = this.iframeId;
+    iframe.allow = "publickey-credentials-get *; publickey-credentials-create *";
+    iframe.src = this.iframeUrl;
+    iframe.style.position = "fixed";
+    iframe.style.zIndex = "999999";
+    iframe.style.border = "none";
+    iframe.style.margin = "0";
+    iframe.style.padding = "0";
+    iframe.style.display = "none";
+    iframe.style.colorScheme = "auto";
+    document.body.appendChild(iframe);
+    this._iframeElement = iframe;
+    return iframe;
+  }
+  setIframeVisibility(isVisible) {
+    this.state.isVisible = isVisible;
+  }
+  updateIframeState() {
+    if (!this.iframeElement) return;
+    const style = {};
+    style.display = this.state.isVisible ? "block" : "none";
+    style.width = "100%";
+    style.height = "100%";
+    style.top = "0px";
+    style.right = "0px";
+    style.left = "0px";
+    style.bottom = "0px";
+    Object.assign(this.iframeElement.style, style);
+  }
+  destroy() {
+    if (this.iframeElement) {
+      this.iframeElement.remove();
+      this._iframeElement = null;
+    }
+  }
+  postMessage(message) {
+    if (!this.iframeElement) return;
+    const {
+      origin
+    } = new URL(this.iframeElement.src);
+    this.iframeElement.contentWindow.postMessage(message, origin);
+  }
+}
+IframeController.defaultState = {
+  isVisible: false
+};
+
+/**
+ * Creates a window features string for `window.open`, based on the current screen size.
+ * It tries to center the window and limits the size to the given max width and height.
+ * Slightly reduces the size to avoid browser auto-resizing.
+ */
+const getWindowFeatures = (maxWidth, maxHeight) => {
+  const dualScreenLeft = window.screenLeft !== undefined ? window.screenLeft : window.screenX;
+  const dualScreenTop = window.screenTop !== undefined ? window.screenTop : window.screenY;
+  const w = window.innerWidth ? window.innerWidth : document.documentElement.clientWidth ? document.documentElement.clientWidth : window.screen.width;
+  const h = window.innerHeight ? window.innerHeight : document.documentElement.clientHeight ? document.documentElement.clientHeight : window.screen.height;
+  // 95% adjustment for mobile devices, some browser might resize the window
+  const finalWidth = Math.min(w, maxWidth) * 0.95;
+  const finalHeight = Math.min(h, maxHeight) * 0.95;
+  const systemZoom = 1; // No reliable estimate
+  const left = Math.abs((w - finalWidth) / 2 / systemZoom + dualScreenLeft);
+  const top = Math.abs((h - finalHeight) / 2 / systemZoom + dualScreenTop);
+  return `titlebar=0,toolbar=0,status=0,location=0,menubar=0,height=${finalHeight / systemZoom},width=${finalWidth / systemZoom},top=${top},left=${left}`;
+};
+class WindowController {
+  get messages$() {
+    return this._messages$.asObservable();
+  }
+  constructor(windowId, windowUrl) {
+    this._windowInstance = null;
+    this._messageHandler = null;
+    this._messages$ = new Subject();
+    this.windowId = windowId;
+    this.windowUrl = windowUrl;
+    this.windowOrigin = new URL(windowUrl).origin;
+    this._messageHandler = ev => {
+      if (ev.source !== this._windowInstance || ev.origin !== this.windowOrigin || !ev.data || !(ev.data instanceof Object)) {
+        return;
+      }
+      this._messages$.next(ev);
+    };
+    window.addEventListener("message", this._messageHandler);
+  }
+  get windowInstance() {
+    return this._windowInstance;
+  }
+  async openWindow(onRetry) {
+    let windowInstance = this.tryOpenWindow();
+    if (!windowInstance) {
+      await onRetry();
+      windowInstance = this.tryOpenWindow();
+      if (!windowInstance) {
+        throw new AirError(WindowErrorName.WINDOW_BLOCKED);
+      }
+    }
+    const pendingWindowOpenCheck = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        if (this.isWindowOpen(windowInstance)) {
+          // only now are we scheduling the close event check since we're sure the window is open
+          this.scheduleWindowClosedChecks(windowInstance);
+          resolve("opened");
+        } else {
+          onRetry().then(() => {
+            windowInstance = this.tryOpenWindow();
+            if (windowInstance) {
+              this._windowInstance = windowInstance;
+              windowInstance.focus();
+              this.scheduleWindowClosedChecks(windowInstance);
+              resolve("retry");
+            } else {
+              reject(new AirError(WindowErrorName.WINDOW_BLOCKED));
+            }
+          }).catch(reject);
+        }
+      }, 1000);
+    });
+    this._windowInstance = windowInstance;
+    windowInstance.focus();
+    return {
+      pendingWindowOpenCheck
+    };
+  }
+  postMessage(message, transfer) {
+    if (!this._windowInstance) return;
+    this._windowInstance.postMessage(message, this.windowOrigin, transfer);
+  }
+  onMessage(callback) {
+    const listener = ev => {
+      if (ev.source !== this._windowInstance || ev.origin !== this.windowOrigin) return;
+      callback(ev);
+    };
+    window.addEventListener("message", listener);
+    const close = () => window.removeEventListener("message", listener);
+    this.onClose(close);
+    return {
+      close
+    };
+  }
+  cleanup() {
+    if (this._windowInstance && !this._windowInstance.closed) {
+      this._windowInstance.close();
+    }
+    this._windowInstance = null;
+    if (this._messageHandler) {
+      window.removeEventListener("message", this._messageHandler);
+      this._messageHandler = null;
+    }
+    if (this._messages$ && !this._messages$.closed) {
+      this._messages$.complete();
+    }
+  }
+  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 {
+  constructor() {
+    this.windowControllers = new Map();
+  }
+  static get instance() {
+    return this._instance || (this._instance = new this());
+  }
+  async sendWindowInitializationRequest(windowId, payload, port) {
+    const windowController = this.windowControllers.get(windowId);
+    if (!windowController) {
+      throw new Error("Window controller not found");
+    }
+    const windowInstance = windowController.windowInstance;
+    if (!windowInstance) {
+      throw new Error("Window instance not found");
+    }
+    const response = firstValueFrom(windowController.messages$.pipe(filter(event => event.data.type === AirWalletMessageTypes.INITIALIZATION_RESPONSE)));
+    windowController.postMessage({
+      type: AirWalletMessageTypes.INITIALIZATION_REQUEST,
+      payload
+    }, [port]);
+    return (await response).data;
+  }
+  async openAndInitializeWalletServiceWindow({
+    url,
+    windowId,
+    partnerId,
+    enableLogging,
+    onRetry,
+    sdkVersion
+  }) {
+    if (this.windowControllers.has(windowId)) {
+      throw new Error("Window controller already exists");
+    }
+    const windowController = new WindowController(windowId, url);
+    const {
+      pendingWindowOpenCheck
+    } = await windowController.openWindow(onRetry);
+    windowController.onClose(() => {
+      this.removeWindowController(windowId);
+    });
+    this.windowControllers.set(windowId, windowController);
+    let channel = null;
+    const initializeWindow = () => {
+      return new Promise((resolve, reject) => {
+        windowController.onMessage(async ev => {
+          if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
+            try {
+              channel = new MessageChannel();
+              const {
+                payload
+              } = await this.sendWindowInitializationRequest(windowId, {
+                partnerId,
+                enableLogging,
+                sdkVersion
+              }, channel.port1);
+              if (payload.success === false) {
+                reject(new AirServiceError(payload.errorName, payload.errorMessage));
+              } else {
+                resolve();
+              }
+            } catch (e) {
+              reject(e);
+            }
+          }
+        });
+      });
+    };
+    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);
+  }
+  removeWindowController(windowId) {
+    this.windowControllers.delete(windowId);
+  }
+}
+var WindowService$1 = WindowService.instance;
+var _a$1, _AuthMessageService_instance;
+const ALLOWED_AUTH_MESSAGES = [AirAuthMessageTypes.INITIALIZATION_RESPONSE, AirAuthMessageTypes.LOGIN_RESPONSE, AirAuthMessageTypes.SETUP_WALLET_REQUEST, AirAuthMessageTypes.LOGOUT_RESPONSE, AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE, AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE, AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE, AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST];
+class AuthMessageService extends MessageServiceBase {
+  static create() {
+    if (__classPrivateFieldGet$1(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$1(this, _a$1, "f", _AuthMessageService_instance);
+  }
+  async open(authIframe) {
+    const origin = new URL(authIframe.src).origin;
+    const window = authIframe.contentWindow;
+    await super._open({
+      window,
+      origin
+    });
+  }
+  async initWalletCommunication(port) {
+    await this.sendMessage({
+      type: AirAuthMessageTypes.INIT_WALLET_COMMUNICATION
+    }, [port]);
+  }
+  async sendPartnerUserInfoRequest() {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE)));
+    await this.sendMessage({
+      type: AirAuthMessageTypes.PARTNER_USER_INFO_REQUEST,
+      payload: {
+        allowCache: false
+      }
+    });
+    return response;
+  }
+  async sendLoginRequest(payload) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirAuthMessageTypes.LOGIN_RESPONSE)));
+    await this.sendMessage({
+      type: AirAuthMessageTypes.LOGIN_REQUEST,
+      payload
+    });
+    return response;
+  }
+  async logout() {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirAuthMessageTypes.LOGOUT_RESPONSE)));
+    await this.sendMessage({
+      type: AirAuthMessageTypes.LOGOUT_REQUEST
+    });
+    return response;
+  }
+  async resetWalletCommunication() {
+    await this.sendMessage({
+      type: AirAuthMessageTypes.RESET_WALLET_COMMUNICATION
+    });
+  }
+  async sendInitializationRequest(payload) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirAuthMessageTypes.INITIALIZATION_RESPONSE)));
+    await this.sendMessage({
+      type: AirAuthMessageTypes.INITIALIZATION_REQUEST,
+      payload
+    });
+    return response;
+  }
+  async sendSetupWalletSuccessResponse() {
+    await this.sendMessage({
+      type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+      payload: {
+        success: true
+      }
+    });
+  }
+  async sendSetupWalletErrorResponse(error) {
+    await this.sendMessage(this.createErrorResponseMessage(AirAuthMessageTypes.SETUP_WALLET_RESPONSE, error));
+  }
+  async sendCrossPartnerTokenRequest(targetPartnerUrl) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE)));
+    await this.sendMessage({
+      type: AirAuthMessageTypes.CROSS_PARTNER_TOKEN_REQUEST,
+      payload: {
+        targetPartnerUrl
+      }
+    });
+    return response;
+  }
+  async sendPartnerAccessTokenRequest() {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE)));
+    await this.sendMessage({
+      type: AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_REQUEST
+    });
+    return response;
+  }
+}
+_a$1 = AuthMessageService;
+_AuthMessageService_instance = {
+  value: undefined
+};
+var _a, _WalletMessageService_instance;
+const ALLOWED_WALLET_MESSAGES = [AirWalletMessageTypes.INITIALIZATION_RESPONSE, AirWalletMessageTypes.WALLET_INITIALIZED, AirWalletMessageTypes.WALLET_LOGIN_RESPONSE, AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_RESPONSE, AirWalletMessageTypes.CLAIM_ID_RESPONSE, AirWalletMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_RESPONSE, AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE, AirWalletMessageTypes.EXECUTE_ACTION_RESPONSE, AirWalletMessageTypes.REVOKE_PERMISSIONS_RESPONSE, AirWalletMessageTypes.GRANT_PERMISSIONS_RESPONSE, AirWalletMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_RESPONSE, AirWalletMessageTypes.WALLET_INITIALIZED, AirWalletMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST, AirWalletMessageTypes.LOGOUT_RESPONSE, AirWalletMessageTypes.OPEN_WINDOW_REQUEST, AirWalletMessageTypes.OPEN_WINDOW_RETRY_RESPONSE];
+class WalletMessageService extends MessageServiceBase {
+  static create() {
+    if (__classPrivateFieldGet$1(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$1(this, _a, "f", _WalletMessageService_instance);
+  }
+  async open(walletIframe) {
+    const origin = new URL(walletIframe.src).origin;
+    const window = walletIframe.contentWindow;
+    await super._open({
+      window,
+      origin
+    });
+  }
+  async initAuthCommunication(skipWalletLogin, port) {
+    await this.sendMessage({
+      type: AirWalletMessageTypes.INIT_AUTH_COMMUNICATION,
+      payload: {
+        skipWalletLogin
+      }
+    }, [port]);
+  }
+  async sendGrantPermissionRequest(policies) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.GRANT_PERMISSIONS_REQUEST,
+      payload: {
+        policies
+      }
+    });
+    const result = await response;
+    if (result.payload.success === false) {
+      throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+    }
+    return result.payload.sessionData;
+  }
+  async sendExecuteActionRequest(params) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.EXECUTE_ACTION_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.EXECUTE_ACTION_REQUEST,
+      payload: {
+        sessionData: params.sessionData,
+        call: {
+          to: params.call.to,
+          value: params.call.value,
+          data: params.call.data
+        },
+        sessionOwnerPrivateKey: params.sessionOwnerPrivateKey
+      }
+    });
+    const result = await response;
+    if (result.payload.success === false) {
+      throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+    }
+    return result.payload.txHash;
+  }
+  async sendRevokePermissionsRequest(permissionId) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.REVOKE_PERMISSIONS_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.REVOKE_PERMISSIONS_REQUEST,
+      payload: {
+        permissionId
+      }
+    });
+    const result = await response;
+    if (result.payload.success === false) {
+      throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+    }
+    return result.payload.txHash;
+  }
+  async sendDeploySmartAccountRequest() {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_REQUEST
+    });
+    return response;
+  }
+  async sendIsSmartAccountDeployedRequest() {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_REQUEST
+    });
+    return response;
+  }
+  async logout() {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.LOGOUT_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.LOGOUT_REQUEST
+    });
+    return response;
+  }
+  async sendInitializationRequest(payload) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.INITIALIZATION_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.INITIALIZATION_REQUEST,
+      payload
+    });
+    return response;
+  }
+  async sendGrantPermissionsRequest(payload) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.GRANT_PERMISSIONS_REQUEST,
+      payload
+    });
+    return response;
+  }
+  async sendListAllSessionKeyScopesRequest() {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_REQUEST
+    });
+    return response;
+  }
+  onInitialized() {
+    return firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.WALLET_INITIALIZED)));
+  }
+  async sendLoginRequest() {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.WALLET_LOGIN_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.WALLET_LOGIN_REQUEST
+    });
+    return response;
+  }
+  async sendSetupMfaRequest() {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_REQUEST
+    });
+    return response;
+  }
+  async sendOpenWindowSuccessResponse(windowId, port) {
+    await this.sendMessage({
+      type: AirWalletMessageTypes.OPEN_WINDOW_RESPONSE,
+      payload: {
+        success: true,
+        windowId
+      }
+    }, [port]);
+  }
+  async sendOpenWindowErrorResponse(windowId, error) {
+    const errorResponse = this.createErrorResponseMessage(AirWalletMessageTypes.OPEN_WINDOW_RESPONSE, error);
+    await this.sendMessage({
+      ...errorResponse,
+      payload: {
+        ...errorResponse.payload,
+        windowId
+      }
+    });
+  }
+  async sendOpenWindowRetryRequest(windowId) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.OPEN_WINDOW_RETRY_RESPONSE), filter(msg => msg.payload.windowId === windowId)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.OPEN_WINDOW_RETRY_REQUEST,
+      payload: {
+        windowId
+      }
+    });
+    return response;
+  }
+  async sendWindowClosed(windowId) {
+    await this.sendMessage({
+      type: AirWalletMessageTypes.WINDOW_CLOSED,
+      payload: {
+        windowId
+      }
+    });
+  }
+  async sendClaimIdRequest(payload) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirWalletMessageTypes.CLAIM_ID_RESPONSE)));
+    await this.sendMessage({
+      type: AirWalletMessageTypes.CLAIM_ID_REQUEST,
+      payload
+    });
+    return response;
+  }
+}
+_a = WalletMessageService;
+_WalletMessageService_instance = {
+  value: undefined
+};
+const getLevelName = levelNum => {
+  const levelNames = Object.keys(log$1.levels);
+  if (levelNum >= 0 && levelNum < levelNames.length) {
+    return levelNames[levelNum];
+  }
+  return "UNKNOWN";
+};
+const configureLogLevel = (environment, enableLogging) => {
+  let level = log$1.levels.ERROR;
+  if (environment === "development") {
+    level = enableLogging ? log$1.levels.TRACE : log$1.levels.INFO;
+  } else if (environment === "staging") {
+    level = enableLogging ? log$1.levels.DEBUG : log$1.levels.INFO;
+  } else if (environment === "uat") {
+    level = enableLogging ? log$1.levels.INFO : log$1.levels.WARN;
+  } else if (environment === "production") {
+    // Be cautious with enabling more than WARN in prod
+    level = enableLogging ? log$1.levels.WARN : log$1.levels.ERROR;
+  }
+  log$1.setLevel(level);
+  log$1.info(`[${window?.location?.origin}] LogLevel: ${getLevelName(log$1.getLevel())}`);
+};
+var name = "@mocanetwork/airkit";
+var version$2 = "1.2.0";
+var description = "Air kit to interact with the Moca Network";
+var main = "dist/airkit.cjs.js";
+var module$1 = "dist/airkit.esm.js";
+var unpkg = "dist/airkit.umd.min.js";
+var jsdelivr = "dist/airkit.umd.min.js";
+var types = "dist/types/index.d.ts";
+var files = ["dist"];
+var scripts = {
+  build: "rollup --config",
+  prepack: "npm run build && npm run postbuild",
+  lint: "eslint --fix 'src/**/*.ts'",
+  format: "prettier --write 'src/**/*.ts'",
+  postbuild: "node scripts/copyAndAdjustDtsFiles.js '../common/src' 'common'"
+};
+var dependencies = {
+  "@mocanetwork/airkit-connector": "^1.2.0",
+  "fast-deep-equal": "^3.1.3",
+  loglevel: "^1.9.2",
+  pump: "^3.0.0",
+  "readable-stream": "^4.5.2",
+  rxjs: "^7.8.1"
+};
+var devDependencies = {
+  "@babel/runtime": "^7.25.6",
+  "@rushstack/eslint-patch": "^1.10.2",
+  "@types/pump": "^1.1.3",
+  "@types/readable-stream": "^4.0.15",
+  "fs-extra": "^11.2.0",
+  glob: "^11.0.0",
+  process: "^0.11.10",
+  "typescript-eslint": "^8.21.0"
+};
+var mocha = {
+  timeout: 0
+};
+var keywords = ["airkit", "mocaverse", "wallet", "embed", "login", "OAuth", "crypto"];
+var author = "Mocaverse";
+var license = "ISC";
+var engines = {
+  node: ">=18.x",
+  npm: ">=9.x"
+};
+var publishConfig = {
+  access: "restricted"
+};
+var airkitPackage = {
+  name: name,
+  version: version$2,
+  description: description,
+  main: main,
+  module: module$1,
+  unpkg: unpkg,
+  jsdelivr: jsdelivr,
+  types: types,
+  files: files,
+  scripts: scripts,
+  dependencies: dependencies,
+  devDependencies: devDependencies,
+  mocha: mocha,
+  keywords: keywords,
+  author: author,
+  license: license,
+  "lint-staged": {
+    "!(*d).{js,ts}": ["eslint --cache --fix", "prettier --write"],
+    "*.{json, md}": ["prettier --write"]
+  },
+  engines: engines,
+  publishConfig: publishConfig
+};
+var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authMessagingService, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletMessagingService, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_walletLoggedInResult, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_subscribeToWalletEvents, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_createWalletInitializedResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
+const airKitVersion = airkitPackage.version;
+class AirService {
+  constructor({
+    partnerId
+  }) {
+    _AirService_instances.add(this);
+    _AirService_loginResult.set(this, undefined);
+    _AirService_buildEnv.set(this, undefined);
+    _AirService_enableLogging.set(this, false);
+    _AirService_partnerId.set(this, undefined);
+    //#modalZIndex: number; TODO implement z index overwrite
+    _AirService_authMessagingService.set(this, undefined);
+    _AirService_authIframeController.set(this, undefined);
+    _AirService_isAuthInitialized.set(this, false);
+    _AirService_airAuthListener.set(this, []);
+    _AirService_walletMessagingService.set(this, undefined);
+    _AirService_walletIframeController.set(this, undefined);
+    _AirService_walletInitialization.set(this, undefined);
+    _AirService_walletLoggedInResult.set(this, undefined);
+    _AirService_airWalletProvider.set(this, undefined);
+    __classPrivateFieldSet(this, _AirService_partnerId, partnerId);
+    __classPrivateFieldSet(this, _AirService_authMessagingService, AuthMessageService.create());
+    __classPrivateFieldSet(this, _AirService_walletMessagingService, WalletMessageService.create());
+    __classPrivateFieldSet(this, _AirService_airWalletProvider, new AirWalletProvider({
+      isLoggedIn: () => this.isLoggedIn,
+      ensureWallet: __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).bind(this)
+    }));
+    // this.#modalZIndex = modalZIndex ?? 99999;
+  }
+  get buildEnv() {
+    return __classPrivateFieldGet$1(this, _AirService_buildEnv, "f");
+  }
+  get isInitialized() {
+    return __classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f");
+  }
+  get isLoggedIn() {
+    return !!__classPrivateFieldGet$1(this, _AirService_loginResult, "f");
+  }
+  get isWalletInitialized() {
+    return !!__classPrivateFieldGet$1(this, _AirService_walletLoggedInResult, "f");
+  }
+  get provider() {
+    const provider = __classPrivateFieldGet$1(this, _AirService_airWalletProvider, "f");
+    return {
+      request: provider.request.bind(provider),
+      on: provider.on.bind(provider),
+      removeListener: provider.removeListener.bind(provider)
+    };
+  }
+  async init({
+    buildEnv = BUILD_ENV.PRODUCTION,
+    enableLogging = false,
+    skipRehydration = false
+  }) {
+    if (!__classPrivateFieldGet$1(this, _AirService_partnerId, "f")) throw new Error("Partner ID is required to initialize auth service");
+    if (__classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f")) return;
+    __classPrivateFieldSet(this, _AirService_buildEnv, buildEnv);
+    __classPrivateFieldSet(this, _AirService_enableLogging, enableLogging);
+    const {
+      authUrl
+    } = AIR_URLS[buildEnv];
+    configureLogLevel(buildEnv, enableLogging);
+    const authIframeOrigin = new URL(authUrl).origin;
+    __classPrivateFieldSet(this, _AirService_authIframeController, new IframeController(authUrl, `air-auth-${randomId()}`));
+    try {
+      __classPrivateFieldGet$1(this, _AirService_authIframeController, "f").createIframe();
+      await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").open(__classPrivateFieldGet$1(this, _AirService_authIframeController, "f").iframeElement);
+      __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").messages$.subscribe(async msg => {
+        switch (msg.type) {
+          case AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST:
+            {
+              const authIframeController = __classPrivateFieldGet$1(this, _AirService_authIframeController, "f");
+              authIframeController.setIframeVisibility(msg.payload.visible);
+              authIframeController.updateIframeState();
+              break;
+            }
+          case AirAuthMessageTypes.SETUP_WALLET_REQUEST:
+            {
+              try {
+                await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, {
+                  skipWalletLogin: true
+                });
+                await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").sendSetupWalletSuccessResponse();
+              } catch (err) {
+                const error = ensureError(err);
+                await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").sendSetupWalletErrorResponse(error);
+              }
+              break;
+            }
+        }
+      });
+      const result = await new Promise((resolve, reject) => {
+        const handleAuthMessage = async ev => {
+          if (ev.origin !== authIframeOrigin) return;
+          if (ev.data === AirAuthMessageTypes.AUTH_SETUP_COMPLETED) {
+            window.removeEventListener("message", handleAuthMessage);
+            const {
+              payload
+            } = await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").sendInitializationRequest({
+              partnerId: __classPrivateFieldGet$1(this, _AirService_partnerId, "f"),
+              skipRehydration,
+              partnerDAppUrl: window.location.href,
+              sdkVersion: airKitVersion,
+              enableLogging: __classPrivateFieldGet$1(this, _AirService_enableLogging, "f")
+            });
+            if (payload.success === true) {
+              resolve(payload);
+            } else {
+              reject(new AirServiceError(payload.errorName, payload.errorMessage));
+            }
+          }
+        };
+        window.addEventListener("message", handleAuthMessage);
+      });
+      __classPrivateFieldSet(this, _AirService_isAuthInitialized, true, "f");
+      __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_triggerAirAuthInitialized).call(this, {
+        rehydrated: result.rehydrated
+      });
+      // rehydrated auth session
+      if (result.rehydrated) {
+        __classPrivateFieldSet(this, _AirService_loginResult, __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_createLoginResult).call(this, result), "f");
+        __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedIn).call(this);
+        return __classPrivateFieldGet$1(this, _AirService_loginResult, "f");
+      }
+    } catch (error) {
+      log$1.debug("Error initializing auth service", error);
+      await this.cleanUp();
+      throw error;
+    }
+    return null;
+  }
+  async login(options) {
+    if (!__classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f")) throw new Error("Service is not initialized");
+    if (__classPrivateFieldGet$1(this, _AirService_loginResult, "f")) return __classPrivateFieldGet$1(this, _AirService_loginResult, "f");
+    const {
+      payload
+    } = await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").sendLoginRequest({
+      partnerLoginToken: options?.authToken
+    });
+    if (payload.success === true) {
+      __classPrivateFieldSet(this, _AirService_loginResult, __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_createLoginResult).call(this, payload));
+      __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedIn).call(this);
+      return __classPrivateFieldGet$1(this, _AirService_loginResult, "f");
+    }
+    throw new AirServiceError(payload.errorName, payload.errorMessage);
+  }
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
+  async deploySmartAccount() {
+    if (!__classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f")) throw new Error("Service is not initialized");
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+    try {
+      log$1.info("deploySmartAccount");
+      const {
+        payload
+      } = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendDeploySmartAccountRequest();
+      if (payload.success === false) {
+        throw new AirServiceError(payload.errorName, payload.errorMessage);
+      }
+      return {
+        txHash: payload.txHash
+      };
+    } catch (error) {
+      throw AirServiceError.from(error);
+    }
+  }
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
+  async grantPermission(policies) {
+    if (!__classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f")) throw new Error("AirAuth is not initialized");
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+    try {
+      log$1.info("grantPermission", policies);
+      const {
+        payload
+      } = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendGrantPermissionsRequest({
+        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() {
+    if (!__classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f")) throw new Error("Service is not initialized");
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+    try {
+      const {
+        payload
+      } = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendListAllSessionKeyScopesRequest();
+      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$1(this, _AirService_isAuthInitialized, "f")) throw new Error("Service is not initialized");
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+    try {
+      log$1.info("executeAction", params);
+      const txHash = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendExecuteActionRequest(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$1(this, _AirService_isAuthInitialized, "f")) throw new Error("Service is not initialized");
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+    try {
+      log$1.info("revokePermission", permissionId);
+      const txHash = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendRevokePermissionsRequest(permissionId);
+      return txHash;
+    } catch (error) {
+      throw AirServiceError.from(error);
+    }
+  }
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
+  async isSmartAccountDeployed() {
+    if (!__classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f")) throw new Error("Service is not initialized");
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+    try {
+      const {
+        payload
+      } = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendIsSmartAccountDeployedRequest();
+      if (payload.success === false) {
+        throw new AirServiceError(payload.errorName, payload.errorMessage);
+      }
+      return payload.isDeployed;
+    } catch (error) {
+      throw AirServiceError.from(error);
+    }
+  }
+  getProvider() {
+    return this.provider;
+  }
+  async preloadWallet() {
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, {
+      skipWalletLogin: true
+    });
+  }
+  async setupOrUpdateMfa() {
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, {
+      skipWalletLogin: true
+    });
+    const result = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendSetupMfaRequest();
+    if (result.payload.success === false) {
+      throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+    }
+    __classPrivateFieldSet(this, _AirService_loginResult, {
+      ...__classPrivateFieldGet$1(this, _AirService_loginResult, "f"),
+      isMFASetup: true
+    });
+  }
+  async claimAirId(options) {
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+    const result = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendClaimIdRequest(options ?? {});
+    if (result.payload.success === true) {
+      return {
+        airId: result.payload.airId
+      };
+    }
+    throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+  }
+  async getUserInfo() {
+    if (!this.isLoggedIn) throw new Error("User not logged in");
+    const info = await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").sendPartnerUserInfoRequest();
+    if (info.payload.success === false) {
+      throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
+    }
+    return {
+      partnerId: info.payload.partnerId,
+      partnerUserId: info.payload.partnerUserId,
+      airId: info.payload.airId,
+      user: {
+        id: info.payload.user.id,
+        abstractAccountAddress: info.payload.user.abstractAccountAddress,
+        email: info.payload.user.email,
+        isMFASetup: info.payload.user.isMFASetup
+      }
+    };
+  }
+  async goToPartner(partnerUrl) {
+    if (!__classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f")) throw new Error("Service is not initialized");
+    if (!this.isLoggedIn) throw new Error("No active session to generate token");
+    const result = await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").sendCrossPartnerTokenRequest(partnerUrl);
+    if (result.payload.success === false) {
+      throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+    }
+    return {
+      urlWithToken: result.payload.urlWithToken
+    };
+  }
+  async getAccessToken() {
+    if (!__classPrivateFieldGet$1(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$1(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$1(this, _AirService_isAuthInitialized, "f")) throw new Error("Service is not initialized");
+    if (!this.isLoggedIn) throw new Error("No active session to logout");
+    // Clear up wallet
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+    await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").logout();
+    __classPrivateFieldSet(this, _AirService_loginResult, undefined);
+    __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedOut).call(this);
+  }
+  async cleanUp() {
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_cleanUpAuth).call(this);
+    this.clearEventListeners();
+  }
+  on(listener) {
+    if (__classPrivateFieldGet$1(this, _AirService_airAuthListener, "f").indexOf(listener) < 0) __classPrivateFieldGet$1(this, _AirService_airAuthListener, "f").push(listener);
+  }
+  off(listener) {
+    if (__classPrivateFieldGet$1(this, _AirService_airAuthListener, "f").indexOf(listener) >= 0) __classPrivateFieldGet$1(this, _AirService_airAuthListener, "f").splice(__classPrivateFieldGet$1(this, _AirService_airAuthListener, "f").indexOf(listener), 1);
+  }
+  clearEventListeners() {
+    __classPrivateFieldSet(this, _AirService_airAuthListener, []);
+  }
+}
+_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) throw new Error("User not logged in");
+  if (!__classPrivateFieldGet$1(this, _AirService_walletInitialization, "f")) __classPrivateFieldSet(this, _AirService_walletInitialization, __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_initializeWallet).call(this, option));
+  if (__classPrivateFieldGet$1(this, _AirService_walletLoggedInResult, "f")) return __classPrivateFieldGet$1(this, _AirService_walletLoggedInResult, "f");
+  try {
+    const result = await __classPrivateFieldGet$1(this, _AirService_walletInitialization, "f");
+    if (option?.skipWalletLogin || result.isWalletLoggedIn) {
+      return __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, result);
+    }
+  } catch (error) {
+    __classPrivateFieldSet(this, _AirService_walletInitialization, null);
+    log$1.error("Error initializing wallet", error);
+    throw error;
+  }
+  if (__classPrivateFieldGet$1(this, _AirService_walletLoggedInResult, "f")) return __classPrivateFieldGet$1(this, _AirService_walletLoggedInResult, "f");
+  const walletLoginResult = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendLoginRequest();
+  if (walletLoginResult.payload.success !== true) {
+    throw new AirServiceError(walletLoginResult.payload.errorName, walletLoginResult.payload.errorMessage);
+  }
+  return __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, walletLoginResult.payload);
+}, _AirService_initializeWallet = async function _AirService_initializeWallet(option) {
+  if (__classPrivateFieldGet$1(this, _AirService_walletInitialization, "f")) throw new Error("Already initializing");
+  const {
+    walletUrl
+  } = AIR_URLS[__classPrivateFieldGet$1(this, _AirService_buildEnv, "f")];
+  log$1.info(walletUrl, "url loaded");
+  const walletIframeOrigin = new URL(walletUrl).origin;
+  try {
+    const walletInitRequestPromise = new Promise((resolve, reject) => {
+      const handleWalletMessage = async ev => {
+        if (ev.origin !== walletIframeOrigin) return;
+        if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
+          window.removeEventListener("message", handleWalletMessage);
+          const {
+            payload
+          } = await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendInitializationRequest({
+            partnerId: __classPrivateFieldGet$1(this, _AirService_partnerId, "f"),
+            enableLogging: __classPrivateFieldGet$1(this, _AirService_enableLogging, "f"),
+            sdkVersion: airKitVersion
+          });
+          if (payload.success === true) {
+            resolve();
+          } else {
+            reject(new AirServiceError(payload.errorName, payload.errorMessage));
+          }
+        }
+      };
+      window.addEventListener("message", handleWalletMessage);
+    });
+    __classPrivateFieldSet(this, _AirService_walletIframeController, new IframeController(walletUrl, `air-wallet-${randomId()}`), "f");
+    __classPrivateFieldGet$1(this, _AirService_walletIframeController, "f").createIframe();
+    await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").open(__classPrivateFieldGet$1(this, _AirService_walletIframeController, "f").iframeElement);
+    __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_subscribeToWalletEvents).call(this);
+    await __classPrivateFieldGet$1(this, _AirService_airWalletProvider, "f").startEventMessageListening(__classPrivateFieldGet$1(this, _AirService_walletIframeController, "f").iframeElement);
+    const walletInitPromise = __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").onInitialized();
+    await walletInitRequestPromise;
+    const channel = new MessageChannel();
+    await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").initWalletCommunication(channel.port1);
+    await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").initAuthCommunication(option?.skipWalletLogin ?? false, channel.port2);
+    const walletInitResult = await walletInitPromise;
+    if (walletInitResult.payload.success !== true) {
+      throw new AirServiceError(walletInitResult.payload.errorName, walletInitResult.payload.errorMessage);
+    }
+    if (!__classPrivateFieldGet$1(this, _AirService_walletLoggedInResult, "f") && walletInitResult.payload.isWalletLoggedIn) {
+      __classPrivateFieldSet(this, _AirService_walletLoggedInResult, __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, walletInitResult.payload), "f");
+      __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_triggerWalletInitialized).call(this, __classPrivateFieldGet$1(this, _AirService_walletLoggedInResult, "f"));
+    }
+    return walletInitResult.payload;
+  } catch (error) {
+    log$1.error("Error initializing wallet", error);
+    await __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+    throw error;
+  }
+}, _AirService_subscribeToWalletEvents = function _AirService_subscribeToWalletEvents() {
+  __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").messages$.subscribe(async msg => {
+    switch (msg.type) {
+      case AirWalletMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST:
+        {
+          const walletIframeController = __classPrivateFieldGet$1(this, _AirService_walletIframeController, "f");
+          walletIframeController.setIframeVisibility(msg.payload.visible);
+          walletIframeController.updateIframeState();
+          break;
+        }
+      case AirWalletMessageTypes.WALLET_LOGIN_RESPONSE:
+        {
+          if (msg.payload.success === true && !__classPrivateFieldGet$1(this, _AirService_walletLoggedInResult, "f")) {
+            __classPrivateFieldSet(this, _AirService_walletLoggedInResult, __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, msg.payload));
+            __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_triggerWalletInitialized).call(this, __classPrivateFieldGet$1(this, _AirService_walletLoggedInResult, "f"));
+          }
+          break;
+        }
+      case AirWalletMessageTypes.OPEN_WINDOW_REQUEST:
+        {
+          try {
+            const onRetry = async () => {
+              const {
+                payload
+              } = await __classPrivateFieldGet$1(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$1(this, _AirService_partnerId, "f"),
+              enableLogging: __classPrivateFieldGet$1(this, _AirService_enableLogging, "f"),
+              sdkVersion: airKitVersion,
+              onRetry
+            });
+            windowController.onClose(async () => await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendWindowClosed(msg.payload.windowId));
+            await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendOpenWindowSuccessResponse(msg.payload.windowId, port);
+          } catch (err) {
+            const error = ensureError(err);
+            await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").sendOpenWindowErrorResponse(msg.payload.windowId, error);
+          }
+          break;
+        }
+    }
+  });
+}, _AirService_triggerEventListeners = function _AirService_triggerEventListeners(data) {
+  __classPrivateFieldGet$1(this, _AirService_airAuthListener, "f").forEach(listener => {
+    listener(data);
+  });
+}, _AirService_triggerAirAuthInitialized = function _AirService_triggerAirAuthInitialized(result) {
+  __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, {
+    event: "initialized",
+    result
+  });
+}, _AirService_triggerAirAuthLoggedIn = function _AirService_triggerAirAuthLoggedIn() {
+  __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, {
+    event: "logged_in",
+    result: __classPrivateFieldGet$1(this, _AirService_loginResult, "f")
+  });
+}, _AirService_triggerAirAuthLoggedOut = function _AirService_triggerAirAuthLoggedOut() {
+  __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, {
+    event: "logged_out"
+  });
+}, _AirService_triggerWalletInitialized = function _AirService_triggerWalletInitialized(result) {
+  __classPrivateFieldGet$1(this, _AirService_instances, "m", _AirService_triggerEventListeners).call(this, {
+    event: "wallet_initialized",
+    result
+  });
+}, _AirService_createLoginResult = function _AirService_createLoginResult(payload) {
+  return {
+    isLoggedIn: true,
+    id: payload.id,
+    abstractAccountAddress: payload.abstractAccountAddress,
+    token: payload.partnerAccessToken,
+    isMFASetup: payload.isMFASetup
+  };
+}, _AirService_createWalletInitializedResult = function _AirService_createWalletInitializedResult(payload) {
+  if ("isWalletLoggedIn" in payload && !payload.isWalletLoggedIn) {
+    return {
+      abstractAccountAddress: null,
+      isMFASetup: __classPrivateFieldGet$1(this, _AirService_loginResult, "f")?.isMFASetup ?? false
+    };
+  }
+  return {
+    abstractAccountAddress: payload.addresses.aa,
+    isMFASetup: payload.isMFASetup
+  };
+}, _AirService_cleanUpAuth = async function _AirService_cleanUpAuth() {
+  // Logout auth session
+  await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").logout();
+  // Destroy the auth iframe
+  const authIframeElement = __classPrivateFieldGet$1(this, _AirService_authIframeController, "f")?.iframeElement;
+  if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
+    __classPrivateFieldGet$1(this, _AirService_authIframeController, "f").destroy();
+    __classPrivateFieldSet(this, _AirService_authIframeController, undefined);
+  }
+  // Close the message service
+  await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").close();
+  __classPrivateFieldSet(this, _AirService_isAuthInitialized, false);
+}, _AirService_cleanUpWallet = async function _AirService_cleanUpWallet() {
+  if (!__classPrivateFieldGet$1(this, _AirService_isAuthInitialized, "f")) return;
+  // Logout wallet and destroy the wallet iframe
+  const walletIframeElement = __classPrivateFieldGet$1(this, _AirService_walletIframeController, "f")?.iframeElement;
+  if (isElement(walletIframeElement) && window.document.body.contains(walletIframeElement)) {
+    await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").logout();
+    __classPrivateFieldGet$1(this, _AirService_walletIframeController, "f").destroy();
+    __classPrivateFieldSet(this, _AirService_walletIframeController, undefined);
+  }
+  const authIframeElement = __classPrivateFieldGet$1(this, _AirService_authIframeController, "f")?.iframeElement;
+  if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
+    await __classPrivateFieldGet$1(this, _AirService_authMessagingService, "f").resetWalletCommunication();
+  }
+  // Close the message service
+  await __classPrivateFieldGet$1(this, _AirService_walletMessagingService, "f").close();
+  __classPrivateFieldSet(this, _AirService_walletLoggedInResult, undefined);
+  __classPrivateFieldSet(this, _AirService_walletInitialization, undefined);
+};
 
 const version$1 = '2.26.5';
 
@@ -1405,7 +4361,7 @@ const DEFAULT_CHAIN = {
 };
 function airConnector(parameters) {
     let providerInitialPromise = null;
-    const service = new airkit.AirService({ partnerId: parameters.partnerId });
+    const service = new AirService({ partnerId: parameters.partnerId });
     let loginResult = null;
     return createConnector((config) => ({
         id: MOCA_NETWORK_CONNECTOR_ID,
@@ -1418,13 +4374,13 @@ function airConnector(parameters) {
         async connect({ chainId } = {}) {
             try {
                 config.emitter.emit("message", { type: "connecting" });
-                loginResult = await service.login({
-                    authToken: parameters.loginOptions?.authToken,
-                });
                 const provider = await this.getProvider();
                 provider.on("accountsChanged", (payload) => this.onAccountsChanged(payload));
                 provider.on("chainChanged", this.onChainChanged);
                 provider.on("disconnect", this.onDisconnect.bind(this));
+                loginResult = await service.login({
+                    authToken: parameters.loginOptions?.authToken,
+                });
                 let currentChainId = await this.getChainId();
                 if (chainId && currentChainId !== chainId) {
                     const chain = await this.switchChain({ chainId }).catch((error) => {