@mocanetwork/airkit 1.8.0 → 1.9.0-beta.1

package/dist/airkit.umd.js

@@ -101,7 +101,7 @@
       return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
-    var version = "1.8.0";
+    var version = "1.9.0-beta.1";
     var airkitPackage = {
     	version: version};
 
@@ -129,6 +129,8 @@
       SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_response",
       SETUP_RECOVERY_REQUEST: "air_auth_setup_recovery_request",
       SETUP_RECOVERY_RESPONSE: "air_auth_setup_recovery_response",
+      SETUP_CREDENTIAL_REQUEST: "air_auth_setup_credential_request",
+      SETUP_CREDENTIAL_RESPONSE: "air_auth_setup_credential_response",
       SIGN_SIWE_MESSAGE_REQUEST: "air_auth_sign_siwe_message_request",
       SIGN_SIWE_MESSAGE_RESPONSE: "air_auth_sign_siwe_message_response",
       CROSS_PARTNER_TOKEN_REQUEST: "air_auth_cross_partner_token_request",
@@ -141,6 +143,8 @@
       START_RECOVERY_RESPONSE: "air_start_recovery_response",
       RECOVERY_REQUEST: "air_auth_recovery_request",
       RECOVERY_RESPONSE: "air_auth_recovery_response",
+      ISSUE_ON_BEHALF_NEW_USER_CONFIRMATION_REQUEST: "air_auth_issue_on_behalf_new_user_confirmation_request",
+      ISSUE_ON_BEHALF_NEW_USER_CONFIRMATION_RESPONSE: "air_auth_issue_on_behalf_new_user_confirmation_response",
       EXPIRED_LOGOUT_REQUEST: "air_auth_expired_logout_request"
     };
 
@@ -153,12 +157,16 @@
       UPDATE_SESSION_CONFIG_RESPONSE: "air_credential_update_session_config_response",
       LOGOUT_REQUEST: "air_credential_logout_request",
       LOGOUT_RESPONSE: "air_credential_logout_response",
+      CLOSE_MODAL_REQUEST: "air_credential_close_modal_request",
+      CLOSE_MODAL_RESPONSE: "air_credential_close_modal_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"
+      VERIFY_CREDENTIAL_RESPONSE: "air_credential_verify_response",
+      ISSUE_ON_BEHALF_NEW_USER_CONFIRMATION_REQUEST: "air_credential_issue_on_behalf_new_user_confirmation_request",
+      ISSUE_ON_BEHALF_NEW_USER_CONFIRMATION_RESPONSE: "air_credential_issue_on_behalf_new_user_confirmation_response"
     };
 
     const AirRecoveryMessageTypes = {
@@ -177,8 +185,8 @@
       SERVICE_STARTED: "air_service_started",
       INITIALIZATION_REQUEST: "air_initialization_request",
       INITIALIZATION_RESPONSE: "air_initialization_response",
-      CLOSE_MODAL_REQUEST: "air_close_modal_request",
-      CLOSE_MODAL_RESPONSE: "air_close_modal_response",
+      CLOSE_MODAL_REQUEST: "air_wallet_close_modal_request",
+      CLOSE_MODAL_RESPONSE: "air_wallet_close_modal_response",
       WALLET_INITIALIZED: "air_wallet_initialized",
       UPDATE_SESSION_CONFIG_REQUEST: "air_wallet_update_session_config_request",
       UPDATE_SESSION_CONFIG_RESPONSE: "air_wallet_update_session_config_response",
@@ -192,6 +200,10 @@
       SHOW_SWAP_UI_RESPONSE: "air_show_swap_ui_response",
       SHOW_ON_RAMP_UI_REQUEST: "air_show_on_ramp_ui_request",
       SHOW_ON_RAMP_UI_RESPONSE: "air_show_on_ramp_ui_response",
+      SHOW_TRANSFER_UI_REQUEST: "air_show_transfer_ui_request",
+      SHOW_TRANSFER_UI_RESPONSE: "air_show_transfer_ui_response",
+      SHOW_RECEIVE_UI_REQUEST: "air_show_receive_ui_request",
+      SHOW_RECEIVE_UI_RESPONSE: "air_show_receive_ui_response",
       DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
       DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response",
       WALLET_IFRAME_VISIBILITY_REQUEST: "air_wallet_iframe_visibility_request",
@@ -200,7 +212,11 @@
       LOGOUT_REQUEST: "air_logout_request",
       LOGOUT_RESPONSE: "air_logout_response",
       INTERNAL_PROVIDER_REQUEST: "air_internal_provider_request",
-      INTERNAL_PROVIDER_RESPONSE: "air_internal_provider_response"
+      INTERNAL_PROVIDER_RESPONSE: "air_internal_provider_response",
+      ADDITIONAL_SIGNER_SIGNATURE_REQUEST: "air_additional_signer_signature_request",
+      ADDITIONAL_SIGNER_SIGNATURE_RESPONSE: "air_additional_signer_signature_response",
+      REMOVE_SIGNER_SIGNATURE_REQUEST: "air_remove_signer_signature_request",
+      REMOVE_SIGNER_SIGNATURE_RESPONSE: "air_remove_signer_signature_response"
     };
 
     const AirWindowMessageTypes = {
@@ -653,6 +669,34 @@
       },
       testnet: true
     };
