@mocanetwork/airkit 0.5.0-beta.2

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

@@ -0,0 +1,176 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { createLoggerMiddleware } from '@toruslabs/base-controllers';
+import { SafeEventEmitter, ObjectMultiplex, createStreamMiddleware, JRPCEngine, createIdRemapMiddleware, rpcErrors, getRpcPromiseCallback } from '@web3auth/auth';
+import pump from 'pump';
+import { isDuplexStream } from './isStream.js';
+import messages from './messages.js';
+import { createErrorMiddleware, logStreamDisconnectWarning } from './utils.js';
+
+/**
+ * @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
+   */
+}
+
+export { BaseProvider as default };

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

@@ -0,0 +1,344 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { COMMUNICATION_JRPC_METHODS, COMMUNICATION_NOTIFICATIONS } from '@toruslabs/base-controllers';
+import { EthereumProviderError } from '@web3auth/auth';
+import BaseProvider from './baseProvider.js';
+import { EXTERNAL_LOGIN_PROVIDER, BUTTON_POSITION } from './interfaces.js';
+import log from './loglevel.js';
+import messages from './messages.js';
+import PopupHandler from './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 === 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
+});
+
+export { CommunicationProvider as default };