@tomo-inc/chains-service 0.0.23 → 0.0.25

package/src/evm/service.ts

@@ -203,6 +203,17 @@ export class EvmService extends BaseService {
     };
   }
 
+  public async request(method: string, params: any): Promise<any> {
+    try {
+      const rpcClient = await this.createPublicClient({});
+      const res = await rpcClient.request(method, params);
+      return res;
+    } catch (error) {
+      console.error("Failed to request:", error);
+      throw error;
+    }
+  }
+
   private async createPublicClient({ chainId, rpcUrl }: { chainId?: string; rpcUrl?: string }): Promise<any> {
     if (rpcUrl) {
       return createPublicClient({

package/src/evm/utils.ts

@@ -13,7 +13,7 @@ import {
 import { CenterSubmitParams, SubmitParamsType } from "../types";
 
 export const isEvmChain = (network: any) => {
-  return network && network?.platformType === "EVM";
+  return network?.platformType === "EVM" || false;
 };
 
 export const isHexChainId = (chainIdHex: string) => {
@@ -36,7 +36,7 @@ export const getAllTypeChainIds = ({ chainId, chainType }: { chainId: string | n
   }
   const chainIdHex = toHex(Number(chainId));
   return {
-    chainId,
+    chainId: String(chainId),
     chainIdHex,
     chainUid: `${chainType}:${chainId}`,
   };

package/src/solana/__tests__/service.test.ts

@@ -0,0 +1,425 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { SolanaService } from "../service";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
+import { IAccountInfo, TomoAppInfo } from "../../types";
+
+// Capture Connection constructor config for coverage of custom fetch (line 31)
+let lastConnectionConfig: { fetch?: (url: string, options: any) => Promise<any> } | undefined;
+
+// Mock Solana Connection
+vi.mock("@solana/web3.js", () => {
+  const mockSimulateTransaction = vi.fn().mockResolvedValue({
+    value: { err: null, logs: [] },
+  });
+  const mockSendAndConfirmRawTransaction = vi.fn().mockResolvedValue("signature123");
+  const mockGetSignatureStatus = vi.fn().mockResolvedValue({
+    value: { confirmationStatus: "confirmed" },
+  });
+  const mockGetAccountInfo = vi.fn().mockResolvedValue({ lamports: 1000000 });
+  const mockGetLatestBlockhash = vi.fn().mockResolvedValue({
+    blockhash: "blockhash123",
+    lastValidBlockHeight: 100,
+  });
+
+  class MockConnection {
+    simulateTransaction = mockSimulateTransaction;
+    getAccountInfo = mockGetAccountInfo;
+    getLatestBlockhash = mockGetLatestBlockhash;
+    constructor(
+      public rpcUrl: string,
+      public config?: any,
+    ) {
+      lastConnectionConfig = config;
+    }
+  }
+
+  return {
+    Connection: MockConnection,
+    PublicKey: class {
+      constructor(public address: string) {}
+      toString() {
+        return this.address;
+      }
+    },
+    VersionedTransaction: {
+      deserialize: vi.fn().mockReturnValue({
+        signatures: [{ toString: () => "signature123" }],
+      }),
+    },
+    sendAndConfirmRawTransaction: mockSendAndConfirmRawTransaction,
+  };
+});
+
+// Mock @solana/spl-token
+vi.mock("@solana/spl-token", () => ({
+  getAssociatedTokenAddress: vi.fn().mockResolvedValue("tokenAddress123"),
+}));
+
+// Mock solana utils for _queryGasInfo
+vi.mock("../utils", () => ({
+  createLegacyTx: vi.fn().mockResolvedValue({ serialize: () => Buffer.from("tx") }),
+  createTokenLegacyTransaction2: vi.fn().mockResolvedValue({ serialize: () => Buffer.from("tx") }),
+  txToHex: vi.fn().mockReturnValue("deadbeef"),
+}));
+
+describe("SolanaService", () => {
+  let mockAccountInfo: IAccountInfo;
+  let mockTomoAppInfo: TomoAppInfo;
+  let service: SolanaService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (SolanaService as any).instance = undefined;
+
+    mockAccountInfo = {
+      getCurrent: vi.fn().mockResolvedValue({
+        address: "SolanaAddress123",
+        publicKey: "test-public-key",
+      }),
+      signMessage: vi.fn().mockResolvedValue("signature123"),
+      signTransaction: vi.fn().mockResolvedValue("signedTx123"),
+    } as any;
+
+    mockTomoAppInfo = {
+      tomoStage: "dev",
+      appId: "test-app",
+      appName: "Test App",
+    };
+
+    service = new SolanaService(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+  });
+
+  describe("constructor and getInstance", () => {
+    it("should pass custom fetch in Connection config and cover fetch call (line 31)", async () => {
+      expect(lastConnectionConfig).toBeDefined();
+      expect(lastConnectionConfig!.fetch).toBeDefined();
+      const mockFetch = vi.fn().mockResolvedValue({ ok: true });
+      vi.stubGlobal("fetch", mockFetch);
+      const fetchResult = lastConnectionConfig!.fetch!("https://example.com/rpc", { method: "POST" });
+      expect(fetchResult).toBeDefined();
+      expect(typeof fetchResult.then).toBe("function");
+      await fetchResult;
+      expect(mockFetch).toHaveBeenCalledWith("https://example.com/rpc", { method: "POST" });
+    });
+
+    it("should return same instance from getInstance", () => {
+      const first = SolanaService.getInstance(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+      const second = SolanaService.getInstance(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+      expect(first).toBe(second);
+    });
+  });
+
+  describe("getAccount", () => {
+    it("should get account with publicKey", async () => {
+      const account = await service.getAccount();
+      expect(account.publicKey).toBe("test-public-key");
+      expect(account.address).toBe("SolanaAddress123");
+    });
+
+    it("should use address as publicKey when publicKey is missing", async () => {
+      mockAccountInfo.getCurrent = vi.fn().mockResolvedValue({
+        address: "SolanaAddress123",
+      });
+      const account = await service.getAccount();
+      expect(account.publicKey).toBe("SolanaAddress123");
+    });
+  });
+
+  describe("signMessage", () => {
+    it("should sign message with prefix", async () => {
+      const result = await service.signMessage({ message: "test message" });
+      expect(result.signature).toBe("signature123");
+      expect(result.message).toContain("test message");
+      expect(mockAccountInfo.signMessage).toHaveBeenCalledWith("test message");
+    });
+  });
+
+  describe("signIn", () => {
+    it("should sign in successfully", async () => {
+      const result = await service.signIn({ message: "test message" });
+      expect(result.signature).toBe("signature123");
+      expect(result.address).toBe("SolanaAddress123");
+      expect(result.signedMessage).toContain("test message");
+    });
+  });
+
+  describe("request", () => {
+    it("should call method via request", async () => {
+      const result = await service.request({ method: "getAccount", params: {} });
+      expect(result).toBeDefined();
+    });
+
+    it("should throw error for unsupported method", async () => {
+      await expect(service.request({ method: "unsupportedMethod", params: {} })).rejects.toThrow(
+        "unsupportedMethod in request is not supported",
+      );
+    });
+  });
+
+  describe("signTransaction", () => {
+    it("should sign transaction", async () => {
+      const result = await service.signTransaction({ rawTransaction: "rawTx123" });
+      expect(result).toBe("signedTx123");
+      expect(mockAccountInfo.signTransaction).toHaveBeenCalled();
+    });
+  });
+
+  describe("signAndSendTransaction", () => {
+    it("should sign and send transaction", async () => {
+      const result = await service.signAndSendTransaction({ rawTransaction: "rawTx123" });
+      expect(result).toBe("signature123");
+    });
+
+    it("should return empty string when signedTx is empty", async () => {
+      mockAccountInfo.signTransaction = vi.fn().mockResolvedValue("");
+      const result = await service.signAndSendTransaction({ rawTransaction: "rawTx123" });
+      expect(result).toBe("");
+    });
+  });
+
+  describe("signAllTransactions", () => {
+    it("should throw error", async () => {
+      await expect(service.signAllTransactions({ rawTransactions: [] })).rejects.toThrow("no support");
+    });
+  });
+
+  describe("signAndSendAllTransactions", () => {
+    it("should throw error", async () => {
+      await expect(service.signAndSendAllTransactions({ rawTransactions: [] })).rejects.toThrow("no support");
+    });
+  });
+
+  describe("queryRent", () => {
+    it("should query rent for SOL transfer when account exists", async () => {
+      const { Connection } = await import("@solana/web3.js");
+      const mockConnection = new Connection("https://rpc.example.com");
+      vi.spyOn(mockConnection, "getAccountInfo").mockResolvedValue({ lamports: 1000000 } as any);
+
+      (service as any).connection = mockConnection;
+
+      const result = await service.queryRent({
+        toAddress: "SolanaAddress123",
+      });
+
+      expect(result.minTransferAmount).toBe("0");
+      expect(result.createSplTokenFee).toBeNull();
+    });
+
+    it("should query rent for token transfer when token account exists", async () => {
+      const { Connection } = await import("@solana/web3.js");
+      const mockConnection = new Connection("https://rpc.example.com");
+      vi.spyOn(mockConnection, "getAccountInfo").mockResolvedValue({ lamports: 1000000 } as any);
+
+      (service as any).connection = mockConnection;
+
+      const result = await service.queryRent({
+        toAddress: "SolanaAddress123",
+        tokenAddress: "TokenAddress123",
+      });
+
+      expect(result.minTransferAmount).toBe("0");
+      expect(result.createSplTokenFee).toBeNull();
+    });
+
+    it("should return default values on error", async () => {
+      const { Connection } = await import("@solana/web3.js");
+      const mockConnection = new Connection("https://rpc.example.com");
+      vi.spyOn(mockConnection, "getAccountInfo").mockRejectedValue(new Error("Network error"));
+
+      (service as any).connection = mockConnection;
+
+      const result = await service.queryRent({
+        toAddress: "SolanaAddress123",
+      });
+
+      expect(result.minTransferAmount).toBe("0.0009");
+      expect(result.createSplTokenFee).toBeNull();
+    });
+
+    it("should set createSplTokenFee when token account does not exist", async () => {
+      const { Connection } = await import("@solana/web3.js");
+      const mockConnection = new Connection("https://rpc.example.com");
+      vi.spyOn(mockConnection, "getAccountInfo").mockResolvedValue(null);
+
+      (service as any).connection = mockConnection;
+
+      const result = await service.queryRent({
+        toAddress: "SolanaAddress123",
+        tokenAddress: "TokenMint123",
+      });
+
+      expect(result.createSplTokenFee).toBe("0.001");
+    });
+
+    it("should set createSplTokenFee when getAssociatedTokenAddress throws", async () => {
+      const { getAssociatedTokenAddress } = await import("@solana/spl-token");
+      vi.mocked(getAssociatedTokenAddress).mockRejectedValue(new Error("Network error"));
+
+      const result = await service.queryRent({
+        toAddress: "SolanaAddress123",
+        tokenAddress: "TokenMint123",
+      });
+
+      expect(result.minTransferAmount).toBe("0");
+      expect(result.createSplTokenFee).toBe("0.001");
+    });
+
+    it("should return default rent info in catch when queryRent throws (covers lines 279-287)", async () => {
+      const result = await service.queryRent(null as any);
+      expect(result).toEqual({ minTransferAmount: "0", createSplTokenFee: null });
+    });
+  });
+
+  describe("_queryGasInfo", () => {
+    it("should return gas fees when queryGasInfo succeeds", async () => {
+      (service as any).transactions = {
+        queryGasInfo: vi.fn().mockResolvedValue({
+          success: true,
+          data: {
+            baseFee: 5000,
+            gasLimit: 200000,
+            priorityFeeLow: 100,
+            priorityFeeMedium: 200,
+            priorityFeeHigh: 300,
+          },
+        }),
+      };
+      (service as any).networks = {
+        getNetworkByChainId: vi.fn().mockResolvedValue({ nativeCurrency: { decimals: 9 } }),
+      };
+
+      const result = await service._queryGasInfo({
+        from: "From123",
+        to: "To123",
+        amount: 1,
+        chainId: "1",
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.fees).toBeDefined();
+      expect(result.gasFee).toBeDefined();
+    });
+
+    it("should use tokenAddress and createTokenLegacyTransaction2 when tokenAddress provided", async () => {
+      const { createTokenLegacyTransaction2 } = await import("../utils");
+      (service as any).transactions = {
+        queryGasInfo: vi.fn().mockResolvedValue({
+          success: true,
+          data: {
+            baseFee: 5000,
+            gasLimit: 200000,
+            priorityFeeLow: 100,
+            priorityFeeMedium: 200,
+            priorityFeeHigh: 300,
+          },
+        }),
+      };
+      (service as any).networks = {
+        getNetworkByChainId: vi.fn().mockResolvedValue({ nativeCurrency: { decimals: 9 } }),
+      };
+
+      await service._queryGasInfo({
+        from: "From123",
+        to: "To123",
+        amount: 1,
+        chainId: "1",
+        tokenAddress: "TokenMint123",
+      });
+
+      expect(createTokenLegacyTransaction2).toHaveBeenCalled();
+    });
+
+    it("should return BaseConfig gasFee when queryGasInfo fails", async () => {
+      (service as any).transactions = {
+        queryGasInfo: vi.fn().mockResolvedValue({ success: false, message: "Error" }),
+      };
+
+      const result = await service._queryGasInfo({
+        from: "From123",
+        to: "To123",
+        amount: 1,
+        chainId: "1",
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.gasFee).toBeDefined();
+    });
+  });
+
+  describe("sendSignedTx", () => {
+    it("should send signed transaction successfully", async () => {
+      const result = await service.sendSignedTx("hexTx123");
+      expect(result).toBe("signature123");
+    });
+
+    it("should use base58 when hex deserialize fails", async () => {
+      const { VersionedTransaction } = await import("@solana/web3.js");
+      const base = await import("../../dogecoin/base");
+      vi.mocked(VersionedTransaction.deserialize)
+        .mockImplementationOnce(() => {
+          throw new Error("invalid hex");
+        })
+        .mockImplementationOnce(() => ({
+          signatures: [{ toString: () => "sig123" }],
+        })) as any;
+      vi.spyOn(base, "toBase58").mockReturnValue("base58Encoded" as any);
+
+      const { Connection } = await import("@solana/web3.js");
+      const mockConn = new Connection("https://rpc.example.com");
+      vi.spyOn(mockConn, "simulateTransaction").mockResolvedValue({ value: { err: null } } as any);
+      (mockConn as any).getSignatureStatus = vi.fn().mockResolvedValue({ value: { confirmationStatus: "confirmed" } });
+      const sendAndConfirm = (await import("@solana/web3.js")).sendAndConfirmRawTransaction;
+      vi.mocked(sendAndConfirm).mockResolvedValue("signature123");
+      (service as any).connection = mockConn;
+
+      const result = await service.sendSignedTx("notValidHex");
+      expect(result).toBe("signature123");
+    });
+
+    it("should throw error when transaction lacks signature", async () => {
+      const { VersionedTransaction } = await import("@solana/web3.js");
+      vi.mocked(VersionedTransaction.deserialize).mockReturnValue({
+        signatures: [],
+      } as any);
+
+      await expect(service.sendSignedTx("hexTx123")).rejects.toThrow("lack of sign");
+    });
+
+    it("should handle transaction simulation error", async () => {
+      const { Connection, VersionedTransaction } = await import("@solana/web3.js");
+      const mockConnection = new Connection("https://rpc.example.com");
+
+      vi.mocked(VersionedTransaction.deserialize).mockReturnValue({
+        signatures: [{ toString: () => "signature123" }],
+      } as any);
+
+      vi.spyOn(mockConnection, "simulateTransaction").mockResolvedValue({
+        value: { err: "InsufficientFunds", logs: ["Error log"] },
+      } as any);
+
+      (service as any).connection = mockConnection;
+
+      await expect(service.sendSignedTx("hexTx123")).rejects.toThrow("Transaction failed");
+    });
+
+    it("should return signature when TransactionExpiredTimeoutError but status is confirmed", async () => {
+      const { Connection, VersionedTransaction } = await import("@solana/web3.js");
+      const mockConnection = new Connection("https://rpc.example.com");
+      (mockConnection as any).getSignatureStatus = vi.fn().mockResolvedValue({
+        value: { confirmationStatus: "confirmed" },
+      });
+
+      vi.mocked(VersionedTransaction.deserialize).mockReturnValue({
+        signatures: [{ toString: () => "sig456" }],
+      } as any);
+      vi.spyOn(mockConnection, "simulateTransaction").mockResolvedValue({ value: { err: null } } as any);
+      const sendAndConfirm = (await import("@solana/web3.js")).sendAndConfirmRawTransaction;
+      vi.mocked(sendAndConfirm).mockRejectedValue(new Error("TransactionExpiredTimeoutError"));
+
+      (service as any).connection = mockConnection;
+
+      const result = await service.sendSignedTx("hexTx123");
+      expect(result).toBe("sig456");
+    });
+  });
+});