@mocanetwork/airkit 1.0.0 → 1.1.0-beta.0

package/dist/airkit.umd.js

@@ -108,6 +108,8 @@
       LOGIN_REQUEST: "air_auth_login_request",
       LOGIN_RESPONSE: "air_auth_login_response",
       LOGIN_WALLET_RESPONSE: "air_auth_login_wallet_response",
+      USER_INFO_REQUEST: "air_auth_user_info_request",
+      USER_INFO_RESPONSE: "air_auth_user_info_response",
       PARTNER_USER_INFO_REQUEST: "air_auth_partner_user_info_request",
       PARTNER_USER_INFO_RESPONSE: "air_auth_partner_user_info_response",
       REFRESH_TOKEN_REQUEST: "air_auth_refresh_token_request",
@@ -120,8 +122,11 @@
       SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_response",
       SIGN_SIWE_MESSAGE_REQUEST: "air_auth_sign_siwe_message_request",
       SIGN_SIWE_MESSAGE_RESPONSE: "air_auth_sign_siwe_message_response",
+      CROSS_PARTNER_TOKEN_REQUEST: "air_auth_cross_partner_token_request",
+      CROSS_PARTNER_TOKEN_RESPONSE: "air_auth_cross_partner_token_response",
       LOGOUT_REQUEST: "air_auth_logout_request",
-      LOGOUT_RESPONSE: "air_auth_logout_response"
+      LOGOUT_RESPONSE: "air_auth_logout_response",
+      RESET_WALLET_COMMUNICATION: "air_auth_reset_wallet_communication"
     };
 
     const AirMessageTypes = {
@@ -144,9 +149,156 @@
       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",
-      LOGOUT_RESPONSE: "air_logout_response"
+      LOGOUT_RESPONSE: "air_logout_response",
+      SETUP_MFA_REQUEST: "air_setup_mfa_request"
     };
 
+    class BaseError extends Error {
+      constructor(name, message, options = {}) {
+        const {
+          cause,
+          context
+        } = options;
+        super(message || name);
+        this.name = name;
+        this.stack = cause?.stack;
+        this.cause = cause;
+        this.context = context;
+      }
+      toJSON() {
+        return {
+          name: this.name,
+          message: this.message,
+          context: this.context,
+          cause: this.cause
+        };
+      }
+    }
+
+    class AirServiceError extends BaseError {
+        static from(error) {
+            if (error instanceof AirServiceError) {
+                return error;
+            }
+            else if (error instanceof Object && "message" in error) {
+                if (error.message === "User cancelled login") {
+                    return new AirServiceError("USER_CANCELLED", error.message);
+                }
+                return new AirServiceError("UNKNOWN_ERROR", error.message.toString());
+            }
+            return new AirServiceError("UNKNOWN_ERROR");
+        }
+    }
+    class ProviderRpcError extends Error {
+        constructor(message) {
+            super(message);
+        }
+    }
+    class UserRejectedRequestError extends ProviderRpcError {
+        constructor() {
+            super(...arguments);
+            this.code = 4001;
+            this.name = "UserRejectedRequestError";
+        }
+    }
+    class UnauthorizedProviderError extends ProviderRpcError {
+        constructor() {
+            super(...arguments);
+            this.code = 4100;
+            this.name = "UnauthorizedProviderError";
+        }
+    }
+    class UnsupportedProviderMethodError extends ProviderRpcError {
+        constructor() {
+            super(...arguments);
+            this.code = 4200;
+            this.name = "UnsupportedProviderMethodError";
+        }
+    }
+    class ProviderDisconnectedError extends ProviderRpcError {
+        constructor() {
+            super(...arguments);
+            this.code = 4900;
+            this.name = "ProviderDisconnectedError";
+        }
+    }
+    class ChainDisconnectedError extends ProviderRpcError {
+        constructor() {
+            super(...arguments);
+            this.code = 4901;
+            this.name = "ChainDisconnectedError";
+        }
+    }
+    class SwitchChainError extends ProviderRpcError {
+        constructor() {
+            super(...arguments);
+            this.code = 4902;
+            this.name = "SwitchChainError";
+        }
+    }
+    class InvalidRequestRpcError extends ProviderRpcError {
+        constructor() {
+            super(...arguments);
+            this.code = -32600;
+            this.name = "InvalidRequestRpcError";
+        }
+    }
+    class MethodNotFoundRpcError extends ProviderRpcError {
+        constructor() {
+            super(...arguments);
+            this.code = -32601;
+            this.name = "MethodNotFoundRpcError";
+        }
+    }
+    class InvalidParamsRpcError extends ProviderRpcError {
+        constructor() {
+            super(...arguments);
+            this.code = -32602;
+            this.name = "InvalidParamsRpcError";
+        }
+    }
+    class InternalRpcError extends ProviderRpcError {
+        constructor() {
+            super(...arguments);
+            this.code = -32603;
+            this.name = "InternalRpcError";
+        }
+    }
+    function ensureProviderRpcError(value) {
+        if (value instanceof ProviderRpcError) {
+            return value;
+        }
+        if (typeof value === "object" &&
+            value !== null &&
+            "errorCode" in value &&
+            "errorMessage" in value) {
+            if (typeof value.errorCode === "number" && typeof value.errorMessage === "string") {
+                switch (value.errorCode) {
+                    case 4001:
+                        return new UserRejectedRequestError(value.errorMessage);
+                    case 4100:
+                        return new UnauthorizedProviderError(value.errorMessage);
+                    case 4200:
+                        return new UnsupportedProviderMethodError(value.errorMessage);
+                    case 4900:
+                        return new ProviderDisconnectedError(value.errorMessage);
+                    case 4901:
+                        return new ChainDisconnectedError(value.errorMessage);
+                    case 4902:
+                        return new SwitchChainError(value.errorMessage);
+                }
+            }
+        }
+        let stringified = "[Unable to stringify the thrown value]";
+        try {
+            stringified = JSON.stringify(value);
+        }
+        catch {
+            // ignoring failed stringify
+        }
+        return new InternalRpcError(`Invalid value for ProviderRpcError: ${stringified}`);
+    }
+
     function isFunction(value) {
       return typeof value === 'function';
     }
