@mocanetwork/airkit 1.5.1 → 1.6.0-beta.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.1";
+var version = "1.6.0-beta.1";
 var airkitPackage = {
 	version: version};
 
@@ -142,6 +142,25 @@ const AirAuthMessageTypes = {
   EXPIRED_LOGOUT_REQUEST: "air_auth_expired_logout_request"
 };
 
+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",
+  LOGOUT_REQUEST: "air_credential_logout_request",
+  LOGOUT_RESPONSE: "air_credential_logout_response",
+  // New credential operation message types
+  ISSUE_CREDENTIAL_REQUEST: "air_credential_issue_request",
+  VERIFY_CREDENTIAL_REQUEST: "air_credential_verify_request",
+  // Event messages for communication with parent
+  ISSUE_CREDENTIAL_RESPONSE: "air_credential_issue_response",
+  VERIFY_CREDENTIAL_RESPONSE: "air_credential_verify_response"
+};
+
 const AirRecoveryMessageTypes = {
   SERVICE_STARTED: "air_recovery_service_started",
   INITIALIZATION_REQUEST: "air_recovery_initialization_request",
@@ -587,9 +606,9 @@ const BUILD_ENV = {
 };
 const IFRAME_NAME_PREFIX_SET = [
     "air-wallet",
-    "air-recovery",
     "air-credential",
     "air-auth",
+    "air-recovery",
 ]; // order defines the z-index from highest to lowest
 
 const AIR_URLS = {
@@ -1781,17 +1800,17 @@ var AirWalletProviderMessageTypes;
   AirWalletProviderMessageTypes["EVENT"] = "JRPC_EVENT";
 })(AirWalletProviderMessageTypes || (AirWalletProviderMessageTypes = {}));
 
-var _a$3, _ProviderMessageService_instance;
+var _a$4, _ProviderMessageService_instance;
 const ALLOWED_PROVIDER_MESSAGES = [
     AirWalletProviderMessageTypes.RESPONSE,
     AirWalletProviderMessageTypes.EVENT,
 ];
 class ProviderMessageService extends MessageServiceBase {
     static create() {
-        if (!__classPrivateFieldGet(this, _a$3, "f", _ProviderMessageService_instance)) {
-            __classPrivateFieldSet(this, _a$3, new _a$3("Embed Service: Provider Channel", ALLOWED_PROVIDER_MESSAGES), "f", _ProviderMessageService_instance);
+        if (!__classPrivateFieldGet(this, _a$4, "f", _ProviderMessageService_instance)) {
+            __classPrivateFieldSet(this, _a$4, new _a$4("Embed Service: Provider Channel", ALLOWED_PROVIDER_MESSAGES), "f", _ProviderMessageService_instance);
         }
-        return __classPrivateFieldGet(this, _a$3, "f", _ProviderMessageService_instance);
+        return __classPrivateFieldGet(this, _a$4, "f", _ProviderMessageService_instance);
     }
     async open(walletIframe) {
         const origin = new URL(walletIframe.src).origin;
@@ -1807,7 +1826,7 @@ class ProviderMessageService extends MessageServiceBase {
         return response;
     }
 }
-_a$3 = ProviderMessageService;
+_a$4 = ProviderMessageService;
 _ProviderMessageService_instance = { value: void 0 };
 
 var _AirWalletProvider_instances, _AirWalletProvider_providerMessageService, _AirWalletProvider_isWalletInitialized, _AirWalletProvider_getLoginResult, _AirWalletProvider_ensureWallet, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
@@ -1918,7 +1937,7 @@ _AirWalletProvider_providerMessageService = new WeakMap(), _AirWalletProvider_is
     });
 };
 
