@sundaeswap/sprinkles 0.4.0 → 0.6.0

package/dist/cjs/Sprinkle/index.js

@@ -4,18 +4,195 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
+  Sprinkle: true,
+  UserCancelledError: true,
   NetworkSchema: true,
   MultisigScriptModule: true,
   MultisigScript: true,
   ProviderSettingsSchema: true,
   WalletSettingsSchema: true,
-  Sprinkle: true
+  isOptional: true,
+  isImport: true,
+  isArray: true,
+  isBigInt: true,
+  isLiteral: true,
+  isObject: true,
+  isRef: true,
+  isString: true,
+  isThis: true,
+  isTuple: true,
+  isUnion: true,
+  isSensitive: true,
+  isNull: true,
+  isNullable: true,
+  unwrapNullable: true,
+  hasDefault: true,
+  getDefault: true,
+  GetProvider: true,
+  GetWallet: true,
+  GetBlaze: true
 };
-exports.WalletSettingsSchema = exports.Sprinkle = exports.ProviderSettingsSchema = exports.NetworkSchema = exports.MultisigScriptModule = exports.MultisigScript = void 0;
-var _query = require("@blaze-cardano/query");
+Object.defineProperty(exports, "GetBlaze", {
+  enumerable: true,
+  get: function () {
+    return _wallet.GetBlaze;
+  }
+});
+Object.defineProperty(exports, "GetProvider", {
+  enumerable: true,
+  get: function () {
+    return _wallet.GetProvider;
+  }
+});
+Object.defineProperty(exports, "GetWallet", {
+  enumerable: true,
+  get: function () {
+    return _wallet.GetWallet;
+  }
+});
+Object.defineProperty(exports, "MultisigScript", {
+  enumerable: true,
+  get: function () {
+    return _schemas.MultisigScript;
+  }
+});
+Object.defineProperty(exports, "MultisigScriptModule", {
+  enumerable: true,
+  get: function () {
+    return _schemas.MultisigScriptModule;
+  }
+});
+Object.defineProperty(exports, "NetworkSchema", {
+  enumerable: true,
+  get: function () {
+    return _schemas.NetworkSchema;
+  }
+});
+Object.defineProperty(exports, "ProviderSettingsSchema", {
+  enumerable: true,
+  get: function () {
+    return _schemas.ProviderSettingsSchema;
+  }
+});
+exports.Sprinkle = void 0;
+Object.defineProperty(exports, "UserCancelledError", {
+  enumerable: true,
+  get: function () {
+    return _types.UserCancelledError;
+  }
+});
+Object.defineProperty(exports, "WalletSettingsSchema", {
+  enumerable: true,
+  get: function () {
+    return _schemas.WalletSettingsSchema;
+  }
+});
+Object.defineProperty(exports, "getDefault", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.getDefault;
+  }
+});
+Object.defineProperty(exports, "hasDefault", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.hasDefault;
+  }
+});
+Object.defineProperty(exports, "isArray", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isArray;
+  }
+});
+Object.defineProperty(exports, "isBigInt", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isBigInt;
+  }
+});
+Object.defineProperty(exports, "isImport", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isImport;
+  }
+});
+Object.defineProperty(exports, "isLiteral", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isLiteral;
+  }
+});
+Object.defineProperty(exports, "isNull", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isNull;
+  }
+});
+Object.defineProperty(exports, "isNullable", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isNullable;
+  }
+});
+Object.defineProperty(exports, "isObject", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isObject;
+  }
+});
+Object.defineProperty(exports, "isOptional", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isOptional;
+  }
+});
+Object.defineProperty(exports, "isRef", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isRef;
+  }
+});
+Object.defineProperty(exports, "isSensitive", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isSensitive;
+  }
+});
+Object.defineProperty(exports, "isString", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isString;
+  }
+});
+Object.defineProperty(exports, "isThis", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isThis;
+  }
+});
+Object.defineProperty(exports, "isTuple", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isTuple;
+  }
+});
+Object.defineProperty(exports, "isUnion", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.isUnion;
+  }
+});
+Object.defineProperty(exports, "unwrapNullable", {
+  enumerable: true,
+  get: function () {
+    return _typeGuards.unwrapNullable;
+  }
+});
 var _sdk = require("@blaze-cardano/sdk");
 var _core = require("@blaze-cardano/core");
-var _prompts = require("@inquirer/prompts");
+var _prompts = require("./prompts.js");
+var _yoctocolorsCjs = _interopRequireDefault(require("yoctocolors-cjs"));
 var _typebox = require("@sinclair/typebox");
 Object.keys(_typebox).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -30,102 +207,26 @@ Object.keys(_typebox).forEach(function (key) {
 });
 var fs = _interopRequireWildcard(require("fs"));
 var path = _interopRequireWildcard(require("path"));