+    const mocaMainnet = {
+      id: 2288,
+      name: "Moca Mainnet",
+      nativeCurrency: {
+        decimals: 18,
+        name: "Moca Network",
+        symbol: "MOCA"
+      },
+      rpcUrls: {
+        default: {
+          http: ["https://rpc.mocachain.org"],
+          webSocket: ["wss://rpc.mocachain.org/ws"]
+        }
+      },
+      blockExplorers: {
+        default: {
+          name: "Moca Mainnet",
+          url: "https://scan.mocachain.org"
+        } // TODO: need to confirm mainnet explorer
+      },
+      contracts: {
+        multicall3: {
+          address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+          blockCreated: 3668598
+        }
+      },
+      testnet: false
+    };
 
     const BUILD_ENV = {
         PRODUCTION: "production",
@@ -1814,7 +1858,7 @@
       ...WindowErrorName
     };
 
-    const AirClientUserErrors = ["USER_CANCELLED", "CONFIG_ERROR", "CLIENT_ERROR", "UNKNOWN_ERROR", "PERMISSION_NOT_ENABLED", "SMART_ACCOUNT_NOT_DEPLOYED", "ACCOUNT_DELETION_PENDING"];
+    const AirClientUserErrors = ["USER_CANCELLED", "CONFIG_ERROR", "CLIENT_ERROR", "UNKNOWN_ERROR", "PERMISSION_NOT_ENABLED", "SMART_ACCOUNT_NOT_DEPLOYED", "ACCOUNT_DELETION_PENDING", "SWAP_TO_ONRAMP", "USER_REJECTED"];
 
     class AirError extends BaseError {}
     new Set(AirClientUserErrors);
@@ -2082,6 +2126,7 @@
         AirAuthMessageTypes.LOGIN_RESPONSE,
         AirAuthMessageTypes.SETUP_WALLET_REQUEST,
         AirAuthMessageTypes.SETUP_RECOVERY_REQUEST,
+        AirAuthMessageTypes.SETUP_CREDENTIAL_REQUEST,
         AirAuthMessageTypes.LOGOUT_RESPONSE,
         AirAuthMessageTypes.UPDATE_SESSION_CONFIG_RESPONSE,
         AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
@@ -2161,6 +2206,15 @@
                 },
             });
         }
+        async sendSetupCredentialSuccessResponse() {
+            await this.sendMessage({
+                type: AirAuthMessageTypes.SETUP_CREDENTIAL_RESPONSE,
+                payload: { success: true },
+            });
+        }
+        async sendSetupCredentialErrorResponse(error) {
+            await this.sendMessage(this.createErrorResponseMessage(AirAuthMessageTypes.SETUP_CREDENTIAL_RESPONSE, error));
+        }
         async sendCrossPartnerTokenRequest(targetPartnerUrl) {
             const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE)));
             await this.sendMessage({
@@ -2284,6 +2338,8 @@
                 "publickey-credentials-create *",
                 "ch-ua-model",
                 "ch-ua-platform-version",
+                "clipboard-write",
+                "web-share"
             ].join("; ");
             iframe.src = this.iframeUrl;
             iframe.style.position = "fixed";
@@ -2394,6 +2450,8 @@
         AirWalletMessageTypes.SETUP_OR_UPDATE_MFA_RESPONSE,
         AirWalletMessageTypes.SHOW_SWAP_UI_RESPONSE,
         AirWalletMessageTypes.SHOW_ON_RAMP_UI_RESPONSE,
+        AirWalletMessageTypes.SHOW_TRANSFER_UI_RESPONSE,
+        AirWalletMessageTypes.SHOW_RECEIVE_UI_RESPONSE,
         AirWalletMessageTypes.CLAIM_ID_RESPONSE,
         AirWalletMessageTypes.IS_SMART_ACCOUNT_DEPLOYED_RESPONSE,
         AirWalletMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE,
@@ -2518,6 +2576,26 @@
             });
             return response;
         }
+        async sendShowTransferUIRequest(payload) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.SHOW_TRANSFER_UI_RESPONSE)));
+            await this.sendMessage({
+                type: AirWalletMessageTypes.SHOW_TRANSFER_UI_REQUEST,
+                payload: {
+                    tokenSymbol: payload?.tokenSymbol,
+                    chainId: payload?.chainId,
+                    recipientAddress: payload?.recipientAddress,
+                    amount: payload?.amount,
+                },
+            });
+            return response;
+        }
+        async sendShowReceiveUIRequest() {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirWalletMessageTypes.SHOW_RECEIVE_UI_RESPONSE)));
+            await this.sendMessage({
+                type: AirWalletMessageTypes.SHOW_RECEIVE_UI_REQUEST,
+            });
+            return response;
+        }
     }
     _a = WalletMessageService;
     _WalletMessageService_instance = { value: void 0 };