-var _a$2, _AuthMessageService_instance;
+var _a$3, _AuthMessageService_instance;
 const ALLOWED_AUTH_MESSAGES = [
     AirAuthMessageTypes.INITIALIZATION_RESPONSE,
     AirAuthMessageTypes.LOGIN_RESPONSE,
@@ -1936,10 +1955,10 @@ const ALLOWED_AUTH_MESSAGES = [
 ];
 class AuthMessageService extends MessageServiceBase {
     static create() {
-        if (!__classPrivateFieldGet(this, _a$2, "f", _AuthMessageService_instance)) {
-            __classPrivateFieldSet(this, _a$2, new _a$2("Embed Service: Auth Channel", ALLOWED_AUTH_MESSAGES), "f", _AuthMessageService_instance);
+        if (!__classPrivateFieldGet(this, _a$3, "f", _AuthMessageService_instance)) {
+            __classPrivateFieldSet(this, _a$3, new _a$3("Embed Service: Auth Channel", ALLOWED_AUTH_MESSAGES), "f", _AuthMessageService_instance);
         }
-        return __classPrivateFieldGet(this, _a$2, "f", _AuthMessageService_instance);
+        return __classPrivateFieldGet(this, _a$3, "f", _AuthMessageService_instance);
     }
     async open(authIframe) {
         const origin = new URL(authIframe.src).origin;
@@ -1964,6 +1983,9 @@ class AuthMessageService extends MessageServiceBase {
         await this.sendMessage({ type: AirAuthMessageTypes.LOGIN_REQUEST, payload });
         return response;
     }
+    onLoggedIn() {
+        return firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LOGIN_RESPONSE && msg.payload?.success === true)));
+    }
     async logout() {
         const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.LOGOUT_RESPONSE)));
         await this.sendMessage({ type: AirAuthMessageTypes.LOGOUT_REQUEST });
@@ -2048,9 +2070,84 @@ class AuthMessageService extends MessageServiceBase {
         });
     }
 }
-_a$2 = AuthMessageService;
+_a$3 = AuthMessageService;
 _AuthMessageService_instance = { value: void 0 };
 
