@sundaeswap/sprinkles 0.1.1 → 0.2.1

package/src/Sprinkle/__tests__/tx-dialog.test.ts

@@ -1,23 +1,31 @@
 import { describe, test, expect, mock, beforeEach } from "bun:test";
 import { Type } from "@sinclair/typebox";
 
-// Track select calls
+// Track calls and responses
 let selectCalls: any[] = [];
-let selectResponses: any[] = [];
+let selectResponses: string[] = [];
+let confirmResponses: boolean[] = [];
+let inputResponses: string[] = [];
 
 // Mock @inquirer/prompts
 mock.module("@inquirer/prompts", () => ({
-  input: mock(async () => "test"),
+  input: mock(async () => {
+    const response = inputResponses.shift();
+    return response ?? "";
+  }),
   password: mock(async () => "secret"),
   select: mock(async (opts: any) => {
     selectCalls.push(opts);
     const response = selectResponses.shift();
     if (response === undefined) {
-      // Default: return -1 (Back/Exit)
-      return -1;
+      return "cancel";
     }
     return response;
   }),
+  confirm: mock(async () => {
+    const response = confirmResponses.shift();
+    return response ?? false;
+  }),
   search: mock(async () => "result"),
 }));
 
@@ -39,255 +47,530 @@ const TestSchema = Type.Object({
   name: Type.String(),
 });
 
