@mocanetwork/airkit 1.3.0 → 1.4.0-beta.0

package/dist/airkit.cjs.js

@@ -97,13 +97,19 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+var version = "1.4.0-beta.0";
+var airkitPackage = {
+	version: version};
+
 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",
+  LOGIN_SERVICE_RESPONSE: "air_auth_login_service_response",
+  PASSKEY_LOGIN_REQUEST: "air_auth_passkey_login_request",
+  PASSKEY_LOGIN_RESPONSE: "air_auth_passkey_login_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",
@@ -116,17 +122,38 @@ const AirAuthMessageTypes = {
   IFRAME_VISIBILITY_REQUEST: "air_auth_iframe_visibility_request",
   SETUP_WALLET_REQUEST: "air_auth_setup_wallet_request",
   SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_response",
+  SETUP_RECOVERY_REQUEST: "air_auth_setup_recovery_request",
+  SETUP_RECOVERY_RESPONSE: "air_auth_setup_recovery_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",
+  PRIVY_LOGIN_REQUEST: "air_auth_privy_login_request",
+  PRIVY_LOGIN_RESPONSE: "air_auth_privy_login_response",
   CREDENTIAL_SALT_REQUEST: "air_auth_credential_salt_request",
   CREDENTIAL_SALT_RESPONSE: "air_auth_credential_salt_response",
   LOGOUT_REQUEST: "air_auth_logout_request",
   LOGOUT_RESPONSE: "air_auth_logout_response",
-  RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication"
+  RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication",
+  INIT_RECOVERY_COMMUNICATION: "air_auth_init_recovery_communication",
+  RESET_RECOVERY_COMMUNICATION: "air_auth_reset_recovery_communication",
+  START_RECOVERY_REQUEST: "air_start_recovery_request",
+  START_RECOVERY_RESPONSE: "air_start_recovery_response",
+  OTP_REQUEST: "air_auth_otp_request",
+  OTP_RESPONSE: "air_auth_otp_response"
+};
+
+const AirRecoveryMessageTypes = {
+  SERVICE_STARTED: "air_recovery_service_started",
+  INITIALIZATION_REQUEST: "air_recovery_initialization_request",
+  INITIALIZATION_RESPONSE: "air_recovery_initialization_response",
+  INIT_AUTH_COMMUNICATION: "air_recovery_init_auth_communication",
+  RECOVERY_INITIALIZED: "air_recovery_initialized",
+  RECOVERY_IFRAME_VISIBILITY_REQUEST: "air_recovery_iframe_visibility_request",
+  LOGOUT_REQUEST: "air_recovery_logout_request",
+  LOGOUT_RESPONSE: "air_recovery_logout_response"
 };
 
 const AirWalletMessageTypes = {
@@ -141,234 +168,25 @@ const AirWalletMessageTypes = {
   SETUP_OR_UPDATE_MFA_RESPONSE: "air_setup_mfa_response",
   CLAIM_ID_REQUEST: "air_claim_id_request",
   CLAIM_ID_RESPONSE: "air_claim_id_response",
+  SHOW_SWAP_UI_REQUEST: "air_show_swap_ui_request",
+  SHOW_SWAP_UI_RESPONSE: "air_show_swap_ui_response",
   DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
   DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_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"
 };
 
-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:8200/auth/",
-        walletUrl: "http://localhost:8200/wallet/",
-    },
-    [BUILD_ENV.UAT]: {
-        authUrl: "https://account.uat.air3.com/auth/",
-        walletUrl: "https://account.uat.air3.com/wallet/",
-    },
-    [BUILD_ENV.STAGING]: {
-        authUrl: "https://account.staging.air3.com/auth/",
-        walletUrl: "https://account.staging.air3.com/wallet/",
-    },
-    [BUILD_ENV.PRODUCTION]: {
-        authUrl: "https://account.air3.com/auth/",
-        walletUrl: "https://account.air3.com/wallet/",
-    },
-};
-const isElement = (element) => element instanceof Element || element instanceof Document;
-const randomId = () => Math.random().toString(36).slice(2);
-const extractErrorHash = (message) => {
-    if (!message)
-        return "";
-    // Format: "reason: 0x..."
-    if (message.includes("reason:")) {
-        return message.split("reason:")[1].trim();
-    }
-    // Format: "UserOperation reverted during simulation with reason: 0x..."
-    if (message.includes("with reason:")) {
-        const match = message.match(/with reason: (0x[a-fA-F0-9]+)/);
-        return match ? match[1].trim() : "";
-    }
-    // Look for any 0x pattern that could be a hash
-    const hexMatch = message.match(/(0x[a-fA-F0-9]{8,})/);
-    return hexMatch ? hexMatch[1].trim() : "";
+const AirWindowMessageTypes = {
+  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"
 };
 
-class AirServiceError extends BaseError {
-    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");
-    }
-}
-class ProviderRpcError extends Error {
-    constructor(message) {
-        super(message);
-        this.metaMessages = [];
-    }
-}
-class UserRejectedRequestError extends ProviderRpcError {
-    constructor() {
-        super(...arguments);
-        this.code = 4001;
-        this.name = "UserRejectedRequestError";
-    }
-}
-class UnauthorizedProviderError extends ProviderRpcError {
-    constructor() {
-        super(...arguments);
-        this.code = 4100;
-        this.name = "UnauthorizedProviderError";
-    }
-}
-class UnsupportedProviderMethodError extends ProviderRpcError {
-    constructor() {
-        super(...arguments);
-        this.code = 4200;
-        this.name = "UnsupportedProviderMethodError";
-    }
-}
-class ProviderDisconnectedError extends ProviderRpcError {
-    constructor() {
-        super(...arguments);
-        this.code = 4900;
-        this.name = "ProviderDisconnectedError";
-    }
-}
-class ChainDisconnectedError extends ProviderRpcError {
-    constructor() {
-        super(...arguments);
-        this.code = 4901;
-        this.name = "ChainDisconnectedError";
-    }
-}
-class SwitchChainError extends ProviderRpcError {
-    constructor() {
-        super(...arguments);
-        this.code = 4902;
-        this.name = "SwitchChainError";
-    }
-}
-class TransactionRejectedRpcError extends ProviderRpcError {
-    constructor(message) {
-        // Remove the "Version: viem@x.x.x" suffix if present
-        const cleanMessage = message.replace(/\nVersion:.*$/, '');
-        super(cleanMessage);
-        this.code = -32003;
-        this.name = "TransactionRejectedRpcError";
-        // Parse the error hash from the message
-        this.metaMessages.push(extractErrorHash(cleanMessage));
-    }
-}
-class InvalidRequestRpcError extends ProviderRpcError {
-    constructor() {
-        super(...arguments);
-        this.code = -32600;
-        this.name = "InvalidRequestRpcError";
-    }
-}
-class MethodNotFoundRpcError extends ProviderRpcError {
-    constructor() {
-        super(...arguments);
-        this.code = -32601;
-        this.name = "MethodNotFoundRpcError";
-    }
-}
-class InvalidParamsRpcError extends ProviderRpcError {
-    constructor() {
-        super(...arguments);
-        this.code = -32602;
-        this.name = "InvalidParamsRpcError";
-    }
-}
-class InternalRpcError extends ProviderRpcError {
-    constructor() {
-        super(...arguments);
-        this.code = -32603;
-        this.name = "InternalRpcError";
-    }
-}
-function ensureProviderRpcError(value) {
-    if (value instanceof ProviderRpcError) {
-        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(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(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 (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -700,11 +518,259 @@ function requireLoglevel() {
 var loglevelExports = requireLoglevel();
 var log = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
 
-function isFunction(value) {
-  return typeof value === 'function';
+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}`);
 }
 
-function createErrorClass(createImpl) {
+const getLevelName = levelNum => {
+  const levelNames = Object.keys(log.levels);
+  if (levelNum >= 0 && levelNum < levelNames.length) {
+    return levelNames[levelNum];
+  }
+  return "UNKNOWN";
+};
+const configureLogLevel = (environment, enableLogging) => {
+  let level = log.levels.ERROR;
+  if (environment === "development") {
+    level = enableLogging ? log.levels.TRACE : log.levels.INFO;
+  } else if (environment === "staging") {
+    level = enableLogging ? log.levels.DEBUG : log.levels.INFO;
+  } else if (environment === "uat") {
+    level = enableLogging ? log.levels.INFO : log.levels.WARN;
+  } else if (environment === "production") {
+    // Be cautious with enabling more than WARN in prod
+    level = enableLogging ? log.levels.WARN : log.levels.ERROR;
+  }
+  log.setLevel(level);
+  log.info(`[${window?.location?.href}] LogLevel: ${getLevelName(log.getLevel())}`);
+};
+
+const BUILD_ENV = {
+    PRODUCTION: "production",
+    UAT: "uat",
+    STAGING: "staging",
+    DEVELOPMENT: "development",
+    SANDBOX: "sandbox",
+};
+
+const AIR_URLS = {
+    [BUILD_ENV.DEVELOPMENT]: {
+        authUrl: "http://localhost:8200/auth/",
+        walletUrl: "http://localhost:8200/wallet/",
+        recoveryUrl: "http://localhost:8200/recovery/",
+    },
+    [BUILD_ENV.STAGING]: {
+        authUrl: "https://account.staging.air3.com/auth/",
+        walletUrl: "https://account.staging.air3.com/wallet/",
+        recoveryUrl: "https://account.staging.air3.com/recovery/",
+    },
+    [BUILD_ENV.UAT]: {
+        authUrl: "https://account.uat.air3.com/auth/",
+        walletUrl: "https://account.uat.air3.com/wallet/",
+        recoveryUrl: "https://account.uat.air3.com/recovery/",
+    },
+    [BUILD_ENV.SANDBOX]: {
+        authUrl: "https://account.sandbox.air3.com/auth/",
+        walletUrl: "https://account.sandbox.air3.com/wallet/",
+        recoveryUrl: "https://account.sandbox.air3.com/recovery/",
+    },
+    [BUILD_ENV.PRODUCTION]: {
+        authUrl: "https://account.air3.com/auth/",
+        walletUrl: "https://account.air3.com/wallet/",
+        recoveryUrl: "https://account.air3.com/recovery/",
+    },
+};
+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:")) {
+        const match = message.match(/reason:\s*(0x[a-fA-F0-9]+)/);
+        return match ? match[1].trim() : "";
+    }
+    // Format: "UserOperation reverted during simulation with reason: 0x..."
+    if (message.includes("with reason:")) {
+        const match = message.match(/with reason:\s*(0x[a-fA-F0-9]+)/);
+        return match ? match[1].trim() : "";
+    }
+    // Look for any 0x pattern that could be a hash
+    const hexMatch = message.match(/(0x[a-fA-F0-9]{8,})/);
+    return hexMatch ? hexMatch[1].trim() : "";
+};
+
+class AirServiceError extends BaseError {
+    static from(error) {
+        if (error instanceof AirServiceError) {
+            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");
+    }
+}
+class ProviderRpcError extends Error {
+    constructor(message) {
+        super(message);
+        this.metaMessages = [];
+    }
+}
+class UserRejectedRequestError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = 4001;
+        this.name = "UserRejectedRequestError";
+    }
+}
+class UnauthorizedProviderError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = 4100;
+        this.name = "UnauthorizedProviderError";
+    }
+}
+class UnsupportedProviderMethodError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = 4200;
+        this.name = "UnsupportedProviderMethodError";
+    }
+}
+class ProviderDisconnectedError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = 4900;
+        this.name = "ProviderDisconnectedError";
+    }
+}
+class ChainDisconnectedError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = 4901;
+        this.name = "ChainDisconnectedError";
+    }
+}
+class SwitchChainError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = 4902;
+        this.name = "SwitchChainError";
+    }
+}
+class TransactionRejectedRpcError extends ProviderRpcError {
+    constructor(message) {
+        // Remove the "Version: viem@x.x.x" suffix if present
+        const cleanMessage = message.replace(/\nVersion:.*$/, '');
+        super(cleanMessage);
+        this.code = -32003;
+        this.name = "TransactionRejectedRpcError";
+        // Parse the error hash from the message
+        this.metaMessages.push(extractErrorHash(cleanMessage));
+    }
+}
+class InvalidRequestRpcError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = -32600;
+        this.name = "InvalidRequestRpcError";
+    }
+}
+class MethodNotFoundRpcError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = -32601;
+        this.name = "MethodNotFoundRpcError";
+    }
+}
+class InvalidParamsRpcError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = -32602;
+        this.name = "InvalidParamsRpcError";
+    }
+}
+class InternalRpcError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = -32603;
+        this.name = "InternalRpcError";
+    }
+}
+function ensureProviderRpcError(value) {
+    if (value instanceof ProviderRpcError) {
+        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(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(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 isFunction(value) {
+  return typeof value === 'function';
+}
+
+function createErrorClass(createImpl) {
   var _super = function (instance) {
     Error.call(instance);
     instance.stack = new Error().stack;
@@ -1728,12 +1794,13 @@ class ProviderMessageService extends MessageServiceBase {
 _a$2 = ProviderMessageService;
 _ProviderMessageService_instance = { value: void 0 };
 
-var _AirWalletProvider_instances, _AirWalletProvider_providerMessageService, _AirWalletProvider_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
+var _AirWalletProvider_instances, _AirWalletProvider_providerMessageService, _AirWalletProvider_isWalletInitialized, _AirWalletProvider_getLoginResult, _AirWalletProvider_ensureWallet, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
 class AirWalletProvider {
-    constructor({ isLoggedIn, ensureWallet, }) {
+    constructor({ ensureWallet, isWalletInitialized, getLoginResult, }) {
         _AirWalletProvider_instances.add(this);
         _AirWalletProvider_providerMessageService.set(this, void 0);
-        _AirWalletProvider_isLoggedIn.set(this, void 0);
+        _AirWalletProvider_isWalletInitialized.set(this, void 0);
+        _AirWalletProvider_getLoginResult.set(this, void 0);
         _AirWalletProvider_ensureWallet.set(this, void 0);
         _AirWalletProvider_eventListeners.set(this, void 0);
         this.startEventMessageListening = async (walletIframe) => {
@@ -1745,7 +1812,6 @@ class AirWalletProvider {
             });
         };
         __classPrivateFieldSet(this, _AirWalletProvider_providerMessageService, ProviderMessageService.create(), "f");
-        __classPrivateFieldSet(this, _AirWalletProvider_isLoggedIn, isLoggedIn, "f");
         __classPrivateFieldSet(this, _AirWalletProvider_ensureWallet, ensureWallet, "f");
         __classPrivateFieldSet(this, _AirWalletProvider_eventListeners, {
             connect: [],
@@ -1754,6 +1820,8 @@ class AirWalletProvider {
             chainChanged: [],
             message: [],
         }, "f");
+        __classPrivateFieldSet(this, _AirWalletProvider_isWalletInitialized, isWalletInitialized, "f");
+        __classPrivateFieldSet(this, _AirWalletProvider_getLoginResult, getLoginResult, "f");
     }
     async request(request) {
         // Check if the request is valid
@@ -1771,11 +1839,16 @@ class AirWalletProvider {
             (typeof params !== "object" || params === null)) {
             throw new InvalidParamsRpcError("Invalid params");
         }
-        // Check if the user is logged in
-        if (!__classPrivateFieldGet(this, _AirWalletProvider_isLoggedIn, "f").call(this)) {
+        const loginResult = __classPrivateFieldGet(this, _AirWalletProvider_getLoginResult, "f").call(this);
+        if (!loginResult) {
             throw new UnauthorizedProviderError("User is not logged in");
         }
-        const skipWalletLoginMethods = ['eth_chainId'];
+        if (method === "eth_accounts" &&
+            !__classPrivateFieldGet(this, _AirWalletProvider_isWalletInitialized, "f").call(this) &&
+            loginResult?.abstractAccountAddress) {
+            return [loginResult.abstractAccountAddress];
+        }
+        const skipWalletLoginMethods = ["eth_chainId"];
         try {
             if (skipWalletLoginMethods.includes(method)) {
                 await __classPrivateFieldGet(this, _AirWalletProvider_ensureWallet, "f").call(this, { skipWalletLogin: true });
@@ -1818,7 +1891,7 @@ class AirWalletProvider {
         }, "f");
     }
 }
-_AirWalletProvider_providerMessageService = new WeakMap(), _AirWalletProvider_isLoggedIn = new WeakMap(), _AirWalletProvider_ensureWallet = new WeakMap(), _AirWalletProvider_eventListeners = new WeakMap(), _AirWalletProvider_instances = new WeakSet(), _AirWalletProvider_emit = function _AirWalletProvider_emit(eventName, ...args) {
+_AirWalletProvider_providerMessageService = new WeakMap(), _AirWalletProvider_isWalletInitialized = new WeakMap(), _AirWalletProvider_getLoginResult = new WeakMap(), _AirWalletProvider_ensureWallet = new WeakMap(), _AirWalletProvider_eventListeners = new WeakMap(), _AirWalletProvider_instances = new WeakSet(), _AirWalletProvider_emit = function _AirWalletProvider_emit(eventName, ...args) {
     (__classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName] || []).forEach((listener) => {
         try {
             return listener(...args);
@@ -1829,287 +1902,33 @@ _AirWalletProvider_providerMessageService = new WeakMap(), _AirWalletProvider_is
     });
 };
 
-class IframeController {
-    constructor(iframeUrl, iframeId, state) {
-        this._iframeElement = null;
-        this.state = {
-            ...IframeController.defaultState,
-            ...state,
-        };
-        this.iframeUrl = iframeUrl;
-        this.iframeId = iframeId;
+var _a$1, _AuthMessageService_instance;
+const ALLOWED_AUTH_MESSAGES = [
+    AirAuthMessageTypes.INITIALIZATION_RESPONSE,
+    AirAuthMessageTypes.LOGIN_RESPONSE,
+    AirAuthMessageTypes.SETUP_WALLET_REQUEST,
+    AirAuthMessageTypes.SETUP_RECOVERY_REQUEST,
+    AirAuthMessageTypes.INIT_RECOVERY_COMMUNICATION,
+    AirAuthMessageTypes.RESET_RECOVERY_COMMUNICATION,
+    AirAuthMessageTypes.LOGOUT_RESPONSE,
+    AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
+    AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE,
+    AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE,
+    AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
+    AirAuthMessageTypes.CREDENTIAL_SALT_RESPONSE,
+    AirAuthMessageTypes.START_RECOVERY_RESPONSE,
+];
+class AuthMessageService extends MessageServiceBase {
+    static create() {
+        if (__classPrivateFieldGet(this, _a$1, "f", _AuthMessageService_instance))
+            throw new Error("AuthMessageService already created");
+        __classPrivateFieldSet(this, _a$1, new _a$1("Embed Service: Auth Channel", ALLOWED_AUTH_MESSAGES), "f", _AuthMessageService_instance);
+        return __classPrivateFieldGet(this, _a$1, "f", _AuthMessageService_instance);
     }
-    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,
-};
-
-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, enableAutomation, }) {
-        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,
-                                enableAutomation,
-                            }, 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,
-    AirAuthMessageTypes.CREDENTIAL_SALT_RESPONSE,
-];
-class AuthMessageService extends MessageServiceBase {
-    static create() {
-        if (__classPrivateFieldGet(this, _a$1, "f", _AuthMessageService_instance))
-            throw new Error("AuthMessageService already created");
-        __classPrivateFieldSet(this, _a$1, new _a$1("Embed Service: Auth Channel", ALLOWED_AUTH_MESSAGES), "f", _AuthMessageService_instance);
-        return __classPrivateFieldGet(this, _a$1, "f", _AuthMessageService_instance);
-    }
-    async open(authIframe) {
-        const origin = new URL(authIframe.src).origin;
-        const window = authIframe.contentWindow;
-        await super._open({ window, origin });
+    async open(authIframe) {
+        const origin = new URL(authIframe.src).origin;
+        const window = authIframe.contentWindow;
+        await super._open({ window, origin });
     }
     async initWalletCommunication() {
         await this.sendMessage({
@@ -2153,6 +1972,32 @@ class AuthMessageService extends MessageServiceBase {
     async sendSetupWalletErrorResponse(error) {
         await this.sendMessage(this.createErrorResponseMessage(AirAuthMessageTypes.SETUP_WALLET_RESPONSE, error));
     }
+    async initRecoveryCommunication() {
+        await this.sendMessage({
+            type: AirAuthMessageTypes.INIT_RECOVERY_COMMUNICATION,
+        });
+    }
+    async resetRecoveryCommunication() {
+        await this.sendMessage({
+            type: AirAuthMessageTypes.RESET_RECOVERY_COMMUNICATION,
+        });
+    }
+    async sendSetupRecoverySuccessResponse() {
+        await this.sendMessage({
+            type: AirAuthMessageTypes.SETUP_RECOVERY_RESPONSE,
+            payload: { success: true },
+        });
+    }
+    async sendSetupRecoveryErrorResponse(error) {
+        await this.sendMessage({
+            type: AirAuthMessageTypes.SETUP_RECOVERY_RESPONSE,
+            payload: {
+                success: false,
+                errorName: error instanceof AirError ? error.name : "UNKNOWN_ERROR",
+                errorMessage: error.message,
+            },
+        });
+    }
     async sendCrossPartnerTokenRequest(targetPartnerUrl) {
         const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE)));
         await this.sendMessage({
@@ -2168,6 +2013,11 @@ class AuthMessageService extends MessageServiceBase {
         await this.sendMessage({ type: AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_REQUEST });
         return response;
     }
+    async sendAccountRecoveryRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.START_RECOVERY_RESPONSE)));
+        await this.sendMessage({ type: AirAuthMessageTypes.START_RECOVERY_REQUEST, payload });
+        return response;
+    }
     async sendCredentialSaltRequest() {
         const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.CREDENTIAL_SALT_RESPONSE)));
         await this.sendMessage({ type: AirAuthMessageTypes.CREDENTIAL_SALT_REQUEST });
@@ -2177,20 +2027,124 @@ class AuthMessageService extends MessageServiceBase {
 _a$1 = AuthMessageService;
 _AuthMessageService_instance = { value: void 0 };
 
+class IframeController {
+    constructor(iframeUrl, iframeId, state) {
+        this._iframeElement = null;
+        this.AUTH_IFRAME_Z_INDEX = "9999999";
+        this.DEFAULT_IFRAME_Z_INDEX = "999999";
+        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 = this.iframeUrl.includes("auth") ? this.AUTH_IFRAME_Z_INDEX : this.DEFAULT_IFRAME_Z_INDEX;
+        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,
+};
+
+const ALLOWED_RECOVERY_MESSAGES = Object.values(AirRecoveryMessageTypes);
+class RecoveryMessageService extends MessageServiceBase {
+    static create() {
+        if (!RecoveryMessageService._instance) {
+            RecoveryMessageService._instance = new RecoveryMessageService("Recovery Service", ALLOWED_RECOVERY_MESSAGES);
+        }
+        return RecoveryMessageService._instance;
+    }
+    async sendInitializationRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirRecoveryMessageTypes.INITIALIZATION_RESPONSE)));
+        await this.sendMessage({
+            type: AirRecoveryMessageTypes.INITIALIZATION_REQUEST,
+            payload,
+        });
+        return response;
+    }
+    async initAuthCommunication() {
+        await this.sendMessage({
+            type: AirRecoveryMessageTypes.INIT_AUTH_COMMUNICATION,
+        });
+    }
+    async onInitialized() {
+        return firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirRecoveryMessageTypes.RECOVERY_INITIALIZED)));
+    }
+    async logout() {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirRecoveryMessageTypes.LOGOUT_RESPONSE)));
+        await this.sendMessage({ type: AirRecoveryMessageTypes.LOGOUT_REQUEST });
+        return response;
+    }
+    async open(element) {
+        await this._open({ window: element.contentWindow, origin: new URL(element.src).origin });
+    }
+    async close() {
+        await super.close();
+    }
+}
+
 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.SHOW_SWAP_UI_RESPONSE,
     AirWalletMessageTypes.CLAIM_ID_RESPONSE,
     AirWalletMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_RESPONSE,
     AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE,
     AirWalletMessageTypes.WALLET_INITIALIZED,
     AirWalletMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST,
     AirWalletMessageTypes.LOGOUT_RESPONSE,
-    AirWalletMessageTypes.OPEN_WINDOW_REQUEST,
-    AirWalletMessageTypes.OPEN_WINDOW_RETRY_RESPONSE,
+    AirWindowMessageTypes.OPEN_WINDOW_REQUEST,
+    AirWindowMessageTypes.OPEN_WINDOW_RETRY_RESPONSE,
 ];
 class WalletMessageService extends MessageServiceBase {
     static create() {
@@ -2231,97 +2185,271 @@ class WalletMessageService extends MessageServiceBase {
         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 sendInitializationRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.INITIALIZATION_RESPONSE)));
+        await this.sendMessage({ type: AirWalletMessageTypes.INITIALIZATION_REQUEST, payload });
+        return response;
+    }
+    onInitialized() {
+        return firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.WALLET_INITIALIZED)));
+    }
+    async sendLoginRequest() {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.WALLET_LOGIN_RESPONSE)));
+        await this.sendMessage({
+            type: AirWalletMessageTypes.WALLET_LOGIN_REQUEST,
+        });
+        return response;
+    }
+    async sendSetupMfaRequest() {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_RESPONSE)));
+        await this.sendMessage({
+            type: AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_REQUEST,
+        });
+        return response;
+    }
+    async sendOpenWindowSuccessResponse(windowId, port) {
+        await this.sendMessage({
+            type: AirWindowMessageTypes.OPEN_WINDOW_RESPONSE,
+            payload: {
+                success: true,
+                windowId,
+            },
+        }, [port]);
+    }
+    async sendOpenWindowErrorResponse(windowId, error) {
+        const errorResponse = this.createErrorResponseMessage(AirWindowMessageTypes.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 === AirWindowMessageTypes.OPEN_WINDOW_RETRY_RESPONSE), filter((msg) => msg.payload.windowId === windowId)));
+        await this.sendMessage({
+            type: AirWindowMessageTypes.OPEN_WINDOW_RETRY_REQUEST,
+            payload: { windowId },
+        });
+        return response;
+    }
+    async sendWindowClosed(windowId) {
+        await this.sendMessage({
+            type: AirWindowMessageTypes.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;
+    }
+    async sendShowSwapUIRequest() {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.SHOW_SWAP_UI_RESPONSE)));
+        await this.sendMessage({
+            type: AirWalletMessageTypes.SHOW_SWAP_UI_REQUEST,
+        });
+        return response;
+    }
+}
+_a = WalletMessageService;
+_WalletMessageService_instance = { value: void 0 };
+
+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;
     }
-    onInitialized() {
-        return firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.WALLET_INITIALIZED)));
+    if (this._messages$ && !this._messages$.closed) {
+      this._messages$.complete();
     }
-    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;
+  }
+  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;
     }
-    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;
+    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();
     }
-    async sendOpenWindowSuccessResponse(windowId, port) {
-        await this.sendMessage({
-            type: AirWalletMessageTypes.OPEN_WINDOW_RESPONSE,
-            payload: {
-                success: true,
-                windowId,
-            },
-        }, [port]);
+    static get instance() {
+        return this._instance || (this._instance = new this());
     }
-    async sendOpenWindowErrorResponse(windowId, error) {
-        const errorResponse = this.createErrorResponseMessage(AirWalletMessageTypes.OPEN_WINDOW_RESPONSE, error);
-        await this.sendMessage({
-            ...errorResponse,
-            payload: { ...errorResponse.payload, windowId },
-        });
+    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 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 },
+    async openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, onRetry, sdkVersion, enableAutomation, }) {
+        if (this.windowControllers.has(windowId)) {
+            throw new Error("Window controller already exists");
+        }
+        const windowController = new WindowController(windowId, url);
+        const { pendingWindowOpenCheck } = await windowController.openWindow(onRetry);
+        windowController.onClose(() => {
+            this.removeWindowController(windowId);
         });
-        return response;
+        this.windowControllers.set(windowId, windowController);
+        let channel = null;
+        const initializeWindow = () => {
+            return new Promise((resolve, reject) => {
+                windowController.onMessage(async (ev) => {
+                    if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
+                        try {
+                            channel = new MessageChannel();
+                            const { payload } = await this.sendWindowInitializationRequest(windowId, {
+                                partnerId,
+                                enableLogging,
+                                sdkVersion,
+                                enableAutomation,
+                            }, channel.port1);
+                            if (payload.success === false) {
+                                reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                            }
+                            else {
+                                resolve();
+                            }
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    }
+                });
+            });
+        };
+        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 };
     }
-    async sendWindowClosed(windowId) {
-        await this.sendMessage({
-            type: AirWalletMessageTypes.WINDOW_CLOSED,
-            payload: {
-                windowId,
-            },
-        });
+    getWindowController(windowId) {
+        return this.windowControllers.get(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;
+    removeWindowController(windowId) {
+        this.windowControllers.delete(windowId);
     }
 }
-_a = WalletMessageService;
-_WalletMessageService_instance = { value: void 0 };
-
-const getLevelName = levelNum => {
-  const levelNames = Object.keys(log.levels);
-  if (levelNum >= 0 && levelNum < levelNames.length) {
-    return levelNames[levelNum];
-  }
-  return "UNKNOWN";
-};
-const configureLogLevel = (environment, enableLogging) => {
-  let level = log.levels.ERROR;
-  if (environment === "development") {
-    level = enableLogging ? log.levels.TRACE : log.levels.INFO;
-  } else if (environment === "staging") {
-    level = enableLogging ? log.levels.DEBUG : log.levels.INFO;
-  } else if (environment === "uat") {
-    level = enableLogging ? log.levels.INFO : log.levels.WARN;
-  } else if (environment === "production") {
-    // Be cautious with enabling more than WARN in prod
-    level = enableLogging ? log.levels.WARN : log.levels.ERROR;
-  }
-  log.setLevel(level);
-  log.info(`[${window?.location?.href}] LogLevel: ${getLevelName(log.getLevel())}`);
-};
-
-var version = "1.3.0";
-var airkitPackage = {
-	version: version};
+var WindowService$1 = WindowService.instance;
 
-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;
+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_recoveryInitialization, _AirService_recoveryMessagingService, _AirService_recoveryIframeController, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_subscribeToWalletEvents, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_createWalletInitializedResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet, _AirService_ensureRecovery, _AirService_initializeRecovery, _AirService_subscribeToRecoveryEvents, _AirService_cleanUpRecovery;
 const airKitVersion = airkitPackage.version;
 class AirService {
     constructor({ partnerId }) {
@@ -2340,12 +2468,17 @@ class AirService {
         _AirService_walletInitialization.set(this, void 0);
         _AirService_walletLoggedInResult.set(this, void 0);
         _AirService_airWalletProvider.set(this, void 0);
+        _AirService_recoveryInitialization.set(this, void 0);
+        _AirService_recoveryMessagingService.set(this, void 0);
+        _AirService_recoveryIframeController.set(this, void 0);
         __classPrivateFieldSet(this, _AirService_partnerId, partnerId, "f");
         __classPrivateFieldSet(this, _AirService_authMessagingService, AuthMessageService.create(), "f");
         __classPrivateFieldSet(this, _AirService_walletMessagingService, WalletMessageService.create(), "f");
+        __classPrivateFieldSet(this, _AirService_recoveryMessagingService, RecoveryMessageService.create(), "f");
         __classPrivateFieldSet(this, _AirService_airWalletProvider, new AirWalletProvider({
-            isLoggedIn: () => this.isLoggedIn,
+            isWalletInitialized: () => this.isWalletInitialized,
             ensureWallet: __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).bind(this),
+            getLoginResult: () => __classPrivateFieldGet(this, _AirService_loginResult, "f"),
         }), "f");
         // this.#modalZIndex = modalZIndex ?? 99999;
     }
@@ -2358,6 +2491,9 @@ class AirService {
     get isLoggedIn() {
         return !!__classPrivateFieldGet(this, _AirService_loginResult, "f");
     }
+    get loginResult() {
+        return __classPrivateFieldGet(this, _AirService_loginResult, "f");
+    }
     get isWalletInitialized() {
         return !!__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f");
     }
@@ -2406,6 +2542,17 @@ class AirService {
                         }
                         break;
                     }
+                    case AirAuthMessageTypes.SETUP_RECOVERY_REQUEST: {
+                        try {
+                            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureRecovery).call(this);
+                            await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendSetupRecoverySuccessResponse();
+                        }
+                        catch (err) {
+                            const error = ensureError(err);
+                            await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendSetupRecoveryErrorResponse(error);
+                        }
+                        break;
+                    }
                 }
             });
             const result = await new Promise((resolve, reject) => {
@@ -2541,6 +2688,14 @@ class AirService {
         }
         throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
     }
+    async showSwapUI() {
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+        const result = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendShowSwapUIRequest();
+        if (result.payload.success === false) {
+            throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+        }
+        return { txHash: result.payload.txHash };
+    }
     async getUserInfo() {
         if (!this.isLoggedIn)
             throw new Error("User not logged in");
@@ -2573,6 +2728,17 @@ class AirService {
             urlWithToken: result.payload.urlWithToken,
         };
     }
+    async startRecovery(payload) {
+        try {
+            const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendAccountRecoveryRequest(payload);
+            if (result.payload.success === false) {
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+            }
+        }
+        catch (error) {
+            throw AirServiceError.from(error);
+        }
+    }
     async getAccessToken() {
         if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
             throw new Error("Service is not initialized");
@@ -2601,6 +2767,7 @@ class AirService {
     async cleanUp() {
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpAuth).call(this);
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpRecovery).call(this);
         this.clearEventListeners();
     }
     on(listener) {
@@ -2615,7 +2782,7 @@ class AirService {
         __classPrivateFieldSet(this, _AirService_airAuthListener, [], "f");
     }
 }
-_AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_authMessagingService = new WeakMap(), _AirService_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airAuthListener = new WeakMap(), _AirService_walletMessagingService = new WeakMap(), _AirService_walletIframeController = new WeakMap(), _AirService_walletInitialization = new WeakMap(), _AirService_walletLoggedInResult = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet(option) {
+_AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_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_recoveryInitialization = new WeakMap(), _AirService_recoveryMessagingService = new WeakMap(), _AirService_recoveryIframeController = 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)
@@ -2711,7 +2878,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
                 }
                 break;
             }
-            case AirWalletMessageTypes.OPEN_WINDOW_REQUEST: {
+            case AirWindowMessageTypes.OPEN_WINDOW_REQUEST: {
                 try {
                     const onRetry = async () => {
                         const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendOpenWindowRetryRequest(msg.payload.windowId);
@@ -2806,6 +2973,95 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").close();
     __classPrivateFieldSet(this, _AirService_walletLoggedInResult, undefined, "f");
     __classPrivateFieldSet(this, _AirService_walletInitialization, undefined, "f");
+}, _AirService_ensureRecovery = async function _AirService_ensureRecovery() {
+    if (!this.isInitialized)
+        throw new Error("Service not initialized");
+    if (!__classPrivateFieldGet(this, _AirService_recoveryInitialization, "f")) {
+        __classPrivateFieldSet(this, _AirService_recoveryInitialization, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_initializeRecovery).call(this), "f");
+    }
+    try {
+        await __classPrivateFieldGet(this, _AirService_recoveryInitialization, "f");
+    }
+    catch (error) {
+        __classPrivateFieldSet(this, _AirService_recoveryInitialization, null, "f");
+        log.error("Error initializing recovery", error);
+        throw error;
+    }
+}, _AirService_initializeRecovery = async function _AirService_initializeRecovery() {
+    if (__classPrivateFieldGet(this, _AirService_recoveryInitialization, "f"))
+        throw new Error("Already initializing");
+    const { recoveryUrl } = AIR_URLS[__classPrivateFieldGet(this, _AirService_buildEnv, "f")];
+    const recoveryIframeOrigin = new URL(recoveryUrl).origin;
+    try {
+        const recoveryInitRequestPromise = new Promise((resolve, reject) => {
+            const handleRecoveryMessage = async (ev) => {
+                if (ev.origin !== recoveryIframeOrigin)
+                    return;
+                if (ev.data === AirRecoveryMessageTypes.SERVICE_STARTED) {
+                    window.removeEventListener("message", handleRecoveryMessage);
+                    const { payload } = await __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").sendInitializationRequest({
+                        partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
+                        enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
+                        sdkVersion: airKitVersion,
+                        enableAutomation: this.shouldEnableAutomation(),
+                    });
+                    if (payload.success === true) {
+                        resolve();
+                    }
+                    else {
+                        reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                    }
+                }
+            };
+            window.addEventListener("message", handleRecoveryMessage);
+        });
+        __classPrivateFieldSet(this, _AirService_recoveryIframeController, new IframeController(recoveryUrl, `air-recovery-${randomId()}`), "f");
+        __classPrivateFieldGet(this, _AirService_recoveryIframeController, "f").createIframe();
+        log.info(recoveryUrl, "url loaded");
+        await __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").open(__classPrivateFieldGet(this, _AirService_recoveryIframeController, "f").iframeElement);
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_subscribeToRecoveryEvents).call(this);
+        const recoveryInitPromise = __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").onInitialized();
+        await recoveryInitRequestPromise;
+        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").initRecoveryCommunication();
+        await __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").initAuthCommunication();
+        const recoveryInitResult = await recoveryInitPromise;
+        if (recoveryInitResult.payload.success !== true) {
+            throw new AirServiceError(recoveryInitResult.payload.errorName, recoveryInitResult.payload.errorMessage);
+        }
+    }
+    catch (error) {
+        log.error("Error initializing recovery", error);
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpRecovery).call(this);
+        throw error;
+    }
+}, _AirService_subscribeToRecoveryEvents = function _AirService_subscribeToRecoveryEvents() {
+    __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").messages$.subscribe(async (message) => {
+        switch (message.type) {
+            case AirRecoveryMessageTypes.RECOVERY_IFRAME_VISIBILITY_REQUEST: {
+                const recoveryIframeController = __classPrivateFieldGet(this, _AirService_recoveryIframeController, "f");
+                recoveryIframeController.setIframeVisibility(message.payload.visible);
+                recoveryIframeController.updateIframeState();
+                break;
+            }
+        }
+    });
+}, _AirService_cleanUpRecovery = async function _AirService_cleanUpRecovery() {
+    if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+        return;
+    // Logout recovery and destroy the recovery iframe
+    const recoveryIframeElement = __classPrivateFieldGet(this, _AirService_recoveryIframeController, "f")?.iframeElement;
+    if (isElement(recoveryIframeElement) && window.document.body.contains(recoveryIframeElement)) {
+        await __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").logout();
+        __classPrivateFieldGet(this, _AirService_recoveryIframeController, "f").destroy();
+        __classPrivateFieldSet(this, _AirService_recoveryIframeController, undefined, "f");
+    }
+    const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
+    if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
+        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").resetRecoveryCommunication();
+    }
+    // Close the message service
+    await __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").close();
+    __classPrivateFieldSet(this, _AirService_recoveryInitialization, undefined, "f");
 };
 
 exports.AirService = AirService;