@@ -874,50 +1026,11 @@
       });
     }
 
-    class BaseError extends Error {
-      constructor(name, message, options = {}) {
-        const {
-          cause,
-          context
-        } = options;
-        super(message || name);
-        this.name = name;
-        this.stack = cause?.stack;
-        this.cause = cause;
-        this.context = context;
-      }
-      toJSON() {
-        return {
-          name: this.name,
-          message: this.message,
-          context: this.context,
-          cause: this.cause
-        };
-      }
-    }
-
-    class AirServiceError extends BaseError {
-        static from(error) {
-            if (error instanceof AirServiceError) {
-                return error;
-            }
-            else if (error instanceof Object && "message" in error) {
-                if (error.message === "User cancelled login") {
-                    return new AirServiceError("USER_CANCELLED", error.message);
-                }
-                return new AirServiceError("UNKNOWN_ERROR", error.message.toString());
-            }
-            return new AirServiceError("UNKNOWN_ERROR");
-        }
-    }
-    class RealmEmbedError extends AirServiceError {
-    }
-
     function getDefaultExportFromCjs (x) {
     	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
     }
 
-    var loglevel$2 = {exports: {}};
+    var loglevel$1 = {exports: {}};
 
     /*
     * loglevel - https://github.com/pimterry/loglevel
@@ -925,10 +1038,10 @@
     * Copyright (c) 2013 Tim Perry
     * Licensed under the MIT license.
     */
-    var loglevel$1 = loglevel$2.exports;
+    var loglevel = loglevel$1.exports;
     var hasRequiredLoglevel;
     function requireLoglevel() {
-      if (hasRequiredLoglevel) return loglevel$2.exports;
+      if (hasRequiredLoglevel) return loglevel$1.exports;
       hasRequiredLoglevel = 1;
       (function (module) {
         (function (root, definition) {
@@ -938,7 +1051,7 @@
           } else {
             root.log = definition();
           }
-        })(loglevel$1, function () {
+        })(loglevel, function () {
 
           // Slightly dubious tricks to cut down minimized file size
           var noop = function () {};
@@ -1237,19 +1350,20 @@
           defaultLogger['default'] = defaultLogger;
           return defaultLogger;
         });
-      })(loglevel$2);
-      return loglevel$2.exports;
+      })(loglevel$1);
+      return loglevel$1.exports;
     }
 
     var loglevelExports = requireLoglevel();
-    var loglevel = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
+    var log$1 = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
 
