@tomo-inc/inject-providers 0.0.2

package/src/evm/shimWeb3.ts

@@ -0,0 +1,49 @@
+import { EvmProvider } from "./metamask";
+
+/**
+ * If no existing window.web3 is found, this function injects a web3 "shim" to
+ * not break dapps that rely on window.web3.currentProvider.
+ *
+ * @param provider - The provider to set as window.web3.currentProvider.
+ * @param log - The logging API to use.
+ */
+export default function shimWeb3(provider: EvmProvider, log: any): void {
+  let loggedCurrentProvider = false;
+  let loggedMissingProperty = false;
+
+  if (!(window as Record<string, any>).web3) {
+    const SHIM_IDENTIFIER = "__isShim__";
+
+    let web3Shim = { currentProvider: provider };
+    Object.defineProperty(web3Shim, SHIM_IDENTIFIER, {
+      value: true,
+      enumerable: true,
+      configurable: false,
+      writable: false,
+    });
+
+    web3Shim = new Proxy(web3Shim, {
+      get: (target, property, ...args) => {
+        if (property === "currentProvider" && !loggedCurrentProvider) {
+          loggedCurrentProvider = true;
+        } else if (property !== "currentProvider" && property !== SHIM_IDENTIFIER && !loggedMissingProperty) {
+          loggedMissingProperty = true;
+          provider.request({ method: "wallet_logWeb3ShimUsage" }).catch((error) => {
+            log.debug(`Failed to log web3 shim usage.`, error);
+          });
+        }
+        return Reflect.get(target, property, ...args);
+      },
+      set: (...args) => {
+        return Reflect.set(...args);
+      },
+    });
+
+    Object.defineProperty(window, "web3", {
+      value: web3Shim,
+      enumerable: false,
+      configurable: true,
+      writable: true,
+    });
+  }
+}

package/src/evm/type.ts

@@ -0,0 +1,81 @@
+import { JsonRpcId, JsonRpcRequest, JsonRpcVersion } from "json-rpc-engine";
+import { ConsoleLike } from "./utils";
+
+export interface UnvalidatedJsonRpcRequest {
+  id?: JsonRpcId;
+  jsonrpc?: JsonRpcVersion;
+  method: string;
+  params?: unknown;
+}
+
+export interface InpageProviderOptions {
+  /**
+   * The logging API to use.
+   */
+  logger?: ConsoleLike;
+
+  jsonRpcStreamName?: any;
+
+  /**
+   * The maximum number of event listeners.
+   */
+  maxEventListeners?: number;
+
+  /**
+   * Whether the provider should send page metadata.
+   */
+  shouldSendMetadata?: boolean;
+
+  sendRequest: (chainType: string, data: any) => void;
+
+  onResponse: any;
+}
+
+export interface RequestArguments {
+  /** The RPC method to request. */
+  method: string;
+
+  /** The params of the RPC method, if any. */
+  params?: unknown[] | Record<string, unknown>;
+}
+
+export interface SendSyncJsonRpcRequest extends JsonRpcRequest<unknown> {
+  method: "eth_accounts" | "eth_coinbase" | "eth_uninstallFilter" | "net_version";
+}
+
+export interface InternalState {
+  sentWarnings: {
+    // methods
+    enable: boolean;
+    experimentalMethods: boolean;
+    send: boolean;
+    // events
+    events: {
+      close: boolean;
+      data: boolean;
+      networkChanged: boolean;
+      notification: boolean;
+    };
+  };
+  accounts: null | string[];
+  isConnected: boolean;
+  isUnlocked: boolean;
+  initialized: boolean;
+  isPermanentlyDisconnected: boolean;
+}
+
+export type WarningEventName = keyof InternalState["sentWarnings"]["events"];
+
+export interface InitializeProviderOptions extends InpageProviderOptions {
+  /**
+   * Whether the provider should be set as window.ethereum.
+   */
+  shouldSetOnWindow?: boolean;
+
+  jsonRpcStreamName?: any;
+
+  /**
+   * Whether the window.web3 shim should be set.
+   */
+  shouldShimWeb3?: boolean;
+}