-describe("TxDialog (2.6)", () => {
+// Helper to create a mock transaction
+const createMockTx = (cbor = "deadbeef") => ({
+  toCbor: () => cbor,
+  body: () => ({
+    toCbor: () => cbor,
+    requiredSigners: () => null,
+    certs: () => null,
+    withdrawals: () => null,
+  }),
+  witnessSet: () => ({
+    vkeys: () => null,
+    setVkeys: () => {},
+  }),
+  setWitnessSet: () => {},
+});
+
+describe("TxDialog", () => {
   beforeEach(() => {
     selectCalls = [];
     selectResponses = [];
+    confirmResponses = [];
+    inputResponses = [];
     clipboardContent = "";
     clipboardShouldFail = false;
   });
 
-  test("shows truncated CBOR by default", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog");
-    const logs: string[] = [];
-    const origLog = console.log;
-    console.log = (...args: any[]) => logs.push(args.join(" "));
-
-    // Just exit immediately
-    selectResponses = [-1];
-
-    const mockTx = {
-      toCbor: () => "a".repeat(100),
-      body: () => ({
-        requiredSigners: () => null,
-        certs: () => null,
-        withdrawals: () => null,
-      }),
-    };
-
-    const mockBlaze = {
-      wallet: { getUsedAddresses: async () => [] },
-    };
-
-    await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
-    console.log = origLog;
-
-    // Should show truncated CBOR (50 chars + ...)
-    const cborLog = logs.find(l => l.includes("Transaction CBOR:"));
-    expect(cborLog).toBeDefined();
-    expect(cborLog!.length).toBeLessThan(100);
-    expect(cborLog).toContain("...");
+  describe("Display", () => {
+    test("shows truncated CBOR by default", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog");
+      const logs: string[] = [];
+      const origLog = console.log;
+      console.log = (...args: any[]) => logs.push(args.join(" "));
+
+      selectResponses = ["cancel"];
+
+      const mockTx = createMockTx("a".repeat(100));
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      const cborLog = logs.find((l) => l.includes("Transaction CBOR:"));
+      expect(cborLog).toBeDefined();
+      expect(cborLog!.length).toBeLessThan(100);
+      expect(cborLog).toContain("...");
+    });
+
+    test("shows transaction hash", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-hash");
+      const logs: string[] = [];
+      const origLog = console.log;
+      console.log = (...args: any[]) => logs.push(args.join(" "));
+
+      selectResponses = ["cancel"];
+
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      const txLog = logs.find((l) => l.includes("Transaction:"));
+      expect(txLog).toBeDefined();
+    });
+
+    test("shows signature count", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-sigs");
+      const logs: string[] = [];
+      const origLog = console.log;
+      console.log = (...args: any[]) => logs.push(args.join(" "));
+
+      selectResponses = ["cancel"];
+
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      const sigLog = logs.find((l) => l.includes("Signatures:"));
+      expect(sigLog).toBeDefined();
+      expect(sigLog).toContain("0");
+    });
+  });
+
+  describe("Menu options", () => {
+    test("non-HotWallet has Expand, Copy, Import, Submit, Cancel - no Sign", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog2");
+      const origLog = console.log;
+      console.log = () => {};
+
+      selectResponses = ["cancel"];
+
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      const menuCall = selectCalls[0];
+      expect(menuCall).toBeDefined();
+      const choiceNames = menuCall.choices.map((c: any) => c.name);
+      expect(choiceNames).toContain("Expand CBOR");
+      expect(choiceNames).toContain("Copy CBOR to clipboard");
+      expect(choiceNames).toContain("Import signatures from CBOR");
+      expect(choiceNames).toContain("Submit transaction");
+      expect(choiceNames).toContain("Cancel");
+      expect(choiceNames).not.toContain("Sign with this wallet");
+    });
+
+    test("HotWallet has Sign option", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog3");
+      const origLog = console.log;
+      console.log = () => {};
+
+      const { HotWallet } = await import("@blaze-cardano/sdk");
+
+      selectResponses = ["cancel"];
+
+      const mockTx = createMockTx();
+
+      const hotWalletProto = HotWallet.prototype;
+      const mockWallet = Object.create(hotWalletProto);
+      mockWallet.getUsedAddresses = async () => [];
+
+      const mockBlaze = {
+        wallet: mockWallet,
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      const menuCall = selectCalls[0];
+      expect(menuCall).toBeDefined();
+      const choiceNames = menuCall.choices.map((c: any) => c.name);
+      expect(choiceNames).toContain("Sign with this wallet");
+    });
+  });
+
+  describe("Copy CBOR", () => {
+    test("copies CBOR to clipboard", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog4");
+      const origLog = console.log;
+      const logs: string[] = [];
+      console.log = (...args: any[]) => logs.push(args.join(" "));
+
+      selectResponses = ["copy", "cancel"];
+
+      const txCbor = "deadbeefcafebabe";
+      const mockTx = createMockTx(txCbor);
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      expect(clipboardContent).toBe(txCbor);
+      expect(logs.some((l) => l.includes("copied to clipboard"))).toBe(true);
+    });
+
+    test("clipboard failure falls back to expanded view", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog5");
+      const origLog = console.log;
+      const logs: string[] = [];
+      console.log = (...args: any[]) => logs.push(args.join(" "));
+
+      clipboardShouldFail = true;
+
+      selectResponses = ["copy", "cancel"];
+
+      const txCbor = "a".repeat(100);
+      const mockTx = createMockTx(txCbor);
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      expect(logs.some((l) => l.includes("Failed to copy"))).toBe(true);
+    });
+  });
+
+  describe("Expand CBOR", () => {
+    test("shows full content when expanded", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog6");
+      const origLog = console.log;
+      const logs: string[] = [];
+      console.log = (...args: any[]) => logs.push(args.join(" "));
+
+      selectResponses = ["expand", "cancel"];
+
+      const txCbor = "b".repeat(100);
+      const mockTx = createMockTx(txCbor);
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      // First shows truncated, second shows full
+      const truncatedLog = logs.find(
+        (l) => l.includes("...") && l.includes("Transaction CBOR:"),
+      );
+      const fullLog = logs.find(
+        (l) => l.includes(txCbor) && !l.includes("..."),
+      );
+      expect(truncatedLog).toBeDefined();
+      expect(fullLog).toBeDefined();
+    });
   });
 
