@mocanetwork/airkit 1.3.0 → 1.4.0-beta.1

package/dist/airkit.umd.js

@@ -101,13 +101,19 @@
       return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
+    var version = "1.4.0-beta.1";
+    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",
@@ -120,17 +126,38 @@
       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 = {
@@ -145,234 +172,25 @@
       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;
     }
@@ -704,11 +522,259 @@
     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;
@@ -1732,12 +1798,13 @@
     _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) => {
@@ -1749,7 +1816,6 @@
                 });
             };
             __classPrivateFieldSet(this, _AirWalletProvider_providerMessageService, ProviderMessageService.create(), "f");
-            __classPrivateFieldSet(this, _AirWalletProvider_isLoggedIn, isLoggedIn, "f");
             __classPrivateFieldSet(this, _AirWalletProvider_ensureWallet, ensureWallet, "f");
             __classPrivateFieldSet(this, _AirWalletProvider_eventListeners, {
                 connect: [],
@@ -1758,6 +1824,8 @@
                 chainChanged: [],
                 message: [],
             }, "f");
+            __classPrivateFieldSet(this, _AirWalletProvider_isWalletInitialized, isWalletInitialized, "f");
+            __classPrivateFieldSet(this, _AirWalletProvider_getLoginResult, getLoginResult, "f");
         }
         async request(request) {
             // Check if the request is valid
@@ -1775,11 +1843,16 @@
                 (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 });
@@ -1822,7 +1895,7 @@
             }, "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);
@@ -1833,287 +1906,33 @@
         });
     };
 
-    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({
@@ -2157,6 +1976,32 @@
         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({
@@ -2172,6 +2017,11 @@
             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 });
@@ -2181,20 +2031,124 @@
     _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() {
@@ -2235,97 +2189,271 @@
             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 }) {
@@ -2344,12 +2472,17 @@
             _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;
         }
@@ -2362,6 +2495,9 @@
         get isLoggedIn() {
             return !!__classPrivateFieldGet(this, _AirService_loginResult, "f");
         }
+        get loginResult() {
+            return __classPrivateFieldGet(this, _AirService_loginResult, "f");
+        }
         get isWalletInitialized() {
             return !!__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f");
         }
@@ -2410,6 +2546,17 @@
                             }
                             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) => {
@@ -2545,6 +2692,14 @@
             }
             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");
@@ -2577,6 +2732,17 @@
                 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");
@@ -2605,6 +2771,7 @@
         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) {
@@ -2619,7 +2786,7 @@
             __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)
@@ -2715,7 +2882,7 @@
                     }
                     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);
@@ -2810,6 +2977,95 @@
         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;