@mocanetwork/airkit 0.5.0-beta.2

package/dist/airkit.esm.js

@@ -0,0 +1,2468 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _classPrivateMethodInitSpec from '@babel/runtime/helpers/classPrivateMethodInitSpec';
+import _classPrivateFieldInitSpec from '@babel/runtime/helpers/classPrivateFieldInitSpec';
+import { createLoggerMiddleware, getPopupFeatures, FEATURES_DEFAULT_POPUP_WINDOW, COMMUNICATION_JRPC_METHODS, COMMUNICATION_NOTIFICATIONS, PROVIDER_JRPC_METHODS, PROVIDER_NOTIFICATIONS, CHAIN_NAMESPACES, randomId, CONFIRMATION_STRATEGY, BUTTON_POSITION as BUTTON_POSITION$1, SETUP_COMPLETE, FEATURES_CONFIRM_WINDOW, FEATURES_PROVIDER_CHANGE_WINDOW } from '@toruslabs/base-controllers';
+export { CONFIRMATION_STRATEGY } from '@toruslabs/base-controllers';
+import { METHOD_TYPES } from '@toruslabs/ethereum-controllers';
+import { rpcErrors, SafeEventEmitter, ObjectMultiplex, createStreamMiddleware, JRPCEngine, createIdRemapMiddleware, getRpcPromiseCallback, EthereumProviderError, WEB3AUTH_NETWORK, BasePostMessageStream } from '@web3auth/auth';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import pump from 'pump';
+import loglevel from 'loglevel';
+import dequal from 'fast-deep-equal';
+import { firstValueFrom, filter, lastValueFrom, takeWhile, tap, forkJoin, last, first, Subject, distinctUntilChanged } from 'rxjs';
+
+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"
+};
+
+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"
+};
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function isStream(stream) {
+  return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
+}
+function isWritableStream(stream) {
+  return isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
+}
+function isReadableStream(stream) {
+  return isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
+}
+function isDuplexStream(stream) {
+  return isWritableStream(stream) && isReadableStream(stream);
+}
+
+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: {}
+};
+
+const EMBED_BUILD_ENV = {
+  PRODUCTION: "production",
+  STAGING: "staging",
+  DEVELOPMENT: "development",
+  TESTING: "testing"
+};
+const BUTTON_POSITION = {
+  BOTTOM_LEFT: "bottom-left",
+  TOP_LEFT: "top-left",
+  BOTTOM_RIGHT: "bottom-right",
+  TOP_RIGHT: "top-right"
+};
+const EXTERNAL_LOGIN_PROVIDER = {
+  METAMASK: "metamask",
+  WALLET_CONNECT: "walletconnect",
+  WAGMI: "wagmi"
+};
+
+var log = loglevel.getLogger("ws-embed");
+
+const AIR_URLS = {
+  [EMBED_BUILD_ENV.TESTING]: {
+    authUrl: "http://localhost:8100",
+    walletUrl: "https://lrc-mocaverse.web3auth.io",
+    logLevel: "debug"
+  },
+  [EMBED_BUILD_ENV.DEVELOPMENT]: {
+    authUrl: "http://localhost:8100",
+    walletUrl: "https://localhost:4050",
+    logLevel: "debug"
+  },
+  [EMBED_BUILD_ENV.STAGING]: {
+    authUrl: "https://login.staging.realmnetwork.io",
+    walletUrl: "https://account.staging.realmnetwork.io",
+    logLevel: "info"
+  },
+  [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 = 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();
+      }
+      log.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}`;
+  }
+  log.warn(warningMsg);
+  if (emitter && emitter.listenerCount("error") > 0) {
+    emitter.emit("error", warningMsg);
+  }
+}
+const EMITTED_NOTIFICATIONS = ["eth_subscription" // per eth-json-rpc-filters/subscriptionManager
+];
+
+/**
+ * @param connectionStream - A Node.js duplex stream
+ * @param opts - An options bag
+ */
+class BaseProvider extends SafeEventEmitter {
+  constructor(connectionStream, {
+    maxEventListeners = 100,
+    jsonRpcStreamName = "provider"
+  }) {
+    super();
+    _defineProperty(this, "rpcEngine", void 0);
+    _defineProperty(this, "jsonRpcConnectionEvents", void 0);
+    /**
+     * Indicating that this provider is a Web3Auth provider.
+     */
+    _defineProperty(this, "isWeb3Auth", void 0);
+    _defineProperty(this, "state", void 0);
+    if (!isDuplexStream(connectionStream)) {
+      throw new Error(messages.errors.invalidDuplexStream());
+    }
+    this.isWeb3Auth = true;
+    this.setMaxListeners(maxEventListeners);
+    this.handleConnect = this.handleConnect.bind(this);
+    this.handleDisconnect = this.handleDisconnect.bind(this);
+    this.handleStreamDisconnect = this.handleStreamDisconnect.bind(this);
+    this.rpcRequest = this.rpcRequest.bind(this);
+    this.initializeState = this.initializeState.bind(this);
+    this.request = this.request.bind(this);
+    this.sendAsync = this.sendAsync.bind(this);
+    this.send = this.send.bind(this);
+    // this.enable = this.enable.bind(this);
+
+    // setup connectionStream multiplexing
+    const mux = new ObjectMultiplex();
+    pump(connectionStream, mux, connectionStream, this.handleStreamDisconnect.bind(this, "Web3Auth"));
+
+    // ignore phishing warning message (handled elsewhere)
+    mux.ignoreStream("phishing");
+
+    // setup own event listeners
+    // connect to async provider
+
+    const jsonRpcConnection = createStreamMiddleware();
+    pump(jsonRpcConnection.stream, mux.createStream(jsonRpcStreamName), jsonRpcConnection.stream, this.handleStreamDisconnect.bind(this, "Web3Auth RpcProvider"));
+
+    // handle RPC requests via dapp-side rpc engine
+    const rpcEngine = new JRPCEngine();
+    rpcEngine.push(createIdRemapMiddleware());
+    rpcEngine.push(createErrorMiddleware());
+    rpcEngine.push(createLoggerMiddleware({
+      origin: location.origin
+    }));
+    rpcEngine.push(jsonRpcConnection.middleware);
+    this.rpcEngine = rpcEngine;
+    this.jsonRpcConnectionEvents = jsonRpcConnection.events;
+  }
+
+  /**
+   * Submits an RPC request for the given method, with the given params.
+   * Resolves with the result of the method call, or rejects on error.
+   *
+   * @param args - The RPC request arguments.
+   * @returns A Promise that resolves with the result of the RPC method,
+   * or rejects if an error is encountered.
+   */
+  async request(args) {
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+      throw rpcErrors.invalidRequest({
+        message: messages.errors.invalidRequestArgs(),
+        data: _objectSpread(_objectSpread({}, args || {}), {}, {
+          cause: messages.errors.invalidRequestArgs()
+        })
+      });
+    }
+    const {
+      method,
+      params
+    } = args;
+    if (typeof method !== "string" || method.length === 0) {
+      throw rpcErrors.invalidRequest({
+        message: messages.errors.invalidRequestMethod(),
+        data: _objectSpread(_objectSpread({}, args || {}), {}, {
+          cause: messages.errors.invalidRequestArgs()
+        })
+      });
+    }
+    if (params !== undefined && !Array.isArray(params) && (typeof params !== "object" || params === null)) {
+      throw rpcErrors.invalidRequest({
+        message: messages.errors.invalidRequestParams(),
+        data: _objectSpread(_objectSpread({}, args || {}), {}, {
+          cause: messages.errors.invalidRequestArgs()
+        })
+      });
+    }
+    return new Promise((resolve, reject) => {
+      this.rpcRequest({
+        method,
+        params
+      }, getRpcPromiseCallback(resolve, reject));
+    });
+  }
+  /**
+   * Submits an RPC request per the given JSON-RPC request object.
+   *
+   * @param payload - The RPC request object.
+   * @param cb - The callback function.
+   */
+  send(payload, callback) {
+    this.rpcRequest(payload, callback);
+  }
+  /**
+   * Submits an RPC request per the given JSON-RPC request object.
+   *
+   * @param payload - The RPC request object.
+   * @param cb - The callback function.
+   */
+  sendAsync(payload) {
+    return new Promise((resolve, reject) => {
+      this.rpcRequest(payload, getRpcPromiseCallback(resolve, reject));
+    });
+  }
+
+  /**
+   * Called when connection is lost to critical streams.
+   *
+   * emits InpageProvider#disconnect
+   */
+  handleStreamDisconnect(streamName, error) {
+    logStreamDisconnectWarning(streamName, error, this);
+    this.handleDisconnect(false, error ? error.message : undefined);
+  }
+
+  // Private Methods
+  //= ===================
+  /**
+   * Constructor helper.
+   * Populates initial state by calling 'wallet_getProviderState' and emits
+   * necessary events.
+   */
+
+  /**
+   * Internal RPC method. Forwards requests to background via the RPC engine.
+   * Also remap ids inbound and outbound
+   */
+
+  /**
+   * When the provider becomes connected, updates internal state and emits
+   * required events. Idempotent.
+   *
+   * @param chainId - The ID of the newly connected chain.
+   * emits InPageProvider#connect
+   */
+
+  /**
+   * When the provider becomes disconnected, updates internal state and emits
+   * required events. Idempotent with respect to the isRecoverable parameter.
+   *
+   * Error codes per the CloseEvent status codes as required by EIP-1193:
+   * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+   *
+   * @param isRecoverable - Whether the disconnection is recoverable.
+   * @param errorMessage - A custom error message.
+   * emits InpageProvider#disconnect
+   */
+}
+
+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;
+    }
+  }
+}
+
+/**
+ * @param connectionStream - A Node.js duplex stream
+ * @param  opts - An options bag
+ */
+class CommunicationProvider extends BaseProvider {
+  constructor(connectionStream, {
+    maxEventListeners = 100,
+    jsonRpcStreamName = "provider"
+  }, state) {
+    super(connectionStream, {
+      maxEventListeners,
+      jsonRpcStreamName
+    });
+
+    // private state
+    _defineProperty(this, "tryWindowHandle", void 0);
+    _defineProperty(this, "onLoginStateHandle", void 0);
+    _defineProperty(this, "windowRefs", void 0);
+    _defineProperty(this, "iframeUrl", void 0);
+    _defineProperty(this, "iframeId", void 0);
+    this.state = _objectSpread(_objectSpread({}, CommunicationProvider.defaultState), state);
+
+    // public state
+    this.iframeUrl = "";
+    this.iframeId = "";
+    this.windowRefs = new Map();
+
+    // setup own event listeners
+
+    // EIP-1193 connect
+    this.on("connect", () => {
+      this.state.isConnected = true;
+    });
+    const notificationHandler = payload => {
+      const {
+        method,
+        params
+      } = payload;
+      // create_window should never come here..
+      // we either pre-open from embed.
+      // if it's blocked, we communicate down that it's blocked and we show full screen iframe and open from iframe
+      if (method === COMMUNICATION_NOTIFICATIONS.IFRAME_STATUS) {
+        const {
+          isFullScreen,
+          rid
+        } = params;
+        this.displayIframe({
+          isFull: isFullScreen,
+          rid: rid
+        }, true);
+      } else if (method === COMMUNICATION_NOTIFICATIONS.CLOSE_WINDOW) {
+        this.handleCloseWindow(params);
+      } else if (method === COMMUNICATION_NOTIFICATIONS.USER_LOGGED_IN) {
+        log.info("[TEST METAMASK] User received notification ", COMMUNICATION_NOTIFICATIONS.USER_LOGGED_IN);
+        const {
+          currentLoginProvider
+        } = params;
+        this.state.isLoggedIn = true;
+        this.state.currentLoginProvider = currentLoginProvider;
+        if (this.onLoginStateHandle) this.onLoginStateHandle(true);
+      } else if (method === COMMUNICATION_NOTIFICATIONS.USER_LOGGED_OUT) {
+        this.state.isLoggedIn = false;
+        this.state.currentLoginProvider = null;
+        this.displayIframe();
+        if (this.onLoginStateHandle) this.onLoginStateHandle(false);
+      }
+    };
+    this.jsonRpcConnectionEvents.on("notification", notificationHandler);
+  }
+  get isLoggedIn() {
+    return this.state.isLoggedIn;
+  }
+
+  // e.g. Metamask, WalletConnect, etc.
+  get isExternalWallet() {
+    return !this.state.currentLoginProvider || this.state.currentLoginProvider === EXTERNAL_LOGIN_PROVIDER.METAMASK || this.state.currentLoginProvider === EXTERNAL_LOGIN_PROVIDER.WALLET_CONNECT || this.state.currentLoginProvider === EXTERNAL_LOGIN_PROVIDER.WAGMI;
+  }
+  get isIFrameFullScreen() {
+    return this.state.isIFrameFullScreen;
+  }
+
+  /**
+   * Returns whether the inPage provider is connected to Torus.
+   */
+  isConnected() {
+    return this.state.isConnected;
+  }
+  async initializeState(params) {
+    try {
+      const {
+        torusUrl,
+        torusIframeId
+      } = params;
+      this.iframeUrl = torusUrl;
+      this.iframeId = torusIframeId;
+      const {
+        currentLoginProvider,
+        isLoggedIn
+      } = await this.request({
+        method: COMMUNICATION_JRPC_METHODS.GET_PROVIDER_STATE,
+        params: []
+      });
+
+      // indicate that we've connected, for EIP-1193 compliance
+      if (isLoggedIn) this.handleConnect(currentLoginProvider, isLoggedIn);
+    } catch (error) {
+      log.error("Web3Auth: Failed to get initial state. Please report this bug.", error);
+    } finally {
+      log.info("initialized communication state");
+      this.state.initialized = true;
+    }
+  }
+  hideTorusButton() {
+    this.state.widgetVisibility = false;
+    this.displayIframe();
+  }
+  showTorusButton() {
+    this.state.widgetVisibility = true;
+    this.displayIframe();
+  }
+  moveToBackground() {
+    this.state.isBackground = true;
+    this.displayIframe({
+      isFull: this.state.isIFrameFullScreen
+    });
+  }
+  moveToForeground() {
+    this.state.isBackground = false;
+    this.displayIframe({
+      isFull: this.state.isIFrameFullScreen
+    });
+  }
+  setIframeVisibility({
+    isVisible
+  }) {
+    this.state.isBackground = !isVisible;
+  }
+  displayIframe({
+    isFull = false,
+    rid = ""
+  } = {}, walletRequest = false) {
+    const style = {};
+    // set phase
+    if (!isFull) {
+      style.display = this.state.widgetVisibility && !this.state.isBackground ? "block" : "none";
+      style.height = "70px";
+      style.width = "70px";
+      switch (this.state.buttonPosition) {
+        case BUTTON_POSITION.TOP_LEFT:
+          style.top = "0px";
+          style.left = "0px";
+          style.right = "auto";
+          style.bottom = "auto";
+          break;
+        case BUTTON_POSITION.TOP_RIGHT:
+          style.top = "0px";
+          style.right = "0px";
+          style.left = "auto";
+          style.bottom = "auto";
+          break;
+        case BUTTON_POSITION.BOTTOM_RIGHT:
+          style.bottom = "0px";
+          style.right = "0px";
+          style.top = "auto";
+          style.left = "auto";
+          break;
+        case BUTTON_POSITION.BOTTOM_LEFT:
+        default:
+          style.bottom = "0px";
+          style.left = "0px";
+          style.top = "auto";
+          style.right = "auto";
+          break;
+      }
+    } else {
+      style.display = this.state.isBackground ? "none" : "block";
+      style.width = "100%";
+      style.height = "100%";
+      style.top = "0px";
+      style.right = "0px";
+      style.left = "0px";
+      style.bottom = "0px";
+    }
+    const iframe = document.getElementById(this.iframeId);
+    Object.assign(iframe.style, style);
+    this.state.isIFrameFullScreen = isFull;
+    if (!walletRequest) {
+      this.request({
+        method: COMMUNICATION_JRPC_METHODS.IFRAME_STATUS,
+        params: {
+          isIFrameFullScreen: isFull,
+          rid
+        }
+      });
+    }
+  }
+
+  /**
+   * Scenarios:
+   * - Login request or pre-open confirmation windows
+   * We try to open here or send a rpc request to iframe that window is blocked.
+   */
+  async handleWindow(windowId, {
+    url,
+    target,
+    features,
+    timeout
+  } = {}) {
+    const finalUrl = new URL(url || `${this.iframeUrl}/redirect?windowId=${windowId}&sessionNamespace=${window.location.hostname}`);
+    const handledWindow = new PopupHandler({
+      url: finalUrl,
+      target,
+      features,
+      timeout
+    });
+    handledWindow.open();
+    if (!handledWindow.window) {
+      this.displayIframe({
+        isFull: true
+      });
+      this.request({
+        method: COMMUNICATION_JRPC_METHODS.WINDOW_BLOCKED,
+        params: {
+          windowId,
+          finalUrl: finalUrl.href
+        }
+      });
+      return;
+    }
+    // Add to collection only if window is opened
+    this.windowRefs.set(windowId, handledWindow);
+    handledWindow.once("close", () => {
+      // user closed the window
+      this.windowRefs.delete(windowId);
+      this.request({
+        method: COMMUNICATION_JRPC_METHODS.CLOSED_WINDOW,
+        params: {
+          windowId
+        }
+      });
+    });
+  }
+
+  /**
+   * Internal RPC method. Forwards requests to background via the RPC engine.
+   * Also remap ids inbound and outbound
+   */
+  rpcRequest(payload, callback) {
+    const cb = callback;
+    const _payload = payload;
+    if (!Array.isArray(_payload)) {
+      if (!_payload.jsonrpc) {
+        _payload.jsonrpc = "2.0";
+      }
+    }
+    this.rpcEngine.handle(_payload, cb);
+  }
+
+  /**
+   * When the provider becomes connected, updates internal state and emits
+   * required events. Idempotent.
+   *
+   * @param currentLoginProvider - The login Provider
+   * emits TorusInpageProvider#connect
+   */
+  handleConnect(currentLoginProvider, isLoggedIn) {
+    if (!this.state.isConnected) {
+      this.state.isConnected = true;
+      this.emit("connect", {
+        currentLoginProvider,
+        isLoggedIn
+      });
+      log.debug(messages.info.connected(currentLoginProvider));
+    }
+  }
+
+  /**
+   * When the provider becomes disconnected, updates internal state and emits
+   * required events. Idempotent with respect to the isRecoverable parameter.
+   *
+   * Error codes per the CloseEvent status codes as required by EIP-1193:
+   * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+   *
+   * @param isRecoverable - Whether the disconnection is recoverable.
+   * @param errorMessage - A custom error message.
+   * emits TorusInpageProvider#disconnect
+   */
+  handleDisconnect(isRecoverable, errorMessage) {
+    if (this.state.isConnected || !this.state.isPermanentlyDisconnected && !isRecoverable) {
+      this.state.isConnected = false;
+      let error;
+      if (isRecoverable) {
+        error = new EthereumProviderError(1013,
+        // Try again later
+        errorMessage || messages.errors.disconnected());
+        log.debug(error);
+      } else {
+        error = new EthereumProviderError(1011,
+        // Internal error
+        errorMessage || messages.errors.permanentlyDisconnected());
+        log.error(error);
+        this.state.currentLoginProvider = null;
+        this.state.isLoggedIn = false;
+        this.state.widgetVisibility = false;
+        this.state.isIFrameFullScreen = false;
+        this.state.isPermanentlyDisconnected = true;
+      }
+      this.emit("disconnect", error);
+    }
+  }
+  handleCloseWindow(params) {
+    const {
+      windowId
+    } = params;
+    if (this.windowRefs.has(windowId)) {
+      this.windowRefs.get(windowId).close();
+      this.windowRefs.delete(windowId);
+    }
+  }
+}
+_defineProperty(CommunicationProvider, "defaultState", {
+  buttonPosition: "bottom-left",
+  currentLoginProvider: null,
+  isIFrameFullScreen: false,
+  isBackground: false,
+  widgetVisibility: false,
+  initialized: false,
+  isLoggedIn: false,
+  isPermanentlyDisconnected: false,
+  isConnected: false,
+  hasEmittedConnection: false
+});
+
+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
+    };
+  }
+}
+
+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 {}
+
+/**
+ * @param connectionStream - A Node.js duplex stream
+ * @param opts - An options bag
+ */
+class AirInPageProvider extends BaseProvider {
+  constructor(connectionStream, {
+    maxEventListeners = 100,
+    jsonRpcStreamName = "provider"
+  }) {
+    super(connectionStream, {
+      maxEventListeners,
+      jsonRpcStreamName
+    });
+
+    // private state
+    /**
+     * The chain ID of the currently connected EVM chain.
+     * See [chainId.network]{@link https://chainid.network} for more information.
+     */
+    _defineProperty(this, "chainId", void 0);
+    /**
+     * The user's currently selected EVM address.
+     * If null, Torus is either locked or the user has not permitted any
+     * addresses to be viewed.
+     */
+    _defineProperty(this, "selectedAddress", void 0);
+    _defineProperty(this, "tryWindowHandle", void 0);
+    this.state = _objectSpread({}, AirInPageProvider.defaultState);
+
+    // public state
+    this.selectedAddress = null;
+    this.chainId = null;
+    this.handleAccountsChanged = this.handleAccountsChanged.bind(this);
+    this.handleChainChanged = this.handleChainChanged.bind(this);
+    this.handleUnlockStateChanged = this.handleUnlockStateChanged.bind(this);
+
+    // setup own event listeners
+
+    // EIP-1193 connect
+    this.on("connect", () => {
+      this.state.isConnected = true;
+    });
+    const jsonRpcNotificationHandler = payload => {
+      const {
+        method,
+        params
+      } = payload;
+      if (method === PROVIDER_NOTIFICATIONS.ACCOUNTS_CHANGED) {
+        this.handleAccountsChanged(params);
+      } else if (method === PROVIDER_NOTIFICATIONS.UNLOCK_STATE_CHANGED) {
+        this.handleUnlockStateChanged(params);
+      } else if (method === PROVIDER_NOTIFICATIONS.CHAIN_CHANGED) {
+        this.handleChainChanged(params);
+      } else if (EMITTED_NOTIFICATIONS.includes(method)) {
+        this.emit("data", payload);
+        this.emit("notification", params.result);
+        this.emit("message", {
+          type: method,
+          data: params
+        });
+      }
+    };
+
+    // json rpc notification listener
+    this.jsonRpcConnectionEvents.on("notification", jsonRpcNotificationHandler);
+  }
+
+  /**
+   * Returns whether the inpage provider is connected to Torus.
+   */
+  isConnected() {
+    return this.state.isConnected;
+  }
+
+  // Private Methods
+  //= ===================
+  /**
+   * Constructor helper.
+   * Populates initial state by calling 'wallet_getProviderState' and emits
+   * necessary events.
+   */
+  async initializeState() {
+    try {
+      const {
+        accounts,
+        chainId,
+        isUnlocked
+      } = await this.request({
+        method: PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE,
+        params: []
+      });
+
+      // indicate that we've connected, for EIP-1193 compliance
+      this.emit("connect", {
+        chainId
+      });
+      this.handleChainChanged({
+        chainId
+      });
+      this.handleUnlockStateChanged({
+        accounts,
+        isUnlocked
+      });
+      this.handleAccountsChanged(accounts);
+    } catch (error) {
+      log.error("WsEmbed: Failed to get initial state. Please report this bug.", error);
+    } finally {
+      log.info("initialized provider state");
+      this.state.initialized = true;
+    }
+  }
+
+  /**
+   * Internal RPC method. Forwards requests to background via the RPC engine.
+   * Also remap ids inbound and outbound
+   */
+  rpcRequest(payload, callback, isInternal = false) {
+    let cb = callback;
+    const _payload = payload;
+    if (!Array.isArray(_payload)) {
+      if (!_payload.jsonrpc) {
+        _payload.jsonrpc = "2.0";
+      }
+      if (_payload.method === "eth_accounts" || _payload.method === "eth_requestAccounts") {
+        // handle accounts changing
+        cb = (err, res) => {
+          this.handleAccountsChanged(res.result || [], _payload.method === "eth_accounts", isInternal);
+          callback(err, res);
+        };
+      } else if (_payload.method === "wallet_getProviderState") {
+        this.rpcEngine.handle(payload, cb);
+        return;
+      }
+    }
+    this.tryWindowHandle(_payload, cb);
+  }
+
+  /**
+   * When the provider becomes connected, updates internal state and emits
+   * required events. Idempotent.
+   *
+   * @param chainId - The ID of the newly connected chain.
+   * emits TorusInpageProvider#connect
+   */
+  handleConnect(chainId) {
+    if (!this.state.isConnected) {
+      this.state.isConnected = true;
+      this.emit("connect", {
+        chainId
+      });
+      log.debug(messages.info.connected(chainId));
+    }
+  }
+
+  /**
+   * When the provider becomes disconnected, updates internal state and emits
+   * required events. Idempotent with respect to the isRecoverable parameter.
+   *
+   * Error codes per the CloseEvent status codes as required by EIP-1193:
+   * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+   *
+   * @param isRecoverable - Whether the disconnection is recoverable.
+   * @param errorMessage - A custom error message.
+   * emits TorusInpageProvider#disconnect
+   */
+  handleDisconnect(isRecoverable, errorMessage) {
+    if (this.state.isConnected || !this.state.isPermanentlyDisconnected && !isRecoverable) {
+      this.state.isConnected = false;
+      let error;
+      if (isRecoverable) {
+        error = new EthereumProviderError(1013,
+        // Try again later
+        errorMessage || messages.errors.disconnected());
+        log.debug(error);
+      } else {
+        error = new EthereumProviderError(1011,
+        // Internal error
+        errorMessage || messages.errors.permanentlyDisconnected());
+        log.error(error);
+        this.chainId = null;
+        this.state.accounts = null;
+        this.selectedAddress = null;
+        this.state.isUnlocked = false;
+        this.state.isPermanentlyDisconnected = true;
+      }
+      this.emit("disconnect", error);
+    }
+  }
+
+  /**
+   * Called when accounts may have changed.
+   */
+  handleAccountsChanged(accounts, isEthAccounts = false, isInternal = false) {
+    // defensive programming
+    let finalAccounts = accounts;
+    if (!Array.isArray(finalAccounts)) {
+      log.error("WsEmbed: Received non-array accounts parameter. Please report this bug.", finalAccounts);
+      finalAccounts = [];
+    }
+    for (const account of accounts) {
+      if (typeof account !== "string") {
+        log.error("WsEmbed: Received non-string account. Please report this bug.", accounts);
+        finalAccounts = [];
+        break;
+      }
+    }
+
+    // emit accountsChanged if anything about the accounts array has changed
+    if (!dequal(this.state.accounts, finalAccounts)) {
+      // we should always have the correct accounts even before eth_accounts
+      // returns, except in cases where isInternal is true
+      if (isEthAccounts && Array.isArray(this.state.accounts) && this.state.accounts.length > 0 && !isInternal) {
+        log.error('WsEmbed: "eth_accounts" unexpectedly updated accounts. Please report this bug.', finalAccounts);
+      }
+      this.state.accounts = finalAccounts;
+      this.emit("accountsChanged", finalAccounts);
+    }
+
+    // handle selectedAddress
+    if (this.selectedAddress !== finalAccounts[0]) {
+      this.selectedAddress = finalAccounts[0] || null;
+    }
+  }
+
+  /**
+   * Upon receipt of a new chainId and networkVersion, emits corresponding
+   * events and sets relevant public state.
+   * Does nothing if neither the chainId nor the networkVersion are different
+   * from existing values.
+   *
+   * emits TorusInpageProvider#chainChanged
+   * @param networkInfo - An object with network info.
+   */
+  handleChainChanged({
+    chainId
+  } = {}) {
+    if (!chainId) {
+      log.error("WsEmbed: Received invalid network parameters. Please report this bug.", {
+        chainId
+      });
+      return;
+    }
+    if (chainId === "loading") {
+      this.handleDisconnect(true);
+    } else {
+      this.handleConnect(chainId);
+      if (chainId !== this.chainId) {
+        this.chainId = chainId;
+        if (this.state.initialized) {
+          this.emit("chainChanged", this.chainId);
+        }
+      }
+    }
+  }
+
+  /**
+   * Upon receipt of a new isUnlocked state, sets relevant public state.
+   * Calls the accounts changed handler with the received accounts, or an empty
+   * array.
+   *
+   * Does nothing if the received value is equal to the existing value.
+   * There are no lock/unlock events.
+   *
+   * @param opts - Options bag.
+   */
+  handleUnlockStateChanged({
+    accounts,
+    isUnlocked
+  } = {}) {
+    if (typeof isUnlocked !== "boolean") {
+      log.error("WsEmbed: Received invalid isUnlocked parameter. Please report this bug.", {
+        isUnlocked
+      });
+      return;
+    }
+    if (isUnlocked !== this.state.isUnlocked) {
+      this.state.isUnlocked = isUnlocked;
+      this.handleAccountsChanged(accounts || []);
+    }
+  }
+}
+_defineProperty(AirInPageProvider, "defaultState", {
+  accounts: null,
+  isConnected: false,
+  isUnlocked: false,
+  initialized: false,
+  isPermanentlyDisconnected: false,
+  hasEmittedConnection: false
+});
+class TorusInPageProvider extends AirInPageProvider {}
+
+const REALM_EMBED_MESSAGES = [AirMessageTypes.LOGIN_CLAIM_STATE, AirMessageTypes.CLOSE_MODAL, AirMessageTypes.SERVICE_INITIALIZED, AirMessageTypes.SERVICE_INITIALIZED_ERROR, AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE];
+const AUTH_EMBED_MESSAGES = [AirAuthMessageTypes.LOGIN_RESPONSE, AirAuthMessageTypes.USER_INFO_RESPONSE, AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE, AirAuthMessageTypes.REFRESH_TOKEN_RESPONSE, AirAuthMessageTypes.INITIALIZATION_RESPONSE, AirAuthMessageTypes.LOGOUT_RESPONSE, AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST, AirAuthMessageTypes.SETUP_WALLET_REQUEST];
+class AirMessageService {
+  constructor() {
+    _defineProperty(this, "airMessages$", void 0);
+    _defineProperty(this, "_loginState$", void 0);
+    _defineProperty(this, "_authMessage$", void 0);
+    _defineProperty(this, "_authIframe", null);
+    _defineProperty(this, "closeAuthMessageListeners", null);
+    _defineProperty(this, "closeRealmMessageListeners", null);
+  }
+  static get instance() {
+    if (!AirMessageService._instance) {
+      AirMessageService._instance = new AirMessageService();
+    }
+    return AirMessageService._instance;
+  }
+  get messages$() {
+    return this.airMessages$.asObservable();
+  }
+  get loginState$() {
+    return this._loginState$;
+  }
+  get authMessage$() {
+    return this._authMessage$.asObservable();
+  }
+  async openAuthObservables({
+    authIframeOrigin
+  }) {
+    this.closeAuthObservables();
+    this.setupAuthObservables();
+    const handleAuthMessage = async ev => {
+      if (ev.origin !== authIframeOrigin || !ev.data || !(ev.data instanceof Object)) return;
+      log.debug("Embed auth message received from auth", ev.data);
+      if (AUTH_EMBED_MESSAGES.includes(ev.data.type)) {
+        this._authMessage$.next(ev.data);
+      }
+    };
+    window.addEventListener("message", handleAuthMessage);
+    this.closeAuthMessageListeners = () => {
+      window.removeEventListener("message", handleAuthMessage);
+    };
+  }
+  async openRealmObservables({
+    walletIframeOrigin
+  }) {
+    this.closeRealmObservables();
+    this.setupRealmObservables();
+    const handleMessage = async ev => {
+      if (ev.origin !== walletIframeOrigin || !ev.data || !(ev.data instanceof Object)) return;
+      // filter out torus and communication provider messages
+      if ("target" in ev.data && (ev.data.target === "embed_torus" || ev.data.target === "embed_communication")) return;
+      log.debug("Embed realm message received from wallet", ev.data);
+      if (REALM_EMBED_MESSAGES.includes(ev.data.type)) {
+        this.airMessages$.next(ev.data);
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    this.closeRealmMessageListeners = () => {
+      window.removeEventListener("message", handleMessage);
+    };
+  }
+
+  // Note: Only use when embed is needed in airAuth
+  setupAuthIframe(authIframe) {
+    this._authIframe = authIframe;
+  }
+  setupIframeCommunication(walletIframe) {
+    if (!this._authIframe) return;
+    const channel = new MessageChannel();
+    const authOrigin = new URL(this._authIframe.src).origin;
+    this._authIframe.contentWindow.postMessage({
+      type: AirAuthMessageTypes.INIT_WALLET_COMMUNICATION
+    }, authOrigin, [channel.port1]);
+    const walletOrigin = new URL(walletIframe.src).origin;
+    walletIframe.contentWindow.postMessage({
+      type: AirMessageTypes.INIT_AUTH_COMMUNICATION
+    }, walletOrigin, [channel.port2]);
+    this._authIframe = undefined;
+  }
+  onInitialized() {
+    return firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirMessageTypes.SERVICE_INITIALIZED)));
+  }
+  sendLoginRequest(walletIframe, payload) {
+    const response = lastValueFrom(this.loginState$.pipe(takeWhile(msg => (!payload.skipClaimFlow || msg.payload.state !== "connected") && msg.payload.state !== "logged_in" && msg.payload.state !== "claim_flow_cancelled", true), tap(msg => {
+      switch (msg.payload.state) {
+        case "claim_flow_cancelled":
+          throw new RealmEmbedError(msg.payload.errorName, msg.payload.errorMessage);
+      }
+    })));
+    const {
+      origin
+    } = new URL(walletIframe.src);
+    walletIframe.contentWindow.postMessage({
+      type: AirMessageTypes.LOGIN_REQUEST,
+      payload
+    }, origin);
+    return response;
+  }
+  sendClaimRequest(walletIframe, options) {
+    const response = lastValueFrom(forkJoin([this.loginState$.pipe(takeWhile(msg => !["logged_in", "claim_flow_cancelled"].includes(msg.payload.state), true), tap(msg => {
+      if (msg.payload.state === "claim_flow_cancelled") {
+        throw new RealmEmbedError(msg.payload.errorName, msg.payload.errorMessage);
+      }
+    }), last()), this.messages$.pipe(filter(msg => msg.type === AirMessageTypes.CLOSE_MODAL), first())]));
+    const {
+      origin
+    } = new URL(walletIframe.src);
+    walletIframe.contentWindow.postMessage({
+      type: AirMessageTypes.CLAIM_REQUEST,
+      payload: {
+        token: options === null || options === void 0 ? void 0 : options.token,
+        claimInBackground: options === null || options === void 0 ? void 0 : options.background
+      }
+    }, origin);
+    return response;
+  }
+  sendDeploySmartAccountRequest(walletIframe) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE)));
+    const {
+      origin
+    } = new URL(walletIframe.src);
+    walletIframe.contentWindow.postMessage({
+      type: AirMessageTypes.DEPLOY_SMART_ACCOUNT_REQUEST
+    }, origin);
+    return response;
+  }
+  async sendUserInfoRequest(authIframe) {
+    const response = firstValueFrom(this.authMessage$.pipe(filter(msg => msg.type === AirAuthMessageTypes.USER_INFO_RESPONSE)));
+    const {
+      origin
+    } = new URL(authIframe.src);
+    authIframe.contentWindow.postMessage({
+      type: AirAuthMessageTypes.USER_INFO_REQUEST
+    }, origin);
+    return response;
+  }
+  async sendPartnerUserInfoRequest(authIframe) {
+    const response = firstValueFrom(this.authMessage$.pipe(filter(msg => msg.type === AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE)));
+    const {
+      origin
+    } = new URL(authIframe.src);
+    authIframe.contentWindow.postMessage({
+      type: AirAuthMessageTypes.PARTNER_USER_INFO_REQUEST
+    }, origin);
+    return response;
+  }
+  async sendAuthLoginRequest(authIframe, payload) {
+    const response = firstValueFrom(this.authMessage$.pipe(filter(msg => msg.type === AirAuthMessageTypes.LOGIN_RESPONSE)));
+    const {
+      origin
+    } = new URL(authIframe.src);
+    authIframe.contentWindow.postMessage({
+      type: AirAuthMessageTypes.LOGIN_REQUEST,
+      payload
+    }, origin);
+    return response;
+  }
+  async logoutAuth(authIframe) {
+    const response = firstValueFrom(this.authMessage$.pipe(filter(msg => msg.type === AirAuthMessageTypes.LOGOUT_RESPONSE)));
+    const {
+      origin
+    } = new URL(authIframe.src);
+    authIframe.contentWindow.postMessage({
+      type: AirAuthMessageTypes.LOGOUT_REQUEST
+    }, origin);
+    return response;
+  }
+  async waitForAuthInitialization() {
+    const response = await firstValueFrom(this._authMessage$.pipe(filter(msg => msg.type === AirAuthMessageTypes.INITIALIZATION_RESPONSE)));
+    if (response.payload.success === false) {
+      throw new RealmEmbedError(response.payload.errorName, response.payload.errorMessage);
+    }
+    return response.payload;
+  }
+  async waitForWalletInitialization() {
+    const response = await firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirMessageTypes.SERVICE_INITIALIZED || msg.type === AirMessageTypes.SERVICE_INITIALIZED_ERROR)));
+    if (response.type === AirMessageTypes.SERVICE_INITIALIZED_ERROR) {
+      throw new RealmEmbedError(response.payload.errorName, response.payload.errorMessage);
+    }
+  }
+  closeAuthObservables() {
+    if (this._authMessage$ && !this._authMessage$.closed) this._authMessage$.complete();
+    if (this.closeAuthMessageListeners) this.closeAuthMessageListeners();
+  }
+  closeRealmObservables() {
+    if (this.airMessages$ && !this.airMessages$.closed) this.airMessages$.complete();
+    if (this.closeRealmMessageListeners) this.closeRealmMessageListeners();
+  }
+  setupAuthObservables() {
+    this._authMessage$ = new Subject();
+  }
+  setupRealmObservables() {
+    this.airMessages$ = new Subject();
+    this._loginState$ = this.airMessages$.pipe(filter(msg => msg.type === AirMessageTypes.LOGIN_CLAIM_STATE), distinctUntilChanged(dequal));
+  }
+}
+// eslint-disable-next-line no-use-before-define
+_defineProperty(AirMessageService, "_instance", void 0);
+var AirMessageService$1 = AirMessageService.instance;
+
+/**
+ * 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)
+});
+
+function _classPrivateFieldGet$1(s, a) { return s.get(_assertClassBrand$1(s, a)); }
+function _classPrivateFieldSet$1(s, a, r) { return s.set(_assertClassBrand$1(s, a), r), r; }
+function _assertClassBrand$1(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"); }
+
+// preload for iframe doesn't work https://bugs.chromium.org/p/chromium/issues/detail?id=593267
+(async function preLoadIframe() {
+  try {
+    if (typeof document === "undefined") return;
+    const airWalletIframeHtml = document.createElement("link");
+    const {
+      walletUrl: airWalletUrl
+    } = AIR_URLS.production;
+    airWalletIframeHtml.href = `${airWalletUrl}/frame`;
+    airWalletIframeHtml.crossOrigin = "anonymous";
+    airWalletIframeHtml.type = "text/html";
+    airWalletIframeHtml.rel = "prefetch";
+    if (airWalletIframeHtml.relList && airWalletIframeHtml.relList.supports) {
+      if (airWalletIframeHtml.relList.supports("prefetch")) {
+        document.head.appendChild(airWalletIframeHtml);
+      }
+    }
+  } catch (error) {
+    log.warn(error);
+  }
+})();
+new Set([COMMUNICATION_JRPC_METHODS.SET_PROVIDER]);
+const PROVIDER_UNSAFE_METHODS = new Set([METHOD_TYPES.ETH_SIGN, METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4, METHOD_TYPES.PERSONAL_SIGN, METHOD_TYPES.ETH_TRANSACTION, METHOD_TYPES.ADD_CHAIN, METHOD_TYPES.SWITCH_CHAIN]);
+const embedChainConfig = {
+  polygon: {
+    chainNamespace: CHAIN_NAMESPACES.EIP155,
+    chainId: "0x89",
+    decimals: 18,
+    displayName: "Polygon",
+    blockExplorerUrl: "https://polygonscan.com",
+    logo: "https://cryptologos.cc/logos/polygon-matic-logo.png",
+    ticker: "MATIC",
+    tickerName: "Matic Network Token"
+  },
+  polygonAmoy: {
+    chainNamespace: CHAIN_NAMESPACES.EIP155,
+    chainId: "0x13882",
+    decimals: 18,
+    displayName: "Polygon Amoy",
+    blockExplorerUrl: "https://amoy.polygonscan.com",
+    logo: "https://cryptologos.cc/logos/polygon-matic-logo.png",
+    ticker: "MATIC",
+    tickerName: "Matic Network Token",
+    isTestnet: true
+  }
+};
+const web3AuthClientId = "BANbxuTYFGeYi8HxUzaPQkvQlSAXiKRtUqb1vqsXbsZsZKrNr05PEPCM2J2PhUJZpIYl0XzQa6jxUjnYzSU9LXY";
+const web3AuthNetwork = WEB3AUTH_NETWORK.SAPPHIRE_MAINNET;
+var _embedNonce$1 = /*#__PURE__*/new WeakMap();
+var _provider = /*#__PURE__*/new WeakMap();
+var _isInitialized$1 = /*#__PURE__*/new WeakMap();
+var _rehydrationState = /*#__PURE__*/new WeakMap();
+var _modalZIndex = /*#__PURE__*/new WeakMap();
+var _communicationProvider = /*#__PURE__*/new WeakMap();
+var _buttonPosition = /*#__PURE__*/new WeakMap();
+var _realmPartnerId = /*#__PURE__*/new WeakMap();
+var _web3AuthClientId = /*#__PURE__*/new WeakMap();
+var _web3AuthNetwork = /*#__PURE__*/new WeakMap();
+var _isPluginMode = /*#__PURE__*/new WeakMap();
+var _confirmationStrategy = /*#__PURE__*/new WeakMap();
+var _walletIframe = /*#__PURE__*/new WeakMap();
+var _buildEnv$1 = /*#__PURE__*/new WeakMap();
+var _walletAddresses = /*#__PURE__*/new WeakMap();
+var _realmId = /*#__PURE__*/new WeakMap();
+var _loginToken = /*#__PURE__*/new WeakMap();
+var _sessionId = /*#__PURE__*/new WeakMap();
+var _embedListeners = /*#__PURE__*/new WeakMap();
+var _RealmEmbed_brand = /*#__PURE__*/new WeakSet();
+class RealmEmbed {
+  constructor({
+    modalZIndex = 99999,
+    partnerId
+  }) {
+    _classPrivateMethodInitSpec(this, _RealmEmbed_brand);
+    _classPrivateFieldInitSpec(this, _embedNonce$1, randomId());
+    _classPrivateFieldInitSpec(this, _provider, void 0);
+    _classPrivateFieldInitSpec(this, _isInitialized$1, void 0);
+    _classPrivateFieldInitSpec(this, _rehydrationState, void 0);
+    _classPrivateFieldInitSpec(this, _modalZIndex, void 0);
+    _classPrivateFieldInitSpec(this, _communicationProvider, void 0);
+    _classPrivateFieldInitSpec(this, _buttonPosition, void 0);
+    _classPrivateFieldInitSpec(this, _realmPartnerId, void 0);
+    _classPrivateFieldInitSpec(this, _web3AuthClientId, void 0);
+    _classPrivateFieldInitSpec(this, _web3AuthNetwork, void 0);
+    _classPrivateFieldInitSpec(this, _isPluginMode, void 0);
+    _classPrivateFieldInitSpec(this, _confirmationStrategy, void 0);
+    _classPrivateFieldInitSpec(this, _walletIframe, void 0);
+    _classPrivateFieldInitSpec(this, _buildEnv$1, void 0);
+    _classPrivateFieldInitSpec(this, _walletAddresses, void 0);
+    _classPrivateFieldInitSpec(this, _realmId, void 0);
+    _classPrivateFieldInitSpec(this, _loginToken, void 0);
+    _classPrivateFieldInitSpec(this, _sessionId, void 0);
+    _classPrivateFieldInitSpec(this, _embedListeners, []);
+    _classPrivateFieldSet$1(_isInitialized$1, this, false); // init done
+    _classPrivateFieldSet$1(_modalZIndex, this, modalZIndex);
+    _classPrivateFieldSet$1(_realmPartnerId, this, partnerId);
+    _classPrivateFieldSet$1(_web3AuthClientId, this, web3AuthClientId);
+    _classPrivateFieldSet$1(_web3AuthNetwork, this, web3AuthNetwork);
+  }
+  get isConnected() {
+    return !!_classPrivateFieldGet$1(_walletAddresses, this) && _classPrivateFieldGet$1(_communicationProvider, this).isLoggedIn;
+  }
+  get isInitialized() {
+    return _classPrivateFieldGet$1(_isInitialized$1, this) && !!_classPrivateFieldGet$1(_rehydrationState, this);
+  }
+  get isLoggedIn() {
+    return !!_classPrivateFieldGet$1(_realmId, this) && this.isConnected;
+  }
+  get getBuildEnv() {
+    return _classPrivateFieldGet$1(_buildEnv$1, this);
+  }
+  get walletAddresses() {
+    var _classPrivateFieldGet2;
+    return (_classPrivateFieldGet2 = _classPrivateFieldGet$1(_walletAddresses, this)) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : null;
+  }
+  get sessionId() {
+    var _classPrivateFieldGet3;
+    return (_classPrivateFieldGet3 = _classPrivateFieldGet$1(_sessionId, this)) !== null && _classPrivateFieldGet3 !== void 0 ? _classPrivateFieldGet3 : null;
+  }
+  get realmId() {
+    var _classPrivateFieldGet4;
+    return (_classPrivateFieldGet4 = _classPrivateFieldGet$1(_realmId, this)) !== null && _classPrivateFieldGet4 !== void 0 ? _classPrivateFieldGet4 : null;
+  }
+  get provider() {
+    return _classPrivateFieldGet$1(_walletAddresses, this) ? _classPrivateFieldGet$1(_provider, this) : null;
+  }
+  async init({
+    buildEnv = EMBED_BUILD_ENV.PRODUCTION,
+    enableLogging = false,
+    skipRehydration = false
+    // confirmationStrategy = CONFIRMATION_STRATEGY.DEFAULT,
+  } = {}) {
+    if (_classPrivateFieldGet$1(_isInitialized$1, this)) throw new RealmEmbedError("ALREADY_INITIALISED", "Already initialized");
+    _classPrivateFieldSet$1(_buildEnv$1, this, buildEnv);
+    _classPrivateFieldSet$1(_confirmationStrategy, this, CONFIRMATION_STRATEGY.DEFAULT);
+    _classPrivateFieldSet$1(_buttonPosition, this, BUTTON_POSITION$1.BOTTOM_LEFT);
+    const {
+      walletUrl,
+      logLevel
+    } = AIR_URLS[buildEnv];
+    log.info(walletUrl, "url loaded");
+    log.setDefaultLevel(logLevel);
+    if (enableLogging) log.enableAll();else log.disableAll();
+    const walletIframeUrl = _assertClassBrand$1(_RealmEmbed_brand, this, _getWsIframeUrl).call(this);
+    const walletIframeOrigin = walletIframeUrl.origin;
+    AirMessageService$1.openRealmObservables({
+      walletIframeOrigin
+    });
+    _classPrivateFieldSet$1(_walletIframe, this, htmlToElement(`<iframe
+        id="walletIframe-${_classPrivateFieldGet$1(_embedNonce$1, this)}"
+        class="walletIframe-${_classPrivateFieldGet$1(_embedNonce$1, this)}"
+        sandbox="allow-popups allow-scripts allow-same-origin allow-forms allow-modals allow-downloads"
+        src="${walletIframeUrl.href}"
+        style="display: none; position: fixed; top: 0; right: 0; width: 100%; color-scheme: none; border-width: 0px; height: 100%; border: none; border-radius: 0; z-index: ${_classPrivateFieldGet$1(_modalZIndex, this).toString()}"
+        allow="clipboard-write"
+      ></iframe>`));
+    AirMessageService$1.messages$.subscribe(msg => {
+      switch (msg.type) {
+        case AirMessageTypes.SERVICE_INITIALIZED:
+          {
+            _classPrivateFieldSet$1(_rehydrationState, this, msg.payload.rehydration);
+            _assertClassBrand$1(_RealmEmbed_brand, this, _triggerInitializedEvent).call(this);
+            break;
+          }
+      }
+    });
+    AirMessageService$1.loginState$.subscribe(async msg => {
+      switch (msg.payload.state) {
+        case "connected":
+          {
+            await _assertClassBrand$1(_RealmEmbed_brand, this, _onInitialized).call(this);
+            if (msg.payload.addresses && !this.isLoggedIn) {
+              _classPrivateFieldSet$1(_walletAddresses, this, msg.payload.addresses);
+              _classPrivateFieldSet$1(_loginToken, this, msg.payload.token);
+              _classPrivateFieldSet$1(_sessionId, this, msg.payload.sessionId);
+              _assertClassBrand$1(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+                event: "connected",
+                result: {
+                  isLoggedIn: false,
+                  addresses: msg.payload.addresses,
+                  token: msg.payload.token,
+                  sessionId: msg.payload.sessionId
+                }
+              });
+            }
+            break;
+          }
+        case "logged_in":
+          {
+            await _assertClassBrand$1(_RealmEmbed_brand, this, _onInitialized).call(this);
+            const isNotConnectedYet = !_classPrivateFieldGet$1(_walletAddresses, this);
+            _classPrivateFieldSet$1(_realmId, this, msg.payload.airId);
+            _classPrivateFieldSet$1(_walletAddresses, this, msg.payload.addresses);
+            _classPrivateFieldSet$1(_loginToken, this, msg.payload.token);
+            _classPrivateFieldSet$1(_sessionId, this, msg.payload.sessionId);
+            if (isNotConnectedYet) {
+              _assertClassBrand$1(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+                event: "connected",
+                result: {
+                  isLoggedIn: false,
+                  addresses: msg.payload.addresses,
+                  token: msg.payload.token,
+                  sessionId: msg.payload.sessionId
+                }
+              });
+            }
+            _assertClassBrand$1(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+              event: "logged_in",
+              result: {
+                isLoggedIn: true,
+                realmId: msg.payload.airId,
+                addresses: msg.payload.addresses,
+                token: msg.payload.token,
+                sessionId: msg.payload.sessionId
+              }
+            });
+            break;
+          }
+        case "minting_started":
+          {
+            _assertClassBrand$1(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+              event: "minting_started"
+            });
+            break;
+          }
+        case "minting_failed":
+          {
+            _assertClassBrand$1(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+              event: "minting_failed",
+              errorMessage: msg.payload.errorMessage
+            });
+            break;
+          }
+      }
+    });
+    try {
+      // Handle wallet iframe message
+      window.document.body.appendChild(_classPrivateFieldGet$1(_walletIframe, this));
+      const initializeWalletService = new Promise((resolve, reject) => {
+        const handleMessage = async ev => {
+          try {
+            if (ev.origin !== walletIframeOrigin) return;
+            if (ev.data === SETUP_COMPLETE) {
+              window.removeEventListener("message", handleMessage);
+              // send init params here
+              const dappMetadata = await getSiteMetadata();
+              _classPrivateFieldGet$1(_walletIframe, this).contentWindow.postMessage({
+                chainConfig: _classPrivateFieldGet$1(_buildEnv$1, this) === EMBED_BUILD_ENV.PRODUCTION ? embedChainConfig.polygon : embedChainConfig.polygonAmoy,
+                dappMetadata,
+                enableLogging,
+                skipRehydration,
+                realmPartnerId: _classPrivateFieldGet$1(_realmPartnerId, this),
+                web3AuthClientId: _classPrivateFieldGet$1(_web3AuthClientId, this),
+                web3AuthNetwork: _classPrivateFieldGet$1(_web3AuthNetwork, this),
+                confirmationStrategy: _classPrivateFieldGet$1(_confirmationStrategy, this)
+              }, walletIframeOrigin);
+              await _assertClassBrand$1(_RealmEmbed_brand, this, _setupWeb).call(this, {
+                torusUrl: walletUrl
+              });
+              _classPrivateFieldGet$1(_communicationProvider, this).onLoginStateHandle = async isLoggedIn => {
+                if (!isLoggedIn) {
+                  await _assertClassBrand$1(_RealmEmbed_brand, this, _logout).call(this);
+                }
+              };
+              resolve();
+            }
+          } catch (err) {
+            reject(err);
+          }
+        };
+        window.addEventListener("message", handleMessage);
+      });
+      const walletServiceInitialization = AirMessageService$1.waitForWalletInitialization();
+      await Promise.all([initializeWalletService, walletServiceInitialization]);
+      AirMessageService$1.setupIframeCommunication(_classPrivateFieldGet$1(_walletIframe, this));
+      _classPrivateFieldSet$1(_isInitialized$1, this, true);
+      _assertClassBrand$1(_RealmEmbed_brand, this, _triggerInitializedEvent).call(this);
+      log.debug("Wallet service initialization resolved");
+    } catch (error) {
+      log.debug("Wallet service initialization error", error);
+      _assertClassBrand$1(_RealmEmbed_brand, this, _clearInit).call(this, true);
+      throw error;
+    }
+  }
+  moveToBackground() {
+    _classPrivateFieldGet$1(_communicationProvider, this).moveToBackground();
+  }
+  moveToForeground() {
+    _classPrivateFieldGet$1(_communicationProvider, this).moveToForeground();
+  }
+  async getUserInfo() {
+    if (!_classPrivateFieldGet$1(_realmId, this)) return null;
+    const userInfoResponse = await _classPrivateFieldGet$1(_communicationProvider, this).request({
+      method: COMMUNICATION_JRPC_METHODS.USER_INFO,
+      params: []
+    });
+    return _objectSpread(_objectSpread({}, userInfoResponse), {}, {
+      realmId: _classPrivateFieldGet$1(_realmId, this)
+    });
+  }
+  async login(options) {
+    var _options$legacy;
+    return _assertClassBrand$1(_RealmEmbed_brand, this, _login).call(this, options, (_options$legacy = options === null || options === void 0 ? void 0 : options.legacy) !== null && _options$legacy !== void 0 ? _options$legacy : true);
+  }
+  async _deploySmartAccount() {
+    if (!this.isConnected) throw new RealmEmbedError("NOT_LOGGED_IN", "User needs to be connected first");
+    try {
+      await AirMessageService$1.sendDeploySmartAccountRequest(_classPrivateFieldGet$1(_walletIframe, this));
+    } catch (error) {
+      throw RealmEmbedError.from(error);
+    }
+  }
+  // async loginV2<T extends boolean>(options?: {
+  //   skipClaiming: T;
+  //   token?: string;
+  // }): Promise<T extends true ? RealmLoginResult | RealmConnectResult : RealmLoginResult> {
+  //   if (!this.#isInitialized) throw new Error("Call init() first");
+
+  //   const iframeController = this.#authIframeController;
+  //   iframeController.setIframeVisibility(true);
+  //   iframeController.updateIframeState();
+
+  //   const { payload } = await RealmMessageService.sendAuthLoginRequest(iframeController.iframeElement);
+
+  //   iframeController.setIframeVisibility(false);
+  //   iframeController.updateIframeState();
+
+  //   if (payload.success === true) {
+  //     return this.#login({
+  //       skipClaiming: options?.skipClaiming,
+  //       token: options?.token,
+  //     });
+  //   }
+  //   throw new RealmEmbedError(payload.errorName, payload.errorMessage);
+  // }
+
+  // This is for internal use only
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  async _loginWithSessionId(params) {
+    if (!_classPrivateFieldGet$1(_isInitialized$1, this)) throw new Error("Call init() first");
+    if (!params.sessionId) throw new Error("sessionId is required");
+    try {
+      const res = await _classPrivateFieldGet$1(_communicationProvider, this).request({
+        method: COMMUNICATION_JRPC_METHODS.LOGIN_WITH_SESSION_ID,
+        params: [params.sessionId, ""]
+      });
+      log.info("Login with session id", res);
+      return res.success;
+    } catch (error) {
+      log.error("login with session id failed", error);
+      throw error;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  async _showWalletWidget() {
+    _classPrivateFieldGet$1(_communicationProvider, this).showTorusButton();
+  }
+  async claimRealmId(options) {
+    if (!this.isConnected) throw new RealmEmbedError("NOT_CONNECTED", "User needs to be connected first");
+    try {
+      if (options !== null && options !== void 0 && options.background) {
+        _classPrivateFieldGet$1(_communicationProvider, this).setIframeVisibility({
+          isVisible: false
+        });
+      }
+      _classPrivateFieldGet$1(_communicationProvider, this).displayIframe({
+        isFull: true
+      });
+      const claimPromise = AirMessageService$1.sendClaimRequest(_classPrivateFieldGet$1(_walletIframe, this), options);
+      log.debug("before claimPromise");
+      await claimPromise;
+      log.debug("after claimPromise");
+      return {
+        isLoggedIn: true,
+        realmId: _classPrivateFieldGet$1(_realmId, this),
+        addresses: _classPrivateFieldGet$1(_walletAddresses, this),
+        token: _classPrivateFieldGet$1(_loginToken, this),
+        sessionId: _classPrivateFieldGet$1(_sessionId, this)
+      };
+    } catch (e) {
+      throw RealmEmbedError.from(e);
+    } finally {
+      if (options !== null && options !== void 0 && options.background) {
+        _classPrivateFieldGet$1(_communicationProvider, this).setIframeVisibility({
+          isVisible: true
+        });
+      }
+      _classPrivateFieldGet$1(_communicationProvider, this).displayIframe({
+        isFull: false
+      });
+    }
+  }
+  async logout() {
+    if (!_classPrivateFieldGet$1(_communicationProvider, this).isLoggedIn) throw new RealmEmbedError("NOT_LOGGED_IN", "Not logged in");
+    await _assertClassBrand$1(_RealmEmbed_brand, this, _logout).call(this);
+  }
+  async cleanUp() {
+    var _classPrivateFieldGet5;
+    if ((_classPrivateFieldGet5 = _classPrivateFieldGet$1(_communicationProvider, this)) !== null && _classPrivateFieldGet5 !== void 0 && _classPrivateFieldGet5.isLoggedIn) {
+      await this.logout();
+    }
+    await this.clearInit();
+  }
+  async clearInit() {
+    _assertClassBrand$1(_RealmEmbed_brand, this, _clearInit).call(this);
+  }
+  on(listener) {
+    if (_classPrivateFieldGet$1(_embedListeners, this).indexOf(listener) < 0) _classPrivateFieldGet$1(_embedListeners, this).push(listener);
+  }
+  off(listener) {
+    const index = _classPrivateFieldGet$1(_embedListeners, this).indexOf(listener);
+    if (index >= 0) _classPrivateFieldGet$1(_embedListeners, this).splice(index, 1);
+  }
+  clearEventListeners() {
+    _classPrivateFieldSet$1(_embedListeners, this, []);
+  }
+}
+function _getWsIframeUrl() {
+  const {
+    walletUrl
+  } = AIR_URLS[_classPrivateFieldGet$1(_buildEnv$1, this)];
+  const torusIframeUrl = new URL(walletUrl);
+  if (torusIframeUrl.pathname.endsWith("/")) torusIframeUrl.pathname += "frame";else torusIframeUrl.pathname += "/frame";
+  const hashParams = new URLSearchParams();
+  hashParams.append("origin", window.location.origin);
+  torusIframeUrl.hash = hashParams.toString();
+  return torusIframeUrl;
+}
+async function _login(options, isLegacyLogin) {
+  let loginResult;
+  if (this.isLoggedIn) {
+    loginResult = _assertClassBrand$1(_RealmEmbed_brand, this, _createLoginResult$1).call(this);
+  } else if (this.isConnected) {
+    if ((options === null || options === void 0 ? void 0 : options.skipClaiming) === true) {
+      loginResult = _assertClassBrand$1(_RealmEmbed_brand, this, _createLoginResult$1).call(this);
+    } else {
+      loginResult = await this.claimRealmId(options);
+    }
+  } else {
+    loginResult = await _assertClassBrand$1(_RealmEmbed_brand, this, _realmLogin).call(this, options, isLegacyLogin);
+  }
+  return loginResult;
+}
+function _createLoginResult$1() {
+  if (this.isLoggedIn) {
+    return {
+      isLoggedIn: true,
+      realmId: _classPrivateFieldGet$1(_realmId, this),
+      addresses: _classPrivateFieldGet$1(_walletAddresses, this),
+      token: _classPrivateFieldGet$1(_loginToken, this),
+      sessionId: _classPrivateFieldGet$1(_sessionId, this)
+    };
+  }
+  return {
+    isLoggedIn: false,
+    addresses: _classPrivateFieldGet$1(_walletAddresses, this),
+    token: _classPrivateFieldGet$1(_loginToken, this),
+    sessionId: _classPrivateFieldGet$1(_sessionId, this)
+  };
+}
+async function _authLogin(params = {}) {
+  try {
+    if (!params.loginProvider || params.loginProvider === EXTERNAL_LOGIN_PROVIDER.WALLET_CONNECT) {
+      _classPrivateFieldGet$1(_communicationProvider, this).displayIframe({
+        isFull: true
+      });
+    }
+
+    // If user is already logged in, we assume they have given access to the website
+    const res = await new Promise((resolve, reject) => {
+      // We use this method because we want to update inPage provider state with account info
+      _classPrivateFieldGet$1(_provider, this).rpcRequest({
+        method: "eth_requestAccounts",
+        params: [params.loginProvider, params.login_hint]
+      }, getRpcPromiseCallback(resolve, reject));
+    });
+    log.debug("check: res", res);
+    if (Array.isArray(res) && res.length > 0) {
+      if (_classPrivateFieldGet$1(_confirmationStrategy, this) === CONFIRMATION_STRATEGY.AUTO_APPROVE) log.warn("Confirmation strategy auto approve is not allowed on Embed Mode, using Default instead.");
+      return res;
+    }
+    // This would never happen, but just in case
+    throw new Error("Login failed");
+  } catch (error) {
+    log.error("login failed", error);
+    throw error;
+  }
+}
+async function _realmLogin(options, isLegacyLogin) {
+  const skipClaimFlow = (options === null || options === void 0 ? void 0 : options.skipClaiming) === true;
+  try {
+    if (options !== null && options !== void 0 && options.authToken) {
+      _classPrivateFieldGet$1(_communicationProvider, this).setIframeVisibility({
+        isVisible: false
+      });
+    }
+    const loginPromise = Promise.all([_assertClassBrand$1(_RealmEmbed_brand, this, _authLogin).call(this), AirMessageService$1.sendLoginRequest(_classPrivateFieldGet$1(_walletIframe, this), {
+      skipClaimFlow,
+      token: options === null || options === void 0 ? void 0 : options.token,
+      customAuthToken: options === null || options === void 0 ? void 0 : options.authToken,
+      isLegacyLogin: !!isLegacyLogin
+    })]);
+    log.debug("start logging in...");
+    await loginPromise;
+    log.debug("login ended");
+    return _assertClassBrand$1(_RealmEmbed_brand, this, _createLoginResult$1).call(this);
+  } catch (e) {
+    await _assertClassBrand$1(_RealmEmbed_brand, this, _logout).call(this);
+    throw RealmEmbedError.from(e);
+  } finally {
+    if (options !== null && options !== void 0 && options.authToken) {
+      _classPrivateFieldGet$1(_communicationProvider, this).setIframeVisibility({
+        isVisible: true
+      });
+    }
+    _classPrivateFieldGet$1(_communicationProvider, this).displayIframe({
+      isFull: false
+    });
+  }
+}
+async function _logout() {
+  var _classPrivateFieldGet6;
+  const silent = !_classPrivateFieldGet$1(_walletAddresses, this);
+  if ((_classPrivateFieldGet6 = _classPrivateFieldGet$1(_communicationProvider, this)) !== null && _classPrivateFieldGet6 !== void 0 && _classPrivateFieldGet6.isLoggedIn) {
+    await _classPrivateFieldGet$1(_communicationProvider, this).request({
+      method: COMMUNICATION_JRPC_METHODS.LOGOUT,
+      params: []
+    });
+  }
+  if (_classPrivateFieldGet$1(_communicationProvider, this)) _classPrivateFieldGet$1(_communicationProvider, this).onLoginStateHandle = undefined;
+  _classPrivateFieldSet$1(_walletAddresses, this, undefined);
+  _classPrivateFieldSet$1(_realmId, this, undefined);
+  if (!silent) {
+    _assertClassBrand$1(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+      event: "logged_out"
+    });
+  }
+}
+async function _clearInit(isSilent) {
+  function isElement(element) {
+    return element instanceof Element || element instanceof Document;
+  }
+  if (isElement(_classPrivateFieldGet$1(_walletIframe, this)) && window.document.body.contains(_classPrivateFieldGet$1(_walletIframe, this))) {
+    _classPrivateFieldGet$1(_walletIframe, this).remove();
+    _classPrivateFieldSet$1(_walletIframe, this, undefined);
+  }
+  AirMessageService$1.closeRealmObservables();
+  _classPrivateFieldSet$1(_isInitialized$1, this, false);
+  _classPrivateFieldSet$1(_walletAddresses, this, undefined);
+  _classPrivateFieldSet$1(_realmId, this, undefined);
+  if (isSilent === true) _assertClassBrand$1(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+    event: "reset"
+  });
+}
+function _getConfirmationStrategyFinal(payload, communicationProvider) {
+  // for external wallets, we'll show the modal and don't need to open a new window
+  let confirmationStrategyFinal = _classPrivateFieldGet$1(_confirmationStrategy, this);
+  if (!Array.isArray(payload) && PROVIDER_UNSAFE_METHODS.has(payload.method) && _classPrivateFieldGet$1(_confirmationStrategy, this) !== CONFIRMATION_STRATEGY.MODAL && !_classPrivateFieldGet$1(_isPluginMode, this) && !communicationProvider.isExternalWallet) {
+    confirmationStrategyFinal = CONFIRMATION_STRATEGY.POPUP;
+  }
+  return confirmationStrategyFinal;
+}
+async function _setupWeb(providerParams) {
+  log.debug("setup embed communication...");
+  // setup background connection
+  const providerStream = new BasePostMessageStream({
+    name: "embed_torus",
+    target: "iframe_torus",
+    targetWindow: _classPrivateFieldGet$1(_walletIframe, this).contentWindow,
+    targetOrigin: new URL(providerParams.torusUrl).origin
+  });
+
+  // We create another LocalMessageDuplexStream for communication between dapp <> iframe
+  const communicationStream = new BasePostMessageStream({
+    name: "embed_communication",
+    target: "iframe_communication",
+    targetWindow: _classPrivateFieldGet$1(_walletIframe, this).contentWindow,
+    targetOrigin: new URL(providerParams.torusUrl).origin
+  });
+
+  // compose the inPage provider
+  const inPageProvider = new TorusInPageProvider(providerStream, {});
+  const communicationProvider = new CommunicationProvider(communicationStream, {}, {
+    buttonPosition: _classPrivateFieldGet$1(_buttonPosition, this)
+  });
+  inPageProvider.tryWindowHandle = (payload, cb) => {
+    const _payload = payload;
+    const confirmationStrategyFinal = _assertClassBrand$1(_RealmEmbed_brand, this, _getConfirmationStrategyFinal).call(this, payload, communicationProvider);
+    if (confirmationStrategyFinal === CONFIRMATION_STRATEGY.POPUP) {
+      const windowId = randomId();
+      communicationProvider.handleWindow(windowId, {
+        target: "_blank",
+        features: getPopupFeatures(FEATURES_CONFIRM_WINDOW),
+        timeout: 500
+      });
+      // for inPageProvider methods sending windowId in request instead of params
+      // as params might be positional.
+      _payload.windowId = windowId;
+    }
+    inPageProvider.rpcEngine.handle(_payload, cb);
+  };
+  communicationProvider.tryWindowHandle = (payload, cb) => {
+    const _payload = payload;
+    const confirmationStrategyFinal = _assertClassBrand$1(_RealmEmbed_brand, this, _getConfirmationStrategyFinal).call(this, payload, communicationProvider);
+    if (confirmationStrategyFinal === CONFIRMATION_STRATEGY.POPUP) {
+      const windowId = randomId();
+      communicationProvider.handleWindow(windowId, {
+        target: "_blank",
+        features: getPopupFeatures(FEATURES_PROVIDER_CHANGE_WINDOW),
+        // todo: are these features generic for all
+        timeout: 500
+      });
+      // for communication methods sending window id in jrpc req params
+      _payload.params.windowId = windowId;
+    }
+    communicationProvider.rpcEngine.handle(_payload, cb);
+  };
+
+  // detect eth_requestAccounts and pipe to enable for now
+  const detectAccountRequestPrototypeModifier = m => {
+    const originalMethod = inPageProvider[m];
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    inPageProvider[m] = function providerFunc(request, cb) {
+      const {
+        method,
+        params = []
+      } = request;
+      if (method === "eth_requestAccounts") {
+        let login = _assertClassBrand$1(_RealmEmbed_brand, self, _authLogin).call(self, {
+          loginProvider: params[0]
+        });
+        if (cb) {
+          login = login.then(res => cb(null, res)).catch(err => cb(err));
+        }
+        return login.finally(() => {
+          _classPrivateFieldGet$1(_communicationProvider, self).displayIframe({
+            isFull: false
+          });
+        });
+      }
+      return originalMethod.apply(this, [request, cb]);
+    };
+  };
+
+  // Detects call to eth_requestAccounts in request & sendAsync and passes to login
+  detectAccountRequestPrototypeModifier("request");
+  detectAccountRequestPrototypeModifier("sendAsync");
+  detectAccountRequestPrototypeModifier("send");
+  const proxiedInPageProvider = new Proxy(inPageProvider, {
+    // straight up lie that we deleted the property so that it doesn't
+    // throw an error in strict mode
+    deleteProperty: () => true
+  });
+  const proxiedCommunicationProvider = new Proxy(communicationProvider, {
+    // straight up lie that we deleted the property so that it doesn't
+    // throw an error in strict mode
+    deleteProperty: () => true
+  });
+  _classPrivateFieldSet$1(_provider, this, proxiedInPageProvider);
+  _classPrivateFieldSet$1(_communicationProvider, this, proxiedCommunicationProvider);
+  await Promise.all([inPageProvider.initializeState(), communicationProvider.initializeState(_objectSpread(_objectSpread({}, providerParams), {}, {
+    torusIframeId: _classPrivateFieldGet$1(_walletIframe, this).id
+  }))]);
+  log.debug("embed communication setup ended");
+}
+function _triggerEvent(data) {
+  const listenersCopy = [..._classPrivateFieldGet$1(_embedListeners, this)];
+  listenersCopy.forEach(listener => {
+    try {
+      listener(data);
+    } catch (error) {
+      log.error(error);
+    }
+  });
+}
+function _triggerInitializedEvent() {
+  if (_classPrivateFieldGet$1(_isInitialized$1, this) && _classPrivateFieldGet$1(_rehydrationState, this)) {
+    _assertClassBrand$1(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+      event: "initialized",
+      result: {
+        rehydration: _classPrivateFieldGet$1(_rehydrationState, this)
+      }
+    });
+  }
+}
+function _onInitialized() {
+  return new Promise(resolve => {
+    if (!_classPrivateFieldGet$1(_isInitialized$1, this) || !_classPrivateFieldGet$1(_rehydrationState, this)) {
+      const sub = event => {
+        log.debug("onInitialized:", event);
+        if (event.event === "initialized") {
+          this.off(sub);
+          resolve();
+        }
+      };
+      this.on(sub);
+    } else {
+      resolve();
+    }
+  });
+}
+
+class IframeController {
+  constructor(iframeUrl, iframeId, state) {
+    _defineProperty(this, "state", void 0);
+    _defineProperty(this, "_iframeElement", null);
+    _defineProperty(this, "iframeUrl", void 0);
+    _defineProperty(this, "iframeId", void 0);
+    this.state = _objectSpread(_objectSpread({}, IframeController.defaultState), state);
+    this.iframeUrl = iframeUrl;
+    this.iframeId = iframeId;
+  }
+  get iframeElement() {
+    return this._iframeElement;
+  }
+  createIframe() {
+    if (this._iframeElement) return this._iframeElement;
+    const iframe = document.createElement("iframe");
+    iframe.id = this.iframeId;
+    iframe.allow = "publickey-credentials-get *; publickey-credentials-create *";
+    iframe.src = this.iframeUrl;
+    iframe.style.position = "fixed";
+    iframe.style.zIndex = "999999";
+    iframe.style.border = "none";
+    iframe.style.margin = "0";
+    iframe.style.padding = "0";
+    iframe.style.display = "none";
+    document.body.appendChild(iframe);
+    this._iframeElement = iframe;
+    return iframe;
+  }
+  setIframeVisibility(isVisible) {
+    this.state.isVisible = isVisible;
+  }
+  updateIframeState() {
+    if (!this.iframeElement) return;
+    const style = {};
+    style.display = this.state.isVisible ? "block" : "none";
+    style.width = "100%";
+    style.height = "100%";
+    style.top = "0px";
+    style.right = "0px";
+    style.left = "0px";
+    style.bottom = "0px";
+    Object.assign(this.iframeElement.style, style);
+  }
+  destroy() {
+    if (this.iframeElement) {
+      this.iframeElement.remove();
+      this._iframeElement = null;
+    }
+  }
+  postMessage(message) {
+    if (!this.iframeElement) return;
+    const {
+      origin
+    } = new URL(this.iframeElement.src);
+    this.iframeElement.contentWindow.postMessage(message, origin);
+  }
+}
+_defineProperty(IframeController, "defaultState", {
+  isVisible: false
+});
+
+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$1.openAuthObservables({
+      authIframeOrigin
+    });
+    _classPrivateFieldSet(_authIframeController, this, new IframeController(authUrl, `air-login-${_classPrivateFieldGet(_embedNonce, this)}`));
+    AirMessageService$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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 { AirInPageProvider, AirService, BUTTON_POSITION, EMBED_BUILD_ENV, EXTERNAL_LOGIN_PROVIDER, RealmEmbed };