@mocanetwork/airkit 1.6.0-beta.5 → 1.7.0

package/dist/airkit.cjs.js

@@ -97,7 +97,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var version = "1.6.0-beta.5";
+var version = "1.7.0";
 var airkitPackage = {
 	version: version};
 
@@ -107,7 +107,11 @@ const AirAuthMessageTypes = {
   INITIALIZATION_RESPONSE: "air_auth_initialization_response",
   LOGIN_REQUEST: "air_auth_login_request",
   LOGIN_RESPONSE: "air_auth_login_response",
+  LOGIN_SERVICE_STATUS_REQUEST: "air_auth_login_service_status_request",
+  LOGIN_SERVICE_STATUS_RESPONSE: "air_auth_login_service_status_response",
   LOGIN_SERVICE_RESPONSE: "air_auth_login_service_response",
+  UPDATE_SESSION_CONFIG_REQUEST: "air_auth_update_session_config_request",
+  UPDATE_SESSION_CONFIG_RESPONSE: "air_auth_update_session_config_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,7 +120,6 @@ const AirAuthMessageTypes = {
   REFRESH_TOKEN_RESPONSE: "air_auth_refresh_token_response",
   WALLET_TOKEN_REQUEST: "air_auth_wallet_token_request",
   WALLET_TOKEN_RESPONSE: "air_auth_wallet_token_response",
-  INIT_WALLET_COMMUNICATION: "air_auth_init_wallet_communication",
   IFRAME_VISIBILITY_REQUEST: "air_auth_iframe_visibility_request",
   SETUP_WALLET_REQUEST: "air_auth_setup_wallet_request",
   SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_response",
@@ -130,15 +133,10 @@ const AirAuthMessageTypes = {
   PARTNER_ACCESS_TOKEN_RESPONSE: "air_auth_partner_access_token_response",
   LOGOUT_REQUEST: "air_auth_logout_request",
   LOGOUT_RESPONSE: "air_auth_logout_response",
-  RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication",
-  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",
   RECOVERY_REQUEST: "air_auth_recovery_request",
   RECOVERY_RESPONSE: "air_auth_recovery_response",
-  INIT_CREDENTIAL_COMMUNICATION: "air_auth_init_credential_communication",
-  RESET_CREDENTIAL_COMMUNICATION: "air_auth_reset_credential_communication",
   EXPIRED_LOGOUT_REQUEST: "air_auth_expired_logout_request"
 };
 
@@ -146,11 +144,9 @@ const AirCredentialMessageTypes = {
   SERVICE_STARTED: "air_credential_service_started",
   INITIALIZATION_REQUEST: "air_credential_initialization_request",
   INITIALIZATION_RESPONSE: "air_credential_initialization_response",
-  INIT_AUTH_COMMUNICATION: "air_credential_init_auth_communication",
-  CREDENTIAL_AUTH_INITIALIZED: "air_credential_auth_initialized",
-  INIT_WALLET_COMMUNICATION: "air_credential_init_wallet_communication",
-  CREDENTIAL_WALLET_INITIALIZED: "air_credential_wallet_initialized",
   CREDENTIAL_IFRAME_VISIBILITY_REQUEST: "air_credential_iframe_visibility_request",
+  UPDATE_SESSION_CONFIG_REQUEST: "air_credential_update_session_config_request",
+  UPDATE_SESSION_CONFIG_RESPONSE: "air_credential_update_session_config_response",
   LOGOUT_REQUEST: "air_credential_logout_request",
   LOGOUT_RESPONSE: "air_credential_logout_response",
   // New credential operation message types
@@ -165,9 +161,10 @@ 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",
+  UPDATE_SESSION_CONFIG_REQUEST: "air_recovery_update_session_config_request",
+  UPDATE_SESSION_CONFIG_RESPONSE: "air_recovery_update_session_config_response",
   LOGOUT_REQUEST: "air_recovery_logout_request",
   LOGOUT_RESPONSE: "air_recovery_logout_response"
 };
@@ -178,8 +175,9 @@ const AirWalletMessageTypes = {
   INITIALIZATION_RESPONSE: "air_initialization_response",
   CLOSE_MODAL_REQUEST: "air_close_modal_request",
   CLOSE_MODAL_RESPONSE: "air_close_modal_response",
-  INIT_AUTH_COMMUNICATION: "air_init_auth_communication",
   WALLET_INITIALIZED: "air_wallet_initialized",
+  UPDATE_SESSION_CONFIG_REQUEST: "air_wallet_update_session_config_request",
+  UPDATE_SESSION_CONFIG_RESPONSE: "air_wallet_update_session_config_response",
   WALLET_LOGIN_REQUEST: "air_wallet_login_request",
   WALLET_LOGIN_RESPONSE: "air_wallet_login_response",
   SETUP_OR_UPDATE_MFA_REQUEST: "air_setup_mfa_request",
@@ -197,8 +195,6 @@ const AirWalletMessageTypes = {
   IS_SMART_ACCOUNT_DEPLOYED_RESPONSE: "air_is_smart_account_deployed_response",
   LOGOUT_REQUEST: "air_logout_request",
   LOGOUT_RESPONSE: "air_logout_response",
-  INIT_CREDENTIAL_COMMUNICATION: "air_init_credential_communication",
-  RESET_CREDENTIAL_COMMUNICATION: "air_reset_credential_communication",
   INTERNAL_PROVIDER_REQUEST: "air_internal_provider_request",
   INTERNAL_PROVIDER_RESPONSE: "air_internal_provider_response"
 };
@@ -597,6 +593,61 @@ const configureLogLevel = (environment, enableLogging) => {
   log.info(`[${window?.location?.href}] LogLevel: ${getLevelName(log.getLevel())}`);
 };
 
+const mocaDevnet = {
+  id: 5151,
+  name: "Moca Devnet",
+  nativeCurrency: {
+    decimals: 18,
+    name: "Moca Network",
+    symbol: "MOCA"
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://devnet-rpc.mocachain.org"],
+      webSocket: ["wss://devnet-rpc.mocachain.org"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Moca Devnet",
+      url: "https://devnet-scan.mocachain.org"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 3837540
+    }
+  }
+};
+const mocaTestnet = {
+  id: 222888,
+  name: "Moca Testnet",
+  nativeCurrency: {
+    decimals: 18,
+    name: "Moca Network",
+    symbol: "MOCA"
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://testnet-rpc.mocachain.org"],
+      webSocket: ["wss://testnet-rpc.mocachain.org"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Moca Testnet",
+      url: "https://testnet-scan.mocachain.org"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 1330259
+    }
+  }
+};
+
 const BUILD_ENV = {
     PRODUCTION: "production",
     UAT: "uat",
@@ -611,12 +662,13 @@ const IFRAME_NAME_PREFIX_SET = [
     "air-recovery",
 ]; // order defines the z-index from highest to lowest
 
+const FONT_CDNS = ["https://fonts.googleapis.com", "https://fonts.gstatic.com"];
 const AIR_URLS = {
     [BUILD_ENV.DEVELOPMENT]: {
-        authUrl: "http://localhost:8200/auth/",
-        walletUrl: "http://localhost:8200/wallet/",
-        recoveryUrl: "http://localhost:8200/recovery/",
-        credentialUrl: "http://localhost:8200/credential/",
+        authUrl: "https://localhost:8200/auth/",
+        walletUrl: "https://localhost:8200/wallet/",
+        recoveryUrl: "https://localhost:8200/recovery/",
+        credentialUrl: "https://localhost:8200/credential/",
     },
     [BUILD_ENV.STAGING]: {
         authUrl: "https://account.staging.air3.com/auth/",
@@ -643,6 +695,47 @@ const AIR_URLS = {
         credentialUrl: "https://account.air3.com/credential/",
     },
 };
+/**
+ * Injects dns-prefetch, preconnect, and prefetch link tags
+ * for a given resource or page URL.
+ *
+ * @param url - Full resource URL (e.g. "https://cdn.example.com/app.js")
+ * @param options - Optional configuration
+ *   prefetch?: boolean — disable if you only want connection warm-up
+ *   as?: string — specify resource type for prefetch ("document", "script", "style", "font", etc.)
+ */
+const addResourceHints = (url, options) => {
+    try {
+        const parsed = new URL(url, window.location.href);
+        const isCrossOrigin = parsed.origin !== window.location.origin;
+        const head = document.head;
+        const addLink = (rel, href, as, crossOrigin) => {
+            // Skip if a matching link already exists
+            if (head.querySelector(`link[rel="${rel}"][href="${href}"]`))
+                return;
+            const link = document.createElement("link");
+            link.rel = rel;
+            link.href = href;
+            if (as)
+                link.as = as;
+            if (crossOrigin)
+                link.crossOrigin = "anonymous";
+            head.appendChild(link);
+        };
+        const hostname = parsed.hostname;
+        // DNS Prefetch (scheme-less, safe for any protocol)
+        addLink("dns-prefetch", `//${hostname}`);
+        // Preconnect (TCP + TLS warm-up)
+        addLink("preconnect", parsed.origin, undefined, isCrossOrigin);
+        // Prefetch (optional — caches the resource or HTML document)
+        if (options?.prefetch !== false) {
+            addLink("prefetch", parsed.href, options?.as ?? "document", isCrossOrigin);
+        }
+    }
+    catch (err) {
+        log.warn("[addResourceHints] Invalid URL:", url, err);
+    }
+};
 const isElement = (element) => element instanceof Element || element instanceof Document;
 const randomId = () => Math.random().toString(36).slice(2);
 const extractErrorHash = (message) => {
@@ -728,7 +821,7 @@ class SwitchChainError extends ProviderRpcError {
 class TransactionRejectedRpcError extends ProviderRpcError {
     constructor(message) {
         // Remove the "Version: viem@x.x.x" suffix if present
-        const cleanMessage = message.replace(/\nVersion:.*$/, '');
+        const cleanMessage = message.replace(/\nVersion:.*$/, "");
         super(cleanMessage);
         this.code = -32003;
         this.name = "TransactionRejectedRpcError";
@@ -1685,6 +1778,7 @@ class AirError extends BaseError {}
 new Set(AirClientUserErrors);
 new Set(Object.values(Codes));
 
+class OutgoingMessageEvent extends MessageEvent {}
 class MessageServiceBase {
   get events$() {
     return this._events$;
@@ -1700,13 +1794,16 @@ class MessageServiceBase {
     this.allowedMessageTypes = allowedMessageTypes;
     this.closeListener = null;
   }
+  static _getName(name, targetName) {
+    return `${name} Service: ${targetName} Channel`;
+  }
   async _open(target) {
     await this.close();
     this.eventSubject = new Subject();
     this._events$ = this.eventSubject.asObservable();
     this._messages$ = this.eventSubject.pipe(map(ev => ev.data));
     this._events$.subscribe(event => {
-      const sentOrReceived = event.origin === window.origin ? "sent" : "received";
+      const sentOrReceived = event instanceof OutgoingMessageEvent ? "sent" : "received";
       log.debug(`[${this.name}] Message ${sentOrReceived}:`, JSON.stringify(event.data, bigIntReplacer));
     });
     const handleMessage = async ev => {
@@ -1778,7 +1875,7 @@ class MessageServiceBase {
       log.debug(`[${this.name}] Not opened yet`);
       return;
     }
-    this.eventSubject.next(new MessageEvent("message", {
+    this.eventSubject.next(new OutgoingMessageEvent("message", {
       data: clonedMessage,
       origin: window.origin
     }));
@@ -1878,7 +1975,7 @@ class AirWalletProvider {
         if (!loginResult) {
             throw new UnauthorizedProviderError("User is not logged in");
         }
-        if (method === "eth_accounts" &&
+        if ((method === "eth_accounts" || method === "eth_requestAccounts") &&
             !__classPrivateFieldGet(this, _AirWalletProvider_isWalletInitialized, "f").call(this) &&
             loginResult?.abstractAccountAddress) {
             return [loginResult.abstractAccountAddress];
@@ -1943,9 +2040,8 @@ const ALLOWED_AUTH_MESSAGES = [
     AirAuthMessageTypes.LOGIN_RESPONSE,
     AirAuthMessageTypes.SETUP_WALLET_REQUEST,
     AirAuthMessageTypes.SETUP_RECOVERY_REQUEST,
-    AirAuthMessageTypes.INIT_RECOVERY_COMMUNICATION,
-    AirAuthMessageTypes.RESET_RECOVERY_COMMUNICATION,
     AirAuthMessageTypes.LOGOUT_RESPONSE,
+    AirAuthMessageTypes.UPDATE_SESSION_CONFIG_RESPONSE,
     AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
     AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE,
     AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE,
@@ -1965,11 +2061,6 @@ class AuthMessageService extends MessageServiceBase {
         const window = authIframe.contentWindow;
         await super._open({ window, origin });
     }
-    async initWalletCommunication() {
-        await this.sendMessage({
-            type: AirAuthMessageTypes.INIT_WALLET_COMMUNICATION,
-        });
-    }
     async sendPartnerUserInfoRequest() {
         const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE)));
         await this.sendMessage({
@@ -1978,6 +2069,11 @@ class AuthMessageService extends MessageServiceBase {
         });
         return response;
     }
+    async sendUpdateSessionConfigRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.UPDATE_SESSION_CONFIG_RESPONSE)));
+        await this.sendMessage({ type: AirAuthMessageTypes.UPDATE_SESSION_CONFIG_REQUEST, payload });
+        return response;
+    }
     async sendLoginRequest(payload) {
         const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LOGIN_RESPONSE)));
         await this.sendMessage({ type: AirAuthMessageTypes.LOGIN_REQUEST, payload });
@@ -1991,9 +2087,6 @@ class AuthMessageService extends MessageServiceBase {
         await this.sendMessage({ type: AirAuthMessageTypes.LOGOUT_REQUEST });
         return response;
     }
-    async resetWalletCommunication() {
-        await this.sendMessage({ type: AirAuthMessageTypes.RESET_WALLET_COMMUNICATION });
-    }
     async sendInitializationRequest(payload) {
         const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.INITIALIZATION_RESPONSE)));
         await this.sendMessage({ type: AirAuthMessageTypes.INITIALIZATION_REQUEST, payload });
@@ -2010,16 +2103,6 @@ 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,
@@ -2056,19 +2139,6 @@ class AuthMessageService extends MessageServiceBase {
         await this.sendMessage({ type: AirAuthMessageTypes.START_RECOVERY_REQUEST, payload });
         return response;
     }
-    /*
-     * Initialize credential communication
-     */
-    async initCredentialCommunication() {
-        await this.sendMessage({
-            type: AirAuthMessageTypes.INIT_CREDENTIAL_COMMUNICATION,
-        });
-    }
-    async resetCredentialCommunication() {
-        await this.sendMessage({
-            type: AirAuthMessageTypes.RESET_CREDENTIAL_COMMUNICATION,
-        });
-    }
 }
 _a$3 = AuthMessageService;
 _AuthMessageService_instance = { value: void 0 };
@@ -2077,8 +2147,7 @@ var _a$2, _CredentialMessageService_instance;
 const ALLOWED_CREDENTIAL_MESSAGES = [
     AirCredentialMessageTypes.INITIALIZATION_RESPONSE,
     AirCredentialMessageTypes.CREDENTIAL_IFRAME_VISIBILITY_REQUEST,
-    AirCredentialMessageTypes.CREDENTIAL_AUTH_INITIALIZED,
-    AirCredentialMessageTypes.CREDENTIAL_WALLET_INITIALIZED,
+    AirCredentialMessageTypes.UPDATE_SESSION_CONFIG_RESPONSE,
     AirCredentialMessageTypes.LOGOUT_RESPONSE,
     AirCredentialMessageTypes.ISSUE_CREDENTIAL_RESPONSE,
     AirCredentialMessageTypes.VERIFY_CREDENTIAL_RESPONSE,
@@ -2104,17 +2173,11 @@ class CredentialMessageService extends MessageServiceBase {
         });
         return response;
     }
-    async initAuthCommunication() {
-        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirCredentialMessageTypes.CREDENTIAL_AUTH_INITIALIZED)));
+    async sendUpdateSessionConfigRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirCredentialMessageTypes.UPDATE_SESSION_CONFIG_RESPONSE)));
         await this.sendMessage({
-            type: AirCredentialMessageTypes.INIT_AUTH_COMMUNICATION,
-        });
-        return response;
-    }
-    async initWalletCommunication() {
-        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirCredentialMessageTypes.CREDENTIAL_WALLET_INITIALIZED)));
-        await this.sendMessage({
-            type: AirCredentialMessageTypes.INIT_WALLET_COMMUNICATION,
+            type: AirCredentialMessageTypes.UPDATE_SESSION_CONFIG_REQUEST,
+            payload,
         });
         return response;
     }
