@mocanetwork/airkit 1.5.0 → 1.5.1

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.5.0";
+var version = "1.5.1";
 var airkitPackage = {
 	version: version};
 
@@ -128,8 +128,6 @@ const AirAuthMessageTypes = {
   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",
-  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",
@@ -139,12 +137,9 @@ const AirAuthMessageTypes = {
   START_RECOVERY_RESPONSE: "air_start_recovery_response",
   RECOVERY_REQUEST: "air_auth_recovery_request",
   RECOVERY_RESPONSE: "air_auth_recovery_response",
-  LINK_EOA_CREDENTIAL_REQUEST: "air_auth_link_eoa_credential_request",
-  LINK_EOA_CREDENTIAL_RESPONSE: "air_auth_link_eoa_credential_response",
-  LINKAGE_NONCE_REQUEST: "air_auth_linkage_nonce_request",
-  LINKAGE_NONCE_RESPONSE: "air_auth_linkage_nonce_response",
-  CREDENTIAL_SIGNERS_REQUEST: "air_auth_credential_signers_request",
-  CREDENTIAL_SIGNERS_RESPONSE: "air_auth_credential_signers_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"
 };
 
 const AirRecoveryMessageTypes = {
@@ -182,7 +177,11 @@ const AirWalletMessageTypes = {
   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"
+  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"
 };
 
 const AirWindowMessageTypes = {
@@ -571,8 +570,6 @@ const configureLogLevel = (environment, enableLogging) => {
     level = enableLogging ? log.levels.DEBUG : log.levels.INFO;
   } else if (environment === "uat" || environment === "sandbox") {
     level = enableLogging ? log.levels.INFO : log.levels.WARN;
-  } else if (environment === "sandbox") {
-    level = enableLogging ? log.levels.WARN : log.levels.ERROR;
   } else if (environment === "production") {
     // Be cautious with enabling more than WARN in prod
     level = enableLogging ? log.levels.WARN : log.levels.ERROR;
@@ -588,32 +585,43 @@ const BUILD_ENV = {
     DEVELOPMENT: "development",
     SANDBOX: "sandbox",
 };
+const IFRAME_NAME_PREFIX_SET = [
+    "air-wallet",
+    "air-recovery",
+    "air-credential",
+    "air-auth",
+]; // order defines the z-index from highest to lowest
 
 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/",
     },
     [BUILD_ENV.STAGING]: {
         authUrl: "https://account.staging.air3.com/auth/",
         walletUrl: "https://account.staging.air3.com/wallet/",
         recoveryUrl: "https://account.staging.air3.com/recovery/",
+        credentialUrl: "https://account.staging.air3.com/credential/",
     },
     [BUILD_ENV.UAT]: {
         authUrl: "https://account.uat.air3.com/auth/",
         walletUrl: "https://account.uat.air3.com/wallet/",
         recoveryUrl: "https://account.uat.air3.com/recovery/",
+        credentialUrl: "https://account.uat.air3.com/credential/",
     },
     [BUILD_ENV.SANDBOX]: {
         authUrl: "https://account.sandbox.air3.com/auth/",
         walletUrl: "https://account.sandbox.air3.com/wallet/",
         recoveryUrl: "https://account.sandbox.air3.com/recovery/",
+        credentialUrl: "https://account.sandbox.air3.com/credential/",
     },
     [BUILD_ENV.PRODUCTION]: {
         authUrl: "https://account.air3.com/auth/",
         walletUrl: "https://account.air3.com/wallet/",
         recoveryUrl: "https://account.air3.com/recovery/",
+        credentialUrl: "https://account.air3.com/credential/",
     },
 };
 const isElement = (element) => element instanceof Element || element instanceof Document;
@@ -1652,7 +1660,7 @@ const Codes = {
   ...WindowErrorName
 };
 
-const AirClientUserErrors = ["USER_CANCELLED", "CONFIG_ERROR", "CLIENT_ERROR", "UNKNOWN_ERROR", "PERMISSION_NOT_ENABLED", "SMART_ACCOUNT_NOT_DEPLOYED"];
+const AirClientUserErrors = ["USER_CANCELLED", "CONFIG_ERROR", "CLIENT_ERROR", "UNKNOWN_ERROR", "PERMISSION_NOT_ENABLED", "SMART_ACCOUNT_NOT_DEPLOYED", "ACCOUNT_DELETION_PENDING"];
 
 class AirError extends BaseError {}
 new Set(AirClientUserErrors);
@@ -1923,11 +1931,8 @@ const ALLOWED_AUTH_MESSAGES = [
     AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE,
     AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE,
     AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
-    AirAuthMessageTypes.CREDENTIAL_SALT_RESPONSE,
     AirAuthMessageTypes.START_RECOVERY_RESPONSE,
-    AirAuthMessageTypes.LINK_EOA_CREDENTIAL_RESPONSE,
-    AirAuthMessageTypes.LINKAGE_NONCE_RESPONSE,
-    AirAuthMessageTypes.CREDENTIAL_SIGNERS_RESPONSE,
+    AirAuthMessageTypes.EXPIRED_LOGOUT_REQUEST,
 ];
 class AuthMessageService extends MessageServiceBase {
     static create() {
@@ -2029,28 +2034,18 @@ class AuthMessageService extends MessageServiceBase {
         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 });
-        return response;
-    }
-    async sendLinkEoaCredentialRequest(payload) {
-        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LINK_EOA_CREDENTIAL_RESPONSE)));
-        await this.sendMessage({ type: AirAuthMessageTypes.LINK_EOA_CREDENTIAL_REQUEST, payload });
-        return response;
-    }
-    async sendCredentialSignersRequest(payload) {
-        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.CREDENTIAL_SIGNERS_RESPONSE)));
+    /*
+     * Initialize credential communication
+     */
+    async initCredentialCommunication() {
         await this.sendMessage({
-            type: AirAuthMessageTypes.CREDENTIAL_SIGNERS_REQUEST,
-            payload,
+            type: AirAuthMessageTypes.INIT_CREDENTIAL_COMMUNICATION,
         });
-        return response;
     }
