@mocanetwork/airkit 0.5.0-beta.2

package/dist/lib.cjs/ws-embed/src/messages.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var messages = {
+  errors: {
+    disconnected: () => "Web3Auth: Lost connection to Web3Auth.",
+    permanentlyDisconnected: () => "Web3Auth: Disconnected from iframe. Page reload required.",
+    unsupportedSync: method => `Web3Auth: The Web3Auth Ethereum provider does not support synchronous methods like ${method} without a callback parameter.`,
+    invalidDuplexStream: () => "Must provide a Node.js-style duplex stream.",
+    invalidOptions: maxEventListeners => `Invalid options. Received: { maxEventListeners: ${maxEventListeners}}`,
+    invalidRequestArgs: () => `Expected a single, non-array, object argument.`,
+    invalidRequestMethod: () => `'args.method' must be a non-empty string.`,
+    invalidRequestParams: () => `'args.params' must be an object or array if provided.`,
+    invalidLoggerObject: () => `'args.logger' must be an object if provided.`,
+    invalidLoggerMethod: method => `'args.logger' must include required method '${method}'.`
+  },
+  info: {
+    connected: chainId => `Web3Auth: Connected to chain with ID "${chainId}".`
+  },
+  warnings: {}
+};
+
+module.exports = messages;

package/dist/lib.cjs/ws-embed/src/siteMetadata.js

