@mocanetwork/airkit 1.0.0 → 1.1.0-beta.0

package/dist/airkit.esm.js

@@ -102,6 +102,8 @@ const AirAuthMessageTypes = {
   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",
@@ -114,8 +116,11 @@ const AirAuthMessageTypes = {
   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 = {
@@ -138,9 +143,156 @@ const AirMessageTypes = {
   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';
 }
@@ -868,50 +1020,11 @@ function filter(predicate, thisArg) {
   });
 }
 
-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
@@ -919,10 +1032,10 @@ var loglevel$2 = {exports: {}};
 * 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) {
@@ -932,7 +1045,7 @@ function requireLoglevel() {
       } else {
         root.log = definition();
       }
-    })(loglevel$1, function () {
+    })(loglevel, function () {
 
       // Slightly dubious tricks to cut down minimized file size
       var noop = function () {};
@@ -1231,19 +1344,20 @@ function requireLoglevel() {
       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 = [
@@ -1266,6 +1380,7 @@ const AUTH_MESSAGES = [
     AirAuthMessageTypes.SETUP_WALLET_REQUEST,
     AirAuthMessageTypes.LOGOUT_RESPONSE,
     AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE,
+    AirAuthMessageTypes.CROSS_PARTNER_TOKEN_RESPONSE,
     AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST,
 ];
 class AirMessageService {
@@ -1289,6 +1404,9 @@ class AirMessageService {
     get providerMessage$() {
         return this._providerMessage$.asObservable();
     }
+    get providerEvent$() {
+        return this._providerEvent$.asObservable();
+    }
     async openAuthObservables({ authIframeOrigin }) {
         this.closeAuthObservables();
         this.setupAuthObservables();
@@ -1329,13 +1447,16 @@ class AirMessageService {
             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({
@@ -1344,6 +1465,9 @@ class AirMessageService {
         const walletOrigin = new URL(walletIframe.src).origin;
         walletIframe.contentWindow.postMessage({
             type: AirMessageTypes.INIT_AUTH_COMMUNICATION,
+            payload: {
+                skipWalletLogin,
+            },
         }, walletOrigin, [channel.port2]);
     }
     async sendGrantPermissionRequest(walletIframe, policies) {
@@ -1357,7 +1481,7 @@ class AirMessageService {
         }, 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;
     }
@@ -1378,7 +1502,7 @@ class AirMessageService {
         }, 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;
     }
@@ -1393,7 +1517,7 @@ class AirMessageService {
         }, 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;
     }
@@ -1437,6 +1561,10 @@ class AirMessageService {
         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);
@@ -1449,6 +1577,17 @@ class AirMessageService {
         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);
@@ -1489,6 +1628,8 @@ class AirMessageService {
     closeWalletObservables() {
         if (this._providerMessage$ && !this._providerMessage$.closed)
             this._providerMessage$.complete();
+        if (this._providerEvent$ && !this._providerEvent$.closed)
+            this._providerEvent$.complete();
         if (this.closeWalletMessageListeners)
             this.closeWalletMessageListeners();
     }
@@ -1500,38 +1641,11 @@ class AirMessageService {
     }
     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",
@@ -1542,66 +1656,113 @@ const AIR_URLS = {
     [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) {
@@ -1666,9 +1827,8 @@ 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_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);
@@ -1682,8 +1842,14 @@ class AirService {
         _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() {
@@ -1696,7 +1862,15 @@ class AirService {
         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"))
@@ -1724,7 +1898,7 @@ class AirService {
                 }
                 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: {
@@ -1759,6 +1933,7 @@ class AirService {
                         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);
@@ -1786,11 +1961,6 @@ class AirService {
         }
         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");
@@ -1895,25 +2065,13 @@ class AirService {
             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);
@@ -1938,9 +2096,39 @@ class AirService {
                 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);
@@ -1961,24 +2149,39 @@ class AirService {
         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")];
@@ -1996,6 +2199,23 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
                     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) => {
@@ -2018,18 +2238,15 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
             };
             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);
@@ -2060,6 +2277,12 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
         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
@@ -2085,8 +2308,16 @@ _AirService_loginResult = new WeakMap(), _AirService_buildEnv = new WeakMap(), _
     }
     // 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);
+    }
 };
 
-export { AirService, AirServiceError, AirWalletProvider, BUILD_ENV, RealmEmbedError };
+export { AirService, AirServiceError, BUILD_ENV, ChainDisconnectedError, InternalRpcError, InvalidParamsRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, ProviderDisconnectedError, SwitchChainError, UnauthorizedProviderError, UnsupportedProviderMethodError, UserRejectedRequestError, ensureProviderRpcError };