@mocanetwork/airkit 0.5.0-beta.2

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

@@ -0,0 +1,18 @@
+import { BaseError } from '../../common/src/error.js';
+
+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 {}
+
+export { AirServiceError, RealmEmbedError };

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

@@ -0,0 +1,66 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+
+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
+});
+
+export { IframeController };

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

@@ -0,0 +1,302 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { PROVIDER_JRPC_METHODS, PROVIDER_NOTIFICATIONS } from '@toruslabs/base-controllers';
+import { EthereumProviderError } from '@web3auth/auth';
+import dequal from 'fast-deep-equal';
+import BaseProvider from './baseProvider.js';
+import log from './loglevel.js';
+import messages from './messages.js';
+import { EMITTED_NOTIFICATIONS } from './utils.js';
+
+/**
+ * @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 {}
+
+export { TorusInPageProvider, AirInPageProvider as default };

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

@@ -0,0 +1,5 @@
+export { default as AirService } from './airService.js';
+export { default as RealmEmbed } from './embed.js';
+export { default as AirInPageProvider } from './inPageProvider.js';
+export { BUTTON_POSITION, EMBED_BUILD_ENV, EXTERNAL_LOGIN_PROVIDER } from './interfaces.js';
+export { CONFIRMATION_STRATEGY } from '@toruslabs/base-controllers';

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

@@ -0,0 +1,21 @@
+export { CONFIRMATION_STRATEGY } from '@toruslabs/base-controllers';
+
+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"
+};
+
+export { BUTTON_POSITION, EMBED_BUILD_ENV, EXTERNAL_LOGIN_PROVIDER };

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

@@ -0,0 +1,15 @@
+/* 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);
+}
+
+export { isDuplexStream, isReadableStream, isStream, isWritableStream };

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

@@ -0,0 +1,5 @@
+import loglevel from 'loglevel';
+
+var log = loglevel.getLogger("ws-embed");
+
+export { log as default };

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

@@ -0,0 +1,210 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import dequal from 'fast-deep-equal';
+import { firstValueFrom, filter, lastValueFrom, takeWhile, tap, forkJoin, last, first, Subject, distinctUntilChanged } from 'rxjs';
+import { AirAuthMessageTypes } from '../../common/src/realm/messaging/auth.js';
+import { AirMessageTypes } from '../../common/src/realm/messaging/types.js';
+import { RealmEmbedError } from './error.js';
+import log from './loglevel.js';
+
+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;
+
+export { AirMessageService$1 as default };

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

@@ -0,0 +1,20 @@
+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: {}
+};
+
+export { messages as default };