@sundaeswap/sprinkles 0.1.1 → 0.2.0

package/dist/esm/Sprinkle/__tests__/tx-dialog.test.js

@@ -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 = [];
 let selectResponses = [];
+let confirmResponses = [];
+let inputResponses = [];
 
 // 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 => {
     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")
 }));
 
@@ -38,232 +46,465 @@ const {
 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 = [];
-    const origLog = console.log;
-    console.log = (...args) => 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, mockTx);
-    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 = [];
+      const origLog = console.log;
+      console.log = (...args) => logs.push(args.join(" "));
+      selectResponses = ["cancel"];
+      const mockTx = createMockTx("a".repeat(100));
+      const mockBlaze = {
+        wallet: {
+          getUsedAddresses: async () => []
+        }
+      };
+      await sprinkle.TxDialog(mockBlaze, mockTx);
+      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 = [];
+      const origLog = console.log;
+      console.log = (...args) => logs.push(args.join(" "));
+      selectResponses = ["cancel"];
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: {
+          getUsedAddresses: async () => []
+        }
+      };
+      await sprinkle.TxDialog(mockBlaze, mockTx);
+      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 = [];
+      const origLog = console.log;
+      console.log = (...args) => logs.push(args.join(" "));
+      selectResponses = ["cancel"];
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: {
+          getUsedAddresses: async () => []
+        }
+      };
+      await sprinkle.TxDialog(mockBlaze, mockTx);
+      console.log = origLog;
+      const sigLog = logs.find(l => l.includes("Signatures:"));
+      expect(sigLog).toBeDefined();
+      expect(sigLog).toContain("0");
+    });
   });
-  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, mockTx);
-    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 => c.name);
-    expect(choiceNames).toContain("Expand CBOR");
-    expect(choiceNames).toContain("Copy CBOR to clipboard");
-    expect(choiceNames).not.toContain("Sign and submit transaction");
+  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, mockTx);
+      console.log = origLog;
+      const menuCall = selectCalls[0];
+      expect(menuCall).toBeDefined();
+      const choiceNames = menuCall.choices.map(c => 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, mockTx);
+      console.log = origLog;
+      const menuCall = selectCalls[0];
+      expect(menuCall).toBeDefined();
+      const choiceNames = menuCall.choices.map(c => 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 = [];
+      console.log = (...args) => logs.push(args.join(" "));
+      selectResponses = ["copy", "cancel"];
+      const txCbor = "deadbeefcafebabe";
+      const mockTx = createMockTx(txCbor);
+      const mockBlaze = {
+        wallet: {
+          getUsedAddresses: async () => []
+        }
+      };
+      await sprinkle.TxDialog(mockBlaze, mockTx);
+      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 = [];
+      console.log = (...args) => 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, mockTx);
+      console.log = origLog;
+      expect(logs.some(l => l.includes("Failed to copy"))).toBe(true);
+    });
   });
-  test("menu items for HotWallet include Sign", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog3");
-    const origLog = console.log;
-    console.log = () => {};
+  describe("Expand CBOR", () => {
+    test("shows full content when expanded", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog6");
+      const origLog = console.log;
+      const logs = [];
+      console.log = (...args) => 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, mockTx);
+      console.log = origLog;
 
-    // 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
-      })
-    };
+      // 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();
+    });
+  });
+  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 => ({
+          witnessSet: () => ({
+            vkeys: () => ({
+              size: () => 1,
+              toCore: () => [["vkey123", "sig123"]]
+            })
+          })
+        })
+      };
+      await sprinkle.TxDialog(mockBlaze, mockTx, {
+        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 => ({
+          witnessSet: () => ({
+            vkeys: () => ({
+              size: () => 1,
+              toCore: () => [["vkey123", "sig123"]]
+            })
+          })
+        })
+      };
+      await sprinkle.TxDialog(mockBlaze, mockTx);
+      console.log = origLog;
+      console.warn = origWarn;
 
-    // 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, mockTx);
-    console.log = origLog;
-    const menuCall = selectCalls[0];
-    expect(menuCall).toBeDefined();
-    const choiceNames = menuCall.choices.map(c => c.name);
-    expect(choiceNames).toContain("Sign and submit transaction");
+      // First menu should have Sign, second should not
+      expect(selectCalls.length).toBe(2);
+      const firstMenuChoices = selectCalls[0].choices.map(c => c.name);
+      const secondMenuChoices = selectCalls[1].choices.map(c => c.name);
+      expect(firstMenuChoices).toContain("Sign with this wallet");
+      expect(secondMenuChoices).not.toContain("Sign with this wallet");
+    });
   });