package/src/evm/utils.ts

@@ -0,0 +1,85 @@
+import { ethErrors } from "eth-rpc-errors";
+import { EventEmitter } from "events";
+import { JsonRpcMiddleware, PendingJsonRpcResponse } from "json-rpc-engine";
+
+export type Maybe<T> = Partial<T> | null | undefined;
+
+export type ConsoleLike = Pick<Console, "log" | "warn" | "error" | "debug" | "info" | "trace">;
+
+// utility functions
+
+/**
+ * json-rpc-engine middleware that logs RPC errors and and validates req.method.
+ *
+ * @param log - The logging API to use.
+ * @returns  json-rpc-engine middleware function
+ */
+export function createErrorMiddleware(log: ConsoleLike): JsonRpcMiddleware<unknown, unknown> {
+  return (req, res, next) => {
+    // json-rpc-engine will terminate the request when it notices this error
+    if (typeof req.method !== "string" || !req.method) {
+      res.error = ethErrors.rpc.invalidRequest({
+        message: `The request 'method' must be a non-empty string.`,
+        data: req,
+      });
+    }
+
+    next((done) => {
+      const { error } = res;
+      if (!error) {
+        return done();
+      }
+      log.error(`RPC Error: ${error.message}`, error);
+      return done();
+    });
+  };
+}
+
+// resolve response.result or response, reject errors
+export const getRpcPromiseCallback =
+  (resolve: (value?: any) => void, reject: (error?: Error) => void, unwrapResult = true) =>
+  (error: Error, response: PendingJsonRpcResponse<unknown>): void => {
+    if (error || response.error) {
+      reject(error || (response.error as Error));
+    } else {
+      !unwrapResult || Array.isArray(response) ? resolve(response) : resolve(response.result);
+    }
+  };
+
+/**
+ * Logs a stream disconnection error. Emits an 'error' if given an
+ * EventEmitter that has listeners for the 'error' event.
+ *
+ * @param log - The logging API to use.
+ * @param remoteLabel - The label of the disconnected stream.
+ * @param error - The associated error to log.
+ * @param emitter - The logging API to use.
+ */
+export function logStreamDisconnectWarning(
+  log: ConsoleLike,
+  remoteLabel: string,
+  error: Error,
+  emitter: EventEmitter,
+): void {
+  let warningMsg = `Lost connection to "${remoteLabel}".`;
+  if (error?.stack) {
+    warningMsg += `\n${error.stack}`;
+  }
+  log.warn(warningMsg);
+  if (emitter && emitter.listenerCount("error") > 0) {
+    emitter.emit("error", warningMsg);
+  }
+}
+
+export const NOOP = () => undefined;
+
+// constants
+
+export const EMITTED_NOTIFICATIONS = [
+  "eth_subscription", // per eth-json-rpc-filters/subscriptionManager
+];
+
+export const guid = () => {
+  const guid = `w-` + (Math.random() * (1 << 30)).toString(16).replace(".", "");
+  return guid;
+};

package/src/global.d.ts