-    var log = loglevel.getLogger("airkit");
+    var log = log$1.getLogger("airkit");
 
     var AirWalletProviderMessageTypes;
     (function (AirWalletProviderMessageTypes) {
       AirWalletProviderMessageTypes["REQUEST"] = "JRPC_REQUEST";
       AirWalletProviderMessageTypes["RESPONSE"] = "JRPC_RESPONSE";
+      AirWalletProviderMessageTypes["EVENT"] = "JRPC_EVENT";
     })(AirWalletProviderMessageTypes || (AirWalletProviderMessageTypes = {}));
 
     const ACCOUNT_MESSAGES = [
@@ -1272,6 +1386,7 @@
         AirAuthMessageTypes.SETUP_WALLET_REQUEST,
         AirAuthMessageTypes.LOGOUT_RESPONSE,
         AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
+        AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE,
         AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
     ];
     class AirMessageService {
@@ -1295,6 +1410,9 @@
         get providerMessage$() {
             return this._providerMessage$.asObservable();
         }
+        get providerEvent$() {
+            return this._providerEvent$.asObservable();
+        }
         async openAuthObservables({ authIframeOrigin }) {
             this.closeAuthObservables();
             this.setupAuthObservables();
@@ -1335,13 +1453,16 @@
                 if (ev.data.type === AirWalletProviderMessageTypes.RESPONSE) {
                     this._providerMessage$.next(ev.data);
                 }
+                if (ev.data.type === AirWalletProviderMessageTypes.EVENT) {
+                    this._providerEvent$.next(ev.data);
+                }
             };
             window.addEventListener("message", handleWalletMessage);
             this.closeWalletMessageListeners = () => {
                 window.removeEventListener("message", handleWalletMessage);
             };
         }
-        setupIframeCommunication(authIframe, walletIframe) {
+        setupIframeCommunication(authIframe, walletIframe, skipWalletLogin) {
             const channel = new MessageChannel();
             const authOrigin = new URL(authIframe.src).origin;
             authIframe.contentWindow.postMessage({
@@ -1350,6 +1471,9 @@
             const walletOrigin = new URL(walletIframe.src).origin;
             walletIframe.contentWindow.postMessage({
                 type: AirMessageTypes.INIT_AUTH_COMMUNICATION,
+                payload: {
+                    skipWalletLogin,
+                },
             }, walletOrigin, [channel.port2]);
         }
         async sendGrantPermissionRequest(walletIframe, policies) {
@@ -1363,7 +1487,7 @@
             }, origin);
             const result = await response;
             if (result.payload.success === false) {
-                throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
             }
             return result.payload.sessionData;
         }
@@ -1384,7 +1508,7 @@
             }, origin);
             const result = await response;
             if (result.payload.success === false) {
-                throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
             }
             return result.payload.txHash;
         }
@@ -1399,7 +1523,7 @@
             }, origin);
             const result = await response;
             if (result.payload.success === false) {
-                throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
             }
             return result.payload.txHash;
         }
@@ -1443,6 +1567,10 @@
             walletIframe.contentWindow.postMessage({ type: AirMessageTypes.LOGOUT_REQUEST }, origin);
             return response;
         }
+        sendResetAuthServiceWalletCommunication(authIframe) {
+            const { origin: authOrigin } = new URL(authIframe.src);
+            authIframe.contentWindow.postMessage({ type: AirAuthMessageTypes.RESET_WALLET_COMMUNICATION }, authOrigin);
+        }
         async sendAuthInitializationRequest(authIframe, payload) {
             const response = firstValueFrom(this._authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.INITIALIZATION_RESPONSE)));
             const { origin } = new URL(authIframe.src);
@@ -1455,6 +1583,17 @@
             walletIframe.contentWindow.postMessage({ type: AirMessageTypes.INITIALIZATION_REQUEST, payload }, origin);
             return response;
         }
