@tomo-inc/inject-providers 0.0.1

package/src/solana/types.ts

@@ -0,0 +1,63 @@
+import { Cluster, VersionedTransaction, Transaction, PublicKey } from "@solana/web3.js";
+
+// solana standard data define.
+
+export interface SignInParams {
+  domain?: string;
+  statement?: string;
+  nonce?: string;
+  chainId?: string;
+  version?: string;
+  issuedAt?: string;
+  resources?: string[];
+}
+
+export interface IPhantomProvider {
+  _isUnlocked: boolean;
+  name: string;
+  icon: string;
+  publicKey: PublicKey | null;
+  chainIds: string[];
+
+  // APIs
+  connect(params?: { onlyIfTrusted: boolean }): Promise<any>;
+  disconnect(): Promise<any>;
+  getAccount(): Promise<any>;
+  signMessage(message: Uint8Array, display: "utf8" | "hex"): Promise<any>;
+  signIn(params?: SignInParams): Promise<any>;
+  signTransaction(tx: VersionedTransaction | Transaction): Promise<any>;
+  signAllTransactions(txs: (VersionedTransaction | Transaction)[]): Promise<any>;
+  signAndSendTransaction(tx: VersionedTransaction | Transaction): Promise<any>;
+  signAndSendAllTransactions(txs: (VersionedTransaction | Transaction)[]): Promise<any>;
+  sendSolana(tx: OriginTransaction): Promise<any>;
+  sendToken(tx: OriginTransaction): Promise<any>;
+}
+
+export type SignInInput = {
+  domain?: string;
+  statement?: string;
+  version?: string;
+  nonce?: string;
+  chainId?: Cluster;
+  issuedAt?: string;
+  resources?: `https://${string}`[];
+};
+
+export interface SolanaChainInfo {
+  id: Cluster;
+  name: string;
+  rpcUrl: string;
+  explorer: string;
+  symbol: string;
+  decimals: number;
+}
+
+export interface OriginTransaction {
+  from: string;
+  to: string;
+  amount: number;
+  tokenAddress?: string;
+  decimals?: number;
+  priorityFee?: number;
+  chainId?: Cluster;
+}

package/src/solana/utils.ts

@@ -0,0 +1,30 @@
+import { Transaction, VersionedTransaction } from "@solana/web3.js";
+
+export const txToHex = (tx: VersionedTransaction | Transaction) => {
+  if (typeof tx === "string") {
+    return tx;
+  }
+  if ((tx as VersionedTransaction)?.message && (tx as VersionedTransaction)?.signatures.length > 0) {
+    return Buffer.from(tx.serialize()).toString("hex");
+  }
+
+  return Buffer.from(
+    tx.serialize({
+      requireAllSignatures: false,
+      verifySignatures: false,
+    }),
+  ).toString("hex");
+};
+
+export const hexToTx = (hexString: string): Transaction | VersionedTransaction => {
+  try {
+    const buffer = Buffer.from(hexString, "hex");
+    try {
+      return VersionedTransaction.deserialize(buffer);
+    } catch (e) {
+      return Transaction.from(buffer);
+    }
+  } catch (error) {
+    throw new Error(`Failed to deserialize transaction: ${error}`);
+  }
+};

package/src/tron/index.ts

@@ -0,0 +1,3 @@
+import { TomoTronProvider } from "./tronLink";
+
+export { TomoTronProvider as TronProvider };

package/src/tron/tronLink.ts

