@tomo-inc/inject-providers 0.0.1

package/src/evm/metamask.ts

@@ -0,0 +1,890 @@
+import { EventEmitter } from "events";
+
+import {
+  createIdRemapMiddleware,
+  JsonRpcEngine,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  JsonRpcSuccess,
+} from "json-rpc-engine";
+import { createStreamMiddleware } from "json-rpc-middleware-stream";
+
+import { getDappInfo } from "../utils/index";
+import messages from "./messages";
+
+import { EthereumRpcError, ethErrors } from "eth-rpc-errors";
+import { toHex } from "viem";
+import {
+  ConsoleLike,
+  createErrorMiddleware,
+  EMITTED_NOTIFICATIONS,
+  getRpcPromiseCallback,
+  logStreamDisconnectWarning,
+  Maybe,
+  NOOP,
+} from "./utils";
+
+import { ChainTypes, IProductInfo } from "../types";
+import {
+  InitializeProviderOptions,
+  InpageProviderOptions,
+  InternalState,
+  RequestArguments,
+  SendSyncJsonRpcRequest,
+  UnvalidatedJsonRpcRequest,
+  WarningEventName,
+} from "./type";
+
+const chainType = ChainTypes.EVM;
+
+export class EvmProvider extends EventEmitter {
+  private readonly _log: ConsoleLike;
+
+  private _state: InternalState;
+
+  private _rpcEngine: JsonRpcEngine;
+
+  public sendRequest: (chainType: string, data: any) => void;
+
+  public onResponse: any;
+
+  /**
+   * The chain ID of the currently connected Ethereum chain.
+   * See [chainId.network]{@link https://chainid.network} for more information.
+   */
+  public chainId: string | null;
+
+  /**
+   * The network ID of the currently connected Ethereum chain.
+   */
+  public networkVersion: string | null;
+
+  /**
+   * The user's currently selected Ethereum address.
+   * If null,  is either locked or the user has not permitted any
+   * addresses to be viewed.
+   */
+  public selectedAddress: string | null;
+
+  /**
+   * Indicating that this provider is a provider.
+   */
+
+  public name: string;
+  public icon: string;
+
+  /**
+   * @param connectionStream - A Node.js duplex stream
+   * @param options - An options bag
+   * @param options.jsonRpcStreamName - The name of the internal JSON-RPC stream.
+   * @param options.logger - The logging API to use. Default: console
+   * @param options.maxEventListeners - The maximum number of event
+   * listeners. Default: 100
+   * @param options.shouldSendMetadata - Whether the provider should
+   * send page metadata. Default: true
+   */
+  constructor(
+    productInfo: IProductInfo,
+    {
+      logger = console,
+      maxEventListeners = 100,
+      shouldSendMetadata = true,
+      sendRequest,
+      onResponse,
+    }: InpageProviderOptions,
+  ) {
+    if (typeof maxEventListeners !== "number" || typeof shouldSendMetadata !== "boolean") {
+      throw new Error(messages.errors.invalidOptions(maxEventListeners, shouldSendMetadata));
+    }
+
+    validateLoggerObject(logger);
+
+    super();
+
+    this._log = logger;
+    this.name = productInfo.name;
+    this.icon = productInfo.icon;
+    this.sendRequest = sendRequest;
+    this.onResponse = onResponse;
+
+    this.setMaxListeners(maxEventListeners);
+
+    // private state
+    this._state = {
+      sentWarnings: {
+        // methods
+        enable: false,
+        experimentalMethods: false,
+        send: false,
+        // events
+        events: {
+          close: false,
+          data: false,
+          networkChanged: false,
+          notification: false,
+        },
+      },
+      accounts: null,
+      isConnected: false,
+      isUnlocked: false,
+      initialized: true,
+      isPermanentlyDisconnected: false,
+    };
+
+    // public state
+    this.selectedAddress = null;
+    this.networkVersion = null;
+    this.chainId = null;
+
+    // bind functions (to prevent consumers from making unbound calls)
+    this._handleAccountsChanged = this._handleAccountsChanged.bind(this);
+    this._handleConnect = this._handleConnect.bind(this);
+    this._handleChainChanged = this._handleChainChanged.bind(this);
+    this._handleDisconnect = this._handleDisconnect.bind(this);
+    this._handleStreamDisconnect = this._handleStreamDisconnect.bind(this);
+    this._handleUnlockStateChanged = this._handleUnlockStateChanged.bind(this);
+    this._sendSync = this._sendSync.bind(this);
+    this._rpcRequest = this._rpcRequest.bind(this);
+    this._warnOfDeprecation = this._warnOfDeprecation.bind(this);
+    this.enable = this.enable.bind(this);
+    this.connect = this.connect.bind(this);
+    this.disconnect = this.disconnect.bind(this);
+    this.request = this.request.bind(this);
+    this.send = this.send.bind(this);
+    this.sendAsync = this.sendAsync.bind(this);
+
+    // EIP-1193 connect
+    this.on("connect", () => {
+      this._state.isConnected = true;
+    });
+
+    const jsonRpcConnection = createStreamMiddleware();
+
+    // handle RPC requests via dapp-side rpc engine
+    const rpcEngine = new JsonRpcEngine();
+    rpcEngine.push(createIdRemapMiddleware());
+    rpcEngine.push(createErrorMiddleware(this._log));
+    rpcEngine.push(jsonRpcConnection.middleware as any);
+    this._rpcEngine = rpcEngine;
+
+    this._initializeState();
+
+    // handle JSON-RPC notifications
+    jsonRpcConnection.events.on("notification", (payload) => {
+      const { method, params } = payload;
+
+      if (method === "wallet_accountsChanged") {
+        this._handleAccountsChanged(params);
+      } else if (method === "wallet_unlockStateChanged") {
+        this._handleUnlockStateChanged(params);
+      } else if (method === "wallet_chainChanged") {
+        this._handleChainChanged(params);
+      } else if (EMITTED_NOTIFICATIONS.includes(method)) {
+        // deprecated
+        // emitted here because that was the original order
+        this.emit("data", payload);
+
+        this.emit("message", {
+          type: method,
+          data: params,
+        });
+
+        // deprecated
+        this.emit("notification", payload.params.result);
+      } else if (method === "WALLET_STREAM_FAILURE") {
+        console.error(messages.errors.permanentlyDisconnected());
+      }
+    });
+
+    // miscellanea
+  }
+
+  //====================
+  // Public Methods
+  //====================
+
+  /**
+   * Returns whether the provider can process RPC requests.
+   */
+  isConnected(): boolean {
+    return this._state.isConnected;
+  }
+
+  /**
+   * 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.
+   * @param args.method - The RPC method name.
+   * @param args.params - The parameters for the RPC method.
+   * @returns A Promise that resolves with the result of the RPC method,
+   * or rejects if an error is encountered.
+   */
+  async request<T>(args: RequestArguments): Promise<Maybe<T>> {
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+      throw ethErrors.rpc.invalidRequest({
+        message: messages.errors.invalidRequestArgs(),
+        data: args,
+      });
+    }
+
+    const { method, params } = args;
+
+    if (typeof method !== "string" || method.length === 0) {
+      throw ethErrors.rpc.invalidRequest({
+        message: messages.errors.invalidRequestMethod(),
+        data: args,
+      });
+    }
+
+    if (method === "wallet_addEthereumChain") {
+      if (!Array.isArray(params) || params.length === 0) {
+        throw ethErrors.rpc.invalidRequest({
+          message: messages.errors.invalidRequestParams(),
+          data: args,
+        });
+      }
+      const network = params[0] as any;
+      if (!network || !network.chainName || !network.rpcUrls || !network.chainId || !network.nativeCurrency) {
+        throw ethErrors.rpc.invalidRequest({
+          message: messages.errors.invalidRequestParams(),
+          data: args,
+        });
+      }
+    }
+
+    if (method === "personal_sign") {
+      if (!Array.isArray(params) || params.length !== 2 || !params[0] || !params[1]) {
+        throw ethErrors.rpc.invalidRequest({
+          message: messages.errors.invalidRequestParams(),
+          data: args,
+        });
+      }
+    }
+
+    if (method === "wallet_watchAsset") {
+      const { type, options } = params as {
+        type: string;
+        options: {
+          address: string;
+          symbol: string;
+          decimals: number;
+        };
+      };
+      const isNotCompelete = !options || !options.address || !options.symbol || !options.decimals;
+      if (!type || isNotCompelete) {
+        throw ethErrors.rpc.invalidRequest({
+          message: messages.errors.invalidRequestParams(),
+          data: args,
+        });
+      }
+    }
+
+    if (params !== undefined && !Array.isArray(params) && (typeof params !== "object" || params === null)) {
+      throw ethErrors.rpc.invalidRequest({
+        message: messages.errors.invalidRequestParams(),
+        data: args,
+      });
+    }
+
+    const connectFuns: Record<string, boolean> = {
+      enable: true,
+      connect: true,
+      eth_accounts: true,
+      eth_requestAccounts: true,
+    };
+    // if (connectFuns[args.method] || args.method === "_wallet_getProviderState" || args.method === "disconnect") {
+    const dappInfo = await getDappInfo();
+    args = { ...args, ...{ dappInfo } };
+    // }
+
+    this.sendRequest(chainType, args);
+
+    return this.onResponse(args).then((res: any) => {
+      const { data, method } = res || {};
+
+      if (method === "_wallet_getProviderState") {
+        this._handleAccountsChanged(data?.accounts || [], true);
+      }
+      if (method === "wallet_revokePermissions") {
+        this._handleAccountsChanged([], true);
+      }
+      if (method in connectFuns && connectFuns[method]) {
+        this._handleAccountsChanged(data || [], true);
+      }
+
+      if (method === "wallet_switchEthereumChain" || method === "eth_chainId") {
+        this._handleChainChanged({ chainId: data, isConnected: true });
+      }
+
+      return data;
+    });
+  }
+
+  /**
+   * Submits an RPC request per the given JSON-RPC request object.
+   *
+   * @param payload - The RPC request object.
+   * @param cb - The callback function.
+   */
+  sendAsync(
+    payload: JsonRpcRequest<unknown>,
+    callback: (error: Error | null, result?: JsonRpcResponse<unknown>) => void,
+  ): void {
+    this._rpcRequest(payload, callback);
+  }
+
+  /**
+   * We override the following event methods so that we can warn consumers
+   * about deprecated events:
+   *   addListener, on, once, prependListener, prependOnceListener
+   */
+
+  addListener(eventName: string, listener: (...args: unknown[]) => void) {
+    this._warnOfDeprecation(eventName);
+    return super.addListener(eventName, listener);
+  }
+
+  on(eventName: string, listener: (...args: unknown[]) => void) {
+    this._warnOfDeprecation(eventName);
+    return super.on(eventName, listener);
+  }
+
+  once(eventName: string, listener: (...args: unknown[]) => void) {
+    this._warnOfDeprecation(eventName);
+    return super.once(eventName, listener);
+  }
+
+  prependListener(eventName: string, listener: (...args: unknown[]) => void) {
+    this._warnOfDeprecation(eventName);
+    return super.prependListener(eventName, listener);
+  }
+
+  prependOnceListener(eventName: string, listener: (...args: unknown[]) => void) {
+    this._warnOfDeprecation(eventName);
+    return super.prependOnceListener(eventName, listener);
+  }
+
+  //====================
+  // Private Methods
+  //====================
+
+  /**
+   * Constructor helper.
+   * Populates initial state by calling 'getProviderState' and emits
+   * necessary events.
+   */
+  private async _initializeState() {
+    try {
+      const {
+        accounts = [],
+        chainId = "0x01",
+        isUnlocked = false,
+        isConnected = false,
+      } = (await this.request({
+        method: "wallet_getProviderState",
+      })) as {
+        accounts: string[];
+        chainId: string;
+        isUnlocked: boolean;
+        isConnected: boolean;
+      };
+
+      // indicate that we've connected, for EIP-1193 compliance
+      this.emit("connect", { chainId });
+
+      this._handleChainChanged({ chainId, isConnected });
+      this._handleUnlockStateChanged({ accounts, isUnlocked });
+      this._handleAccountsChanged(accounts);
+
+      window.addEventListener("message", (event: MessageEvent<any>) => {
+        const { data, type, method } = event.data;
+        if (type === "subscribeWalletEvents" && method) {
+          this.subscribeWalletEventsCallback({ data, method });
+        }
+      });
+    } catch (error) {
+      this._log.error(`${this.name}: Failed to get initial state.`, error);
+    } finally {
+      this._state.initialized = true;
+      this.emit("_initialized");
+    }
+
+    this.keepAlive();
+  }
+
+  private subscribeWalletEventsCallback = ({ method, data }: { method: string; data: any }) => {
+    if (method === "accountsChanged") {
+      const addresses = data?.[chainType] || [];
+      const accounts = addresses.map(({ address }: { address: string }) => address);
+      this._handleAccountsChanged(accounts, true);
+    }
+    if (method === "chainChanged") {
+      const { chainId, type }: { chainId: string; type: string } = data;
+      if (type.indexOf(`${chainType}:`) === 0) {
+        const chainIdHex = toHex(parseInt(chainId));
+        this._handleChainChanged({ chainId: chainIdHex, isConnected: true });
+      }
+    }
+  };
+
+  private keepAlive = () => {
+    this.request({
+      method: "keepAlive",
+      params: {},
+    }).then(() => {
+      setTimeout(() => {
+        this.keepAlive();
+      }, 1000);
+    });
+  };
+
+  /**
+   * Internal RPC method. Forwards requests to background via the RPC engine.
+   * Also remap ids inbound and outbound.
+   *
+   * @param payload - The RPC request object.
+   * @param callback - The consumer's callback.
+   */
+  private _rpcRequest(
+    payload: UnvalidatedJsonRpcRequest | UnvalidatedJsonRpcRequest[],
+    callback: (...args: any[]) => void,
+  ) {
+    let cb = callback;
+
+    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: Error, res: JsonRpcSuccess<string[]>) => {
+          this._handleAccountsChanged(res.result || [], payload.method === "eth_accounts");
+          callback(err, res);
+        };
+      }
+      return this._rpcEngine.handle(payload as JsonRpcRequest<unknown>, cb);
+    }
+    return this._rpcEngine.handle(payload as JsonRpcRequest<unknown>[], cb);
+  }
+
+  /**
+   * 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
+   */
+  private _handleConnect(chainId: string) {
+    if (!this._state.isConnected) {
+      this._state.isConnected = true;
+      this.emit("connect", { chainId });
+      // this._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 InpageProvider#disconnect
+   */
+  private _handleDisconnect(isRecoverable: boolean, errorMessage?: string) {
+    if (this._state.isConnected || (!this._state.isPermanentlyDisconnected && !isRecoverable)) {
+      this._state.isConnected = false;
+
+      let error;
+      if (isRecoverable) {
+        error = new EthereumRpcError(
+          1013, // Try again later
+          errorMessage || messages.errors.disconnected(),
+        );
+        // this._log.debug(error);
+      } else {
+        error = new EthereumRpcError(
+          1011, // Internal error
+          errorMessage || messages.errors.permanentlyDisconnected(),
+        );
+        // this._log.error(error);
+        this.chainId = null;
+        this.networkVersion = null;
+        this._state.accounts = null;
+        this.selectedAddress = null;
+        this._state.isUnlocked = false;
+        this._state.isPermanentlyDisconnected = true;
+      }
+
+      this.emit("disconnect", error);
+      this.emit("close", error); // deprecated
+    }
+  }
+
+  /**
+   * Called when connection is lost to critical streams.
+   *
+   * @emits InpageProvider#disconnect
+   */
+  private _handleStreamDisconnect(streamName: string, error: Error) {
+    logStreamDisconnectWarning(this._log, streamName, error, this);
+    this._handleDisconnect(false, error ? error?.message : undefined);
+  }
+
+  /**
+   * 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 InpageProvider#chainChanged
+   * @param networkInfo - An object with network info.
+   * @param networkInfo.chainId - The latest chain ID.
+   * @param networkInfo.networkVersion - The latest network ID.
+   */
+  private _handleChainChanged({ chainId, isConnected }: { chainId?: string; isConnected?: boolean } = {}) {
+    if (!chainId || typeof chainId !== "string" || !chainId.startsWith("0x")) {
+      // this._log.error(`${this.name}: Received invalid network parameters.`, {
+      //   chainId,
+      // });
+      return;
+    }
+
+    if (!isConnected) {
+      this._handleDisconnect(true);
+    } else {
+      this._handleConnect(chainId);
+
+      if (chainId !== this.chainId) {
+        this.chainId = chainId;
+        if (this._state.initialized) {
+          this.emit("chainChanged", this.chainId);
+        }
+      }
+    }
+  }
+
+  /**
+   * Called when accounts may have changed. Diffs the new accounts value with
+   * the current one, updates all state as necessary, and emits the
+   * accountsChanged event.
+   *
+   * @param accounts - The new accounts value.
+   * @param isEthAccounts - Whether the accounts value was returned by
+   * a call to eth_accounts.
+   */
+  private _handleAccountsChanged(accounts: unknown[], isEthAccounts = false): void {
+    let _accounts = accounts;
+
+    if (!Array.isArray(accounts)) {
+      this._log.error(`${this.name}: Received invalid accounts parameter.`, accounts);
+      _accounts = [];
+    }
+
+    for (const account of accounts) {
+      if (typeof account !== "string") {
+        this._log.error(`${this.name}: Received non-string account.`, accounts);
+        _accounts = [];
+        break;
+      }
+    }
+
+    // emit accountsChanged if anything about the accounts array has changed
+    if (this._state.accounts !== _accounts) {
+      // we should always have the correct accounts even before eth_accounts
+      // returns
+      if (isEthAccounts && this._state.accounts !== null) {
+        // this._log.error(
+        //   `${this.name}: 'eth_accounts' unexpectedly updated accounts. Please report this bug.`,
+        //   _accounts,
+        // );
+      }
+
+      this._state.accounts = _accounts as string[];
+
+      // handle selectedAddress
+      if (this.selectedAddress !== _accounts[0]) {
+        this.selectedAddress = (_accounts[0] as string) || null;
+      }
+
+      // finally, after all state has been updated, emit the event
+      if (this._state.initialized) {
+        this.emit("accountsChanged", _accounts);
+      }
+    }
+  }
+
+  /**
+   * 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.
+   * @param opts.accounts - The exposed accounts, if any.
+   * @param opts.isUnlocked - The latest isUnlocked value.
+   */
+  private _handleUnlockStateChanged({ accounts, isUnlocked }: { accounts?: string[]; isUnlocked?: boolean } = {}) {
+    if (typeof isUnlocked !== "boolean") {
+      this._log.error(`${this.name}: Received invalid isUnlocked parameter.`);
+      return;
+    }
+
+    if (isUnlocked !== this._state.isUnlocked) {
+      this._state.isUnlocked = isUnlocked;
+      this._handleAccountsChanged(accounts || []);
+    }
+  }
+
+  /**
+   * Warns of deprecation for the given event, if applicable.
+   */
+  private _warnOfDeprecation(eventName: string): void {
+    const events = this._state.sentWarnings.events;
+    if (events[eventName as WarningEventName] === false) {
+      this._log.warn(messages.warnings.events[eventName as WarningEventName]);
+      events[eventName as WarningEventName] = true;
+    }
+  }
+
+  //====================
+  // Deprecated Methods
+  //====================
+
+  /**
+   * Equivalent to: ethereum.request('eth_requestAccounts')
+   *
+   * @deprecated Use request({ method: 'eth_requestAccounts' }) instead.
+   * @returns A promise that resolves to an array of addresses.
+   */
+  enable(): Promise<string[]> {
+    return this.connect();
+  }
+
+  setConnectedStatus({ connected, address }: { connected: boolean; address: string[] }) {
+    this._state.isConnected = connected;
+    this._state.accounts = address;
+  }
+
+  connect(): Promise<string[]> {
+    if (!this._state.sentWarnings.enable) {
+      this._log.warn(messages.warnings.enableDeprecation);
+      this._state.sentWarnings.enable = true;
+    }
+    return new Promise<string[]>((resolve, reject) => {
+      if (this._state.isConnected) {
+        resolve(this._state.accounts as string[]);
+      }
+      try {
+        this.request<string[]>({
+          method: "eth_requestAccounts",
+        }).then((accounts) => {
+          if (accounts) {
+            this.emit("connect", {});
+            resolve(accounts as string[]);
+          } else {
+            reject(new Error("No accounts returned"));
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  disconnect(): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
+      try {
+        (async () => {
+          const { isConnected } = (await this.request({
+            method: "wallet_revokePermissions",
+          })) as {
+            isConnected: boolean;
+          };
+          if (!isConnected) {
+            this._handleDisconnect(true);
+            this.emit("disconnect", null);
+          }
+          resolve(!isConnected);
+        })();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Submits an RPC request for the given method, with the given params.
+   *
+   * @deprecated Use "request" instead.
+   * @param method - The method to request.
+   * @param params - Any params for the method.
+   * @returns A Promise that resolves with the JSON-RPC response object for the
+   * request.
+   */
+  send<T>(method: string, params?: T[]): Promise<JsonRpcResponse<T>>;
+
+  /**
+   * Submits an RPC request per the given JSON-RPC request object.
+   *
+   * @deprecated Use "request" instead.
+   * @param payload - A JSON-RPC request object.
+   * @param callback - An error-first callback that will receive the JSON-RPC
+   * response object.
+   */
+  send<T>(payload: JsonRpcRequest<unknown>, callback: (error: Error | null, result?: JsonRpcResponse<T>) => void): void;
+
+  /**
+   * Accepts a JSON-RPC request object, and synchronously returns the cached result
+   * for the given method. Only supports 4 specific RPC methods.
+   *
+   * @deprecated Use "request" instead.
+   * @param payload - A JSON-RPC request object.
+   * @returns A JSON-RPC response object.
+   */
+  send<T>(payload: SendSyncJsonRpcRequest): JsonRpcResponse<T>;
+
+  send(methodOrPayload: unknown, callbackOrArgs?: unknown): unknown {
+    if (!this._state.sentWarnings.send) {
+      this._log.warn(messages.warnings.sendDeprecation);
+      this._state.sentWarnings.send = true;
+    }
+
+    if (typeof methodOrPayload === "string" && (!callbackOrArgs || Array.isArray(callbackOrArgs))) {
+      return new Promise((resolve, reject) => {
+        try {
+          this._rpcRequest(
+            { method: methodOrPayload, params: callbackOrArgs },
+            getRpcPromiseCallback(resolve, reject, false),
+          );
+        } catch (error) {
+          reject(error);
+        }
+      });
+    } else if (methodOrPayload && typeof methodOrPayload === "object" && typeof callbackOrArgs === "function") {
+      return this._rpcRequest(
+        methodOrPayload as JsonRpcRequest<unknown>,
+        callbackOrArgs as (...args: unknown[]) => void,
+      );
+    }
+    return this._sendSync(methodOrPayload as SendSyncJsonRpcRequest);
+  }
+
+  /**
+   * Internal backwards compatibility method, used in send.
+   *
+   * @deprecated
+   */
+  private _sendSync(payload: SendSyncJsonRpcRequest) {
+    let result;
+    switch (payload.method) {
+      case "eth_accounts":
+        result = this.selectedAddress ? [this.selectedAddress] : [];
+        break;
+
+      case "eth_coinbase":
+        result = this.selectedAddress || null;
+        break;
+
+      case "eth_uninstallFilter":
+        this._rpcRequest(payload, NOOP);
+        result = true;
+        break;
+
+      case "net_version":
+        result = this.networkVersion || null;
+        break;
+
+      default:
+        throw new Error(messages.errors.unsupportedSync(payload.method));
+    }
+
+    return {
+      id: payload.id,
+      jsonrpc: payload.jsonrpc,
+      result,
+    };
+  }
+}
+
+function validateLoggerObject(logger: ConsoleLike): void {
+  if (logger !== console) {
+    if (typeof logger === "object") {
+      const methodKeys = ["log", "warn", "error", "debug", "info", "trace"];
+      for (const key of methodKeys) {
+        if (typeof logger[key as keyof ConsoleLike] !== "function") {
+          throw new Error(messages.errors.invalidLoggerMethod(key));
+        }
+      }
+      return;
+    }
+    throw new Error(messages.errors.invalidLoggerObject());
+  }
+}
+
+/**
+ * Initializes a InpageProvider and (optionally) assigns it as window.ethereum.
+ *
+ * @param options - An options bag.
+ * @param options.connectionStream - A Node.js stream.
+ * @param options.jsonRpcStreamName - The name of the internal JSON-RPC stream.
+ * @param options.maxEventListeners - The maximum number of event listeners.
+ * @param options.shouldSendMetadata - Whether the provider should send page metadata.
+ * @param options.shouldSetOnWindow - Whether the provider should be set as window.ethereum.
+ * @param options.shouldShimWeb3 - Whether a window.web3 shim should be injected.
+ * @returns The initialized provider (whether set or not).
+ */
+export function initializeEvmProvider(
+  productInfo: IProductInfo,
+  {
+    jsonRpcStreamName,
+    logger = console,
+    maxEventListeners = 100,
+    shouldSendMetadata = true,
+    shouldSetOnWindow = true,
+    shouldShimWeb3 = false,
+    sendRequest,
+    onResponse,
+  }: InitializeProviderOptions,
+): EvmProvider {
+  let provider = new EvmProvider(productInfo, {
+    jsonRpcStreamName,
+    logger,
+    maxEventListeners,
+    shouldSendMetadata,
+    sendRequest,
+    onResponse,
+  });
+
+  provider = new Proxy(provider, {
+    // some common libraries, e.g. web3@1.x, mess with our API
+    deleteProperty: () => true,
+  });
+
+  if (shouldSetOnWindow) {
+    setGlobalProvider(provider);
+  }
+
+  if (shouldShimWeb3) {
+    // shimWeb3(provider, logger);
+  }
+
+  return provider;
+}
+
+/**
+ * Sets the given provider instance as window.ethereum and dispatches the
+ * 'ethereum#initialized' event on window.
+ *
+ * @param providerInstance - The provider instance.
+ */
+export function setGlobalProvider(providerInstance: EvmProvider): void {
+  (window as Record<string, any>).ethereum = providerInstance;
+  window.dispatchEvent(new Event("ethereum#initialized"));
+}