+        async sendCrossPartnerTokenRequest(authIframe, targetPartnerUrl) {
+            const response = firstValueFrom(this.authMessage$.pipe(filter((msg) => msg.type === AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE)));
+            const { origin } = new URL(authIframe.src);
+            authIframe.contentWindow.postMessage({
+                type: AirAuthMessageTypes.CROSS_PARTNER_TOKEN_REQUEST,
+                payload: {
+                    targetPartnerUrl,
+                },
+            }, origin);
+            return response;
+        }
         async sendGrantPermissionsRequest(walletIframe, payload) {
             const response = firstValueFrom(this.messages$.pipe(filter((msg) => msg.type === AirMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
             const { origin } = new URL(walletIframe.src);
@@ -1495,6 +1634,8 @@
         closeWalletObservables() {
             if (this._providerMessage$ && !this._providerMessage$.closed)
                 this._providerMessage$.complete();
+            if (this._providerEvent$ && !this._providerEvent$.closed)
+                this._providerEvent$.complete();
             if (this.closeWalletMessageListeners)
                 this.closeWalletMessageListeners();
         }
@@ -1506,38 +1647,11 @@
         }
         setupWalletObservables() {
             this._providerMessage$ = new Subject();
+            this._providerEvent$ = new Subject();
         }
     }
     var AirMessageService$1 = AirMessageService.instance;
 
-    class ProviderRpcError extends Error {
-      constructor(message, code, data) {
-        super(message);
-        this.code = code;
-        this.data = data;
-      }
-    }
-    new ProviderRpcError("Invalid JSON", -32700);
-    const ProviderRpcInvalidRequestError = new ProviderRpcError("Invalid request", -32600);
-    const ProviderRpcMethodNotFoundError = new ProviderRpcError("Method not found", -32601);
-    const ProviderRpcInvalidParamsError = new ProviderRpcError("Invalid params", -32602);
-    new ProviderRpcError("Internal error", -32603);
-    new ProviderRpcError("User rejected request", 4001);
-    new ProviderRpcError("Unauthorized", 4100);
-    new ProviderRpcError("Unsupported method", 4200);
-    new ProviderRpcError("Disconnected", 4900);
-    new ProviderRpcError("Chain Disconnected", 4901);
-    function ensureProviderRpcError(value) {
-      if (value instanceof ProviderRpcError) return value;
-      let stringified = "[Unable to stringify the thrown value]";
-      try {
-        stringified = JSON.stringify(value);
-      } catch {
-        // ignoring failed stringify
-      }
-      return new ProviderRpcError(`This value was not thrown as type ProviderRpcError: ${stringified}`, -32603);
-    }
-
     const BUILD_ENV = {
         PRODUCTION: "production",
         STAGING: "staging",
@@ -1548,66 +1662,113 @@
         [BUILD_ENV.DEVELOPMENT]: {
             authUrl: "http://localhost:8100",
             walletUrl: "http://localhost:8200",
-            legacyWalletUrl: "https://localhost:4050",
             logLevel: "debug",
         },
         [BUILD_ENV.STAGING]: {
             authUrl: "https://auth.staging.air3.com",
             walletUrl: "https://account.staging.air3.com",
-            legacyWalletUrl: "https://account.staging.realmnetwork.io",
             logLevel: "info",
         },
         [BUILD_ENV.PRODUCTION]: {
             authUrl: "https://auth.air3.com",
             walletUrl: "https://account.air3.com",
-            legacyWalletUrl: "https://account.realmnetwork.io",
             logLevel: "error",
         },
     };
     const isElement = (element) => element instanceof Element || element instanceof Document;
     const randomId = () => Math.random().toString(36).slice(2);
 
-    var _AirWalletProvider_walletIframe;
+    var _AirWalletProvider_instances, _AirWalletProvider_isLoggedIn, _AirWalletProvider_ensureWallet, _AirWalletProvider_getWalletIframeController, _AirWalletProvider_eventListeners, _AirWalletProvider_emit;
     class AirWalletProvider {
-        constructor(walletIframe) {
-            _AirWalletProvider_walletIframe.set(this, undefined);
-            __classPrivateFieldSet(this, _AirWalletProvider_walletIframe, walletIframe, "f");
+        constructor({ isLoggedIn, ensureWallet, getWalletIframeController, }) {
+            _AirWalletProvider_instances.add(this);
+            _AirWalletProvider_isLoggedIn.set(this, undefined);
+            _AirWalletProvider_ensureWallet.set(this, undefined);
+            _AirWalletProvider_getWalletIframeController.set(this, undefined);
+            _AirWalletProvider_eventListeners.set(this, undefined);
+            this.listenProviderEventMessage = () => {
+                AirMessageService$1.providerEvent$.subscribe((message) => {
+                    __classPrivateFieldGet(this, _AirWalletProvider_instances, "m", _AirWalletProvider_emit).call(this, message.payload.event, ...[message.payload.data]);
+                });
+            };
+            __classPrivateFieldSet(this, _AirWalletProvider_isLoggedIn, isLoggedIn, "f");
+            __classPrivateFieldSet(this, _AirWalletProvider_ensureWallet, ensureWallet, "f");
+            __classPrivateFieldSet(this, _AirWalletProvider_getWalletIframeController, getWalletIframeController, "f");
+            __classPrivateFieldSet(this, _AirWalletProvider_eventListeners, {
+                connect: [],
+                disconnect: [],
+                accountsChanged: [],
+                chainChanged: [],
+                message: [],
+            }, "f");
         }
         async request(request) {
             // Check if the request is valid
             if (!request || typeof request !== "object" || Array.isArray(request)) {
-                throw ProviderRpcInvalidRequestError;
+                throw new InvalidRequestRpcError("Invalid request");
             }
             const { method, params } = request;
             // Check if the method is valid
             if (typeof method !== "string" || method.length === 0) {
-                throw ProviderRpcMethodNotFoundError;
+                throw new MethodNotFoundRpcError("Invalid method");
             }
             // Check if the params are valid
             if (params !== undefined &&
                 !Array.isArray(params) &&
                 (typeof params !== "object" || params === null)) {
-                throw ProviderRpcInvalidParamsError;
+                throw new InvalidParamsRpcError("Invalid params");
+            }
+            // Check if the user is logged in
+            if (!__classPrivateFieldGet(this, _AirWalletProvider_isLoggedIn, "f").call(this)) {
+                throw new UnauthorizedProviderError("User is not logged in");
+            }
+            try {
+                await __classPrivateFieldGet(this, _AirWalletProvider_ensureWallet, "f").call(this);
+            }
+            catch (error) {
+                throw ensureProviderRpcError(error);
             }
             const requestId = randomId();
-            const response = await AirMessageService$1.sendWalletProviderRequest(__classPrivateFieldGet(this, _AirWalletProvider_walletIframe, "f"), {
+            const response = await AirMessageService$1.sendWalletProviderRequest(__classPrivateFieldGet(this, _AirWalletProvider_getWalletIframeController, "f").call(this).iframeElement, {
                 requestId,
                 ...request,
             });
             if (!response.success) {
-                const error = ensureProviderRpcError(response.payload);
-                throw error;
+                throw ensureProviderRpcError(response.payload);
             }
             return response.payload.response;
         }
         on(eventName, listener) {
-            console.log("on", eventName, listener);
+            __classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName] = __classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName] || [];
+            __classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName].push(listener);
         }
         removeListener(eventName, listener) {
-            console.log("removeListener", eventName, listener);
+            __classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName] = __classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName] || [];
+            const index = __classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName].indexOf(listener);
+            if (index >= 0) {
+                __classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName].splice(index, 1);
+            }
+        }
+        removeAllListeners() {
+            __classPrivateFieldSet(this, _AirWalletProvider_eventListeners, {
+                connect: [],
+                disconnect: [],
+                accountsChanged: [],
+                chainChanged: [],
+                message: [],
+            }, "f");
         }
     }
