@mocanetwork/airkit 1.2.0-beta.2 → 1.2.0-beta.3

package/dist/types/airWalletProvider.d.ts

@@ -1,13 +1,11 @@
 import { EIP1193EventMap, EIP1193Provider } from "./common/provider/types";
 import { AirWalletInitializedResult } from "./interfaces";
-import { IframeController } from "./iframeController";
 declare class AirWalletProvider implements EIP1193Provider {
     #private;
     chainId: string;
-    constructor({ isLoggedIn, ensureWallet, getWalletIframeController, }: {
+    constructor({ isLoggedIn, ensureWallet, }: {
         isLoggedIn: () => boolean;
         ensureWallet: () => Promise<AirWalletInitializedResult>;
-        getWalletIframeController: () => IframeController;
     });
     request(request: {
         method: string;
@@ -16,6 +14,6 @@ declare class AirWalletProvider implements EIP1193Provider {
     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;
+    startEventMessageListening: (walletIframe: HTMLIFrameElement) => Promise<void>;
 }
 export default AirWalletProvider;

package/dist/types/authMessageService.d.ts

@@ -0,0 +1,17 @@
+import { AirAuthInitializationRequestMessage, AirAuthLoginRequestMessage, AirAuthMessage } from "./common/air/messaging/auth";
+import { MessageServiceBase } from "@mocanetwork/common/src/air/messaging/messageServiceBase";
+export declare class AuthMessageService extends MessageServiceBase<AirAuthMessage> {
+    #private;
+    static create(): AuthMessageService;
+    open(authIframe: HTMLIFrameElement): Promise<void>;
+    initWalletCommunication(port: MessagePort): Promise<void>;
+    sendPartnerUserInfoRequest(): Promise<import("./common/air/messaging/auth").AirAuthPartnerUserInfoResponseMessage>;
+    sendLoginRequest(payload?: AirAuthLoginRequestMessage["payload"]): Promise<import("./common/air/messaging/auth").AirAuthLoginResponseToEmbedMessage>;
+    logout(): Promise<import("./common/air/messaging/auth").AirAuthLogoutResponseMessage>;
+    resetWalletCommunication(): Promise<void>;
+    sendInitializationRequest(payload: AirAuthInitializationRequestMessage["payload"]): Promise<import("./common/air/messaging/auth").AirAuthInitializationResponseMessage>;
+    sendSetupWalletSuccessResponse(): Promise<void>;
+    sendSetupWalletErrorResponse(error: Error): Promise<void>;
+    sendCrossPartnerTokenRequest(targetPartnerUrl: string): Promise<import("./common/air/messaging/auth").AirAuthCrossPartnerTokenResponseMessage>;
+    sendPartnerAccessTokenRequest(): Promise<import("./common/air/messaging/auth").AirAuthPartnerAccessTokenResponseMessage>;
+}

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

@@ -84,7 +84,14 @@ export declare enum AirIDErrorName {
     AIR_ID_INVALID_MINT_NAME = "AIR_ID_INVALID_MINT_NAME",
     AIR_ID_MINT_TRANSACTION_HASH_MISMATCH = "AIR_ID_MINT_TRANSACTION_HASH_MISMATCH"
 }
+/*** Window Errors ***/
+export declare enum WindowErrorName {
+    WINDOW_BLOCKED = "WINDOW_BLOCKED",
+    WINDOW_CLOSED = "WINDOW_CLOSED"
+}
 export declare const Codes: {
+    WINDOW_BLOCKED: WindowErrorName.WINDOW_BLOCKED;
+    WINDOW_CLOSED: WindowErrorName.WINDOW_CLOSED;
     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;

package/dist/types/common/{realm → air}/messaging/auth.d.ts

@@ -1,5 +1,5 @@
-import { AirErrorName } from "../../air/error/types";
-import { AirIdDetails, GlobalId, MFASetup } from "../user/types";
+import { AirIdDetails, GlobalId, MFASetup } from "../../realm/user/types";
+import { AirMessageBase, AirMessageBaseWithoutPayload, AirMessageErrorPayload, AirMessageSuccessPayload } from "./types";
 export declare const AirAuthMessageTypes: {
     readonly AUTH_SETUP_COMPLETED: "air_auth_setup_completed";
     readonly INITIALIZATION_REQUEST: "air_auth_initialization_request";
@@ -30,34 +30,21 @@ export declare const AirAuthMessageTypes: {
     readonly RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication";
 };
 export type AirAuthMessageType = (typeof AirAuthMessageTypes)[keyof typeof AirAuthMessageTypes];
-type AirAuthMessageBase<TType extends AirAuthMessageType, TPayload> = {
-    type: TType;
-    payload: TPayload;
-};
-type AirAuthMessageBaseWithoutPayload<TType extends AirAuthMessageType> = {
-    type: TType;
-};
-export type AirAuthSuccess = {
-    success: true;
-};
-export type AirAuthError = {
-    success: false;
-    errorName: AirErrorName;
-    errorMessage?: string;
-};
-export type AirAuthLoginSuccess = AirAuthSuccess & {
+export type AirAuthMessageBase<TType extends AirAuthMessageType, TPayload extends object> = AirMessageBase<TType, TPayload>;
+export type AirAuthMessageBaseWithoutPayload<TType extends AirAuthMessageType> = AirMessageBaseWithoutPayload<TType>;
+export type AirAuthLoginSuccess = AirMessageSuccessPayload & {
     email?: string;
     partnerAccessToken: string;
 } & GlobalId & MFASetup;
-export type AirAuthSuccessTokens = AirAuthSuccess & {
+export type AirMessageSuccessPayloadTokens = AirMessageSuccessPayload & {
     accessToken: string;
     partnerAccessToken: string;
 };
-export type AirAuthUserInfoResponsePayload = (AirAuthSuccess & GlobalId & {
+export type AirAuthUserInfoResponsePayload = (AirMessageSuccessPayload & GlobalId & {
     email?: string;
     airIds: AirIdDetails[];
-}) | AirAuthError;
-export type AirAuthPartnerUserDetailsSuccess = AirAuthSuccess & {
+}) | AirMessageErrorPayload;
+export type AirAuthPartnerUserDetailsSuccess = AirMessageSuccessPayload & {
     partnerId: string;
     partnerUserId: string;
     airId?: AirIdDetails;
@@ -65,11 +52,11 @@ export type AirAuthPartnerUserDetailsSuccess = AirAuthSuccess & {
         email?: string;
     } & MFASetup;
 };
-export type AirAuthSuccessWithAirIdAndTokens = AirAuthPartnerUserDetailsSuccess & AirAuthSuccessTokens;
-type AirAuthLoginResponseToEmbedPayload = AirAuthLoginSuccess | AirAuthError;
-type AirAuthLoginResponseToWalletPayload = AirAuthSuccessWithAirIdAndTokens | AirAuthError;
-type AirAuthRefreshTokenResponsePayload = AirAuthSuccessTokens | AirAuthError;
-type AirAuthPartnerUserInfoResponsePayload = AirAuthPartnerUserDetailsSuccess | AirAuthError;
+export type AirAuthSuccessWithAirIdAndTokens = AirAuthPartnerUserDetailsSuccess & AirMessageSuccessPayloadTokens;
+type AirAuthLoginResponseToEmbedPayload = AirAuthLoginSuccess | AirMessageErrorPayload;
+type AirAuthLoginResponseToWalletPayload = AirAuthSuccessWithAirIdAndTokens | AirMessageErrorPayload;
+type AirAuthRefreshTokenResponsePayload = AirMessageSuccessPayloadTokens | AirMessageErrorPayload;
+type AirAuthPartnerUserInfoResponsePayload = AirAuthPartnerUserDetailsSuccess | AirMessageErrorPayload;
 type AirAuthWalletTokenRequestPayload = {
     nonce: string;
     partnerId: string;
@@ -77,36 +64,38 @@ type AirAuthWalletTokenRequestPayload = {
 type AirAuthWalletTokenResponsePayload = (AirAuthPartnerUserDetailsSuccess & {
     accessToken: string;
     walletToken: string;
-}) | AirAuthError;
+}) | AirMessageErrorPayload;
 export type AirAuthInitializationSuccess = (AirAuthLoginSuccess & {
     rehydrated: true;
-}) | (AirAuthSuccess & {
+}) | (AirMessageSuccessPayload & {
     rehydrated: false;
 });
-type AirAuthInitializationResponsePayload = AirAuthInitializationSuccess | AirAuthError;
+type AirAuthInitializationResponsePayload = AirAuthInitializationSuccess | AirMessageErrorPayload;
 type AirAuthLoginRequestPayload = {
     partnerLoginToken?: string;
 };
-type AirAuthSetupWalletResponsePayload = AirAuthSuccess | AirAuthError;
+type AirAuthSetupWalletResponsePayload = AirMessageSuccessPayload | AirMessageErrorPayload;
 type AirAuthSignSiweMessageRequestPayload = {
     wallet: string;
 };
-export type AirAuthSignSiweMessageSuccessPayload = AirAuthSuccess & {
+export type AirAuthSignSiweMessageSuccessPayload = AirMessageSuccessPayload & {
     address: string;
     message: string;
     signature: string;
 };
-type AirAuthSignSiweMessageResponsePayload = AirAuthSignSiweMessageSuccessPayload | AirAuthError;
+type AirAuthSignSiweMessageResponsePayload = AirAuthSignSiweMessageSuccessPayload | AirMessageErrorPayload;
 type AirAuthCrossPartnerTokenRequestPayload = {
     targetPartnerUrl: string;
 };
-export type AirAuthCrossPartnerTokenSuccessPayload = AirAuthSuccess & {
+export type AirAuthCrossPartnerTokenSuccessPayload = AirMessageSuccessPayload & {
     urlWithToken: string;
 };
 export type AirAuthInitializationRequestPayload = {
     partnerId: string;
     partnerDAppUrl?: string;
     skipRehydration?: boolean;
+    sdkVersion: string;
+    enableLogging: boolean;
 };
 export type AirAuthInitializationRequestMessage = AirAuthMessageBase<"air_auth_initialization_request", AirAuthInitializationRequestPayload>;
 export type AirAuthInitializationResponseMessage = AirAuthMessageBase<"air_auth_initialization_response", AirAuthInitializationResponsePayload>;
@@ -115,7 +104,9 @@ export type AirAuthLoginResponseToEmbedMessage = AirAuthMessageBase<"air_auth_lo
 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 AirAuthPartnerUserInfoRequestMessage = AirAuthMessageBase<"air_auth_partner_user_info_request", {
+    allowCache?: boolean;
+}>;
 export type AirAuthPartnerUserInfoResponseMessage = AirAuthMessageBase<"air_auth_partner_user_info_response", AirAuthPartnerUserInfoResponsePayload>;
 export type AirAuthRefreshTokenRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_refresh_token_request">;
 export type AirAuthRefreshTokenResponseMessage = AirAuthMessageBase<"air_auth_refresh_token_response", AirAuthRefreshTokenResponsePayload>;
@@ -128,7 +119,7 @@ export type AirAuthSetupWalletResponseMessage = AirAuthMessageBase<"air_auth_set
 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 AirAuthCrossPartnerTokenResponseMessage = AirAuthMessageBase<"air_auth_cross_partner_token_response", AirAuthCrossPartnerTokenSuccessPayload | AirMessageErrorPayload>;
 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">;
@@ -136,9 +127,9 @@ export type AirAuthIframeVisibilityRequestMessage = AirAuthMessageBase<"air_auth
     visible: boolean;
 }>;
 export type AirAuthPartnerAccessTokenRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_partner_access_token_request">;
-export type AirAuthPartnerAccessTokenResponsePayload = (AirAuthSuccess & {
+export type AirAuthPartnerAccessTokenResponsePayload = (AirMessageSuccessPayload & {
     partnerAccessToken: string;
-}) | AirAuthError;
+}) | AirMessageErrorPayload;
 export type AirAuthPartnerAccessTokenResponseMessage = AirAuthMessageBase<"air_auth_partner_access_token_response", AirAuthPartnerAccessTokenResponsePayload>;
 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 | AirAuthPartnerAccessTokenRequestMessage | AirAuthPartnerAccessTokenResponseMessage;
 export {};

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

@@ -0,0 +1,34 @@
+import { Observable } from "rxjs";
+import { AirMessageBase, AirMessageBaseWithoutPayload } from "./types";
+export declare abstract class MessageServiceBase<TMessage extends AirMessageBase | AirMessageBaseWithoutPayload> {
+    protected readonly name: string;
+    protected allowedMessageTypes: string[];
+    private eventSubject;
+    private _events$;
+    private _messages$;
+    private messagePort?;
+    private targetWindow?;
+    private targetOrigin?;
+    private closeListener;
+    get events$(): Observable<MessageEvent<TMessage>>;
+    get messages$(): Observable<TMessage>;
+    get isOpen(): boolean;
+    protected constructor(name: string, allowedMessageTypes: string[]);
+    protected _open(target: {
+        window: Window;
+        origin: string;
+    } | MessagePort): Promise<void>;
+    protected isMessageAllowed(message: TMessage): boolean;
+    protected onBeforeEvent(_event: MessageEvent<TMessage>): Promise<void>;
+    close(): Promise<void>;
+    protected createErrorResponseMessage<T extends TMessage["type"]>(type: T, error: Error): {
+        type: T;
+        payload: {
+            success: false;
+            errorName: "USER_CANCELLED" | "CONFIG_ERROR" | "CLIENT_ERROR" | "UNKNOWN_ERROR" | "PERMISSION_NOT_ENABLED" | "SMART_ACCOUNT_NOT_DEPLOYED" | 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;
+            errorMessage: string;
+        };
+    };
+    protected sendMessage(message: TMessage, transfer?: Transferable[]): Promise<void>;
+    protected deepClone(message: TMessage): TMessage;
+}

package/dist/types/common/{realm → air}/messaging/provider.d.ts

@@ -1,4 +1,4 @@
-import { EIP1193Request, EIP1193EventMap } from "../../provider/types";
+import { EIP1193EventMap, EIP1193Request } from "../../provider/types";
 export declare const enum AirWalletProviderMessageTypes {
     REQUEST = "JRPC_REQUEST",
     RESPONSE = "JRPC_RESPONSE",

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

@@ -0,0 +1,16 @@
+import { AirErrorName } from "../error/types";
+export type AirMessageBase<TType extends string = string, TPayload extends object = object> = {
+    type: TType;
+    payload: TPayload;
+};
+export type AirMessageBaseWithoutPayload<TType extends string = string> = {
+    type: TType;
+};
+export type AirMessageSuccessPayload = {
+    success: true;
+};
+export type AirMessageErrorPayload = {
+    success: false;
+    errorName: AirErrorName;
+    errorMessage?: string;
+};

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

@@ -0,0 +1,140 @@
+import type { Hex } from "viem";
+import { ActionPolicyInfo, Call } from "../../realm/smart-session/types";
+import { AirIdDetails, MFASetup } from "../../realm/user/types";
+import { AirMessageBase, AirMessageBaseWithoutPayload, AirMessageErrorPayload, AirMessageSuccessPayload } from "./types";
+export declare const AirWalletMessageTypes: {
+    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_OR_UPDATE_MFA_REQUEST: "air_setup_mfa_request";
+    readonly SETUP_OR_UPDATE_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";
+    readonly DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response";
+    readonly GRANT_PERMISSIONS_REQUEST: "air_grant_permissions_request";
+    readonly GRANT_PERMISSIONS_RESPONSE: "air_grant_permissions_response";
+    readonly EXECUTE_ACTION_REQUEST: "air_execute_action_request";
+    readonly EXECUTE_ACTION_RESPONSE: "air_execute_action_response";
+    readonly REVOKE_PERMISSIONS_REQUEST: "air_revoke_permissions_request";
+    readonly REVOKE_PERMISSIONS_RESPONSE: "air_revoke_permissions_response";
+    readonly LIST_ALL_SESSION_KEY_SCOPES_REQUEST: "air_list_all_session_key_scopes_request";
+    readonly LIST_ALL_SESSION_KEY_SCOPES_RESPONSE: "air_list_all_session_key_scopes_response";
+    readonly WALLET_IFRAME_VISIBILITY_REQUEST: "air_wallet_iframe_visibility_request";
+    readonly OPEN_WINDOW_REQUEST: "air_open_window_request";
+    readonly OPEN_WINDOW_RESPONSE: "air_open_window_response";
+    readonly OPEN_WINDOW_RETRY_REQUEST: "air_open_window_retry_request";
+    readonly OPEN_WINDOW_RETRY_RESPONSE: "air_open_window_retry_response";
+    readonly WINDOW_CLOSED: "air_window_closed";
+    readonly IS_SMART_ACCOUNT_DEPLOYED_REQUEST: "air_is_smart_account_deployed_request";
+    readonly IS_SMART_ACCOUNT_DEPLOYED_RESPONSE: "air_is_smart_account_deployed_response";
+    readonly LOGOUT_REQUEST: "air_logout_request";
+    readonly LOGOUT_RESPONSE: "air_logout_response";
+};
+export type AirWalletMessageType = (typeof AirWalletMessageTypes)[keyof typeof AirWalletMessageTypes];
+export type AirWalletMessageBase<TType extends AirWalletMessageType, TPayload extends object> = AirMessageBase<TType, TPayload>;
+export type AirWalletMessageBaseWithoutPayload<TType extends AirWalletMessageType> = AirMessageBaseWithoutPayload<TType>;
+export type AirInitializationResponsePayload = AirMessageSuccessPayload | AirMessageErrorPayload;
+export type AirInitializationRequestMessage = AirWalletMessageBase<"air_initialization_request", {
+    partnerId: string;
+    enableLogging: boolean;
+    sdkVersion: string;
+}>;
+export type AirInitializationResponseMessage = AirWalletMessageBase<"air_initialization_response", AirInitializationResponsePayload>;
+export type AirWalletInitializationSuccess = AirMessageSuccessPayload & ({
+    isWalletLoggedIn: false;
+} | ({
+    isWalletLoggedIn: true;
+    addresses: {
+        aa: string;
+    };
+} & MFASetup));
+type AirWalletInitializedPayload = AirWalletInitializationSuccess | AirMessageErrorPayload;
+export type AirWalletInitializedMessage = AirWalletMessageBase<"air_wallet_initialized", AirWalletInitializedPayload>;
+export type AirWalletLoginRequestMessage = AirWalletMessageBaseWithoutPayload<"air_wallet_login_request">;
+export type AirWalletLoginSuccess = AirMessageSuccessPayload & MFASetup & {
+    addresses: {
+        aa: string;
+    };
+};
+type AirWalletLoginResponsePayload = AirWalletLoginSuccess | AirMessageErrorPayload;
+export type AirWalletLoginResponseMessage = AirWalletMessageBase<"air_wallet_login_response", AirWalletLoginResponsePayload>;
+export type AirSetupOrUpdateMfaRequestMessage = AirWalletMessageBaseWithoutPayload<"air_setup_mfa_request">;
+export type AirSetupOrUpdateMfaResponseMessage = AirWalletMessageBase<"air_setup_mfa_response", AirMessageSuccessPayload | AirMessageErrorPayload>;
+export type AirClaimIdRequestMessage = AirWalletMessageBase<"air_claim_id_request", {
+    token?: string;
+    claimInBackground?: boolean;
+}>;
+export type AirClaimIdSuccess = AirMessageSuccessPayload & {
+    airId: AirIdDetails;
+};
+export type AirClaimIdResponsePayload = AirClaimIdSuccess | AirMessageErrorPayload;
+export type AirClaimIdResponseMessage = AirWalletMessageBase<"air_claim_id_response", AirClaimIdResponsePayload>;
+export type AirInitAuthCommunicationMessage = AirWalletMessageBase<"air_init_auth_communication", {
+    skipWalletLogin: boolean;
+}>;
+export type AirIsSmartAccountDeployedResponseMessage = AirWalletMessageBase<"air_is_smart_account_deployed_response", (AirMessageSuccessPayload & {
+    isDeployed: boolean;
+}) | AirMessageErrorPayload>;
+export type AirDeploySmartAccountRequestMessage = AirWalletMessageBaseWithoutPayload<"air_deploy_smart_account_request">;
+export type AirDeploySmartAccountResponseMessage = AirWalletMessageBase<"air_deploy_smart_account_response", (AirMessageSuccessPayload & {
+    txHash: string;
+}) | AirMessageErrorPayload>;
+export type AirIsSmartAccountDeployedRequestMessage = AirWalletMessageBaseWithoutPayload<"air_is_smart_account_deployed_request">;
+export type AirGrantPermissionsRequestMessage = AirWalletMessageBase<"air_grant_permissions_request", {
+    policies: ActionPolicyInfo[];
+}>;
+export type AirGrantPermissionsResponseMessage = AirWalletMessageBase<"air_grant_permissions_response", (AirMessageSuccessPayload & {
+    sessionData: {
+        compressedSessionData: string;
+        sessionOwnerPrivateKey: string;
+        permissionIds: string[];
+    };
+}) | AirMessageErrorPayload>;
+export type AirExecuteActionRequestMessage = AirWalletMessageBase<"air_execute_action_request", {
+    sessionData: string;
+    call: Call;
+    sessionOwnerPrivateKey: `0x${string}`;
+}>;
+export type AirRevokePermissionsRequestMessage = AirWalletMessageBase<"air_revoke_permissions_request", {
+    permissionId: Hex;
+}>;
+export type AirRevokePermissionsResponseMessage = AirWalletMessageBase<"air_revoke_permissions_response", (AirMessageSuccessPayload & {
+    txHash: string;
+}) | AirMessageErrorPayload>;
+export type AirExecuteActionResponseMessage = AirWalletMessageBase<"air_execute_action_response", (AirMessageSuccessPayload & {
+    txHash: string;
+}) | AirMessageErrorPayload>;
+export type AirListAllSessionKeyScopesSuccess = {
+    success: true;
+    sessionKeyScopes: ActionPolicyInfo[];
+};
+export type AirListAllSessionKeyScopesRequestMessage = AirWalletMessageBaseWithoutPayload<"air_list_all_session_key_scopes_request">;
+export type AirListAllSessionKeyScopesResponseMessage = AirWalletMessageBase<"air_list_all_session_key_scopes_response", AirListAllSessionKeyScopesSuccess | AirMessageErrorPayload>;
+export type AirWalletIframeVisibilityRequestMessage = AirWalletMessageBase<"air_wallet_iframe_visibility_request", {
+    visible: boolean;
+}>;
+export type AirLogoutRequestMessage = AirWalletMessageBaseWithoutPayload<"air_logout_request">;
+export type AirLogoutResponseMessage = AirWalletMessageBase<"air_logout_response", AirMessageSuccessPayload | AirMessageErrorPayload>;
+export type AirOpenWindowRequestMessage = AirWalletMessageBase<"air_open_window_request", {
+    url: string;
+    windowId: string;
+}>;
+export type AirOpenWindowResponseMessage = AirWalletMessageBase<"air_open_window_response", (AirMessageSuccessPayload | AirMessageErrorPayload) & {
+    windowId: string;
+}>;
+export type AirOpenWindowRetryRequestMessage = AirWalletMessageBase<"air_open_window_retry_request", {
+    windowId: string;
+}>;
+export type AirOpenWindowRetryResponseMessage = AirWalletMessageBase<"air_open_window_retry_response", (AirMessageSuccessPayload | AirMessageErrorPayload) & {
+    windowId: string;
+}>;
+export type AirWindowClosedMessage = AirWalletMessageBase<"air_window_closed", {
+    windowId: string;
+}>;
+export type AirWalletMessage = AirInitializationRequestMessage | AirInitializationResponseMessage | AirWalletInitializedMessage | AirWalletLoginRequestMessage | AirWalletLoginResponseMessage | AirSetupOrUpdateMfaRequestMessage | AirSetupOrUpdateMfaResponseMessage | AirClaimIdRequestMessage | AirClaimIdResponseMessage | AirInitAuthCommunicationMessage | AirIsSmartAccountDeployedRequestMessage | AirIsSmartAccountDeployedResponseMessage | AirDeploySmartAccountRequestMessage | AirDeploySmartAccountResponseMessage | AirGrantPermissionsRequestMessage | AirGrantPermissionsResponseMessage | AirRevokePermissionsRequestMessage | AirRevokePermissionsResponseMessage | AirExecuteActionRequestMessage | AirExecuteActionResponseMessage | AirListAllSessionKeyScopesRequestMessage | AirListAllSessionKeyScopesResponseMessage | AirWalletIframeVisibilityRequestMessage | AirLogoutRequestMessage | AirLogoutResponseMessage | AirOpenWindowRequestMessage | AirOpenWindowResponseMessage | AirOpenWindowRetryRequestMessage | AirOpenWindowRetryResponseMessage | AirWindowClosedMessage;
+export {};

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

@@ -0,0 +1,2 @@
+import { Environment } from "./types";
+export declare const configureLogLevel: (environment: Environment, enableLogging: boolean) => void;

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

@@ -1,3 +1,4 @@
+export type Environment = "development" | "staging" | "uat" | "production";
 export type Jsonable = string | number | boolean | null | undefined | readonly Jsonable[] | {
     readonly [key: string]: Jsonable;
 } | {

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

@@ -19,3 +19,9 @@ export declare const setPartnerTheme: (theme: string, partnerId: string, configA
  */
 export declare const randomId: () => string;
 export declare const bigIntReplacer: (_key: string, value: unknown) => unknown;
+/**
+ * Creates a window features string for `window.open`, based on the current screen size.
+ * It tries to center the window and limits the size to the given max width and height.
+ * Slightly reduces the size to avoid browser auto-resizing.
+ */
+export declare const getWindowFeatures: (maxWidth: number, maxHeight: number) => string;

package/dist/types/{windowController.d.ts → common/window/windowController.d.ts}

@@ -6,14 +6,19 @@ export declare class WindowController {
     private windowOrigin;
     private windowId;
     private _messages$;
-    get messages$(): import("rxjs").Observable<MessageEvent<any>>;
-    constructor(windowUrl: string, windowId: string);
+    get messages$(): import("rxjs").Observable<MessageEvent<unknown>>;
+    constructor(windowId: string, windowUrl: string);
     get windowInstance(): Window | null;
-    openWindow(): Window;
+    openWindow(onRetry: () => Promise<void>): Promise<{
+        pendingWindowOpenCheck: Promise<"opened" | "retry">;
+    }>;
     postMessage(message: unknown, transfer?: Transferable[]): void;
     onMessage(callback: (event: MessageEvent) => void): {
         close: () => void;
     };
     cleanup(): void;
     onClose(callback: () => void): Subscription;
+    private isWindowOpen;
+    private tryOpenWindow;
+    private scheduleWindowClosedChecks;
 }

package/dist/types/error.d.ts

@@ -4,9 +4,10 @@ type AirServiceErrorName = AirErrorName | "NOT_INITIALISED" | "ALREADY_INITIALIS
 export declare class AirServiceError extends BaseError<AirServiceErrorName> {
     static from(error: unknown): AirServiceError;
 }
-declare class ProviderRpcError extends Error {
+export declare class ProviderRpcError extends Error {
     code: number;
     name: string;
+    metaMessages: string[];
     constructor(message: string);
 }
 export declare class UserRejectedRequestError extends ProviderRpcError {
@@ -36,6 +37,7 @@ export declare class SwitchChainError extends ProviderRpcError {
 export declare class TransactionRejectedRpcError extends ProviderRpcError {
     code: number;
     name: string;
+    constructor(message: string);
 }
 export declare class InvalidRequestRpcError extends ProviderRpcError {
     code: number;

package/dist/types/interfaces.d.ts

@@ -1,4 +1,3 @@
-import { LogLevelDesc } from "loglevel";
 import { AirIdDetails } from "./common/realm/user/types";
 import { EIP1193Provider as EIP1193ProviderInterface } from "./common/provider/types";
 export declare const BUILD_ENV: {
@@ -11,7 +10,6 @@ export type BUILD_ENV_TYPE = (typeof BUILD_ENV)[keyof typeof BUILD_ENV];
 export interface AirUrlConfig {
     authUrl: string;
     walletUrl: string;
-    logLevel: LogLevelDesc;
 }
 export type AirInitializationResult = {
     rehydrated: boolean;

package/dist/types/providerMessageService.d.ts

@@ -0,0 +1,8 @@
+import { MessageServiceBase } from "./common/air/messaging/messageServiceBase";
+import { AirWalletProviderMessage, AirWalletProviderMessageRequest } from "./common/air/messaging/provider";
+export declare class ProviderMessageService extends MessageServiceBase<AirWalletProviderMessage> {
+    #private;
+    static create(): ProviderMessageService;
+    open(walletIframe: HTMLIFrameElement): Promise<void>;
+    sendWalletProviderRequest(payload: AirWalletProviderMessageRequest["payload"]): Promise<import("./common/air/messaging/provider").AirWalletProviderMessageSuccessResponse | import("./common/air/messaging/provider").AirWalletProviderMessageErrorResponse>;
+}

package/dist/types/utils.d.ts

@@ -2,6 +2,6 @@ import { AirUrlConfig, BUILD_ENV_TYPE } from "./interfaces";
 export declare const AIR_URLS: Record<BUILD_ENV_TYPE, AirUrlConfig>;
 export declare const handleEvent: (handle: EventTarget, eventName: string, handler: (...args: unknown[]) => void, ...handlerArgs: unknown[]) => void;
 export declare const htmlToElement: <T extends Element>(html: string) => T;
-export declare const isElement: (element: unknown) => element is Document | Element;
+export declare const isElement: (element: unknown) => element is Element | Document;
 export declare const randomId: () => string;
-export declare const getWindowFeatures: (width: number, height: number) => string;
+export declare const extractErrorHash: (message: string) => string;

package/dist/types/walletMessageService.d.ts

@@ -0,0 +1,35 @@
+import type { Hex } from "viem";
+import { AirClaimIdRequestMessage, AirGrantPermissionsRequestMessage, AirInitializationRequestMessage, AirWalletMessage } from "./common/air/messaging/wallet";
+import type { ActionPolicyInfo, Call } from "./common/realm/smart-session/types";
+import { MessageServiceBase } from "./common/air/messaging/messageServiceBase";
+export declare class WalletMessageService extends MessageServiceBase<AirWalletMessage> {
+    #private;
+    static create(): WalletMessageService;
+    open(walletIframe: HTMLIFrameElement): Promise<void>;
+    initAuthCommunication(skipWalletLogin: boolean, port: MessagePort): Promise<void>;
+    sendGrantPermissionRequest(policies: ActionPolicyInfo[]): Promise<{
+        compressedSessionData: string;
+        sessionOwnerPrivateKey: string;
+        permissionIds: string[];
+    }>;
+    sendExecuteActionRequest(params: {
+        sessionData: string;
+        sessionOwnerPrivateKey: `0x${string}`;
+        call: Call;
+    }): Promise<string>;
+    sendRevokePermissionsRequest(permissionId: Hex): Promise<string>;
+    sendDeploySmartAccountRequest(): Promise<import("./common/air/messaging/wallet").AirDeploySmartAccountResponseMessage>;
+    sendIsSmartAccountDeployedRequest(): Promise<import("./common/air/messaging/wallet").AirIsSmartAccountDeployedResponseMessage>;
+    logout(): Promise<import("./common/air/messaging/wallet").AirLogoutResponseMessage>;
+    sendInitializationRequest(payload: AirInitializationRequestMessage["payload"]): Promise<import("./common/air/messaging/wallet").AirInitializationResponseMessage>;
+    sendGrantPermissionsRequest(payload: AirGrantPermissionsRequestMessage["payload"]): Promise<import("./common/air/messaging/wallet").AirGrantPermissionsResponseMessage>;
+    sendListAllSessionKeyScopesRequest(): Promise<import("./common/air/messaging/wallet").AirListAllSessionKeyScopesResponseMessage>;
+    onInitialized(): Promise<import("./common/air/messaging/wallet").AirWalletInitializedMessage>;
+    sendLoginRequest(): Promise<import("./common/air/messaging/wallet").AirWalletLoginResponseMessage>;
+    sendSetupMfaRequest(): Promise<import("./common/air/messaging/wallet").AirSetupOrUpdateMfaResponseMessage>;
+    sendOpenWindowSuccessResponse(windowId: string, port: MessagePort): Promise<void>;
+    sendOpenWindowErrorResponse(windowId: string, error: Error): Promise<void>;
+    sendOpenWindowRetryRequest(windowId: string): Promise<import("./common/air/messaging/wallet").AirOpenWindowRetryResponseMessage>;
+    sendWindowClosed(windowId: string): Promise<void>;
+    sendClaimIdRequest(payload: AirClaimIdRequestMessage["payload"]): Promise<import("./common/air/messaging/wallet").AirClaimIdResponseMessage>;
+}

package/dist/types/windowService.d.ts

@@ -1,16 +1,19 @@
-import { WindowController } from "./windowController";
+import { WindowController } from "./common/window/windowController";
 declare class WindowService {
     private static _instance;
     static get instance(): WindowService;
     private windowControllers;
     private sendWindowInitializationRequest;
-    openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, port, }: {
+    openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, onRetry, }: {
         url: string;
         windowId: string;
         partnerId: string;
         enableLogging: boolean;
+        onRetry: () => Promise<void>;
+    }): Promise<{
+        windowController: WindowController;
         port: MessagePort;
-    }): Promise<WindowController>;
+    }>;
     getWindowController(windowId: string): WindowController;
     removeWindowController(windowId: string): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mocanetwork/airkit",
-  "version": "1.2.0-beta.2",
+  "version": "1.2.0-beta.3",
   "description": "Air kit to interact with the Moca Network",
   "main": "dist/airkit.cjs.js",
   "module": "dist/airkit.esm.js",