@tomo-inc/chains-service 0.0.23 → 0.0.25

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

@@ -0,0 +1,420 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { DogecoinService } from "../service";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
+import { IAccountInfo, TomoAppInfo } from "../../types";
+import * as API from "../rpc";
+import { DogecoinUtils } from "../utils-doge";
+
+vi.mock("../rpc");
+vi.mock("../utils-doge");
+
+describe("DogecoinService Extended Tests", () => {
+  let mockAccountInfo: IAccountInfo;
+  let mockTomoAppInfo: TomoAppInfo;
+  let service: DogecoinService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (DogecoinService as any).instance = undefined;
+
+    mockAccountInfo = {
+      getCurrent: vi.fn().mockResolvedValue([
+        {
+          address: "DAddress123",
+          publicKey: "test-public-key",
+        },
+      ]),
+      signMessage: vi.fn().mockResolvedValue("signature123"),
+      signTransaction: vi.fn().mockResolvedValue("signedPsbt123"),
+    } as any;
+
+    mockTomoAppInfo = {
+      tomoStage: "dev",
+      appId: "test-app",
+      appName: "Test App",
+    };
+
+    service = new DogecoinService(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+  });
+
+  describe("getBalance", () => {
+    it("should get balance successfully", async () => {
+      vi.mocked(API.getBalance).mockResolvedValue({ balance: 1000000 });
+
+      const result = await service.getBalance();
+      expect(result.confirmed).toBe(1000000);
+      expect(result.unconfirmed).toBe(0);
+      expect(result.total).toBe(1000000);
+    });
+
+    it("should throw error when address is not set", async () => {
+      mockAccountInfo.getCurrent = vi.fn().mockResolvedValue([]);
+      await expect(service.getBalance()).rejects.toThrow("address is not set");
+    });
+  });
+
+  describe("requestPsbt", () => {
+    it("should request PSBT successfully", async () => {
+      vi.mocked(DogecoinUtils.rawTxToPsbtBase64).mockResolvedValue("psbtBase64");
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("signedRawTx");
+      vi.mocked(API.sendDogeTx).mockResolvedValue({ txid: "txid123" });
+
+      const result = await service.requestPsbt({
+        rawTx: "rawTx123",
+        signOnly: false,
+      });
+
+      expect(result).toBeDefined();
+      expect(result?.signedRawTx).toBe("signedRawTx");
+      expect(result?.txId).toBe("txid123");
+    });
+
+    it("should return only signedRawTx when signOnly is true", async () => {
+      vi.mocked(DogecoinUtils.rawTxToPsbtBase64).mockResolvedValue("psbtBase64");
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("signedRawTx");
+
+      const result = await service.requestPsbt({
+        rawTx: "rawTx123",
+        signOnly: true,
+      });
+
+      expect(result?.signedRawTx).toBe("signedRawTx");
+      expect(result?.txId).toBeUndefined();
+    });
+
+    it("should return null when signedPsbt is empty", async () => {
+      mockAccountInfo.signTransaction = vi.fn().mockResolvedValue("");
+      vi.mocked(DogecoinUtils.rawTxToPsbtBase64).mockResolvedValue("psbtBase64");
+
+      const result = await service.requestPsbt({
+        rawTx: "rawTx123",
+      });
+
+      expect(result).toBeNull();
+    });
+
+    it("should send transaction when signOnly is false", async () => {
+      vi.mocked(DogecoinUtils.rawTxToPsbtBase64).mockResolvedValue("psbtBase64");
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("signedRawTx");
+      vi.mocked(API.sendDogeTx).mockResolvedValue({ txid: "txid123" });
+
+      const result = await service.requestPsbt({
+        rawTx: "rawTx123",
+        signOnly: false,
+      });
+
+      expect(result?.txId).toBe("txid123");
+      expect(API.sendDogeTx).toHaveBeenCalledWith("signedRawTx");
+    });
+  });
+
+  describe("signPsbt", () => {
+    it("should sign PSBT successfully", async () => {
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("signedRawTx");
+
+      const result = await service.signPsbt({ psbtHex: "psbtHex123" });
+      expect(result).toBe("signedRawTx");
+    });
+
+    it("should throw error when signedPsbt is empty", async () => {
+      mockAccountInfo.signTransaction = vi.fn().mockResolvedValue("");
+
+      await expect(service.signPsbt({ psbtHex: "psbtHex123" })).rejects.toThrow("error psbtHex:psbtHex123");
+    });
+  });
+
+  describe("signPsbts", () => {
+    it("should throw error", async () => {
+      await expect(service.signPsbts({ psbtHexs: [] })).rejects.toThrow("not implemented");
+    });
+  });
+
+  describe("requestTransaction", () => {
+    it("should request transaction successfully", async () => {
+      const mockTxData = {
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 1.0,
+        fee: 0.001,
+        spendableUtxos: [
+          {
+            txid: "txid123",
+            vout: 0,
+            outputValue: 101000000, // 1.01 DOGE (enough for 1.0 + 0.001 fee)
+          },
+        ],
+      };
+
+      vi.mocked(API.getSpendableUtxos).mockResolvedValue([]);
+      vi.mocked(API.getTxDetail).mockResolvedValue({ hex: "hex123" } as any);
+      vi.mocked(DogecoinUtils.buildPsbtToBase64).mockReturnValue("psbtBase64");
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("signedTx");
+      vi.mocked(API.sendDogeTx).mockResolvedValue({ txid: "txid123" });
+
+      const result = await service.requestTransaction(mockTxData as any);
+      expect(result?.txId).toBe("txid123");
+    });
+
+    it("should throw error when amountMismatch", async () => {
+      const mockTxData = {
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 1.0,
+        fee: 0.001,
+        amountMismatch: true,
+      };
+
+      await expect(service.requestTransaction(mockTxData as any)).rejects.toThrow("balance_insufficient");
+    });
+
+    it("should fetch spendableUtxos when not provided", async () => {
+      const mockTxData = {
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 1.0,
+        fee: 0.001,
+      };
+
+      vi.mocked(API.getSpendableUtxos).mockResolvedValue([
+        {
+          txid: "txid123",
+          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");
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("signedTx");
+      vi.mocked(API.sendDogeTx).mockResolvedValue({ txid: "txid123" });
+
+      await service.requestTransaction(mockTxData as any);
+      expect(API.getSpendableUtxos).toHaveBeenCalledWith("DAddress123");
+    });
+
+    it("should throw error when signedTx is empty", async () => {
+      const mockTxData = {
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 1.0,
+        fee: 0.001,
+        spendableUtxos: [
+          {
+            txid: "txid123",
+            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");
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("");
+
+      await expect(service.requestTransaction(mockTxData as any)).rejects.toThrow("Error: sign transaction err.");
+    });
+
+    it("should throw error when send transaction fails", async () => {
+      const mockTxData = {
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 1.0,
+        fee: 0.001,
+        spendableUtxos: [
+          {
+            txid: "txid123",
+            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");
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("signedTx");
+      vi.mocked(API.sendDogeTx).mockRejectedValue(new Error("Network error"));
+
+      await expect(service.requestTransaction(mockTxData as any)).rejects.toThrow("Error: send transaction err.");
+    });
+  });
+
+  describe("send", () => {
+    it("should send successfully", async () => {
+      vi.mocked(API.getSpendableUtxos).mockResolvedValue([
+        {
+          txid: "txid123",
+          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");
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("signedTx");
+      vi.mocked(API.sendDogeTx).mockResolvedValue({ txid: "txid123" });
+
+      const result = await service.send({
+        toAddress: "DAddress456",
+        amount: 100000000, // 1.0 DOGE
+        fee: 1000000, // 0.001 DOGE
+      });
+
+      expect(result).toBe("txid123");
+    });
+
+    it("should throw error when fee is not provided", async () => {
+      await expect(
+        service.send({
+          toAddress: "DAddress456",
+          amount: 100000000,
+          fee: 0,
+        }),
+      ).rejects.toThrow("fee is required");
+    });
+  });
+
+  describe("sendDogecoin", () => {
+    it("should call send method", async () => {
+      vi.mocked(API.getSpendableUtxos).mockResolvedValue([
+        {
+          txid: "txid123",
+          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");
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("signedTx");
+      vi.mocked(API.sendDogeTx).mockResolvedValue({ txid: "txid123" });
+
+      const result = await service.sendDogecoin({
+        toAddress: "DAddress456",
+        amount: 100000000, // 1.0 DOGE
+        fee: 1000000, // 0.001 DOGE
+      });
+
+      expect(result).toBe("txid123");
+    });
+
+    it("should warn when options are passed (not supported)", async () => {
+      vi.mocked(API.getSpendableUtxos).mockResolvedValue([
+        {
+          txid: "txid123",
+          vout: 0,
+          outputValue: 101000000,
+        },
+      ]);
+      vi.mocked(API.getTxDetail).mockResolvedValue({ hex: "hex123" } as any);
+      vi.mocked(DogecoinUtils.buildPsbtToBase64).mockReturnValue("psbtBase64");
+      vi.mocked(DogecoinUtils.extractPsbtTransaction).mockReturnValue("signedTx");
+      vi.mocked(API.sendDogeTx).mockResolvedValue({ txid: "txid123" });
+
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const result = await service.sendDogecoin({
+        toAddress: "DAddress456",
+        amount: 100000000,
+        fee: 1000000,
+        options: { feeRate: 1, memo: "test" },
+      });
+      expect(warnSpy).toHaveBeenCalledWith("not support options");
+      warnSpy.mockRestore();
+      expect(result).toBe("txid123");
+    });
+  });
+
+  describe("getTransactionStatus", () => {
+    it("should get transaction status", async () => {
+      const mockTx = {
+        txid: "txid123",
+        confirmations: 5,
+        vout: [
+          {
+            value: 1.0,
+            addresses: ["DAddress456"],
+          },
+        ],
+        blockTime: 1234567890,
+      };
+
+      vi.mocked(API.getTxDetail).mockResolvedValue(mockTx as any);
+
+      const result = await service.getTransactionStatus({ txId: "txid123" });
+      expect(result.txId).toBe("txid123");
+      expect(result.status).toBe("confirmed");
+      expect(result.confirmations).toBe(5);
+    });
+
+    it("should return null when transaction not found", async () => {
+      vi.mocked(API.getTxDetail).mockResolvedValue(null as any);
+
+      const result = await service.getTransactionStatus({ txId: "txid123" });
+      expect(result).toBeNull();
+    });
+
+    it("should return pending status when confirmations is 0", async () => {
+      const mockTx = {
+        txid: "txid123",
+        confirmations: 0,
+        vout: [
+          {
+            value: 1.0,
+            addresses: ["DAddress456"],
+          },
+        ],
+        blockTime: 1234567890,
+      };
+
+      vi.mocked(API.getTxDetail).mockResolvedValue(mockTx as any);
+
+      const result = await service.getTransactionStatus({ txId: "txid123" });
+      expect(result.status).toBe("pending");
+    });
+  });
+
+  describe("_queryGasInfo", () => {
+    it("should query gas info successfully", async () => {
+      const mockGasInfo = {
+        baseFee: 1,
+        gasLimit: 100000,
+        priorityFeeLow: 1000,
+        priorityFeeMedium: 2000,
+        priorityFeeHigh: 3000,
+      };
+
+      (service as any).transactions = {
+        queryGasInfo: vi.fn().mockResolvedValue({
+          success: true,
+          data: mockGasInfo,
+        }),
+      };
+
+      const result = await service._queryGasInfo({
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 1.0,
+        chainId: "1",
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.fees).toBeDefined();
+      expect(result.gasFee).toBeDefined();
+    });
+
+    it("should return default gas fee on error", async () => {
+      (service as any).transactions = {
+        queryGasInfo: vi.fn().mockResolvedValue({
+          success: false,
+          message: "Error",
+        }),
+      };
+
+      const result = await service._queryGasInfo({
+        from: "DAddress123",
+        to: "DAddress456",
+        amount: 1.0,
+        chainId: "1",
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.gasFee).toBeDefined();
+    });
+  });
+});

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

@@ -0,0 +1,244 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { DogecoinUtils, DogecoinAddress } from "../utils-doge";
+import * as rpc from "../rpc";
+import { Psbt, Transaction } from "bitcoinjs-lib";
+
+// Mock rpc
+vi.mock("../rpc", () => ({
+  getTxDetail: vi.fn(),
+}));
+
+describe("DogecoinUtils", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("DogecoinAddress", () => {
+    describe("generatePath", () => {
+      it("should generate path for address index", () => {
+        const path = DogecoinAddress.generatePath(0);
+        expect(path).toBe("m/44'/3'/0'/0/0");
+      });
+
+      it("should generate path for non-zero address index", () => {
+        const path = DogecoinAddress.generatePath(5);
+        expect(path).toBe("m/44'/3'/0'/0/5");
+      });
+    });
+
+    describe("verifyAddress", () => {
+      it("should verify valid dogecoin address", () => {
+        // This is a valid dogecoin address format
+        const validAddress = "DTest123456789012345678901234567890";
+        // Note: This will fail in actual implementation if address is not valid
+        // We're just testing the function exists and can be called
+        const result = DogecoinAddress.verifyAddress(validAddress);
+        expect(typeof result).toBe("boolean");
+      });
+
+      it("should return false for invalid address", () => {
+        const invalidAddress = "invalid";
+        const result = DogecoinAddress.verifyAddress(invalidAddress);
+        expect(result).toBe(false);
+      });
+    });
+  });
+
+  describe("buildPsbtToBase64", () => {
+    it("should throw error for invalid transaction data", () => {
+      // Test with invalid txId (too short)
+      const tx = {
+        address: "DTest123",
+        inputs: [
+          {
+            txId: "invalid", // Invalid txId
+            vOut: 0,
+            amount: 100000000,
+          },
+        ],
+        outputs: [
+          {
+            address: "DRecipient123",
+            amount: 50000000,
+          },
+        ],
+      };
+
+      expect(() => {
+        DogecoinUtils.buildPsbtToBase64(tx);
+      }).toThrow();
+    });
+
+    it("should throw error for invalid address format", () => {
+      const validTxId = "a".repeat(64); // Valid 32-byte hex
+      const tx = {
+        address: "invalid-address",
+        inputs: [
+          {
+            txId: validTxId,
+            vOut: 0,
+            amount: 100000000,
+          },
+        ],
+        outputs: [
+          {
+            address: "invalid-recipient",
+            amount: 50000000,
+          },
+        ],
+      };
+
+      // Should throw error due to invalid address format
+      expect(() => {
+        DogecoinUtils.buildPsbtToBase64(tx);
+      }).toThrow();
+    });
+
+    it("should include nonWitnessUtxo in input options when provided (covers line 61-62)", () => {
+      const validTxId = "b".repeat(64);
+      const minimalPrevTxHex = "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff00ffffffff0100f2052a010000001976a914000000000000000000000000000000000000000088ac00000000";
+      const tx = {
+        address: "DTest123456789012345678901234567890",
+        inputs: [
+          {
+            txId: validTxId,
+            vOut: 0,
+            amount: 100000000,
+            nonWitnessUtxo: minimalPrevTxHex,
+          },
+        ],
+        outputs: [{ address: "DRecipient123456789012345678901234567890", amount: 50000000 }],
+      };
+      // nonWitnessUtxo branch (line 61-62) runs first; addOutput then throws due to invalid address
+      expect(() => DogecoinUtils.buildPsbtToBase64(tx)).toThrow(/no matching Script/);
+    });
+  });
+
+  describe("extractPsbtTransaction", () => {
+    it("should throw error for invalid PSBT format", () => {
+      const invalidPsbt = "invalid-psbt";
+      expect(() => {
+        DogecoinUtils.extractPsbtTransaction(invalidPsbt);
+      }).toThrow();
+    });
+
+    it("should use custom _maximumFeeRate when provided", () => {
+      const invalidPsbt = "invalid-psbt";
+      expect(() => {
+        DogecoinUtils.extractPsbtTransaction(invalidPsbt, 50000);
+      }).toThrow();
+    });
+
+    it("should call setMaximumFeeRate with _maximumFeeRate when provided (covers lines 80-81)", () => {
+      const minimalHex = "c000";
+      const base64Psbt = Buffer.from(minimalHex, "hex").toString("base64");
+      const setMaximumFeeRate = vi.fn();
+      const extractTransaction = vi.fn().mockReturnValue({ toHex: () => "deadbeef" });
+      const fromHexSpy = vi.spyOn(Psbt, "fromHex").mockReturnValue({
+        setMaximumFeeRate,
+        finalizeAllInputs: vi.fn(),
+        extractTransaction,
+      } as any);
+
+      const result = DogecoinUtils.extractPsbtTransaction(base64Psbt, 50000);
+
+      expect(setMaximumFeeRate).toHaveBeenCalledWith(50000);
+      expect(result).toBe("deadbeef");
+      fromHexSpy.mockRestore();
+    });
+
+    it("should use default maximumFeeRate 100000 when _maximumFeeRate not provided (covers lines 80-81)", () => {
+      const minimalHex = "c000";
+      const base64Psbt = Buffer.from(minimalHex, "hex").toString("base64");
+      const setMaximumFeeRate = vi.fn();
+      const fromHexSpy = vi.spyOn(Psbt, "fromHex").mockReturnValue({
+        setMaximumFeeRate,
+        finalizeAllInputs: vi.fn(),
+        extractTransaction: vi.fn().mockReturnValue({ toHex: () => "ab" }),
+      } as any);
+
+      DogecoinUtils.extractPsbtTransaction(base64Psbt);
+
+      expect(setMaximumFeeRate).toHaveBeenCalledWith(100000);
+      fromHexSpy.mockRestore();
+    });
+  });
+
+  describe("rawTxToPsbtBase64", () => {
+    it("should throw error for invalid raw transaction", async () => {
+      const invalidRawTx = "invalid-tx";
+      vi.spyOn(rpc, "getTxDetail").mockResolvedValue({
+        hex: "01000000",
+      } as any);
+
+      await expect(DogecoinUtils.rawTxToPsbtBase64(invalidRawTx)).rejects.toThrow();
+    });
+
+    it("should handle raw transaction with 0x prefix", async () => {
+      const rawTx =
+        "0x01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff08044c86041b020602ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52daaf87de6c36dfd4115338ef46e897963355484b448fd40aadcbee1d4047e10ac00000000";
+      const validTxId = "a".repeat(64);
+      const mockTxDetail = {
+        hex: "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff08044c86041b020602ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52daaf87de6c36dfd4115338ef46e897963355484b448fd40aadcbee1d4047e10ac00000000",
+      };
+
+      vi.spyOn(rpc, "getTxDetail").mockResolvedValue(mockTxDetail as any);
+
+      // This will fail because the transaction format is invalid, but we're testing the 0x prefix handling
+      await expect(DogecoinUtils.rawTxToPsbtBase64(rawTx)).rejects.toThrow();
+    });
+
+    it("should throw error when previous transaction not found", async () => {
+      const rawTx =
+        "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff08044c86041b020602ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52daaf87de6c36dfd4115338ef46e897963355484b448fd40aadcbee1d4047e10ac00000000";
+
+      vi.spyOn(rpc, "getTxDetail").mockRejectedValue(new Error("Transaction not found"));
+
+      await expect(DogecoinUtils.rawTxToPsbtBase64(rawTx)).rejects.toThrow();
+    });
+
+    it("should throw error when previous transaction has no hex", async () => {
+      const rawTx =
+        "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff08044c86041b020602ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52daaf87de6c36dfd4115338ef46e897963355484b448fd40aadcbee1d4047e10ac00000000";
+      const mockTxDetail = {
+        txid: "test-tx",
+        // no hex property
+      };
+
+      vi.spyOn(rpc, "getTxDetail").mockResolvedValue(mockTxDetail as any);
+
+      await expect(DogecoinUtils.rawTxToPsbtBase64(rawTx)).rejects.toThrow();
+    });
+
+    it("should return PSBT base64 when rawTx is valid and getTxDetail returns hex (covers 132-183)", async () => {
+      const minimalPrevTxHex =
+        "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff00ffffffff0100f2052a010000001976a914000000000000000000000000000000000000000088ac00000000";
+      const mockTx = {
+        ins: [{ hash: Buffer.alloc(32, 0), index: 0 }],
+        outs: [
+          { script: Buffer.from([0x6a, 0x00]), value: 0 }, // OP_RETURN so fromOutputScript throws -> catch adds output with script
+        ],
+      };
+      vi.spyOn(Transaction, "fromHex").mockReturnValue(mockTx as any);
+      vi.mocked(rpc.getTxDetail).mockResolvedValue({ hex: minimalPrevTxHex } as any);
+
+      const result = await DogecoinUtils.rawTxToPsbtBase64("01000000");
+
+      expect(typeof result).toBe("string");
+      expect(result.length).toBeGreaterThan(0);
+      vi.restoreAllMocks();
+    });
+
+    it("should throw when prevTxDetail has no hex (covers 151-152)", async () => {
+      const mockTx = {
+        ins: [{ hash: Buffer.alloc(32, 0), index: 0 }],
+        outs: [{ script: Buffer.from([0x76, 0xa9, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0xac]), value: 1000 }],
+      };
+      vi.spyOn(Transaction, "fromHex").mockReturnValue(mockTx as any);
+      vi.mocked(rpc.getTxDetail).mockResolvedValue({ txid: "tx" } as any);
+
+      await expect(DogecoinUtils.rawTxToPsbtBase64("00")).rejects.toThrow(/has no hex data/);
+      vi.restoreAllMocks();
+    });
+  });
+});