-    _AirWalletProvider_walletIframe = new WeakMap();
+    _AirWalletProvider_isLoggedIn = new WeakMap(), _AirWalletProvider_ensureWallet = new WeakMap(), _AirWalletProvider_getWalletIframeController = new WeakMap(), _AirWalletProvider_eventListeners = new WeakMap(), _AirWalletProvider_instances = new WeakSet(), _AirWalletProvider_emit = function _AirWalletProvider_emit(eventName, ...args) {
+        (__classPrivateFieldGet(this, _AirWalletProvider_eventListeners, "f")[eventName] || []).forEach((listener) => {
+            try {
+                return listener(...args);
+            }
+            catch (error) {
+                log$1.error(error);
+            }
+        });
+    };
 
     class IframeController {
         constructor(iframeUrl, iframeId, state) {
@@ -1672,9 +1833,8 @@
         isVisible: false,
     };
 
-    var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_isWalletInitialized, _AirService_airWalletProvider, _AirService_ensureWallet, _AirService_initializeWallet, _AirService_triggerEventListeners, _AirService_triggerAirAuthInitialized, _AirService_triggerAirAuthLoggedIn, _AirService_triggerAirAuthLoggedOut, _AirService_triggerWalletInitialized, _AirService_createLoginResult, _AirService_cleanUpAuth, _AirService_cleanUpWallet;
+    var _AirService_instances, _AirService_loginResult, _AirService_buildEnv, _AirService_enableLogging, _AirService_partnerId, _AirService_authIframeController, _AirService_isAuthInitialized, _AirService_airAuthListener, _AirService_walletIframeController, _AirService_walletInitialization, _AirService_isWalletInitialized, _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, _AirService_cleanUpAuthWalletCommunication;
     class AirService {
-        // #walletRehydrationState: AirRehydrationResult;
         constructor({ partnerId }) {
             _AirService_instances.add(this);
             _AirService_loginResult.set(this, undefined);
@@ -1688,8 +1848,14 @@
             _AirService_walletIframeController.set(this, undefined);
             _AirService_walletInitialization.set(this, undefined);
             _AirService_isWalletInitialized.set(this, false);
+            _AirService_walletLoggedInResult.set(this, undefined);
             _AirService_airWalletProvider.set(this, undefined);
             __classPrivateFieldSet(this, _AirService_partnerId, partnerId, "f");
+            __classPrivateFieldSet(this, _AirService_airWalletProvider, new AirWalletProvider({
+                isLoggedIn: () => this.isLoggedIn,
+                ensureWallet: __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).bind(this),
+                getWalletIframeController: () => __classPrivateFieldGet(this, _AirService_walletIframeController, "f"),
+            }), "f");
             // this.#modalZIndex = modalZIndex ?? 99999;
         }
         get buildEnv() {
@@ -1702,7 +1868,15 @@
             return !!__classPrivateFieldGet(this, _AirService_loginResult, "f");
         }
         get isWalletInitialized() {
-            return __classPrivateFieldGet(this, _AirService_isWalletInitialized, "f");
+            return !!__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f");
+        }
+        get provider() {
+            const provider = __classPrivateFieldGet(this, _AirService_airWalletProvider, "f");
+            return {
+                request: provider.request.bind(provider),
+                on: provider.on.bind(provider),
+                removeListener: provider.removeListener.bind(provider),
+            };
         }
         async init({ buildEnv = BUILD_ENV.PRODUCTION, enableLogging = false, skipRehydration = false, }) {
             if (!__classPrivateFieldGet(this, _AirService_partnerId, "f"))
@@ -1730,7 +1904,7 @@
                     }
                     case AirAuthMessageTypes.SETUP_WALLET_REQUEST: {
                         try {
-                            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+                            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this, { skipWalletLogin: true });
                             __classPrivateFieldGet(this, _AirService_authIframeController, "f").postMessage({
                                 type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
                                 payload: {
@@ -1765,6 +1939,7 @@
                             const { payload } = await AirMessageService$1.sendAuthInitializationRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, {
                                 partnerId: __classPrivateFieldGet(this, _AirService_partnerId, "f"),
                                 skipRehydration,
+                                partnerDAppUrl: window.location.href,
                             });
                             if (payload.success === true) {
                                 resolve(payload);
@@ -1792,11 +1967,6 @@
             }
             return null;
         }
-        async cleanUp() {
-            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
-            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpAuth).call(this);
-            this.clearEventListeners();
-        }
         async login(options) {
             if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
                 throw new Error("Service is not initialized");
@@ -1901,25 +2071,13 @@
                 throw AirServiceError.from(error);
             }
         }
-        async logout() {
-            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
-                throw new Error("Service is not initialized");
-            if (!this.isLoggedIn)
-                throw new Error("No active session to logout");
-            // Clear up wallet
-            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
-            await AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
-            __classPrivateFieldSet(this, _AirService_loginResult, undefined, "f");
-            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedOut).call(this);
-        }
-        async getProvider() {
-            if (!this.isLoggedIn)
-                return null;
-            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
-            return __classPrivateFieldGet(this, _AirService_airWalletProvider, "f");
+        getProvider() {
+            return this.provider;
         }
         async preloadWallet() {
-            return __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
+            if (__classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f"))
+                return __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f");
+            return await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
         }
         async claimAirId(options) {
             await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_ensureWallet).call(this);
@@ -1944,9 +2102,39 @@
                     id: info.payload.user.id,
                     abstractAccountAddress: info.payload.user.abstractAccountAddress,
                     email: info.payload.user.email,
+                    isMFASetup: info.payload.user.isMFASetup,
                 },
             };
         }
