@sundaeswap/sprinkles 0.3.0 → 0.5.0

package/dist/esm/Sprinkle/index.js

@@ -1,106 +1,36 @@
 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); }
-import { Blockfrost } from "@blaze-cardano/query";
-import { Blaze, ColdWallet, Core, HotWallet } from "@blaze-cardano/sdk";
-import { CborSet, VkeyWitness, blake2b_256, TxCBOR, wordlist } from "@blaze-cardano/core";
-import { confirm, input, password, search, select } from "@inquirer/prompts";
-import { Kind, Type, OptionalKind } from "@sinclair/typebox";
+import { Core, HotWallet } from "@blaze-cardano/sdk";
+import { CborSet, VkeyWitness, TxCBOR } from "@blaze-cardano/core";
+import { selectCancellable, inputCancellable, passwordCancellable, confirmCancellable, searchCancellable } from "./prompts.js";
+import { OptionalKind } from "@sinclair/typebox";
 import * as fs from "fs";
 import * as path from "path";
 export * from "@sinclair/typebox";
-const isOptional = t => t[OptionalKind] === "Optional";
-const isImport = t => t[Kind] === "Import";
-const isArray = t => t[Kind] === "Array";
-const isBigInt = t => t[Kind] === "BigInt";
-// const isBoolean = (t: TSchema): t is TBoolean => t[Kind] === "Boolean";
-const isLiteral = t => t[Kind] === "Literal";
-// const isNumber = (t: TSchema): t is TNumber => t[Kind] === "Number";
-const isObject = t => t[Kind] === "Object";
-// const isRecord = (t: TSchema): t is TRecord => t[Kind] === "Record";
-const isRef = t => t[Kind] === "Ref";
-const isString = t => t[Kind] === "String";
-const isThis = t => t[Kind] === "This";
-const isTuple = t => t[Kind] === "Tuple";
-const isUnion = t => t[Kind] === "Union";
-// const isAny = (t: TSchema): t is TAny => t[Kind] === "Any";
 
