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

package/dist/airkit.cjs.js

@@ -120,8 +120,8 @@ const AirAuthMessageTypes = {
   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",
+  PARTNER_ACCESS_TOKEN_REQUEST: "air_auth_partner_access_token_request",
+  PARTNER_ACCESS_TOKEN_RESPONSE: "air_auth_partner_access_token_response",
   LOGOUT_REQUEST: "air_auth_logout_request",
   LOGOUT_RESPONSE: "air_auth_logout_response",
   RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication"
@@ -150,6 +150,9 @@ const AirMessageTypes = {
   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 +180,16 @@ class BaseError extends Error {
     };
   }
 }
+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) {
@@ -239,6 +252,13 @@ class SwitchChainError extends ProviderRpcError {
         this.name = "SwitchChainError";
     }
 }
+class TransactionRejectedRpcError extends ProviderRpcError {
+    constructor() {
+        super(...arguments);
+        this.code = -32003;
+        this.name = "TransactionRejectedRpcError";
+    }
+}
 class InvalidRequestRpcError extends ProviderRpcError {
     constructor() {
         super(...arguments);
@@ -289,6 +309,8 @@ function ensureProviderRpcError(value) {
                     return new ChainDisconnectedError(value.errorMessage);
                 case 4902:
                     return new SwitchChainError(value.errorMessage);
+                case -32003:
+                    return new TransactionRejectedRpcError(value.errorMessage);
             }
         }
     }
@@ -1384,6 +1406,7 @@ const ACCOUNT_MESSAGES = [
     AirMessageTypes.WALLET_INITIALIZED,
     AirMessageTypes.WALLET_IFRAME_VISIBILITY_REQUEST,
     AirMessageTypes.LOGOUT_RESPONSE,
+    AirMessageTypes.OPEN_WINDOW_REQUEST,
 ];
 const AUTH_MESSAGES = [
     AirAuthMessageTypes.INITIALIZATION_RESPONSE,
@@ -1393,7 +1416,7 @@ const AUTH_MESSAGES = [
     AirAuthMessageTypes.LOGOUT_RESPONSE,
     AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
     AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE,
-    AirAuthMessageTypes.GET_PARTNER_ACCESS_TOKEN_RESPONSE,
+    AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE,
     AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
 ];
 class AirMessageService {
@@ -1628,6 +1651,37 @@ class AirMessageService {
         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);
@@ -1674,10 +1728,10 @@ class AirMessageService {
         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)));
+    async sendPartnerAccessTokenRequest(authIframe) {
+        const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_RESPONSE)));
         const { origin } = new URL(authIframe.src);
-        authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.GET_PARTNER_ACCESS_TOKEN_REQUEST }, origin);
+        authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.PARTNER_ACCESS_TOKEN_REQUEST }, origin);
         return response;
     }
 }
@@ -1685,6 +1739,7 @@ var AirMessageService$1 = AirMessageService.instance;
 
 const BUILD_ENV = {
     PRODUCTION: "production",
+    UAT: "uat",
     STAGING: "staging",
     DEVELOPMENT: "development",
 };
@@ -1695,6 +1750,11 @@ const AIR_URLS = {
         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",
@@ -1708,6 +1768,24 @@ const AIR_URLS = {
 };
 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 {
@@ -1864,7 +1942,145 @@ IframeController.defaultState = {
     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(425, 680));
+        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);
@@ -2172,6 +2388,20 @@ class AirService {
             urlWithToken: result.payload.urlWithToken,
         };
     }
+    async getAccessToken() {
+        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.sendPartnerAccessTokenRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+        if (result.payload.success !== true) {
+            throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+        }
+        if (!result.payload.partnerAccessToken) {
+            throw new Error("Partner access token not found in response");
+        }
+        return { token: result.payload.partnerAccessToken };
+    }
     async logout() {
         if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
             throw new Error("Service is not initialized");
@@ -2199,20 +2429,6 @@ class AirService {
     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)
@@ -2251,23 +2467,7 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     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)
@@ -2306,6 +2506,43 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         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);
@@ -2385,6 +2622,7 @@ exports.InvalidRequestRpcError = InvalidRequestRpcError;
 exports.MethodNotFoundRpcError = MethodNotFoundRpcError;
 exports.ProviderDisconnectedError = ProviderDisconnectedError;
 exports.SwitchChainError = SwitchChainError;
+exports.TransactionRejectedRpcError = TransactionRejectedRpcError;
 exports.UnauthorizedProviderError = UnauthorizedProviderError;
 exports.UnsupportedProviderMethodError = UnsupportedProviderMethodError;
 exports.UserRejectedRequestError = UserRejectedRequestError;