@@ -2183,6 +2246,17 @@ class IframeController {
         iframe.style.padding = "0";
         iframe.style.display = "none";
         iframe.style.colorScheme = "auto";
+        iframe.setAttribute("sandbox", [
+            "allow-scripts",
+            "allow-same-origin",
+            "allow-storage-access-by-user-activation",
+            "allow-modals",
+            "allow-popups",
+            "allow-popups-to-escape-sandbox", // for google login
+            "allow-forms", // for google login
+            "allow-downloads", // for recovery export
+            "allow-top-navigation-by-user-activation",
+        ].join(" "));
         document.body.appendChild(iframe);
         this._iframeElement = iframe;
         return iframe;
@@ -2238,14 +2312,17 @@ class RecoveryMessageService extends MessageServiceBase {
         });
         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 sendUpdateSessionConfigRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirRecoveryMessageTypes.UPDATE_SESSION_CONFIG_RESPONSE)));
+        await this.sendMessage({
+            type: AirRecoveryMessageTypes.UPDATE_SESSION_CONFIG_REQUEST,
+            payload,
+        });
+        return response;
+    }
     async logout() {
         const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirRecoveryMessageTypes.LOGOUT_RESPONSE)));
         await this.sendMessage({ type: AirRecoveryMessageTypes.LOGOUT_REQUEST });