@@ -0,0 +1,341 @@
+import { ethErrors } from "eth-rpc-errors";
+import { EventEmitter } from "events";
+import { TronWeb } from "tronweb";
+import type { Transaction } from "tronweb/lib/esm/types/Transaction";
+
+import { ChainTypes, IConnectors, IProductInfo } from "../types";
+import { ReadyPromise, domReadyCall, getDappInfo } from "../utils/index";
+
+const chainType = ChainTypes.TRON;
+
+interface StateProvider {
+  accounts: any[] | null;
+  isConnected: boolean;
+  isUnlocked: boolean;
+  initialized: boolean;
+  isPermanentlyDisconnected: boolean;
+}
+
+export class TomoTronProvider extends EventEmitter {
+  _isUnlocked = false;
+  name = "";
+  icon = "";
+  ready = false;
+  tronWeb: TronWeb | 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", (res: any) => {
+      this._state.isConnected = true;
+
+      this._initTronWeb(res);
+
+      window.postMessage(
+        {
+          message: {
+            action: "connect",
+            data: res,
+          },
+        },
+        window.location.origin,
+      );
+    });
+
+    this.on("disconnect", (result: any) => {
+      this._state.isConnected = false;
+
+      this.tronWeb = null;
+
+      window.postMessage(
+        {
+          message: {
+            action: "disconnect",
+            data: result,
+          },
+        },
+        window.location.origin,
+      );
+    });
+
+    this.on("accountChanged", (address: any) => {
+      window.postMessage(
+        {
+          message: {
+            action: "accountChanged",
+            data: {
+              address,
+            },
+          },
+        },
+        window.location.origin,
+      );
+    });
+  }
+
+  private _initTronWeb = async (res: any) => {
+    const { fullHost = "https://api.trongrid.io", address } = res || {};
+    this.tronWeb = new TronWeb({
+      fullHost,
+    });
+
+    this.tronWeb.defaultAddress.base58 = address;
+    this.tronWeb.defaultAddress.hex = TronWeb.address.toHex(address);
+
+    (this.tronWeb as any)["request"] = async ({ method, params }: any) => {
+      return await this.request({ method, params });
+    };
+
+    const trx = this.tronWeb.trx;
+    this.tronWeb.trx = new Proxy(trx, {
+      get: (target: any, prop: string) => {
+        switch (prop) {
+          case "sign":
+          case "signMessage":
+            throw new Error("Not supported");
+          case "signMessageV2":
+            return async (message: string, privateKey?: string) => {
+              return await this.signMessage(message);
+            };
+          case "multiSign":
+            return async (transaction: Transaction, privateKey?: string) => {
+              const signedTransaction = await this.signTransaction(transaction);
+              return signedTransaction;
+            };
+          case "sendTransaction":
+            return async (to: string, amount: number) => {
+              const signedTransaction = await this.sendTransaction({ from: address, to, amount });
+              return signedTransaction;
+            };
+          case "sendToken":
+            return async (to: string, amount: number, tokenId: string) => {
+              const signedTransaction = await this.sendToken({ from: address, to, amount, tokenAddress: tokenId });
+              return signedTransaction;
+            };
+          // case "sendRawTransaction":
+          //   return async (transaction: Transaction, privateKey?: string) => {
+          //     const res = await this.sendRawTransaction(transaction);
+          //     return res;
+          //   };
+          default:
+            return Reflect.get(target, prop);
+        }
+      },
+    });
+  };
+
+  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._state.initialized = true;
+  };
+
+  subscribeWalletEventsCallback = ({ method, data }: { method: string; data: any }) => {
+    if (method === "accountsChanged") {
+      const accounts = data?.[chainType];
+      this._handleAccountsChanged(accounts);
+    }
+  };
+
+  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;
+
+      const { address } = _accounts[0] || {};
+
+      // finally, after all state has been updated, emit the event
+      if (this._state.initialized) {
+        this.emit("accountChanged", address);
+      }
+    }
+  }
+
+  _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) => {
+      const { data, method } = res || {};
+      if (method === "tron_requestAccounts") {
+        this.emit("connect", data);
+      }
+      if (responseAdaptor) {
+        return responseAdaptor(data);
+      }
+      return data;
+    });
+  };
+
+  request = async ({ method, params }: { method: string; params: any }, responseAdaptor?: any) => {
+    return this._request(
+      {
+        method,
+        params,
+      },
+      responseAdaptor,
+    );
+  };
+
+  //tronLink api
+  connect = async () => {
+    return this._request(
+      {
+        method: "connect",
+      },
+      (data: any) => {
+        this.emit("connect", data);
+        this.ready = true;
+        return data;
+      },
+    );
+  };
+
+  disconnect = async () => {
+    return this._request(
+      {
+        method: "disconnect",
+      },
+      (data: any) => {
+        this.emit("disconnect", true);
+        this.ready = false;
+        return data;
+      },
+    );
+  };
+
+  signMessage = async (message: string) => {
+    return this._request(
+      {
+        method: "signMessage",
+        params: {
+          message,
+        },
+      },
+      (data: any) => {
+        return data;
+      },
+    );
+  };
+
+  signTransaction = async (transaction: Transaction) => {
+    return this._request(
+      {
+        method: "signTransaction",
+        params: {
+          transaction,
+        },
+      },
+      (data: any) => {
+        return data;
+      },
+    );
+  };
+
+  sendRawTransaction = async (transaction: Transaction) => {
+    return this._request(
+      {
+        method: "sendRawTransaction",
+        params: {
+          transaction,
+        },
+      },
+      (data: any) => {
+        return data;
+      },
+    );
+  };
+
+  sendTransaction = async (params: any) => {
+    return this._request(
+      {
+        method: "sendTransaction",
+        params,
+      },
+      (data: any) => {
+        return data;
+      },
+    );
+  };
+
+  sendToken = async (params: any) => {
+    return this._request(
+      {
+        method: "sendToken",
+        params,
+      },
+      (data: any) => {
+        return data;
+      },
+    );
+  };
+}

