@mocanetwork/airkit 1.1.0 → 1.2.0-beta.1

package/dist/airkit.umd.js

@@ -124,6 +124,8 @@
       SIGN_SIWE_MESSAGE_RESPONSE: "air_auth_sign_siwe_message_response",
       CROSS_PARTNER_TOKEN_REQUEST: "air_auth_cross_partner_token_request",
       CROSS_PARTNER_TOKEN_RESPONSE: "air_auth_cross_partner_token_response",
+      GET_PARTNER_ACCESS_TOKEN_REQUEST: "air_auth_get_partner_access_token_request",
+      GET_PARTNER_ACCESS_TOKEN_RESPONSE: "air_auth_get_partner_access_token_response",
       LOGOUT_REQUEST: "air_auth_logout_request",
       LOGOUT_RESPONSE: "air_auth_logout_response",
       RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication"
@@ -149,7 +151,12 @@
       EXECUTE_ACTION_RESPONSE: "air_execute_action_response",
       REVOKE_PERMISSIONS_REQUEST: "air_revoke_permissions_request",
       REVOKE_PERMISSIONS_RESPONSE: "air_revoke_permissions_response",
+      LIST_ALL_SESSION_KEY_SCOPES_REQUEST: "air_list_all_session_key_scopes_request",
+      LIST_ALL_SESSION_KEY_SCOPES_RESPONSE: "air_list_all_session_key_scopes_response",
       WALLET_IFRAME_VISIBILITY_REQUEST: "air_wallet_iframe_visibility_request",
+      OPEN_WINDOW_REQUEST: "air_open_window_request",
+      OPEN_WINDOW_RESPONSE: "air_open_window_response",
+      WINDOW_CLOSED: "air_window_closed",
       IS_SMART_ACCOUNT_DEPLOYED_REQUEST: "air_is_smart_account_deployed_request",
       IS_SMART_ACCOUNT_DEPLOYED_RESPONSE: "air_is_smart_account_deployed_response",
       LOGOUT_REQUEST: "air_logout_request",
@@ -177,6 +184,16 @@
         };
       }
     }
+    function ensureError(value) {
+      if (value instanceof Error) return value;
+      let stringified = "[Unable to stringify the thrown value]";
+      try {
+        stringified = JSON.stringify(value);
+      } catch {
+        // ignoring failed stringify
+      }
+      return new Error(`This value was not thrown as type Error: ${stringified}`);
+    }
 
     class AirServiceError extends BaseError {
         static from(error) {
@@ -1380,9 +1397,11 @@
         AirMessageTypes.EXECUTE_ACTION_RESPONSE,
         AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE,
         AirMessageTypes.GRANT_PERMISSIONS_RESPONSE,
+        AirMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_RESPONSE,
         AirMessageTypes.WALLET_INITIALIZED,
         AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST,
         AirMessageTypes.LOGOUT_RESPONSE,
+        AirMessageTypes.OPEN_WINDOW_REQUEST,
     ];
     const AUTH_MESSAGES = [
         AirAuthMessageTypes.INITIALIZATION_RESPONSE,
@@ -1392,6 +1411,7 @@
         AirAuthMessageTypes.LOGOUT_RESPONSE,
         AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
         AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE,
+        AirAuthMessageTypes.GET_PARTNER_ACCESS_TOKEN_RESPONSE,
         AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
     ];
     class AirMessageService {
@@ -1605,6 +1625,12 @@
             walletIframe.contentWindow.postMessage({ type: AirMessageTypes.GRANT_PERMISSIONS_REQUEST, payload }, origin);
             return response;
         }
+        async sendListAllSessionKeyScopesRequest(walletIframe) {
+            const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_RESPONSE)));
+            const { origin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({ type: AirMessageTypes.LIST_ALL_SESSION_KEY_SCOPES_REQUEST }, origin);
+            return response;
+        }
         onWalletInitialized() {
             return firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.WALLET_INITIALIZED)));
         }
@@ -1620,6 +1646,37 @@
             walletIframe.contentWindow.postMessage({ type: AirMessageTypes.SETUP_MFA_REQUEST }, origin);
             return response;
         }
