@tomo-inc/chains-service 0.0.22 → 0.0.24

package/src/dogecoin/__tests__/base.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from "vitest";
+import { fromHex, toHex, toBase64, fromBase64, toBase58 } from "../base";
+
+describe("dogecoin/base", () => {
+  describe("fromHex", () => {
+    it("should convert hex to Uint8Array", () => {
+      const result = fromHex("48656c6c6f");
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(result.length).toBe(5);
+    });
+
+    it("should handle hex with 0x prefix", () => {
+      const result = fromHex("0x48656c6c6f");
+      expect(result.length).toBe(5);
+    });
+
+    it("should pad odd-length hex", () => {
+      const result = fromHex("48656c6c6");
+      expect(result.length).toBe(5);
+    });
+  });
+
+  describe("toHex", () => {
+    it("should convert Uint8Array to hex", () => {
+      const array = new Uint8Array([72, 101, 108, 108, 111]);
+      const hex = toHex(array);
+      expect(hex).toBe("48656c6c6f");
+    });
+
+    it("should convert Buffer to hex", () => {
+      const buffer = Buffer.from("Hello");
+      const hex = toHex(buffer);
+      expect(hex).toBe("48656c6c6f");
+    });
+
+    it("should handle string input", () => {
+      const hex = toHex("0x48656c6c6f");
+      expect(hex).toBe("48656c6c6f");
+    });
+  });
+
+  describe("toBase64", () => {
+    it("should convert Uint8Array to base64", () => {
+      const array = new Uint8Array([72, 101, 108, 108, 111]);
+      const base64 = toBase64(array);
+      expect(base64).toBe("SGVsbG8=");
+    });
+
+    it("should convert hex string to base64", () => {
+      const base64 = toBase64("48656c6c6f");
+      expect(base64).toBe("SGVsbG8=");
+    });
+
+    it("should convert Buffer to base64", () => {
+      const buffer = Buffer.from("Hello");
+      const base64 = toBase64(buffer);
+      expect(base64).toBe("SGVsbG8=");
+    });
+  });
+
+  describe("fromBase64", () => {
+    it("should convert base64 to Uint8Array", () => {
+      const result = fromBase64("SGVsbG8=");
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(result.length).toBe(5);
+    });
+  });
+
+  describe("toBase58", () => {
+    it("should throw with message to install bs58", () => {
+      expect(() => toBase58(new Uint8Array([1, 2, 3]))).toThrow(
+        "toBase58 requires bs58 package. Install it: pnpm add bs58",
+      );
+    });
+  });
+});

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