@@ -0,0 +1,77 @@
+'use strict';
+
+/**
+ * Returns whether the given image URL exists
+ * @param url - the url of the image
+ * @returns whether the image exists
+ */
+function imgExists(url) {
+  return new Promise((resolve, reject) => {
+    try {
+      const img = document.createElement("img");
+      img.onload = () => resolve(true);
+      img.onerror = () => resolve(false);
+      img.src = url;
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+
+/**
+ * Extracts a name for the site from the DOM
+ */
+const getSiteName = window => {
+  const {
+    document
+  } = window;
+  const siteName = document.querySelector('head > meta[property="og:site_name"]');
+  if (siteName) {
+    return siteName.content;
+  }
+  const metaTitle = document.querySelector('head > meta[name="title"]');
+  if (metaTitle) {
+    return metaTitle.content;
+  }
+  if (document.title && document.title.length > 0) {
+    return document.title;
+  }
+  return window.location.hostname;
+};
+
+/**
+ * Extracts an icon for the site from the DOM
+ */
+async function getSiteIcon(window) {
+  try {
+    const {
+      document
+    } = window;
+
+    // Use the site's favicon if it exists
+    let icon = document.querySelector('head > link[rel="shortcut icon"]');
+    if (icon && (await imgExists(icon.href))) {
+      return icon.href;
+    }
+
+    // Search through available icons in no particular order
+    icon = Array.from(document.querySelectorAll('head > link[rel="icon"]')).find(_icon => Boolean(_icon.href));
+    if (icon && (await imgExists(icon.href))) {
+      return icon.href;
+    }
+    return "";
+  } catch (error) {
+    return "";
+  }
+}
+
+/**
+ * Gets site metadata and returns it
+ *
+ */
+const getSiteMetadata = async () => ({
+  name: getSiteName(window),
+  icon: await getSiteIcon(window)
+});
+
+module.exports = getSiteMetadata;

package/dist/lib.cjs/ws-embed/src/utils.js

@@ -0,0 +1,95 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var auth = require('@web3auth/auth');
+var interfaces = require('./interfaces.js');
+var loglevel = require('./loglevel.js');
+
+const AIR_URLS = {
+  [interfaces.EMBED_BUILD_ENV.TESTING]: {
+    authUrl: "http://localhost:8100",
+    walletUrl: "https://lrc-mocaverse.web3auth.io",
+    logLevel: "debug"
+  },
+  [interfaces.EMBED_BUILD_ENV.DEVELOPMENT]: {
+    authUrl: "http://localhost:8100",
+    walletUrl: "https://localhost:4050",
+    logLevel: "debug"
+  },
+  [interfaces.EMBED_BUILD_ENV.STAGING]: {
+    authUrl: "https://login.staging.realmnetwork.io",
+    walletUrl: "https://account.staging.realmnetwork.io",
+    logLevel: "info"
+  },
+  [interfaces.EMBED_BUILD_ENV.PRODUCTION]: {
+    authUrl: "https://login.realmnetwork.io",
+    walletUrl: "https://account.realmnetwork.io",
+    logLevel: "error"
+  }
+};
+const htmlToElement = html => {
+  const template = window.document.createElement("template");
+  const trimmedHtml = html.trim(); // Never return a text node of whitespace as the result
+  template.innerHTML = trimmedHtml;
+  return template.content.firstChild;
+};
+const isElement = element => element instanceof Element || element instanceof Document;
+
+/**
+ * json-rpc-engine middleware that logs RPC errors and and validates req.method.
+ *
+ * @param log - The logging API to use.
+ * @returns  json-rpc-engine middleware function
+ */
+function createErrorMiddleware() {
+  return (req, res, next) => {
+    // json-rpc-engine will terminate the request when it notices this error
+    if (typeof req.method !== "string" || !req.method) {
+      res.error = auth.rpcErrors.invalidRequest({
+        message: `The request 'method' must be a non-empty string.`,
+        data: _objectSpread(_objectSpread({}, req || {}), {}, {
+          cause: `The request 'method' must be a non-empty string.`
+        })
+      });
+    }
+    next(done => {
+      const {
+        error
+      } = res;
+      if (!error) {
+        return done();
+      }
+      loglevel.error(`Ws-Embed - RPC Error: ${error.message}`, error);
+      return done();
+    });
+  };
+}
+
+/**
+ * Logs a stream disconnection error. Emits an 'error' if given an
+ * EventEmitter that has listeners for the 'error' event.
+ *
+ * @param log - The logging API to use.
+ * @param remoteLabel - The label of the disconnected stream.
+ * @param error - The associated error to log.
+ * @param emitter - The logging API to use.
+ */
+function logStreamDisconnectWarning(remoteLabel, error, emitter) {
+  let warningMsg = `Web3Auth: Lost connection to "${remoteLabel}".`;
+  if (error !== null && error !== void 0 && error.stack) {
+    warningMsg += `\n${error.stack}`;
+  }
+  loglevel.warn(warningMsg);
+  if (emitter && emitter.listenerCount("error") > 0) {
+    emitter.emit("error", warningMsg);
+  }
+}
+const EMITTED_NOTIFICATIONS = ["eth_subscription" // per eth-json-rpc-filters/subscriptionManager
+];
+
+exports.AIR_URLS = AIR_URLS;
+exports.EMITTED_NOTIFICATIONS = EMITTED_NOTIFICATIONS;
+exports.createErrorMiddleware = createErrorMiddleware;
+exports.htmlToElement = htmlToElement;
+exports.isElement = isElement;
+exports.logStreamDisconnectWarning = logStreamDisconnectWarning;

package/dist/lib.esm/common/src/error.js

@@ -0,0 +1,23 @@
+class BaseError extends Error {
+  constructor(name, message, options = {}) {
+    const {
+      cause,
+      context
+    } = options;
+    super(message || name);
+    this.name = name;
+    this.stack = cause === null || cause === void 0 ? void 0 : cause.stack;
+    this.cause = cause;
+    this.context = context;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      context: this.context,
+      cause: this.cause
+    };
+  }
+}
+
+export { BaseError };

package/dist/lib.esm/common/src/realm/messaging/auth.js

@@ -0,0 +1,26 @@
+const AirAuthMessageTypes = {
+  SETUP_COMPLETED: "air_auth_setup_completed",
+  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",
+  REFRESH_TOKEN_RESPONSE: "air_auth_refresh_token_response",
+  WALLET_TOKEN_REQUEST: "air_auth_wallet_token_request",
+  WALLET_TOKEN_RESPONSE: "air_auth_wallet_token_response",
+  INITIALIZATION_REQUEST: "air_auth_initialization_request",
+  INITIALIZATION_RESPONSE: "air_auth_initialization_response",
+  INIT_WALLET_COMMUNICATION: "air_auth_init_wallet_communication",
+  IFRAME_VISIBILITY_REQUEST: "air_auth_iframe_visibility_request",
+  SETUP_WALLET_REQUEST: "air_auth_setup_wallet_request",
+  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",
+  LOGOUT_REQUEST: "air_auth_logout_request",
+  LOGOUT_RESPONSE: "air_auth_logout_response"
+};
+
+export { AirAuthMessageTypes };

package/dist/lib.esm/common/src/realm/messaging/types.js

@@ -0,0 +1,13 @@
+const AirMessageTypes = {
+  SERVICE_INITIALIZED: "air_service_initialized",
+  SERVICE_INITIALIZED_ERROR: "air_service_initialized_error",
+  LOGIN_REQUEST: "air_login_request",
+  CLAIM_REQUEST: "air_claim_request",
+  LOGIN_CLAIM_STATE: "air_login_claim_state",
+  CLOSE_MODAL: "air_close_modal",
+  INIT_AUTH_COMMUNICATION: "air_init_auth_communication",
+  DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
+  DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response"
+};
+
+export { AirMessageTypes };

package/dist/lib.esm/ws-embed/src/PopupHandler.js

@@ -0,0 +1,62 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { getPopupFeatures, FEATURES_DEFAULT_POPUP_WINDOW } from '@toruslabs/base-controllers';
+import { SafeEventEmitter } from '@web3auth/auth';
+
+class PopupHandler extends SafeEventEmitter {
+  constructor({
+    url,
+    target,
+    features,
+    timeout = 30000
+  }) {
+    super();
+    _defineProperty(this, "url", void 0);
+    _defineProperty(this, "target", void 0);
+    _defineProperty(this, "features", void 0);
+    _defineProperty(this, "window", void 0);
+    _defineProperty(this, "windowTimer", void 0);
+    _defineProperty(this, "iClosedWindow", void 0);
+    _defineProperty(this, "timeout", void 0);
+    this.url = url;
+    this.target = target || "_blank";
+    this.features = features || getPopupFeatures(FEATURES_DEFAULT_POPUP_WINDOW);
+    this.window = undefined;
+    this.windowTimer = undefined;
+    this.iClosedWindow = false;
+    this.timeout = timeout;
+    this._setupTimer();
+  }
+  _setupTimer() {
+    this.windowTimer = Number(setInterval(() => {
+      if (this.window && this.window.closed) {
+        clearInterval(this.windowTimer);
+        setTimeout(() => {
+          if (!this.iClosedWindow) {
+            this.emit("close");
+          }
+          this.iClosedWindow = false;
+          this.window = undefined;
+        }, this.timeout);
+      }
+      if (this.window === undefined) clearInterval(this.windowTimer);
+    }, 500));
+  }
+  open() {
+    var _this$window;
+    this.window = window.open(this.url.href, this.target, this.features);
+    if ((_this$window = this.window) !== null && _this$window !== void 0 && _this$window.focus) this.window.focus();
+  }
+  close() {
+    this.iClosedWindow = true;
+    if (this.window) this.window.close();
+  }
+  redirect(locationReplaceOnRedirect) {
+    if (locationReplaceOnRedirect) {
+      window.location.replace(this.url.href);
+    } else {
+      window.location.href = this.url.href;
+    }
+  }
+}
+
+export { PopupHandler as default };

package/dist/lib.esm/ws-embed/src/airService.js

@@ -0,0 +1,362 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _classPrivateMethodInitSpec from '@babel/runtime/helpers/classPrivateMethodInitSpec';
+import _classPrivateFieldInitSpec from '@babel/runtime/helpers/classPrivateFieldInitSpec';
+import { randomId } from '@toruslabs/base-controllers';
+import { AirAuthMessageTypes } from '../../common/src/realm/messaging/auth.js';
+import RealmEmbed from './embed.js';
+import { AirServiceError } from './error.js';
+import { IframeController } from './iframeController.js';
+import { EMBED_BUILD_ENV } from './interfaces.js';
+import log from './loglevel.js';
+import AirMessageService from './messageService.js';
+import { AIR_URLS, isElement } from './utils.js';
+
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var _authIframeController = /*#__PURE__*/new WeakMap();
+var _loginResult = /*#__PURE__*/new WeakMap();
+var _buildEnv = /*#__PURE__*/new WeakMap();
+var _embedNonce = /*#__PURE__*/new WeakMap();
+var _enableLogging = /*#__PURE__*/new WeakMap();
+var _isInitialized = /*#__PURE__*/new WeakMap();
+var _partnerId = /*#__PURE__*/new WeakMap();
+var _realmEmbed = /*#__PURE__*/new WeakMap();
+var _walletInitialization = /*#__PURE__*/new WeakMap();
+var _airAuthListener = /*#__PURE__*/new WeakMap();
+var _AirService_brand = /*#__PURE__*/new WeakSet();
+class AirService {
+  constructor({
+    partnerId
+  }) {
+    _classPrivateMethodInitSpec(this, _AirService_brand);
+    _classPrivateFieldInitSpec(this, _authIframeController, void 0);
+    _classPrivateFieldInitSpec(this, _loginResult, void 0);
+    _classPrivateFieldInitSpec(this, _buildEnv, void 0);
+    _classPrivateFieldInitSpec(this, _embedNonce, randomId());
+    _classPrivateFieldInitSpec(this, _enableLogging, false);
+    _classPrivateFieldInitSpec(this, _isInitialized, false);
+    _classPrivateFieldInitSpec(this, _partnerId, void 0);
+    // Realm Embed related
+    _classPrivateFieldInitSpec(this, _realmEmbed, void 0);
+    _classPrivateFieldInitSpec(this, _walletInitialization, void 0);
+    _classPrivateFieldInitSpec(this, _airAuthListener, []);
+    _classPrivateFieldSet(_partnerId, this, partnerId);
+    _classPrivateFieldSet(_realmEmbed, this, new RealmEmbed({
+      partnerId: _classPrivateFieldGet(_partnerId, this)
+    }));
+  }
+  get buildEnv() {
+    return _classPrivateFieldGet(_buildEnv, this);
+  }
+  get isAirAuth() {
+    return true;
+  }
+  get isInitialized() {
+    return _classPrivateFieldGet(_isInitialized, this);
+  }
+  get isLoggedIn() {
+    return !!_classPrivateFieldGet(_loginResult, this);
+  }
+  get isWalletLoaded() {
+    var _classPrivateFieldGet2;
+    return (_classPrivateFieldGet2 = _classPrivateFieldGet(_realmEmbed, this)) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.isInitialized;
+  }
+  async init({
+    buildEnv = EMBED_BUILD_ENV.PRODUCTION,
+    enableLogging = false,
+    skipRehydration = false
+  }) {
+    if (!_classPrivateFieldGet(_partnerId, this)) throw new Error("Partner ID is required to initialize auth service");
+    if (_classPrivateFieldGet(_isInitialized, this)) return;
+    _classPrivateFieldSet(_buildEnv, this, buildEnv);
+    _classPrivateFieldSet(_enableLogging, this, enableLogging);
+    const {
+      authUrl,
+      logLevel
+    } = AIR_URLS[buildEnv];
+    log.setDefaultLevel(logLevel);
+    if (_classPrivateFieldGet(_enableLogging, this)) log.enableAll();else log.disableAll();
+    const authIframeOrigin = new URL(authUrl).origin;
+    await AirMessageService.openAuthObservables({
+      authIframeOrigin
+    });
+    _classPrivateFieldSet(_authIframeController, this, new IframeController(authUrl, `air-login-${_classPrivateFieldGet(_embedNonce, this)}`));
+    AirMessageService.authMessage$.subscribe(async msg => {
+      switch (msg.type) {
+        case AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST:
+          {
+            const authIframeController = _classPrivateFieldGet(_authIframeController, this);
+            authIframeController.setIframeVisibility(msg.payload.visible);
+            authIframeController.updateIframeState();
+            break;
+          }
+        case AirAuthMessageTypes.SETUP_WALLET_REQUEST:
+          {
+            await _assertClassBrand(_AirService_brand, this, _initializeWallet).call(this);
+            break;
+          }
+      }
+    });
+    try {
+      _classPrivateFieldGet(_authIframeController, this).createIframe();
+      const initializationPromise = new Promise((resolve, reject) => {
+        const handleAuthMessage = ev => {
+          try {
+            if (ev.origin !== authIframeOrigin) return;
+            if (ev.data === AirAuthMessageTypes.SETUP_COMPLETED) {
+              window.removeEventListener("message", handleAuthMessage);
+              _classPrivateFieldGet(_authIframeController, this).postMessage({
+                type: AirAuthMessageTypes.INITIALIZATION_REQUEST,
+                payload: {
+                  partnerId: _classPrivateFieldGet(_partnerId, this),
+                  skipRehydration
+                }
+              });
+              resolve();
+            }
+          } catch (err) {
+            reject(err);
+          }
+        };
+        window.addEventListener("message", handleAuthMessage);
+      });
+      const authServiceInitialization = AirMessageService.waitForAuthInitialization();
+      const result = await Promise.all([initializationPromise, authServiceInitialization]);
+      _classPrivateFieldSet(_isInitialized, this, true);
+      _assertClassBrand(_AirService_brand, this, _triggerAirAuthInitialized).call(this);
+      _assertClassBrand(_AirService_brand, this, _prepareRealmEmbedListeners).call(this);
+
+      // rehydrated auth session
+      if (result[1].rehydrated) {
+        _classPrivateFieldSet(_loginResult, this, _assertClassBrand(_AirService_brand, this, _createLoginResult).call(this, result[1]));
+        _assertClassBrand(_AirService_brand, this, _triggerAirAuthLoggedIn).call(this);
+        return _classPrivateFieldGet(_loginResult, this);
+      }
+    } catch (error) {
+      log.debug("Error initializing auth service", error);
+      await this.cleanUp();
+      throw error;
+    }
+    return null;
+  }
+  async cleanUp() {
+    var _classPrivateFieldGet3;
+    // Clear up wallet service iframe if exists
+    await _assertClassBrand(_AirService_brand, this, _cleanUpWallet).call(this);
+
+    // Logout auth session
+    await AirMessageService.logoutAuth(_classPrivateFieldGet(_authIframeController, this).iframeElement);
+
+    // Destroy the auth iframe
+    const authIframeElement = (_classPrivateFieldGet3 = _classPrivateFieldGet(_authIframeController, this)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.iframeElement;
+    if (isElement(authIframeElement) && window.document.body.contains(authIframeElement)) {
+      _classPrivateFieldGet(_authIframeController, this).destroy();
+      _classPrivateFieldSet(_authIframeController, this, undefined);
+    }
+
+    // Close the message service
+    AirMessageService.closeAuthObservables();
+    this.clearEventListeners();
+    _classPrivateFieldSet(_isInitialized, this, false);
+  }
+  async login(options) {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Service is not initialized");
+    if (_classPrivateFieldGet(_loginResult, this)) return _classPrivateFieldGet(_loginResult, this);
+    const iframeController = _classPrivateFieldGet(_authIframeController, this);
+    const {
+      payload
+    } = await AirMessageService.sendAuthLoginRequest(iframeController.iframeElement, {
+      partnerLoginToken: options === null || options === void 0 ? void 0 : options.authToken
+    });
+    if (payload.success === true) {
+      _classPrivateFieldSet(_loginResult, this, _assertClassBrand(_AirService_brand, this, _createLoginResult).call(this, payload));
+      _assertClassBrand(_AirService_brand, this, _triggerAirAuthLoggedIn).call(this);
+      return _classPrivateFieldGet(_loginResult, this);
+    }
+    throw new AirServiceError("UNKNOWN_ERROR", "Unknown error occurred");
+  }
+  async deploySmartAccount() {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Service is not initialized");
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this)._deploySmartAccount();
+  }
+  async logout() {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Service is not initialized");
+    if (!this.isLoggedIn) throw new Error("No active session to logout");
+
+    // Clear up wallet
+    await _assertClassBrand(_AirService_brand, this, _cleanUpWallet).call(this);
+    await AirMessageService.logoutAuth(_classPrivateFieldGet(_authIframeController, this).iframeElement);
+    _classPrivateFieldSet(_loginResult, this, undefined);
+    _assertClassBrand(_AirService_brand, this, _triggerAirAuthLoggedOut).call(this);
+  }
+  async getProvider() {
+    if (!this.isLoggedIn) return null;
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this).provider;
+  }
+  async preloadWallet() {
+    return _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+  }
+  async claimAirId(options) {
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this).claimRealmId(options);
+  }
+  async getUserInfo() {
+    if (!this.isLoggedIn) throw new Error("User not logged in");
+    const info = await AirMessageService.sendUserInfoRequest(_classPrivateFieldGet(_authIframeController, this).iframeElement);
+    if (info.payload.success === false) {
+      throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
+    }
+    return {
+      id: info.payload.id,
+      abstractAccountAddress: info.payload.abstractAccountAddress,
+      email: info.payload.email,
+      airIds: info.payload.airIds
+    };
+  }
+  async getPartnerUserInfo() {
+    if (!this.isLoggedIn) throw new Error("User not logged in");
+    const info = await AirMessageService.sendPartnerUserInfoRequest(_classPrivateFieldGet(_authIframeController, this).iframeElement);
+    if (info.payload.success === false) {
+      throw new AirServiceError(info.payload.errorName, info.payload.errorMessage);
+    }
+    return {
+      partnerId: info.payload.partnerId,
+      partnerUserId: info.payload.partnerUserId,
+      airId: info.payload.airId
+    };
+  }
+  on(listener) {
+    if (_classPrivateFieldGet(_airAuthListener, this).indexOf(listener) < 0) _classPrivateFieldGet(_airAuthListener, this).push(listener);
+  }
+  off(listener) {
+    if (_classPrivateFieldGet(_airAuthListener, this).indexOf(listener) >= 0) _classPrivateFieldGet(_airAuthListener, this).splice(_classPrivateFieldGet(_airAuthListener, this).indexOf(listener), 1);
+  }
+  clearEventListeners() {
+    _classPrivateFieldSet(_airAuthListener, this, []);
+  }
+
+  // This is for internal use only
+  // @ts-expect-error for unused function
+  async _showWalletWidget() {
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return _classPrivateFieldGet(_realmEmbed, this)._showWalletWidget();
+  }
+}
+async function _createWallet() {
+  return _classPrivateFieldGet(_realmEmbed, this).login({
+    skipClaiming: true,
+    legacy: false
+  });
+}
+async function _ensureWallet() {
+  if (!this.isLoggedIn) throw new Error("No active session to create wallet");
+  if (!_classPrivateFieldGet(_walletInitialization, this)) {
+    AirMessageService.setupAuthIframe(_classPrivateFieldGet(_authIframeController, this).iframeElement);
+    _classPrivateFieldSet(_walletInitialization, this, (async () => {
+      try {
+        await _assertClassBrand(_AirService_brand, this, _initializeWallet).call(this);
+        return await _assertClassBrand(_AirService_brand, this, _createWallet).call(this);
+      } catch (error) {
+        log.error("Error initializing wallet", error);
+        throw error;
+      }
+    })());
+  }
+  return _classPrivateFieldGet(_walletInitialization, this);
+}
+async function _cleanUpWallet() {
+  if (_classPrivateFieldGet(_walletInitialization, this) || _classPrivateFieldGet(_realmEmbed, this)) {
+    await _classPrivateFieldGet(_walletInitialization, this);
+    await _classPrivateFieldGet(_realmEmbed, this).cleanUp();
+    _classPrivateFieldSet(_walletInitialization, this, undefined);
+  }
+}
+async function _initializeWallet() {
+  if (!_classPrivateFieldGet(_realmEmbed, this).isInitialized) {
+    try {
+      await _classPrivateFieldGet(_realmEmbed, this).init({
+        buildEnv: _classPrivateFieldGet(_buildEnv, this),
+        skipRehydration: true,
+        enableLogging: _classPrivateFieldGet(_enableLogging, this) || false
+      });
+      _classPrivateFieldGet(_authIframeController, this).postMessage({
+        type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+        payload: {
+          success: true
+        }
+      });
+    } catch (error) {
+      log.error("Error initializing wallet", error);
+      _classPrivateFieldGet(_authIframeController, this).postMessage({
+        type: AirAuthMessageTypes.SETUP_WALLET_RESPONSE,
+        payload: {
+          success: false,
+          errorName: "UNKNOWN_ERROR",
+          errorMessage: "Unknown error occurred"
+        }
+      });
+      throw error;
+    }
+  }
+}
+async function _triggerEventListeners(data) {
+  _classPrivateFieldGet(_airAuthListener, this).forEach(listener => {
+    listener(data);
+  });
+}
+async function _triggerAirAuthInitialized() {
+  await _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+    event: "initialized"
+  });
+}
+async function _triggerAirAuthLoggedIn() {
+  await _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+    event: "logged_in",
+    result: _classPrivateFieldGet(_loginResult, this)
+  });
+}
+async function _triggerAirAuthLoggedOut() {
+  await _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+    event: "logged_out"
+  });
+}
+function _createLoginResult(payload) {
+  return {
+    isLoggedIn: true,
+    id: payload.id,
+    abstractAccountAddress: payload.abstractAccountAddress,
+    token: payload.partnerAccessToken
+  };
+}
+async function _prepareRealmEmbedListeners() {
+  _classPrivateFieldGet(_realmEmbed, this).on(data => {
+    if (data.event === "connected" || data.event === "logged_in") {
+      var _data$result$addresse;
+      const result = _objectSpread(_objectSpread({}, data.result), {}, {
+        addresses: {
+          eoa: data.result.addresses.eoa,
+          aa: (_data$result$addresse = data.result.addresses.aa) !== null && _data$result$addresse !== void 0 ? _data$result$addresse : ""
+        }
+      });
+      _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+        event: "wallet_loaded",
+        result
+      });
+    } else if (data.event === "minting_started") {
+      _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+        event: "minting_started"
+      });
+    } else if (data.event === "minting_failed") {
+      _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
+        event: "minting_failed",
+        errorMessage: data.errorMessage
+      });
+    }
+  });
+}
+
+export { AirService as default };