package/src/tron/types.ts

@@ -0,0 +1,56 @@
+import type { Transaction, SignedTransaction } from "tronweb/lib/esm/types/Transaction";
+import type { TronLinkWallet } from "@tronweb3/tronwallet-adapter-tronlink"; // Import TronLink wallet class
+
+export interface ITomoTronProvider extends TronLinkWallet {
+  address: string | null;
+  connect(options?: Record<string, unknown>): Promise<void | any>;
+  disconnect(): Promise<void | any>;
+  signMessage(message: string, privateKey?: string): Promise<any>;
+  signTransaction(transaction: Transaction, privateKey?: string): Promise<SignedTransaction>;
+  switchChain?: (chainId: string) => Promise<void>;
+}
+
+export enum SupportedTronRequestMethods {
+  tron_requestAccounts = "tron_requestAccounts",
+}
+
+//https://docs.tronlink.org/tronlink-wallet-extension/request-tronlink-extension/connect-website
+//https://docs.tronlink.org/tronlink-app/deeplink/result-code
+export enum ResponseCode {
+  UNKNOWN_REASON = -1,
+  SUCCESS = 200,
+  REPEAT_REQUEST = 4000,
+  NOT_CONNECTED = 4100,
+  USER_REJECTED = 4001,
+  METHOD_NOT_SUPPORTED = 4200,
+  INVALID_PARAMS = 4300,
+
+  INCORRECT_JSON = 10001,
+  MISSING_ACTION = 10002,
+  UNKNOWN_ACTION = 10003,
+  MISSING_ACTIONID = 10004,
+  INCORRECT_DAPP_URL = 10005,
+  INCORRECT_CALLBACKURL = 10006,
+  EMPTY_DAPP_NAME = 10007,
+  VERSION_NUMBER_NOT_SUPPORTED = 10008,
+  CURRENT_NETWORK_NOT_SUPPORTED = 10009,
+  THE_URL_IS_NOT_SUPPORTED_TO_OPEN_TRONLINK = 10010,
+  UNKNOWN_SIGNTYPE = 10011,
+  INCORRECT_TRANSACTION_FORMAT = 10012,
+  INCORRECT_METHOD_FORMAT = 10013,
+  INCORRECT_MESSAGE_FORMAT = 10014,
+  INCORRECT_TOADDRESS = 10015,
+  NO_WALLET_CREATED_IN_TRONLINK = 10016,
+  INCORRECT_FROMADDRESS = 10017,
+  INCORRECT_CONTACTADDRESS = 10018,
+  INCORRECT_CHAINID = 10019,
+  INCORRECT_AMOUNT = 10020,
+  THE_INITIATING_ADDRESS_DOES_NOT_MATCH_THE_CURRENT_WALLET = 10021,
+  INCORRECT_LOGINADDRESS = 10022,
+  SYSTEM_CONTRACT_NOT_SUPPORT = 10023,
+  INCORRECT_TOKENID = 10024,
+  TOKENID_CONTRACT_ADDRESS_SHOULD_NOT_BE_EXIST_TOGETHER = 10025,
+  TRANSACTION_CANCELED = 300,
+  TRANSACTION_EXECUTED_IN_TRONLINK = 301,
+  BROADCAST_FAILURE = 302,
+}

package/src/types/dapp.ts

@@ -0,0 +1,7 @@
+export interface DappInfo {
+  origin: string;
+  favicon?: string;
+  title?: string;
+  desc?: string;
+  allow?: any;
+}

package/src/types/index.ts