+        async goToPartner(partnerUrl) {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                throw new Error("Service is not initialized");
+            if (!this.isLoggedIn)
+                throw new Error("No active session to generate token");
+            const result = await AirMessageService$1.sendCrossPartnerTokenRequest(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, partnerUrl);
+            if (result.payload.success === false) {
+                throw new AirServiceError(result.payload.errorName, result.payload.errorMessage);
+            }
+            return {
+                urlWithToken: result.payload.urlWithToken,
+            };
+        }
+        async logout() {
+            if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+                throw new Error("Service is not initialized");
+            if (!this.isLoggedIn)
+                throw new Error("No active session to logout");
+            // Clear up wallet
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+            await AirMessageService$1.logoutAuth(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement);
+            __classPrivateFieldSet(this, _AirService_loginResult, undefined, "f");
+            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerAirAuthLoggedOut).call(this);
+        }
+        async cleanUp() {
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+            await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpAuth).call(this);
+            this.clearEventListeners();
+        }
         on(listener) {
             if (__classPrivateFieldGet(this, _AirService_airAuthListener, "f").indexOf(listener) < 0)
                 __classPrivateFieldGet(this, _AirService_airAuthListener, "f").push(listener);
@@ -1967,24 +2155,39 @@
             return null;
         }
     }