+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.LOGOUT_RESPONSE,
+    AirCredentialMessageTypes.ISSUE_CREDENTIAL_RESPONSE,
+    AirCredentialMessageTypes.VERIFY_CREDENTIAL_RESPONSE,
+];
+class CredentialMessageService extends MessageServiceBase {
+    static create() {
+        if (!__classPrivateFieldGet(this, _a$2, "f", _CredentialMessageService_instance)) {
+            __classPrivateFieldSet(this, _a$2, new _a$2("Embed Service: Credential Channel", ALLOWED_CREDENTIAL_MESSAGES), "f", _CredentialMessageService_instance);
+        }
+        return __classPrivateFieldGet(this, _a$2, "f", _CredentialMessageService_instance);
+    }
+    async open(iframeElement) {
+        await this._open({
+            window: iframeElement.contentWindow,
+            origin: new URL(iframeElement.src).origin,
+        });
+    }
+    async sendInitializationRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirCredentialMessageTypes.INITIALIZATION_RESPONSE)));
+        await this.sendMessage({
+            type: AirCredentialMessageTypes.INITIALIZATION_REQUEST,
+            payload,
+        });
+        return response;
+    }
+    async initAuthCommunication() {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirCredentialMessageTypes.CREDENTIAL_AUTH_INITIALIZED)));
+        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,
+        });
+        return response;
+    }
+    async logout() {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirCredentialMessageTypes.LOGOUT_RESPONSE)));
+        await this.sendMessage({
+            type: AirCredentialMessageTypes.LOGOUT_REQUEST,
+        });
+        return response;
+    }
+    async sendIssueCredentialRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirCredentialMessageTypes.ISSUE_CREDENTIAL_RESPONSE)));
+        await this.sendMessage({
+            type: AirCredentialMessageTypes.ISSUE_CREDENTIAL_REQUEST,
+            payload,
+        });
+        return response;
+    }
+    async sendVerifyCredentialRequest(payload) {
+        const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirCredentialMessageTypes.VERIFY_CREDENTIAL_RESPONSE)));
+        await this.sendMessage({
+            type: AirCredentialMessageTypes.VERIFY_CREDENTIAL_REQUEST,
+            payload,
+        });
+        return response;
+    }
+    async close() {
+        await super.close();
+    }
+}
+_a$2 = CredentialMessageService;
+_CredentialMessageService_instance = { value: void 0 };
+
 class IframeController {
     getZIndex() {
         for (let i = 0; i < IFRAME_NAME_PREFIX_SET.length; i++) {
@@ -2501,12 +2598,9 @@ 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_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_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;
 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,11 +2620,14 @@ class AirService {
         _AirService_recoveryInitialization.set(this, void 0);
         _AirService_recoveryMessagingService.set(this, void 0);
         _AirService_recoveryIframeController.set(this, void 0);
+        _AirService_credentialsInitialization.set(this, void 0);
+        _AirService_credentialMessagingService.set(this, void 0);
+        _AirService_credentialIframeController.set(this, void 0);
         __classPrivateFieldSet(this, _AirService_partnerId, partnerId, "f");
         __classPrivateFieldSet(this, _AirService_authMessagingService, AuthMessageService.create(), "f");
         __classPrivateFieldSet(this, _AirService_walletMessagingService, WalletMessageService.create(), "f");
         __classPrivateFieldSet(this, _AirService_recoveryMessagingService, RecoveryMessageService.create(), "f");
-        // this.#credentialMessagingService = CredentialMessageService.create();
+        __classPrivateFieldSet(this, _AirService_credentialMessagingService, CredentialMessageService.create(), "f");
         __classPrivateFieldSet(this, _AirService_airWalletProvider, new AirWalletProvider({
             isWalletInitialized: () => this.isWalletInitialized,
             ensureWallet: __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).bind(this),
@@ -2642,7 +2739,7 @@ class AirService {
             __classPrivateFieldSet(this, _AirService_isAuthInitialized, true, "f");
             __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthInitialized).call(this, { rehydrated: result.rehydrated });
             if (result.preloadWallet)
-                this.preloadWallet();
+                void this.preloadWallet();
             // rehydrated auth session
             if (result.rehydrated) {
                 __classPrivateFieldSet(this, _AirService_loginResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createLoginResult).call(this, result), "f");
@@ -2821,7 +2918,7 @@ class AirService {
         if (!this.isLoggedIn)
             throw new Error("No active session to logout");
         // Clear up credentials first to avoid issues with wallet and auth messaging services
-        // await this.#cleanUpCredential();
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpCredential).call(this);
         await Promise.all([
             __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this),
             __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpRecovery).call(this),
@@ -2834,7 +2931,7 @@ 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();
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpCredential).call(this);
         this.clearEventListeners();
     }
     /**
@@ -2845,8 +2942,6 @@ class AirService {
      * - "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
      */
@@ -2861,216 +2956,139 @@ class AirService {
     clearEventListeners() {
         __classPrivateFieldSet(this, _AirService_airAuthListener, [], "f");
     }
+    async preloadCredential() {
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureCredential).call(this);
+    }
+    async issueCredential({ authToken, issuerDid, credentialId, credentialSubject, }) {
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureCredential).call(this);
+        const { payload } = await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").sendIssueCredentialRequest({
+            partnerToken: authToken,
+            issuerDid,
+            credentialId,
+            credentialSubject,
+        });
+        if (payload.closeDApp) {
+            window.close();
+        }
+        if (payload.success === false) {
+            throw new AirServiceError(payload.errorName, payload.errorMessage);
+        }
+    }
+    async verifyCredential({ authToken, programId, redirectUrl, }) {
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureCredential).call(this);
+        const { payload } = await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").sendVerifyCredentialRequest({
+            partnerToken: authToken,
+            programId,
+            redirectUrl,
+        });
+        if (payload.success === false) {
+            throw new AirServiceError(payload.errorName, payload.errorMessage);
+        }
+        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_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) {
+_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");
+    void __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+    try {
+        if (!__classPrivateFieldGet(this, _AirService_credentialsInitialization, "f"))
+            __classPrivateFieldSet(this, _AirService_credentialsInitialization, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_initializeCredentials).call(this), "f");
+        await __classPrivateFieldGet(this, _AirService_credentialsInitialization, "f");
+    }
+    catch (error) {
+        __classPrivateFieldSet(this, _AirService_credentialsInitialization, null, "f");
+        log.error("Error ensuring credentials", error);
+        throw error;
+    }
+}, _AirService_initializeCredentials = async function _AirService_initializeCredentials() {
+    if (__classPrivateFieldGet(this, _AirService_credentialsInitialization, "f")) {
+        throw new Error("Already initializing credentials");
+    }
+    const { credentialUrl } = AIR_URLS[__classPrivateFieldGet(this, _AirService_buildEnv, "f")];
+    const credentialIframeOrigin = new URL(credentialUrl).origin;
+    let closeDApp = false;
+    try {
+        const credentialInitRequestPromise = new Promise((resolve, reject) => {
+            const handleCredentialMessage = async (ev) => {
+                if (ev.origin !== credentialIframeOrigin)
+                    return;
+                if (ev.data === AirCredentialMessageTypes.SERVICE_STARTED) {
+                    window.removeEventListener("message", handleCredentialMessage);
+                    const { payload } = await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").sendInitializationRequest({
+                        partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
+                        enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
+                        sdkVersion: airKitVersion,
+                        partnerDAppUrl: window.location.href,
+                        enableAutomation: this.shouldEnableAutomation(),
+                    });
+                    if (payload.success === true) {
+                        resolve();
+                    }
+                    else {
+                        closeDApp = !!payload.closeDApp;
+                        reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                    }
+                }
+            };
+            window.addEventListener("message", handleCredentialMessage);
+        });
+        __classPrivateFieldSet(this, _AirService_credentialIframeController, new IframeController("air-credential", credentialUrl), "f");
+        __classPrivateFieldGet(this, _AirService_credentialIframeController, "f").createIframe();
+        log.info(credentialUrl, "url loaded");
+        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");
+        log.info("Credential service initialized successfully");
+    }
+    catch (error) {
+        log.error("Error initializing credentials", error);
+        await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpCredential).call(this);
+        if (closeDApp) {
+            window.close();
+        }
+        throw error;
+    }
+}, _AirService_subscribeToCredentialEvents = function _AirService_subscribeToCredentialEvents() {
+    __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").messages$.subscribe(async (message) => {
+        switch (message.type) {
+            case AirCredentialMessageTypes.CREDENTIAL_IFRAME_VISIBILITY_REQUEST: {
+                __classPrivateFieldGet(this, _AirService_credentialIframeController, "f").setIframeVisibility(message.payload.visible);
+                __classPrivateFieldGet(this, _AirService_credentialIframeController, "f").updateIframeState();
+                break;
+            }
+        }
+    });
+}, _AirService_cleanUpCredential = async function _AirService_cleanUpCredential() {
+    if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+        return;
+    const credentialIframeElement = __classPrivateFieldGet(this, _AirService_credentialIframeController, "f")?.iframeElement;
+    if (isElement(credentialIframeElement) &&
+        window.document.body.contains(credentialIframeElement)) {
+        await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").logout();
+        __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");
-    if (!this.isLoggedIn && !option?.skipWalletLogin)
-        throw new Error("User not logged in");
     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"))
@@ -3129,6 +3147,9 @@ async function _AirService_ensureWallet(option) {
         await __classPrivateFieldGet(this, _AirService_airWalletProvider, "f").startEventMessageListening(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
         const walletInitPromise = __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").onInitialized();
         await walletInitRequestPromise;
+        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;