@mocanetwork/airkit 0.5.0-beta.2

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

@@ -0,0 +1,346 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('@web3auth/auth');
+var baseProvider = require('./baseProvider.js');
+var interfaces = require('./interfaces.js');
+var loglevel = require('./loglevel.js');
+var messages = require('./messages.js');
+var PopupHandler = require('./PopupHandler.js');
+
+/**
+ * @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 === baseControllers.COMMUNICATION_NOTIFICATIONS.IFRAME_STATUS) {
+        const {
+          isFullScreen,
+          rid
+        } = params;
+        this.displayIframe({
+          isFull: isFullScreen,
+          rid: rid
+        }, true);
+      } else if (method === baseControllers.COMMUNICATION_NOTIFICATIONS.CLOSE_WINDOW) {
+        this.handleCloseWindow(params);
+      } else if (method === baseControllers.COMMUNICATION_NOTIFICATIONS.USER_LOGGED_IN) {
+        loglevel.info("[TEST METAMASK] User received notification ", baseControllers.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 === baseControllers.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 === interfaces.EXTERNAL_LOGIN_PROVIDER.METAMASK || this.state.currentLoginProvider === interfaces.EXTERNAL_LOGIN_PROVIDER.WALLET_CONNECT || this.state.currentLoginProvider === interfaces.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: baseControllers.COMMUNICATION_JRPC_METHODS.GET_PROVIDER_STATE,
+        params: []
+      });
+
+      // indicate that we've connected, for EIP-1193 compliance
+      if (isLoggedIn) this.handleConnect(currentLoginProvider, isLoggedIn);
+    } catch (error) {
+      loglevel.error("Web3Auth: Failed to get initial state. Please report this bug.", error);
+    } finally {
+      loglevel.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 interfaces.BUTTON_POSITION.TOP_LEFT:
+          style.top = "0px";
+          style.left = "0px";
+          style.right = "auto";
+          style.bottom = "auto";
+          break;
+        case interfaces.BUTTON_POSITION.TOP_RIGHT:
+          style.top = "0px";
+          style.right = "0px";
+          style.left = "auto";
+          style.bottom = "auto";
+          break;
+        case interfaces.BUTTON_POSITION.BOTTOM_RIGHT:
+          style.bottom = "0px";
+          style.right = "0px";
+          style.top = "auto";
+          style.left = "auto";
+          break;
+        case interfaces.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: baseControllers.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: baseControllers.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: baseControllers.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
+      });
+      loglevel.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 auth.EthereumProviderError(1013,
+        // Try again later
+        errorMessage || messages.errors.disconnected());
+        loglevel.debug(error);
+      } else {
+        error = new auth.EthereumProviderError(1011,
+        // Internal error
+        errorMessage || messages.errors.permanentlyDisconnected());
+        loglevel.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
+});
+
+module.exports = CommunicationProvider;