+        sendOpenWindowSuccessResponse(walletIframe, windowId, port) {
+            const { origin: walletOrigin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.OPEN_WINDOW_RESPONSE,
+                payload: {
+                    success: true,
+                    windowId,
+                },
+            }, walletOrigin, [port]);
+        }
+        sendOpenWindowErrorResponse(walletIframe, windowId, error) {
+            const { origin: walletOrigin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.OPEN_WINDOW_RESPONSE,
+                payload: {
+                    success: false,
+                    windowId,
+                    errorName: "UNKNOWN_ERROR",
+                    errorMessage: error.message,
+                },
+            }, walletOrigin);
+        }
+        sendWindowClosed(walletIframe, windowId) {
+            const { origin: walletOrigin } = new URL(walletIframe.src);
+            walletIframe.contentWindow.postMessage({
+                type: AirMessageTypes.WINDOW_CLOSED,
+                payload: {
+                    windowId,
+                },
+            }, walletOrigin);
+        }
         async sendClaimIdRequest(walletIframe, payload) {
             const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.CLAIM_ID_RESPONSE)));
             const { origin } = new URL(walletIframe.src);
@@ -1666,11 +1723,18 @@
             this._providerMessage$ = new Subject();
             this._providerEvent$ = new Subject();
         }
+        async sendGetPartnerAccessTokenRequest(authIframe) {
+            const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.GET_PARTNER_ACCESS_TOKEN_RESPONSE)));
+            const { origin } = new URL(authIframe.src);
+            authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.GET_PARTNER_ACCESS_TOKEN_REQUEST }, origin);
+            return response;
+        }
     }
     var AirMessageService$1 = AirMessageService.instance;
 
     const BUILD_ENV = {
         PRODUCTION: "production",
+        UAT: "uat",
         STAGING: "staging",
         DEVELOPMENT: "development",
     };
@@ -1681,6 +1745,11 @@
             walletUrl: "http://localhost:8200",
             logLevel: "debug",
         },
+        [BUILD_ENV.UAT]: {
+            authUrl: "https://auth.uat.air3.com",
+            walletUrl: "https://account.uat.air3.com",
+            logLevel: "info",
+        },
         [BUILD_ENV.STAGING]: {
             authUrl: "https://auth.staging.air3.com",
             walletUrl: "https://account.staging.air3.com",
@@ -1694,6 +1763,24 @@
     };
     const isElement = (element) => element instanceof Element || element instanceof Document;
     const randomId = () => Math.random().toString(36).slice(2);
+    const getWindowFeatures = (width, height) => {
+        const dualScreenLeft = window.screenLeft !== undefined ? window.screenLeft : window.screenX;
+        const dualScreenTop = window.screenTop !== undefined ? window.screenTop : window.screenY;
+        const w = window.innerWidth
+            ? window.innerWidth
+            : document.documentElement.clientWidth
+                ? document.documentElement.clientWidth
+                : window.screen.width;
+        const h = window.innerHeight
+            ? window.innerHeight
+            : document.documentElement.clientHeight
+                ? document.documentElement.clientHeight
+                : window.screen.height;
+        const systemZoom = 1; // No reliable estimate
+        const left = Math.abs((w - width) / 2 / systemZoom + dualScreenLeft);
+        const top = Math.abs((h - height) / 2 / systemZoom + dualScreenTop);
+        return `titlebar=0,toolbar=0,status=0,location=0,menubar=0,height=${height / systemZoom},width=${width / systemZoom},top=${top},left=${left}`;
+    };
 
     var _AirWalletProvider_instances, _AirWalletProvider_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_getWalletIframeController, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
     class AirWalletProvider {
@@ -1850,7 +1937,145 @@
         isVisible: false,
     };
 
