@mocanetwork/airkit 1.0.0 → 1.1.0

package/dist/types/airService.d.ts

@@ -1,7 +1,6 @@
 import { Hex } from "./common/realm/smart-session/hex";
 import { ActionPolicyInfo, Call } from "./common/realm/smart-session/types";
-import AirWalletProvider from "./airWalletProvider";
-import { AirEventListener, AirLoginResult, AirUserDetails, AirWalletInitializedResult, BUILD_ENV_TYPE, ClaimAirIdOptions, ClaimAirIdResult } from "./interfaces";
+import { AirEventListener, AirLoginResult, AirUserDetails, BUILD_ENV_TYPE, ClaimAirIdOptions, ClaimAirIdResult, EIP1193Provider } from "./interfaces";
 declare class AirService {
     #private;
     constructor({ partnerId }: {
@@ -12,12 +11,12 @@ declare class AirService {
     get isInitialized(): boolean;
     get isLoggedIn(): boolean;
     get isWalletInitialized(): boolean;
+    get provider(): EIP1193Provider;
     init({ buildEnv, enableLogging, skipRehydration, }: {
         buildEnv: BUILD_ENV_TYPE;
         enableLogging: boolean;
         skipRehydration: boolean;
     }): Promise<AirLoginResult | null>;
-    cleanUp(): Promise<void>;
     login(options?: {
         authToken?: string;
     }): Promise<AirLoginResult>;
@@ -51,14 +50,18 @@ declare class AirService {
      * @experimental This method is experimental and will change in the future.
      */
     isSmartAccountDeployed(): Promise<boolean>;
-    logout(): Promise<void>;
-    getProvider(): Promise<AirWalletProvider>;
-    preloadWallet(): Promise<AirWalletInitializedResult>;
+    getProvider(): EIP1193Provider;
+    preloadWallet(): Promise<void>;
+    setupOrUpdateMfa(): Promise<void>;
     claimAirId(options?: ClaimAirIdOptions): Promise<ClaimAirIdResult>;
     getUserInfo(): Promise<AirUserDetails>;
+    goToPartner(partnerUrl: string): Promise<{
+        urlWithToken: string;
+    }>;
+    logout(): Promise<void>;
+    cleanUp(): Promise<void>;
     on(listener: AirEventListener): void;
     off(listener: AirEventListener): void;
     clearEventListeners(): void;
-    private _showWalletWidget;
 }
 export default AirService;

package/dist/types/airWalletProvider.d.ts

@@ -1,13 +1,21 @@
 import { EIP1193EventMap, EIP1193Provider } from "@mocanetwork/common/src/provider/types";
+import { AirWalletInitializedResult } from "./interfaces";
+import { IframeController } from "./iframeController";
 declare class AirWalletProvider implements EIP1193Provider {
     #private;
     chainId: string;
-    constructor(walletIframe: HTMLIFrameElement);
+    constructor({ isLoggedIn, ensureWallet, getWalletIframeController, }: {
+        isLoggedIn: () => boolean;
+        ensureWallet: () => Promise<AirWalletInitializedResult>;
+        getWalletIframeController: () => IframeController;
+    });
     request(request: {
         method: string;
         params?: unknown[];
     }): Promise<unknown>;
-    on<EventName extends keyof EIP1193EventMap>(eventName: EventName, listener: EIP1193EventMap[EventName]): void;
-    removeListener<EventName extends keyof EIP1193EventMap>(eventName: EventName, listener: EIP1193EventMap[EventName]): void;
+    on<T extends keyof EIP1193EventMap>(eventName: T, listener: EIP1193EventMap[T]): void;
+    removeListener<T extends keyof EIP1193EventMap>(eventName: T, listener: EIP1193EventMap[T]): void;
+    removeAllListeners(): void;
+    startEventMessageListening: () => void;
 }
 export default AirWalletProvider;

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

@@ -0,0 +1,138 @@
+/*** Authentication Errors ***/
+export declare enum AuthErrorName {
+    UNAUTHORIZED = "UNAUTHORIZED",
+    INVALID_TOKEN = "INVALID_TOKEN",
+    TOKEN_EXPIRED = "TOKEN_EXPIRED",
+    INVALID_CREDENTIALS = "INVALID_CREDENTIALS"
+}
+/*** Partner Access Token Errors ***/
+export declare enum PartnerAccessTokenErrorName {
+    PARTNER_ACCESS_TOKEN_INVALID = "PARTNER_ACCESS_TOKEN_INVALID",
+    USER_MISMATCH = "USER_MISMATCH"
+}
+/*** Realm ID Errors ***/
+export declare enum RealmIDErrorName {
+    REALM_ID_NOT_FOUND = "REALM_ID_NOT_FOUND",
+    REALM_ID_INVALID_NAME = "REALM_ID_INVALID_NAME",
+    REALM_ID_ALREADY_EXISTS = "REALM_ID_ALREADY_EXISTS",
+    REALM_ID_DUPLICATE_PARTNER_USER = "REALM_ID_DUPLICATE_PARTNER_USER"
+}
+/*** Parameter Errors ***/
+export declare enum ParameterErrorName {
+    INVALID_PARAMETER = "INVALID_PARAMETER"
+}
+/*** Server Errors ***/
+export declare enum ServerErrorName {
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
+}
+/*** Passkey Errors ***/
+export declare enum PasskeyErrorName {
+    PASSKEY_REGISTRATION_FAILED = "PASSKEY_REGISTRATION_FAILED",
+    PASSKEY_AUTHENTICATION_FAILED = "PASSKEY_AUTHENTICATION_FAILED",
+    PASSKEY_LIMIT_EXCEEDED = "PASSKEY_LIMIT_EXCEEDED",
+    PASSKEY_NOT_FOUND = "PASSKEY_NOT_FOUND",
+    PASSKEY_UNAUTHORIZED = "PASSKEY_UNAUTHORIZED",
+    PASSKEY_CHALLENGE_INVALID = "PASSKEY_CHALLENGE_INVALID"
+}
+/*** Passwordless Authentication Errors ***/
+export declare enum PasswordlessErrorName {
+    PASSWORDLESS_CODE_EXPIRED = "PASSWORDLESS_CODE_EXPIRED",
+    PASSWORDLESS_INVALID_CODE = "PASSWORDLESS_INVALID_CODE",
+    PASSWORDLESS_MAX_ATTEMPTS = "PASSWORDLESS_MAX_ATTEMPTS",
+    PASSWORDLESS_HOURLY_LIMIT = "PASSWORDLESS_HOURLY_LIMIT",
+    PASSWORDLESS_LOCK_EXCEEDED = "PASSWORDLESS_LOCK_EXCEEDED"
+}
+/*** Authentication Wallet Errors ***/
+export declare enum AuthWalletErrorName {
+    AUTH_WALLET_LOCK_EXCEEDED = "AUTH_WALLET_LOCK_EXCEEDED",
+    AUTH_WALLET_NONCE_EXPIRED_OR_INVALID = "AUTH_WALLET_NONCE_EXPIRED_OR_INVALID",
+    AUTH_WALLET_ADDRESS_MISMATCH = "AUTH_WALLET_ADDRESS_MISMATCH",
+    AUTH_WALLET_SIGNATURE_VERIFICATION_FAILED = "AUTH_WALLET_SIGNATURE_VERIFICATION_FAILED"
+}
+/*** Wallet Linking Errors ***/
+export declare enum WalletLinkErrorName {
+    LINK_WALLET_ALREADY_LINKED = "LINK_WALLET_ALREADY_LINKED",
+    LINK_WALLET_LINKED_OTHER_ACCOUNT = "LINK_WALLET_LINKED_OTHER_ACCOUNT",
+    LINK_EMAIL_LINKED_OTHER_ACCOUNT = "LINK_EMAIL_LINKED_OTHER_ACCOUNT"
+}
+/*** Intent Errors ***/
+export declare enum IntentErrorName {
+    INTENT_INVALID = "INTENT_INVALID",
+    INTENT_LOCK_EXCEEDED = "INTENT_LOCK_EXCEEDED",
+    INTENT_REQUIRED = "INTENT_REQUIRED",
+    INTENT_UNSUPPORTED_TYPE = "INTENT_UNSUPPORTED_TYPE"
+}
+/*** Privy Errors ***/
+export declare enum PrivyErrorName {
+    WALLET_PROVIDER_ERROR = "WALLET_PROVIDER_ERROR"
+}
+/*** Air ID Errors ***/
+export declare enum AirIDErrorName {
+    AIR_ID_MINT_TRANSACTION_NOT_FOUND = "AIR_ID_MINT_TRANSACTION_NOT_FOUND",
+    AIR_ID_ON_CHAIN_TRANSACTION_NOT_FOUND = "AIR_ID_ON_CHAIN_TRANSACTION_NOT_FOUND",
+    AIR_ID_NOT_FOUND = "AIR_ID_NOT_FOUND",
+    AIR_ID_INVALID_OR_DISABLED_CONFIGURATION = "AIR_ID_INVALID_OR_DISABLED_CONFIGURATION",
+    AIR_ID_RPC_URL_NOT_CONFIGURED = "AIR_ID_RPC_URL_NOT_CONFIGURED",
+    AIR_ID_INVALID_STATUS = "AIR_ID_INVALID_STATUS",
+    AIR_ID_PARTNER_ELIGIBILITY_CHECK_FAILED = "AIR_ID_PARTNER_ELIGIBILITY_CHECK_FAILED",
+    AIR_ID_PARTNER_ELIGIBILITY_CHECK_TIMEOUT = "AIR_ID_PARTNER_ELIGIBILITY_CHECK_TIMEOUT",
+    AIR_ID_MULTIPLE_AIR_IDS_FOUND = "AIR_ID_MULTIPLE_AIR_IDS_FOUND",
+    AIR_ID_NAME_RESERVED = "AIR_ID_NAME_RESERVED",
+    AIR_ID_NAME_PROFANITY = "AIR_ID_NAME_PROFANITY",
+    AIR_ID_USER_ALREADY_HAS_AIR_ID = "AIR_ID_USER_ALREADY_HAS_AIR_ID",
+    AIR_ID_NAME_ALREADY_EXISTS = "AIR_ID_NAME_ALREADY_EXISTS",
+    AIR_ID_INVALID_MINT_NAME = "AIR_ID_INVALID_MINT_NAME",
+    AIR_ID_MINT_TRANSACTION_HASH_MISMATCH = "AIR_ID_MINT_TRANSACTION_HASH_MISMATCH"
+}
+export declare const Codes: {
+    AIR_ID_MINT_TRANSACTION_NOT_FOUND: AirIDErrorName.AIR_ID_MINT_TRANSACTION_NOT_FOUND;
+    AIR_ID_ON_CHAIN_TRANSACTION_NOT_FOUND: AirIDErrorName.AIR_ID_ON_CHAIN_TRANSACTION_NOT_FOUND;
+    AIR_ID_NOT_FOUND: AirIDErrorName.AIR_ID_NOT_FOUND;
+    AIR_ID_INVALID_OR_DISABLED_CONFIGURATION: AirIDErrorName.AIR_ID_INVALID_OR_DISABLED_CONFIGURATION;
+    AIR_ID_RPC_URL_NOT_CONFIGURED: AirIDErrorName.AIR_ID_RPC_URL_NOT_CONFIGURED;
+    AIR_ID_INVALID_STATUS: AirIDErrorName.AIR_ID_INVALID_STATUS;
+    AIR_ID_PARTNER_ELIGIBILITY_CHECK_FAILED: AirIDErrorName.AIR_ID_PARTNER_ELIGIBILITY_CHECK_FAILED;
+    AIR_ID_PARTNER_ELIGIBILITY_CHECK_TIMEOUT: AirIDErrorName.AIR_ID_PARTNER_ELIGIBILITY_CHECK_TIMEOUT;
+    AIR_ID_MULTIPLE_AIR_IDS_FOUND: AirIDErrorName.AIR_ID_MULTIPLE_AIR_IDS_FOUND;
+    AIR_ID_NAME_RESERVED: AirIDErrorName.AIR_ID_NAME_RESERVED;
+    AIR_ID_NAME_PROFANITY: AirIDErrorName.AIR_ID_NAME_PROFANITY;
+    AIR_ID_USER_ALREADY_HAS_AIR_ID: AirIDErrorName.AIR_ID_USER_ALREADY_HAS_AIR_ID;
+    AIR_ID_NAME_ALREADY_EXISTS: AirIDErrorName.AIR_ID_NAME_ALREADY_EXISTS;
+    AIR_ID_INVALID_MINT_NAME: AirIDErrorName.AIR_ID_INVALID_MINT_NAME;
+    AIR_ID_MINT_TRANSACTION_HASH_MISMATCH: AirIDErrorName.AIR_ID_MINT_TRANSACTION_HASH_MISMATCH;
+    WALLET_PROVIDER_ERROR: PrivyErrorName.WALLET_PROVIDER_ERROR;
+    INTENT_INVALID: IntentErrorName.INTENT_INVALID;
+    INTENT_LOCK_EXCEEDED: IntentErrorName.INTENT_LOCK_EXCEEDED;
+    INTENT_REQUIRED: IntentErrorName.INTENT_REQUIRED;
+    INTENT_UNSUPPORTED_TYPE: IntentErrorName.INTENT_UNSUPPORTED_TYPE;
+    LINK_WALLET_ALREADY_LINKED: WalletLinkErrorName.LINK_WALLET_ALREADY_LINKED;
+    LINK_WALLET_LINKED_OTHER_ACCOUNT: WalletLinkErrorName.LINK_WALLET_LINKED_OTHER_ACCOUNT;
+    LINK_EMAIL_LINKED_OTHER_ACCOUNT: WalletLinkErrorName.LINK_EMAIL_LINKED_OTHER_ACCOUNT;
+    AUTH_WALLET_LOCK_EXCEEDED: AuthWalletErrorName.AUTH_WALLET_LOCK_EXCEEDED;
+    AUTH_WALLET_NONCE_EXPIRED_OR_INVALID: AuthWalletErrorName.AUTH_WALLET_NONCE_EXPIRED_OR_INVALID;
+    AUTH_WALLET_ADDRESS_MISMATCH: AuthWalletErrorName.AUTH_WALLET_ADDRESS_MISMATCH;
+    AUTH_WALLET_SIGNATURE_VERIFICATION_FAILED: AuthWalletErrorName.AUTH_WALLET_SIGNATURE_VERIFICATION_FAILED;
+    PASSWORDLESS_CODE_EXPIRED: PasswordlessErrorName.PASSWORDLESS_CODE_EXPIRED;
+    PASSWORDLESS_INVALID_CODE: PasswordlessErrorName.PASSWORDLESS_INVALID_CODE;
+    PASSWORDLESS_MAX_ATTEMPTS: PasswordlessErrorName.PASSWORDLESS_MAX_ATTEMPTS;
+    PASSWORDLESS_HOURLY_LIMIT: PasswordlessErrorName.PASSWORDLESS_HOURLY_LIMIT;
+    PASSWORDLESS_LOCK_EXCEEDED: PasswordlessErrorName.PASSWORDLESS_LOCK_EXCEEDED;
+    PASSKEY_REGISTRATION_FAILED: PasskeyErrorName.PASSKEY_REGISTRATION_FAILED;
+    PASSKEY_AUTHENTICATION_FAILED: PasskeyErrorName.PASSKEY_AUTHENTICATION_FAILED;
+    PASSKEY_LIMIT_EXCEEDED: PasskeyErrorName.PASSKEY_LIMIT_EXCEEDED;
+    PASSKEY_NOT_FOUND: PasskeyErrorName.PASSKEY_NOT_FOUND;
+    PASSKEY_UNAUTHORIZED: PasskeyErrorName.PASSKEY_UNAUTHORIZED;
+    PASSKEY_CHALLENGE_INVALID: PasskeyErrorName.PASSKEY_CHALLENGE_INVALID;
+    INTERNAL_SERVER_ERROR: ServerErrorName.INTERNAL_SERVER_ERROR;
+    INVALID_PARAMETER: ParameterErrorName.INVALID_PARAMETER;
+    REALM_ID_NOT_FOUND: RealmIDErrorName.REALM_ID_NOT_FOUND;
+    REALM_ID_INVALID_NAME: RealmIDErrorName.REALM_ID_INVALID_NAME;
+    REALM_ID_ALREADY_EXISTS: RealmIDErrorName.REALM_ID_ALREADY_EXISTS;
+    REALM_ID_DUPLICATE_PARTNER_USER: RealmIDErrorName.REALM_ID_DUPLICATE_PARTNER_USER;
+    PARTNER_ACCESS_TOKEN_INVALID: PartnerAccessTokenErrorName.PARTNER_ACCESS_TOKEN_INVALID;
+    USER_MISMATCH: PartnerAccessTokenErrorName.USER_MISMATCH;
+    UNAUTHORIZED: AuthErrorName.UNAUTHORIZED;
+    INVALID_TOKEN: AuthErrorName.INVALID_TOKEN;
+    TOKEN_EXPIRED: AuthErrorName.TOKEN_EXPIRED;
+    INVALID_CREDENTIALS: AuthErrorName.INVALID_CREDENTIALS;
+};

package/dist/types/common/air/{error.d.ts → error/index.d.ts}

@@ -1,8 +1,9 @@
-import { BaseError } from "../error";
-export type AirErrorName = "USER_CANCELLED" | "CONFIG_ERROR" | "SERVER_ERROR" | "CLIENT_ERROR" | "UNKNOWN_ERROR" | "PERMISSION_NOT_ENABLED" | "SMART_ACCOUNT_NOT_DEPLOYED";
+import { BaseError } from "../../error";
+import { AirErrorName } from "./types";
 export declare class AirError extends BaseError<AirErrorName> {
 }
 export declare class AirHttpError extends AirError {
     readonly response: unknown;
     constructor(name: AirErrorName, message: string, response?: unknown, options?: Record<string, unknown>);
 }
+export declare const isAirErrorName: (name: string) => name is AirErrorName;

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

@@ -0,0 +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"];
+export type AirErrorName = (typeof AirClientUserErrors)[number] | (typeof Codes)[keyof typeof Codes];

package/dist/types/common/provider/types.d.ts

@@ -1,4 +1,3 @@
-import { ProviderRpcError } from "./error";
 export type ProviderConnectInfo = {
     chainId: string;
 };
@@ -6,6 +5,11 @@ export type ProviderMessage = {
     type: string;
     data: unknown;
 };
+export type ProviderRpcError = {
+    code: number;
+    name: string;
+    message: string;
+};
 export type EIP1193EventMap = {
     accountsChanged(accounts: string[]): void;
     chainChanged(chainId: string): void;
@@ -13,6 +17,7 @@ export type EIP1193EventMap = {
     disconnect(error: ProviderRpcError): void;
     message(message: ProviderMessage): void;
 };
+export type EIP1193Event = keyof EIP1193EventMap;
 export type EIP1193Request = {
     method: string;
     params?: Array<unknown> | undefined;

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

@@ -1,5 +1,5 @@
-import { AirErrorName } from "../../air/error";
-import { AirIdDetails, GlobalId } from "../user/types";
+import { AirErrorName } from "../../air/error/types";
+import { AirIdDetails, GlobalId, MFASetup } from "../user/types";
 export declare const AirAuthMessageTypes: {
     readonly AUTH_SETUP_COMPLETED: "air_auth_setup_completed";
     readonly INITIALIZATION_REQUEST: "air_auth_initialization_request";
@@ -7,6 +7,8 @@ export declare const AirAuthMessageTypes: {
     readonly LOGIN_REQUEST: "air_auth_login_request";
     readonly LOGIN_RESPONSE: "air_auth_login_response";
     readonly LOGIN_WALLET_RESPONSE: "air_auth_login_wallet_response";
+    readonly USER_INFO_REQUEST: "air_auth_user_info_request";
+    readonly USER_INFO_RESPONSE: "air_auth_user_info_response";
     readonly PARTNER_USER_INFO_REQUEST: "air_auth_partner_user_info_request";
     readonly PARTNER_USER_INFO_RESPONSE: "air_auth_partner_user_info_response";
     readonly REFRESH_TOKEN_REQUEST: "air_auth_refresh_token_request";
@@ -19,8 +21,11 @@ export declare const AirAuthMessageTypes: {
     readonly SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_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";
+    readonly CROSS_PARTNER_TOKEN_RESPONSE: "air_auth_cross_partner_token_response";
     readonly LOGOUT_REQUEST: "air_auth_logout_request";
     readonly LOGOUT_RESPONSE: "air_auth_logout_response";
+    readonly RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication";
 };
 export type AirAuthMessageType = (typeof AirAuthMessageTypes)[keyof typeof AirAuthMessageTypes];
 type AirAuthMessageBase<TType extends AirAuthMessageType, TPayload> = {
@@ -30,90 +35,84 @@ type AirAuthMessageBase<TType extends AirAuthMessageType, TPayload> = {
 type AirAuthMessageBaseWithoutPayload<TType extends AirAuthMessageType> = {
     type: TType;
 };
+export type AirAuthSuccess = {
+    success: true;
+};
 export type AirAuthError = {
     success: false;
     errorName: AirErrorName;
     errorMessage?: string;
 };
-export type AirAuthSuccess = {
-    success: true;
+export type AirAuthLoginSuccess = AirAuthSuccess & {
     email?: string;
     partnerAccessToken: string;
-} & GlobalId;
-export type AirAuthSuccessTokens = {
-    success: true;
+} & GlobalId & MFASetup;
+export type AirAuthSuccessTokens = AirAuthSuccess & {
     accessToken: string;
     partnerAccessToken: string;
 };
-export type AirAuthUserDetailsSuccess = {
-    success: true;
+export type AirAuthUserInfoResponsePayload = (AirAuthSuccess & GlobalId & {
     email?: string;
     airIds: AirIdDetails[];
-} & GlobalId;
-export type AirAuthPartnerUserDetailsSuccess = {
-    success: true;
+}) | AirAuthError;
+export type AirAuthPartnerUserDetailsSuccess = AirAuthSuccess & {
     partnerId: string;
     partnerUserId: string;
     airId?: AirIdDetails;
     user: GlobalId & {
         email?: string;
-    };
+    } & MFASetup;
 };
-export type AirAuthSuccessWithAirIdsAndTokens = AirAuthUserDetailsSuccess & AirAuthSuccessTokens;
-type AirAuthLoginResponseToEmbedPayload = AirAuthSuccess | AirAuthError;
-type AirAuthLoginResponseToWalletPayload = AirAuthSuccessWithAirIdsAndTokens | AirAuthError;
+export type AirAuthSuccessWithAirIdAndTokens = AirAuthPartnerUserDetailsSuccess & AirAuthSuccessTokens;
+type AirAuthLoginResponseToEmbedPayload = AirAuthLoginSuccess | AirAuthError;
+type AirAuthLoginResponseToWalletPayload = AirAuthSuccessWithAirIdAndTokens | AirAuthError;
 type AirAuthRefreshTokenResponsePayload = AirAuthSuccessTokens | AirAuthError;
 type AirAuthPartnerUserInfoResponsePayload = AirAuthPartnerUserDetailsSuccess | AirAuthError;
 type AirAuthWalletTokenRequestPayload = {
     nonce: string;
     partnerId: string;
 };
-type AirAuthWalletTokenResponsePayload = {
-    success: true;
+type AirAuthWalletTokenResponsePayload = (AirAuthPartnerUserDetailsSuccess & {
     accessToken: string;
     walletToken: string;
-} | AirAuthError;
-export type AirAuthInitializationSuccess = (AirAuthSuccess & {
+}) | AirAuthError;
+export type AirAuthInitializationSuccess = (AirAuthLoginSuccess & {
     rehydrated: true;
-}) | (Pick<AirAuthSuccess, "success"> & {
+}) | (AirAuthSuccess & {
     rehydrated: false;
 });
 type AirAuthInitializationResponsePayload = AirAuthInitializationSuccess | AirAuthError;
 type AirAuthLoginRequestPayload = {
     partnerLoginToken?: string;
 };
-type AirAuthSetupWalletSuccessPayload = {
-    success: true;
-};
-type AirAuthSetupWalletErrorPayload = {
-    success: false;
-    errorName: AirErrorName;
-    errorMessage: string;
-};
-type AirAuthSetupWalletResponsePayload = AirAuthSetupWalletSuccessPayload | AirAuthSetupWalletErrorPayload;
+type AirAuthSetupWalletResponsePayload = AirAuthSuccess | AirAuthError;
 type AirAuthSignSiweMessageRequestPayload = {
     wallet: string;
 };
-export type AirAuthSignSiweMessageSuccessPayload = {
-    success: true;
+export type AirAuthSignSiweMessageSuccessPayload = AirAuthSuccess & {
     address: string;
     message: string;
     signature: string;
 };
-type AirAuthSignSiweMessageErrorPayload = {
-    success: false;
-    errorName: AirErrorName;
-    errorMessage: string;
+type AirAuthSignSiweMessageResponsePayload = AirAuthSignSiweMessageSuccessPayload | AirAuthError;
+type AirAuthCrossPartnerTokenRequestPayload = {
+    targetPartnerUrl: string;
+};
+export type AirAuthCrossPartnerTokenSuccessPayload = AirAuthSuccess & {
+    urlWithToken: string;
 };
-type AirAuthSignSiweMessageResponsePayload = AirAuthSignSiweMessageSuccessPayload | AirAuthSignSiweMessageErrorPayload;
-export type AirAuthInitializationRequestMessage = AirAuthMessageBase<"air_auth_initialization_request", {
+export type AirAuthInitializationRequestPayload = {
     partnerId: string;
+    partnerDAppUrl?: string;
     skipRehydration?: boolean;
-}>;
+};
+export type AirAuthInitializationRequestMessage = AirAuthMessageBase<"air_auth_initialization_request", AirAuthInitializationRequestPayload>;
 export type AirAuthInitializationResponseMessage = AirAuthMessageBase<"air_auth_initialization_response", AirAuthInitializationResponsePayload>;
 export type AirAuthLoginRequestMessage = AirAuthMessageBase<"air_auth_login_request", AirAuthLoginRequestPayload>;
 export type AirAuthLoginResponseToEmbedMessage = AirAuthMessageBase<"air_auth_login_response", AirAuthLoginResponseToEmbedPayload>;
 export type AirAuthLoginResponseToWalletServiceMessage = AirAuthMessageBase<"air_auth_login_wallet_response", AirAuthLoginResponseToWalletPayload>;
+export type AirAuthUserInfoRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_user_info_request">;
+export type AirAuthUserInfoResponseMessage = AirAuthMessageBase<"air_auth_user_info_response", AirAuthUserInfoResponsePayload>;
 export type AirAuthPartnerUserInfoRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_partner_user_info_request">;
 export type AirAuthPartnerUserInfoResponseMessage = AirAuthMessageBase<"air_auth_partner_user_info_response", AirAuthPartnerUserInfoResponsePayload>;
 export type AirAuthRefreshTokenRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_refresh_token_request">;
@@ -126,10 +125,13 @@ export type AirAuthSetupWalletRequestMessage = AirAuthMessageBaseWithoutPayload<
 export type AirAuthSetupWalletResponseMessage = AirAuthMessageBase<"air_auth_setup_wallet_response", AirAuthSetupWalletResponsePayload>;
 export type AirAuthSignSiweMessageRequestMessage = AirAuthMessageBase<"air_auth_sign_siwe_message_request", AirAuthSignSiweMessageRequestPayload>;
 export type AirAuthSignSiweMessageResponseMessage = AirAuthMessageBase<"air_auth_sign_siwe_message_response", AirAuthSignSiweMessageResponsePayload>;
+export type AirAuthCrossPartnerTokenRequestMessage = AirAuthMessageBase<"air_auth_cross_partner_token_request", AirAuthCrossPartnerTokenRequestPayload>;
+export type AirAuthCrossPartnerTokenResponseMessage = AirAuthMessageBase<"air_auth_cross_partner_token_response", AirAuthCrossPartnerTokenSuccessPayload | AirAuthError>;
 export type AirAuthLogoutRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_logout_request">;
 export type AirAuthLogoutResponseMessage = AirAuthMessageBaseWithoutPayload<"air_auth_logout_response">;
+export type AirAuthResetWalletCommunicationRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_reset_wallet_communication">;
 export type AirAuthIframeVisibilityRequestMessage = AirAuthMessageBase<"air_auth_iframe_visibility_request", {
     visible: boolean;
 }>;
-export type AirAuthMessage = AirAuthSetupCompletedMessage | AirAuthInitializationRequestMessage | AirAuthInitializationResponseMessage | AirAuthLoginRequestMessage | AirAuthLoginResponseToEmbedMessage | AirAuthLoginResponseToWalletServiceMessage | AirAuthPartnerUserInfoRequestMessage | AirAuthPartnerUserInfoResponseMessage | AirAuthRefreshTokenRequestMessage | AirAuthRefreshTokenResponseMessage | AirAuthWalletTokenRequestMessage | AirAuthWalletTokenResponseMessage | AirAuthInitWalletCommunicationMessage | AirAuthSetupWalletRequestMessage | AirAuthSetupWalletResponseMessage | AirAuthSignSiweMessageRequestMessage | AirAuthSignSiweMessageResponseMessage | AirAuthLogoutRequestMessage | AirAuthLogoutResponseMessage | AirAuthIframeVisibilityRequestMessage;
+export type AirAuthMessage = AirAuthSetupCompletedMessage | AirAuthInitializationRequestMessage | AirAuthInitializationResponseMessage | AirAuthLoginRequestMessage | AirAuthLoginResponseToEmbedMessage | AirAuthLoginResponseToWalletServiceMessage | AirAuthUserInfoRequestMessage | AirAuthUserInfoResponseMessage | AirAuthPartnerUserInfoRequestMessage | AirAuthPartnerUserInfoResponseMessage | AirAuthRefreshTokenRequestMessage | AirAuthRefreshTokenResponseMessage | AirAuthWalletTokenRequestMessage | AirAuthWalletTokenResponseMessage | AirAuthInitWalletCommunicationMessage | AirAuthSetupWalletRequestMessage | AirAuthSetupWalletResponseMessage | AirAuthSignSiweMessageRequestMessage | AirAuthSignSiweMessageResponseMessage | AirAuthCrossPartnerTokenRequestMessage | AirAuthCrossPartnerTokenResponseMessage | AirAuthLogoutRequestMessage | AirAuthLogoutResponseMessage | AirAuthIframeVisibilityRequestMessage | AirAuthResetWalletCommunicationRequestMessage;
 export {};

package/dist/types/common/realm/messaging/provider.d.ts

@@ -1,7 +1,8 @@
-import { EIP1193Request } from "../../provider/types";
+import { EIP1193Request, EIP1193EventMap } from "../../provider/types";
 export declare const enum AirWalletProviderMessageTypes {
     REQUEST = "JRPC_REQUEST",
-    RESPONSE = "JRPC_RESPONSE"
+    RESPONSE = "JRPC_RESPONSE",
+    EVENT = "JRPC_EVENT"
 }
 export type AirWalletProviderMessageRequest = {
     type: AirWalletProviderMessageTypes.REQUEST;
@@ -29,4 +30,21 @@ export type AirWalletProviderMessageErrorResponse = {
     };
 };
 export type AirWalletProviderMessageResponse = AirWalletProviderMessageSuccessResponse | AirWalletProviderMessageErrorResponse;
-export type AirWalletProviderMessage = AirWalletProviderMessageRequest | AirWalletProviderMessageResponse;
+export type AirWalletProviderMessageBaseEvent<T extends keyof EIP1193EventMap, TPayload> = {
+    type: AirWalletProviderMessageTypes.EVENT;
+    payload: {
+        event: T;
+        data: TPayload;
+    };
+};
+export type AirWalletProviderMessageEvent = AirWalletProviderMessageBaseEvent<"accountsChanged", string[]> | AirWalletProviderMessageBaseEvent<"chainChanged", string> | AirWalletProviderMessageBaseEvent<"connect", {
+    chainId: string;
+}> | AirWalletProviderMessageBaseEvent<"disconnect", {
+    code: number;
+    name: string;
+    message: string;
+}> | AirWalletProviderMessageBaseEvent<"message", {
+    type: string;
+    data: unknown;
+}>;
+export type AirWalletProviderMessage = AirWalletProviderMessageRequest | AirWalletProviderMessageResponse | AirWalletProviderMessageEvent;

package/dist/types/common/realm/messaging/types.d.ts

@@ -1,13 +1,17 @@
 import type { Hex } from "viem";
-import { AirErrorName } from "../../air/error";
 import { ActionPolicyInfo, Call } from "../smart-session/types";
-import { AirIdDetails } from "../user/types";
+import { AirIdDetails, MFASetup } from "../user/types";
+import { AirErrorName } from "../../air/error/types";
 export declare const AirMessageTypes: {
     readonly SERVICE_STARTED: "air_service_started";
     readonly INITIALIZATION_REQUEST: "air_initialization_request";
     readonly INITIALIZATION_RESPONSE: "air_initialization_response";
     readonly INIT_AUTH_COMMUNICATION: "air_init_auth_communication";
     readonly WALLET_INITIALIZED: "air_wallet_initialized";
+    readonly WALLET_LOGIN_REQUEST: "air_wallet_login_request";
+    readonly WALLET_LOGIN_RESPONSE: "air_wallet_login_response";
+    readonly SETUP_MFA_REQUEST: "air_setup_mfa_request";
+    readonly SETUP_MFA_RESPONSE: "air_setup_mfa_response";
     readonly CLAIM_ID_REQUEST: "air_claim_id_request";
     readonly CLAIM_ID_RESPONSE: "air_claim_id_response";
     readonly DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request";
@@ -32,67 +36,70 @@ type AirMessageBase<TType extends AirMessageType, TPayload> = {
 type AirMessageBaseWithoutPayload<TType extends AirMessageType> = {
     type: TType;
 };
+type AirSuccessPayload = {
+    success: true;
+};
 type AirErrorPayload = {
     success: false;
     errorName: AirErrorName;
     errorMessage?: string;
 };
-type AirInitializationResponsePayload = {
-    success: true;
-} | AirErrorPayload;
+type AirInitializationResponsePayload = AirSuccessPayload | AirErrorPayload;
 export type AirInitializationRequestMessage = AirMessageBase<"air_initialization_request", {
     partnerId: string;
     enableLogging: boolean;
 }>;
 export type AirInitializationResponseMessage = AirMessageBase<"air_initialization_response", AirInitializationResponsePayload>;
-export type AirWalletInitializationSuccess = {
-    success: true;
+export type AirWalletInitializationSuccess = AirSuccessPayload & ({
+    isWalletLoggedIn: false;
+} | ({
+    isWalletLoggedIn: true;
     addresses: {
         aa: string;
     };
-};
+} & MFASetup));
 type AirWalletInitializedPayload = AirWalletInitializationSuccess | AirErrorPayload;
 export type AirWalletInitializedMessage = AirMessageBase<"air_wallet_initialized", AirWalletInitializedPayload>;
+export type AirWalletLoginRequestMessage = AirMessageBaseWithoutPayload<"air_wallet_login_request">;
+export type AirWalletLoginSuccess = AirSuccessPayload & MFASetup & {
+    addresses: {
+        aa: string;
+    };
+};
+type AirWalletLoginResponsePayload = AirWalletLoginSuccess | AirErrorPayload;
+export type AirWalletLoginResponseMessage = AirMessageBase<"air_wallet_login_response", AirWalletLoginResponsePayload>;
+export type AirSetupMfaRequestMessage = AirMessageBaseWithoutPayload<"air_setup_mfa_request">;
+export type AirSetupMfaResponseMessage = AirMessageBase<"air_setup_mfa_response", AirSuccessPayload | AirErrorPayload>;
 export type AirClaimIdRequestMessage = AirMessageBase<"air_claim_id_request", {
     token?: string;
     claimInBackground?: boolean;
 }>;
-export type AirClaimIdSuccess = {
-    success: true;
+export type AirClaimIdSuccess = AirSuccessPayload & {
     airId: AirIdDetails;
 };
 export type AirClaimIdResponsePayload = AirClaimIdSuccess | AirErrorPayload;
 export type AirClaimIdResponseMessage = AirMessageBase<"air_claim_id_response", AirClaimIdResponsePayload>;
-export type AirInitAuthCommunicationMessage = AirMessageBaseWithoutPayload<"air_init_auth_communication">;
-export type AirIsSmartAccountDeployedResponseMessage = AirMessageBase<"air_is_smart_account_deployed_response", {
-    success: true;
+export type AirInitAuthCommunicationMessage = AirMessageBase<"air_init_auth_communication", {
+    skipWalletLogin: boolean;
+}>;
+export type AirIsSmartAccountDeployedResponseMessage = AirMessageBase<"air_is_smart_account_deployed_response", (AirSuccessPayload & {
     isDeployed: boolean;
-} | AirErrorPayload>;
+}) | AirErrorPayload>;
 export type AirDeploySmartAccountRequestMessage = AirMessageBaseWithoutPayload<"air_deploy_smart_account_request">;
-export type AirDeploySmartAccountResponseMessage = AirMessageBase<"air_deploy_smart_account_response", {
-    success: true;
+export type AirDeploySmartAccountResponseMessage = AirMessageBase<"air_deploy_smart_account_response", (AirSuccessPayload & {
     txHash: string;
-} | {
-    success: false;
-    errorName: AirErrorName;
-    errorMessage?: string;
-}>;
+}) | AirErrorPayload>;
 export type AirIsSmartAccountDeployedRequestMessage = AirMessageBaseWithoutPayload<"air_is_smart_account_deployed_request">;
 export type AirGrantPermissionsRequestMessage = AirMessageBase<"air_grant_permissions_request", {
     policies: ActionPolicyInfo[];
 }>;
-export type AirGrantPermissionsResponseMessage = AirMessageBase<"air_grant_permissions_response", {
-    success: true;
+export type AirGrantPermissionsResponseMessage = AirMessageBase<"air_grant_permissions_response", (AirSuccessPayload & {
     sessionData: {
         compressedSessionData: string;
         sessionOwnerPrivateKey: string;
         permissionIds: string[];
     };
-} | {
-    success: false;
-    errorName: AirErrorName;
-    errorMessage?: string;
-}>;
+}) | AirErrorPayload>;
 export type AirExecuteActionRequestMessage = AirMessageBase<"air_execute_action_request", {
     sessionData: string;
     call: Call;
@@ -101,32 +108,16 @@ export type AirExecuteActionRequestMessage = AirMessageBase<"air_execute_action_
 export type AirRevokePermissionsRequestMessage = AirMessageBase<"air_revoke_permissions_request", {
     permissionId: Hex;
 }>;
-export type AirRevokePermissionsResponseMessage = AirMessageBase<"air_revoke_permissions_response", {
-    success: true;
+export type AirRevokePermissionsResponseMessage = AirMessageBase<"air_revoke_permissions_response", (AirSuccessPayload & {
     txHash: string;
-} | {
-    success: false;
-    errorName: AirErrorName;
-    errorMessage?: string;
-}>;
-export type AirExecuteActionResponseMessage = AirMessageBase<"air_execute_action_response", {
-    success: true;
+}) | AirErrorPayload>;
+export type AirExecuteActionResponseMessage = AirMessageBase<"air_execute_action_response", (AirSuccessPayload & {
     txHash: string;
-} | {
-    success: false;
-    errorName: AirErrorName;
-    errorMessage?: string;
-}>;
+}) | AirErrorPayload>;
 export type AirWalletIframeVisibilityRequestMessage = AirMessageBase<"air_wallet_iframe_visibility_request", {
     visible: boolean;
 }>;
 export type AirLogoutRequestMessage = AirMessageBaseWithoutPayload<"air_logout_request">;
-export type AirLogoutResponseMessage = AirMessageBase<"air_logout_response", {
-    success: true;
-} | {
-    success: false;
-    errorName: AirErrorName;
-    errorMessage?: string;
-}>;
-export type AirMessage = AirInitializationRequestMessage | AirInitializationResponseMessage | AirWalletInitializedMessage | AirClaimIdRequestMessage | AirClaimIdResponseMessage | AirInitAuthCommunicationMessage | AirIsSmartAccountDeployedRequestMessage | AirIsSmartAccountDeployedResponseMessage | AirDeploySmartAccountRequestMessage | AirDeploySmartAccountResponseMessage | AirGrantPermissionsRequestMessage | AirGrantPermissionsResponseMessage | AirRevokePermissionsRequestMessage | AirRevokePermissionsResponseMessage | AirExecuteActionRequestMessage | AirExecuteActionResponseMessage | AirWalletIframeVisibilityRequestMessage | AirLogoutRequestMessage | AirLogoutResponseMessage;
+export type AirLogoutResponseMessage = AirMessageBase<"air_logout_response", AirSuccessPayload | AirErrorPayload>;
+export type AirMessage = AirInitializationRequestMessage | AirInitializationResponseMessage | AirWalletInitializedMessage | AirWalletLoginRequestMessage | AirWalletLoginResponseMessage | AirSetupMfaRequestMessage | AirSetupMfaResponseMessage | AirClaimIdRequestMessage | AirClaimIdResponseMessage | AirInitAuthCommunicationMessage | AirIsSmartAccountDeployedRequestMessage | AirIsSmartAccountDeployedResponseMessage | AirDeploySmartAccountRequestMessage | AirDeploySmartAccountResponseMessage | AirGrantPermissionsRequestMessage | AirGrantPermissionsResponseMessage | AirRevokePermissionsRequestMessage | AirRevokePermissionsResponseMessage | AirExecuteActionRequestMessage | AirExecuteActionResponseMessage | AirWalletIframeVisibilityRequestMessage | AirLogoutRequestMessage | AirLogoutResponseMessage;
 export {};

package/dist/types/common/realm/partner/config.d.ts

@@ -4,36 +4,29 @@ export type RealmIdValidation = {
     maxLength: number;
 };
 export type RealmPartnerConfigStyle = {
-    hideCloseIcon?: boolean;
-    hideModalOverlay?: boolean;
     passwordlessButtonVariant?: "inline" | "standalone";
+    airLogoTheme?: "default" | "reverse" | "dark_only" | "light_only";
+    transactionDetailsExpanded?: boolean;
 };
 export declare const REALM_LOGIN_METHODS: readonly ["passwordless", "passwordlessToggle", "google", "wallet", "passkey"];
 export type RealmLoginMethod = (typeof REALM_LOGIN_METHODS)[number];
 export type RealmPartnerConfig = {
     partnerId: string;
     node: string;
-    gating: "none" | "jwt" | "invite";
-    apiUrl: string;
+    gating: "none" | "jwt";
     theme?: string;
     chainId: string;
     allowedDomains?: string[];
     publicKey?: string;
     jwksUrl?: string;
     realmIdValidation: RealmIdValidation;
-    allowConnectOnly: boolean;
-    cyberConnectAppId?: string;
     style?: RealmPartnerConfigStyle;
+    loginMethods?: RealmLoginMethod[];
     walletLoginMethods?: RealmLoginWalletId[];
-    walletSignupMethods?: RealmLoginWalletId[];
     recommendedWallets?: RealmLoginWalletId[];
     defaultLanguage?: string;
     supportedLocales?: string[];
-    localeUrls?: Record<string, string>;
     authLocaleUrls?: Record<string, string>;
     walletLocaleUrls?: Record<string, string>;
-    sessionTime?: number;
-    allowSessionIdLogin?: boolean;
-    loginMethods?: RealmLoginMethod[];
-    skipPartnerLinkingConfirmation?: boolean;
+    allowUnverifiedEmails?: boolean;
 };