@tomo-inc/chains-service 0.0.2

package/src/solana/service.ts

@@ -0,0 +1,312 @@
+import { ChainTypes, SupportedChainTypes, TomoApiDomains } from "@tomo-inc/wallet-utils";
+
+import { BaseService } from "../base/service";
+
+import { BaseConfig, MSG_PREFIX } from "./config";
+import { createLegacyTx, createTokenLegacyTransaction2, txToHex } from "./utils";
+
+import { IaccountInfo, QueryGasParams, QueryGasResponse, TomoAppInfo, TransactionParams } from "../types";
+import { QueryRentParams, SolanaRentInfo } from "./types";
+
+import { getAssociatedTokenAddress } from "@solana/spl-token";
+import { Connection, PublicKey, VersionedTransaction, sendAndConfirmRawTransaction } from "@solana/web3.js";
+import { BigNumber } from "bignumber.js";
+import { formatUnits, parseUnits, toHex } from "viem";
+import * as base from "../dogecoin/base";
+
+export class SolanaService extends BaseService {
+  private static instance: SolanaService;
+  public chainType: ChainTypes | "";
+  public rpcUrl: string;
+  private connection: Connection;
+
+  public constructor(chainType: ChainTypes, accountInfo: IaccountInfo, tomoAppInfo: TomoAppInfo) {
+    super(tomoAppInfo, accountInfo);
+    this.chainType = chainType;
+    const config: any = {
+      commitment: "confirmed",
+      disableRetryOnRateLimit: false,
+      confirmTransactionInitialTimeout: 120000,
+      fetch: (url: string, options: any) => {
+        return fetch(url, { ...options });
+      },
+    };
+    const domain = TomoApiDomains[tomoAppInfo.tomoStage];
+    const rpcUrl = `${domain}/rpc/v1/solana`;
+
+    this.rpcUrl = rpcUrl;
+    this.connection = new Connection(rpcUrl, config);
+  }
+
+  public static getInstance(chainType: ChainTypes, accountInfo: any, tomoAppInfo: TomoAppInfo) {
+    if (!SolanaService.instance) {
+      SolanaService.instance = new SolanaService(chainType, accountInfo, tomoAppInfo);
+    }
+    return SolanaService.instance;
+  }
+
+  public async getCurrentWalletAccount() {
+    return await this.accountInfo.getCurrent();
+  }
+
+  public async getAccount(): Promise<{ publicKey: string; address: string }> {
+    const { currentAddress, publicKey }: any = await this.accountInfo.getIds();
+    return { publicKey: publicKey || currentAddress, address: currentAddress };
+  }
+
+  public async signMessage(params: any): Promise<{ message: string; signature: string; publicKey: string }> {
+    const { currentAddress, publicKey }: any = await this.accountInfo.getIds();
+
+    const { message } = params;
+    const signature = await this.accountInfo.signMessage(message);
+
+    return {
+      message: MSG_PREFIX + message,
+      signature,
+      publicKey: publicKey || currentAddress,
+    };
+  }
+
+  public async signIn(
+    params: any,
+  ): Promise<{ address: string; publicKey: string; signature: string; signedMessage: string }> {
+    const { currentAddress, publicKey }: any = await this.accountInfo.getIds();
+
+    const { signature = "" } = await this.signMessage(params);
+
+    return {
+      address: currentAddress,
+      publicKey: publicKey || currentAddress,
+      signature,
+      signedMessage: MSG_PREFIX + params.message,
+    };
+  }
+
+  public async request({ method, params }: { method: string; params: any }): Promise<any> {
+    if (!this[method as keyof SolanaService]) {
+      throw new Error(`${method} in request is not supported`);
+    }
+    return this[method as keyof SolanaService](params);
+  }
+
+  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) {
+      const transaction = await createTokenLegacyTransaction2(txData as any, this.connection);
+      callData = "0x" + txToHex(transaction);
+    } else {
+      const transaction = await createLegacyTx(txData as any, this.connection);
+      callData = "0x" + txToHex(transaction);
+    }
+
+    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 solana", txData, message, gasInfo);
+
+      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).times(2);
+    const gasLimitBN = new BigNumber(gasLimit);
+    const calcFee = (feeLevel: string) => {
+      const priorityFee = gasLimitBN
+        .times(gasInfo[feeLevel] || 0)
+        .dividedBy(1000000)
+        .integerValue(BigNumber.ROUND_DOWN); // only integer
+
+      const gasFee = baseFeeBN.plus(priorityFee);
+      return formatUnits(BigInt(gasFee.toNumber()), nativeCurrency?.decimals || 9);
+    };
+
+    return {
+      success: true,
+      fees: {
+        low: calcFee("priorityFeeLow"),
+        medium: calcFee("priorityFeeMedium"),
+        high: calcFee("priorityFeeHigh"),
+      },
+      gasFee: calcFee("priorityFeeHigh"),
+    };
+  }
+
+  public async sendSignedTx(signedTx: string): Promise<string> {
+    let rawTx: Buffer;
+    try {
+      const hexBuffer = Buffer.from(signedTx, "hex");
+      VersionedTransaction.deserialize(hexBuffer);
+      rawTx = hexBuffer;
+    } catch (error) {
+      const base58Buffer = Buffer.from(base.toBase58(signedTx as any));
+      VersionedTransaction.deserialize(base58Buffer);
+      rawTx = base58Buffer;
+    }
+
+    const transaction = VersionedTransaction.deserialize(rawTx);
+    if (!transaction.signatures || transaction.signatures.length === 0) {
+      throw new Error("lack of sign");
+    }
+
+    const confirmationStrategy: any = {
+      commitment: "confirmed",
+      preflightCommitment: "processed",
+      skipPreflight: false,
+      maxRetries: 5,
+    };
+    try {
+      // First simulate the transaction
+      const simulation = await this.connection.simulateTransaction(transaction);
+
+      if (simulation.value.err) {
+        const logs = simulation.value.logs || [];
+        const message = logs[logs.length - 1] || simulation.value.err || "Unknown error occurred";
+        console.error("send err logs:", logs, message);
+
+        // Generic simulation error
+        throw new Error(`Transaction failed: ${message}`);
+      }
+
+      const signature = await sendAndConfirmRawTransaction(this.connection, rawTx, confirmationStrategy);
+      return signature;
+    } catch (error: any) {
+      if (error.message.includes("TransactionExpiredTimeoutError")) {
+        const status = await this.connection.getSignatureStatus(transaction.signatures[0].toString());
+        if (status.value?.confirmationStatus === "confirmed") {
+          return transaction.signatures[0].toString();
+        }
+      }
+      throw error;
+    }
+  }
+
+  public async signTransaction({ rawTransaction }: { rawTransaction: string }): Promise<string> {
+    const params = {
+      rawTransaction,
+      walletId: -1,
+      rpcUrl: this.rpcUrl,
+    };
+    const signature = await this.accountInfo.signTransaction(JSON.stringify(params));
+
+    return signature;
+  }
+
+  public async signAndSendTransaction({ rawTransaction }: { rawTransaction: string }): Promise<string> {
+    const signedTx = await this.signTransaction({ rawTransaction });
+    if (!signedTx) {
+      return "";
+    }
+
+    const signature = await this.sendSignedTx(signedTx);
+    return signature;
+  }
+
+  public async signAllTransactions({ rawTransactions }: { rawTransactions: string[] }) {
+    throw new Error("no support");
+  }
+
+  public async signAndSendAllTransactions({ rawTransactions }: { rawTransactions: string[] }) {
+    throw new Error("no support");
+  }
+
+  public async queryRent(params: QueryRentParams): Promise<SolanaRentInfo> {
+    // Predefined constants for Solana rent calculations
+    const MIN_ACCOUNT_ACTIVATION_SOL = "0.0009"; // Minimum SOL required to activate a new account
+    const SPL_TOKEN_ACCOUNT_CREATION_FEE = "0.001"; // Fee to create SPL token account
+
+    try {
+      const { toAddress, tokenAddress } = params;
+
+      let minTransferAmount = "0";
+      let createSplTokenFee: string | null = null;
+
+      if (tokenAddress) {
+        // SPL Token transfer
+        // Check if recipient has token account
+        const tokenAccountExists = await this.checkTokenAccount(toAddress, tokenAddress);
+
+        if (!tokenAccountExists) {
+          createSplTokenFee = SPL_TOKEN_ACCOUNT_CREATION_FEE; // SPL Token account creation fee
+        }
+      } else {
+        // SOL transfer
+        // Check if recipient account exists
+        const accountExists = await this.checkAccountExists(toAddress);
+
+        if (!accountExists) {
+          // If recipient account doesn't exist, minimum SOL required to activate account
+          minTransferAmount = MIN_ACCOUNT_ACTIVATION_SOL;
+        }
+      }
+
+      const rentInfo: SolanaRentInfo = {
+        minTransferAmount,
+        createSplTokenFee,
+      };
+
+      return rentInfo;
+    } catch (error: any) {
+      console.error("queryRent error:", error);
+
+      // Return default values to ensure transaction is not blocked
+      const defaultRentInfo: SolanaRentInfo = {
+        minTransferAmount: "0",
+        createSplTokenFee: null,
+      };
+
+      return defaultRentInfo;
+    }
+  }
+
+  private async checkAccountExists(address: string): Promise<boolean> {
+    try {
+      const accountInfo = await this.connection.getAccountInfo(new PublicKey(address));
+      return accountInfo !== null;
+    } catch (error) {
+      console.warn("Failed to check account exists:", error);
+      return false; // Conservative estimate, assume account doesn't exist
+    }
+  }
+
+  private async checkTokenAccount(ownerAddress: string, tokenMint: string): Promise<boolean> {
+    try {
+      const owner = new PublicKey(ownerAddress);
+      const mint = new PublicKey(tokenMint);
+
+      const associatedTokenAddress = await getAssociatedTokenAddress(mint, owner);
+      const accountInfo = await this.connection.getAccountInfo(associatedTokenAddress);
+      return accountInfo !== null;
+    } catch (error) {
+      console.warn("Failed to check token account:", error);
+      return false; // Conservative estimate, assume account doesn't exist
+    }
+  }
+}