-    var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_walletLoggedInResult, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_createWalletInitializedResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
+    class WindowController {
+        get messages$() {
+            return this._messages$.asObservable();
+        }
+        constructor(windowUrl, windowId) {
+            this._windowInstance = null;
+            this._messageHandler = null;
+            this._messages$ = new Subject();
+            this.windowUrl = windowUrl;
+            this.windowOrigin = new URL(windowUrl).origin;
+            this.windowId = windowId;
+        }
+        get windowInstance() {
+            return this._windowInstance;
+        }
+        openWindow() {
+            if (this._windowInstance && !this._windowInstance.closed) {
+                this._windowInstance.focus();
+                return this._windowInstance;
+            }
+            const windowInstance = window.open(this.windowUrl, this.windowId, getWindowFeatures(400, 600));
+            if (!windowInstance) {
+                throw new Error("Failed to open window. Popup might be blocked by the browser.");
+            }
+            this._windowInstance = windowInstance;
+            this._messageHandler = (ev) => {
+                if (ev.source !== windowInstance ||
+                    ev.origin !== this.windowOrigin ||
+                    !ev.data ||
+                    !(ev.data instanceof Object)) {
+                    return;
+                }
+                this._messages$.next(ev);
+            };
+            window.addEventListener("message", this._messageHandler);
+            const checkWindow = setInterval(() => {
+                if (!this._windowInstance || this._windowInstance?.closed) {
+                    this.cleanup();
+                    clearInterval(checkWindow);
+                }
+            }, 500);
+            return windowInstance;
+        }
+        postMessage(message, transfer) {
+            if (!this._windowInstance)
+                return;
+            this._windowInstance.postMessage(message, this.windowOrigin, transfer);
+        }
+        onMessage(callback) {
+            const listener = (ev) => {
+                if (ev.source !== this._windowInstance)
+                    return;
+                callback(ev);
+            };
+            window.addEventListener("message", listener);
+            const close = () => window.removeEventListener("message", listener);
+            this.onClose(close);
+            return {
+                close,
+            };
+        }
+        cleanup() {
+            if (this._windowInstance && !this._windowInstance.closed) {
+                this._windowInstance.close();
+            }
+            if (this._messageHandler) {
+                window.removeEventListener("message", this._messageHandler);
+                this._messageHandler = null;
+            }
+            if (this._messages$ && !this._messages$.closed) {
+                this._messages$.complete();
+            }
+            this._windowInstance = null;
+        }
+        onClose(callback) {
+            return this._messages$.subscribe({
+                complete: callback,
+            });
+        }
+    }
+
+    class WindowService {
+        constructor() {
+            this.windowControllers = new Map();
+        }
+        static get instance() {
+            return this._instance || (this._instance = new this());
+        }
+        async sendWindowInitializationRequest(windowId, payload, port) {
+            const windowController = this.windowControllers.get(windowId);
+            if (!windowController) {
+                throw new Error("Window controller not found");
+            }
+            const windowInstance = windowController.windowInstance;
+            if (!windowInstance) {
+                throw new Error("Window instance not found");
+            }
+            const response = firstValueFrom(windowController.messages$.pipe(filter((event) => event.data.type === AirMessageTypes.INITIALIZATION_RESPONSE)));
+            windowController.postMessage({ type: AirMessageTypes.INITIALIZATION_REQUEST, payload }, [port]);
+            return (await response).data;
+        }
+        async openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, port, }) {
+            if (this.windowControllers.has(windowId)) {
+                throw new Error("Window controller already exists");
+            }
+            const windowController = new WindowController(url, windowId);
+            this.windowControllers.set(windowId, windowController);
+            windowController.openWindow();
+            windowController.onClose(() => {
+                this.removeWindowController(windowId);
+            });
+            await new Promise((resolve, reject) => {
+                windowController.onMessage(async (ev) => {
+                    if (ev.data === AirMessageTypes.SERVICE_STARTED) {
+                        const { payload } = await this.sendWindowInitializationRequest(windowId, {
+                            partnerId,
+                            enableLogging,
+                        }, port);
+                        if (payload.success === false) {
+                            reject(new AirServiceError(payload.errorName, payload.errorMessage));
+                        }
+                        else {
+                            resolve();
+                        }
+                    }
+                });
+            });
+            return windowController;
+        }
+        getWindowController(windowId) {
+            return this.windowControllers.get(windowId);
+        }
+        removeWindowController(windowId) {
+            this.windowControllers.delete(windowId);
+        }
+    }
+    var WindowService$1 = WindowService.instance;
+
+    var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_walletLoggedInResult, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_subscribeToWalletEvents, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_createWalletInitializedResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
     class AirService {
         constructor({ partnerId }) {
             _AirService_instances.add(this);
@@ -2037,6 +2262,24 @@
                 throw AirServiceError.from(error);
             }
         }
