@tomo-inc/chains-service 0.0.2

package/src/evm/service.ts

@@ -0,0 +1,403 @@
+import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
+import { BigNumber } from "bignumber.js";
+import {
+  createPublicClient,
+  formatUnits,
+  fromHex,
+  http,
+  isHex,
+  parseTransaction,
+  parseUnits,
+  toHex,
+  Transaction,
+} from "viem";
+
+import { BaseService } from "../base/service";
+import { getRPCClient } from "./rpc";
+
+import {
+  QueryGasParams,
+  ITypedData,
+  INetwork,
+  TomoAppInfo,
+  IaccountInfo,
+  TransactionParams,
+  QueryGasResponse,
+} from "../types";
+import { createErc20TxData, getAllTypeChainIds, isEvmChain } from "./utils";
+
+export class EvmService extends BaseService {
+  private static instance: EvmService;
+  public chainType: ChainTypes | "";
+
+  public constructor(chainType: ChainTypes, accountInfo: IaccountInfo, tomoAppInfo: TomoAppInfo) {
+    super(tomoAppInfo, accountInfo);
+    this.chainType = chainType;
+  }
+
+  public static getInstance(chainType: ChainTypes, accountInfo: any, tomoAppInfo: TomoAppInfo) {
+    if (!EvmService.instance) {
+      EvmService.instance = new EvmService(chainType, accountInfo, tomoAppInfo);
+    }
+    return EvmService.instance;
+  }
+
+  public async eth_requestAccounts(): Promise<string[]> {
+    const res = await this.eth_accounts();
+    return res;
+  }
+
+  public async eth_accounts(): Promise<string[]> {
+    const accounts = await this.accountInfo.getCurrent();
+    return accounts.map((account: any) => account.address);
+  }
+
+  public async eth_chainId(): Promise<`0x${string}`> {
+    const chainType = this.chainType;
+
+    const currentNetwork: any = await this.getCurrentChain();
+    const { chainIdHex } = getAllTypeChainIds({
+      chainId: currentNetwork?.chainId,
+      chainType,
+    });
+    return chainIdHex;
+  }
+
+  private async getCurrentChain(): Promise<INetwork> {
+    this.networks.setChainType(this.chainType as ChainTypes);
+    const currentNetwork = await this.networks.getCurrentNetwork();
+    return currentNetwork;
+  }
+
+  public async wallet_switchEthereumChain(networks: any[]): Promise<boolean> {
+    const { chainId } = networks[0];
+    const isSupported = await this.isChainSupported(chainId);
+    if (!isSupported) {
+      throw new Error(`Chain ${chainId} is not supported`);
+    }
+    return await this.networks.setCurrentNetwork(chainId);
+  }
+
+  //evm chains
+  private async isChainSupported(chainId: string): Promise<boolean> {
+    const chainType = this.chainType;
+    const res = getAllTypeChainIds({ chainId, chainType }) as {
+      chainId: string;
+    };
+    if (!res.chainId) {
+      return false;
+    }
+    const chainInfo = await this.networks.getNetworkByChainId(res.chainId);
+    if (!chainInfo) {
+      return false;
+    }
+    return isEvmChain(chainInfo);
+  }
+
+  public async personal_sign([message, address]: [`0x${string}`, `0x${string}`]): Promise<`0x${string}`> {
+    const accounts = await this.accountInfo.getCurrent();
+    if (accounts[0].address !== address) {
+      throw new Error("address is not the current account");
+    }
+    const signature = await this.accountInfo.signMessage(message);
+    return signature;
+  }
+
+  public async eth_signTypedData_v4([address, typedData]: [`0x${string}`, ITypedData]): Promise<`0x${string}`> {
+    const accounts = await this.accountInfo.getCurrent();
+    if (accounts[0].address !== address) {
+      throw new Error("address is not the current account");
+    }
+    const signature = await this.accountInfo.signTypedData(typedData);
+
+    return signature;
+  }
+
+  public async eth_getBalance([address, type]: [`0x${string}`, "latest"]): Promise<string> {
+    const accounts = await this.accountInfo.getCurrent();
+    if (accounts[0].address !== address) {
+      throw new Error("address is not the current account");
+    }
+    if (type !== "latest") {
+      throw new Error("type is not supported");
+    }
+
+    const chainInfo = await this.getCurrentChain();
+    const { rpcClient }: { rpcClient: any } = getRPCClient(chainInfo);
+    try {
+      const balance = await rpcClient.getBalance({ address });
+      return balance?.toString() || "0";
+    } catch (error) {
+      console.error(error);
+      return "0";
+    }
+  }
+
+  public async _queryGasInfo(txData: TransactionParams): Promise<QueryGasResponse> {
+    const { tokenAddress, chainId, amount = 0, decimals = 9 } = txData;
+    const value = tokenAddress ? "0x1" : toHex(parseUnits(amount.toString(), decimals));
+    let callData = "0x";
+    if (tokenAddress) {
+      callData = createErc20TxData(txData, { decimals, address: tokenAddress })?.data;
+    }
+    const gasLimitParam: any = {
+      from: txData.from,
+      to: txData.to,
+      value,
+    };
+    const queryGasParams: QueryGasParams = {
+      chainIndex: Number(chainId),
+      callData,
+      gasLimitParam,
+      addressList: [txData.from],
+    };
+
+    const {
+      data: gasInfo,
+      success,
+      message,
+    }: any = await this.transactions.queryGasInfo({
+      chainType: this.chainType,
+      params: queryGasParams,
+    });
+    if (!success) {
+      console.error("queryGasInfo evm", txData, queryGasParams, message, gasInfo);
+
+      const BaseConfig = SupportedChainTypes[ChainTypes.EVM];
+      const { gasFee } = BaseConfig;
+      return {
+        success: true,
+        gasFee: gasFee.toString(),
+      };
+    }
+
+    const nativeChainId = SupportedChainTypes[this.chainType as ChainTypes].chainId as string;
+    const { nativeCurrency } = await this.networks.getNetworkByChainId(nativeChainId);
+
+    const { baseFee = 1, gasLimit = 0 } = gasInfo;
+
+    const baseFeeBN = new BigNumber(baseFee);
+    const calcFee = (feeLevel: string) => {
+      const fee = baseFeeBN.plus(gasInfo[feeLevel] || 0);
+      const gasFee = fee.times(gasLimit);
+      return formatUnits(BigInt(gasFee.toNumber()), nativeCurrency?.decimals || 9);
+    };
+    return {
+      success,
+      fees: {
+        low: calcFee("priorityFeeLow"),
+        medium: calcFee("priorityFeeMedium"),
+        high: calcFee("priorityFeeHigh"),
+      },
+      gasFee: calcFee("priorityFeeMedium"),
+      baseFee,
+      gasLimit,
+      priorityFee: {
+        low: gasInfo.priorityFeeLow,
+        medium: gasInfo.priorityFeeMedium,
+        high: gasInfo.priorityFeeHigh,
+      },
+    };
+  }
+
+  public async eth_estimateGas(txs: Transaction[]): Promise<`0x${string}`> {
+    const { from, to, value = "0x1" } = txs[0] || {};
+    const accounts = await this.accountInfo.getCurrent();
+    if (accounts[0].address !== from) {
+      throw new Error("address is not the current account");
+    }
+    if (!to) {
+      throw new Error("to is not set");
+    }
+
+    const chainId = txs[0]?.chainId || (await this.eth_chainId());
+    const queryGasParams: QueryGasParams = {
+      chainIndex: Number(chainId),
+      callData: "0x",
+      gasLimitParam: {
+        from,
+        to,
+        value: value as `0x${string}`,
+      },
+      addressList: [from],
+    };
+
+    const chainType = this.chainType as ChainTypes;
+    const {
+      data: gasInfo,
+      success,
+      message,
+    }: any = await this.transactions.queryGasInfo({
+      chainType,
+      params: queryGasParams,
+    });
+    if (!success) {
+      console.error("queryGasInfo evm", txs, message, gasInfo);
+
+      const { gasFee } = SupportedChainTypes[chainType];
+      return gasFee.toString() as `0x${string}`;
+    }
+
+    const res = getAllTypeChainIds({ chainId, chainType });
+    const { nativeCurrencyDecimals }: any = await this.networks.getNetworkByChainId(res.chainId as string);
+
+    const { baseFee = 1, gasLimit = 0 } = gasInfo;
+
+    const baseFeeBN = new BigNumber(baseFee);
+    const calcFee = (feeLevel: "priorityFeeLow" | "priorityFeeMedium" | "priorityFeeHigh") => {
+      const fee = baseFeeBN.plus(gasInfo[feeLevel] || 0);
+      const gasFee = fee.times(gasLimit);
+      return toHex(BigInt(gasFee.toNumber()), nativeCurrencyDecimals);
+    };
+    return calcFee("priorityFeeMedium");
+  }
+
+  private async createPublicClient({ chainId, rpcUrl }: { chainId?: string; rpcUrl?: string }): Promise<any> {
+    if (rpcUrl) {
+      return createPublicClient({
+        transport: http(rpcUrl),
+      });
+    }
+    if (chainId) {
+      this.networks.setChainType(this.chainType as ChainTypes);
+      const chainInfo: any = await this.networks.getNetworkByChainId(chainId);
+      rpcUrl = chainInfo.rpcUrls[0];
+    } else {
+      const chainInfo: any = await this.getCurrentChain();
+      rpcUrl = chainInfo.rpcUrls[0];
+    }
+    if (!rpcUrl) {
+      throw new Error("rpcUrl is not set");
+    }
+    return createPublicClient({
+      transport: http(rpcUrl),
+    });
+  }
+
+  // Get nonce for current account
+  public async eth_getTransactionCount([address, type]: [`0x${string}`, "latest" | "pending"]): Promise<number> {
+    const accounts = await this.accountInfo.getCurrent();
+    if (accounts[0].address !== address) {
+      throw new Error("address is not the current account");
+    }
+    if (type !== "latest" && type !== "pending") {
+      throw new Error("type is not supported");
+    }
+
+    try {
+      const rpcClient = await this.createPublicClient({});
+      const nonce = await rpcClient.getTransactionCount({ address });
+      return nonce;
+    } catch (error) {
+      console.error("Failed to get nonce:", error);
+      throw new Error(`Failed to get nonce: ${error}`);
+    }
+  }
+
+  //https://docs.metamask.io/snaps/reference/keyring-api/chain-methods/#eth_signtransaction
+  public async eth_signTransaction(
+    txParams: {
+      type?: number;
+      from: `0x${string}`;
+      to: `0x${string}`;
+      value: `0x${string}`;
+      data?: `0x${string}`;
+      chainId: `0x${string}`;
+      nonce: `0x${string}`;
+      gasLimit: `0x${string}`;
+      maxFeePerGas?: `0x${string}`;
+      maxPriorityFeePerGas?: `0x${string}`;
+      accessList?: any[];
+    }[],
+  ): Promise<Transaction> {
+    const preparedTxPropsType: any = {
+      chainId: "number",
+      to: "string",
+      value: "bigint",
+      data: "string",
+      nonce: "number",
+      maxPriorityFeePerGas: "bigint",
+      maxFeePerGas: "bigint",
+      gasLimit: "bigint",
+      gas: "bigint",
+    };
+    let txData: any = txParams?.[0];
+    const gas = txData?.gas || txData?.gasLimit;
+    txData = { ...txData, gas, gasLimit: gas };
+    txData.data = txData.data || "0x";
+
+    const accounts = await this.accountInfo.getCurrent();
+    const address = accounts[0].address;
+    if (txData?.from && txData?.from !== address) {
+      console.error("eth_signTransaction error data: from is not the current account", txData);
+      throw new Error(`eth_signTransaction error data: from is not the current account`);
+    }
+    delete txData?.from;
+
+    const preparedTx: any = {
+      type: "eip1559",
+      gas: txData?.gasLimit,
+      account: address,
+    };
+    for (const key in preparedTxPropsType) {
+      if (!txData?.[key] || !isHex(txData?.[key])) {
+        throw new Error(`${key}: no data or wrong type`);
+      }
+      preparedTx[key] = preparedTxPropsType[key] === "number" ? fromHex(txData[key], "number") : txData[key];
+    }
+
+    try {
+      const serializedTransaction = await this.accountInfo.signTransaction(
+        JSON.stringify({
+          data: preparedTx,
+          types: preparedTxPropsType,
+        }),
+      );
+
+      if (serializedTransaction === "") {
+        throw new Error(`eth_signTransaction error data: ${JSON.stringify(txParams)}`);
+      }
+
+      const data = parseTransaction(serializedTransaction as `0x${string}`) as Transaction;
+      // console.log("v, r, s", data, serializedTransaction);
+
+      return data;
+    } catch (err) {
+      throw new Error("eth_signTransaction error" + err);
+    }
+  }
+
+  public async eth_sendRawTransaction(
+    [serializedTransaction]: [`0x${string}`],
+    rpcUrl?: `https://${string}`,
+  ): Promise<`0x${string}`> {
+    try {
+      const rpcClient = await this.createPublicClient({ rpcUrl });
+      const hash = await rpcClient.sendRawTransaction({
+        serializedTransaction,
+      });
+
+      return hash;
+    } catch (error) {
+      console.error("Failed to send transaction via RPC:", error, rpcUrl);
+      throw error;
+    }
+  }
+
+  public async getTransaction(hash: `0x${string}`): Promise<Transaction> {
+    if (!hash || !isHex(hash)) {
+      throw new Error("txId is not valid");
+    }
+    try {
+      const rpcClient = await this.createPublicClient({});
+      const tx: Transaction = await rpcClient.getTransaction({
+        hash,
+      });
+
+      return tx;
+    } catch (error) {
+      console.error("Failed to send transaction via RPC:", error, hash);
+      throw error;
+    }
+  }
+}