-  test("menu items for non-HotWallet include Expand, Copy, no Sign", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog2");
-    const origLog = console.log;
-    console.log = () => {};
-
-    selectResponses = [-1];
-
-    const mockTx = {
-      toCbor: () => "deadbeef",
-      body: () => ({
-        requiredSigners: () => null,
-        certs: () => null,
-        withdrawals: () => null,
-      }),
-    };
-
-    const mockBlaze = {
-      wallet: { getUsedAddresses: async () => [] },
-    };
-
-    await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
-    console.log = origLog;
-
-    // Check the select call had Expand and Copy but not Sign
-    const menuCall = selectCalls[0];
-    expect(menuCall).toBeDefined();
-    const choiceNames = menuCall.choices.map((c: any) => c.name);
-    expect(choiceNames).toContain("Expand CBOR");
-    expect(choiceNames).toContain("Copy CBOR to clipboard");
-    expect(choiceNames).not.toContain("Sign and submit transaction");
+  describe("Sign", () => {
+    test("beforeSign hook is called before signing", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog7");
+      const origLog = console.log;
+      const origWarn = console.warn;
+      console.log = () => {};
+      console.warn = () => {};
+
+      const { HotWallet } = await import("@blaze-cardano/sdk");
+
+      let beforeSignCalled = false;
+
+      selectResponses = ["sign", "cancel"];
+
+      const mockTx = createMockTx();
+
+      const hotWalletProto = HotWallet.prototype;
+      const mockWallet = Object.create(hotWalletProto);
+      mockWallet.getUsedAddresses = async () => [];
+
+      const mockBlaze = {
+        wallet: mockWallet,
+        signTransaction: async (tx: any) => ({
+          witnessSet: () => ({
+            vkeys: () => ({
+              size: () => 1,
+              toCore: () => [["vkey123", "sig123"]],
+            }),
+          }),
+        }),
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any, {
+        beforeSign: async () => {
+          beforeSignCalled = true;
+        },
+      });
+      console.log = origLog;
+      console.warn = origWarn;
+
+      expect(beforeSignCalled).toBe(true);
+    });
+
+    test("Sign option hidden after signing", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-signed");
+      const origLog = console.log;
+      const origWarn = console.warn;
+      console.log = () => {};
+      console.warn = () => {};
+
+      const { HotWallet } = await import("@blaze-cardano/sdk");
+
+      selectResponses = ["sign", "cancel"];
+
+      const mockTx = createMockTx();
+
+      const hotWalletProto = HotWallet.prototype;
+      const mockWallet = Object.create(hotWalletProto);
+      mockWallet.getUsedAddresses = async () => [];
+
+      const mockBlaze = {
+        wallet: mockWallet,
+        signTransaction: async (tx: any) => ({
+          witnessSet: () => ({
+            vkeys: () => ({
+              size: () => 1,
+              toCore: () => [["vkey123", "sig123"]],
+            }),
+          }),
+        }),
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+      console.warn = origWarn;
+
+      // First menu should have Sign, second should not
+      expect(selectCalls.length).toBe(2);
+      const firstMenuChoices = selectCalls[0].choices.map((c: any) => c.name);
+      const secondMenuChoices = selectCalls[1].choices.map((c: any) => c.name);
+      expect(firstMenuChoices).toContain("Sign with this wallet");
+      expect(secondMenuChoices).not.toContain("Sign with this wallet");
+    });
   });
 
-  test("menu items for HotWallet include Sign", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog3");
-    const origLog = console.log;
-    console.log = () => {};
-
-    // Need to import HotWallet to use instanceof
-    const { HotWallet } = await import("@blaze-cardano/sdk");
-
-    selectResponses = [-1];
-
-    const mockTx = {
-      toCbor: () => "deadbeef",
-      body: () => ({
-        requiredSigners: () => null,
-        certs: () => null,
-        withdrawals: () => null,
-      }),
-    };
-
-    // Create a mock that passes instanceof HotWallet check
-    // We need to use Object.create to set the prototype
-    const hotWalletProto = HotWallet.prototype;
-    const mockWallet = Object.create(hotWalletProto);
-    mockWallet.getUsedAddresses = async () => [];
-
-    const mockBlaze = {
-      wallet: mockWallet,
-    };
-
-    await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
-    console.log = origLog;
-
-    const menuCall = selectCalls[0];
-    expect(menuCall).toBeDefined();
-    const choiceNames = menuCall.choices.map((c: any) => c.name);
-    expect(choiceNames).toContain("Sign and submit transaction");
+  describe("Return values", () => {
+    test("returns cancelled when user cancels", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-cancel");
+      const origLog = console.log;
+      console.log = () => {};
+
+      selectResponses = ["cancel"];
+
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      const result = await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      expect(result.action).toBe("cancelled");
+      expect(result.tx).toBeDefined();
+      expect(result.txId).toBeUndefined();
+    });
+
+    test("returns signed when user signs then cancels", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-signed2");
+      const origLog = console.log;
+      const origWarn = console.warn;
+      console.log = () => {};
+      console.warn = () => {};
+
+      const { HotWallet } = await import("@blaze-cardano/sdk");
+
+      selectResponses = ["sign", "cancel"];
+
+      const mockTx = createMockTx();
+
+      const hotWalletProto = HotWallet.prototype;
+      const mockWallet = Object.create(hotWalletProto);
+      mockWallet.getUsedAddresses = async () => [];
+
+      const mockBlaze = {
+        wallet: mockWallet,
+        signTransaction: async (tx: any) => ({
+          witnessSet: () => ({
+            vkeys: () => ({
+              size: () => 1,
+              toCore: () => [["vkey123", "sig123"]],
+            }),
+          }),
+        }),
+      };
+
+      const result = await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+      console.warn = origWarn;
+
+      expect(result.action).toBe("signed");
+      expect(result.tx).toBeDefined();
+    });
+
+    test("returns submitted with txId on successful submit", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-submit");
+      const origLog = console.log;
+      console.log = () => {};
+
+      selectResponses = ["submit"];
+      confirmResponses = [true]; // Confirm submit with no signatures
+
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+        submitTransaction: async () => "txhash123456",
+      };
+
+      const result = await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      expect(result.action).toBe("submitted");
+      expect(result.txId).toBe("txhash123456");
+      expect(result.tx).toBeDefined();
+    });
   });
 