+        /**
+         * @experimental This method is experimental and will change in the future.
+         */
+        async listAllSessionKeyScopes() {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                throw new Error("Service is not initialized");
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            try {
+                const { payload } = await AirMessageService$1.sendListAllSessionKeyScopesRequest(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+                if (payload.success === false) {
+                    throw new AirServiceError(payload.errorName, payload.errorMessage);
+                }
+                return payload.sessionKeyScopes;
+            }
+            catch (error) {
+                throw AirServiceError.from(error);
+            }
+        }
         /**
          * @experimental This method is experimental and will change in the future.
          */
@@ -2167,6 +2410,20 @@
         clearEventListeners() {
             __classPrivateFieldSet(this, _AirService_airAuthListener, [], "f");
         }
+        async getPartnerAccessToken() {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                throw new Error("Service is not initialized");
+            if (!this.isLoggedIn)
+                throw new Error("No active session to get partner access token");
+            const result = await AirMessageService$1.sendGetPartnerAccessTokenRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+            if (result.payload.success === false) {
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+            }
+            if (!result.payload.partnerAccessToken) {
+                throw new Error("Partner access token not found in response");
+            }
+            return result.payload.partnerAccessToken;
+        }
     }
     _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _AirService_enableLogging = new WeakMap(), _AirService_partnerId = new WeakMap(), _AirService_authIframeController = new WeakMap(), _AirService_isAuthInitialized = new WeakMap(), _AirService_airAuthListener = new WeakMap(), _AirService_walletIframeController = new WeakMap(), _AirService_walletInitialization = new WeakMap(), _AirService_walletLoggedInResult = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet(option) {
         if (!this.isInitialized)
@@ -2205,23 +2462,7 @@
         try {
             __classPrivateFieldSet(this, _AirService_walletIframeController, new IframeController(walletUrl, `air-wallet-${randomId()}`), "f");
             __classPrivateFieldGet(this, _AirService_walletIframeController, "f").createIframe();
-            AirMessageService$1.messages$.subscribe(async (msg) => {
-                switch (msg.type) {
-                    case AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST: {
-                        const walletIframeController = __classPrivateFieldGet(this, _AirService_walletIframeController, "f");
-                        walletIframeController.setIframeVisibility(msg.payload.visible);
-                        walletIframeController.updateIframeState();
-                        break;
-                    }
-                    case AirMessageTypes.WALLET_LOGIN_RESPONSE: {
-                        if (msg.payload.success === true && !__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f")) {
-                            __classPrivateFieldSet(this, _AirService_walletLoggedInResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, msg.payload), "f");
-                            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerWalletInitialized).call(this, __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f"));
-                        }
-                        break;
-                    }
-                }
-            });
+            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_subscribeToWalletEvents).call(this);
             await new Promise((resolve, reject) => {
                 const handleAuthMessage = async (ev) => {
                     if (ev.origin !== walletIframeOrigin)
@@ -2260,6 +2501,43 @@
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
             throw error;
         }
+    }, _AirService_subscribeToWalletEvents = function _AirService_subscribeToWalletEvents() {
+        AirMessageService$1.messages$.subscribe(async (msg) => {
+            switch (msg.type) {
+                case AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST: {
+                    const walletIframeController = __classPrivateFieldGet(this, _AirService_walletIframeController, "f");
+                    walletIframeController.setIframeVisibility(msg.payload.visible);
+                    walletIframeController.updateIframeState();
+                    break;
+                }
+                case AirMessageTypes.WALLET_LOGIN_RESPONSE: {
+                    if (msg.payload.success === true && !__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f")) {
+                        __classPrivateFieldSet(this, _AirService_walletLoggedInResult, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, msg.payload), "f");
+                        __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerWalletInitialized).call(this, __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f"));
+                    }
+                    break;
+                }
+                case AirMessageTypes.OPEN_WINDOW_REQUEST: {
+                    try {
+                        const channel = new MessageChannel();
+                        const windowController = await WindowService$1.openAndInitializeWalletServiceWindow({
+                            url: msg.payload.url,
+                            windowId: msg.payload.windowId,
+                            partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
+                            enableLogging: __classPrivateFieldGet(this, _AirService_enableLogging, "f"),
+                            port: channel.port1,
+                        });
+                        windowController.onClose(() => AirMessageService$1.sendWindowClosed(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, msg.payload.windowId));
+                        AirMessageService$1.sendOpenWindowSuccessResponse(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, msg.payload.windowId, channel.port2);
+                    }
+                    catch (err) {
+                        const error = ensureError(err);
+                        AirMessageService$1.sendOpenWindowErrorResponse(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, msg.payload.windowId, error);
+                    }
+                    break;
+                }
+            }
+        });
     }, _AirService_triggerEventListeners = function _AirService_triggerEventListeners(data) {
         __classPrivateFieldGet(this, _AirService_airAuthListener, "f").forEach((listener) => {
             listener(data);

package/dist/types/airService.d.ts

@@ -34,6 +34,10 @@ declare class AirService {
         sessionOwnerPrivateKey: string;
         permissionIds: string[];
     }>;
+    /**
+     * @experimental This method is experimental and will change in the future.
+     */
+    listAllSessionKeyScopes(): Promise<ActionPolicyInfo[]>;
     /**
      * @experimental This method is experimental and will change in the future.
      */
@@ -63,5 +67,6 @@ declare class AirService {
     on(listener: AirEventListener): void;
     off(listener: AirEventListener): void;
     clearEventListeners(): void;
+    getPartnerAccessToken(): Promise<string>;
 }
 export default AirService;

package/dist/types/airWalletProvider.d.ts

@@ -1,4 +1,4 @@
-import { EIP1193EventMap, EIP1193Provider } from "@mocanetwork/common/src/provider/types";
+import { EIP1193EventMap, EIP1193Provider } from "./common/provider/types";
 import { AirWalletInitializedResult } from "./interfaces";
 import { IframeController } from "./iframeController";
 declare class AirWalletProvider implements EIP1193Provider {

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

@@ -23,6 +23,8 @@ export declare const AirAuthMessageTypes: {
     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 GET_PARTNER_ACCESS_TOKEN_REQUEST: "air_auth_get_partner_access_token_request";
+    readonly GET_PARTNER_ACCESS_TOKEN_RESPONSE: "air_auth_get_partner_access_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";
@@ -133,5 +135,10 @@ export type AirAuthResetWalletCommunicationRequestMessage = AirAuthMessageBaseWi
 export type AirAuthIframeVisibilityRequestMessage = AirAuthMessageBase<"air_auth_iframe_visibility_request", {
     visible: boolean;
 }>;
-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 type AirAuthGetPartnerAccessTokenRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_get_partner_access_token_request">;
+export type AirAuthGetPartnerAccessTokenResponsePayload = AirAuthSuccess & {
+    partnerAccessToken: string;
+};
+export type AirAuthGetPartnerAccessTokenResponseMessage = AirAuthMessageBase<"air_auth_get_partner_access_token_response", AirAuthGetPartnerAccessTokenResponsePayload>;
+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 | AirAuthGetPartnerAccessTokenRequestMessage | AirAuthGetPartnerAccessTokenResponseMessage;
 export {};

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

@@ -22,7 +22,12 @@ export declare const AirMessageTypes: {
     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 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";
@@ -39,7 +44,7 @@ type AirMessageBaseWithoutPayload<TType extends AirMessageType> = {
 type AirSuccessPayload = {
     success: true;
 };
-type AirErrorPayload = {
+export type AirErrorPayload = {
     success: false;
     errorName: AirErrorName;
     errorMessage?: string;
@@ -114,10 +119,26 @@ export type AirRevokePermissionsResponseMessage = AirMessageBase<"air_revoke_per
 export type AirExecuteActionResponseMessage = AirMessageBase<"air_execute_action_response", (AirSuccessPayload & {
     txHash: string;
 }) | AirErrorPayload>;
+export type AirListAllSessionKeyScopesSuccess = {
+    success: true;
+    sessionKeyScopes: ActionPolicyInfo[];
+};
+export type AirListAllSessionKeyScopesRequestMessage = AirMessageBaseWithoutPayload<"air_list_all_session_key_scopes_request">;
+export type AirListAllSessionKeyScopesResponseMessage = AirMessageBase<"air_list_all_session_key_scopes_response", AirListAllSessionKeyScopesSuccess | 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", 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 type AirOpenWindowRequestMessage = AirMessageBase<"air_open_window_request", {
+    url: string;
+    windowId: string;
+}>;
+export type AirOpenWindowResponseMessage = AirMessageBase<"air_open_window_response", (AirSuccessPayload | AirErrorPayload) & {
+    windowId: string;
+}>;
+export type AirWindowClosedMessage = AirMessageBase<"air_window_closed", {
+    windowId: string;
+}>;
+export type AirMessage = AirInitializationRequestMessage | AirInitializationResponseMessage | AirWalletInitializedMessage | AirWalletLoginRequestMessage | AirWalletLoginResponseMessage | AirSetupMfaRequestMessage | AirSetupMfaResponseMessage | AirClaimIdRequestMessage | AirClaimIdResponseMessage | AirInitAuthCommunicationMessage | AirIsSmartAccountDeployedRequestMessage | AirIsSmartAccountDeployedResponseMessage | AirDeploySmartAccountRequestMessage | AirDeploySmartAccountResponseMessage | AirGrantPermissionsRequestMessage | AirGrantPermissionsResponseMessage | AirRevokePermissionsRequestMessage | AirRevokePermissionsResponseMessage | AirExecuteActionRequestMessage | AirExecuteActionResponseMessage | AirListAllSessionKeyScopesRequestMessage | AirListAllSessionKeyScopesResponseMessage | AirWalletIframeVisibilityRequestMessage | AirLogoutRequestMessage | AirLogoutResponseMessage | AirOpenWindowRequestMessage | AirOpenWindowResponseMessage | AirWindowClosedMessage;
 export {};

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

@@ -29,4 +29,5 @@ export type RealmPartnerConfig = {
     authLocaleUrls?: Record<string, string>;
     walletLocaleUrls?: Record<string, string>;
     allowUnverifiedEmails?: boolean;
+    mfaRequired?: boolean;
 };

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

@@ -6,8 +6,9 @@ export declare function promiseCreator<T>(): {
     reject: (reason?: string) => void;
     promise: Promise<T>;
 };
-export declare const isMain: boolean;
-export declare const getIFrameOrigin: () => string;
+export declare const isRoot: boolean;
+export declare const getParentOrReferrerOrigin: () => string | undefined;
+export declare const getWindowId: () => string | undefined;
 export declare const isUnsafeOrigin: (origin: string) => boolean;
 export declare const isParentHttps: (origin: string) => boolean;
 export declare const formatPublicKey: (publicKey: string) => string;

package/dist/types/interfaces.d.ts

@@ -3,6 +3,7 @@ import { AirIdDetails } from "./common/realm/user/types";
 import { EIP1193Provider as EIP1193ProviderInterface } from "./common/provider/types";
 export declare const BUILD_ENV: {
     readonly PRODUCTION: "production";
+    readonly UAT: "uat";
     readonly STAGING: "staging";
     readonly DEVELOPMENT: "development";
 };

package/dist/types/messageService.d.ts

@@ -46,9 +46,13 @@ declare class AirMessageService {
     sendWalletInitializationRequest(walletIframe: HTMLIFrameElement, payload: AirInitializationRequestMessage["payload"]): Promise<import("./common/realm/messaging/types").AirInitializationResponseMessage>;
     sendCrossPartnerTokenRequest(authIframe: HTMLIFrameElement, targetPartnerUrl: string): Promise<import("./common/realm/messaging/auth").AirAuthCrossPartnerTokenResponseMessage>;
     sendGrantPermissionsRequest(walletIframe: HTMLIFrameElement, payload: AirGrantPermissionsRequestMessage["payload"]): Promise<import("./common/realm/messaging/types").AirGrantPermissionsResponseMessage>;
+    sendListAllSessionKeyScopesRequest(walletIframe: HTMLIFrameElement): Promise<import("./common/realm/messaging/types").AirListAllSessionKeyScopesResponseMessage>;
     onWalletInitialized(): Promise<import("./common/realm/messaging/types").AirWalletInitializedMessage>;
     sendWalletLoginRequest(walletIframe: HTMLIFrameElement): Promise<import("./common/realm/messaging/types").AirWalletLoginResponseMessage>;
     sendSetupMfaRequest(walletIframe: HTMLIFrameElement): Promise<import("./common/realm/messaging/types").AirSetupMfaResponseMessage>;
+    sendOpenWindowSuccessResponse(walletIframe: HTMLIFrameElement, windowId: string, port: MessagePort): void;
+    sendOpenWindowErrorResponse(walletIframe: HTMLIFrameElement, windowId: string, error: Error): void;
+    sendWindowClosed(walletIframe: HTMLIFrameElement, windowId: string): void;
     sendClaimIdRequest(walletIframe: HTMLIFrameElement, payload: AirClaimIdRequestMessage["payload"]): Promise<import("./common/realm/messaging/types").AirClaimIdResponseMessage>;
     sendWalletProviderRequest(walletIframe: HTMLIFrameElement, payload: AirWalletProviderMessageRequest["payload"]): Promise<AirWalletProviderMessageResponse>;
     closeAuthObservables(): void;
@@ -57,6 +61,7 @@ declare class AirMessageService {
     private setupAuthObservables;
     private setupAirObservables;
     private setupWalletObservables;
+    sendGetPartnerAccessTokenRequest(authIframe: HTMLIFrameElement): Promise<import("./common/realm/messaging/auth").AirAuthGetPartnerAccessTokenResponseMessage>;
 }
 declare const _default: AirMessageService;
 export default _default;

package/dist/types/utils.d.ts

@@ -4,3 +4,4 @@ export declare const handleEvent: (handle: EventTarget, eventName: string, handl
 export declare const htmlToElement: <T extends Element>(html: string) => T;
 export declare const isElement: (element: unknown) => element is Document | Element;
 export declare const randomId: () => string;
+export declare const getWindowFeatures: (width: number, height: number) => string;

package/dist/types/windowController.d.ts

@@ -0,0 +1,19 @@
+import { Subscription } from "rxjs";
+export declare class WindowController {
+    private _windowInstance;
+    private _messageHandler;
+    private windowUrl;
+    private windowOrigin;
+    private windowId;
+    private _messages$;
+    get messages$(): import("rxjs").Observable<MessageEvent<any>>;
+    constructor(windowUrl: string, windowId: string);
+    get windowInstance(): Window | null;
+    openWindow(): Window;
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    onMessage(callback: (event: MessageEvent) => void): {
+        close: () => void;
+    };
+    cleanup(): void;
+    onClose(callback: () => void): Subscription;
+}

package/dist/types/windowService.d.ts

@@ -0,0 +1,18 @@
+import { WindowController } from "./windowController";
+declare class WindowService {
+    private static _instance;
+    static get instance(): WindowService;
+    private windowControllers;
+    private sendWindowInitializationRequest;
+    openAndInitializeWalletServiceWindow({ url, windowId, partnerId, enableLogging, port, }: {
+        url: string;
+        windowId: string;
+        partnerId: string;
+        enableLogging: boolean;
+        port: MessagePort;
+    }): Promise<WindowController>;
+    getWindowController(windowId: string): WindowController;
+    removeWindowController(windowId: string): void;
+}
+declare const _default: WindowService;
+export default _default;

package/package.json

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