package/src/evm/utils.ts

@@ -0,0 +1,92 @@
+import {
+  decodeFunctionData,
+  encodeFunctionData,
+  erc20Abi,
+  formatEther,
+  fromHex,
+  hexToBigInt,
+  isAddressEqual,
+  isHex,
+  parseUnits,
+  toHex,
+} from "viem";
+import { CenterSubmitParams, SubmitParamsType } from "../types";
+
+export const isEvmChain = (network: any) => {
+  return network && network?.platformType === "EVM";
+};
+
+export const isHexChainId = (chainIdHex: string) => {
+  return isHex(chainIdHex);
+};
+
+export const isSameAddress = (addr1: "0x${string}", addr2: "0x${string}") => {
+  return isAddressEqual(addr1, addr2);
+};
+
+export const getAllTypeChainIds = ({ chainId, chainType }: { chainId: string | number; chainType: string }) => {
+  if (isHex(chainId)) {
+    const chainIdHex = chainId;
+    chainId = fromHex(chainId, "number").toString();
+    return {
+      chainId,
+      chainIdHex,
+      chainUid: `${chainType}:${chainId}`,
+    };
+  }
+  const chainIdHex = toHex(Number(chainId));
+  return {
+    chainId,
+    chainIdHex,
+    chainUid: `${chainType}:${chainId}`,
+  };
+};
+
+export const getAmount = (value: `0x${string}`) => {
+  const amount = hexToBigInt(value);
+  return Number(formatEther(amount));
+};
+
+export async function buildSubmitTxParams(params: any): Promise<CenterSubmitParams> {
+  const { txParams, network, tx, serializedTransaction, from, to, tokenAddress } = params;
+  return {
+    type: params.submitType || SubmitParamsType.TRANSFER,
+    userId: "",
+    fromTokenPrice: 0,
+    toTokenPrice: 0,
+    fromAmount: params?.amount?.toString() || "0",
+    toAmount: params?.amount?.toString() || "0",
+    source: "",
+    slippage: 0,
+    fromAddress: from,
+    toAddress: to,
+    fromChainIndex: network.chainIndex?.toString(),
+    fromTokenAddress: tokenAddress,
+    toChainIndex: network.chainIndex?.toString(),
+    toTokenAddress: tokenAddress,
+    sourceDex: "",
+    estimatedGas: txParams.maxFeePerGas || txParams.gasLimit,
+    failReason: "",
+    tx,
+    callData: serializedTransaction,
+  };
+}
+
+export function decodeErc20Func(data: `0x${string}`) {
+  return decodeFunctionData({ data, abi: erc20Abi });
+}
+
+export function createErc20TxData(params: any, token: any) {
+  const { decimals, address: tokenAddress } = token;
+  const value = parseUnits(params?.amount.toString(), decimals);
+  const callData = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "transfer",
+    args: [params.to, value],
+  });
+
+  return {
+    ...params,
+    ...{ amount: 0, data: callData, to: tokenAddress },
+  };
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+import { EvmService } from "./evm/service";
+import { SolanaService } from "./solana/service";
+// import { DogecoinService } from "./dogecoin/service";
+import { ChainTypes } from "@tomo-inc/wallet-utils";
+
+export { EvmService, SolanaService };
+
+export const ChainTypeServices = {
+  [ChainTypes.EVM]: EvmService,
+  [ChainTypes.SOL]: SolanaService,
+  // [ChainTypes.DOGE]: DogecoinService,
+};
+
+export { TomoWallet } from "./wallet";
+
+// export * from "./types";
+// export type * from "./types";
+
+export type {
+  ChainAddress,
+  IAccount,
+  TomoAppInfo,
+  TransactionItem,
+  TransactionsParams,
+  TransactionsResponse
+} from "./types";
+
+export { AccountType, TxTypes } from "./types";

package/src/solana/config.ts

@@ -0,0 +1,5 @@
+import { ChainTypes, SupportedChainTypes } from "@tomo-inc/wallet-utils";
+export const BaseConfig = SupportedChainTypes[ChainTypes.SOL] as any;
+
+export const TOKEN_METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+export const MSG_PREFIX = "\xffsolana offchain";