@@ -2265,6 +2342,7 @@ var _a, _WalletMessageService_instance;
 const ALLOWED_WALLET_MESSAGES = [
     AirWalletMessageTypes.INITIALIZATION_RESPONSE,
     AirWalletMessageTypes.WALLET_INITIALIZED,
+    AirWalletMessageTypes.UPDATE_SESSION_CONFIG_RESPONSE,
     AirWalletMessageTypes.WALLET_LOGIN_RESPONSE,
     AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_RESPONSE,
     AirWalletMessageTypes.SHOW_SWAP_UI_RESPONSE,
@@ -2289,14 +2367,6 @@ class WalletMessageService extends MessageServiceBase {
         const window = walletIframe.contentWindow;
         await super._open({ window, origin });
     }
-    async initAuthCommunication(skipWalletLogin) {
-        await this.sendMessage({
-            type: AirWalletMessageTypes.INIT_AUTH_COMMUNICATION,
-            payload: {
-                skipWalletLogin,
-            },
-        });
-    }
     async sendDeploySmartAccountRequest() {
         const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE)));
         await this.sendMessage({
@@ -2324,6 +2394,11 @@ class WalletMessageService extends MessageServiceBase {
     onInitialized() {
         return firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.WALLET_INITIALIZED)));
     }
+    async sendUpdateSessionConfigRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.UPDATE_SESSION_CONFIG_RESPONSE)));
+        await this.sendMessage({ type: AirWalletMessageTypes.UPDATE_SESSION_CONFIG_REQUEST, payload });
+        return response;
+    }
     async sendLoginRequest() {
         const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.WALLET_LOGIN_RESPONSE)));
         await this.sendMessage({
@@ -2375,10 +2450,11 @@ class WalletMessageService extends MessageServiceBase {
         await this.sendMessage({ type: AirWalletMessageTypes.CLAIM_ID_REQUEST, payload });
         return response;
     }
-    async sendShowSwapUIRequest() {
+    async sendShowSwapUIRequest(payload) {
         const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.SHOW_SWAP_UI_RESPONSE)));
         await this.sendMessage({
             type: AirWalletMessageTypes.SHOW_SWAP_UI_REQUEST,
+            payload
         });
         return response;
     }
@@ -2390,16 +2466,6 @@ class WalletMessageService extends MessageServiceBase {
         });
         return response;
     }
-    async initCredentialCommunication() {
-        await this.sendMessage({
-            type: AirWalletMessageTypes.INIT_CREDENTIAL_COMMUNICATION,
-        });
-    }
-    async resetCredentialCommunication() {
-        await this.sendMessage({
-            type: AirWalletMessageTypes.RESET_CREDENTIAL_COMMUNICATION,
-        });
-    }
 }
 _a = WalletMessageService;
 _WalletMessageService_instance = { value: void 0 };
@@ -2541,7 +2607,7 @@ class WindowService {
         ]);
         return (await response).data;
     }