-  test("copy CBOR to clipboard works", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog4");
-    const origLog = console.log;
-    const logs: string[] = [];
-    console.log = (...args: any[]) => logs.push(args.join(" "));
-
-    // Select "Copy CBOR to clipboard" (index 1), then Back (-1)
-    selectResponses = [1, -1];
-
-    const txCbor = "deadbeefcafebabe";
-    const mockTx = {
-      toCbor: () => txCbor,
-      body: () => ({
-        requiredSigners: () => null,
-        certs: () => null,
-        withdrawals: () => null,
-      }),
-    };
-
-    const mockBlaze = {
-      wallet: { getUsedAddresses: async () => [] },
-    };
-
-    await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
-    console.log = origLog;
-
-    expect(clipboardContent).toBe(txCbor);
-    expect(logs.some(l => l.includes("copied to clipboard"))).toBe(true);
+  describe("Submit warnings", () => {
+    test("warns when submitting with no signatures", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-warn");
+      const origLog = console.log;
+      console.log = () => {};
+
+      // First try to submit, decline warning, then cancel
+      selectResponses = ["submit", "cancel"];
+      confirmResponses = [false];
+
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      const result = await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      // Should have returned to menu, then cancelled
+      expect(result.action).toBe("cancelled");
+      expect(selectCalls.length).toBe(2);
+    });
   });
 
-  test("clipboard failure falls back to expanded view", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog5");
-    const origLog = console.log;
-    const logs: string[] = [];
-    console.log = (...args: any[]) => logs.push(args.join(" "));
-
-    clipboardShouldFail = true;
-
-    // Select "Copy CBOR to clipboard" (index 1), 
-    // It will fail and call showDialog again with expanded=true
-    // Then Back (-1) from the expanded menu, then Back from outer
-    selectResponses = [1, -1, -1];
-
-    const txCbor = "a".repeat(100);
-    const mockTx = {
-      toCbor: () => txCbor,
-      body: () => ({
-        requiredSigners: () => null,
-        certs: () => null,
-        withdrawals: () => null,
-      }),
-    };
-
-    const mockBlaze = {
-      wallet: { getUsedAddresses: async () => [] },
-    };
-
-    await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
-    console.log = origLog;
-
-    expect(logs.some(l => l.includes("Failed to copy"))).toBe(true);
-    // After failure it should show the full CBOR without truncation
-    expect(logs.some(l => l.includes(txCbor) && !l.includes("..."))).toBe(true);
+  describe("Exit behavior", () => {
+    test("exits loop after successful submit", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-exit");
+      const origLog = console.log;
+      console.log = () => {};
+
+      selectResponses = ["submit"];
+      confirmResponses = [true];
+
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+        submitTransaction: async () => "txhash789",
+      };
+
+      const result = await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      // Should only have one menu call - no loop after submit
+      expect(selectCalls.length).toBe(1);
+      expect(result.action).toBe("submitted");
+    });
   });
 
