@mocanetwork/airkit 1.5.0 → 1.5.1

package/dist/airkit.umd.js

@@ -101,7 +101,7 @@
       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};
 
@@ -132,8 +132,6 @@
       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",
@@ -143,12 +141,9 @@
       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 = {
@@ -186,7 +181,11 @@
       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 = {
@@ -575,8 +574,6 @@
         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;
@@ -592,32 +589,43 @@
         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;
@@ -1656,7 +1664,7 @@
       ...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);
@@ -1927,11 +1935,8 @@
         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() {
@@ -2033,28 +2038,18 @@
             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;
@@ -2062,25 +2057,21 @@
 
     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;
@@ -2093,7 +2084,7 @@
             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";
@@ -2132,9 +2123,10 @@
             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);
@@ -2187,7 +2179,6 @@
         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,
@@ -2195,9 +2186,9 @@
     ];
     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) {
@@ -2306,6 +2297,16 @@
             });
             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 };
@@ -2507,6 +2508,9 @@
     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);
@@ -2530,6 +2534,7 @@
             __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),
@@ -2573,7 +2578,7 @@
             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");
@@ -2608,6 +2613,10 @@
                             }
                             break;
                         }
+                        case AirAuthMessageTypes.EXPIRED_LOGOUT_REQUEST: {
+                            await this.logout();
+                            break;
+                        }
                     }
                 });
                 const result = await new Promise((resolve, reject) => {
@@ -2704,65 +2713,6 @@
                 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;
         }
@@ -2874,9 +2824,13 @@
                 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);
         }
@@ -2884,8 +2838,22 @@
             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);
@@ -2898,7 +2866,211 @@
             __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)
@@ -2953,7 +3125,7 @@
                 };
                 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);
@@ -3131,7 +3303,7 @@
                 };
                 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);
@@ -3184,6 +3356,7 @@
     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;