@tomo-inc/chains-service 0.0.23 → 0.0.25

package/src/dogecoin/__tests__/utils-extended.test.ts

@@ -0,0 +1,323 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { toSatoshi, toBitcoin, addUsedUtxos, getUsedUtxos, createPsbt, decodePsbt, TransactionParser } from "../utils";
+import * as API from "../rpc";
+import { DogecoinUtils } from "../utils-doge";
+import { Psbt } from "bitcoinjs-lib";
+
+vi.mock("../rpc");
+vi.mock("../utils-doge");
+vi.mock("bitcoinjs-lib");
+
+// Mock cache
+const mockCache = new Map<string, any>();
+vi.mock("@tomo-inc/wallet-utils", async () => {
+  const actual = await vi.importActual("@tomo-inc/wallet-utils");
+  return {
+    ...actual,
+    cache: {
+      get: vi.fn((key: string) => {
+        return mockCache.get(key) || null;
+      }),
+      set: vi.fn((key: string, value: any, isTemp?: boolean) => {
+        mockCache.set(key, value);
+        return true;
+      }),
+    },
+  };
+});
+
+describe("dogecoin/utils Extended Tests", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockCache.clear();
+  });
+
+  describe("toSatoshi", () => {
+    it("should convert bitcoin to satoshi", () => {
+      expect(toSatoshi(1)).toBe(100000000);
+      expect(toSatoshi("1.5")).toBe(150000000);
+    });
+
+    it("should throw error for invalid amount", () => {
+      expect(() => toSatoshi(-1)).toThrow("Invalid amount");
+      expect(() => toSatoshi("invalid")).toThrow("Invalid amount");
+    });
+  });
+
+  describe("toBitcoin", () => {
+    it("should convert satoshi to bitcoin", () => {
+      expect(toBitcoin(100000000)).toBe(1);
+      expect(toBitcoin("150000000")).toBe(1.5);
+    });
+
+    it("should throw error for invalid amount", () => {
+      expect(() => toBitcoin(-1)).toThrow("Invalid Koinu amount");
+      expect(() => toBitcoin("invalid")).toThrow("Invalid Koinu amount");
+    });
+  });
+
+  describe("addUsedUtxos", () => {
+    it("should add used UTXOs to cache", () => {
+      const newUsedUtxos = {
+        txid1: 1,
+        txid2: 1,
+      };
+      addUsedUtxos(newUsedUtxos);
+      const usedUtxos = getUsedUtxos();
+      expect(usedUtxos.txid1).toBe(1);
+      expect(usedUtxos.txid2).toBe(1);
+    });
+  });
+
+  describe("getUsedUtxos", () => {
+    it("should get used UTXOs from cache", () => {
+      const usedUtxos = getUsedUtxos();
+      expect(usedUtxos).toBeDefined();
+    });
+  });
+
+  describe("createPsbt", () => {
+    it("should create PSBT successfully", async () => {
+      const mockUtxos = [
+        {
+          txid: "txid1",
+          vout: 0,
+          outputValue: 101000000, // 1.01 DOGE (enough for 1.0 + 0.001 fee)
+        },
+      ];
+
+      vi.mocked(API.getTxDetail).mockResolvedValue({
+        hex: "hex123",
+      } as any);
+
+      vi.mocked(DogecoinUtils.buildPsbtToBase64).mockReturnValue("psbtBase64");
+
+      const result = await createPsbt({
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 1.0,
+        fee: 0.001,
+        spendableUtxos: mockUtxos,
+      });
+
+      expect(result.psbtBase64).toBe("psbtBase64");
+      expect(result.usingUtxos).toBeDefined();
+    });
+
+    it("should throw error when no spendable UTXOs", async () => {
+      await expect(
+        createPsbt({
+          from: "DAddress123",
+          to: "DAddress456",
+          amount: 1.0,
+          fee: 0.001,
+          spendableUtxos: [],
+        }),
+      ).rejects.toThrow("no spendable utxos");
+    });
+
+    it("should throw error when not enough funds", async () => {
+      const mockUtxos = [
+        {
+          txid: "txid1",
+          vout: 0,
+          outputValue: 1000, // Not enough
+        },
+      ];
+
+      await expect(
+        createPsbt({
+          from: "DAddress123",
+          to: "DAddress456",
+          amount: 1.0,
+          fee: 0.001,
+          spendableUtxos: mockUtxos,
+        }),
+      ).rejects.toThrow("not enough funds");
+    });
+
+    it("should return utxoDetail null when getTxDetail fails for one utxo (covers line 97)", async () => {
+      const mockUtxos = [
+        { txid: "txid1", vout: 0, outputValue: 60000000 },
+        { txid: "txid2", vout: 0, outputValue: 50000000 },
+      ];
+      vi.mocked(API.getTxDetail)
+        .mockResolvedValueOnce({ hex: "hex1" } as any)
+        .mockRejectedValueOnce(new Error("fetch failed"));
+      vi.mocked(DogecoinUtils.buildPsbtToBase64).mockReturnValue("psbtBase64");
+
+      const result = await createPsbt({
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 0.5,
+        fee: 0.001,
+        spendableUtxos: mockUtxos,
+      });
+
+      expect(result.psbtBase64).toBe("psbtBase64");
+    });
+
+    it("should throw when fetched details leave insufficient inputs (covers line 127)", async () => {
+      const mockUtxos = [
+        { txid: "txid1", vout: 0, outputValue: 50000000 },
+        { txid: "txid2", vout: 0, outputValue: 50000000 },
+      ];
+      vi.mocked(API.getTxDetail)
+        .mockRejectedValueOnce(new Error("fetch failed"))
+        .mockResolvedValueOnce({ hex: "hex2" } as any);
+
+      await expect(
+        createPsbt({
+          from: "DAddress123",
+          to: "DAddress456",
+          amount: 1.0,
+          fee: 0.001,
+          spendableUtxos: mockUtxos,
+        }),
+      ).rejects.toThrow("not enough funds to cover amount and fee");
+
+      vi.mocked(API.getTxDetail).mockReset();
+    });
+
+    it("should throw when all getTxDetail fail so no inputs added (covers line 97 and 127)", async () => {
+      const mockUtxos = [
+        { txid: "txid1", vout: 0, outputValue: 60000000 },
+        { txid: "txid2", vout: 0, outputValue: 50000000 },
+      ];
+      vi.mocked(API.getTxDetail).mockRejectedValue(new Error("network error"));
+
+      await expect(
+        createPsbt({
+          from: "DAddress123",
+          to: "DAddress456",
+          amount: 0.5,
+          fee: 0.001,
+          spendableUtxos: mockUtxos,
+        }),
+      ).rejects.toThrow("not enough funds to cover amount and fee");
+    });
+
+    it("should add change output when needed", async () => {
+      const mockUtxos = [
+        {
+          txid: "txid1",
+          vout: 0,
+          outputValue: 200000000, // More than needed
+        },
+      ];
+
+      vi.mocked(API.getTxDetail).mockResolvedValue({
+        hex: "hex123",
+      } as any);
+
+      vi.mocked(DogecoinUtils.buildPsbtToBase64).mockReturnValue("psbtBase64");
+
+      const result = await createPsbt({
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 1.0,
+        fee: 0.001,
+        spendableUtxos: mockUtxos,
+      });
+
+      expect(result).toBeDefined();
+    });
+
+    it("should break when addedAmount >= totalNeeded (covers line 109)", async () => {
+      const mockUtxos = [
+        { txid: "txid1", vout: 0, outputValue: 60000000 },
+        { txid: "txid2", vout: 0, outputValue: 50000000 },
+      ];
+      vi.mocked(API.getTxDetail).mockResolvedValue({ hex: "hex1" } as any);
+      vi.mocked(DogecoinUtils.buildPsbtToBase64).mockReturnValue("psbtBase64");
+
+      const result = await createPsbt({
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 0.5,
+        fee: 0.001,
+        spendableUtxos: mockUtxos,
+      });
+
+      expect(result.psbtBase64).toBe("psbtBase64");
+      expect(API.getTxDetail).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("decodePsbt", () => {
+    it("should decode PSBT from base64", () => {
+      vi.mocked(Psbt.fromHex).mockReturnValue({} as any);
+
+      const psbt = decodePsbt("base64psbt", "base64");
+      expect(psbt).toBeDefined();
+    });
+
+    it("should decode PSBT from hex", () => {
+      vi.mocked(Psbt.fromHex).mockReturnValue({} as any);
+
+      const psbt = decodePsbt("hexpsbt", "hex");
+      expect(psbt).toBeDefined();
+    });
+
+    it("should throw error on decode failure", () => {
+      vi.mocked(Psbt.fromHex).mockImplementation(() => {
+        throw new Error("Invalid PSBT");
+      });
+
+      expect(() => decodePsbt("invalid", "hex")).toThrow("Invalid PSBT");
+    });
+  });
+
+  describe("TransactionParser", () => {
+    it("should create parser instance", () => {
+      const parser = new TransactionParser("rawTx123");
+      expect(parser.rawTx).toBe("rawTx123");
+    });
+
+    describe("hexToText", () => {
+      it("should convert hex to text", () => {
+        const parser = new TransactionParser("");
+        const text = parser.hexToText("48656c6c6f"); // "Hello" in hex
+        expect(text).toBe("Hello");
+      });
+    });
+
+    describe("extractOPReturnData", () => {
+      it("should extract OP_RETURN data", () => {
+        const rawTx = "6f72647b2274797065223a2274657374227d"; // 'ord{"type":"test"}'
+        const parser = new TransactionParser(rawTx);
+        const data = parser.extractOPReturnData();
+        expect(data).toBeDefined();
+      });
+
+      it("should return null when no OP_RETURN data", () => {
+        const parser = new TransactionParser("rawTx123");
+        const data = parser.extractOPReturnData();
+        expect(data).toBeNull();
+      });
+    });
+
+    describe("parseInputs", () => {
+      it("should parse inputs", () => {
+        const rawTx =
+          "01000000" + "01" + "txid1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" + "00000000";
+        const parser = new TransactionParser(rawTx);
+        const inputs = parser.parseInputs();
+        expect(inputs).toBeDefined();
+        expect(inputs.length).toBeGreaterThan(0);
+      });
+    });
+
+    describe("parseScript", () => {
+      it("should parse script", () => {
+        const rawTx =
+          "01000000" + "01" + "txid1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" + "00000000";
+        const parser = new TransactionParser(rawTx);
+        const script = parser.parseScript();
+        expect(script.version).toBeDefined();
+        expect(script.inputCount).toBeDefined();
+        expect(script.inputs).toBeDefined();
+      });
+    });
+  });
+});

package/src/dogecoin/base.ts

@@ -35,5 +35,6 @@ export function fromBase64(base64: string): Uint8Array {
 }
 
 export function toBase58(data: Uint8Array | Buffer | string): string {
+  console.warn("toBase58:", data);
   throw new Error("toBase58 requires bs58 package. Install it: pnpm add bs58");
 }

package/src/dogecoin/config.ts

@@ -1,6 +1,6 @@
 import { ChainTypeEnum, SupportedChainTypes } from "@tomo-inc/wallet-utils";
 
-export const BaseConfig = SupportedChainTypes[ChainTypeEnum.DOGE] as any;
+export const BaseConfig = SupportedChainTypes[ChainTypeEnum.DOGECOIN] as any;
 
 export const BLOCK_CONFIRMATIONS = 1;
 export const FEE_RATE_KB = 0.5;
@@ -18,7 +18,7 @@ export const NETWORK = "livenet";
 export const MYDOGE_BASE_URL = "https://api.mydoge.com";
 export const TX_LINK = "https://chain.so/tx/DOGE/";
 
-export const RPC_URL_TOMO = "https://wallet-pro.tomo.inc/rpc/v1/doge_coin";
+export const RPC_URL_TOMO = "https://wallet-test.tomo.inc/rpc/v1/doge_coin";
 export const RPC_URL = "https://api.bitcore.io/api/DOGE/mainnet";
 export const RPC_TIMEOUT = 20 * 1000;
 

package/src/dogecoin/rpc.ts

@@ -1,6 +1,15 @@
 import axios from "axios";
 
-import { BLOCK_CONFIRMATIONS, FEE_RATE_KB, MYDOGE_BASE_URL, RPC_TIMEOUT, RPC_URL, RPC_URL_TOMO, TRANSACTION_PAGE_SIZE, TX_SIZE } from "./config";
+import {
+  BLOCK_CONFIRMATIONS,
+  FEE_RATE_KB,
+  MYDOGE_BASE_URL,
+  RPC_TIMEOUT,
+  RPC_URL,
+  RPC_URL_TOMO,
+  TRANSACTION_PAGE_SIZE,
+  TX_SIZE,
+} from "./config";
 import { DogeSpendableUtxos } from "./type";
 import { TransactionParser, toBitcoin, toSatoshi } from "./utils";
 

package/src/dogecoin/service.ts

@@ -114,11 +114,7 @@ export class DogecoinService extends BaseService {
       addressList: [txData.from],
     };
 
-    const {
-      data: gasInfo,
-      success,
-      message,
-    }: any = await this.transactions.queryGasInfo({
+    const { data: gasInfo, success }: any = await this.transactions.queryGasInfo({
       chainType: this.chainType,
       params: queryGasParams,
     });
@@ -183,6 +179,10 @@ export class DogecoinService extends BaseService {
     const psbtBase64 = base.toBase64(base.fromHex(psbtHex));
     const signedPsbt = await this.accountInfo.signTransaction(JSON.stringify({ psbtBase64 }));
 
+    if (!options) {
+      console.warn("not support options.");
+    }
+
     if (!signedPsbt) {
       throw new Error("error psbtHex:" + psbtHex);
     }
@@ -192,6 +192,7 @@ export class DogecoinService extends BaseService {
   }
 
   public async signPsbts({ psbtHexs, options }: { psbtHexs: string[]; options?: any }): Promise<string[]> {
+    console.warn("signPsbsts:", psbtHexs, options);
     throw new Error("not implemented");
   }
 
@@ -233,6 +234,9 @@ export class DogecoinService extends BaseService {
     fee: number; //satoshis
     options?: { feeRate: number; memo?: string };
   }): Promise<string> {
+    if (options) {
+      console.warn("not support options");
+    }
     if (fee <= 0) {
       throw new Error("fee is required");
     }

package/src/evm/__tests__/rpc.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi } from "vitest";
+import { getRPCClient, getERC20Contract, decodeErc20Func, createErc20TxData } from "../rpc";
+
+// Mock viem
+vi.mock("viem", async () => {
+  const actual = await vi.importActual("viem");
+  return {
+    ...actual,
+    createPublicClient: vi.fn(() => ({
+      getBalance: vi.fn(),
+      estimateGas: vi.fn(),
+      getTransactionCount: vi.fn(),
+      sendRawTransaction: vi.fn(),
+      getTransaction: vi.fn(),
+    })),
+    http: vi.fn(),
+    getContract: vi.fn(() => ({
+      read: {
+        balanceOf: vi.fn(),
+        decimals: vi.fn(),
+        symbol: vi.fn(),
+      },
+      write: {
+        transfer: vi.fn(),
+      },
+    })),
+    encodeFunctionData: vi.fn(() => "0x1234"),
+    decodeFunctionData: vi.fn(() => ({
+      functionName: "transfer",
+      args: ["0xRecipient", 100n],
+    })),
+  };
+});
+
+describe("evm rpc", () => {
+  describe("getRPCClient", () => {
+    it("should create RPC client with network config", () => {
+      const network = {
+        chainId: 1,
+        name: "Ethereum",
+        rpcUrls: ["https://rpc.ethereum.org"],
+        nativeCurrencyDecimals: 18,
+        nativeCurrencyName: "Ether",
+        nativeCurrencySymbol: "ETH",
+      };
+
+      const result = getRPCClient(network);
+      expect(result).toHaveProperty("rpcClient");
+    });
+
+    it("should handle network with number chainId", () => {
+      const network = {
+        chainId: 56,
+        name: "BSC",
+        rpcUrls: ["https://rpc.bsc.com"],
+        nativeCurrencyDecimals: 18,
+        nativeCurrencyName: "BNB",
+        nativeCurrencySymbol: "BNB",
+      };
+
+      const result = getRPCClient(network);
+      expect(result).toHaveProperty("rpcClient");
+    });
+
+    it("should use chainId as-is when Number(chainId) is 0", () => {
+      const network = {
+        chainId: 0,
+        name: "Local",
+        rpcUrls: ["http://127.0.0.1:8545"],
+        nativeCurrencyDecimals: 18,
+        nativeCurrencyName: "ETH",
+        nativeCurrencySymbol: "ETH",
+      };
+
+      const result = getRPCClient(network);
+      expect(result).toHaveProperty("rpcClient");
+    });
+  });
+
+  describe("getERC20Contract", () => {
+    it("should get ERC20 contract", () => {
+      const mockClient = {} as any;
+      const address = "0x1234567890123456789012345678901234567890" as `0x${string}`;
+
+      const result = getERC20Contract(mockClient, address);
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("decodeErc20Func", () => {
+    it("should decode ERC20 function data", () => {
+      const data =
+        "0xa9059cbb00000000000000000000000012345678901234567890123456789012345678900000000000000000000000000000000000000000000000000000000000000064" as `0x${string}`;
+
+      const result = decodeErc20Func(data);
+      expect(result).toBeDefined();
+      expect(result.functionName).toBe("transfer");
+    });
+  });
+
+  describe("createErc20TxData", () => {
+    it("should create ERC20 transaction data", () => {
+      const params = {
+        to: "0xRecipient1234567890123456789012345678901234" as `0x${string}`,
+        amount: "100",
+      };
+      const token = {
+        address: "0xToken1234567890123456789012345678901234" as `0x${string}`,
+        decimals: 18,
+      };
+
+      const result = createErc20TxData(params, token);
+      expect(result).toHaveProperty("data");
+      expect(result.amount).toBe(0);
+      expect(result.to).toBe(token.address);
+    });
+
+    it("should handle different decimal values", () => {
+      const params = {
+        to: "0xRecipient1234567890123456789012345678901234" as `0x${string}`,
+        amount: "100",
+      };
+      const token = {
+        address: "0xToken1234567890123456789012345678901234" as `0x${string}`,
+        decimals: 6,
+      };
+
+      const result = createErc20TxData(params, token);
+      expect(result).toHaveProperty("data");
+    });
+  });
+});