-  test("expand CBOR shows full content", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog6");
-    const origLog = console.log;
-    const logs: string[] = [];
-    console.log = (...args: any[]) => logs.push(args.join(" "));
-
-    // Select "Expand CBOR" (index 0), then Back (-1) from expanded, then Back from outer
-    selectResponses = [0, -1, -1];
-
-    const txCbor = "b".repeat(100);
-    const mockTx = {
-      toCbor: () => txCbor,
-      body: () => ({
-        requiredSigners: () => null,
-        certs: () => null,
-        withdrawals: () => null,
-      }),
-    };
-
-    const mockBlaze = {
-      wallet: { getUsedAddresses: async () => [] },
-    };
-
-    await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
-    console.log = origLog;
-
-    // First call shows truncated, second shows full
-    const truncatedLog = logs.find(l => l.includes("...") && l.includes("Transaction CBOR:"));
-    const fullLog = logs.find(l => l.includes(txCbor) && !l.includes("..."));
-    expect(truncatedLog).toBeDefined();
-    expect(fullLog).toBeDefined();
+  describe("Required signers display", () => {
+    test("shows required signers when present", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-req");
+      const logs: string[] = [];
+      const origLog = console.log;
+      console.log = (...args: any[]) => logs.push(args.join(" "));
+
+      selectResponses = ["cancel"];
+
+      const mockTx = {
+        toCbor: () => "deadbeef",
+        body: () => ({
+          toCbor: () => "deadbeef",
+          requiredSigners: () => ({
+            values: () => [
+              { toString: () => "abc123def456" },
+              { toString: () => "789ghi012jkl" },
+            ],
+          }),
+          certs: () => null,
+          withdrawals: () => null,
+        }),
+        witnessSet: () => ({
+          vkeys: () => null,
+        }),
+      };
+
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      // Should show "X of Y required" format
+      expect(logs.some((l) => l.includes("of") && l.includes("required"))).toBe(
+        true,
+      );
+      // Should show required signers list
+      expect(logs.some((l) => l.includes("Required signers:"))).toBe(true);
+    });
   });
 
-  test("beforeSign hook is called before signing", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog7");
-    const origLog = console.log;
-    const origWarn = console.warn;
-    console.log = () => {};
-    console.warn = () => {};
-
-    const { HotWallet } = await import("@blaze-cardano/sdk");
-
-    let beforeSignCalled = false;
-
-    // Select "Sign and submit" (index 2 - after Expand and Copy), then Back
-    selectResponses = [2, -1];
-
-    const mockTx = {
-      toCbor: () => "deadbeef",
-      body: () => ({
-        requiredSigners: () => null,
-        certs: () => null,
-        withdrawals: () => null,
-      }),
-    };
-
-    const hotWalletProto = HotWallet.prototype;
-    const mockWallet = Object.create(hotWalletProto);
-    mockWallet.getUsedAddresses = async () => [];
-
-    const mockBlaze = {
-      wallet: mockWallet,
-      signTransaction: async (tx: any) => tx,
-      submitTransaction: async () => "txhash123",
-    };
-
-    await sprinkle.TxDialog(mockBlaze as any, mockTx as any, {
-      beforeSign: async () => {
-        beforeSignCalled = true;
-      },
+  describe("Import signatures", () => {
+    test("continues on empty CBOR input", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-import1");
+      const origLog = console.log;
+      const logs: string[] = [];
+      console.log = (...args: any[]) => logs.push(args.join(" "));
+
+      selectResponses = ["import", "cancel"];
+      inputResponses = [""]; // Empty input
+
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      const result = await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+
+      expect(logs.some((l) => l.includes("No CBOR provided"))).toBe(true);
+      expect(result.action).toBe("cancelled");
     });
-    console.log = origLog;
-    console.warn = origWarn;
 
-    expect(beforeSignCalled).toBe(true);
+    test("handles invalid CBOR gracefully", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-import2");
+      const origLog = console.log;
+      const origErr = console.error;
+      const logs: string[] = [];
+      const errors: string[] = [];
+      console.log = (...args: any[]) => logs.push(args.join(" "));
+      console.error = (...args: any[]) => errors.push(args.join(" "));
+
+      selectResponses = ["import", "cancel"];
+      inputResponses = ["not-valid-cbor"];
+
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: { getUsedAddresses: async () => [] },
+      };
+
+      const result = await sprinkle.TxDialog(mockBlaze as any, mockTx as any);
+      console.log = origLog;
+      console.error = origErr;
+
+      expect(errors.some((l) => l.includes("Failed to import"))).toBe(true);
+      expect(result.action).toBe("cancelled");
+    });
   });
 });