@web3auth/ws-embed/dist/lib.cjs/baseProvider.js

Embed script

'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 readableStream = require('readable-stream');
var isStream = require('./isStream.js');
var messages = require('./messages.js');
var utils = require('./utils.js');

/**
 * @param connectionStream - A Node.js duplex stream
 * @param opts - An options bag
 */
class BaseProvider extends auth.SafeEventEmitter {
  constructor(connectionStream, {
    maxEventListeners = 100,
    jsonRpcStreamName = "provider"
  }) {
    super();
    _defineProperty(this, "rpcEngine", void 0);
    _defineProperty(this, "jsonRpcConnectionEvents", new auth.SafeEventEmitter());
    /**
     * Indicating that this provider is a Web3Auth provider.
     */
    _defineProperty(this, "isWeb3Auth", void 0);
    _defineProperty(this, "state", void 0);
    if (!isStream.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 auth.ObjectMultiplex();
    readableStream.pipeline(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 {
      middleware: streamMiddleware,
      stream: clientStream
    } = auth.createClientStreamMiddlewareV2({
      notificationEmitter: this.jsonRpcConnectionEvents
    });
    const engine = auth.JRPCEngineV2.create({
      middleware: [utils.createErrorMiddleware(), baseControllers.createLoggerMiddleware({
        origin: location.origin
      }), streamMiddleware]
    });
    readableStream.pipeline(clientStream, mux.createStream(jsonRpcStreamName), clientStream, this.handleStreamDisconnect.bind(this, "Web3Auth RpcProvider"));
    this.rpcEngine = engine;
  }
  /**
   * 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 auth.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 auth.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 auth.rpcErrors.invalidRequest({
        message: messages.errors.invalidRequestParams(),
        data: _objectSpread(_objectSpread({}, args || {}), {}, {
          cause: messages.errors.invalidRequestArgs()
        })
      });
    }
    return this.rpcRequest({
      id: auth.randomId(),
      method,
      params
    });
  }
  /**
   * 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) {
    const resolveCallback = (error, result) => {
      callback(error, result);
    };
    this.rpcRequest(payload).then(result => {
      return resolveCallback(null, {
        id: payload.id,
        jsonrpc: "2.0",
        result
      });
    }).catch(err => {
      const error = err instanceof Error ? err : auth.rpcErrors.internal({
        message: "Internal JSON-RPC error",
        data: {
          cause: err
        }
      });
      return resolveCallback(error, {
        id: payload.id,
        jsonrpc: "2.0",
        error: auth.serializeJrpcError(error, {
          shouldIncludeStack: false,
          shouldPreserveMessage: true,
          fallbackError: auth.rpcErrors.internal({
            message: "Internal JSON-RPC error",
            data: {
              cause: "Internal JSON-RPC error"
            }
          })
        })
      });
    });
  }
  /**
   * 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 this.rpcRequest(payload);
  }
  /**
   * Called when connection is lost to critical streams.
   *
   * emits InpageProvider#disconnect
   */
  handleStreamDisconnect(streamName, error) {
    utils.logStreamDisconnectWarning(streamName, error, this);
    this.handleDisconnect(false, error ? error.message : undefined);
  }
}

module.exports = BaseProvider;