@@ -2784,7 +2862,7 @@
             return localStorage.getItem("automation") === "true" && __classPrivateFieldGet(this, _AirService_buildEnv, "f") !== BUILD_ENV.PRODUCTION;
         }
         async init(config) {
-            const { buildEnv = BUILD_ENV.PRODUCTION, enableLogging = false, skipRehydration = false, sessionConfig = undefined, preloadWallet = false, preloadCredential = false, credentialNetwork = "testnet", } = config;
+            const { buildEnv = BUILD_ENV.PRODUCTION, enableLogging = false, skipRehydration = false, sessionConfig = undefined, preloadWallet = false, preloadCredential = false, credentialNetwork = "devnet", } = config;
             if (!__classPrivateFieldGet(this, _AirService_partnerId, "f"))
                 throw new AirServiceError("CLIENT_ERROR", "Partner ID is required to initialize the service");
             if (__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
@@ -2839,6 +2917,18 @@
                             }
                             break;
                         }
+                        case AirAuthMessageTypes.SETUP_CREDENTIAL_REQUEST: {
+                            try {
+                                await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, { skipWalletLogin: true });
+                                await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureCredential).call(this);
+                                await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendSetupCredentialSuccessResponse();
+                            }
+                            catch (err) {
+                                const error = ensureError(err);
+                                await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendSetupCredentialErrorResponse(error);
+                            }
+                            break;
+                        }
                         case AirAuthMessageTypes.EXPIRED_LOGOUT_REQUEST: {
                             await this.logout();
                             break;
@@ -2900,6 +2990,10 @@
             });
             if (payload.success === true) {
                 __classPrivateFieldSet(this, _AirService_loginResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createLoginResult).call(this, payload), "f");
+                if (payload.needsWalletRestart === true) {
+                    await Promise.all([__classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this), __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpCredential).call(this)]);
+                    void __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureCredential).call(this);
+                }
                 __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedIn).call(this);
                 return __classPrivateFieldGet(this, _AirService_loginResult, "f");
             }
@@ -2977,6 +3071,37 @@
                 throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
             }
         }
+        /**
+         * @experimental This feature has not been officially released and might change in the future.
+         */
+        async showTransferUI(options) {
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            const result = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendShowTransferUIRequest(options);
+            if (result.payload.success === false) {
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+            }
+            return {
+                txHash: result.payload.txHash,
+                symbol: result.payload.symbol,
+                chainId: result.payload.chainId,
+                decimals: result.payload.decimals,
+                address: result.payload.address,
+                recipientAddress: result.payload.recipientAddress,
+                amount: result.payload.amount
+            };
+        }
+        /**
+         * @experimental This feature has not been officially released and might change in the future.
+         */
+        async showReceiveUI() {
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            const result = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendShowReceiveUIRequest();
+            if (result.payload.success === false) {
+                if (result.payload.errorName === "USER_CANCELLED")
+                    return;
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+            }
+        }
         async getUserInfo() {
             __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_assertLoggedIn).call(this);
             const info = await __classPrivateFieldGet(this, _AirService_authMessagingService, "f").sendPartnerUserInfoRequest();
@@ -3086,7 +3211,7 @@
         async preloadCredential() {
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureCredential).call(this);
         }
-        async issueCredential({ authToken, issuerDid, credentialId, credentialSubject, curve, }) {
+        async issueCredential({ authToken, issuerDid, credentialId, credentialSubject, curve, offchain, }) {
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureCredential).call(this);
             const response = await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").sendIssueCredentialRequest({
                 partnerToken: authToken,
@@ -3094,6 +3219,7 @@
                 credentialId,
                 credentialSubject,
                 curve,
+                offchain,
             });
             const { payload } = response;
             if (payload.closeDApp) {
@@ -3106,12 +3232,14 @@
                 cakPublicKey: payload.cakPublicKey,
             };
         }