-    _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_isWalletInitialized = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = async function _AirService_ensureWallet() {
+    _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_isWalletInitialized = new WeakMap(), _AirService_walletLoggedInResult = new WeakMap(), _AirService_airWalletProvider = new WeakMap(), _AirService_instances = new WeakSet(), _AirService_ensureWallet = 
+    // Result of this.#walletInitialization:
+    // - If skipWalletLogin is true, it returns the result of empty abstractAccountAddress
+    // - If skipWalletLogin is false, it returns the result of abstractAccountAddress from wallet initialization
+    // - If #ensureWallet is called again, it returns the result of abstractAccountAddress from the second
+    //   wallet initialization if this first wallet initialization doesn't have abstractAccountAddress
+    async function _AirService_ensureWallet(option) {
         if (!this.isInitialized)
             throw new Error("Service not initialized");
-        if (!__classPrivateFieldGet(this, _AirService_walletInitialization, "f")) {
-            try {
-                __classPrivateFieldSet(this, _AirService_walletInitialization, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_initializeWallet).call(this), "f");
-                return await __classPrivateFieldGet(this, _AirService_walletInitialization, "f");
+        if (!this.isLoggedIn && !option?.skipWalletLogin)
+            throw new Error("User not logged in");
+        if (!__classPrivateFieldGet(this, _AirService_walletInitialization, "f"))
+            __classPrivateFieldSet(this, _AirService_walletInitialization, __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_initializeWallet).call(this, option), "f");
+        try {
+            const result = await __classPrivateFieldGet(this, _AirService_walletInitialization, "f");
+            // Note: Checking for abstractAccountAddress from the result and this.#walletLoggedInResult to avoid race condition
+            if (option?.skipWalletLogin ||
+                result?.abstractAccountAddress ||
+                __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f")?.abstractAccountAddress) {
+                return result || __classPrivateFieldGet(this, _AirService_walletLoggedInResult, "f");
             }
-            catch (error) {
-                __classPrivateFieldSet(this, _AirService_walletInitialization, null, "f");
-                log.error("Error initializing wallet", error);
-                throw error;
+            const walletInitResult = await AirMessageService$1.onWalletInitialized();
+            if (walletInitResult.payload.success !== true) {
+                throw new AirServiceError(walletInitResult.payload.errorName, walletInitResult.payload.errorMessage);
             }
+            return __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, walletInitResult.payload);
         }
-        else {
-            return __classPrivateFieldGet(this, _AirService_walletInitialization, "f");
+        catch (error) {
+            __classPrivateFieldSet(this, _AirService_walletInitialization, null, "f");
+            log.error("Error initializing wallet", error);
+            throw error;
         }
-    }, _AirService_initializeWallet = async function _AirService_initializeWallet() {
+    }, _AirService_initializeWallet = async function _AirService_initializeWallet(option) {
         if (__classPrivateFieldGet(this, _AirService_isWalletInitialized, "f"))
             throw new AirServiceError("ALREADY_INITIALISED", "Already initialized");
         const { walletUrl } = AIR_URLS[__classPrivateFieldGet(this, _AirService_buildEnv, "f")];
@@ -2002,6 +2205,23 @@
                         walletIframeController.updateIframeState();
                         break;
                     }
+                    case AirMessageTypes.WALLET_INITIALIZED: {
+                        if (msg.payload.success === true && msg.payload.addresses?.aa) {
+                            __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"));
+                        }
+                        if (msg.payload.success === false) {
+                            if (!__classPrivateFieldGet(this, _AirService_isWalletInitialized, "f")) {
+                                // MFA fail case, also reset wallet port
+                                __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpAuthWalletCommunication).call(this);
+                            }
+                            else {
+                                // Logout wallet and destroy the wallet iframe
+                                await __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_cleanUpWallet).call(this);
+                            }
+                        }
+                        break;
+                    }
                 }
             });
             await new Promise((resolve, reject) => {
@@ -2024,18 +2244,15 @@
                 };
                 window.addEventListener("message", handleAuthMessage);
             });