@@ -0,0 +1,34 @@
+export * from "./dapp";
+
+export interface IProductInfo {
+  name: string;
+  rdns: string;
+  icon: string;
+}
+
+export interface IWalletNamespaces {
+  global: string;
+  doge: string;
+  evm: string;
+  solana?: string;
+  tron?: string;
+  btc?: string;
+  shop?: string;
+}
+
+export interface IConnectors {
+  sendRequest: (chainType: string, data: any) => void;
+  onResponse: (data: any) => void;
+}
+
+export enum ChainTypes {
+  BTC = "btc",
+  DOGE = "doge",
+  EVM = "evm",
+  SOL = "sol",
+  SUI = "sui",
+  TON = "ton",
+  TRON = "tron",
+  COSMOS = "cosmos",
+  APTOS = "aptos",
+}

package/src/utils/dapp-info.ts

@@ -0,0 +1,96 @@
+const $ = document.querySelector.bind(document);
+
+export async function getDappInfo() {
+  return {
+    origin: window.top?.location.origin,
+    // host: window.location.hostname,
+    favicon: await getSiteIcon(window),
+    title: getSiteName(window),
+    desc: getSiteDesc(window),
+  };
+}
+
+/**
+ * Extracts a name for the site from the DOM
+ */
+function getSiteName(windowObject: typeof window): string {
+  const { document } = windowObject;
+
+  const siteName: HTMLMetaElement | null = document.querySelector('head > meta[property="og:site_name"]');
+  if (siteName) {
+    return siteName.content;
+  }
+
+  const metaTitle: HTMLMetaElement | null = document.querySelector('head > meta[name="title"]');
+  if (metaTitle) {
+    return metaTitle.content;
+  }
+
+  if (document.title && document.title.length > 0) {
+    return document.title;
+  }
+
+  return window.location.hostname;
+}
+
+function getSiteDesc(windowObject: typeof window): string {
+  const { document } = windowObject;
+
+  const siteName: HTMLMetaElement | null = document.querySelector('head > meta[property="og:description"]');
+  if (siteName) {
+    return siteName.content;
+  }
+  const siteNameX: HTMLMetaElement | null = document.querySelector('head > meta[property="twitter:description"]');
+  if (siteNameX) {
+    return siteNameX.content;
+  }
+
+  const metaTitle: HTMLMetaElement | null = document.querySelector('head > meta[name="description"]');
+  if (metaTitle) {
+    return metaTitle.content;
+  }
+
+  if (document.title && document.title.length > 0) {
+    return document.title;
+  }
+
+  return document.body.innerText.split("\n")[0] || "";
+}
+
+/**
+ * Extracts an icon for the site from the DOM
+ * @returns an icon URL
+ */
+async function getSiteIcon(windowObject: typeof window): Promise<string | null> {
+  const { document } = windowObject;
+
+  const icon =
+    ($('head > link[rel~="icon"]') as HTMLLinkElement)?.href ||
+    ($('head > meta[itemprop="image"]') as HTMLMetaElement)?.content;
+  if (!icon) {
+    return "";
+  }
+  const isOK = await imgExists(icon);
+  if (isOK) {
+    return icon;
+  }
+  return "";
+}
+
+/**
+ * Returns whether the given image URL exists
+ * @param url - the url of the image
+ * @returns Whether the image exists.
+ */
+function imgExists(url: string): Promise<boolean> {
+  return new Promise((resolve, reject) => {
+    try {
+      const img = document.createElement("img");
+      img.onload = () => resolve(true);
+      img.onerror = () => resolve(false);
+      img.src = url;
+    } catch (e) {
+      reject(e);
+    }
+  });
+}

package/src/utils/dom.ts

@@ -0,0 +1,29 @@
+let tryCount = 0;
+const checkLoaded = (callback: () => void) => {
+  tryCount++;
+  if (tryCount > 600) {
+    // some error happen?
+    return;
+  }
+  if (document.readyState === "complete") {
+    callback();
+    return true;
+  } else {
+    setTimeout(() => {
+      checkLoaded(callback);
+    }, 100);
+  }
+};
+export const domReadyCall = (callback: () => void) => {
+  // checkLoaded(callback);
+
+  if (document.readyState === "complete") {
+    callback();
+  } else {
+    const domContentLoadedHandler = (e: Event) => {
+      callback();
+      document.removeEventListener("DOMContentLoaded", domContentLoadedHandler);
+    };
+    document.addEventListener("DOMContentLoaded", domContentLoadedHandler);
+  }
+};

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from "./dapp-info";
+export * from "./dom";
+export * from "./ready-promise";
+export * from "./utils";