-        async verifyCredential({ authToken, programId, redirectUrl, }) {
+        async verifyCredential({ authToken, programId, redirectUrl, requestDisclosure, offchain, }) {
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureCredential).call(this);
             const { payload } = await __classPrivateFieldGet(this, _AirService_credentialMessagingService, "f").sendVerifyCredentialRequest({
                 partnerToken: authToken,
                 programId,
                 redirectUrl,
+                requestDisclosure,
+                offchain,
             });
             if (payload.success === false) {
                 throw new AirServiceError(payload.errorName, payload.errorMessage);
@@ -3253,6 +3381,7 @@
                         const { payload } = await __classPrivateFieldGet(this, _AirService_walletMessagingService, "f").sendInitializationRequest({
                             sessionId: __classPrivateFieldGet(this, _AirService_sessionId, "f"),
                             partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
+                            partnerDAppUrl: window.location.href,
                             enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
                             sdkVersion: airKitVersion,
                             enableAutomation: this.shouldEnableAutomation(),
@@ -3430,6 +3559,7 @@
                         const { payload } = await __classPrivateFieldGet(this, _AirService_recoveryMessagingService, "f").sendInitializationRequest({
                             sessionId: __classPrivateFieldGet(this, _AirService_sessionId, "f"),
                             partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
+                            partnerDAppUrl: window.location.href,
                             enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
                             sdkVersion: airKitVersion,
                             enableAutomation: this.shouldEnableAutomation(),
@@ -3503,6 +3633,7 @@
     exports.UserRejectedRequestError = UserRejectedRequestError;
     exports.ensureProviderRpcError = ensureProviderRpcError;
     exports.mocaDevnet = mocaDevnet;
+    exports.mocaMainnet = mocaMainnet;
     exports.mocaTestnet = mocaTestnet;
 
 }));

package/dist/types/airService.d.ts

@@ -1,6 +1,6 @@
 import { AirAuthStartRecoveryRequestPayload } from "@mocanetwork/common/src/air/messaging/auth";
-import { AirEventListener, AirLoginResult, AirSessionConfig, AirUserDetails, BUILD_ENV, BUILD_ENV_TYPE, ClaimAirIdOptions, ClaimAirIdResult, CredentialNetwork, CredentialVerificationResult, EIP1193Provider, ShowSwapUIOptions } from "./interfaces";
 import { Token } from "@mocanetwork/common/src/types";
+import { AirEventListener, AirLoginResult, AirSessionConfig, AirUserDetails, BUILD_ENV, BUILD_ENV_TYPE, ClaimAirIdOptions, ClaimAirIdResult, CredentialNetwork, CredentialVerificationResult, EIP1193Provider, ShowSwapUIOptions, ShowTransferUIOptions, ShowTransferUIResult } from "./interfaces";
 declare class AirService {
     #private;
     constructor({ partnerId }: {
@@ -65,6 +65,14 @@ declare class AirService {
         displayCurrencyCode: string;
         targetCurrencyCode?: string;
     }): Promise<void>;
+    /**
+     * @experimental This feature has not been officially released and might change in the future.
+     */
+    showTransferUI(options?: ShowTransferUIOptions): Promise<ShowTransferUIResult>;
+    /**
+     * @experimental This feature has not been officially released and might change in the future.
+     */
+    showReceiveUI(): Promise<void>;
     getUserInfo(): Promise<AirUserDetails>;
     updateSessionConfig(config: Partial<AirSessionConfig>): Promise<AirSessionConfig>;
     goToPartner(partnerUrl: string): Promise<{
@@ -79,19 +87,22 @@ declare class AirService {
     on(listener: AirEventListener): void;
     off(listener: AirEventListener): void;
     preloadCredential(): Promise<void>;
-    issueCredential({ authToken, issuerDid, credentialId, credentialSubject, curve, }: {
+    issueCredential({ authToken, issuerDid, credentialId, credentialSubject, curve, offchain, }: {
         authToken: string;
         issuerDid: string;
         credentialId: string;
         credentialSubject: Record<string, unknown>;
         curve?: "secp256r1" | "secp256k1";
+        offchain?: boolean;
     }): Promise<{
         cakPublicKey?: string;
     }>;
-    verifyCredential({ authToken, programId, redirectUrl, }: {
+    verifyCredential({ authToken, programId, redirectUrl, requestDisclosure, offchain, }: {
         authToken: string;
         programId: string;
         redirectUrl?: string;
+        requestDisclosure?: boolean;
+        offchain?: boolean;
     }): Promise<CredentialVerificationResult>;
 }
 export default AirService;

package/dist/types/authMessageService.d.ts

@@ -14,6 +14,8 @@ export declare class AuthMessageService extends MessageServiceBase<AirAuthMessag
     sendSetupWalletErrorResponse(error: Error): Promise<void>;
     sendSetupRecoverySuccessResponse(): Promise<void>;
     sendSetupRecoveryErrorResponse(error: Error): Promise<void>;
+    sendSetupCredentialSuccessResponse(): Promise<void>;
+    sendSetupCredentialErrorResponse(error: Error): Promise<void>;
     sendCrossPartnerTokenRequest(targetPartnerUrl: string): Promise<import("./common/air/messaging/auth").AirAuthCrossPartnerTokenResponseMessage>;
     sendPartnerAccessTokenRequest(): Promise<import("./common/air/messaging/auth").AirAuthPartnerAccessTokenResponseMessage>;
     sendAccountRecoveryRequest(payload: AirAuthStartRecoveryRequestPayload): Promise<import("./common/air/messaging/auth").AirStartRecoveryResponseMessage>;

package/dist/types/common/air/error/types.d.ts

@@ -1,3 +1,3 @@
 import { Codes } from "./codes";
-export declare const AirClientUserErrors: readonly ["USER_CANCELLED", "CONFIG_ERROR", "CLIENT_ERROR", "UNKNOWN_ERROR", "PERMISSION_NOT_ENABLED", "SMART_ACCOUNT_NOT_DEPLOYED", "ACCOUNT_DELETION_PENDING"];
+export declare const AirClientUserErrors: readonly ["USER_CANCELLED", "CONFIG_ERROR", "CLIENT_ERROR", "UNKNOWN_ERROR", "PERMISSION_NOT_ENABLED", "SMART_ACCOUNT_NOT_DEPLOYED", "ACCOUNT_DELETION_PENDING", "SWAP_TO_ONRAMP", "USER_REJECTED"];
 export type AirErrorName = (typeof AirClientUserErrors)[number] | (typeof Codes)[keyof typeof Codes];

package/dist/types/common/air/messaging/auth.d.ts

@@ -25,6 +25,8 @@ export declare const AirAuthMessageTypes: {
     readonly SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_response";
     readonly SETUP_RECOVERY_REQUEST: "air_auth_setup_recovery_request";
     readonly SETUP_RECOVERY_RESPONSE: "air_auth_setup_recovery_response";
+    readonly SETUP_CREDENTIAL_REQUEST: "air_auth_setup_credential_request";
+    readonly SETUP_CREDENTIAL_RESPONSE: "air_auth_setup_credential_response";
     readonly SIGN_SIWE_MESSAGE_REQUEST: "air_auth_sign_siwe_message_request";
     readonly SIGN_SIWE_MESSAGE_RESPONSE: "air_auth_sign_siwe_message_response";
     readonly CROSS_PARTNER_TOKEN_REQUEST: "air_auth_cross_partner_token_request";
@@ -37,6 +39,8 @@ export declare const AirAuthMessageTypes: {
     readonly START_RECOVERY_RESPONSE: "air_start_recovery_response";
     readonly RECOVERY_REQUEST: "air_auth_recovery_request";
     readonly RECOVERY_RESPONSE: "air_auth_recovery_response";
+    readonly ISSUE_ON_BEHALF_NEW_USER_CONFIRMATION_REQUEST: "air_auth_issue_on_behalf_new_user_confirmation_request";
+    readonly ISSUE_ON_BEHALF_NEW_USER_CONFIRMATION_RESPONSE: "air_auth_issue_on_behalf_new_user_confirmation_response";
     readonly EXPIRED_LOGOUT_REQUEST: "air_auth_expired_logout_request";
 };
 export type AirAuthMessageType = (typeof AirAuthMessageTypes)[keyof typeof AirAuthMessageTypes];
@@ -60,10 +64,14 @@ export type AirAuthPartnerUserDetailsSuccess = AirMessageSuccessPayload & {
     airId?: AirIdDetails;
     user: GlobalId & {
         email?: string;
+        credentialSignerAvailable: boolean;
+        issueOnBehalfApproved?: boolean;
     } & MFASetup & CredentialConfigResponse;
 };
 export type AirAuthSuccessWithAirIdAndTokens = AirAuthPartnerUserDetailsSuccess & AirMessageSuccessPayloadTokens;
-type AirAuthLoginResponseToEmbedPayload = AirAuthLoginSuccess | AirMessageErrorPayload;
+type AirAuthLoginResponseToEmbedPayload = AirAuthLoginSuccess & {
+    needsWalletRestart?: boolean;
+} | AirMessageErrorPayload;
 type AirAuthLoginResponseToAirServicePayload = AirAuthSuccessWithAirIdAndTokens | AirMessageErrorPayload;
 export type AirAuthLoginServiceStatusResponsePayload = ({
     isUserLoggedIn: false;
@@ -167,6 +175,9 @@ export type AirAuthStartRecoveryRequestPayload = {
 };
 export type AirStartRecoveryRequestMessage = AirAuthMessageBase<"air_start_recovery_request", AirAuthStartRecoveryRequestPayload>;
 export type AirStartRecoveryResponseMessage = AirAuthMessageBase<"air_start_recovery_response", AirMessageSuccessPayload | AirMessageErrorPayload>;
+export type AirAuthSetupCredentialResponsePayload = AirMessageSuccessPayload | AirMessageErrorPayload;
+export type AirAuthSetupCredentialRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_setup_credential_request">;
+export type AirAuthSetupCredentialResponseMessage = AirAuthMessageBase<"air_auth_setup_credential_response", AirAuthSetupCredentialResponsePayload>;
 export type UpdateEmailCompletePayloadParam = {
     privyAccessToken?: string;
     intentId?: string;
@@ -199,5 +210,9 @@ export type AirAuthRecoverySuccessPayload = AirMessageSuccessPayload & {
 };
 export type AirAuthRecoveryResponseMessage = AirAuthMessageBase<"air_auth_recovery_response", AirAuthRecoverySuccessPayload | AirMessageErrorPayload>;
 export type AirAuthExpiredLogoutRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_expired_logout_request">;
-export type AirAuthMessage = AirAuthSetupCompletedMessage | AirAuthInitializationRequestMessage | AirAuthInitializationResponseMessage | AirAuthLoginRequestMessage | AirAuthLoginResponseToEmbedMessage | AirAuthLoginResponseToAirServiceMessage | AirAuthLoginStatusRequestMessage | AirAuthLoginStatusResponseMessage | AirAuthUpdateSessionConfigRequestMessage | AirAuthUpdateSessionConfigResponseMessage | AirAuthUserInfoRequestMessage | AirAuthUserInfoResponseMessage | AirAuthPartnerUserInfoRequestMessage | AirAuthPartnerUserInfoResponseMessage | AirAuthRefreshTokenRequestMessage | AirAuthRefreshTokenResponseMessage | AirAuthWalletTokenRequestMessage | AirAuthWalletTokenResponseMessage | AirAuthSetupWalletRequestMessage | AirAuthSetupWalletResponseMessage | AirAuthSignSiweMessageRequestMessage | AirAuthSignSiweMessageResponseMessage | AirAuthCrossPartnerTokenRequestMessage | AirAuthCrossPartnerTokenResponseMessage | AirAuthLogoutRequestMessage | AirAuthLogoutResponseMessage | AirAuthIframeVisibilityRequestMessage | AirAuthPartnerAccessTokenRequestMessage | AirAuthPartnerAccessTokenResponseMessage | AirAuthSetupRecoveryRequestMessage | AirAuthSetupRecoveryResponseMessage | AirStartRecoveryRequestMessage | AirStartRecoveryResponseMessage | AirAuthRecoveryRequestMessage | AirAuthRecoveryResponseMessage | AirAuthExpiredLogoutRequestMessage;
+export type AirAuthIssueOnBehalfNewUserConfirmationRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_issue_on_behalf_new_user_confirmation_request">;
+export type AirAuthIssueOnBehalfNewUserConfirmationResponseMessage = AirAuthMessageBase<"air_auth_issue_on_behalf_new_user_confirmation_response", AirMessageSuccessPayload & {
+    needsWalletRestart: boolean;
+} | AirMessageErrorPayload>;
+export type AirAuthMessage = AirAuthSetupCompletedMessage | AirAuthInitializationRequestMessage | AirAuthInitializationResponseMessage | AirAuthLoginRequestMessage | AirAuthLoginResponseToEmbedMessage | AirAuthLoginResponseToAirServiceMessage | AirAuthLoginStatusRequestMessage | AirAuthLoginStatusResponseMessage | AirAuthUpdateSessionConfigRequestMessage | AirAuthUpdateSessionConfigResponseMessage | AirAuthUserInfoRequestMessage | AirAuthUserInfoResponseMessage | AirAuthPartnerUserInfoRequestMessage | AirAuthPartnerUserInfoResponseMessage | AirAuthRefreshTokenRequestMessage | AirAuthRefreshTokenResponseMessage | AirAuthWalletTokenRequestMessage | AirAuthWalletTokenResponseMessage | AirAuthSetupWalletRequestMessage | AirAuthSetupWalletResponseMessage | AirAuthSignSiweMessageRequestMessage | AirAuthSignSiweMessageResponseMessage | AirAuthCrossPartnerTokenRequestMessage | AirAuthCrossPartnerTokenResponseMessage | AirAuthLogoutRequestMessage | AirAuthLogoutResponseMessage | AirAuthIframeVisibilityRequestMessage | AirAuthPartnerAccessTokenRequestMessage | AirAuthPartnerAccessTokenResponseMessage | AirAuthSetupRecoveryRequestMessage | AirAuthSetupRecoveryResponseMessage | AirStartRecoveryRequestMessage | AirStartRecoveryResponseMessage | AirAuthRecoveryRequestMessage | AirAuthRecoveryResponseMessage | AirAuthExpiredLogoutRequestMessage | AirAuthSetupCredentialRequestMessage | AirAuthSetupCredentialResponseMessage | AirAuthIssueOnBehalfNewUserConfirmationRequestMessage | AirAuthIssueOnBehalfNewUserConfirmationResponseMessage;
 export {};

package/dist/types/common/air/messaging/credential.d.ts

@@ -8,10 +8,14 @@ export declare const AirCredentialMessageTypes: {
     readonly UPDATE_SESSION_CONFIG_RESPONSE: "air_credential_update_session_config_response";
     readonly LOGOUT_REQUEST: "air_credential_logout_request";
     readonly LOGOUT_RESPONSE: "air_credential_logout_response";
+    readonly CLOSE_MODAL_REQUEST: "air_credential_close_modal_request";
+    readonly CLOSE_MODAL_RESPONSE: "air_credential_close_modal_response";
     readonly ISSUE_CREDENTIAL_REQUEST: "air_credential_issue_request";
     readonly VERIFY_CREDENTIAL_REQUEST: "air_credential_verify_request";
     readonly ISSUE_CREDENTIAL_RESPONSE: "air_credential_issue_response";
     readonly VERIFY_CREDENTIAL_RESPONSE: "air_credential_verify_response";
+    readonly ISSUE_ON_BEHALF_NEW_USER_CONFIRMATION_REQUEST: "air_credential_issue_on_behalf_new_user_confirmation_request";
+    readonly ISSUE_ON_BEHALF_NEW_USER_CONFIRMATION_RESPONSE: "air_credential_issue_on_behalf_new_user_confirmation_response";
 };
 export type AirCredentialMessageType = (typeof AirCredentialMessageTypes)[keyof typeof AirCredentialMessageTypes];
 export type AirCredentialMessageBase<TType extends AirCredentialMessageType, TPayload extends object> = AirMessageBase<TType, TPayload>;
@@ -38,17 +42,29 @@ export type AirCredentialUpdateSessionConfigRequestMessage = AirCredentialMessag
 export type AirCredentialUpdateSessionConfigResponseMessage = AirCredentialMessageBase<"air_credential_update_session_config_response", (AirMessageSuccessPayload & SessionConfig) | AirMessageErrorPayload>;
 export type AirLogoutRequestMessage = AirCredentialMessageBaseWithoutPayload<"air_credential_logout_request">;
 export type AirLogoutResponseMessage = AirCredentialMessageBase<"air_credential_logout_response", AirMessageSuccessPayload | AirMessageErrorPayload>;
+export type AirCloseModalRequestMessage = AirCredentialMessageBaseWithoutPayload<"air_credential_close_modal_request">;
+export type AirCloseModalResponseMessage = AirCredentialMessageBase<"air_credential_close_modal_response", AirMessageSuccessPayload | AirMessageErrorPayload>;
 export type AirIssueCredentialRequestMessage = AirCredentialMessageBase<"air_credential_issue_request", {
     partnerToken: string;
     issuerDid: string;
     credentialId: string;
     credentialSubject: Record<string, unknown>;
     curve?: "secp256r1" | "secp256k1";
+    /** When true, credential is stored offchain only (OSS, no blockchain). Status = STORED. */
+    offchain?: boolean;
 }>;
 export type AirVerifyCredentialRequestMessage = AirCredentialMessageBase<"air_credential_verify_request", {
     partnerToken: string;
     programId: string;
     redirectUrl?: string;
+    /**
+     * When true, the verifier requests full disclosure of credential data.
+     * The user will be prompted to consent and sign a message authorizing disclosure.
+     * If the user consents, the disclosed data will be included in the verification response.
+     */
+    requestDisclosure?: boolean;
+    /** When true, verification skips ZKP and on-chain proof, using offchain flow instead. Works with both ONCHAIN and STORED credentials. */
+    offchain?: boolean;
 }>;
 export type AirIssueCredentialResponseMessage = AirCredentialMessageBase<"air_credential_issue_response", ((AirMessageSuccessPayload & {
     result: Record<string, unknown>;
@@ -56,6 +72,58 @@ export type AirIssueCredentialResponseMessage = AirCredentialMessageBase<"air_cr
 }) | AirMessageErrorPayload) & {
     closeDApp?: boolean;
 }>;
+/**
+ * Credential proof data containing the issuer's signature.
+ * This allows verifiers to validate that the credential data has not been tampered with.
+ */
+export type CredentialProof = {
+    /** The type of proof (e.g., "BJJSignature2021", "Iden3SparseMerkleTreeProof") */
+    type: string;
+    /** The core claim in hex format - can be used to verify the credential on-chain */
+    coreClaim?: string;
+    /** Issuer data including state and authentication information */
+    issuerData?: {
+        id: string;
+        state?: {
+            claimsTreeRoot?: string;
+            revocationTreeRoot?: string;
+            rootOfRoots?: string;
+            value?: string;
+        };
+        authCoreClaim?: string;
+        credentialStatus?: {
+            id: string;
+            type: string;
+            revocationNonce?: number;
+        };
+    };
+    /** The signature value (format depends on proof type) */
+    signature?: string;
+    /** Merkle tree proof data if applicable */
+    mtp?: Record<string, unknown>;
+};
+/**
+ * Disclosed credential data returned during verification.
+ * This is the decrypted credential subject data that the user has consented to share.
+ * Includes proof data for verifiers to validate the credential's authenticity.
+ */
+export type DisclosedCredentialData = {
+    /** The credential subject data (e.g., KYC data, age verification, etc.) */
+    credentialSubject: Record<string, unknown>;
+    /** The schema/type of the credential */
+    credentialType: string;
+    /** The issuer DID that issued this credential */
+    issuerDid: string;
+    /** When the credential was issued */
+    issuanceDate: string;
+    /** When the credential expires */
+    expirationDate: string;
+    /**
+     * The credential proof containing the issuer's signature.
+     * Verifiers can use this to validate that the credential data has not been modified.
+     */
+    proof?: CredentialProof[];
+};
 export type AirVerifyCredentialSuccessResponsePayload = {
     verificationResult: {
         status: "Non-Compliant" | "Pending" | "Revoking" | "Revoked" | "Expired" | "NotFound";
@@ -64,8 +132,10 @@ export type AirVerifyCredentialSuccessResponsePayload = {
         zkProofs: Record<string, string>;
         transactionHash: string;
         cakPrivateKey?: string;
+        /** Disclosed credential data - only present when full disclosure is enabled */
+        disclosedData?: DisclosedCredentialData;
     };
 } & AirMessageSuccessPayload;
 export type AirVerifyCredentialResponseMessage = AirCredentialMessageBase<"air_credential_verify_response", AirVerifyCredentialSuccessResponsePayload | AirMessageErrorPayload>;
-export type AirCredentialMessage = AirInitializationRequestMessage | AirInitializationResponseMessage | AirCredentialIframeVisibilityRequestMessage | AirCredentialUpdateSessionConfigRequestMessage | AirCredentialUpdateSessionConfigResponseMessage | AirLogoutRequestMessage | AirLogoutResponseMessage | AirIssueCredentialRequestMessage | AirVerifyCredentialRequestMessage | AirIssueCredentialResponseMessage | AirVerifyCredentialResponseMessage;
+export type AirCredentialMessage = AirInitializationRequestMessage | AirInitializationResponseMessage | AirCredentialIframeVisibilityRequestMessage | AirCredentialUpdateSessionConfigRequestMessage | AirCredentialUpdateSessionConfigResponseMessage | AirLogoutRequestMessage | AirLogoutResponseMessage | AirCloseModalRequestMessage | AirCloseModalResponseMessage | AirIssueCredentialRequestMessage | AirVerifyCredentialRequestMessage | AirIssueCredentialResponseMessage | AirVerifyCredentialResponseMessage;
 export {};

package/dist/types/common/air/messaging/messageServiceBase.d.ts

@@ -27,7 +27,7 @@ export declare abstract class MessageServiceBase<TMessage extends AirMessageBase
         type: T;
         payload: {
             success: false;
-            errorName: "USER_CANCELLED" | "CONFIG_ERROR" | "CLIENT_ERROR" | "UNKNOWN_ERROR" | "PERMISSION_NOT_ENABLED" | "SMART_ACCOUNT_NOT_DEPLOYED" | "ACCOUNT_DELETION_PENDING" | import("../error/codes").AuthErrorName | import("../error/codes").PartnerAccessTokenErrorName | import("../error/codes").RealmIDErrorName | import("../error/codes").ParameterErrorName | import("../error/codes").ServerErrorName | import("../error/codes").PasskeyErrorName | import("../error/codes").PasswordlessErrorName | import("../error/codes").AuthWalletErrorName | import("../error/codes").WalletLinkErrorName | import("../error/codes").IntentErrorName | import("../error/codes").PrivyErrorName | import("../error/codes").AirIDErrorName | import("../error/codes").WindowErrorName;
+            errorName: import("../error/codes").AuthErrorName | import("../error/codes").PartnerAccessTokenErrorName | import("../error/codes").RealmIDErrorName | import("../error/codes").ParameterErrorName | import("../error/codes").ServerErrorName | import("../error/codes").PasskeyErrorName | import("../error/codes").PasswordlessErrorName | import("../error/codes").AuthWalletErrorName | import("../error/codes").WalletLinkErrorName | import("../error/codes").IntentErrorName | import("../error/codes").PrivyErrorName | import("../error/codes").AirIDErrorName | import("../error/codes").WindowErrorName | "USER_CANCELLED" | "CONFIG_ERROR" | "CLIENT_ERROR" | "UNKNOWN_ERROR" | "PERMISSION_NOT_ENABLED" | "SMART_ACCOUNT_NOT_DEPLOYED" | "ACCOUNT_DELETION_PENDING" | "SWAP_TO_ONRAMP" | "USER_REJECTED";
             errorMessage: string;
         };
     };

package/dist/types/common/air/messaging/recovery.d.ts

@@ -17,6 +17,7 @@ export type AirInitializationResponsePayload = AirMessageSuccessPayload | AirMes
 export type AirInitializationRequestMessage = AirRecoveryMessageBase<"air_recovery_initialization_request", {
     sessionId: string;
     partnerId: string;
+    partnerDAppUrl?: string;
     enableLogging: boolean;
     sdkVersion: string;
     enableAutomation: boolean;