@tomo-inc/inject-providers 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+# @tomo-inc/inject-providers
+
+## 0.0.1

package/README.md

@@ -0,0 +1,58 @@
+# @tomo-inc/inject-providers
+
+Supply wallet standard APIs.
+
+## Data flow
+
+browser extension/web dapp
+
+```mermaid
+sequenceDiagram
+    participant dapp
+    participant provider
+    provider -->> dapp: inject API
+    dapp ->> provider: call API
+    provider -->> dapp: result
+    Note right of provider: approve for private key
+
+    provider ->> relay: check API + params, ask for use approve
+    relay -->> provider: result
+
+    relay ->> server API: request
+    server API -->> relay: result
+
+```
+
+## supported
+
+```
+//chainType + wallet standard
+doge: "doge",
+evm: "metamask",
+solana: "solana",
+xxxx: "xxxx",
+```
+
+## how to use?
+
+### 1. namespaces + product info
+
+file: /content/inject/setting
+
+export providers
+
+### 2. onRequest/onResponse
+
+1. onProviderRequest: receive and deliver dapp request
+2. onResponse: send result back to dapp
+
+### 3. provider-in-wallet
+
+1. xxxRequest：XxxxRequest(chainType: string, data: any, getUserApprove?: any)
+2.
+
+```
+import { IXxxxProvider, StateProvider } from "@/providers/xxxx/types";
+
+export class XxxxService implements IXxxxProvider
+```

package/eth-rpc-errors.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/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@tomo-inc/inject-providers",
+  "version": "0.0.1",
+  "author": "tomo.inc",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.98.4",
+    "@tomo-inc/wallet-utils": "^0.0.3",
+    "@tronweb3/tronwallet-adapter-tronlink": "^1.1.12",
+    "bs58": "^6.0.0",
+    "eth-rpc-errors": "^2.1.1",
+    "events": "^3.3.0",
+    "json-rpc-engine": "^6.1.0",
+    "json-rpc-middleware-stream": "^3.0.0",
+    "tronweb": "^6.0.3",
+    "viem": "^2.38.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/supertest": "^2.0.12",
+    "@vitest/browser": "^3.2.4",
+    "playwright": "^1.44.1",
+    "supertest": "^6.3.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.4"
+  }
+}

package/project.json

@@ -0,0 +1,59 @@
+{
+  "name": "inject-providers",
+  "sourceRoot": "packages/inject-providers/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "nx:run-commands",
+      "outputs": ["{projectRoot}/dist"],
+      "options": {
+        "command": "tsup src/index.ts --format esm,cjs --dts --treeshake",
+        "cwd": "packages/inject-providers"
+      }
+    },
+    "dev": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "tsup src/index.ts --format esm,cjs --watch --dts",
+        "cwd": "packages/inject-providers"
+      }
+    },
+    "lint": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "eslint src/**/*.ts",
+        "cwd": "packages/inject-providers"
+      }
+    },
+    "lint:fix": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "eslint src/**/*.ts --fix",
+        "cwd": "packages/inject-providers"
+      }
+    },
+    "format": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "prettier --write \"src/**/*.{ts,tsx}\"",
+        "cwd": "packages/inject-providers"
+      }
+    },
+    "test": {
+      "executor": "nx:run-commands",
+      "outputs": ["{projectRoot}/coverage"],
+      "options": {
+        "command": "vitest run",
+        "cwd": "packages/inject-providers"
+      }
+    },
+    "test:watch": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "vitest",
+        "cwd": "packages/inject-providers"
+      }
+    }
+  },
+  "tags": ["npm:private", "scope:inject-providers", "type:library"]
+}

package/src/btc/index.ts

@@ -0,0 +1,3 @@
+import { BtcProvider } from "./unisat";
+
+export { BtcProvider };

package/src/btc/types.ts

@@ -0,0 +1,38 @@
+export enum TxType {
+  SIGN_TX,
+  SEND_BITCOIN,
+  SEND_INSCRIPTION,
+  SEND_DOGECOIN,
+}
+
+export type Network = "livenet" | "testnet";
+export type ChainId = "BITCOIN_MAINNET" | "BITCOIN_TESTNET" | "FRACTAL_BITCOIN_MAINNET";
+
+export type Balance = {
+  confirmed: number;
+  unconfirmed: number;
+  total: number;
+};
+
+export type IBtcProvider = {
+  connect: () => Promise<any>;
+  disconnect: () => Promise<any>;
+  requestAccounts: () => Promise<any>;
+  getAccounts: () => Promise<any>;
+  getPublicKey: () => Promise<any>;
+  getBalance: () => Promise<any>;
+  getTransactionStatus: (params: { txId: string }) => Promise<any>;
+  signMessage: (params: { text: string; type: string }) => Promise<any>;
+  getNetwork: () => Promise<any>;
+  switchNetwork: (network: Network) => Promise<any>;
+  getChain: () => Promise<any>;
+  switchChain: (chainId: any) => Promise<any>;
+  networkChanged?: (network: Network) => Promise<any>;
+  chainChanged?: (chainId: ChainId) => Promise<any>;
+  signPsbt: (psbtHex: string, options?: any) => Promise<any>;
+  signPsbts?: (psbtHexs: string[], options?: any[]) => Promise<any>;
+  signTx: (rawtx: string) => Promise<any>;
+  pushTx: (rawtx: string) => Promise<any>;
+  sendTransaction: (params: any) => Promise<any>;
+  sendBitcoin: (rawtx: string) => Promise<any>;
+};