-    async openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, onRetry, sdkVersion, enableAutomation, }) {
+    async openAndInitializeWalletServiceWindow({ url, windowId, sessionId, partnerId, enableLogging, onRetry, sdkVersion, enableAutomation, }) {
         if (this.windowControllers.has(windowId)) {
             throw new Error("Window controller already exists");
         }
@@ -2559,6 +2625,7 @@ class WindowService {
                         try {
                             channel = new MessageChannel();
                             const { payload } = await this.sendWindowInitializationRequest(windowId, {
+                                sessionId,
                                 partnerId,
                                 enableLogging,
                                 sdkVersion,
@@ -2598,7 +2665,7 @@ class WindowService {
 }
 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_recoveryInitialization, _AirService_recoveryMessagingService, _AirService_recoveryIframeController, _AirService_credentialsInitialization, _AirService_credentialMessagingService, _AirService_credentialIframeController, _AirService_ensureCredential, _AirService_initializeCredentials, _AirService_subscribeToCredentialEvents, _AirService_cleanUpCredential, _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;
+var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_sessionId, _AirService_sessionConfig, _AirService_authMessagingService, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airEventListener, _AirService_walletMessagingService, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_walletLoggedInResult, _AirService_airWalletProvider, _AirService_recoveryInitialization, _AirService_recoveryMessagingService, _AirService_recoveryIframeController, _AirService_credentialsInitialization, _AirService_credentialMessagingService, _AirService_credentialIframeController, _AirService_assertInitialized, _AirService_assertLoggedIn, _AirService_ensureCredential, _AirService_initializeCredentials, _AirService_subscribeToCredentialEvents, _AirService_cleanUpCredential, _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 }) {
@@ -2607,11 +2674,13 @@ class AirService {
         _AirService_buildEnv.set(this, void 0);
         _AirService_enableLogging.set(this, false);
         _AirService_partnerId.set(this, void 0);
+        _AirService_sessionId.set(this, void 0);
+        _AirService_sessionConfig.set(this, void 0);
         //#modalZIndex: number; TODO implement z index overwrite
         _AirService_authMessagingService.set(this, void 0);
         _AirService_authIframeController.set(this, void 0);
         _AirService_isAuthInitialized.set(this, false);
-        _AirService_airAuthListener.set(this, []);
+        _AirService_airEventListener.set(this, []);
         _AirService_walletMessagingService.set(this, void 0);
         _AirService_walletIframeController.set(this, void 0);
         _AirService_walletInitialization.set(this, void 0);
@@ -2633,7 +2702,7 @@ class AirService {
             ensureWallet: __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).bind(this),
             getLoginResult: () => __classPrivateFieldGet(this, _AirService_loginResult, "f"),
         }), "f");
-        // this.#modalZIndex = modalZIndex ?? 99999;
+        FONT_CDNS.forEach((cdn) => addResourceHints(cdn, { prefetch: false }));
     }
     get buildEnv() {
         return __classPrivateFieldGet(this, _AirService_buildEnv, "f");
@@ -2661,15 +2730,24 @@ class AirService {
     shouldEnableAutomation() {
         return localStorage.getItem("automation") === "true" && __classPrivateFieldGet(this, _AirService_buildEnv, "f") !== BUILD_ENV.PRODUCTION;
     }
-    async init({ buildEnv = BUILD_ENV.PRODUCTION, enableLogging = false, skipRehydration = false, }) {
+    async init({ buildEnv = BUILD_ENV.PRODUCTION, enableLogging = false, skipRehydration = false, sessionConfig = undefined, preloadWallet = false, preloadCredential = false, }) {
         if (!__classPrivateFieldGet(this, _AirService_partnerId, "f"))
-            throw new Error("Partner ID is required to initialize auth service");
+            throw new AirServiceError("CLIENT_ERROR", "Partner ID is required to initialize the service");
         if (__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            return;
+            return __classPrivateFieldGet(this, _AirService_loginResult, "f") ?? null;
+        configureLogLevel(buildEnv, enableLogging);
+        const { authUrl, walletUrl, credentialUrl } = AIR_URLS[buildEnv];
+        addResourceHints(authUrl);
+        if (preloadWallet) {
+            addResourceHints(walletUrl);
+        }
+        if (preloadCredential) {
+            addResourceHints(credentialUrl);
+        }
         __classPrivateFieldSet(this, _AirService_buildEnv, buildEnv, "f");
         __classPrivateFieldSet(this, _AirService_enableLogging, enableLogging, "f");
-        const { authUrl } = AIR_URLS[buildEnv];
-        configureLogLevel(buildEnv, enableLogging);
+        __classPrivateFieldSet(this, _AirService_sessionConfig, sessionConfig, "f");
+        __classPrivateFieldSet(this, _AirService_sessionId, randomId(), "f");
         const authIframeOrigin = new URL(authUrl).origin;
         __classPrivateFieldSet(this, _AirService_authIframeController, new IframeController("air-auth", authUrl), "f");
         try {
@@ -2719,12 +2797,14 @@ class AirService {
                     if (ev.data === AirAuthMessageTypes.AUTH_SETUP_COMPLETED) {
                         window.removeEventListener("message", handleAuthMessage);
                         const { payload } = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendInitializationRequest({
+                            sessionId: __classPrivateFieldGet(this, _AirService_sessionId, "f"),
                             partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                             skipRehydration,
                             partnerDAppUrl: window.location.href,
                             sdkVersion: airKitVersion,
                             enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
                             enableAutomation: this.shouldEnableAutomation(),
+                            sessionConfig,
                         });
                         if (payload.success === true) {
                             resolve(payload);
@@ -2738,8 +2818,10 @@ class AirService {
             });
             __classPrivateFieldSet(this, _AirService_isAuthInitialized, true, "f");
             __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthInitialized).call(this, { rehydrated: result.rehydrated });
-            if (result.preloadWallet)
+            if (result.preloadWallet || preloadWallet)
                 void this.preloadWallet();
+            if (preloadCredential)
+                void this.preloadCredential();
             // rehydrated auth session
             if (result.rehydrated) {
                 __classPrivateFieldSet(this, _AirService_loginResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createLoginResult).call(this, result), "f");
@@ -2750,13 +2832,12 @@ class AirService {
         catch (error) {
             log.debug("Error initializing auth service", error);
             await this.cleanUp();
-            throw error;
+            throw AirServiceError.from(error);
         }
         return null;
     }
     async login(options) {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertInitialized).call(this);
         if (__classPrivateFieldGet(this, _AirService_loginResult, "f"))
             return __classPrivateFieldGet(this, _AirService_loginResult, "f");
         const { payload } = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendLoginRequest({
@@ -2773,38 +2854,24 @@ class AirService {
      * @experimental This method is experimental and will change in the future.
      */
     async deploySmartAccount() {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
-        try {
-            log.info("deploySmartAccount");
-            const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendDeploySmartAccountRequest();
-            if (payload.success === false) {
-                throw new AirServiceError(payload.errorName, payload.errorMessage);
-            }
-            return { txHash: payload.txHash };
-        }
-        catch (error) {
-            throw AirServiceError.from(error);
+        log.info("deploySmartAccount");
+        const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendDeploySmartAccountRequest();
+        if (payload.success === false) {
+            throw new AirServiceError(payload.errorName, payload.errorMessage);
         }
+        return { txHash: payload.txHash };
     }
     /**
      * @experimental This method is experimental and will change in the future.
      */
     async isSmartAccountDeployed() {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
-        try {
-            const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendIsSmartAccountDeployedRequest();
-            if (payload.success === false) {
-                throw new AirServiceError(payload.errorName, payload.errorMessage);
-            }
-            return payload.isDeployed;
-        }
-        catch (error) {
-            throw AirServiceError.from(error);
+        const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendIsSmartAccountDeployedRequest();
+        if (payload.success === false) {
+            throw new AirServiceError(payload.errorName, payload.errorMessage);
         }
+        return payload.isDeployed;
     }
     getProvider() {
         return this.provider;
@@ -2837,9 +2904,9 @@ class AirService {
     /**
      * @experimental This feature has not been officially released and might change in the future.
      */
-    async showSwapUI() {
+    async showSwapUI(options) {
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
-        const result = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendShowSwapUIRequest();
+        const result = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendShowSwapUIRequest(options);
         if (result.payload.success === false) {
             throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
         }
@@ -2856,8 +2923,7 @@ class AirService {
         }
     }
     async getUserInfo() {
-        if (!this.isLoggedIn)
-            throw new Error("User not logged in");
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertLoggedIn).call(this);
         const info = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendPartnerUserInfoRequest();
         if (info.payload.success === false) {
             throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
@@ -2874,11 +2940,37 @@ class AirService {
             },
         };
     }
+    async updateSessionConfig(config) {
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertInitialized).call(this);
+        __classPrivateFieldSet(this, _AirService_sessionConfig, config, "f");
+        const resultsPromise = [__classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendUpdateSessionConfigRequest(config)];
+        if (__classPrivateFieldGet(this, _AirService_walletInitialization, "f")) {
+            resultsPromise.push(__classPrivateFieldGet(this, _AirService_walletInitialization, "f")
+                .then(() => __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendUpdateSessionConfigRequest(config))
+                .catch(() => null));
+        }
+        if (__classPrivateFieldGet(this, _AirService_recoveryInitialization, "f")) {
+            resultsPromise.push(__classPrivateFieldGet(this, _AirService_recoveryInitialization, "f")
+                .then(() => __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").sendUpdateSessionConfigRequest(config))
+                .catch(() => null));
+        }
+        if (__classPrivateFieldGet(this, _AirService_credentialsInitialization, "f")) {
+            resultsPromise.push(__classPrivateFieldGet(this, _AirService_credentialsInitialization, "f")
+                .then(() => __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").sendUpdateSessionConfigRequest(config))
+                .catch(() => null));
+        }
+        const results = await Promise.all(resultsPromise);
+        for (const result of results) {
+            if (result && result.payload.success === false) {
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+            }
+        }
+        const sessionConfig = { locale: results[0].payload.locale };
+        __classPrivateFieldSet(this, _AirService_sessionConfig, sessionConfig, "f");
+        return sessionConfig;
+    }
     async goToPartner(partnerUrl) {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
-        if (!this.isLoggedIn)
-            throw new Error("No active session to generate token");
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertLoggedIn).call(this);
         const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendCrossPartnerTokenRequest(partnerUrl);
         if (result.payload.success === false) {
             throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
@@ -2888,35 +2980,24 @@ class AirService {
         };
     }
     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);
+        const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendAccountRecoveryRequest(payload);
+        if (result.payload.success === false) {
+            throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
         }
     }
     async getAccessToken() {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
-        if (!this.isLoggedIn)
-            throw new Error("No active session to get partner access token");
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertLoggedIn).call(this);
         const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendPartnerAccessTokenRequest();
         if (result.payload.success !== true) {
             throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
         }
         if (!result.payload.partnerAccessToken) {
-            throw new Error("Partner access token not found in response");
+            throw new AirServiceError("UNAUTHORIZED", "Partner access token not found in response");
         }
         return { token: result.payload.partnerAccessToken };
     }
     async logout() {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
-        if (!this.isLoggedIn)
-            throw new Error("No active session to logout");
+        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertLoggedIn).call(this);
         // Clear up credentials first to avoid issues with wallet and auth messaging services
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpCredential).call(this);
         await Promise.all([
@@ -2928,33 +3009,21 @@ class AirService {
         __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedOut).call(this);
     }
     async cleanUp() {
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpCredential).call(this);
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpRecovery).call(this);
         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);
-        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpCredential).call(this);
-        this.clearEventListeners();
+        __classPrivateFieldSet(this, _AirService_airEventListener, [], "f");
+        __classPrivateFieldSet(this, _AirService_sessionId, undefined, "f");
+        __classPrivateFieldSet(this, _AirService_buildEnv, undefined, "f");
     }
-    /**
-     * Register an event listener for Air service events.
-     *
-     * Available events:
-     * - "initialized": Service initialization completed
-     * - "logged_in": User successfully logged in
-     * - "logged_out": User logged out
-     * - "wallet_initialized": Wallet initialization completed
-     *
-     * @param listener The event listener function
-     */
     on(listener) {
-        if (__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener) < 0)
-            __classPrivateFieldGet(this, _AirService_airAuthListener, "f").push(listener);
+        if (__classPrivateFieldGet(this, _AirService_airEventListener, "f").indexOf(listener) < 0)
+            __classPrivateFieldGet(this, _AirService_airEventListener, "f").push(listener);
     }
     off(listener) {
-        if (__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener) >= 0)
-            __classPrivateFieldGet(this, _AirService_airAuthListener, "f").splice(__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener), 1);
-    }
-    clearEventListeners() {
-        __classPrivateFieldSet(this, _AirService_airAuthListener, [], "f");
+        if (__classPrivateFieldGet(this, _AirService_airEventListener, "f").indexOf(listener) >= 0)
+            __classPrivateFieldGet(this, _AirService_airEventListener, "f").splice(__classPrivateFieldGet(this, _AirService_airEventListener, "f").indexOf(listener), 1);
     }
     async preloadCredential() {
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureCredential).call(this);
@@ -2987,9 +3056,15 @@ class AirService {
         return payload.verificationResult;
     }
 }
-_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_credentialsInitialization = new WeakMap(), _AirService_credentialMessagingService = new WeakMap(), _AirService_credentialIframeController = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureCredential = async function _AirService_ensureCredential() {
-    if (!this.isInitialized)
-        throw new Error("Service not initialized");
+_AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_sessionId = new WeakMap(), _AirService_sessionConfig = new WeakMap(), _AirService_authMessagingService = new WeakMap(), _AirService_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airEventListener = 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_credentialsInitialization = new WeakMap(), _AirService_credentialMessagingService = new WeakMap(), _AirService_credentialIframeController = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_assertInitialized = function _AirService_assertInitialized() {
+    if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+        throw new AirServiceError("NOT_INITIALIZED", "Service is not initialized");
+}, _AirService_assertLoggedIn = function _AirService_assertLoggedIn() {
+    __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertInitialized).call(this);
+    if (!this.isLoggedIn)
+        throw new AirServiceError("NOT_LOGGED_IN", "User not logged in");
+}, _AirService_ensureCredential = async function _AirService_ensureCredential() {
+    __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertInitialized).call(this);
     void __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
     try {
         if (!__classPrivateFieldGet(this, _AirService_credentialsInitialization, "f"))
@@ -2999,11 +3074,11 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     catch (error) {
         __classPrivateFieldSet(this, _AirService_credentialsInitialization, null, "f");
         log.error("Error ensuring credentials", error);
-        throw error;
+        throw AirServiceError.from(error);
     }
 }, _AirService_initializeCredentials = async function _AirService_initializeCredentials() {
     if (__classPrivateFieldGet(this, _AirService_credentialsInitialization, "f")) {
-        throw new Error("Already initializing credentials");
+        throw new AirServiceError("ALREADY_INITIALIZING", "Already initializing credentials");
     }
     const { credentialUrl } = AIR_URLS[__classPrivateFieldGet(this, _AirService_buildEnv, "f")];
     const credentialIframeOrigin = new URL(credentialUrl).origin;
@@ -3016,11 +3091,13 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
                 if (ev.data === AirCredentialMessageTypes.SERVICE_STARTED) {
                     window.removeEventListener("message", handleCredentialMessage);
                     const { payload } = await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").sendInitializationRequest({
+                        sessionId: __classPrivateFieldGet(this, _AirService_sessionId, "f"),
                         partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                         enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
                         sdkVersion: airKitVersion,
                         partnerDAppUrl: window.location.href,
                         enableAutomation: this.shouldEnableAutomation(),
+                        sessionConfig: __classPrivateFieldGet(this, _AirService_sessionConfig, "f"),
                     });
                     if (payload.success === true) {
                         resolve();
@@ -3039,13 +3116,8 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").open(__classPrivateFieldGet(this, _AirService_credentialIframeController, "f").iframeElement);
         __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_subscribeToCredentialEvents).call(this);
         await credentialInitRequestPromise;
-        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").initCredentialCommunication();
-        await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").initAuthCommunication();
-        log.info("[Embed] Credential auth channel initialized");
-        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
-        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").initCredentialCommunication();
-        await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").initWalletCommunication();
-        log.info("[Embed] Credential wallet channel initialized");
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, { skipWalletLogin: true });
+        void __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this); // this call triggers wallet login for later usage
         log.info("Credential service initialized successfully");
     }
     catch (error) {
@@ -3054,7 +3126,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         if (closeDApp) {
             window.close();
         }
-        throw error;
+        throw AirServiceError.from(error);
     }
 }, _AirService_subscribeToCredentialEvents = function _AirService_subscribeToCredentialEvents() {
     __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").messages$.subscribe(async (message) => {
@@ -3076,19 +3148,10 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         __classPrivateFieldGet(this, _AirService_credentialIframeController, "f").destroy();
         __classPrivateFieldSet(this, _AirService_credentialIframeController, undefined, "f");
     }
-    const walletIframeElement = __classPrivateFieldGet(this, _AirService_walletIframeController, "f")?.iframeElement;
-    if (isElement(walletIframeElement) && window.document.body.contains(walletIframeElement)) {
-        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").resetCredentialCommunication();
-    }
-    const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
-    if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
-        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").resetCredentialCommunication();
-    }
     await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").close();
     __classPrivateFieldSet(this, _AirService_credentialsInitialization, undefined, "f");
 }, _AirService_ensureWallet = async function _AirService_ensureWallet(option) {
-    if (!this.isInitialized)
-        throw new Error("Service not initialized");
+    __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertInitialized).call(this);
     if (!__classPrivateFieldGet(this, _AirService_walletInitialization, "f"))
         __classPrivateFieldSet(this, _AirService_walletInitialization, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_initializeWallet).call(this, option), "f");
     if (__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f"))
@@ -3102,7 +3165,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     catch (error) {
         __classPrivateFieldSet(this, _AirService_walletInitialization, null, "f");
         log.error("Error initializing wallet", error);
-        throw error;
+        throw AirServiceError.from(error);
     }
     if (__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f"))
         return __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f");
@@ -3113,7 +3176,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     return __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, walletLoginResult.payload);
 }, _AirService_initializeWallet = async function _AirService_initializeWallet(option) {
     if (__classPrivateFieldGet(this, _AirService_walletInitialization, "f"))
-        throw new Error("Already initializing");
+        throw new AirServiceError("ALREADY_INITIALIZING", "Already initializing");
     const { walletUrl } = AIR_URLS[__classPrivateFieldGet(this, _AirService_buildEnv, "f")];
     const walletIframeOrigin = new URL(walletUrl).origin;
     try {
@@ -3124,10 +3187,12 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
                 if (ev.data === AirWalletMessageTypes.SERVICE_STARTED) {
                     window.removeEventListener("message", handleWalletMessage);
                     const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendInitializationRequest({
+                        sessionId: __classPrivateFieldGet(this, _AirService_sessionId, "f"),
                         partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                         enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
                         sdkVersion: airKitVersion,
                         enableAutomation: this.shouldEnableAutomation(),
+                        sessionConfig: __classPrivateFieldGet(this, _AirService_sessionConfig, "f"),
                     });
                     if (payload.success === true) {
                         resolve();
@@ -3150,8 +3215,6 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         if (!this.isLoggedIn && !option?.skipWalletLogin) {
             await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").onLoggedIn();
         }
-        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").initWalletCommunication();
-        await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").initAuthCommunication(option?.skipWalletLogin ?? false);
         const walletInitResult = await walletInitPromise;
         if (walletInitResult.payload.success !== true) {
             throw new AirServiceError(walletInitResult.payload.errorName, walletInitResult.payload.errorMessage);
@@ -3165,7 +3228,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     catch (error) {
         log.error("Error initializing wallet", error);
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
-        throw error;
+        throw AirServiceError.from(error);
     }
 }, _AirService_subscribeToWalletEvents = function _AirService_subscribeToWalletEvents() {
     __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").messages$.subscribe(async (msg) => {
@@ -3194,6 +3257,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
                     const { windowController, port } = await WindowService$1.openAndInitializeWalletServiceWindow({
                         url: msg.payload.url,
                         windowId: msg.payload.windowId,
+                        sessionId: __classPrivateFieldGet(this, _AirService_sessionId, "f"),
                         partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                         enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
                         sdkVersion: airKitVersion,
@@ -3212,7 +3276,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         }
     });
 }, _AirService_triggerEventListeners = function _AirService_triggerEventListeners(data) {
-    __classPrivateFieldGet(this, _AirService_airAuthListener, "f").forEach((listener) => {
+    __classPrivateFieldGet(this, _AirService_airEventListener, "f").forEach((listener) => {
         listener(data);
     });
 }, _AirService_triggerAirAuthInitialized = function _AirService_triggerAirAuthInitialized(result) {
@@ -3270,17 +3334,12 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         __classPrivateFieldGet(this, _AirService_walletIframeController, "f").destroy();
         __classPrivateFieldSet(this, _AirService_walletIframeController, undefined, "f");
     }
-    const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
-    if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
-        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").resetWalletCommunication();
-    }
     // Close the message service
     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");
+    __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertInitialized).call(this);
     if (!__classPrivateFieldGet(this, _AirService_recoveryInitialization, "f")) {
         __classPrivateFieldSet(this, _AirService_recoveryInitialization, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_initializeRecovery).call(this), "f");
     }
@@ -3290,11 +3349,11 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     catch (error) {
         __classPrivateFieldSet(this, _AirService_recoveryInitialization, null, "f");
         log.error("Error initializing recovery", error);
-        throw error;
+        throw AirServiceError.from(error);
     }
 }, _AirService_initializeRecovery = async function _AirService_initializeRecovery() {
     if (__classPrivateFieldGet(this, _AirService_recoveryInitialization, "f"))
-        throw new Error("Already initializing");
+        throw new AirServiceError("ALREADY_INITIALIZING", "Already initializing");
     const { recoveryUrl } = AIR_URLS[__classPrivateFieldGet(this, _AirService_buildEnv, "f")];
     const recoveryIframeOrigin = new URL(recoveryUrl).origin;
     try {
@@ -3305,10 +3364,12 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
                 if (ev.data === AirRecoveryMessageTypes.SERVICE_STARTED) {
                     window.removeEventListener("message", handleRecoveryMessage);
                     const { payload } = await __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").sendInitializationRequest({
+                        sessionId: __classPrivateFieldGet(this, _AirService_sessionId, "f"),
                         partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                         enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
                         sdkVersion: airKitVersion,
                         enableAutomation: this.shouldEnableAutomation(),
+                        sessionConfig: __classPrivateFieldGet(this, _AirService_sessionConfig, "f"),
                     });
                     if (payload.success === true) {
                         resolve();
@@ -3327,17 +3388,12 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         __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);
-        }
+        await recoveryInitPromise;
     }
     catch (error) {
         log.error("Error initializing recovery", error);
         await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpRecovery).call(this);
-        throw error;
+        throw AirServiceError.from(error);
     }
 }, _AirService_subscribeToRecoveryEvents = function _AirService_subscribeToRecoveryEvents() {
     __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").messages$.subscribe(async (message) => {
@@ -3360,10 +3416,6 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         __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");
@@ -3386,3 +3438,5 @@ exports.UnauthorizedProviderError = UnauthorizedProviderError;
 exports.UnsupportedProviderMethodError = UnsupportedProviderMethodError;
 exports.UserRejectedRequestError = UserRejectedRequestError;
 exports.ensureProviderRpcError = ensureProviderRpcError;
+exports.mocaDevnet = mocaDevnet;
+exports.mocaTestnet = mocaTestnet;