@@ -0,0 +1,37 @@
+declare module "eth-rpc-errors" {
+  export class EthereumRpcError<T = any> extends Error {
+    code: number;
+    data?: T;
+    constructor(code: number, message: string, data?: T);
+  }
+
+  export interface EthereumProviderError<T = any> extends Error {
+    message: string;
+    code: number;
+    data?: T;
+  }
+
+  export const ethErrors: {
+    rpc: {
+      invalidInput: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      resourceNotFound: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      resourceUnavailable: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      transactionRejected: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      methodNotSupported: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      limitExceeded: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      parse: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      invalidRequest: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      methodNotFound: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      invalidParams: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      internal: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+    };
+    provider: {
+      userRejectedRequest: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      unauthorized: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      unsupportedMethod: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      disconnected: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      chainDisconnected: (opts?: { message?: string; data?: any }) => EthereumRpcError;
+      custom: (opts: { code: number; message: string; data?: any }) => EthereumRpcError;
+    };
+  };
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+import { BtcProvider } from "./btc";
+import { DogecoinProvider } from "./dogecoin";
+import { EvmProvider } from "./evm";
+import { SolanaProvider } from "./solana";
+import { TronProvider } from "./tron";
+
+export { BtcProvider, DogecoinProvider, EvmProvider, SolanaProvider, TronProvider };

package/src/solana/index.ts

@@ -0,0 +1,3 @@
+import { PhantomProvider } from "./phantom";
+
+export { PhantomProvider as SolanaProvider };

package/src/solana/phantom.ts

@@ -0,0 +1,424 @@
+import { ethErrors } from "eth-rpc-errors";
+import { EventEmitter } from "events";
+
+import { PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+import bs58 from "bs58";
+
+import { ReadyPromise, domReadyCall, getDappInfo, hexToUint8Array, isHexString } from "../utils/index";
+import { hexToTx, txToHex } from "./utils";
+
+import { ChainTypes, IConnectors, IProductInfo } from "../types";
+import { OriginTransaction, SignInInput } from "./types";
+const chainType = ChainTypes.SOL;
+
+interface StateProvider {
+  accounts: any[] | null;
+  isConnected: boolean;
+  isUnlocked: boolean;
+  initialized: boolean;
+  isPermanentlyDisconnected: boolean;
+}
+
+export class PhantomProvider extends EventEmitter {
+  _isUnlocked = false;
+  name = "";
+  icon = "";
+  publicKey: PublicKey | null = null;
+  sendRequest: (chainType: string, data: any) => void;
+  onResponse: any;
+  events = {
+    connect: true,
+    disconnect: true,
+    accountChanged: true,
+  };
+
+  _state: StateProvider = {
+    accounts: null,
+    isConnected: false,
+    isUnlocked: false,
+    initialized: false,
+    isPermanentlyDisconnected: false,
+  };
+
+  // private _pushEventHandlers: PushEventHandlers;
+  private _requestPromise = new ReadyPromise(0);
+
+  constructor(productInfo: IProductInfo, { sendRequest, onResponse }: IConnectors) {
+    super();
+    this.setMaxListeners(100);
+    this.name = productInfo.name;
+    this.icon = productInfo.icon;
+    this.sendRequest = sendRequest;
+    this.onResponse = onResponse;
+
+    this.initialize();
+    this._handleAccountsChanged = this._handleAccountsChanged.bind(this);
+    // this._pushEventHandlers = new PushEventHandlers(this);
+
+    this.on("connect", () => {
+      this._state.isConnected = true;
+    });
+  }
+
+  initialize = async () => {
+    //dapp tab switch send data;
+    document.addEventListener("visibilitychange", async () => {
+      if (document.visibilityState === "visible") {
+        this._request({
+          method: "wallet_sendDomainMetadata",
+          params: await getDappInfo(),
+        });
+      }
+    });
+
+    // this._bcm.connect().on("message", this._handleBackgroundMessage);
+    domReadyCall(async () => {
+      this._request({
+        method: "wallet_sendDomainMetadata",
+        params: await getDappInfo(),
+      });
+    });
+
+    window.addEventListener("message", (event: MessageEvent<any>) => {
+      const { data, type, method } = event.data;
+      if (type === "subscribeWalletEvents" && method) {
+        this.subscribeWalletEventsCallback({ data, method });
+      }
+    });
+
+    this.keepAlive();
+    this._state.initialized = true;
+  };
+
+  subscribeWalletEventsCallback = ({ method, data }: { method: string; data: any }) => {
+    if (method === "accountsChanged") {
+      const accounts = data?.[chainType];
+      this._handleAccountsChanged(accounts);
+    }
+  };
+
+  /**
+   * Sending a message to the extension to receive will keep the service worker alive.
+   */
+  private keepAlive = () => {
+    this._request({
+      method: "keepAlive",
+      params: {},
+    }).then(() => {
+      setTimeout(() => {
+        this.keepAlive();
+      }, 1000);
+    });
+  };
+
+  on(eventName: string, listener: (...args: unknown[]) => void) {
+    if (!this.events[eventName as keyof typeof this.events]) {
+      throw Error("${eventName} no supported.");
+    }
+    return super.on(eventName, listener);
+  }
+
+  private _handleAccountsChanged(accounts: any[]): void {
+    let _accounts = accounts;
+
+    if (!Array.isArray(accounts)) {
+      console.error(`${this.name}: Received invalid accounts parameter.`, accounts);
+      _accounts = [];
+    }
+
+    if (this._state.accounts !== _accounts) {
+      this._state.accounts = _accounts;
+
+      // handle selectedAddress
+      // if (this._state.publicKey !== _accounts[0]?.publicKey) {
+      //   this._state.publicKey = _accounts[0]?.publicKey;
+      // }
+      const { publicKey, address } = _accounts[0] || {};
+      const currentPublicKey = publicKey || address;
+      if (currentPublicKey) {
+        this.publicKey = new PublicKey(currentPublicKey);
+      }
+
+      // finally, after all state has been updated, emit the event
+      if (this._state.initialized) {
+        this.emit("accountChanged", this.publicKey);
+      }
+    }
+  }
+
+  _request = async (data: any, responseAdaptor?: any) => {
+    if (!data || !data.method) {
+      throw ethErrors.rpc.invalidRequest();
+    }
+
+    const dappInfo = await getDappInfo();
+
+    this.sendRequest(chainType, { ...data, dappInfo });
+
+    return this.onResponse(data).then((res: any) => {
+      let { data } = res || {};
+      if (data && data.publicKey) {
+        data = {
+          ...data,
+          ...{ publicKey: new PublicKey(data.publicKey) },
+        };
+      }
+      if (data && data.address && !data.publicKey) {
+        data = {
+          ...data,
+          ...{ address: new PublicKey(data.address) },
+        };
+      }
+
+      if (responseAdaptor) {
+        return responseAdaptor(data);
+      }
+
+      return data;
+    });
+  };
+
+  request = async ({ method, params }: { method: string; params: any }, responseAdaptor: any) => {
+    if (method === "signMessage") {
+      const { message, display = "utf8" } = params;
+      params = {
+        ...params,
+        ...{
+          message: new TextDecoder().decode(message),
+          display,
+        },
+      };
+    }
+    const dappInfo = await getDappInfo();
+    return this._request(
+      {
+        method,
+        params: { ...dappInfo, ...(params || {}) },
+      },
+      responseAdaptor,
+    );
+  };
+
+  //phantom api
+  connect = async (params?: { onlyIfTrusted: boolean }) => {
+    const dappInfo = await getDappInfo();
+    return this._request(
+      {
+        method: "connect",
+        params: { ...dappInfo, ...(params || {}) },
+      },
+      (data: any) => {
+        this.emit("connect", true);
+        this.publicKey = data?.publicKey;
+        return data;
+      },
+    );
+  };
+
+  disconnect = async () => {
+    return this._request(
+      {
+        method: "disconnect",
+        params: await getDappInfo(),
+      },
+      (data: any) => {
+        this.emit("disconnect", true);
+        this.publicKey = null;
+        return data;
+      },
+    );
+  };
+
+  getAccount = async () => {
+    return this._request({
+      method: "getAccount",
+      params: {},
+    });
+  };
+
+  signMessage = async (message: Uint8Array, display: "utf8" | "hex") => {
+    return this._request(
+      {
+        method: "signMessage",
+        params: {
+          message: new TextDecoder().decode(message),
+          display,
+        },
+      },
+      (data: any) => {
+        if (data && data.signedMessage) {
+          data = {
+            ...data,
+            ...{ signedMessage: new TextEncoder().encode(data.signedMessage) },
+          };
+        }
+        if (data && data.signature) {
+          const signature = hexToUint8Array(data.signature);
+          data = {
+            ...data,
+            ...{ signature },
+          };
+        }
+        return data;
+      },
+    );
+  };
+
+  //doc: https://github.com/phantom/sign-in-with-solana
+  signIn = async (params?: SignInInput) => {
+    const { domain = window.location.host, statement, nonce, version, issuedAt, resources = [] } = params || {};
+    const address = this.publicKey ? this.publicKey.toString() : "";
+
+    let message = `${domain} wants you to sign in with your Solana account:\n${address}`;
+
+    if (statement) {
+      message += `\n\n${statement}`;
+    }
+    if (version) {
+      message += `\n\nVersion:${version}`;
+    }
+    if (nonce) {
+      message += `\nNonce:${nonce}`;
+    }
+    if (issuedAt) {
+      message += `\nIssued At:${issuedAt}`;
+    }
+    if (resources.length > 0) {
+      message += `\nResources:`;
+      resources.forEach((resource) => {
+        message += `\n- ${resource}`;
+      });
+    }
+
+    return this._request(
+      {
+        method: "signIn",
+        params: {
+          message,
+        },
+      },
+      (data: any) => {
+        if (data && data.signedMessage) {
+          data = {
+            ...data,
+            ...{ signedMessage: new TextEncoder().encode(data.signedMessage) },
+          };
+        }
+        if (data && data.signature) {
+          const signature = hexToUint8Array(data.signature);
+          data = {
+            ...data,
+            ...{ signature },
+          };
+        }
+        return data;
+      },
+    );
+  };
+
+  signTransaction = async (tx: VersionedTransaction | Transaction) => {
+    return this._request(
+      {
+        method: "signTransaction",
+        params: {
+          rawTransaction: txToHex(tx),
+        },
+      },
+      (data: any) => {
+        return hexToTx(data.signature);
+      },
+    );
+  };
+
+  signAllTransactions = async (txs: (VersionedTransaction | Transaction)[]) => {
+    const rawTransactions = [];
+    for (const tx of txs) {
+      rawTransactions.push(txToHex(tx));
+    }
+    return this._request(
+      {
+        method: "signAllTransactions",
+        params: {
+          rawTransactions,
+        },
+      },
+      (data: any) => {
+        return data;
+      },
+    );
+  };
+
+  signAndSendTransaction = async (tx: VersionedTransaction | Transaction) => {
+    return this._request(
+      {
+        method: "signAndSendTransaction",
+        params: {
+          rawTransaction: txToHex(tx),
+        },
+      },
+      (data: any) => {
+        if (data && data.signature) {
+          const signature = bs58.decode(data.signature);
+          data = {
+            ...data,
+            ...{ signature },
+          };
+        }
+        return data;
+      },
+    );
+  };
+
+  signAndSendAllTransactions = async (txs: (VersionedTransaction | Transaction)[]) => {
+    const rawTransactions = [];
+    for (const tx of txs) {
+      rawTransactions.push(txToHex(tx));
+    }
+    return this._request({
+      method: "signAndSendAllTransactions",
+      params: {
+        rawTransactions,
+      },
+    });
+  };
+
+  sendSolana = async (tx: OriginTransaction) => {
+    return this._request(
+      {
+        method: "sendSolana",
+        intent: true,
+        params: tx,
+      },
+      (data: any) => {
+        if (data && data.signature) {
+          const signature = isHexString(data.signature) ? hexToUint8Array(data.signature) : bs58.decode(data.signature);
+          data = {
+            ...data,
+            ...{ signature },
+          };
+        }
+        return data;
+      },
+    );
+  };
+
+  sendToken = async (tx: OriginTransaction) => {
+    return this._request(
+      {
+        method: "sendToken",
+        intent: true,
+        params: tx,
+      },
+      (data: any) => {
+        if (data && data.signature) {
+          const signature = isHexString(data.signature) ? hexToUint8Array(data.signature) : bs58.decode(data.signature);
+          data = {
+            ...data,
+            ...{ signature },
+          };
+        }
+        return data;
+      },
+    );
+  };
+}