+            __classPrivateFieldGet(this, _AirService_airWalletProvider, "f").listenProviderEventMessage();
             const walletInitPromise = AirMessageService$1.onWalletInitialized();
-            AirMessageService$1.setupIframeCommunication(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, __classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement);
+            AirMessageService$1.setupIframeCommunication(__classPrivateFieldGet(this, _AirService_authIframeController, "f").iframeElement, __classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement, option?.skipWalletLogin ?? false);
             const walletInitResult = await walletInitPromise;
             if (walletInitResult.payload.success !== true) {
                 throw new AirServiceError(walletInitResult.payload.errorName, walletInitResult.payload.errorMessage);
             }
-            __classPrivateFieldSet(this, _AirService_airWalletProvider, new AirWalletProvider(__classPrivateFieldGet(this, _AirService_walletIframeController, "f").iframeElement), "f");
-            const result = {
-                abstractAccountAddress: walletInitResult.payload.addresses.aa,
-            };
-            __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_triggerWalletInitialized).call(this, result);
-            return result;
+            __classPrivateFieldSet(this, _AirService_isWalletInitialized, true, "f");
+            return __classPrivateFieldGet(this, _AirService_instances, "m", _AirService_createWalletInitializedResult).call(this, walletInitResult.payload);
         }
         catch (error) {
             log.error("Error initializing wallet", error);
@@ -2066,6 +2283,12 @@
             id: payload.id,
             abstractAccountAddress: payload.abstractAccountAddress,
             token: payload.partnerAccessToken,
+            isMFASetup: payload.isMFASetup,
+        };
+    }, _AirService_createWalletInitializedResult = function _AirService_createWalletInitializedResult(payload) {
+        return {
+            abstractAccountAddress: payload.addresses?.aa ?? null,
+            isMFASetup: payload.isMFASetup,
         };
     }, _AirService_cleanUpAuth = async function _AirService_cleanUpAuth() {
         // Logout auth session
@@ -2091,14 +2314,31 @@
         }
         // Close the message service
         AirMessageService$1.closeAirObservables();
-        __classPrivateFieldSet(this, _AirService_walletInitialization, null, "f");
+        __classPrivateFieldSet(this, _AirService_walletLoggedInResult, undefined, "f");
+        __classPrivateFieldSet(this, _AirService_walletInitialization, undefined, "f");
         __classPrivateFieldSet(this, _AirService_isWalletInitialized, false, "f");
+    }, _AirService_cleanUpAuthWalletCommunication = function _AirService_cleanUpAuthWalletCommunication() {
+        if (!__classPrivateFieldGet(this, _AirService_isAuthInitialized, "f"))
+            return;
+        const authIframeElement = __classPrivateFieldGet(this, _AirService_authIframeController, "f")?.iframeElement;
+        if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
+            AirMessageService$1.sendResetAuthServiceWalletCommunication(authIframeElement);
+        }
     };
 
     exports.AirService = AirService;
     exports.AirServiceError = AirServiceError;
-    exports.AirWalletProvider = AirWalletProvider;
     exports.BUILD_ENV = BUILD_ENV;
-    exports.RealmEmbedError = RealmEmbedError;
+    exports.ChainDisconnectedError = ChainDisconnectedError;
+    exports.InternalRpcError = InternalRpcError;
+    exports.InvalidParamsRpcError = InvalidParamsRpcError;
+    exports.InvalidRequestRpcError = InvalidRequestRpcError;
+    exports.MethodNotFoundRpcError = MethodNotFoundRpcError;
+    exports.ProviderDisconnectedError = ProviderDisconnectedError;
+    exports.SwitchChainError = SwitchChainError;
+    exports.UnauthorizedProviderError = UnauthorizedProviderError;
+    exports.UnsupportedProviderMethodError = UnsupportedProviderMethodError;
+    exports.UserRejectedRequestError = UserRejectedRequestError;
+    exports.ensureProviderRpcError = ensureProviderRpcError;
 
 }));