@tomo-inc/chains-service 0.0.2

package/src/solana/utils.ts

@@ -0,0 +1,635 @@
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountInstruction,
+  createTransferInstruction,
+  getAccount,
+  getAssociatedTokenAddress,
+  TOKEN_PROGRAM_ID,
+  TokenAccountNotFoundError,
+  TokenInvalidAccountOwnerError,
+} from "@solana/spl-token";
+import {
+  ComputeBudgetProgram,
+  Connection,
+  LAMPORTS_PER_SOL,
+  ParsedAccountData,
+  PublicKey,
+  SystemProgram,
+  Transaction,
+  TransactionMessage,
+  VersionedTransaction,
+} from "@solana/web3.js";
+
+import Bignumber from "bignumber.js";
+import BN from "bn.js";
+
+import { IntentTxData, SolSignParam, TokenInfo } from "./types";
+
+import { CenterSubmitParams, SubmitParamsType } from "../types";
+import { TOKEN_METADATA_PROGRAM_ID } from "./config";
+
+export const TOKEN_METADATA_PROGRAM_PUBLICKEY = new PublicKey(TOKEN_METADATA_PROGRAM_ID);
+
+export function isAddress(address: string): boolean {
+  try {
+    new PublicKey(address);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+export const txToHex = (tx: VersionedTransaction | Transaction) => {
+  if (tx instanceof VersionedTransaction) {
+    return Buffer.from(tx.serialize()).toString("hex");
+  }
+
+  if (tx instanceof Transaction) {
+    return Buffer.from(
+      tx.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false,
+      }),
+    ).toString("hex");
+  }
+  return tx;
+};
+
+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}`);
+  }
+};
+
+export function hexToUint8Array(hexString: string): Uint8Array {
+  const cleanHex = hexString.startsWith("0x") ? hexString.slice(2) : hexString;
+
+  if (cleanHex.length !== 128) {
+    throw new Error("Invalid signature length");
+  }
+
+  const bytes = new Uint8Array(64);
+  for (let i = 0; i < 64; i++) {
+    bytes[i] = parseInt(cleanHex.slice(i * 2, i * 2 + 2), 16);
+  }
+
+  return bytes;
+}
+
+export async function createTransaction(
+  {
+    from = "",
+    to = "",
+    amount = 0,
+    priorityFee = 0, // microLamports (1 SOL = 1e6 microLamports)
+  }: IntentTxData,
+  connection: Connection,
+) {
+  const fromPubkey = new PublicKey(from);
+
+  const instructions = [];
+  if (priorityFee > 0) {
+    instructions.push(
+      ComputeBudgetProgram.setComputeUnitPrice({
+        microLamports: priorityFee,
+      }),
+    );
+  }
+  instructions.push(
+    SystemProgram.transfer({
+      fromPubkey,
+      toPubkey: new PublicKey(to),
+      lamports: amount * LAMPORTS_PER_SOL,
+    }),
+  );
+
+  const blockhash = await connection.getLatestBlockhash().then((res) => res.blockhash);
+
+  // create v0 compatible message
+  const messageV0 = new TransactionMessage({
+    payerKey: fromPubkey,
+    recentBlockhash: blockhash,
+    instructions,
+  }).compileToV0Message();
+
+  // make a versioned transaction
+  const transactionV0 = new VersionedTransaction(messageV0);
+  // return Buffer.from(transactionV0.serialize()).toString('hex');
+
+  return transactionV0;
+}
+
+export async function createLegacyTx({ from = "", to = "", amount = 0 }: IntentTxData, connection: Connection) {
+  const fromPubkey = new PublicKey(from);
+  const toPubkey = new PublicKey(to);
+
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+
+  const transaction = new Transaction().add(
+    SystemProgram.transfer({
+      fromPubkey, //payer
+      toPubkey, //toAccount
+      lamports: amount * LAMPORTS_PER_SOL,
+    }),
+  );
+  transaction.feePayer = fromPubkey;
+  transaction.recentBlockhash = blockhash;
+  transaction.lastValidBlockHeight = lastValidBlockHeight;
+
+  return transaction;
+}
+
+export async function createTokenLegacyTransaction(
+  {
+    from = "",
+    to = "",
+    amount = 0,
+    tokenAddress = "",
+    priorityFee = 0, // microLamports (1 SOL = 1e6 microLamports)
+    decimals = 6,
+  }: IntentTxData,
+  connection: Connection,
+) {
+  try {
+    const fromPubkey = new PublicKey(from);
+    const toPubkey = new PublicKey(to);
+    const tokenPublicKey = new PublicKey(tokenAddress);
+
+    const fromTokenPubKey = await getAssociatedTokenAddress(tokenPublicKey, fromPubkey);
+    const toTokenPubKey = await getAssociatedTokenAddress(tokenPublicKey, toPubkey);
+
+    const transaction = new Transaction();
+
+    try {
+      await getAccount(connection as any, toTokenPubKey);
+    } catch (error: unknown) {
+      if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
+        try {
+          const instruction = createAssociatedTokenAccountInstruction(
+            fromPubkey,
+            toTokenPubKey,
+            toPubkey,
+            tokenPublicKey,
+          );
+          transaction.add(instruction);
+        } catch (err: unknown) {
+          console.error(err);
+        }
+      } else {
+        throw error;
+      }
+    }
+
+    const tokenAmount = new Bignumber(amount).multipliedBy(new Bignumber(10).pow(decimals)).toNumber();
+
+    transaction.add(
+      createTransferInstruction(fromTokenPubKey, toTokenPubKey, fromPubkey, tokenAmount, [], TOKEN_PROGRAM_ID),
+    );
+    const { blockhash } = await connection.getLatestBlockhash("finalized");
+    transaction.feePayer = fromPubkey;
+    transaction.recentBlockhash = blockhash;
+    return transaction;
+  } catch (error) {
+    console.error("Error creating transaction:", error);
+    throw error;
+  }
+}
+
+export async function createTokenLegacyTransaction2(
+  {
+    from = "",
+    to = "",
+    amount = 0,
+    tokenAddress = "",
+    priorityFee = 0, // microLamports (1 SOL = 1e6 microLamports)
+    decimals = 6,
+  }: IntentTxData,
+  connection: Connection,
+) {
+  try {
+    const fromPubkey = new PublicKey(from);
+    const toPubkey = new PublicKey(to);
+    const tokenPublicKey = new PublicKey(tokenAddress);
+
+    const fromTokenPubKey = await getAssociatedTokenAddress(tokenPublicKey, fromPubkey);
+    const toTokenPubKey = await getAssociatedTokenAddress(tokenPublicKey, toPubkey);
+
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    const transaction = new Transaction();
+    transaction.feePayer = fromPubkey;
+    transaction.recentBlockhash = blockhash;
+
+    try {
+      const instruction = createAssociatedTokenAccountInstruction(fromPubkey, toTokenPubKey, toPubkey, tokenPublicKey);
+      transaction.add(instruction);
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+
+    const tokenAmount = new Bignumber(amount).multipliedBy(new Bignumber(10).pow(decimals)).toNumber();
+
+    transaction.add(
+      createTransferInstruction(fromTokenPubKey, toTokenPubKey, fromPubkey, tokenAmount, [], TOKEN_PROGRAM_ID),
+    );
+
+    return transaction;
+  } catch (error) {
+    console.error("Error creating transaction:", error);
+    throw error;
+  }
+}
+
+export async function createOkxTxData(
+  { amount = 0, from = "", to = "", tokenAddress = "", decimals = LAMPORTS_PER_SOL }: IntentTxData,
+  method: "sendSolana" | "sendToken",
+  connection: Connection,
+): Promise<SolSignParam> {
+  const { blockhash: blockHash } = await connection.getLatestBlockhash();
+
+  if (method === "sendSolana") {
+    return {
+      type: "transfer",
+      payer: from,
+      blockHash,
+      from,
+      to,
+      amount: Math.floor(amount * decimals),
+    };
+  }
+
+  const tokenDetail = await getTokenDetailFromRpc(tokenAddress, connection);
+  return {
+    type: "tokenTransfer",
+    payer: from,
+    blockHash,
+    from,
+    to,
+    amount: new Bignumber(amount).multipliedBy(tokenDetail.decimals || 1).toString(),
+    mint: tokenAddress,
+    createAssociatedAddress: false,
+    token2022: false,
+    computeUnitLimit: 140000,
+    computeUnitPrice: 10,
+  };
+}
+
+export async function estimateFees(
+  {
+    txData,
+    priorityFee = 0,
+    computeUnits = 200000,
+  }: {
+    txData: any;
+    priorityFee?: number; // lamports per compute unit
+    computeUnits?: number;
+  },
+  connection: Connection,
+) {
+  const { tokenAddress } = txData;
+  let transaction = null;
+  if (tokenAddress) {
+    transaction = await createTokenLegacyTransaction(txData, connection);
+  } else {
+    transaction = await createLegacyTx(txData, connection);
+  }
+
+  let message = (transaction as any).message;
+  // const rawTransaction = transaction?.serialize();
+  // if (rawTransaction) {
+  //   message = Message.from(rawTransaction);
+  // }
+  if (!message) {
+    message = transaction.compileMessage();
+  }
+  const fee = await connection.getFeeForMessage(message, "confirmed");
+  const baseFee = ((fee.value || 5000) * 2) / LAMPORTS_PER_SOL;
+  const totalPriorityFee = (priorityFee * computeUnits) / 1_000_000; // to lamports
+  return {
+    baseFee: baseFee.toString(),
+    priorityFee: totalPriorityFee,
+    totalFee: (baseFee + totalPriorityFee / LAMPORTS_PER_SOL).toString(),
+  };
+}
+
+export async function getBalances(addresses: string[], connection: Connection) {
+  const balances = await connection.getMultipleAccountsInfo(addresses.map((addr) => new PublicKey(addr)));
+
+  const balancesMap: { [key: string]: number } = {};
+  addresses.map((address, index) => {
+    balancesMap[address] = (balances[index]?.lamports || 0) / LAMPORTS_PER_SOL;
+  });
+
+  return balancesMap;
+}
+
+export async function getTokenBalances(address: string, connection: Connection) {
+  const pubkey = new PublicKey(address);
+
+  const accounts = await connection.getParsedTokenAccountsByOwner(pubkey, {
+    programId: TOKEN_PROGRAM_ID,
+  });
+
+  const balancesMap: { [key: string]: { tokenAddress: string; balance: number; decimals: number } } = {};
+  accounts.value.map((account) => {
+    const parsedData = account.account.data as ParsedAccountData;
+    const info = parsedData.parsed?.info;
+
+    const res = {
+      tokenAddress: info.mint,
+      balance: Number(info.tokenAmount.amount),
+      decimals: info.tokenAmount.decimals || LAMPORTS_PER_SOL,
+    };
+    balancesMap[info.mint] = res;
+    // return res;
+  });
+
+  return balancesMap;
+}
+
+const tokenCache = new Map();
+export const getTokenDetailFromRpc = async (tokenAddress: string, connection: Connection): Promise<TokenInfo> => {
+  try {
+    if (tokenCache.has(tokenAddress)) {
+      return tokenCache.get(tokenAddress);
+    }
+
+    const mint = new PublicKey(tokenAddress);
+    const [metadataPDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from("metadata"), TOKEN_METADATA_PROGRAM_PUBLICKEY.toBuffer(), mint.toBuffer()],
+      TOKEN_METADATA_PROGRAM_PUBLICKEY,
+    );
+
+    const accountInfo = await connection.getAccountInfo(metadataPDA);
+    if (!accountInfo || !accountInfo.data) {
+      return null as unknown as TokenInfo;
+    }
+
+    // Parse metadata directly from buffer
+    const metadata = decodeMetadata(accountInfo.data);
+
+    const tokenInfo = {
+      address: tokenAddress,
+      name: metadata.name,
+      symbol: metadata.symbol,
+      icon: "",
+      uri: metadata.uri,
+      decimals: metadata.decimals,
+    };
+
+    // Fetch token metadata from URI if available
+    //uri = https://gateway.pinata.cloud/ipfs/QmbtPVC8Ki79jKMioSDSY9SSDiNgk4mZA5HHZXeMiPTgmT;
+    if (metadata.uri) {
+      try {
+        const response = await fetch(metadata.uri);
+        const json: any = await response.json();
+        tokenInfo.icon = json.image || "";
+      } catch (e) {
+        console.error("Failed to fetch token metadata:", e);
+      }
+    }
+
+    tokenCache.set(tokenAddress, tokenInfo);
+    return tokenInfo;
+  } catch (e) {
+    console.error("Failed to get token details:", e);
+    return null as unknown as TokenInfo;
+  }
+};
+
+// Helper function to decode metadata from buffer
+export function decodeMetadata(buffer: Buffer) {
+  try {
+    // Key (1 byte) + UpdateAuthority (32 bytes) + Mint (32 bytes) + Data
+    let offset = 1 + 32 + 32;
+
+    const readByte = function () {
+      const value = buffer[offset];
+      offset += 1;
+      return value;
+    };
+
+    const readString = function () {
+      // String length (4 bytes)
+      const length = buffer.readUInt32LE(offset);
+      offset += 4;
+      if (length > 1000) {
+        throw new Error("String too long");
+      }
+      // Read string data
+      const str = buffer.slice(offset, offset + length).toString("utf8");
+      offset += length;
+      return str.replace(/x00/g, "");
+    };
+
+    // Read name, symbol, uri
+    const name = readString();
+    const symbol = readString();
+    const uri = readString();
+
+    // Read seller fee basis points (2 bytes)
+    offset += 2;
+
+    // Read creators array length
+    const creatorLength = readByte();
+    // Skip creators if any
+    if (creatorLength) {
+      offset += creatorLength * (32 + 1 + 1);
+    }
+
+    // Read decimals
+    const decimals = readByte();
+
+    return {
+      name,
+      symbol,
+      uri,
+      decimals,
+    };
+  } catch (e) {
+    console.error("Metadata decode error:", e);
+    return {
+      name: "",
+      symbol: "",
+      uri: "",
+      decimals: 0,
+    };
+  }
+}
+
+/**
+ * Parses a Solana transaction and extracts relevant information.
+ *
+ * @param transaction The Solana transaction to parse.
+ * @returns An object containing the transaction's from address, to address, amount, and mint address (if applicable).
+ */
+
+export async function parseSolTx(
+  transaction: Transaction | VersionedTransaction,
+  connection: Connection,
+): Promise<{
+  from: string;
+  to: string;
+  amount: number;
+  tokenAddress?: string;
+}> {
+  try {
+    const txData = parseSolVersionedTx(transaction as VersionedTransaction);
+    if (txData && txData.from) {
+      return txData;
+    }
+    return null as unknown as { from: string; to: string; amount: number; tokenAddress?: string };
+  } catch (error) {
+    return parseSolLegacyTx(transaction as Transaction, connection);
+  }
+}
+
+export async function parseSolLegacyTx(
+  transaction: Transaction,
+  connection: Connection,
+): Promise<{
+  from: string;
+  to: string;
+  amount: number;
+  tokenAddress?: string;
+}> {
+  let from = "";
+  let to = "";
+  let value = 0;
+  let mintAddress: string | undefined;
+
+  // token 1st
+  for (const instruction of transaction.instructions) {
+    if (instruction.programId.equals(TOKEN_PROGRAM_ID) && instruction.data[0] === 3) {
+      const amountData = instruction.data.slice(1, 9);
+      value = Number(new BN(amountData, "le"));
+
+      // ata accounts
+      const fromTokenAccount = instruction.keys[0]?.pubkey;
+      const toTokenAccount = instruction.keys[1]?.pubkey;
+
+      try {
+        // to account check
+        const toAccount = await getAccount(connection as any, toTokenAccount!);
+        mintAddress = toAccount.mint.toString();
+        to = toAccount.owner.toString(); // to
+      } catch (error) {
+        console.warn("Failed to get token account:", error);
+      }
+
+      //token account
+      if (!from && fromTokenAccount) {
+        try {
+          const fromAccount = await getAccount(connection as any, fromTokenAccount);
+          from = fromAccount.owner.toString();
+        } catch (error) {
+          console.warn("Failed to get source token account:", error);
+        }
+      }
+    }
+  }
+
+  // ata account
+  for (const instruction of transaction.instructions) {
+    if (instruction.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mintKey = instruction.keys[3]?.pubkey;
+      const ownerKey = instruction.keys[2]?.pubkey;
+      if (mintKey && ownerKey) {
+        mintAddress = mintKey.toString();
+        to = ownerKey.toString();
+      }
+    }
+  }
+
+  // sol transfer
+  for (const instruction of transaction.instructions) {
+    if (instruction.programId.equals(SystemProgram.programId) && instruction.data[0] === 2) {
+      const fromPubkey = instruction.keys[0]?.pubkey.toString();
+      const toPubkey = instruction.keys[1]?.pubkey.toString();
+      const lamportsData = instruction.data.slice(4);
+      value = Number(new BN(lamportsData, "le"));
+      from = fromPubkey!;
+      to = toPubkey!;
+    }
+  }
+
+  return { from, to, amount: value, tokenAddress: mintAddress };
+}
+
+const parseSolVersionedTx = (versionedTx: VersionedTransaction): any => {
+  try {
+    const message = TransactionMessage.decompile(versionedTx.message);
+
+    for (const instruction of message.instructions) {
+      const programId = instruction.programId.toString();
+
+      // SPL Token
+      if (programId === TOKEN_PROGRAM_ID.toString()) {
+        // 3 = Transfer instruction
+        // 8 bytes = amount (u64)
+        if (instruction.data[0] === 3) {
+          const amount = instruction.data.slice(1, 9).readBigUInt64LE();
+
+          return {
+            from: instruction.keys[0].pubkey.toString(),
+            to: instruction.keys[1].pubkey.toString(),
+            amount: Number(amount),
+            tokenAddress: instruction.keys[1].pubkey.toString(), // Token mint address
+          };
+        }
+      } else if (
+        programId === "System11111111111111111111111111111111" ||
+        programId === "11111111111111111111111111111111"
+      ) {
+        // Transfer instruction = 2
+        if (instruction.data[0] === 2) {
+          const amount = instruction.data.slice(4).readBigUInt64LE();
+
+          return {
+            from: instruction.keys[0].pubkey.toString(),
+            to: instruction.keys[1].pubkey.toString(),
+            amount: Number(amount) / LAMPORTS_PER_SOL,
+          };
+        }
+      }
+    }
+
+    return {};
+  } catch (error) {
+    console.error("Error parsing transaction:", error);
+    return {};
+  }
+};
+
+export async function buildSubmitTxParams(
+  txData: IntentTxData & { chainIndex: string },
+  callData: string,
+): Promise<CenterSubmitParams> {
+  const { from, to, tokenAddress, chainIndex } = txData;
+  const centerParams: CenterSubmitParams = {
+    type: (txData.submitType as SubmitParamsType) || SubmitParamsType.TRANSFER,
+    userId: "",
+    source: 0,
+    fromAddress: from,
+    fromAmount: txData.amount?.toString() || "",
+    toAddress: to,
+    fromChainIndex: chainIndex,
+    fromTokenAddress: tokenAddress || "",
+    toChainIndex: chainIndex,
+    toTokenAddress: tokenAddress || "",
+    toAmount: txData.amount?.toString() || "",
+    sourceDex: "",
+    estimatedGas: "",
+    failReason: "",
+    tx: "",
+    callData,
+  };
+  return centerParams;
+}

package/src/types/account.ts

@@ -0,0 +1,58 @@
+import { ChainTypes } from "@tomo-inc/wallet-utils";
+
+export interface WalletAccountItem {
+  addresses: object[];
+  path: string;
+  publicKey: string;
+}
+
+export interface AddressItem {
+  address: string;
+  path: string;
+  publicKey: string;
+  subType: string;
+}
+
+// Account Types
+export enum AccountType {
+  EOA = "EOA",
+  SOCIAL = "SOCIAL",
+}
+
+export interface ChainAddress {
+  subType: string;
+  address: string;
+  path: string;
+  publicKey?: string;
+  privateKey?: string;
+}
+
+// Base Account Interface
+export interface IAccount {
+  readonly id: string;
+  readonly userId?: string | number;
+  readonly name: string;
+  readonly type: AccountType;
+  readonly lastUsedTime: number;
+  readonly sortIndex?: number;
+  readonly addresses: Record<ChainTypes, ChainAddress[]>;
+
+  readonly mnemonic: string | null;
+  readonly addressIndex: number;
+
+  readonly isImported: boolean;
+  readonly isBackedUp: boolean;
+  readonly isLocked: boolean; // ?? -> TODO: remove this, use passwordManager instead
+  readonly isFrozen: boolean;
+
+  // External id
+  readonly externalId?: string | number;
+  readonly totalAssets?: string;
+}
+
+export interface IaccountInfo {
+  getCurrent: () => Promise<any[]>;
+  signMessage: (message: string) => Promise<string>;
+  signTypedData: (message: any) => Promise<string>;
+  signTransaction: (transaction: any) => Promise<string>;
+}

package/src/types/dapp.ts

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