-const isSensitive = t => isString(t) && t.sensitive === true;
-export const NetworkSchema = Type.Union([Type.Literal("mainnet"), Type.Literal("preview"), Type.Literal("preprod")]);
-export const MultisigScriptModule = Type.Module({
-  MultisigScript: Type.Union([Type.Object({
-    Signature: Type.Object({
-      key_hash: Type.String()
-    }, {
-      ctor: 0n
-    })
-  }), Type.Object({
-    AllOf: Type.Object({
-      scripts: Type.Array(Type.Ref("MultisigScript"))
-    }, {
-      ctor: 1n
-    })
-  }), Type.Object({
-    AnyOf: Type.Object({
-      scripts: Type.Array(Type.Ref("MultisigScript"))
-    }, {
-      ctor: 2n
-    })
-  }), Type.Object({
-    AtLeast: Type.Object({
-      required: Type.BigInt(),
-      scripts: Type.Array(Type.Ref("MultisigScript"))
-    }, {
-      ctor: 3n
-    })
-  }), Type.Object({
-    Before: Type.Object({
-      time: Type.BigInt()
-    }, {
-      ctor: 4n
-    })
-  }), Type.Object({
-    After: Type.Object({
-      time: Type.BigInt()
-    }, {
-      ctor: 5n
-    })
-  }), Type.Object({
-    Script: Type.Object({
-      script_hash: Type.String()
-    }, {
-      ctor: 6n
-    })
-  })])
-});
-export const MultisigScript = MultisigScriptModule.Import("MultisigScript");
-export const ProviderSettingsSchema = Type.Union([Type.Object({
-  type: Type.Literal("blockfrost"),
-  projectId: Type.String({
-    minLength: 1,
-    title: "Blockfrost Project ID"
-  })
-}), Type.Object({
-  type: Type.Literal("maestro"),
-  apiKey: Type.String({
-    minLength: 1,
-    title: "Maestro API Key"
-  })
-})]);
-export const WalletSettingsSchema = Type.Union([Type.Object({
-  type: Type.Literal("hot"),
-  privateKey: Type.String({
-    minLength: 1,
-    title: "Hot Wallet Private Key",
-    sensitive: true
-  })
-}), Type.Object({
-  type: Type.Literal("cold"),
-  address: Type.String({
-    minLength: 1,
-    title: "Cold Wallet Address"
-  })
-})]);
+// Re-export types from types.ts
+
+export { UserCancelledError } from "./types.js";
+import { UserCancelledError } from "./types.js";
+
+// Re-export schemas from schemas.ts
+export { NetworkSchema, MultisigScriptModule, MultisigScript, ProviderSettingsSchema, WalletSettingsSchema } from "./schemas.js";
+// Import and re-export type guards
+import { isOptional, isImport, isArray, isBigInt, isLiteral, isObject, isRef, isString, isThis, isTuple, isUnion, isSensitive } from "./type-guards.js";
+export { isOptional, isImport, isArray, isBigInt, isLiteral, isObject, isRef, isString, isThis, isTuple, isUnion, isSensitive } from "./type-guards.js";
+
+// Import schemas for use in this file
+
+// Import and re-export wallet utilities
+import { GetProvider as GetProviderFn, GetWallet as GetWalletFn, GetBlaze as GetBlazeFn, generateWalletFromMnemonic } from "./wallet.js";
+export { GetProvider, GetWallet, GetBlaze } from "./wallet.js";
+
+// Import encryption utilities
+import { bigIntReplacer, bigIntReviver, encryptSensitiveFields, decryptSensitiveFields, maskSensitiveFields } from "./encryption.js";
+
+// Import tx-dialog utilities
+import { countSignatures, getRequiredSigners, getTxBodyHash, formatHash, mergeSignatures } from "./tx-dialog.js";
 export class Sprinkle {
   constructor(type, storagePath, options) {
     _defineProperty(this, "storagePath", void 0);
@@ -119,6 +49,16 @@ export class Sprinkle {
     this.options = options ?? {};
   }
 
+  // --- Current Profile Accessor ---
+
+  get currentProfile() {
+    if (!this.profileId) return null;
+    return {
+      id: this.profileId,
+      ...this.profileMeta
+    };
+  }
+
   // --- Profile path helpers ---
 
   static sanitizeProfileId(name) {
@@ -197,32 +137,42 @@ export class Sprinkle {
       meta: this.profileMeta,
       settings: settingsToSave,
       defaults: this.defaults
-    }, Sprinkle.bigIntReplacer, 2);
+    }, bigIntReplacer, 2);
     fs.writeFileSync(filePath, jsonContent, "utf-8");
   }
   async promptProfileMeta(defaultName, defaultDescription) {
-    const name = await input({
+    const name = await inputCancellable({
       message: "Profile name:",
       default: defaultName,
       validate: v => v.trim().length > 0 ? true : "Name cannot be empty"
     });
-    const description = await input({
+    if (name === null) return null; // User cancelled
+    const description = await 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,
@@ -231,7 +181,19 @@ export 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 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");
   }
@@ -256,7 +218,7 @@ export 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, bigIntReplacer, 2), "utf-8");
         fs.writeFileSync(Sprinkle.activeProfilePath(this.storagePath), "default", "utf-8");
         // Backup legacy file
         fs.renameSync(legacyPath, `${legacyPath}.bak`);
@@ -293,23 +255,26 @@ export class Sprinkle {
   }
   async selectProfile(profiles) {
     const available = profiles ?? this.scanProfiles();
-    const selection = await select({
+    const selection = await 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();
@@ -324,15 +289,17 @@ export class Sprinkle {
       },
       settings: settingsToSave,
       defaults: this.defaults
-    }, Sprinkle.bigIntReplacer, 2);
+    }, 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;
@@ -360,25 +327,26 @@ export class Sprinkle {
       console.log("Cannot delete the only profile.");
       return;
     }
-    const toDelete = await select({
+    const toDelete = await 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 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 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.`);
     }
   }
 
@@ -419,14 +387,24 @@ export class Sprinkle {
         value: -1
       });
     }
-    const selection = await select({
+    const selectionResult = await selectCancellable({
       message: "Select an option:",
       choices: choices
     });
+    // Handle escape (null) as Back
+    if (selectionResult === null) {
+      return;
+    }
+    const selection = selectionResult;
     if (selection === -5) {
       const settingsMenu = {
         title: "Settings & Profiles",
         items: [{
+          title: "View settings",
+          action: async () => {
+            console.log(JSON.stringify(this.getDisplaySettings(), bigIntReplacer, 2));
+          }
+        }, {
           title: "Edit settings",
           action: async () => {
             this.settings = await this.EditStruct(this.type, this.settings);
@@ -494,40 +472,13 @@ export class Sprinkle {
     return sprinkle;
   }
   static async GetProvider(network, settings) {
-    switch (settings.type) {
-      case "blockfrost":
-        return new 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 import("@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 GetProviderFn(network, settings);
   }
   static async GetWallet(settings, provider) {
-    switch (settings.type) {
-      case "hot":
-        return HotWallet.fromMasterkey(Core.Bip32PrivateKeyHex(settings.privateKey), provider, provider.network);
-      case "cold":
-        return new ColdWallet(Core.Address.fromBech32(settings.address), provider.network, provider);
-      default:
-        throw new Error("Invalid wallet type");
-    }
+    return GetWalletFn(settings, provider);
   }
   static async GetBlaze(network, providerSettings, walletSettings) {
-    const provider = await Sprinkle.GetProvider(network, providerSettings);
-    const wallet = await Sprinkle.GetWallet(walletSettings, provider);
-    return Blaze.from(provider, wallet);
+    return GetBlazeFn(network, providerSettings, walletSettings);
   }
 
   /**
@@ -536,30 +487,10 @@ export class Sprinkle {
    * @returns The Bip32PrivateKey hex string for storage
    */
   static async generateWalletFromMnemonic() {
-    const mnemonic = Core.generateMnemonic(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 confirm({
-      message: "Have you saved your recovery phrase?",
-      default: false
-    });
-    if (!confirmed) {
-      throw new Error("Wallet generation cancelled - recovery phrase not saved");
-    }
-    const entropy = Core.mnemonicToEntropy(mnemonic, wordlist);
-    const masterKey = Core.Bip32PrivateKey.fromBip39Entropy(Buffer.from(entropy), "");
-    return masterKey.hex();
+    return generateWalletFromMnemonic();
   }
   static async SearchSelect(opts) {
-    return search(opts);
+    return searchCancellable(opts);
   }
   static SettingsPath(storagePath) {
     return `${storagePath}${path.sep}settings.json`;
@@ -583,155 +514,21 @@ export 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 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 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 decryptSensitiveFields(settings, this.type, this.options.encryption);
   }
   saveSettings() {
     this.saveProfile();
   }
-
-  // --- 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 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(CborSet.fromCore([...targetVkeys, ...newVkeys], VkeyWitness.fromCore));
-    target.setWitnessSet(targetWs);
-    return newVkeys.length;
+  getDisplaySettings() {
+    return maskSensitiveFields(this.settings, this.type);
   }
   async TxDialog(blaze, tx, opts) {
     let currentTx = tx;
@@ -759,16 +556,16 @@ export class Sprinkle {
     }
     while (true) {
       // Display transaction status
-      const txHash = this.getTxBodyHash(currentTx);
-      const sigCount = this.countSignatures(currentTx);
-      const requiredSigners = this.getRequiredSigners(currentTx);
+      const txHash = getTxBodyHash(currentTx);
+      const sigCount = countSignatures(currentTx);
+      const requiredSigners = getRequiredSigners(currentTx);
       console.log("");
-      console.log(`Transaction: ${this.formatHash(txHash)}`);
+      console.log(`Transaction: ${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(`  - ${formatHash(signer)}`);
         }
       } else {
         console.log(`Signatures: ${sigCount}`);
@@ -818,11 +615,25 @@ export class Sprinkle {
         name: "Cancel",
         value: "cancel"
       });
-      const selection = await select({
+      const selection = await selectCancellable({
         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) {
@@ -888,7 +699,7 @@ export 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 = mergeSignatures(currentTx, signedTx);
             if (added > 0) {
               console.log(`Added ${added} signature(s).`);
               hasSignedThisSession = true;
@@ -920,10 +731,10 @@ export class Sprinkle {
         continue;
       }
       if (selection === "import") {
-        const cborInput = await input({
+        const cborInput = await inputCancellable({
           message: "Paste transaction CBOR (hex):"
         });
-        if (!cborInput || cborInput.trim() === "") {
+        if (cborInput === null || cborInput.trim() === "") {
           console.log("No CBOR provided.");
           continue;
         }
@@ -931,21 +742,21 @@ export class Sprinkle {
           const importedTx = Core.Transaction.fromCbor(TxCBOR(cborInput.trim()));
 
           // Validate body hash matches
-          const currentHash = this.getTxBodyHash(currentTx);
-          const importedHash = this.getTxBodyHash(importedTx);
+          const currentHash = getTxBodyHash(currentTx);
+          const importedHash = getTxBodyHash(importedTx);
           if (currentHash !== importedHash) {
-            const proceed = await confirm({
-              message: `Warning: Imported transaction has different body hash.\nCurrent:  ${this.formatHash(currentHash)}\nImported: ${this.formatHash(importedHash)}\nProceed anyway?`,
+            const proceed = await confirmCancellable({
+              message: `Warning: Imported transaction has different body hash.\nCurrent:  ${formatHash(currentHash)}\nImported: ${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 = mergeSignatures(currentTx, importedTx);
           const sourceVkeys = importedTx.witnessSet().vkeys();
           const sourceCount = sourceVkeys ? sourceVkeys.size() : 0;
           const skipped = sourceCount - added;
@@ -964,13 +775,13 @@ export class Sprinkle {
         continue;
       }
       if (selection === "submit") {
-        const sigCount = this.countSignatures(currentTx);
+        const sigCount = countSignatures(currentTx);
         if (sigCount === 0) {
-          const proceed = await confirm({
+          const proceed = await confirmCancellable({
             message: "Warning: Transaction has no signatures. Submit anyway?",
             default: false
           });
-          if (!proceed) {
+          if (proceed === null || !proceed) {
             continue;
           }
         }
@@ -1059,7 +870,7 @@ export class Sprinkle {
       return this._fillInStruct(resolvedType, path, defs, def);
     }
     if (isOptional(type)) {
-      const shouldSet = await select({
+      const shouldSet = await selectCancellable({
         message: Sprinkle.ExtractMessage(type, `Set value for ${path.join(".")}?`),
         choices: [{
           name: "Yes",
@@ -1070,6 +881,9 @@ export class Sprinkle {
         }],
         default: def !== undefined
       });
+      if (shouldSet === null) {
+        throw new UserCancelledError();
+      }
       if (!shouldSet) {
         return undefined;
       }
@@ -1089,17 +903,21 @@ export class Sprinkle {
           value: variant
         });
       }
-      const selection = await select({
+      const selectionResult = await selectCancellable({
         message: Sprinkle.ExtractMessage(resolved, `Enter a choice for ${path.join(".")}`),
         choices: choices,
         default: def ? `${def}` : undefined
       });
+      if (selectionResult === null) {
+        throw new UserCancelledError();
+      }
+      const selection = selectionResult;
       return this._fillInStruct(selection, path, defs);
     }
     if (isString(type)) {
       // Special handling for hot wallet private key - offer generation option
       if (type.title === "Hot Wallet Private Key") {
-        const choice = await select({
+        const choice = await selectCancellable({
           message: "Hot wallet setup:",
           choices: [{
             name: "Enter existing private key",
@@ -1109,33 +927,44 @@ export class Sprinkle {
             value: "generate"
           }]
         });
+        if (choice === null) {
+          throw new UserCancelledError();
+        }
         if (choice === "generate") {
           return Sprinkle.generateWalletFromMnemonic();
         }
         // Fall through to password prompt for "existing" choice
-        const answer = await password({
+        const answer = await passwordCancellable({
           message: "Enter your private key:"
         });
+        if (answer === null) {
+          throw new UserCancelledError();
+        }
         return answer;
       }
       const defaultString = def ? def : this.defaults["string"];
       const message = Sprinkle.ExtractMessage(type, `Enter a string for ${path.join(".")}`);
       let answer;
       if (isSensitive(type)) {
-        answer = await password({
+        answer = await passwordCancellable({
           message
         });
       } else {
-        answer = await input({
+        answer = await inputCancellable({
           message,
           default: defaultString
         });
-        this.defaults["string"] = answer;
+        if (answer !== null) {
+          this.defaults["string"] = answer;
+        }
+      }
+      if (answer === null) {
+        throw new UserCancelledError();
       }
       return answer;
     }
     if (isBigInt(type)) {
-      const answer = await input({
+      const answer = await inputCancellable({
         message: Sprinkle.ExtractMessage(type, `Enter a bigint for ${path.join(".")}`),
         default: def ? def.toString() : undefined,
         validate: s => {
@@ -1147,6 +976,9 @@ export class Sprinkle {
           }
         }
       });
+      if (answer === null) {
+        throw new UserCancelledError();
+      }
       return BigInt(answer);
     }
     if (isLiteral(type)) {
@@ -1170,7 +1002,7 @@ export class Sprinkle {
       while (addMore) {
         const itemValue = await this._fillInStruct(itemType, path.concat([`[${arr.length}]`]), defs);
         arr.push(itemValue);
-        const continueAnswer = await select({
+        const continueAnswer = await selectCancellable({
           message: `Add another item to ${path.join(".")}?`,
           choices: [{
             name: "Yes",
@@ -1180,6 +1012,9 @@ export class Sprinkle {
             value: false
           }]
         });
+        if (continueAnswer === null) {
+          throw new UserCancelledError();
+        }
         addMore = continueAnswer;
       }
       return arr;