@@ -0,0 +1,465 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import axios from "axios";
+
+// Mock axios before importing rpc module
+vi.mock("axios", () => ({
+  default: {
+    create: vi.fn(() => ({
+      get: vi.fn(),
+      post: vi.fn(),
+    })),
+  },
+}));
+
+// Import rpc after mocking axios
+import * as rpc from "../rpc";
+
+describe("dogecoin rpc", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Replace methods on the exported mydoge instance
+    if (rpc.mydoge) {
+      rpc.mydoge.get = vi.fn();
+      rpc.mydoge.post = vi.fn();
+    }
+
+    // For api instance (not exported), we need to spy on axios.create calls
+    // But since it's already created, we'll handle it differently in each test
+  });
+
+  describe("getBalance", () => {
+    it("should return balance for valid address", async () => {
+      (rpc.mydoge.get as any).mockResolvedValue({
+        data: {
+          address: "DTest123",
+          balance: 100000000,
+        },
+      });
+
+      const result = await rpc.getBalance("DTest123");
+      expect(result.address).toBe("DTest123");
+      expect(result.balance).toBe(100000000);
+    });
+
+    it("should return empty balance for empty address", async () => {
+      const result = await rpc.getBalance("");
+      expect(result.address).toBe("");
+      expect(result.balance).toBe(0);
+    });
+
+    it("should return empty balance for undefined address", async () => {
+      const result = await rpc.getBalance(undefined as any);
+      expect(result.address).toBe("");
+      expect(result.balance).toBe(0);
+    });
+  });
+
+  describe("getTxDetail", () => {
+    it("should return transaction detail for valid txId", async () => {
+      const mockTxDetail = {
+        txid: "test-tx-id",
+        hex: "01000000",
+        blockHeight: 100,
+        confirmations: 10,
+      };
+      (rpc.mydoge.get as any).mockResolvedValue({ data: mockTxDetail });
+
+      const result = await rpc.getTxDetail("test-tx-id");
+      expect(result.txid).toBe("test-tx-id");
+    });
+
+    it("should return empty object for empty txId", async () => {
+      const result = await rpc.getTxDetail("");
+      expect(result).toEqual({});
+    });
+  });
+
+  describe("getSpendableUtxos", () => {
+    it("should return spendable UTXOs", async () => {
+      const mockUtxos = [
+        { txid: "tx1", vout: 0, satoshis: 100000000 },
+        { txid: "tx2", vout: 1, satoshis: 50000000 },
+      ];
+      (rpc.mydoge.get as any).mockResolvedValue({
+        data: {
+          utxos: mockUtxos,
+          next_cursor: null,
+        },
+      });
+
+      const result = await rpc.getSpendableUtxos("DTest123");
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it("should paginate when next_cursor is present", async () => {
+      const page1 = [{ txid: "tx1", vout: 0, satoshis: 50000000 }];
+      const page2 = [{ txid: "tx2", vout: 1, satoshis: 100000000 }];
+      (rpc.mydoge.get as any)
+        .mockResolvedValueOnce({
+          data: { utxos: page1, next_cursor: 100 },
+        })
+        .mockResolvedValueOnce({
+          data: { utxos: page2, next_cursor: null },
+        });
+
+      const result = await rpc.getSpendableUtxos("DTest123");
+      expect(result.length).toBe(2);
+    });
+  });
+
+  describe("getInscriptionsUtxos", () => {
+    it("should return inscription UTXOs", async () => {
+      const mockUtxos = [{ txid: "tx1", vout: 0, satoshis: 100000000, inscriptions: [] }];
+      (rpc.mydoge.get as any).mockResolvedValue({
+        data: {
+          utxos: mockUtxos,
+          next_cursor: null,
+        },
+      });
+
+      const result = await rpc.getInscriptionsUtxos("DTest123");
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    it("should include inscriptions field when filter is inscriptions", async () => {
+      const mockUtxos = [
+        { txid: "tx1", vout: 0, satoshis: 100000000, script_pubkey: "script", inscriptions: [{ id: "ins1" }] },
+      ];
+      (rpc.mydoge.get as any).mockResolvedValue({
+        data: { utxos: mockUtxos, next_cursor: null },
+      });
+
+      const result = await rpc.getInscriptionsUtxos("DTest123");
+      expect(result[0]).toHaveProperty("inscriptions");
+      expect(result[0].inscriptions).toEqual([{ id: "ins1" }]);
+    });
+  });
+
+  describe("getInscriptionsUtxo", () => {
+    it("should return single inscription utxo for given tx", async () => {
+      const tx = { txid: "tx1", vout: 0 };
+      const mockUtxos = [
+        { txid: "tx1", vout: 0, satoshis: 100000000, script_pubkey: "script", inscriptions: [{ id: "ins1" }] },
+      ];
+      (rpc.mydoge.get as any).mockResolvedValue({
+        data: { utxos: mockUtxos, next_cursor: null },
+      });
+
+      const result = await rpc.getInscriptionsUtxo("DTest123", tx);
+      expect(result).toBeDefined();
+      expect(result.inscriptions).toEqual([{ id: "ins1" }]);
+    });
+  });
+
+  describe("getUnSpentUtxos", () => {
+    it("should return unspent UTXOs and filter by spentTxid", async () => {
+      const mockUtxos = [
+        { txid: "tx1", vout: 0, value: 100000000, spentTxid: null },
+        { txid: "tx2", vout: 1, value: 50000000, spentTxid: "spent-tx" },
+      ];
+      const mockApiInstance = {
+        get: vi.fn().mockResolvedValue({ data: mockUtxos }),
+        post: vi.fn(),
+      };
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() }); // mydoge
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() }); // tomoApi
+      (axios.create as any).mockReturnValueOnce(mockApiInstance); // api
+
+      vi.resetModules();
+      const freshRpc = await import("../rpc");
+      const result = await freshRpc.getUnSpentUtxos("DTest123");
+      expect(result.length).toBe(1);
+      expect(result[0].spentTxid).toBeNull();
+    });
+
+    it("should return empty array when API returns empty data", async () => {
+      const mockApiInstance = {
+        get: vi.fn().mockResolvedValue({ data: [] }),
+        post: vi.fn(),
+      };
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce(mockApiInstance);
+
+      vi.resetModules();
+      const freshRpc = await import("../rpc");
+      const result = await freshRpc.getUnSpentUtxos("DTest123");
+      expect(result).toEqual([]);
+    });
+
+    it("should return empty array on error", async () => {
+      const mockApiInstance = {
+        get: vi.fn().mockRejectedValue(new Error("API Error")),
+        post: vi.fn(),
+      };
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce(mockApiInstance);
+
+      vi.resetModules();
+      const freshRpc = await import("../rpc");
+      const result = await freshRpc.getUnSpentUtxos("DTest123");
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("sendTransaction", () => {
+    it("should send transaction", async () => {
+      (rpc.mydoge.post as any).mockResolvedValue({
+        data: {
+          result: "tx-hash",
+        },
+      });
+
+      const result = await rpc.sendTransaction({
+        signed: "signed-tx-hex",
+        senderAddress: "DTest123",
+      });
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("estimateSmartFee", () => {
+    it("should estimate smart fee", async () => {
+      (rpc.mydoge.post as any).mockResolvedValue({
+        data: {
+          result: {
+            feerate: 0.001,
+          },
+        },
+      });
+
+      const result = await rpc.estimateSmartFee({ senderAddress: "DTest123" });
+      expect(result).toHaveProperty("feePerKB");
+    });
+  });
+
+  describe("getTransactions", () => {
+    it("should get transactions", async () => {
+      const mockTxIds = ["tx1", "tx2"];
+      const mockTxDetail = {
+        txid: "tx1",
+        hex: "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff08044c86041b020602ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52daaf87de6c36dfd4115338ef46e897963355484b448fd40aadcbee1d4047e10ac00000000",
+        blockHeight: 100,
+      };
+      (rpc.mydoge.get as any)
+        .mockResolvedValueOnce({
+          data: {
+            txids: mockTxIds,
+            totalPages: 1,
+            page: 1,
+          },
+        })
+        .mockResolvedValueOnce({ data: mockTxDetail })
+        .mockResolvedValueOnce({ data: mockTxDetail });
+
+      const result = await rpc.getTransactions("DTest123", { pageSize: 10, pageNumber: 1 });
+      expect(result.transactions).toBeDefined();
+      expect(result.txIds).toEqual(mockTxIds);
+    });
+
+    it("should throw error on failure", async () => {
+      (rpc.mydoge.get as any).mockRejectedValue(new Error("API Error"));
+
+      await expect(rpc.getTransactions("DTest123")).rejects.toThrow("getTransactions failed");
+    });
+  });
+
+  describe("onCreateTransaction", () => {
+    it("should call sendResponse with rawTx and amountMismatch when resultAmount < amount - fee", async () => {
+      const sendResponse = vi.fn();
+      (rpc.mydoge.post as any).mockResolvedValue({
+        data: {
+          rawTx: "raw-hex",
+          fee: 0.001,
+          amount: 0.998, // less than 1 - 0.001
+        },
+      });
+
+      await rpc.onCreateTransaction({
+        data: {
+          senderAddress: "DFrom",
+          recipientAddress: "DTo",
+          dogeAmount: 1,
+        },
+        sendResponse,
+      });
+
+      expect(sendResponse).toHaveBeenCalledWith(
+        expect.objectContaining({
+          rawTx: "raw-hex",
+          fee: 0.001,
+          amount: 0.998,
+          amountMismatch: true,
+        }),
+      );
+    });
+
+    it("should call sendResponse with amountMismatch false when amount is sufficient", async () => {
+      const sendResponse = vi.fn();
+      (rpc.mydoge.post as any).mockResolvedValue({
+        data: {
+          rawTx: "raw-hex",
+          fee: 0.001,
+          amount: 0.999,
+        },
+      });
+
+      await rpc.onCreateTransaction({
+        data: {
+          senderAddress: "DFrom",
+          recipientAddress: "DTo",
+          dogeAmount: 1,
+        },
+        sendResponse,
+      });
+
+      expect(sendResponse).toHaveBeenCalledWith(
+        expect.objectContaining({
+          amountMismatch: false,
+        }),
+      );
+    });
+
+    it("should call sendResponse(false) on API error", async () => {
+      const sendResponse = vi.fn();
+      (rpc.mydoge.post as any).mockRejectedValue(new Error("API Error"));
+
+      await rpc.onCreateTransaction({
+        data: {
+          senderAddress: "DFrom",
+          recipientAddress: "DTo",
+          dogeAmount: 1,
+        },
+        sendResponse,
+      });
+
+      expect(sendResponse).toHaveBeenCalledWith(false);
+    });
+  });
+
+  describe("getDogeFeeByBlock", () => {
+    it("should get fee by block", async () => {
+      const mockApiInstance = {
+        get: vi.fn().mockResolvedValue({
+          data: {
+            feerate: 0.001,
+          },
+        }),
+        post: vi.fn(),
+      };
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce(mockApiInstance);
+
+      vi.resetModules();
+      const freshRpc = await import("../rpc");
+      const result = await freshRpc.getDogeFeeByBlock("DTest123", 22);
+      expect(result).toBeGreaterThan(0);
+    });
+  });
+
+  describe("sendDogeTx", () => {
+    it("should send doge transaction", async () => {
+      const mockTomoApi = {
+        get: vi.fn(),
+        post: vi.fn().mockResolvedValue({
+          data: {
+            result: "test-tx-id",
+          },
+        }),
+      };
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce(mockTomoApi);
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+
+      vi.resetModules();
+      const freshRpc = await import("../rpc");
+      const result = await freshRpc.sendDogeTx("raw-tx-hex");
+      expect(result.txid).toBe("test-tx-id");
+    });
+
+    it("should reject with error message from response", async () => {
+      const mockError = {
+        response: {
+          data: "Transaction failed",
+        },
+      };
+      const mockTomoApi = {
+        get: vi.fn(),
+        post: vi.fn().mockRejectedValue(mockError),
+      };
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce(mockTomoApi);
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+
+      vi.resetModules();
+      const freshRpc = await import("../rpc");
+      await expect(freshRpc.sendDogeTx("raw-tx-hex")).rejects.toThrow("Transaction failed");
+    });
+
+    it("should reject with error message from error object", async () => {
+      const mockError = {
+        message: "Network error",
+      };
+      const mockTomoApi = {
+        get: vi.fn(),
+        post: vi.fn().mockRejectedValue(mockError),
+      };
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce(mockTomoApi);
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+
+      vi.resetModules();
+      const freshRpc = await import("../rpc");
+      await expect(freshRpc.sendDogeTx("raw-tx-hex")).rejects.toThrow("Network error");
+    });
+
+    it("should reject when response data contains error", async () => {
+      const mockTomoApi = {
+        get: vi.fn(),
+        post: vi.fn().mockResolvedValue({
+          data: { error: { message: "insufficient fee" } },
+        }),
+      };
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce(mockTomoApi);
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+
+      vi.resetModules();
+      const freshRpc = await import("../rpc");
+      await expect(freshRpc.sendDogeTx("raw-tx-hex")).rejects.toThrow("insufficient fee");
+    });
+
+    it("should reject with error.message when catch has response.data.error.message", async () => {
+      const mockTomoApi = {
+        get: vi.fn(),
+        post: vi.fn().mockRejectedValue({
+          response: { data: { error: { message: "RPC error message" } } },
+        }),
+      };
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce(mockTomoApi);
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+
+      vi.resetModules();
+      const freshRpc = await import("../rpc");
+      await expect(freshRpc.sendDogeTx("raw-tx-hex")).rejects.toThrow("RPC error message");
+    });
+
+    it("should reject with error when catch has no response.data", async () => {
+      const mockTomoApi = {
+        get: vi.fn(),
+        post: vi.fn().mockRejectedValue({ message: "Network failed" }),
+      };
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+      (axios.create as any).mockReturnValueOnce(mockTomoApi);
+      (axios.create as any).mockReturnValueOnce({ get: vi.fn(), post: vi.fn() });
+
+      vi.resetModules();
+      const freshRpc = await import("../rpc");
+      await expect(freshRpc.sendDogeTx("raw-tx-hex")).rejects.toThrow("Network failed");
+    });
+  });
+});