package/src/solana/types.ts

@@ -0,0 +1,91 @@
+import { Cluster } from "@solana/web3.js";
+import { SubmitParamsType } from "../types";
+
+// solana standard data define.
+
+export type PhantomAPIs = {
+  // connect
+  connect: ({ onlyIfTrusted }: any) => Promise<object>;
+  disconnect: () => Promise<boolean>;
+  getAccount: () => Promise<object>;
+  getBalance: () => Promise<object>;
+  on: (type: "accountChanged" | "balanceChanged", callback: (data: any) => void) => void;
+  signedMessage: ({ message }: any) => Promise<string>;
+};
+
+export type SignInInput = {
+  domain?: string;
+  statement?: string;
+  version?: string;
+  nonce?: string;
+  network?: Cluster;
+  issuedAt?: string;
+  resources?: `https://${string}`[];
+};
+
+export interface SolanaChainInfo {
+  id: Cluster;
+  name: string;
+  rpcUrl: string;
+  explorer: string;
+  symbol: string;
+  decimals: number;
+}
+
+export interface IntentTxData {
+  from?: string;
+  to?: string;
+  amount?: number;
+  tokenAddress?: string;
+  decimals?: number;
+  priorityFee?: number;
+  network?: Cluster;
+  type?: TransactionType;
+  submitType?: SubmitParamsType;
+  chainId?: string;
+}
+
+export type TransactionType = "transfer" | "tokenTransfer" | "mplTransfer";
+export type SolSignParam = {
+  type: TransactionType;
+  payer: string;
+  blockHash: string;
+  from: string;
+  to: string;
+  amount?: number | string;
+  mint?: string;
+  createAssociatedAddress?: boolean;
+  version?: number;
+  tokenStandard?: number;
+  token2022?: boolean;
+  decimal?: number;
+  computeUnitLimit?: number;
+  computeUnitPrice?: number;
+  needPriorityFee?: boolean;
+};
+
+export type TokenInfo = {
+  address: string;
+  icon: string; //`htpps://${string}`;
+  name: string;
+  symbol: string;
+  decimals?: number;
+};
+
+export interface SolanaRentInfo {
+  minTransferAmount: string;
+  createSplTokenFee: string | null;
+}
+
+export interface QueryRentParams {
+  toAddress: string;
+  tokenAddress?: string;
+}
+
+export interface QueryRentResult {
+  success: boolean;
+  method: string;
+  data: {
+    result: SolanaRentInfo;
+  };
+}