@tomo-inc/chains-service 0.0.23 → 0.0.25

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

@@ -0,0 +1,937 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  isAddress,
+  txToHex,
+  hexToTx,
+  hexToUint8Array,
+  createTransaction,
+  createLegacyTx,
+  createTokenLegacyTransaction,
+  createTokenLegacyTransaction2,
+  createOkxTxData,
+  estimateFees,
+  getBalances,
+  getTokenBalances,
+  getTokenDetailFromRpc,
+  decodeMetadata,
+  buildSubmitTxParams,
+  parseSolTx,
+  parseSolLegacyTx,
+} from "../utils";
+import { Connection, Transaction, VersionedTransaction } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } from "@solana/spl-token";
+
+// Mock Solana modules
+vi.mock("@solana/web3.js", async () => {
+  const actual = await vi.importActual("@solana/web3.js");
+
+  class MockConnection {
+    getLatestBlockhash = vi.fn().mockResolvedValue({
+      blockhash: "blockhash123",
+      lastValidBlockHeight: 100,
+    });
+    getMultipleAccountsInfo = vi.fn().mockResolvedValue([{ lamports: 1000000 }]);
+    getParsedTokenAccountsByOwner = vi.fn().mockResolvedValue({
+      value: [
+        {
+          account: {
+            data: {
+              parsed: {
+                info: {
+                  mint: "TokenMint123",
+                  tokenAmount: {
+                    amount: "1000000",
+                    decimals: 6,
+                  },
+                },
+              },
+            },
+          },
+        },
+      ],
+    });
+    getAccountInfo = vi.fn().mockResolvedValue({
+      data: Buffer.from("metadata"),
+    });
+    getFeeForMessage = vi.fn().mockResolvedValue({ value: 5000 });
+    constructor(
+      public rpcUrl: string,
+      public config?: any,
+    ) {}
+  }
+
+  return {
+    ...actual,
+    Connection: MockConnection,
+    PublicKey: class {
+      constructor(public address: string) {
+        if (address === "invalid") {
+          throw new Error("Invalid public key");
+        }
+      }
+      toString() {
+        return this.address;
+      }
+      toBuffer() {
+        return Buffer.alloc(32, 0);
+      }
+      static findProgramAddressSync = vi.fn().mockReturnValue([{ toString: () => "pda123" }]);
+    },
+    Transaction: class {
+      add = vi.fn().mockReturnThis();
+      feePayer: any = null;
+      recentBlockhash: any = null;
+      lastValidBlockHeight: any = null;
+      serialize = vi.fn().mockReturnValue(Buffer.from("serialized"));
+      compileMessage = vi.fn().mockReturnValue({});
+      instructions: any[] = [];
+      static from = vi.fn().mockImplementation((buffer: Buffer) => {
+        // Only throw error for truly invalid buffers (empty or null)
+        // Valid test cases should succeed
+        if (!buffer || buffer.length === 0) {
+          throw new Error("Invalid transaction");
+        }
+        return new (Transaction as any)();
+      });
+    },
+    VersionedTransaction: class {
+      constructor(public message: any) {}
+      serialize = vi.fn().mockReturnValue(Buffer.from("serialized"));
+      static deserialize = vi.fn().mockImplementation((buffer: Buffer) => {
+        // Only throw error for truly invalid buffers (empty or null)
+        // Valid test cases should succeed
+        if (!buffer || buffer.length === 0) {
+          throw new Error("Invalid transaction");
+        }
+        return {
+          message: {
+            instructions: [],
+          },
+          signatures: [],
+        };
+      });
+    },
+    TransactionMessage: class {
+      constructor(public params: any) {}
+      compileToV0Message = vi.fn().mockReturnValue({
+        instructions: [],
+      });
+      static decompile = vi.fn().mockReturnValue({
+        instructions: [],
+      });
+    },
+    SystemProgram: {
+      transfer: vi.fn().mockReturnValue({}),
+      programId: { toString: () => "SystemProgram" },
+    },
+    ComputeBudgetProgram: {
+      setComputeUnitPrice: vi.fn().mockReturnValue({}),
+    },
+    LAMPORTS_PER_SOL: 1000000000,
+  };
+});
+
+// Mock @solana/spl-token
+vi.mock("@solana/spl-token", () => {
+  class TokenAccountNotFoundError extends Error {
+    name = "TokenAccountNotFoundError";
+  }
+  class TokenInvalidAccountOwnerError extends Error {
+    name = "TokenInvalidAccountOwnerError";
+  }
+  return {
+    getAssociatedTokenAddress: vi.fn().mockResolvedValue("tokenAddress123"),
+    getAccount: vi.fn().mockResolvedValue({
+      mint: { toString: () => "TokenMint123" },
+      owner: { toString: () => "Owner123" },
+    }),
+    createTransferInstruction: vi.fn().mockReturnValue({}),
+    createAssociatedTokenAccountInstruction: vi.fn().mockReturnValue({}),
+    TOKEN_PROGRAM_ID: { toString: () => "TokenProgram" },
+    ASSOCIATED_TOKEN_PROGRAM_ID: { toString: () => "AssociatedTokenProgram" },
+    TokenAccountNotFoundError,
+    TokenInvalidAccountOwnerError,
+  };
+});
+
+/** Build a buffer that decodeMetadata can parse (name, symbol, uri, optional creators, decimals). */
+function buildMetadataBuffer(opts: { name: string; symbol: string; uri: string; creatorLength?: number; decimals?: number }) {
+  const { name, symbol, uri, creatorLength = 0, decimals = 6 } = opts;
+  const base = 1 + 32 + 32;
+  const nameBuf = Buffer.from(name, "utf8");
+  const symbolBuf = Buffer.from(symbol, "utf8");
+  const uriBuf = Buffer.from(uri, "utf8");
+  const size = base + 4 + nameBuf.length + 4 + symbolBuf.length + 4 + uriBuf.length + 2 + 1 + creatorLength * 34 + 1;
+  const buffer = Buffer.alloc(Math.max(size, 200));
+  let offset = base;
+  buffer.writeUInt32LE(nameBuf.length, offset);
+  offset += 4;
+  nameBuf.copy(buffer, offset);
+  offset += nameBuf.length;
+  buffer.writeUInt32LE(symbolBuf.length, offset);
+  offset += 4;
+  symbolBuf.copy(buffer, offset);
+  offset += symbolBuf.length;
+  buffer.writeUInt32LE(uriBuf.length, offset);
+  offset += 4;
+  uriBuf.copy(buffer, offset);
+  offset += uriBuf.length;
+  offset += 2; // seller fee
+  buffer[offset] = creatorLength;
+  offset += 1;
+  offset += creatorLength * 34;
+  buffer[offset] = decimals;
+  return buffer;
+}
+
+describe("solana/utils", () => {
+  let mockConnection: Connection;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockConnection = new Connection("https://rpc.example.com");
+  });
+
+  describe("isAddress", () => {
+    it("should return true for valid address", () => {
+      expect(isAddress("11111111111111111111111111111111")).toBe(true);
+    });
+
+    it("should return false for invalid address", () => {
+      expect(isAddress("invalid")).toBe(false);
+    });
+  });
+
+  describe("txToHex", () => {
+    it("should convert VersionedTransaction to hex", () => {
+      const tx = new VersionedTransaction({} as any);
+      const hex = txToHex(tx);
+      expect(hex).toBeDefined();
+    });
+
+    it("should convert Transaction to hex", () => {
+      const tx = new Transaction();
+      const hex = txToHex(tx);
+      expect(hex).toBeDefined();
+    });
+
+    it("should return tx as-is when not VersionedTransaction or Transaction", () => {
+      const other = { custom: true };
+      const result = txToHex(other as any);
+      expect(result).toBe(other);
+    });
+  });
+
+  describe("hexToTx", () => {
+    it("should convert hex to VersionedTransaction", () => {
+      const hex = "01020304";
+      const tx = hexToTx(hex);
+      expect(tx).toBeDefined();
+    });
+
+    it("should throw error for invalid hex", async () => {
+      // Mock VersionedTransaction.deserialize and Transaction.from to throw errors for invalid hex
+      const { VersionedTransaction, Transaction } = await import("@solana/web3.js");
+      vi.mocked(VersionedTransaction.deserialize).mockImplementation((buffer: Buffer) => {
+        // Check if buffer is invalid - "invalid" as hex creates a buffer, but deserialize will fail
+        // We'll simulate this by checking if the hex string would create an invalid transaction
+        // For this test, we'll make it throw for the specific "invalid" case
+        if (!buffer || buffer.length === 0) {
+          throw new Error("Invalid transaction");
+        }
+        // For "invalid" hex string, the buffer will exist but deserialization will fail
+        // We simulate this by checking the buffer content or length
+        // Since "invalid" creates a valid buffer, we need a different approach
+        // Let's make it throw for very short buffers that would be invalid transactions
+        if (buffer.length < 2) {
+          throw new Error("Invalid transaction");
+        }
+        return {
+          message: { instructions: [] },
+          signatures: [],
+        };
+      });
+      vi.mocked(Transaction.from).mockImplementation((buffer: Buffer) => {
+        // Same logic for Transaction.from
+        if (!buffer || buffer.length === 0) {
+          throw new Error("Invalid transaction");
+        }
+        if (buffer.length < 2) {
+          throw new Error("Invalid transaction");
+        }
+        return new Transaction();
+      });
+
+      // For "invalid" hex, Buffer.from("invalid", "hex") creates a buffer
+      // But we want it to fail, so we'll make the mock throw for this specific case
+      // Actually, "invalid" as hex creates a valid buffer of length 3
+      // So we need to make the mock throw for this case
+      vi.mocked(VersionedTransaction.deserialize).mockImplementationOnce((buffer: Buffer) => {
+        throw new Error("Invalid transaction");
+      });
+      vi.mocked(Transaction.from).mockImplementationOnce((buffer: Buffer) => {
+        throw new Error("Invalid transaction");
+      });
+
+      expect(() => hexToTx("invalid")).toThrow("Failed to deserialize transaction");
+    });
+  });
+
+  describe("hexToUint8Array", () => {
+    it("should convert hex to Uint8Array", () => {
+      const hex = "0x" + "00".repeat(64);
+      const array = hexToUint8Array(hex);
+      expect(array.length).toBe(64);
+    });
+
+    it("should handle hex without 0x prefix", () => {
+      const hex = "00".repeat(64);
+      const array = hexToUint8Array(hex);
+      expect(array.length).toBe(64);
+    });
+
+    it("should throw error for invalid length", () => {
+      expect(() => hexToUint8Array("0x1234")).toThrow("Invalid signature length");
+    });
+  });
+
+  describe("createTransaction", () => {
+    it("should create transaction", async () => {
+      const tx = await createTransaction(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 1.0,
+          priorityFee: 1000,
+        },
+        mockConnection,
+      );
+      expect(tx).toBeDefined();
+    });
+
+    it("should create transaction without priority fee", async () => {
+      const tx = await createTransaction(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 1.0,
+        },
+        mockConnection,
+      );
+      expect(tx).toBeDefined();
+    });
+  });
+
+  describe("createLegacyTx", () => {
+    it("should create legacy transaction", async () => {
+      const tx = await createLegacyTx(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 1.0,
+        },
+        mockConnection,
+      );
+      expect(tx).toBeDefined();
+    });
+  });
+
+  describe("createTokenLegacyTransaction", () => {
+    it("should create token transaction when account exists", async () => {
+      const { getAccount } = await import("@solana/spl-token");
+      vi.mocked(getAccount).mockResolvedValue({
+        mint: { toString: () => "TokenMint123" },
+        owner: { toString: () => "Owner123" },
+      } as any);
+
+      const tx = await createTokenLegacyTransaction(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 1.0,
+          tokenAddress: "TokenMint123",
+          decimals: 6,
+        },
+        mockConnection,
+      );
+      expect(tx).toBeDefined();
+    });
+
+    it("should add createAssociatedTokenAccountInstruction when TokenAccountNotFoundError", async () => {
+      const { getAccount, createAssociatedTokenAccountInstruction, TokenAccountNotFoundError } =
+        await import("@solana/spl-token");
+      vi.mocked(getAccount).mockRejectedValue(new TokenAccountNotFoundError());
+
+      const tx = await createTokenLegacyTransaction(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 1.0,
+          tokenAddress: "TokenMint123",
+          decimals: 6,
+        },
+        mockConnection,
+      );
+      expect(tx).toBeDefined();
+      expect(createAssociatedTokenAccountInstruction).toHaveBeenCalled();
+    });
+
+    it("should throw when getAccount throws non-TokenAccountNotFoundError (covers lines 179, 193-194)", async () => {
+      const { getAccount } = await import("@solana/spl-token");
+      vi.mocked(getAccount).mockRejectedValueOnce(new Error("RPC error"));
+
+      await expect(
+        createTokenLegacyTransaction(
+          {
+            from: "11111111111111111111111111111111",
+            to: "22222222222222222222222222222222",
+            amount: 1.0,
+            tokenAddress: "TokenMint123",
+            decimals: 6,
+          },
+          mockConnection,
+        ),
+      ).rejects.toThrow("RPC error");
+    });
+  });
+
+  describe("createTokenLegacyTransaction2", () => {
+    it("should create token legacy transaction", async () => {
+      const { createTokenLegacyTransaction2 } = await import("../utils");
+      const tx = await createTokenLegacyTransaction2(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 1.0,
+          tokenAddress: "TokenMint123",
+          decimals: 6,
+        },
+        mockConnection,
+      );
+      expect(tx).toBeDefined();
+    });
+  });
+
+  describe("createOkxTxData", () => {
+    it("should return sendSolana params", async () => {
+      const { createOkxTxData } = await import("../utils");
+      const result = await createOkxTxData(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 1.0,
+        },
+        "sendSolana",
+        mockConnection,
+      );
+      expect(result.type).toBe("transfer");
+      expect(result.blockHash).toBeDefined();
+    });
+  });
+
+  describe("estimateFees", () => {
+    it("should estimate fees for SOL transfer", async () => {
+      const fees = await estimateFees(
+        {
+          txData: {
+            from: "11111111111111111111111111111111",
+            to: "22222222222222222222222222222222",
+            amount: 1.0,
+          },
+          priorityFee: 1000,
+          computeUnits: 200000,
+        },
+        mockConnection,
+      );
+      expect(fees.baseFee).toBeDefined();
+      expect(fees.priorityFee).toBeDefined();
+      expect(fees.totalFee).toBeDefined();
+    });
+
+    it("should estimate fees for token transfer", async () => {
+      const fees = await estimateFees(
+        {
+          txData: {
+            from: "11111111111111111111111111111111",
+            to: "22222222222222222222222222222222",
+            amount: 1.0,
+            tokenAddress: "TokenMint123",
+          },
+          priorityFee: 1000,
+          computeUnits: 200000,
+        },
+        mockConnection,
+      );
+      expect(fees.baseFee).toBeDefined();
+    });
+  });
+
+  describe("getBalances", () => {
+    it("should get balances", async () => {
+      const balances = await getBalances(["11111111111111111111111111111111"], mockConnection);
+      expect(balances).toBeDefined();
+      expect(balances["11111111111111111111111111111111"]).toBeDefined();
+    });
+  });
+
+  describe("getTokenBalances", () => {
+    it("should get token balances", async () => {
+      const balances = await getTokenBalances("11111111111111111111111111111111", mockConnection);
+      expect(balances).toBeDefined();
+    });
+  });
+
+  describe("getTokenDetailFromRpc", () => {
+    it("should get token detail from RPC", async () => {
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue({ image: "icon.png" }),
+      });
+
+      const tokenInfo = await getTokenDetailFromRpc("TokenMint123", mockConnection);
+      expect(tokenInfo).toBeDefined();
+    });
+
+    it("should return token info with name, symbol, decimals and icon from metadata URI", async () => {
+      const metaBuffer = buildMetadataBuffer({
+        name: "TestToken",
+        symbol: "TST",
+        uri: "https://example.com/meta.json",
+        decimals: 9,
+      });
+      vi.mocked(mockConnection.getAccountInfo).mockResolvedValue({ data: metaBuffer } as any);
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue({ image: "https://example.com/icon.png" }),
+      });
+
+      const tokenInfo = await getTokenDetailFromRpc("MetaTokenMint", mockConnection);
+
+      expect(tokenInfo).toBeDefined();
+      expect(tokenInfo.name).toBe("TestToken");
+      expect(tokenInfo.symbol).toBe("TST");
+      expect(tokenInfo.decimals).toBe(9);
+      expect(tokenInfo.icon).toBe("https://example.com/icon.png");
+    });
+
+    it("should return cached token info on second call (same address)", async () => {
+      const metaBuffer = buildMetadataBuffer({ name: "C", symbol: "C", uri: "" });
+      vi.mocked(mockConnection.getAccountInfo).mockResolvedValue({ data: metaBuffer } as any);
+
+      await getTokenDetailFromRpc("CachedMint", mockConnection);
+      const tokenInfo = await getTokenDetailFromRpc("CachedMint", mockConnection);
+
+      expect(tokenInfo).toBeDefined();
+      expect(tokenInfo.name).toBe("C");
+      expect(mockConnection.getAccountInfo).toHaveBeenCalledTimes(1);
+    });
+
+    it("should set icon to empty when fetch of metadata URI fails", async () => {
+      const metaBuffer = buildMetadataBuffer({
+        name: "F",
+        symbol: "F",
+        uri: "https://example.com/fail",
+      });
+      vi.mocked(mockConnection.getAccountInfo).mockResolvedValue({ data: metaBuffer } as any);
+      global.fetch = vi.fn().mockRejectedValue(new Error("Network error"));
+
+      const tokenInfo = await getTokenDetailFromRpc("FetchFailMint", mockConnection);
+
+      expect(tokenInfo).toBeDefined();
+      expect(tokenInfo.icon).toBe("");
+    });
+
+    it("should return null on error", async () => {
+      const conn = new Connection("https://rpc.example.com");
+      vi.mocked(conn.getAccountInfo).mockResolvedValue(null);
+      const uniqueAddress = "NonexistentTokenMintForNullTest";
+
+      const tokenInfo = await getTokenDetailFromRpc(uniqueAddress, conn);
+      expect(tokenInfo).toBeNull();
+    });
+
+    it("should return null when getTokenDetailFromRpc throws (covers catch 388-389)", async () => {
+      const tokenInfo = await getTokenDetailFromRpc("invalid", mockConnection);
+      expect(tokenInfo).toBeNull();
+    });
+  });
+
+  describe("decodeMetadata", () => {
+    it("should decode metadata from buffer", () => {
+      // Create a mock buffer with metadata structure
+      const buffer = Buffer.alloc(200);
+      let offset = 1 + 32 + 32; // Skip key, updateAuthority, mint
+
+      // Write name length and string
+      buffer.writeUInt32LE(4, offset);
+      offset += 4;
+      buffer.write("Test", offset);
+      offset += 4;
+
+      // Write symbol length and string
+      buffer.writeUInt32LE(3, offset);
+      offset += 4;
+      buffer.write("TST", offset);
+      offset += 3;
+
+      // Write URI length and string
+      buffer.writeUInt32LE(10, offset);
+      offset += 4;
+      buffer.write("https://...", offset);
+      offset += 10;
+
+      // Write seller fee (2 bytes)
+      offset += 2;
+
+      // Write creator length (1 byte)
+      buffer[offset] = 0;
+      offset += 1;
+
+      // Write decimals (1 byte)
+      buffer[offset] = 9;
+
+      const metadata = decodeMetadata(buffer);
+      expect(metadata.name).toBe("Test");
+      expect(metadata.symbol).toBe("TST");
+      expect(metadata.decimals).toBe(9);
+    });
+
+    it("should return default values on error", () => {
+      const buffer = Buffer.alloc(10);
+      const metadata = decodeMetadata(buffer);
+      expect(metadata.name).toBe("");
+      expect(metadata.symbol).toBe("");
+      expect(metadata.uri).toBe("");
+      expect(metadata.decimals).toBe(0);
+    });
+
+    it("should return default when string length > 1000", () => {
+      const buffer = Buffer.alloc(2000);
+      let offset = 1 + 32 + 32;
+      buffer.writeUInt32LE(1500, offset);
+      const metadata = decodeMetadata(buffer);
+      expect(metadata.name).toBe("");
+      expect(metadata.decimals).toBe(0);
+    });
+
+    it("should skip creators when creatorLength > 0", () => {
+      const buffer = buildMetadataBuffer({
+        name: "N",
+        symbol: "S",
+        uri: "",
+        creatorLength: 1,
+        decimals: 8,
+      });
+      const metadata = decodeMetadata(buffer);
+      expect(metadata.name).toBe("N");
+      expect(metadata.symbol).toBe("S");
+      expect(metadata.decimals).toBe(8);
+    });
+  });
+
+  describe("buildSubmitTxParams", () => {
+    it("should build submit tx params", async () => {
+      const params = await buildSubmitTxParams(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 1.0,
+          chainIndex: "100",
+        },
+        "0xcallData",
+      );
+      expect(params.fromAddress).toBe("11111111111111111111111111111111");
+      expect(params.callData).toBe("0xcallData");
+    });
+
+    it("should use submitType when provided", async () => {
+      const { SubmitParamsType } = await import("../../types");
+      const params = await buildSubmitTxParams(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 1.0,
+          chainIndex: "100",
+          submitType: SubmitParamsType.SWAP,
+        },
+        "0xcallData",
+      );
+      expect(params.type).toBe(SubmitParamsType.SWAP);
+    });
+  });
+
+  describe("createTokenLegacyTransaction inner catch", () => {
+    it("should continue when createAssociatedTokenAccountInstruction throws after TokenAccountNotFoundError", async () => {
+      const { getAccount, createAssociatedTokenAccountInstruction, TokenAccountNotFoundError } =
+        await import("@solana/spl-token");
+      vi.mocked(getAccount).mockRejectedValue(new TokenAccountNotFoundError());
+      vi.mocked(createAssociatedTokenAccountInstruction).mockImplementation(() => {
+        throw new Error("create ATA failed");
+      });
+
+      const tx = await createTokenLegacyTransaction(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 1.0,
+          tokenAddress: "TokenMint123",
+          decimals: 6,
+        },
+        mockConnection,
+      );
+      expect(tx).toBeDefined();
+    });
+  });
+
+  describe("createTokenLegacyTransaction2", () => {
+    it("should throw when createAssociatedTokenAccountInstruction throws", async () => {
+      const { createAssociatedTokenAccountInstruction } = await import("@solana/spl-token");
+      vi.mocked(createAssociatedTokenAccountInstruction).mockImplementation(() => {
+        throw new Error("ATA failed");
+      });
+
+      await expect(
+        createTokenLegacyTransaction2(
+          {
+            from: "11111111111111111111111111111111",
+            to: "22222222222222222222222222222222",
+            amount: 1.0,
+            tokenAddress: "TokenMint123",
+            decimals: 6,
+          },
+          mockConnection,
+        ),
+      ).rejects.toThrow("ATA failed");
+    });
+  });
+
+  describe("createOkxTxData sendToken", () => {
+    it("should return tokenTransfer params when method is sendToken", async () => {
+      const metaBuffer = buildMetadataBuffer({ name: "T", symbol: "T", uri: "", decimals: 6 });
+      vi.mocked(mockConnection.getAccountInfo).mockResolvedValue({ data: metaBuffer } as any);
+
+      const result = await createOkxTxData(
+        {
+          from: "11111111111111111111111111111111",
+          to: "22222222222222222222222222222222",
+          amount: 100,
+          tokenAddress: "Mint456",
+        },
+        "sendToken",
+        mockConnection,
+      );
+
+      expect(result.type).toBe("tokenTransfer");
+      expect(result.mint).toBe("Mint456");
+      expect(result.from).toBe("11111111111111111111111111111111");
+      expect(result.to).toBe("22222222222222222222222222222222");
+    });
+  });
+
+  describe("parseSolTx and parseSolLegacyTx", () => {
+    it("should parse legacy transaction with SPL token transfer instruction", async () => {
+      const { getAccount } = await import("@solana/spl-token");
+      const fromAcc = { mint: { toString: () => "Mint1" }, owner: { toString: () => "OwnerFrom" } };
+      const toAcc = { mint: { toString: () => "Mint1" }, owner: { toString: () => "OwnerTo" } };
+      vi.mocked(getAccount)
+        .mockResolvedValueOnce(toAcc as any)
+        .mockResolvedValueOnce(fromAcc as any);
+
+      const fromKey = { pubkey: { toString: () => "OwnerFrom" } };
+      const toKey = { pubkey: { toString: () => "OwnerTo" } };
+      const data = Buffer.alloc(9);
+      data[0] = 3; // Transfer
+      data.writeBigUInt64LE(BigInt(1000), 1);
+
+      const tx = {
+        instructions: [
+          {
+            programId: { equals: (id: any) => id?.toString?.() === TOKEN_PROGRAM_ID?.toString?.() },
+            keys: [fromKey, toKey],
+            data,
+          },
+        ],
+      };
+
+      const result = await parseSolLegacyTx(tx as any, mockConnection);
+      expect(result.from).toBe("OwnerFrom");
+      expect(result.to).toBe("OwnerTo");
+      expect(result.amount).toBe(1000);
+      expect(result.tokenAddress).toBe("Mint1");
+    });
+
+    it("should parse legacy transaction with ATA instruction and system transfer", async () => {
+      const { getAccount } = await import("@solana/spl-token");
+      const { SystemProgram } = await import("@solana/web3.js");
+      vi.mocked(getAccount).mockRejectedValue(new Error("no account"));
+
+      const mintKey = { pubkey: { toString: () => "MintAddr" } };
+      const ownerKey = { pubkey: { toString: () => "OwnerTo" } };
+      const ataInstruction = {
+        programId: {
+          equals: (id: any) => id?.toString?.() === ASSOCIATED_TOKEN_PROGRAM_ID?.toString?.(),
+        },
+        keys: [{}, {}, ownerKey, mintKey],
+        data: Buffer.alloc(0),
+      };
+
+      const sysData = Buffer.alloc(12);
+      sysData[0] = 2; // Transfer
+      sysData.writeBigUInt64LE(BigInt(1e9), 4);
+      const sysInstruction = {
+        programId: {
+          equals: (id: any) => id === SystemProgram.programId || id?.toString?.() === SystemProgram.programId?.toString?.(),
+        },
+        keys: [
+          { pubkey: { toString: () => "FromSys" } },
+          { pubkey: { toString: () => "ToSys" } },
+        ],
+        data: sysData,
+      };
+
+      const tx = {
+        instructions: [ataInstruction, sysInstruction],
+      };
+
+      const result = await parseSolLegacyTx(tx as any, mockConnection);
+      expect(result.tokenAddress).toBe("MintAddr");
+      expect(result.from).toBe("FromSys");
+      expect(result.to).toBe("ToSys");
+      expect(result.amount).toBe(1e9);
+    });
+
+    it("should parse legacy token tx when getAccount fails for toTokenAccount (covers line 510)", async () => {
+      const { getAccount } = await import("@solana/spl-token");
+      vi.mocked(getAccount)
+        .mockRejectedValueOnce(new Error("to account not found"))
+        .mockResolvedValueOnce({ owner: { toString: () => "OwnerFrom" }, mint: {} } as any);
+
+      const fromKey = { pubkey: { toString: () => "OwnerFrom" } };
+      const toKey = { pubkey: { toString: () => "OwnerTo" } };
+      const data = Buffer.alloc(9);
+      data[0] = 3;
+      data.writeBigUInt64LE(BigInt(500), 1);
+
+      const tx = {
+        instructions: [
+          {
+            programId: { equals: (id: any) => id?.toString?.() === TOKEN_PROGRAM_ID?.toString?.() },
+            keys: [fromKey, toKey],
+            data,
+          },
+        ],
+      };
+
+      const result = await parseSolLegacyTx(tx as any, mockConnection);
+      expect(result.amount).toBe(500);
+      expect(result.from).toBe("OwnerFrom");
+    });
+
+    it("should parse legacy token tx when getAccount fails for fromTokenAccount (covers line 519)", async () => {
+      const { getAccount } = await import("@solana/spl-token");
+      vi.mocked(getAccount)
+        .mockResolvedValueOnce({ mint: { toString: () => "Mint1" }, owner: { toString: () => "ToOwner" } } as any)
+        .mockRejectedValueOnce(new Error("from account not found"));
+
+      const fromKey = { pubkey: { toString: () => "FromKey" } };
+      const toKey = { pubkey: { toString: () => "ToKey" } };
+      const data = Buffer.alloc(9);
+      data[0] = 3;
+      data.writeBigUInt64LE(BigInt(100), 1);
+
+      const tx = {
+        instructions: [
+          {
+            programId: { equals: (id: any) => id?.toString?.() === TOKEN_PROGRAM_ID?.toString?.() },
+            keys: [fromKey, toKey],
+            data,
+          },
+        ],
+      };
+
+      const result = await parseSolLegacyTx(tx as any, mockConnection);
+      expect(result.amount).toBe(100);
+      expect(result.to).toBe("ToOwner");
+    });
+  });
+
+  describe("parseSolTx versioned path", () => {
+    it("should return parsed data from versioned tx when decompile yields token transfer", async () => {
+      const { TransactionMessage } = await import("@solana/web3.js");
+      vi.mocked(TransactionMessage.decompile).mockReturnValue({
+        instructions: [
+          {
+            programId: { toString: () => TOKEN_PROGRAM_ID.toString() },
+            keys: [
+              { pubkey: { toString: () => "FromV" } },
+              { pubkey: { toString: () => "ToV" } },
+            ],
+            data: (() => {
+              const b = Buffer.alloc(9);
+              b[0] = 3;
+              b.writeBigUInt64LE(BigInt(2000), 1);
+              return b;
+            })(),
+          },
+        ],
+      } as any);
+
+      const vTx = new VersionedTransaction({} as any);
+      const result = await parseSolTx(vTx, mockConnection);
+
+      expect(result).toBeDefined();
+      expect(result!.from).toBe("FromV");
+      expect(result!.to).toBe("ToV");
+      expect(result!.amount).toBe(2000);
+    });
+
+    it("should return parsed data from versioned tx when decompile yields system transfer", async () => {
+      const { TransactionMessage } = await import("@solana/web3.js");
+      vi.mocked(TransactionMessage.decompile).mockReturnValue({
+        instructions: [
+          {
+            programId: { toString: () => "11111111111111111111111111111111" },
+            keys: [
+              { pubkey: { toString: () => "FromSys" } },
+              { pubkey: { toString: () => "ToSys" } },
+            ],
+            data: (() => {
+              const b = Buffer.alloc(12);
+              b[0] = 2;
+              b.writeBigUInt64LE(BigInt(2 * 1e9), 4);
+              return b;
+            })(),
+          },
+        ],
+      } as any);
+
+      const vTx = new VersionedTransaction({} as any);
+      const result = await parseSolTx(vTx, mockConnection);
+
+      expect(result).toBeDefined();
+      expect(result!.from).toBe("FromSys");
+      expect(result!.to).toBe("ToSys");
+      expect(result!.amount).toBe(2);
+    });
+
+    it("should return null when versioned parse returns no from", async () => {
+      const { TransactionMessage } = await import("@solana/web3.js");
+      vi.mocked(TransactionMessage.decompile).mockReturnValue({ instructions: [] } as any);
+
+      const vTx = new VersionedTransaction({} as any);
+      const result = await parseSolTx(vTx, mockConnection);
+
+      expect(result).toBeNull();
+    });
+
+    it("should return null when versioned decompile throws (parseSolVersionedTx catches and returns {})", async () => {
+      const { TransactionMessage } = await import("@solana/web3.js");
+      vi.mocked(TransactionMessage.decompile).mockImplementation(() => {
+        throw new Error("decompile failed");
+      });
+
+      const vTx = new VersionedTransaction({} as any);
+      const result = await parseSolTx(vTx, mockConnection);
+
+      expect(result).toBeNull();
+    });
+  });
+});