package/src/btc/unisat.ts

@@ -0,0 +1,332 @@
+import { ethErrors } from "eth-rpc-errors";
+import { EventEmitter } from "events";
+
+import { ChainTypes, IConnectors, IProductInfo } from "../types";
+import { ReadyPromise, domReadyCall, getDappInfo } from "../utils/index";
+import { Balance, ChainId, Network } from "./types";
+
+const chainType = ChainTypes.BTC;
+
+interface StateProvider {
+  accounts: string[] | null;
+  isConnected: boolean;
+  isUnlocked: boolean;
+  initialized: boolean;
+  isPermanentlyDisconnected: boolean;
+}
+
+export class BtcProvider extends EventEmitter {
+  _selectedAddress: string | null = null;
+  _isConnected = false;
+  _initialized = false;
+  _isUnlocked = false;
+  rdns = "";
+  name = "";
+  chainId = "BITCOIN_MAINNET";
+  sendRequest: (chainType: string, data: any) => void;
+  onResponse: any;
+
+  _state: StateProvider = {
+    accounts: null,
+    isConnected: false,
+    isUnlocked: false,
+    initialized: false,
+    isPermanentlyDisconnected: false,
+  };
+
+  private _requestPromise = new ReadyPromise(0);
+
+  constructor(productInfo: IProductInfo, { sendRequest, onResponse }: IConnectors) {
+    super();
+    this.name = productInfo.name;
+    this.rdns = productInfo.rdns;
+    this._handleAccountsChanged = this._handleAccountsChanged.bind(this);
+    this.setMaxListeners(100);
+    this.sendRequest = sendRequest;
+    this.onResponse = onResponse;
+    this.initialize();
+  }
+
+  initialize = async () => {
+    // dapp tab switch send data;
+    document.addEventListener("visibilitychange", async () => {
+      if (document.visibilityState === "visible") {
+        this._request({
+          method: "wallet_sendDomainMetadata",
+          params: await getDappInfo(),
+        });
+      }
+    });
+
+    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._state.initialized = true;
+    this._state.isConnected = true;
+
+    this.keepAlive();
+  };
+
+  subscribeWalletEventsCallback = ({ method, data }: { method: string; data: any }) => {
+    if (method === "accountsChanged") {
+      const addresses = data?.[chainType] || [];
+      // addresses = addresses.filter((item) => item.subType === "default");
+      const accounts = addresses.map(({ address }: { address: string }) => address);
+      this._handleAccountsChanged(accounts);
+    }
+    if (method === "chainChanged") {
+      const { chainId, type }: { chainId: string; type: string } = data;
+      if (type.indexOf(`${chainType}:`) === 0) {
+        this._handleChainChanged({ chainId, isConnected: true });
+      }
+    }
+  };
+
+  /**
+   * Sending a message to the extension to receive will keep the service worker alive.
+   */
+  private keepAlive = () => {
+    this._request({
+      method: "keepAlive",
+      params: {},
+    }).then((v) => {
+      setTimeout(() => {
+        this.keepAlive();
+      }, 1000);
+    });
+  };
+
+  private _handleChainChanged({ chainId, isConnected }: { chainId?: string; isConnected?: boolean } = {}) {
+    if (!chainId || typeof chainId !== "string" || !chainId.startsWith("0x")) {
+      return;
+    }
+
+    if (!isConnected || chainId === this.chainId || !this._state.initialized) {
+      return;
+    }
+
+    this.chainId = chainId;
+    this.emit("chainChanged", this.chainId);
+  }
+
+  private _handleAccountsChanged(accounts: string[]): void {
+    let _accounts = accounts;
+
+    if (!Array.isArray(accounts)) {
+      console.error("BTC: Received invalid accounts parameter.", accounts);
+      _accounts = [];
+    }
+
+    if (this._state.accounts !== _accounts) {
+      this._state.accounts = _accounts;
+      this._selectedAddress = _accounts[0];
+
+      // finally, after all state has been updated, emit the event
+      if (this._state.initialized) {
+        this.emit("accountsChanged", accounts);
+      }
+    }
+  }
+
+  //adapter data by reuqest function
+  _request = async ({ method, params }: { method: string; params?: any }, adapter?: any) => {
+    if (!method) {
+      throw ethErrors.rpc.invalidRequest();
+    }
+
+    //api call -> ("0: dapp -> injector -> content");
+    const dappInfo = await getDappInfo();
+    this.sendRequest(chainType, { method, params, dappInfo });
+
+    const connectFuns: Record<string, boolean> = {
+      getAccounts: true,
+      requestAccounts: true,
+    };
+    //check result by method
+    return this.onResponse({ method }).then((res: any) => {
+      const { data } = res || {};
+
+      if (method === "wallet_switchEthereumChain") {
+        this._handleChainChanged({ chainId: data, isConnected: true });
+      }
+      if (method === "connect" && data?.address) {
+        this._handleAccountsChanged([data?.address]);
+      }
+      if (method in connectFuns && connectFuns[method]) {
+        this._handleAccountsChanged(data || []);
+      }
+
+      //maybe need some adaptor for doge api
+      return adapter ? adapter(data) : data;
+    });
+  };
+
+  request = async ({ method, params }: { method: string; params: any }) => {
+    if (!method) {
+      throw ethErrors.rpc.invalidRequest();
+    }
+    return this._request({
+      method,
+      params,
+    });
+  };
+
+  //res = { address, approved, balance, publicKey }
+  connect = async () => {
+    return this._request({
+      method: "connect",
+    });
+  };
+
+  //res = { disconnected }
+  disconnect = async () => {
+    return this._request({
+      method: "disconnect",
+    });
+  };
+
+  //unisat public methods
+  requestAccounts = async (): Promise<string[]> => {
+    return this._request({
+      method: "requestAccounts",
+    });
+  };
+
+  getAccounts = async (): Promise<string[]> => {
+    return this._request({
+      method: "getAccounts",
+    });
+  };
+
+  getPublicKey = async () => {
+    return this._request({
+      method: "getPublicKey",
+    });
+  };
+
+  //res = { address, balance }
+  getBalance = async (): Promise<Balance> => {
+    return this._request({
+      method: "getBalance",
+    });
+  };
+
+  //res = {status === 'confirmed', confirmations > 1}
+  getTransactionStatus = async ({ txId }: { txId: string }) => {
+    return this._request({
+      method: "getTransactionStatus",
+      params: { txId },
+    });
+  };
+
+  signMessage = async (text: string, type?: "ecdsa" | "bip322-simple"): Promise<string> => {
+    return this._request({
+      method: "signMessage",
+      params: {
+        text,
+        type,
+      },
+    });
+  };
+
+  getNetwork = async () => {
+    return this._request({
+      method: "getNetwork",
+    });
+  };
+
+  switchNetwork = async (network: Network) => {
+    return this._request({
+      method: "switchNetwork",
+      params: {
+        network,
+      },
+    });
+  };
+
+  getChain = async () => {
+    return this._request({
+      method: "getChain",
+    });
+  };
+
+  switchChain = async (chainId: ChainId) => {
+    return this._request({
+      method: "switchChain",
+      params: {
+        chainId,
+      },
+    });
+  };
+
+  signPsbt = async (psbtHex: string, options?: any): Promise<string> => {
+    return this._request({
+      method: "signPsbt",
+      params: {
+        psbtHex,
+        options: {
+          autoFinalized: options?.autoFinalized,
+        },
+      },
+    });
+  };
+
+  signPsbts = async (psbtHexs: string[], options?: any[]): Promise<string[]> => {
+    return this._request({
+      method: "signPsbts",
+      params: {
+        psbtHexs,
+        options,
+      },
+    });
+  };
+
+  pushPsbt = async (psbtHex: string): Promise<string> => {
+    return this._request({
+      method: "pushPsbt",
+      params: {
+        psbtHex,
+      },
+    });
+  };
+
+  sendBitcoin = async (toAddress: string, satoshis?: number, options?: { feeRate: number }): Promise<string> => {
+    return this._request({
+      method: "sendBitcoin",
+      params: {
+        to: toAddress,
+        amount: satoshis,
+        feeRate: options?.feeRate,
+      },
+    });
+  };
+
+  signTx = async (rawtx: string) => {
+    return this._request({
+      method: "signTx",
+      params: {
+        rawtx,
+      },
+    });
+  };
+
+  pushTx = async (rawtx: string): Promise<string> => {
+    return this._request({
+      method: "pushTx",
+      params: {
+        rawtx,
+      },
+    });
+  };
+}