@mocanetwork/airkit 0.5.0-beta.2

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

@@ -0,0 +1,730 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _classPrivateMethodInitSpec from '@babel/runtime/helpers/classPrivateMethodInitSpec';
+import _classPrivateFieldInitSpec from '@babel/runtime/helpers/classPrivateFieldInitSpec';
+import { COMMUNICATION_JRPC_METHODS, CHAIN_NAMESPACES, randomId, CONFIRMATION_STRATEGY, BUTTON_POSITION, SETUP_COMPLETE, getPopupFeatures, FEATURES_CONFIRM_WINDOW, FEATURES_PROVIDER_CHANGE_WINDOW } from '@toruslabs/base-controllers';
+import { METHOD_TYPES } from '@toruslabs/ethereum-controllers';
+import { WEB3AUTH_NETWORK, BasePostMessageStream, getRpcPromiseCallback } from '@web3auth/auth';
+import { AirMessageTypes } from '../../common/src/realm/messaging/types.js';
+import CommunicationProvider from './communicationProvider.js';
+import { RealmEmbedError } from './error.js';
+import { TorusInPageProvider } from './inPageProvider.js';
+import { EMBED_BUILD_ENV, EXTERNAL_LOGIN_PROVIDER } from './interfaces.js';
+import log from './loglevel.js';
+import AirMessageService from './messageService.js';
+import getSiteMetadata from './siteMetadata.js';
+import { AIR_URLS, htmlToElement } from './utils.js';
+
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+
+// 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 = /*#__PURE__*/new WeakMap();
+var _provider = /*#__PURE__*/new WeakMap();
+var _isInitialized = /*#__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 = /*#__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, randomId());
+    _classPrivateFieldInitSpec(this, _provider, void 0);
+    _classPrivateFieldInitSpec(this, _isInitialized, 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, 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(_isInitialized, this, false); // init done
+    _classPrivateFieldSet(_modalZIndex, this, modalZIndex);
+    _classPrivateFieldSet(_realmPartnerId, this, partnerId);
+    _classPrivateFieldSet(_web3AuthClientId, this, web3AuthClientId);
+    _classPrivateFieldSet(_web3AuthNetwork, this, web3AuthNetwork);
+  }
+  get isConnected() {
+    return !!_classPrivateFieldGet(_walletAddresses, this) && _classPrivateFieldGet(_communicationProvider, this).isLoggedIn;
+  }
+  get isInitialized() {
+    return _classPrivateFieldGet(_isInitialized, this) && !!_classPrivateFieldGet(_rehydrationState, this);
+  }
+  get isLoggedIn() {
+    return !!_classPrivateFieldGet(_realmId, this) && this.isConnected;
+  }
+  get getBuildEnv() {
+    return _classPrivateFieldGet(_buildEnv, this);
+  }
+  get walletAddresses() {
+    var _classPrivateFieldGet2;
+    return (_classPrivateFieldGet2 = _classPrivateFieldGet(_walletAddresses, this)) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : null;
+  }
+  get sessionId() {
+    var _classPrivateFieldGet3;
+    return (_classPrivateFieldGet3 = _classPrivateFieldGet(_sessionId, this)) !== null && _classPrivateFieldGet3 !== void 0 ? _classPrivateFieldGet3 : null;
+  }
+  get realmId() {
+    var _classPrivateFieldGet4;
+    return (_classPrivateFieldGet4 = _classPrivateFieldGet(_realmId, this)) !== null && _classPrivateFieldGet4 !== void 0 ? _classPrivateFieldGet4 : null;
+  }
+  get provider() {
+    return _classPrivateFieldGet(_walletAddresses, this) ? _classPrivateFieldGet(_provider, this) : null;
+  }
+  async init({
+    buildEnv = EMBED_BUILD_ENV.PRODUCTION,
+    enableLogging = false,
+    skipRehydration = false
+    // confirmationStrategy = CONFIRMATION_STRATEGY.DEFAULT,
+  } = {}) {
+    if (_classPrivateFieldGet(_isInitialized, this)) throw new RealmEmbedError("ALREADY_INITIALISED", "Already initialized");
+    _classPrivateFieldSet(_buildEnv, this, buildEnv);
+    _classPrivateFieldSet(_confirmationStrategy, this, CONFIRMATION_STRATEGY.DEFAULT);
+    _classPrivateFieldSet(_buttonPosition, this, BUTTON_POSITION.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(_RealmEmbed_brand, this, _getWsIframeUrl).call(this);
+    const walletIframeOrigin = walletIframeUrl.origin;
+    AirMessageService.openRealmObservables({
+      walletIframeOrigin
+    });
+    _classPrivateFieldSet(_walletIframe, this, htmlToElement(`<iframe
+        id="walletIframe-${_classPrivateFieldGet(_embedNonce, this)}"
+        class="walletIframe-${_classPrivateFieldGet(_embedNonce, 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(_modalZIndex, this).toString()}"
+        allow="clipboard-write"
+      ></iframe>`));
+    AirMessageService.messages$.subscribe(msg => {
+      switch (msg.type) {
+        case AirMessageTypes.SERVICE_INITIALIZED:
+          {
+            _classPrivateFieldSet(_rehydrationState, this, msg.payload.rehydration);
+            _assertClassBrand(_RealmEmbed_brand, this, _triggerInitializedEvent).call(this);
+            break;
+          }
+      }
+    });
+    AirMessageService.loginState$.subscribe(async msg => {
+      switch (msg.payload.state) {
+        case "connected":
+          {
+            await _assertClassBrand(_RealmEmbed_brand, this, _onInitialized).call(this);
+            if (msg.payload.addresses && !this.isLoggedIn) {
+              _classPrivateFieldSet(_walletAddresses, this, msg.payload.addresses);
+              _classPrivateFieldSet(_loginToken, this, msg.payload.token);
+              _classPrivateFieldSet(_sessionId, this, msg.payload.sessionId);
+              _assertClassBrand(_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(_RealmEmbed_brand, this, _onInitialized).call(this);
+            const isNotConnectedYet = !_classPrivateFieldGet(_walletAddresses, this);
+            _classPrivateFieldSet(_realmId, this, msg.payload.airId);
+            _classPrivateFieldSet(_walletAddresses, this, msg.payload.addresses);
+            _classPrivateFieldSet(_loginToken, this, msg.payload.token);
+            _classPrivateFieldSet(_sessionId, this, msg.payload.sessionId);
+            if (isNotConnectedYet) {
+              _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+                event: "connected",
+                result: {
+                  isLoggedIn: false,
+                  addresses: msg.payload.addresses,
+                  token: msg.payload.token,
+                  sessionId: msg.payload.sessionId
+                }
+              });
+            }
+            _assertClassBrand(_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(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+              event: "minting_started"
+            });
+            break;
+          }
+        case "minting_failed":
+          {
+            _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+              event: "minting_failed",
+              errorMessage: msg.payload.errorMessage
+            });
+            break;
+          }
+      }
+    });
+    try {
+      // Handle wallet iframe message
+      window.document.body.appendChild(_classPrivateFieldGet(_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(_walletIframe, this).contentWindow.postMessage({
+                chainConfig: _classPrivateFieldGet(_buildEnv, this) === EMBED_BUILD_ENV.PRODUCTION ? embedChainConfig.polygon : embedChainConfig.polygonAmoy,
+                dappMetadata,
+                enableLogging,
+                skipRehydration,
+                realmPartnerId: _classPrivateFieldGet(_realmPartnerId, this),
+                web3AuthClientId: _classPrivateFieldGet(_web3AuthClientId, this),
+                web3AuthNetwork: _classPrivateFieldGet(_web3AuthNetwork, this),
+                confirmationStrategy: _classPrivateFieldGet(_confirmationStrategy, this)
+              }, walletIframeOrigin);
+              await _assertClassBrand(_RealmEmbed_brand, this, _setupWeb).call(this, {
+                torusUrl: walletUrl
+              });
+              _classPrivateFieldGet(_communicationProvider, this).onLoginStateHandle = async isLoggedIn => {
+                if (!isLoggedIn) {
+                  await _assertClassBrand(_RealmEmbed_brand, this, _logout).call(this);
+                }
+              };
+              resolve();
+            }
+          } catch (err) {
+            reject(err);
+          }
+        };
+        window.addEventListener("message", handleMessage);
+      });
+      const walletServiceInitialization = AirMessageService.waitForWalletInitialization();
+      await Promise.all([initializeWalletService, walletServiceInitialization]);
+      AirMessageService.setupIframeCommunication(_classPrivateFieldGet(_walletIframe, this));
+      _classPrivateFieldSet(_isInitialized, this, true);
+      _assertClassBrand(_RealmEmbed_brand, this, _triggerInitializedEvent).call(this);
+      log.debug("Wallet service initialization resolved");
+    } catch (error) {
+      log.debug("Wallet service initialization error", error);
+      _assertClassBrand(_RealmEmbed_brand, this, _clearInit).call(this, true);
+      throw error;
+    }
+  }
+  moveToBackground() {
+    _classPrivateFieldGet(_communicationProvider, this).moveToBackground();
+  }
+  moveToForeground() {
+    _classPrivateFieldGet(_communicationProvider, this).moveToForeground();
+  }
+  async getUserInfo() {
+    if (!_classPrivateFieldGet(_realmId, this)) return null;
+    const userInfoResponse = await _classPrivateFieldGet(_communicationProvider, this).request({
+      method: COMMUNICATION_JRPC_METHODS.USER_INFO,
+      params: []
+    });
+    return _objectSpread(_objectSpread({}, userInfoResponse), {}, {
+      realmId: _classPrivateFieldGet(_realmId, this)
+    });
+  }
+  async login(options) {
+    var _options$legacy;
+    return _assertClassBrand(_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.sendDeploySmartAccountRequest(_classPrivateFieldGet(_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(_isInitialized, this)) throw new Error("Call init() first");
+    if (!params.sessionId) throw new Error("sessionId is required");
+    try {
+      const res = await _classPrivateFieldGet(_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(_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(_communicationProvider, this).setIframeVisibility({
+          isVisible: false
+        });
+      }
+      _classPrivateFieldGet(_communicationProvider, this).displayIframe({
+        isFull: true
+      });
+      const claimPromise = AirMessageService.sendClaimRequest(_classPrivateFieldGet(_walletIframe, this), options);
+      log.debug("before claimPromise");
+      await claimPromise;
+      log.debug("after claimPromise");
+      return {
+        isLoggedIn: true,
+        realmId: _classPrivateFieldGet(_realmId, this),
+        addresses: _classPrivateFieldGet(_walletAddresses, this),
+        token: _classPrivateFieldGet(_loginToken, this),
+        sessionId: _classPrivateFieldGet(_sessionId, this)
+      };
+    } catch (e) {
+      throw RealmEmbedError.from(e);
+    } finally {
+      if (options !== null && options !== void 0 && options.background) {
+        _classPrivateFieldGet(_communicationProvider, this).setIframeVisibility({
+          isVisible: true
+        });
+      }
+      _classPrivateFieldGet(_communicationProvider, this).displayIframe({
+        isFull: false
+      });
+    }
+  }
+  async logout() {
+    if (!_classPrivateFieldGet(_communicationProvider, this).isLoggedIn) throw new RealmEmbedError("NOT_LOGGED_IN", "Not logged in");
+    await _assertClassBrand(_RealmEmbed_brand, this, _logout).call(this);
+  }
+  async cleanUp() {
+    var _classPrivateFieldGet5;
+    if ((_classPrivateFieldGet5 = _classPrivateFieldGet(_communicationProvider, this)) !== null && _classPrivateFieldGet5 !== void 0 && _classPrivateFieldGet5.isLoggedIn) {
+      await this.logout();
+    }
+    await this.clearInit();
+  }
+  async clearInit() {
+    _assertClassBrand(_RealmEmbed_brand, this, _clearInit).call(this);
+  }
+  on(listener) {
+    if (_classPrivateFieldGet(_embedListeners, this).indexOf(listener) < 0) _classPrivateFieldGet(_embedListeners, this).push(listener);
+  }
+  off(listener) {
+    const index = _classPrivateFieldGet(_embedListeners, this).indexOf(listener);
+    if (index >= 0) _classPrivateFieldGet(_embedListeners, this).splice(index, 1);
+  }
+  clearEventListeners() {
+    _classPrivateFieldSet(_embedListeners, this, []);
+  }
+}
+function _getWsIframeUrl() {
+  const {
+    walletUrl
+  } = AIR_URLS[_classPrivateFieldGet(_buildEnv, 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(_RealmEmbed_brand, this, _createLoginResult).call(this);
+  } else if (this.isConnected) {
+    if ((options === null || options === void 0 ? void 0 : options.skipClaiming) === true) {
+      loginResult = _assertClassBrand(_RealmEmbed_brand, this, _createLoginResult).call(this);
+    } else {
+      loginResult = await this.claimRealmId(options);
+    }
+  } else {
+    loginResult = await _assertClassBrand(_RealmEmbed_brand, this, _realmLogin).call(this, options, isLegacyLogin);
+  }
+  return loginResult;
+}
+function _createLoginResult() {
+  if (this.isLoggedIn) {
+    return {
+      isLoggedIn: true,
+      realmId: _classPrivateFieldGet(_realmId, this),
+      addresses: _classPrivateFieldGet(_walletAddresses, this),
+      token: _classPrivateFieldGet(_loginToken, this),
+      sessionId: _classPrivateFieldGet(_sessionId, this)
+    };
+  }
+  return {
+    isLoggedIn: false,
+    addresses: _classPrivateFieldGet(_walletAddresses, this),
+    token: _classPrivateFieldGet(_loginToken, this),
+    sessionId: _classPrivateFieldGet(_sessionId, this)
+  };
+}
+async function _authLogin(params = {}) {
+  try {
+    if (!params.loginProvider || params.loginProvider === EXTERNAL_LOGIN_PROVIDER.WALLET_CONNECT) {
+      _classPrivateFieldGet(_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(_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(_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(_communicationProvider, this).setIframeVisibility({
+        isVisible: false
+      });
+    }
+    const loginPromise = Promise.all([_assertClassBrand(_RealmEmbed_brand, this, _authLogin).call(this), AirMessageService.sendLoginRequest(_classPrivateFieldGet(_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(_RealmEmbed_brand, this, _createLoginResult).call(this);
+  } catch (e) {
+    await _assertClassBrand(_RealmEmbed_brand, this, _logout).call(this);
+    throw RealmEmbedError.from(e);
+  } finally {
+    if (options !== null && options !== void 0 && options.authToken) {
+      _classPrivateFieldGet(_communicationProvider, this).setIframeVisibility({
+        isVisible: true
+      });
+    }
+    _classPrivateFieldGet(_communicationProvider, this).displayIframe({
+      isFull: false
+    });
+  }
+}
+async function _logout() {
+  var _classPrivateFieldGet6;
+  const silent = !_classPrivateFieldGet(_walletAddresses, this);
+  if ((_classPrivateFieldGet6 = _classPrivateFieldGet(_communicationProvider, this)) !== null && _classPrivateFieldGet6 !== void 0 && _classPrivateFieldGet6.isLoggedIn) {
+    await _classPrivateFieldGet(_communicationProvider, this).request({
+      method: COMMUNICATION_JRPC_METHODS.LOGOUT,
+      params: []
+    });
+  }
+  if (_classPrivateFieldGet(_communicationProvider, this)) _classPrivateFieldGet(_communicationProvider, this).onLoginStateHandle = undefined;
+  _classPrivateFieldSet(_walletAddresses, this, undefined);
+  _classPrivateFieldSet(_realmId, this, undefined);
+  if (!silent) {
+    _assertClassBrand(_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(_walletIframe, this)) && window.document.body.contains(_classPrivateFieldGet(_walletIframe, this))) {
+    _classPrivateFieldGet(_walletIframe, this).remove();
+    _classPrivateFieldSet(_walletIframe, this, undefined);
+  }
+  AirMessageService.closeRealmObservables();
+  _classPrivateFieldSet(_isInitialized, this, false);
+  _classPrivateFieldSet(_walletAddresses, this, undefined);
+  _classPrivateFieldSet(_realmId, this, undefined);
+  if (isSilent === true) _assertClassBrand(_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(_confirmationStrategy, this);
+  if (!Array.isArray(payload) && PROVIDER_UNSAFE_METHODS.has(payload.method) && _classPrivateFieldGet(_confirmationStrategy, this) !== CONFIRMATION_STRATEGY.MODAL && !_classPrivateFieldGet(_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(_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(_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(_buttonPosition, this)
+  });
+  inPageProvider.tryWindowHandle = (payload, cb) => {
+    const _payload = payload;
+    const confirmationStrategyFinal = _assertClassBrand(_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(_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(_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(_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(_provider, this, proxiedInPageProvider);
+  _classPrivateFieldSet(_communicationProvider, this, proxiedCommunicationProvider);
+  await Promise.all([inPageProvider.initializeState(), communicationProvider.initializeState(_objectSpread(_objectSpread({}, providerParams), {}, {
+    torusIframeId: _classPrivateFieldGet(_walletIframe, this).id
+  }))]);
+  log.debug("embed communication setup ended");
+}
+function _triggerEvent(data) {
+  const listenersCopy = [..._classPrivateFieldGet(_embedListeners, this)];
+  listenersCopy.forEach(listener => {
+    try {
+      listener(data);
+    } catch (error) {
+      log.error(error);
+    }
+  });
+}
+function _triggerInitializedEvent() {
+  if (_classPrivateFieldGet(_isInitialized, this) && _classPrivateFieldGet(_rehydrationState, this)) {
+    _assertClassBrand(_RealmEmbed_brand, this, _triggerEvent).call(this, {
+      event: "initialized",
+      result: {
+        rehydration: _classPrivateFieldGet(_rehydrationState, this)
+      }
+    });
+  }
+}
+function _onInitialized() {
+  return new Promise(resolve => {
+    if (!_classPrivateFieldGet(_isInitialized, this) || !_classPrivateFieldGet(_rehydrationState, this)) {
+      const sub = event => {
+        log.debug("onInitialized:", event);
+        if (event.event === "initialized") {
+          this.off(sub);
+          resolve();
+        }
+      };
+      this.on(sub);
+    } else {
+      resolve();
+    }
+  });
+}
+
+export { PROVIDER_UNSAFE_METHODS, RealmEmbed as default };