-  test("copy CBOR to clipboard works", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog4");
-    const origLog = console.log;
-    const logs = [];
-    console.log = (...args) => logs.push(args.join(" "));
+  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, mockTx);
+      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 => ({
+          witnessSet: () => ({
+            vkeys: () => ({
+              size: () => 1,
+              toCore: () => [["vkey123", "sig123"]]
+            })
+          })
+        })
+      };
+      const result = await sprinkle.TxDialog(mockBlaze, mockTx);
+      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
 
-    // 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, mockTx);
-    console.log = origLog;
-    expect(clipboardContent).toBe(txCbor);
-    expect(logs.some(l => l.includes("copied to clipboard"))).toBe(true);
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: {
+          getUsedAddresses: async () => []
+        },
+        submitTransaction: async () => "txhash123456"
+      };
+      const result = await sprinkle.TxDialog(mockBlaze, mockTx);
+      console.log = origLog;
+      expect(result.action).toBe("submitted");
+      expect(result.txId).toBe("txhash123456");
+      expect(result.tx).toBeDefined();
+    });
   });
-  test("clipboard failure falls back to expanded view", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog5");
-    const origLog = console.log;
-    const logs = [];
-    console.log = (...args) => logs.push(args.join(" "));
-    clipboardShouldFail = 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, mockTx);
+      console.log = origLog;
 
-    // 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, mockTx);
-    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);
+      // Should have returned to menu, then cancelled
+      expect(result.action).toBe("cancelled");
+      expect(selectCalls.length).toBe(2);
+    });
   });
-  test("expand CBOR shows full content", async () => {
-    const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog6");
-    const origLog = console.log;
-    const logs = [];
-    console.log = (...args) => logs.push(args.join(" "));
+  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, mockTx);
+      console.log = origLog;
 
-    // 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, mockTx);
-    console.log = origLog;
+      // Should only have one menu call - no loop after submit
+      expect(selectCalls.length).toBe(1);
+      expect(result.action).toBe("submitted");
+    });
+  });
+  describe("Required signers display", () => {
+    test("shows required signers when present", async () => {
+      const sprinkle = new Sprinkle(TestSchema, "/tmp/test-txdialog-req");
+      const logs = [];
+      const origLog = console.log;
+      console.log = (...args) => 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, mockTx);
+      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();
+      // 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;
+  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 = [];
+      console.log = (...args) => logs.push(args.join(" "));
+      selectResponses = ["import", "cancel"];
+      inputResponses = [""]; // Empty input
 
-    // 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 => tx,
-      submitTransaction: async () => "txhash123"
-    };
-    await sprinkle.TxDialog(mockBlaze, mockTx, {
-      beforeSign: async () => {
-        beforeSignCalled = true;
-      }
+      const mockTx = createMockTx();
+      const mockBlaze = {
+        wallet: {
+          getUsedAddresses: async () => []
+        }
+      };
+      const result = await sprinkle.TxDialog(mockBlaze, mockTx);
+      console.log = origLog;
+      expect(logs.some(l => l.includes("No CBOR provided"))).toBe(true);
+      expect(result.action).toBe("cancelled");
+    });
+    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 = [];
+      const errors = [];
+      console.log = (...args) => logs.push(args.join(" "));
+      console.error = (...args) => 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, mockTx);
+      console.log = origLog;
+      console.error = origErr;
+      expect(errors.some(l => l.includes("Failed to import"))).toBe(true);
+      expect(result.action).toBe("cancelled");
     });
-    console.log = origLog;
-    console.warn = origWarn;
-    expect(beforeSignCalled).toBe(true);
   });
 });
 //# sourceMappingURL=tx-dialog.test.js.map