+var _types = require("./types.js");
+var _schemas = require("./schemas.js");
+var _typeGuards = require("./type-guards.js");
+var _wallet = require("./wallet.js");
+var _encryption = require("./encryption.js");
+var _txDialog = require("./tx-dialog.js");
+var _index = require("./menus/index.js");
+var _formatting = require("./utils/formatting.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-const isOptional = t => t[_typebox.OptionalKind] === "Optional";
-const isImport = t => t[_typebox.Kind] === "Import";
-const isArray = t => t[_typebox.Kind] === "Array";
-const isBigInt = t => t[_typebox.Kind] === "BigInt";
-// const isBoolean = (t: TSchema): t is TBoolean => t[Kind] === "Boolean";
-const isLiteral = t => t[_typebox.Kind] === "Literal";
-// const isNumber = (t: TSchema): t is TNumber => t[Kind] === "Number";
-const isObject = t => t[_typebox.Kind] === "Object";
-// const isRecord = (t: TSchema): t is TRecord => t[Kind] === "Record";
-const isRef = t => t[_typebox.Kind] === "Ref";
-const isString = t => t[_typebox.Kind] === "String";
-const isThis = t => t[_typebox.Kind] === "This";
-const isTuple = t => t[_typebox.Kind] === "Tuple";
-const isUnion = t => t[_typebox.Kind] === "Union";
-// const isAny = (t: TSchema): t is TAny => t[Kind] === "Any";
-
-const isSensitive = t => isString(t) && t.sensitive === true;
-const NetworkSchema = exports.NetworkSchema = _typebox.Type.Union([_typebox.Type.Literal("mainnet"), _typebox.Type.Literal("preview"), _typebox.Type.Literal("preprod")]);
-const MultisigScriptModule = exports.MultisigScriptModule = _typebox.Type.Module({
-  MultisigScript: _typebox.Type.Union([_typebox.Type.Object({
-    Signature: _typebox.Type.Object({
-      key_hash: _typebox.Type.String()
-    }, {
-      ctor: 0n
-    })
-  }), _typebox.Type.Object({
-    AllOf: _typebox.Type.Object({
-      scripts: _typebox.Type.Array(_typebox.Type.Ref("MultisigScript"))
-    }, {
-      ctor: 1n
-    })
-  }), _typebox.Type.Object({
-    AnyOf: _typebox.Type.Object({
-      scripts: _typebox.Type.Array(_typebox.Type.Ref("MultisigScript"))
-    }, {
-      ctor: 2n
-    })
-  }), _typebox.Type.Object({
-    AtLeast: _typebox.Type.Object({
-      required: _typebox.Type.BigInt(),
-      scripts: _typebox.Type.Array(_typebox.Type.Ref("MultisigScript"))
-    }, {
-      ctor: 3n
-    })
-  }), _typebox.Type.Object({
-    Before: _typebox.Type.Object({
-      time: _typebox.Type.BigInt()
-    }, {
-      ctor: 4n
-    })
-  }), _typebox.Type.Object({
-    After: _typebox.Type.Object({
-      time: _typebox.Type.BigInt()
-    }, {
-      ctor: 5n
-    })
-  }), _typebox.Type.Object({
-    Script: _typebox.Type.Object({
-      script_hash: _typebox.Type.String()
-    }, {
-      ctor: 6n
-    })
-  })])
-});
-const MultisigScript = exports.MultisigScript = MultisigScriptModule.Import("MultisigScript");
-const ProviderSettingsSchema = exports.ProviderSettingsSchema = _typebox.Type.Union([_typebox.Type.Object({
-  type: _typebox.Type.Literal("blockfrost"),
-  projectId: _typebox.Type.String({
-    minLength: 1,
-    title: "Blockfrost Project ID"
-  })
-}), _typebox.Type.Object({
-  type: _typebox.Type.Literal("maestro"),
-  apiKey: _typebox.Type.String({
-    minLength: 1,
-    title: "Maestro API Key"
-  })
-})]);
-const WalletSettingsSchema = exports.WalletSettingsSchema = _typebox.Type.Union([_typebox.Type.Object({
-  type: _typebox.Type.Literal("hot"),
-  privateKey: _typebox.Type.String({
-    minLength: 1,
-    title: "Hot Wallet Private Key",
-    sensitive: true
-  })
-}), _typebox.Type.Object({
-  type: _typebox.Type.Literal("cold"),
-  address: _typebox.Type.String({
-    minLength: 1,
-    title: "Cold Wallet Address"
-  })
-})]);
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // Re-export types from types.ts
+// Re-export schemas from schemas.ts
+// Import and re-export type guards
+// Import schemas for use in this file
+// Import and re-export wallet utilities
+// Import encryption utilities
+// Import tx-dialog utilities
+// Import menu modules
 class Sprinkle {
   constructor(type, storagePath, options) {
     _defineProperty(this, "storagePath", void 0);
@@ -232,32 +333,42 @@ class Sprinkle {
       meta: this.profileMeta,
       settings: settingsToSave,
       defaults: this.defaults
-    }, Sprinkle.bigIntReplacer, 2);
+    }, _encryption.bigIntReplacer, 2);
     fs.writeFileSync(filePath, jsonContent, "utf-8");
   }
   async promptProfileMeta(defaultName, defaultDescription) {
-    const name = await (0, _prompts.input)({
+    const name = await (0, _prompts.inputCancellable)({
       message: "Profile name:",
       default: defaultName,
       validate: v => v.trim().length > 0 ? true : "Name cannot be empty"
     });
-    const description = await (0, _prompts.input)({
+    if (name === null) return null; // User cancelled
+    const description = await (0, _prompts.inputCancellable)({
       message: "Profile description (optional):",
       default: defaultDescription ?? ""
     });
+    if (description === null) return null; // User cancelled
     return {
       name,
       description: description || undefined
     };
   }
   async createProfile() {
+    const result = await this.promptProfileMeta();
+    if (result === null) return; // User cancelled
     const {
       name,
       description
-    } = await this.promptProfileMeta();
+    } = result;
     const profilesDir = Sprinkle.profilesDir(this.storagePath);
     const id = Sprinkle.findAvailableId(profilesDir, Sprinkle.sanitizeProfileId(name));
     const now = new Date().toISOString();
+
+    // Snapshot current state in case we need to restore on cancellation
+    const prevProfileId = this.profileId;
+    const prevProfileMeta = this.profileMeta;
+    const prevDefaults = this.defaults;
+    const prevSettings = this.settings;
     this.profileId = id;
     this.profileMeta = {
       name,
@@ -266,7 +377,19 @@ class Sprinkle {
       updatedAt: now
     };
     this.defaults = {};
-    this.settings = await this.FillInStruct(this.type);
+    try {
+      this.settings = await this.FillInStruct(this.type);
+    } catch (e) {
+      // Restore previous state on cancellation
+      if (e instanceof _types.UserCancelledError) {
+        this.profileId = prevProfileId;
+        this.profileMeta = prevProfileMeta;
+        this.defaults = prevDefaults;
+        this.settings = prevSettings;
+        return;
+      }
+      throw e;
+    }
     this.saveProfile();
     fs.writeFileSync(Sprinkle.activeProfilePath(this.storagePath), id, "utf-8");
   }
@@ -291,7 +414,7 @@ class Sprinkle {
         fs.mkdirSync(profilesDir, {
           recursive: true
         });
-        fs.writeFileSync(Sprinkle.profilePath(this.storagePath, "default"), JSON.stringify(profileData, Sprinkle.bigIntReplacer, 2), "utf-8");
+        fs.writeFileSync(Sprinkle.profilePath(this.storagePath, "default"), JSON.stringify(profileData, _encryption.bigIntReplacer, 2), "utf-8");
         fs.writeFileSync(Sprinkle.activeProfilePath(this.storagePath), "default", "utf-8");
         // Backup legacy file
         fs.renameSync(legacyPath, `${legacyPath}.bak`);
@@ -328,23 +451,26 @@ class Sprinkle {
   }
   async selectProfile(profiles) {
     const available = profiles ?? this.scanProfiles();
-    const selection = await (0, _prompts.select)({
+    const selection = await (0, _prompts.selectCancellable)({
       message: "Select a profile:",
       choices: available.map(p => ({
         name: p.meta.description ? `${p.meta.name} - ${p.meta.description}` : p.meta.name,
         value: p.id
       }))
     });
+    if (selection === null) return; // User cancelled
     await this.loadProfile(selection);
   }
 
   // --- Profile management (CRUD) ---
 
   async duplicateProfile() {
+    const result = await this.promptProfileMeta(`${this.profileMeta.name} (copy)`, this.profileMeta.description);
+    if (result === null) return; // User cancelled
     const {
       name,
       description
-    } = await this.promptProfileMeta(`${this.profileMeta.name} (copy)`, this.profileMeta.description);
+    } = result;
     const profilesDir = Sprinkle.profilesDir(this.storagePath);
     const id = Sprinkle.findAvailableId(profilesDir, Sprinkle.sanitizeProfileId(name));
     const now = new Date().toISOString();
@@ -359,15 +485,17 @@ class Sprinkle {
       },
       settings: settingsToSave,
       defaults: this.defaults
-    }, Sprinkle.bigIntReplacer, 2);
+    }, _encryption.bigIntReplacer, 2);
     fs.writeFileSync(path.join(profilesDir, `${id}.json`), jsonContent, "utf-8");
     console.log(`Profile "${name}" created as a copy.`);
   }
   async renameProfile() {
+    const result = await this.promptProfileMeta(this.profileMeta.name, this.profileMeta.description);
+    if (result === null) return; // User cancelled
     const {
       name,
       description
-    } = await this.promptProfileMeta(this.profileMeta.name, this.profileMeta.description);
+    } = result;
     const newId = Sprinkle.sanitizeProfileId(name);
     const oldId = this.profileId;
     this.profileMeta.name = name;
@@ -395,34 +523,39 @@ class Sprinkle {
       console.log("Cannot delete the only profile.");
       return;
     }
-    const toDelete = await (0, _prompts.select)({
+    const toDelete = await (0, _prompts.selectCancellable)({
       message: "Select a profile to delete:",
-      choices: [...others.map(p => ({
+      choices: others.map(p => ({
         name: p.meta.description ? `${p.meta.name} - ${p.meta.description}` : p.meta.name,
         value: p.id
-      })), {
-        name: "Cancel",
-        value: "__cancel__"
-      }]
+      }))
     });
-    if (toDelete === "__cancel__") return;
-    const profileToDelete = others.find(p => p.id === toDelete);
-    const confirmed = await (0, _prompts.confirm)({
-      message: `Delete profile "${profileToDelete?.meta.name ?? toDelete}"? This cannot be undone.`,
+    if (toDelete === null) return; // User cancelled
+
+    const profileId = toDelete;
+    const profileToDelete = others.find(p => p.id === profileId);
+    const confirmed = await (0, _prompts.confirmCancellable)({
+      message: `Delete profile "${profileToDelete?.meta.name ?? profileId}"? This cannot be undone.`,
       default: false
     });
+    if (confirmed === null) return; // User cancelled
+
     if (confirmed) {
-      fs.unlinkSync(Sprinkle.profilePath(this.storagePath, toDelete));
-      console.log(`Profile "${profileToDelete?.meta.name ?? toDelete}" deleted.`);
+      fs.unlinkSync(Sprinkle.profilePath(this.storagePath, profileId));
+      console.log(`Profile "${profileToDelete?.meta.name ?? profileId}" deleted.`);
     }
   }
 
   // --- Menu ---
 
   async showMenu(menu) {
-    return this._showMenu(menu, true);
+    return this._showMenu(menu, true, [menu.title]);
   }
-  async _showMenu(menu, main) {
+  async _showMenu(menu, main, path, clearPrevious = false) {
+    // Clear previous breadcrumb if coming back from action/submenu
+    if (clearPrevious) {
+      process.stdout.write("\x1b[1A\x1b[2K\x1b[G");
+    }
     if (menu.beforeShow) {
       await menu.beforeShow(this);
     }
@@ -454,14 +587,43 @@ class Sprinkle {
         value: -1
       });
     }
-    const selection = await (0, _prompts.select)({
+
+    // Show breadcrumb
+    const breadcrumb = path.join(" > ");
+    console.log(_yoctocolorsCjs.default.dim("🍞 " + breadcrumb));
+    const selectionResult = await (0, _prompts.selectWithClear)({
       message: "Select an option:",
       choices: choices
     });
+    // Handle escape (null) as Back
+    // Don't clear here - let the caller's clearPrevious handle it
+    if (selectionResult === null) {
+      return;
+    }
+    const selection = selectionResult;
     if (selection === -5) {
       const settingsMenu = {
         title: "Settings & Profiles",
         items: [{
+          title: "View settings",
+          action: async () => {
+            const jsonStr = JSON.stringify(this.getDisplaySettings(), _encryption.bigIntReplacer, 2);
+            const jsonLines = jsonStr.split("\n").length;
+            console.log(jsonStr);
+
+            // Wait for user to press Enter
+            await (0, _prompts.selectWithClear)({
+              message: "Press Enter to continue...",
+              choices: [{
+                name: "Continue",
+                value: "continue"
+              }]
+            });
+
+            // Clear the JSON output
+            process.stdout.write("\x1b[1A\x1b[2K".repeat(jsonLines) + "\x1b[G");
+          }
+        }, {
           title: "Edit settings",
           action: async () => {
             this.settings = await this.EditStruct(this.type, this.settings);
@@ -500,24 +662,28 @@ class Sprinkle {
           }
         }]
       };
-      await this._showMenu(settingsMenu, false);
-      await this._showMenu(menu, main);
+      await this._showMenu(settingsMenu, false, [...path, "Settings & Profiles"], true);
+      await this._showMenu(menu, main, path, true);
       return;
     }
     if (selection === -1) {
+      // Don't clear here - let the caller's clearPrevious handle it
       return;
     }
     const selectedItem = menu.items[selection];
     if ("action" in selectedItem) {
+      // Update breadcrumb to show current action
+      process.stdout.write("\x1b[1A\x1b[2K\x1b[G");
+      console.log(_yoctocolorsCjs.default.dim("🍞 " + [...path, selectedItem.title].join(" > ")));
       const result = await selectedItem.action(this);
       if (result instanceof Sprinkle) {
         this.settings = result.settings;
         this.saveSettings();
       }
-      await this._showMenu(menu, main);
+      await this._showMenu(menu, main, path, true);
     } else {
-      await this._showMenu(selectedItem, false);
-      await this._showMenu(menu, main);
+      await this._showMenu(selectedItem, false, [...path, selectedItem.title], true);
+      await this._showMenu(menu, main, path, true);
     }
     return;
   }
@@ -529,40 +695,13 @@ class Sprinkle {
     return sprinkle;
   }
   static async GetProvider(network, settings) {
-    switch (settings.type) {
-      case "blockfrost":
-        return new _query.Blockfrost({
-          network: `cardano-${network}`,
-          projectId: settings.projectId
-        });
-      case "maestro":
-        // Dynamic import - Maestro may or may not be exported depending on @blaze-cardano/query version
-        const queryModule = await Promise.resolve().then(() => _interopRequireWildcard(require("@blaze-cardano/query")));
-        if (!queryModule.Maestro) {
-          throw new Error("Maestro is not available in the installed version of @blaze-cardano/query. Please install a version that includes Maestro support.");
-        }
-        return new queryModule.Maestro({
-          network: network,
-          apiKey: settings.apiKey
-        });
-      default:
-        throw new Error("Invalid provider type");
-    }
+    return (0, _wallet.GetProvider)(network, settings);
   }
   static async GetWallet(settings, provider) {
-    switch (settings.type) {
-      case "hot":
-        return _sdk.HotWallet.fromMasterkey(_sdk.Core.Bip32PrivateKeyHex(settings.privateKey), provider, provider.network);
-      case "cold":
-        return new _sdk.ColdWallet(_sdk.Core.Address.fromBech32(settings.address), provider.network, provider);
-      default:
-        throw new Error("Invalid wallet type");
-    }
+    return (0, _wallet.GetWallet)(settings, provider);
   }
   static async GetBlaze(network, providerSettings, walletSettings) {
-    const provider = await Sprinkle.GetProvider(network, providerSettings);
-    const wallet = await Sprinkle.GetWallet(walletSettings, provider);
-    return _sdk.Blaze.from(provider, wallet);
+    return (0, _wallet.GetBlaze)(network, providerSettings, walletSettings);
   }
 
   /**
@@ -571,30 +710,10 @@ class Sprinkle {
    * @returns The Bip32PrivateKey hex string for storage
    */
   static async generateWalletFromMnemonic() {
-    const mnemonic = _sdk.Core.generateMnemonic(_core.wordlist, 256); // 24 words
-    const words = mnemonic.split(" ");
-    console.log("\n=== NEW WALLET GENERATED ===\n");
-    console.log("IMPORTANT: Save these 24 words in a secure location.");
-    console.log("This is the ONLY way to recover your wallet.\n");
-
-    // Display in 4 columns
-    for (let i = 0; i < 6; i++) {
-      console.log(`${(i + 1).toString().padStart(2)}. ${words[i].padEnd(12)} ` + `${(i + 7).toString().padStart(2)}. ${words[i + 6].padEnd(12)} ` + `${(i + 13).toString().padStart(2)}. ${words[i + 12].padEnd(12)} ` + `${(i + 19).toString().padStart(2)}. ${words[i + 18]}`);
-    }
-    console.log("");
-    const confirmed = await (0, _prompts.confirm)({
-      message: "Have you saved your recovery phrase?",
-      default: false
-    });
-    if (!confirmed) {
-      throw new Error("Wallet generation cancelled - recovery phrase not saved");
-    }
-    const entropy = _sdk.Core.mnemonicToEntropy(mnemonic, _core.wordlist);
-    const masterKey = _sdk.Core.Bip32PrivateKey.fromBip39Entropy(Buffer.from(entropy), "");
-    return masterKey.hex();
+    return (0, _wallet.generateWalletFromMnemonic)();
   }
   static async SearchSelect(opts) {
-    return (0, _prompts.search)(opts);
+    return (0, _prompts.searchCancellable)(opts);
   }
   static SettingsPath(storagePath) {
     return `${storagePath}${path.sep}settings.json`;
@@ -618,166 +737,21 @@ class Sprinkle {
     }
   }
   static bigIntReviver(key, value) {
-    if (typeof value === "string" && /^\d+n$/.test(value)) {
-      return BigInt(value.slice(0, -1));
-    }
-    return value;
-  }
-  static bigIntReplacer(_key, value) {
-    return typeof value === "bigint" ? `${value.toString()}n` : value;
-  }
-  static collectSensitivePaths(type, prefix = "") {
-    const paths = [];
-    if (isObject(type)) {
-      const fields = type["properties"];
-      for (const [field, fieldType] of Object.entries(fields)) {
-        const fieldPath = prefix ? `${prefix}.${field}` : field;
-        if (isSensitive(fieldType)) {
-          paths.push(fieldPath);
-        }
-        paths.push(...Sprinkle.collectSensitivePaths(fieldType, fieldPath));
-      }
-    }
-    if (isUnion(type)) {
-      for (const variant of type.anyOf) {
-        paths.push(...Sprinkle.collectSensitivePaths(variant, prefix));
-      }
-    }
-    return paths;
-  }
-  static getNestedValue(obj, path) {
-    return path.split(".").reduce((o, k) => o?.[k], obj);
-  }
-  static setNestedValue(obj, path, value) {
-    const keys = path.split(".");
-    const last = keys.pop();
-    const parent = keys.reduce((o, k) => o?.[k], obj);
-    if (parent && typeof parent === "object") {
-      parent[last] = value;
-    }
+    return (0, _encryption.bigIntReviver)(key, value);
   }
   encryptSettings(settings) {
     if (!this.options.encryption) return settings;
-    const clone = JSON.parse(JSON.stringify(settings, Sprinkle.bigIntReplacer), Sprinkle.bigIntReviver);
-    const sensitivePaths = Sprinkle.collectSensitivePaths(this.type);
-    for (const p of sensitivePaths) {
-      const value = Sprinkle.getNestedValue(clone, p);
-      if (typeof value === "string" && value.length > 0) {
-        Sprinkle.setNestedValue(clone, p, this.options.encryption.encrypt(value));
-      }
-    }
-    return clone;
+    return (0, _encryption.encryptSensitiveFields)(settings, this.type, this.options.encryption);
   }
   async decryptSettings(settings) {
     if (!this.options.encryption) return settings;
-    const clone = JSON.parse(JSON.stringify(settings, Sprinkle.bigIntReplacer), Sprinkle.bigIntReviver);
-    const sensitivePaths = Sprinkle.collectSensitivePaths(this.type);
-    for (const p of sensitivePaths) {
-      const value = Sprinkle.getNestedValue(clone, p);
-      if (typeof value === "string" && value.length > 0) {
-        Sprinkle.setNestedValue(clone, p, await this.options.encryption.decrypt(value));
-      }
-    }
-    return clone;
+    return (0, _encryption.decryptSensitiveFields)(settings, this.type, this.options.encryption);
   }
   saveSettings() {
     this.saveProfile();
   }
   getDisplaySettings() {
-    const clone = JSON.parse(JSON.stringify(this.settings, Sprinkle.bigIntReplacer), Sprinkle.bigIntReviver);
-    const sensitivePaths = Sprinkle.collectSensitivePaths(this.type);
-    for (const p of sensitivePaths) {
-      const value = Sprinkle.getNestedValue(clone, p);
-      if (typeof value === "string" && value.length > 0) {
-        Sprinkle.setNestedValue(clone, p, "********");
-      }
-    }
-    return clone;
-  }
-
-  // --- TxDialog Helpers ---
-
-  /**
-   * Get the payment key hash from a HotWallet's first address
-   */
-  async getWalletPaymentKeyHash(wallet) {
-    try {
-      const addresses = await wallet.getUsedAddresses();
-      const address = addresses[0];
-      if (!address) return null;
-      const paymentCredential = address.asBase()?.getPaymentCredential();
-      return paymentCredential?.hash?.toString() ?? null;
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Count the number of vkey signatures in a transaction's witness set
-   */
-  countSignatures(tx) {
-    const vkeys = tx.witnessSet().vkeys();
-    return vkeys ? vkeys.size() : 0;
-  }
-
-  /**
-   * Check if a specific public key has already signed the transaction
-   * Compares by vkey (public key bytes)
-   */
-  hasVkeySigned(tx, vkeyHex) {
-    const vkeys = tx.witnessSet().vkeys();
-    if (!vkeys) return false;
-    const vkeyArray = vkeys.toCore();
-    return vkeyArray.some(([vkey]) => vkey === vkeyHex);
-  }
-
-  /**
-   * Get the list of required signer key hashes from the transaction body
-   */
-  getRequiredSigners(tx) {
-    const requiredSigners = tx.body().requiredSigners();
-    if (!requiredSigners) return [];
-    return Array.from(requiredSigners.values()).map(s => s.toString());
-  }
-
-  /**
-   * Compute the transaction body hash for display
-   */
-  getTxBodyHash(tx) {
-    const bodyCbor = tx.body().toCbor();
-    return (0, _core.blake2b_256)(bodyCbor);
-  }
-
-  /**
-   * Format a hash for display: first 8 chars + ... + last 8 chars
-   */
-  formatHash(hash) {
-    if (hash.length <= 20) return hash;
-    return `${hash.slice(0, 8)}...${hash.slice(-8)}`;
-  }
-
-  /**
-   * Merge signatures from source transaction into target transaction.
-   * Prevents duplicate signatures by comparing vkey (public key).
-   * Returns the count of newly added signatures.
-   */
-  mergeSignatures(target, source) {
-    const targetWs = target.witnessSet();
-    const sourceWs = source.witnessSet();
-    const targetVkeys = targetWs.vkeys()?.toCore() ?? [];
-    const sourceVkeys = sourceWs.vkeys()?.toCore() ?? [];
-
-    // Find vkeys in source that aren't in target (by comparing public key)
-    const existingPubKeys = new Set(targetVkeys.map(([vkey]) => vkey));
-    const newVkeys = sourceVkeys.filter(([vkey]) => !existingPubKeys.has(vkey));
-    if (newVkeys.length === 0) {
-      return 0;
-    }
-
-    // Merge the new vkeys into target
-    targetWs.setVkeys(_core.CborSet.fromCore([...targetVkeys, ...newVkeys], _core.VkeyWitness.fromCore));
-    target.setWitnessSet(targetWs);
-    return newVkeys.length;
+    return (0, _encryption.maskSensitiveFields)(this.settings, this.type);
   }
   async TxDialog(blaze, tx, opts) {
     let currentTx = tx;
@@ -805,16 +779,16 @@ class Sprinkle {
     }
     while (true) {
       // Display transaction status
-      const txHash = this.getTxBodyHash(currentTx);
-      const sigCount = this.countSignatures(currentTx);
-      const requiredSigners = this.getRequiredSigners(currentTx);
+      const txHash = (0, _txDialog.getTxBodyHash)(currentTx);
+      const sigCount = (0, _txDialog.countSignatures)(currentTx);
+      const requiredSigners = (0, _txDialog.getRequiredSigners)(currentTx);
       console.log("");
-      console.log(`Transaction: ${this.formatHash(txHash)}`);
+      console.log(`Transaction: ${(0, _txDialog.formatHash)(txHash)}`);
       if (requiredSigners.length > 0) {
         console.log(`Signatures: ${sigCount} of ${requiredSigners.length} required`);
         console.log("Required signers:");
         for (const signer of requiredSigners) {
-          console.log(`  - ${this.formatHash(signer)}`);
+          console.log(`  - ${(0, _txDialog.formatHash)(signer)}`);
         }
       } else {
         console.log(`Signatures: ${sigCount}`);
@@ -864,11 +838,25 @@ class Sprinkle {
         name: "Cancel",
         value: "cancel"
       });
-      const selection = await (0, _prompts.select)({
+      const selection = await (0, _prompts.selectWithClear)({
         message: "Select an option:",
         choices
       });
 
+      // Handle escape/cancel as cancel action
+      if (selection === null) {
+        if (hasSignedThisSession) {
+          return {
+            action: "signed",
+            tx: currentTx
+          };
+        }
+        return {
+          action: "cancelled",
+          tx: currentTx
+        };
+      }
+
       // Handle selection
       if (selection === "sign") {
         if (opts?.beforeSign) {
@@ -934,7 +922,7 @@ class Sprinkle {
           } else {
             const signedTx = await blaze.signTransaction(currentTx);
             // Merge signatures from signed tx into current tx
-            const added = this.mergeSignatures(currentTx, signedTx);
+            const added = (0, _txDialog.mergeSignatures)(currentTx, signedTx);
             if (added > 0) {
               console.log(`Added ${added} signature(s).`);
               hasSignedThisSession = true;
@@ -966,10 +954,10 @@ class Sprinkle {
         continue;
       }
       if (selection === "import") {
-        const cborInput = await (0, _prompts.input)({
+        const cborInput = await (0, _prompts.inputCancellable)({
           message: "Paste transaction CBOR (hex):"
         });
-        if (!cborInput || cborInput.trim() === "") {
+        if (cborInput === null || cborInput.trim() === "") {
           console.log("No CBOR provided.");
           continue;
         }
@@ -977,21 +965,21 @@ class Sprinkle {
           const importedTx = _sdk.Core.Transaction.fromCbor((0, _core.TxCBOR)(cborInput.trim()));
 
           // Validate body hash matches
-          const currentHash = this.getTxBodyHash(currentTx);
-          const importedHash = this.getTxBodyHash(importedTx);
+          const currentHash = (0, _txDialog.getTxBodyHash)(currentTx);
+          const importedHash = (0, _txDialog.getTxBodyHash)(importedTx);
           if (currentHash !== importedHash) {
-            const proceed = await (0, _prompts.confirm)({
-              message: `Warning: Imported transaction has different body hash.\nCurrent:  ${this.formatHash(currentHash)}\nImported: ${this.formatHash(importedHash)}\nProceed anyway?`,
+            const proceed = await (0, _prompts.confirmCancellable)({
+              message: `Warning: Imported transaction has different body hash.\nCurrent:  ${(0, _txDialog.formatHash)(currentHash)}\nImported: ${(0, _txDialog.formatHash)(importedHash)}\nProceed anyway?`,
               default: false
             });
-            if (!proceed) {
+            if (proceed === null || !proceed) {
               console.log("Import cancelled.");
               continue;
             }
           }
 
           // Merge signatures
-          const added = this.mergeSignatures(currentTx, importedTx);
+          const added = (0, _txDialog.mergeSignatures)(currentTx, importedTx);
           const sourceVkeys = importedTx.witnessSet().vkeys();
           const sourceCount = sourceVkeys ? sourceVkeys.size() : 0;
           const skipped = sourceCount - added;
@@ -1010,13 +998,13 @@ class Sprinkle {
         continue;
       }
       if (selection === "submit") {
-        const sigCount = this.countSignatures(currentTx);
+        const sigCount = (0, _txDialog.countSignatures)(currentTx);
         if (sigCount === 0) {
-          const proceed = await (0, _prompts.confirm)({
+          const proceed = await (0, _prompts.confirmCancellable)({
             message: "Warning: Transaction has no signatures. Submit anyway?",
             default: false
           });
-          if (!proceed) {
+          if (proceed === null || !proceed) {
             continue;
           }
         }
@@ -1048,46 +1036,18 @@ class Sprinkle {
       }
     }
   }
+
+  /**
+   * Edit an existing struct value using a menu-based interface.
+   * This is now unified with FillInStruct - both use the same menu system.
+   * @param type - The TypeBox schema
+   * @param current - The current value to edit
+   * @returns The edited value
+   */
   async EditStruct(type, current) {
-    return this._editStruct(type, ["root"], current);
-  }
-  async _editStruct(type, path, current) {
-    if (isObject(type)) {
-      const obj = {};
-      const fields = type["properties"];
-      const menuItems = [];
-      const currentRecord = current;
-      for (const [field, fieldType] of Object.entries(fields)) {
-        if (current && field in currentRecord) {
-          obj[field] = currentRecord[field];
-        }
-        const menuTitle = Sprinkle.ExtractMessage(fieldType, `Edit ${field} at ${path.join(".")}`);
-        if (isOptional(fieldType) && current && currentRecord[field] !== undefined) {
-          menuItems.push({
-            title: `Clear ${field}`,
-            action: async sprinkle => {
-              obj[field] = undefined;
-              return sprinkle;
-            }
-          });
-        }
-        menuItems.push({
-          title: menuTitle,
-          action: async sprinkle => {
-            const fieldValue = await sprinkle._editStruct(fieldType, path.concat([field]), current && field in currentRecord ? currentRecord[field] : undefined);
-            obj[field] = fieldValue;
-            return sprinkle;
-          }
-        });
-      }
-      const editMenu = {
-        title: "Test",
-        items: menuItems
-      };
-      await this._showMenu(editMenu, false);
-      return obj;
-    }
-    return this._fillInStruct(type, path, {}, current);
+    // Use FillInStruct with current values as defaults
+    // The menu system will show existing values and allow editing
+    return this.FillInStruct(type, current);
   }
   async FillInStruct(type, def) {
     return this._fillInStruct(type, ["root"], {}, def);
@@ -1104,9 +1064,10 @@ class Sprinkle {
       }
       return this._fillInStruct(resolvedType, path, defs, def);
     }
-    if (isOptional(type)) {
-      const shouldSet = await (0, _prompts.select)({
-        message: Sprinkle.ExtractMessage(type, `Set value for ${path.join(".")}?`),
+    if ((0, _typeGuards.isOptional)(type)) {
+      const pathDisplay = (0, _formatting.formatPath)(path) || "value";
+      const shouldSet = await (0, _prompts.selectWithClear)({
+        message: Sprinkle.ExtractMessage(type, `Set value for ${pathDisplay}?`),
         choices: [{
           name: "Yes",
           value: true
@@ -1116,6 +1077,9 @@ class Sprinkle {
         }],
         default: def !== undefined
       });
+      if (shouldSet === null) {
+        throw new _types.UserCancelledError();
+      }
       if (!shouldSet) {
         return undefined;
       }
@@ -1126,7 +1090,8 @@ class Sprinkle {
       delete innerType[_typebox.OptionalKind];
       return this._fillInStruct(innerType, path, defs, def);
     }
-    if (isUnion(type)) {
+    if ((0, _typeGuards.isUnion)(type)) {
+      const pathDisplay = (0, _formatting.formatPath)(path) || "value";
       const choices = [];
       const resolved = this.resolveType(type, path, defs);
       for (const variant of resolved.anyOf) {
@@ -1135,17 +1100,20 @@ class Sprinkle {
           value: variant
         });
       }
-      const selection = await (0, _prompts.select)({
-        message: Sprinkle.ExtractMessage(resolved, `Enter a choice for ${path.join(".")}`),
-        choices: choices,
-        default: def ? `${def}` : undefined
+      const selectionResult = await (0, _prompts.selectWithClear)({
+        message: Sprinkle.ExtractMessage(resolved, `Enter a choice for ${pathDisplay}`),
+        choices: choices
       });
+      if (selectionResult === null) {
+        throw new _types.UserCancelledError();
+      }
+      const selection = selectionResult;
       return this._fillInStruct(selection, path, defs);
     }
-    if (isString(type)) {
+    if ((0, _typeGuards.isString)(type)) {
       // Special handling for hot wallet private key - offer generation option
       if (type.title === "Hot Wallet Private Key") {
-        const choice = await (0, _prompts.select)({
+        const choice = await (0, _prompts.selectWithClear)({
           message: "Hot wallet setup:",
           choices: [{
             name: "Enter existing private key",
@@ -1155,34 +1123,47 @@ class Sprinkle {
             value: "generate"
           }]
         });
+        if (choice === null) {
+          throw new _types.UserCancelledError();
+        }
         if (choice === "generate") {
           return Sprinkle.generateWalletFromMnemonic();
         }
         // Fall through to password prompt for "existing" choice
-        const answer = await (0, _prompts.password)({
+        const answer = await (0, _prompts.passwordWithClear)({
           message: "Enter your private key:"
         });
+        if (answer === null) {
+          throw new _types.UserCancelledError();
+        }
         return answer;
       }
+      const pathDisplay = (0, _formatting.formatPath)(path) || "value";
       const defaultString = def ? def : this.defaults["string"];
-      const message = Sprinkle.ExtractMessage(type, `Enter a string for ${path.join(".")}`);
+      const message = Sprinkle.ExtractMessage(type, `Enter a string for ${pathDisplay}`);
       let answer;
-      if (isSensitive(type)) {
-        answer = await (0, _prompts.password)({
+      if ((0, _typeGuards.isSensitive)(type)) {
+        answer = await (0, _prompts.passwordWithClear)({
           message
         });
       } else {
-        answer = await (0, _prompts.input)({
+        answer = await (0, _prompts.inputWithClear)({
           message,
           default: defaultString
         });
-        this.defaults["string"] = answer;
+        if (answer !== null) {
+          this.defaults["string"] = answer;
+        }
+      }
+      if (answer === null) {
+        throw new _types.UserCancelledError();
       }
       return answer;
     }
-    if (isBigInt(type)) {
-      const answer = await (0, _prompts.input)({
-        message: Sprinkle.ExtractMessage(type, `Enter a bigint for ${path.join(".")}`),
+    if ((0, _typeGuards.isBigInt)(type)) {
+      const pathDisplay = (0, _formatting.formatPath)(path) || "value";
+      const answer = await (0, _prompts.inputWithClear)({
+        message: Sprinkle.ExtractMessage(type, `Enter a bigint for ${pathDisplay}`),
         default: def ? def.toString() : undefined,
         validate: s => {
           try {
@@ -1193,44 +1174,51 @@ class Sprinkle {
           }
         }
       });
+      if (answer === null) {
+        throw new _types.UserCancelledError();
+      }
       return BigInt(answer);
     }
-    if (isLiteral(type)) {
+    if ((0, _typeGuards.isLiteral)(type)) {
       return type.const;
     }
-    if (isObject(type)) {
-      const obj = {};
-      const fields = type["properties"];
-      for (const [field, fieldType] of Object.entries(fields)) {
-        const fieldValue = await this._fillInStruct(fieldType, path.concat([field]), defs, def ? def[field] : undefined);
-        obj[field] = fieldValue;
+    if ((0, _typeGuards.isObject)(type)) {
+      // Use menu-based editing for objects
+      const defaults = def;
+      const sprinkle = this;
+      const result = await (0, _index.promptObject)({
+        type,
+        path,
+        defs,
+        defaults,
+        fillField: async (fieldType, fieldPath, fieldDefs, fieldDef) => {
+          return sprinkle._fillInStruct(fieldType, fieldPath, fieldDefs, fieldDef);
+        }
+      });
+      if (result.action === "cancel") {
+        throw new _types.UserCancelledError();
       }
-      return obj;
+      return result.value;
     }
-
-    //TODO: support starting with default values for arrays and allow removal of items
-    if (isArray(type)) {
-      const arr = [];
-      const itemType = type.items;
-      let addMore = true;
-      while (addMore) {
-        const itemValue = await this._fillInStruct(itemType, path.concat([`[${arr.length}]`]), defs);
-        arr.push(itemValue);
-        const continueAnswer = await (0, _prompts.select)({
-          message: `Add another item to ${path.join(".")}?`,
-          choices: [{
-            name: "Yes",
-            value: true
-          }, {
-            name: "No",
-            value: false
-          }]
-        });
-        addMore = continueAnswer;
+    if ((0, _typeGuards.isArray)(type)) {
+      // Use menu-based editing for arrays
+      const defaults = def;
+      const sprinkle = this;
+      const result = await (0, _index.promptArray)({
+        type,
+        path,
+        defs,
+        defaults,
+        fillField: async (itemType, itemPath, itemDefs, itemDef) => {
+          return sprinkle._fillInStruct(itemType, itemPath, itemDefs, itemDef);
+        }
+      });
+      if (result.action === "back") {
+        throw new _types.UserCancelledError();
       }
-      return arr;
+      return result.value;
     }
-    if (isTuple(type)) {
+    if ((0, _typeGuards.isTuple)(type)) {
       const items = type.items ?? [];
       const result = [];
       for (let i = 0; i < items.length; i++) {
@@ -1240,10 +1228,11 @@ class Sprinkle {
       }
       return result;
     }
-    throw new Error(`Unable to fill in struct for type at path ${path.join(".")}`);
+    const pathDisplay = (0, _formatting.formatPath)(path) || "root";
+    throw new Error(`Unable to fill in struct for type at path ${pathDisplay}`);
   }
   resolveType(type, path, defs) {
-    if (isRef(type) || isThis(type) || isImport(type)) {
+    if ((0, _typeGuards.isRef)(type) || (0, _typeGuards.isThis)(type) || (0, _typeGuards.isImport)(type)) {
       defs = {
         ...defs,
         ...type.$defs
@@ -1263,10 +1252,10 @@ class Sprinkle {
     if ("description" in type) {
       return type.description;
     }
-    if (isLiteral(type)) {
+    if ((0, _typeGuards.isLiteral)(type)) {
       return `${type.const}`;
     }
-    if (isObject(type)) {
+    if ((0, _typeGuards.isObject)(type)) {
       const fields = type["properties"];
       if ("type" in fields) {
         return Sprinkle.ExtractMessage(fields["type"], def);