-    async sendLinkageNonceRequest(payload) {
-        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LINKAGE_NONCE_RESPONSE)));
-        await this.sendMessage({ type: AirAuthMessageTypes.LINKAGE_NONCE_REQUEST, payload });
-        return response;
+    async resetCredentialCommunication() {
+        await this.sendMessage({
+            type: AirAuthMessageTypes.RESET_CREDENTIAL_COMMUNICATION,
+        });
     }
 }
 _a$2 = AuthMessageService;
@@ -2058,25 +2053,21 @@ _AuthMessageService_instance = { value: void 0 };
 
 class IframeController {
     getZIndex() {
-        if (this.iframeId.includes("air-auth"))
-            return this.AUTH_IFRAME_Z_INDEX;
-        if (this.iframeId.includes("air-wallet"))
-            return this.WALLET_IFRAME_Z_INDEX;
-        if (this.iframeId.includes("air-recovery"))
-            return this.RECOVERY_IFRAME_Z_INDEX;
-        return "9999999"; // Default z-index if not matched
-    }
-    constructor(iframeUrl, iframeId, state) {
+        for (let i = 0; i < IFRAME_NAME_PREFIX_SET.length; i++) {
+            if (this.iframeId.includes(IFRAME_NAME_PREFIX_SET[i])) {
+                return IframeController.HIGHEST_Z_INDEX - i;
+            }
+        }
+        return IframeController.HIGHEST_Z_INDEX - IFRAME_NAME_PREFIX_SET.length; // Lowest z-index if no match
+    }
+    constructor(iframePrefix, iframeUrl, state) {
         this._iframeElement = null;
-        this.AUTH_IFRAME_Z_INDEX = "9999998";
-        this.WALLET_IFRAME_Z_INDEX = "9999999";
-        this.RECOVERY_IFRAME_Z_INDEX = "999999";
         this.state = {
-            ...IframeController.defaultState,
+            ...IframeController.DEFAULT_STATE,
             ...state,
         };
         this.iframeUrl = iframeUrl;
-        this.iframeId = iframeId;
+        this.iframeId = `${iframePrefix}-${randomId()}`;
     }
     get iframeElement() {
         return this._iframeElement;
@@ -2089,7 +2080,7 @@ class IframeController {
         iframe.allow = "publickey-credentials-get *; publickey-credentials-create *";
         iframe.src = this.iframeUrl;
         iframe.style.position = "fixed";
-        iframe.style.zIndex = this.getZIndex();
+        iframe.style.zIndex = `${this.getZIndex()}`;
         iframe.style.border = "none";
         iframe.style.margin = "0";
         iframe.style.padding = "0";
@@ -2128,9 +2119,10 @@ class IframeController {
         this.iframeElement.contentWindow.postMessage(message, origin);
     }
 }
-IframeController.defaultState = {
+IframeController.DEFAULT_STATE = {
     isVisible: false,
 };
+IframeController.HIGHEST_Z_INDEX = 2147483647;
 
 var _a$1, _RecoveryMessageService_instance;
 const ALLOWED_RECOVERY_MESSAGES = Object.values(AirRecoveryMessageTypes);
@@ -2183,7 +2175,6 @@ const ALLOWED_WALLET_MESSAGES = [
     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,
     AirWindowMessageTypes.OPEN_WINDOW_REQUEST,
@@ -2191,9 +2182,9 @@ const ALLOWED_WALLET_MESSAGES = [
 ];
 class WalletMessageService extends MessageServiceBase {
     static create() {
-        if (__classPrivateFieldGet(this, _a, "f", _WalletMessageService_instance))
-            throw new Error("WalletMessageService already created");
-        __classPrivateFieldSet(this, _a, new _a("Embed Service: Wallet Channel", ALLOWED_WALLET_MESSAGES), "f", _WalletMessageService_instance);
+        if (!__classPrivateFieldGet(this, _a, "f", _WalletMessageService_instance)) {
+            __classPrivateFieldSet(this, _a, new _a("Embed Service: Wallet Channel", ALLOWED_WALLET_MESSAGES), "f", _WalletMessageService_instance);
+        }
         return __classPrivateFieldGet(this, _a, "f", _WalletMessageService_instance);
     }
     async open(walletIframe) {
@@ -2302,6 +2293,16 @@ 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 };
@@ -2503,6 +2504,9 @@ 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_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 {
+    // #credentialsInitialization?: Promise<void>;
+    // #credentialMessagingService: CredentialMessageService;
+    // #credentialIframeController: IframeController;
     constructor({ partnerId }) {
         _AirService_instances.add(this);
         _AirService_loginResult.set(this, void 0);
@@ -2526,6 +2530,7 @@ class AirService {
         __classPrivateFieldSet(this, _AirService_authMessagingService, AuthMessageService.create(), "f");
         __classPrivateFieldSet(this, _AirService_walletMessagingService, WalletMessageService.create(), "f");
         __classPrivateFieldSet(this, _AirService_recoveryMessagingService, RecoveryMessageService.create(), "f");
+        // this.#credentialMessagingService = CredentialMessageService.create();
         __classPrivateFieldSet(this, _AirService_airWalletProvider, new AirWalletProvider({
             isWalletInitialized: () => this.isWalletInitialized,
             ensureWallet: __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).bind(this),
@@ -2569,7 +2574,7 @@ class AirService {
         const { authUrl } = AIR_URLS[buildEnv];
         configureLogLevel(buildEnv, enableLogging);
         const authIframeOrigin = new URL(authUrl).origin;
-        __classPrivateFieldSet(this, _AirService_authIframeController, new IframeController(authUrl, `air-auth-${randomId()}`), "f");
+        __classPrivateFieldSet(this, _AirService_authIframeController, new IframeController("air-auth", authUrl), "f");
         try {
             __classPrivateFieldGet(this, _AirService_authIframeController, "f").createIframe();
             log.info(authUrl, "url loaded");
@@ -2604,6 +2609,10 @@ class AirService {
                         }
                         break;
                     }
+                    case AirAuthMessageTypes.EXPIRED_LOGOUT_REQUEST: {
+                        await this.logout();
+                        break;
+                    }
                 }
             });
             const result = await new Promise((resolve, reject) => {
@@ -2700,65 +2709,6 @@ class AirService {
             throw AirServiceError.from(error);
         }
     }
-    /**
-     * @experimental This method is experimental and will change in the future.
-     */
-    async getCredentialSalt() {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
-        if (!this.isLoggedIn)
-            throw new Error("No active session to get partner access token");
-        const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendCredentialSaltRequest();
-        if (result.payload.success === false) {
-            throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
-        }
-        return {
-            credentialSalt: result.payload.credentialSalt,
-        };
-    }
-    /**
-     * @experimental This method is experimental and will change in the future.
-     */
-    async getLinkageNonce(payload) {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
-        if (!this.isLoggedIn)
-            throw new Error("No active session to get nonce");
-        const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendLinkageNonceRequest(payload);
-        if (result.payload.success === false) {
-            throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
-        }
-        return {
-            nonce: result.payload.nonce,
-        };
-    }
-    /**
-     * @experimental This method is experimental and will change in the future.
-     */
-    async retrieveCredentialSigners(payload) {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
-        if (!this.isLoggedIn)
-            throw new Error("No active session to retrieve EOA credential");
-        const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendCredentialSignersRequest(payload);
-        if (result.payload.success === false) {
-            throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
-        }
-        return result.payload.credentials;
-    }
-    /**
-     * @experimental This method is experimental and will change in the future.
-     */
-    async linkEoaCredential(payload) {
-        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-            throw new Error("Service is not initialized");
-        if (!this.isLoggedIn)
-            throw new Error("No active session to link EOA credential");
-        const result = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendLinkEoaCredentialRequest(payload);
-        if (result.payload.success === false) {
-            throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
-        }
-    }
     getProvider() {
         return this.provider;
     }
@@ -2870,9 +2820,13 @@ class AirService {
             throw new Error("Service is not initialized");
         if (!this.isLoggedIn)
             throw new Error("No active session to logout");
-        // Clear up wallet
-        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
-        await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").logout();
+        // Clear up credentials first to avoid issues with wallet and auth messaging services
+        // await this.#cleanUpCredential();
+        await Promise.all([
+            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this),
+            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpRecovery).call(this),
+            __classPrivateFieldGet(this, _AirService_authMessagingService, "f").logout(),
+        ]);
         __classPrivateFieldSet(this, _AirService_loginResult, undefined, "f");
         __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedOut).call(this);
     }
@@ -2880,8 +2834,22 @@ class AirService {
         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 this.#cleanUpCredential();
         this.clearEventListeners();
     }
+    /**
+     * 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
+     * - "credential_issuance_finished": Credential issuance finished (success or failure)
+     * - "credential_verification_finished": Credential verification finished (success or failure)
+     *
+     * @param listener The event listener function
+     */
     on(listener) {
         if (__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener) < 0)
             __classPrivateFieldGet(this, _AirService_airAuthListener, "f").push(listener);
@@ -2894,7 +2862,211 @@ class AirService {
         __classPrivateFieldSet(this, _AirService_airAuthListener, [], "f");
     }
 }
-_AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_authMessagingService = new WeakMap(), _AirService_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airAuthListener = new WeakMap(), _AirService_walletMessagingService = new WeakMap(), _AirService_walletIframeController = new WeakMap(), _AirService_walletInitialization = new WeakMap(), _AirService_walletLoggedInResult = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_recoveryInitialization = new WeakMap(), _AirService_recoveryMessagingService = new WeakMap(), _AirService_recoveryIframeController = 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 = 
+// /**
+//  * Issue a credential using the credential SDK
+//  * @param claimRequest The claim request containing credential details
+//  * @param projectName The name of the project
+//  * @param options Optional configuration for the credential widget
+//  */
+// public async issueCredential(
+//   claimRequest: {
+//     process: "Issue";
+//     issuerDid: string;
+//     issuerAuth: string;
+//     credentialId: string;
+//     credentialSubject: Record<string, unknown>;
+//   },
+//   projectName: string,
+//   options?: {
+//     endpoint?: string;
+//     theme?: "auto" | "light" | "dark";
+//     locale?: "en" | "zh-hk";
+//   }
+// ): Promise<Record<string, never>> {
+//   await this.#ensureCredentials();
+//   try {
+//     const { payload } = await this.#credentialMessagingService.sendIssueCredentialRequest({
+//       claimRequest,
+//       projectName,
+//       options: options || {},
+//     });
+//
+//     return payload;
+//   } catch (error) {
+//     throw AirServiceError.from(error);
+//   }
+// }
+//
+// /**
+//  * Verify a credential using the credential SDK
+//  * @param queryRequest The query request containing verification details
+//  * @param projectName The name of the project
+//  * @param options Optional configuration for the credential widget
+//  */
+// public async verifyCredential(
+//   queryRequest: {
+//     process: "Verify";
+//     verifierAuth: string;
+//     programId: string;
+//   },
+//   projectName: string,
+//   options?: {
+//     endpoint?: string;
+//     theme?: "auto" | "light" | "dark";
+//     locale?: "en" | "zh-hk";
+//   }
+// ): Promise<{
+//   verificationResults: {
+//     status:
+//       | "Compliant"
+//       | "Non-Compliant"
+//       | "Pending"
+//       | "Revoking"
+//       | "Revoked"
+//       | "Expired"
+//       | "NotFound";
+//   };
+// }> {
+//   await this.#ensureCredentials();
+//
+//   try {
+//     const { payload } = await this.#credentialMessagingService.sendVerifyCredentialRequest({
+//       queryRequest,
+//       projectName,
+//       options: options || {},
+//     });
+//
+//     return payload;
+//   } catch (error) {
+//     throw AirServiceError.from(error);
+//   }
+// }
+// async #ensureCredentials(): Promise<void> {
+//   if (!this.isInitialized) throw new Error("Service not initialized");
+//   if (!this.isLoggedIn) throw new Error("User not logged in");
+//   void this.#ensureWallet();
+//
+//   try {
+//     if (!this.#credentialsInitialization)
+//       this.#credentialsInitialization = this.#initializeCredentials();
+//     await this.#credentialsInitialization;
+//   } catch (error) {
+//     this.#credentialsInitialization = null;
+//     log.error("Error ensuring credentials", error);
+//     throw error;
+//   }
+// }
+// async #initializeCredentials(): Promise<void> {
+//   if (this.#credentialsInitialization) {
+//     throw new Error("Already initializing credentials");
+//   }
+//   const { credentialUrl } = AIR_URLS[this.#buildEnv];
+//   const credentailIframeOrigin = new URL(credentialUrl).origin;
+//   try {
+//     const credentialInitRequestPromise = new Promise<void>((resolve, reject) => {
+//       const handleCredentialMessage = async (ev: MessageEvent) => {
+//         if (ev.origin !== credentailIframeOrigin) return;
+//         if (ev.data === AirCredentialMessageTypes.SERVICE_STARTED) {
+//           window.removeEventListener("message", handleCredentialMessage);
+//           const { payload } = await this.#credentialMessagingService.sendInitializationRequest({
+//             partnerId: this.#partnerId,
+//             enableLogging: this.#enableLogging,
+//             sdkVersion: airKitVersion,
+//             enableAutomation: this.shouldEnableAutomation(),
+//           });
+//           if (payload.success === true) {
+//             resolve();
+//           } else {
+//             reject(new AirServiceError(payload.errorName, payload.errorMessage));
+//           }
+//         }
+//       };
+//       window.addEventListener("message", handleCredentialMessage);
+//     });
+//     this.#credentialIframeController = new IframeController("air-credential", credentialUrl);
+//     this.#credentialIframeController.createIframe();
+//     log.info(credentialUrl, "url loaded");
+//
+//     await this.#credentialMessagingService.open(this.#credentialIframeController.iframeElement);
+//     this.#subscribeToCredentialEvents();
+//     await credentialInitRequestPromise;
+//
+//     await this.#authMessagingService.initCredentialCommunication();
+//     await this.#credentialMessagingService.initAuthCommunication();
+//     log.info("[Embed] Credential auth channel initialized");
+//
+//     await this.#ensureWallet();
+//     await this.#walletMessagingService.initCredentialCommunication();
+//     await this.#credentialMessagingService.initWalletCommunication();
+//     log.info("[Embed] Credential wallet channel initialized");
+//
+//     log.info("Credential service initialized successfully");
+//   } catch (error) {
+//     log.error("Error initializing credentials", error);
+//     await this.#cleanUpCredential();
+//     throw error;
+//   }
+// }
+// #subscribeToCredentialEvents() {
+//   this.#credentialMessagingService.messages$.subscribe(async (message: AirCredentialMessage) => {
+//     switch (message.type) {
+//       case AirCredentialMessageTypes.CREDENTIAL_IFRAME_VISIBILITY_REQUEST: {
+//         this.#credentialIframeController.setIframeVisibility(message.payload.visible);
+//         this.#credentialIframeController.updateIframeState();
+//         break;
+//       }
+//       case AirCredentialMessageTypes.ISSUE_CREDENTIAL_RESPONSE: {
+//         // Trigger general event for issue credential completion
+//         this.#triggerEventListeners({
+//           event: "credential_issuance_finished",
+//           data: {
+//             success: true,
+//           },
+//         });
+//         break;
+//       }
+//       case AirCredentialMessageTypes.VERIFY_CREDENTIAL_RESPONSE: {
+//         // Trigger general event for verify credential completion
+//         this.#triggerEventListeners({
+//           event: "credential_verification_finished",
+//           data: {
+//             success: true,
+//             verificationResults: message.payload.verificationResults,
+//           },
+//         });
+//         break;
+//       }
+//     }
+//   });
+// }
+// async #cleanUpCredential(): Promise<void> {
+//   if (!this.#isAuthInitialized) return;
+//
+//   const credentialIframeElement = this.#credentialIframeController?.iframeElement;
+//   if (
+//     isElement(credentialIframeElement) &&
+//     window.document.body.contains(credentialIframeElement)
+//   ) {
+//     await this.#credentialMessagingService.logout();
+//     this.#credentialIframeController.destroy();
+//     this.#credentialIframeController = undefined;
+//   }
+//
+//   const walletIframeElement = this.#walletIframeController?.iframeElement;
+//   if (isElement(walletIframeElement) && window.document.body.contains(walletIframeElement)) {
+//     await this.#walletMessagingService.resetCredentialCommunication();
+//   }
+//
+//   const authIframeElement = this.#authIframeController?.iframeElement;
+//   if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
+//     await this.#authMessagingService.resetCredentialCommunication();
+//   }
+//
+//   await this.#credentialMessagingService.close();
+//   this.#credentialsInitialization = undefined;
+// }
+async function _AirService_ensureWallet(option) {
     if (!this.isInitialized)
         throw new Error("Service not initialized");
     if (!this.isLoggedIn && !option?.skipWalletLogin)
@@ -2949,7 +3121,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
             };
             window.addEventListener("message", handleWalletMessage);
         });
-        __classPrivateFieldSet(this, _AirService_walletIframeController, new IframeController(walletUrl, `air-wallet-${randomId()}`), "f");
+        __classPrivateFieldSet(this, _AirService_walletIframeController, new IframeController("air-wallet", walletUrl), "f");
         __classPrivateFieldGet(this, _AirService_walletIframeController, "f").createIframe();
         log.info(walletUrl, "url loaded");
         await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").open(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
@@ -3127,7 +3299,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
             };
             window.addEventListener("message", handleRecoveryMessage);
         });
-        __classPrivateFieldSet(this, _AirService_recoveryIframeController, new IframeController(recoveryUrl, `air-recovery-${randomId()}`), "f");
+        __classPrivateFieldSet(this, _AirService_recoveryIframeController, new IframeController("air-recovery", recoveryUrl), "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);
@@ -3180,6 +3352,7 @@ exports.AirService = AirService;
 exports.AirServiceError = AirServiceError;
 exports.BUILD_ENV = BUILD_ENV;
 exports.ChainDisconnectedError = ChainDisconnectedError;
+exports.IFRAME_NAME_PREFIX_SET = IFRAME_NAME_PREFIX_SET;
 exports.InternalRpcError = InternalRpcError;
 exports.InvalidParamsRpcError = InvalidParamsRpcError;
 exports.InvalidRequestRpcError = InvalidRequestRpcError;