@sundaeswap/sprinkles 0.3.0 → 0.5.0

package/src/Sprinkle/index.ts

@@ -1,189 +1,126 @@
-import { Blockfrost, type Provider } from "@blaze-cardano/query";
+import { type Provider } from "@blaze-cardano/query";
 import {
   Blaze,
-  ColdWallet,
   Core,
   HotWallet,
   type Wallet,
 } from "@blaze-cardano/sdk";
+import { CborSet, VkeyWitness, TxCBOR } from "@blaze-cardano/core";
 import {
-  CborSet,
-  VkeyWitness,
-  blake2b_256,
-  TxCBOR,
-  wordlist,
-} from "@blaze-cardano/core";
-import { confirm, input, password, search, select } from "@inquirer/prompts";
-import {
-  Kind,
-  type Static,
-  type TBigInt,
-  type TLiteral,
-  type TObject,
-  type TSchema,
-  type TString,
-  type TTuple,
-  type TUnion,
-  Type,
-  type TArray,
-  type TThis,
-  type TRef,
-  type TImport,
-  type TOptional,
-  OptionalKind,
-} from "@sinclair/typebox";
+  selectCancellable,
+  inputCancellable,
+  passwordCancellable,
+  confirmCancellable,
+  searchCancellable,
+  select,
+} from "./prompts.js";
+import { type TSchema, Type, OptionalKind } from "@sinclair/typebox";
 import * as fs from "fs";
 import * as path from "path";
 export * from "@sinclair/typebox";
 
-export type TExact<T> = T extends TSchema ? Static<T> : T;
-
-const isOptional = <T extends TSchema>(t: T): t is TOptional<T> =>
-  t[OptionalKind] === "Optional";
-const isImport = (t: TSchema): t is TImport => t[Kind] === "Import";
-const isArray = (t: TSchema): t is TArray => t[Kind] === "Array";
-const isBigInt = (t: TSchema): t is TBigInt => t[Kind] === "BigInt";
-// const isBoolean = (t: TSchema): t is TBoolean => t[Kind] === "Boolean";
-const isLiteral = (t: TSchema): t is TLiteral => t[Kind] === "Literal";
-// const isNumber = (t: TSchema): t is TNumber => t[Kind] === "Number";
-const isObject = (t: TSchema): t is TObject => t[Kind] === "Object";
-// const isRecord = (t: TSchema): t is TRecord => t[Kind] === "Record";
-const isRef = (t: TSchema): t is TRef => t[Kind] === "Ref";
-const isString = (t: TSchema): t is TString => t[Kind] === "String";
-const isThis = (t: TSchema): t is TThis => t[Kind] === "This";
-const isTuple = (t: TSchema): t is TTuple => t[Kind] === "Tuple";
-const isUnion = (t: TSchema): t is TUnion => t[Kind] === "Union";
-// const isAny = (t: TSchema): t is TAny => t[Kind] === "Any";
-
-const isSensitive = (t: TSchema): boolean =>
-  isString(t) && t.sensitive === true;
-
-export interface IEncryptionOptions {
-  encrypt: (plaintext: string) => string;
-  decrypt: (ciphertext: string) => Promise<string>;
-}
-
-export interface ISprinkleOptions {
-  encryption?: IEncryptionOptions;
-}
-
-export interface IProfileMeta {
-  name: string;
-  description?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface IProfileEntry {
-  id: string;
-  meta: IProfileMeta;
-}
-
-export interface TxDialogResult {
-  action: "submitted" | "signed" | "cancelled";
-  txId?: string; // present only if action === 'submitted'
-  tx: Core.Transaction; // the (potentially signed) transaction
-}
-
-export interface TxDialogOptions {
-  beforeSign?: () => Promise<void>;
-}
+// Re-export types from types.ts
+export type { TExact } from "./types.js";
+export type {
+  IEncryptionOptions,
+  ISprinkleOptions,
+  IProfileMeta,
+  ICurrentProfile,
+  IProfileEntry,
+  TxDialogResult,
+  TxDialogOptions,
+} from "./types.js";
+export { UserCancelledError } from "./types.js";
+import type {
+  TExact,
+  IEncryptionOptions,
+  ISprinkleOptions,
+  IProfileMeta,
+  ICurrentProfile,
+  IProfileEntry,
+  TxDialogResult,
+  TxDialogOptions,
+} from "./types.js";
+import { UserCancelledError } from "./types.js";
+
+// Re-export schemas from schemas.ts
+export {
+  NetworkSchema,
+  MultisigScriptModule,
+  MultisigScript,
+  ProviderSettingsSchema,
+  WalletSettingsSchema,
+} from "./schemas.js";
+export type { TMultisigScript } 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 {
+  NetworkSchema,
+  ProviderSettingsSchema,
+  WalletSettingsSchema,
+} from "./schemas.js";
 
-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 type TMultisigScript = TExact<typeof 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" }),
-  }),
-]);
+// 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 {
+  collectSensitivePaths,
+  getNestedValue,
+  setNestedValue,
+  bigIntReplacer,
+  bigIntReviver,
+  encryptSensitiveFields,
+  decryptSensitiveFields,
+  maskSensitiveFields,
+} from "./encryption.js";
+
+// Import tx-dialog utilities
+import {
+  getWalletPaymentKeyHash,
+  countSignatures,
+  hasVkeySigned,
+  getRequiredSigners,
+  getTxBodyHash,
+  formatHash,
+  mergeSignatures,
+} from "./tx-dialog.js";
 
 export interface IMenuAction<S extends TSchema> {
   title: string;
@@ -211,6 +148,16 @@ export class Sprinkle<S extends TSchema> {
     this.options = options ?? {};
   }
 
+  // --- Current Profile Accessor ---
+
+  get currentProfile(): ICurrentProfile | null {
+    if (!this.profileId) return null;
+    return {
+      id: this.profileId,
+      ...this.profileMeta,
+    };
+  }
+
   // --- Profile path helpers ---
 
   static sanitizeProfileId(name: string): string {
@@ -304,7 +251,7 @@ export class Sprinkle<S extends TSchema> {
         settings: settingsToSave,
         defaults: this.defaults,
       },
-      Sprinkle.bigIntReplacer,
+      bigIntReplacer,
       2,
     );
     fs.writeFileSync(filePath, jsonContent, "utf-8");
@@ -313,31 +260,54 @@ export class Sprinkle<S extends TSchema> {
   private async promptProfileMeta(
     defaultName?: string,
     defaultDescription?: string,
-  ): Promise<{ name: string; description?: string }> {
-    const name = await input({
+  ): Promise<{ name: string; description?: string } | null> {
+    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 };
   }
 
   private async createProfile(): Promise<void> {
-    const { name, description } = await this.promptProfileMeta();
+    const result = await this.promptProfileMeta();
+    if (result === null) return; // User cancelled
+    const { name, description } = 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, description, createdAt: now, 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");
   }
@@ -364,7 +334,7 @@ export class Sprinkle<S extends TSchema> {
         fs.mkdirSync(profilesDir, { recursive: true });
         fs.writeFileSync(
           Sprinkle.profilePath(this.storagePath, "default"),
-          JSON.stringify(profileData, Sprinkle.bigIntReplacer, 2),
+          JSON.stringify(profileData, bigIntReplacer, 2),
           "utf-8",
         );
         fs.writeFileSync(
@@ -409,7 +379,7 @@ export class Sprinkle<S extends TSchema> {
 
   private async selectProfile(profiles?: IProfileEntry[]): Promise<void> {
     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
@@ -418,16 +388,19 @@ export class Sprinkle<S extends TSchema> {
         value: p.id,
       })),
     });
-    await this.loadProfile(selection);
+    if (selection === null) return; // User cancelled
+    await this.loadProfile(selection as string);
   }
 
   // --- Profile management (CRUD) ---
 
   private async duplicateProfile(): Promise<void> {
-    const { name, description } = await this.promptProfileMeta(
+    const result = await this.promptProfileMeta(
       `${this.profileMeta.name} (copy)`,
       this.profileMeta.description,
     );
+    if (result === null) return; // User cancelled
+    const { name, description } = result;
     const profilesDir = Sprinkle.profilesDir(this.storagePath);
     const id = Sprinkle.findAvailableId(
       profilesDir,
@@ -442,7 +415,7 @@ export class Sprinkle<S extends TSchema> {
         settings: settingsToSave,
         defaults: this.defaults,
       },
-      Sprinkle.bigIntReplacer,
+      bigIntReplacer,
       2,
     );
     fs.writeFileSync(
@@ -454,10 +427,12 @@ export class Sprinkle<S extends TSchema> {
   }
 
   private async renameProfile(): Promise<void> {
-    const { name, description } = await this.promptProfileMeta(
+    const result = await this.promptProfileMeta(
       this.profileMeta.name,
       this.profileMeta.description,
     );
+    if (result === null) return; // User cancelled
+    const { name, description } = result;
     const newId = Sprinkle.sanitizeProfileId(name);
     const oldId = this.profileId;
 
@@ -496,31 +471,31 @@ export class Sprinkle<S extends TSchema> {
       return;
     }
 
-    const toDelete = await select({
+    const toDelete = await selectCancellable({
       message: "Select a profile to delete:",
-      choices: [
-        ...others.map((p) => ({
-          name: p.meta.description
-            ? `${p.meta.name} - ${p.meta.description}`
-            : p.meta.name,
-          value: p.id,
-        })),
-        { name: "Cancel", value: "__cancel__" },
-      ],
+      choices: others.map((p) => ({
+        name: p.meta.description
+          ? `${p.meta.name} - ${p.meta.description}`
+          : p.meta.name,
+        value: p.id,
+      })),
     });
 
-    if (toDelete === "__cancel__") return;
+    if (toDelete === null) return; // User cancelled
 
-    const profileToDelete = others.find((p) => p.id === toDelete);
-    const confirmed = await confirm({
-      message: `Delete profile "${profileToDelete?.meta.name ?? toDelete}"? This cannot be undone.`,
+    const profileId = toDelete as string;
+    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));
+      fs.unlinkSync(Sprinkle.profilePath(this.storagePath, profileId));
       console.log(
-        `Profile "${profileToDelete?.meta.name ?? toDelete}" deleted.`,
+        `Profile "${profileToDelete?.meta.name ?? profileId}" deleted.`,
       );
     }
   }
@@ -548,14 +523,27 @@ export class Sprinkle<S extends TSchema> {
       choices.push({ name: "Settings & Profiles", value: -5 });
       choices.push({ name: "Exit", 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 as number;
     if (selection === -5) {
       const settingsMenu: IMenu<S> = {
         title: "Settings & Profiles",
         items: [
+          {
+            title: "View settings",
+            action: async () => {
+              console.log(
+                JSON.stringify(this.getDisplaySettings(), bigIntReplacer, 2),
+              );
+            },
+          },
           {
             title: "Edit settings",
             action: async () => {
@@ -641,49 +629,14 @@ export class Sprinkle<S extends TSchema> {
     network: TExact<typeof NetworkSchema>,
     settings: TExact<typeof ProviderSettingsSchema>,
   ): Promise<Provider> {
-    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")) as any;
-        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 as "mainnet" | "preview" | "preprod",
-          apiKey: settings.apiKey,
-        });
-      default:
-        throw new Error("Invalid provider type");
-    }
+    return GetProviderFn(network, settings);
   }
 
   static async GetWallet(
     settings: TExact<typeof WalletSettingsSchema>,
     provider: Provider,
   ): Promise<Wallet> {
-    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(
@@ -691,9 +644,7 @@ export class Sprinkle<S extends TSchema> {
     providerSettings: TExact<typeof ProviderSettingsSchema>,
     walletSettings: TExact<typeof WalletSettingsSchema>,
   ): Promise<Blaze<Provider, Wallet>> {
-    const provider = await Sprinkle.GetProvider(network, providerSettings);
-    const wallet = await Sprinkle.GetWallet(walletSettings, provider);
-    return Blaze.from(provider, wallet);
+    return GetBlazeFn(network, providerSettings, walletSettings);
   }
 
   /**
@@ -702,39 +653,7 @@ export class Sprinkle<S extends TSchema> {
    * @returns The Bip32PrivateKey hex string for storage
    */
   private static async generateWalletFromMnemonic(): Promise<string> {
-    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<T>(opts: {
@@ -742,8 +661,8 @@ export class Sprinkle<S extends TSchema> {
     source: (
       term: string | undefined,
     ) => Promise<{ name: string; value: T }[]> | { name: string; value: T }[];
-  }): Promise<T> {
-    return search(opts) as Promise<T>;
+  }): Promise<T | null> {
+    return searchCancellable(opts) as Promise<T | null>;
   }
 
   static SettingsPath(storagePath: string): string {
@@ -775,191 +694,25 @@ export class Sprinkle<S extends TSchema> {
   }
 
   static bigIntReviver(key: string, value: unknown): unknown {
-    if (typeof value === "string" && /^\d+n$/.test(value)) {
-      return BigInt(value.slice(0, -1));
-    }
-    return value;
-  }
-
-  private static bigIntReplacer(_key: string, value: unknown): unknown {
-    return typeof value === "bigint" ? `${value.toString()}n` : value;
-  }
-
-  private static collectSensitivePaths(
-    type: TSchema,
-    prefix: string = "",
-  ): string[] {
-    const paths: string[] = [];
-    if (isObject(type)) {
-      const fields = type["properties"] as Record<string, TSchema>;
-      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;
-  }
-
-  private static getNestedValue(obj: any, path: string): unknown {
-    return path.split(".").reduce((o, k) => o?.[k], obj);
-  }
-
-  private static setNestedValue(obj: any, path: string, value: unknown): void {
-    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);
   }
 
   private encryptSettings(settings: TExact<S>): TExact<S> {
     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);
   }
 
   private async decryptSettings(settings: TExact<S>): Promise<TExact<S>> {
     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(): void {
     this.saveProfile();
   }
 
-  // --- TxDialog Helpers ---
-
-  /**
-   * Get the payment key hash from a HotWallet's first address
-   */
-  private async getWalletPaymentKeyHash(
-    wallet: HotWallet,
-  ): Promise<string | null> {
-    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
-   */
-  private countSignatures(tx: Core.Transaction): number {
-    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)
-   */
-  private hasVkeySigned(tx: Core.Transaction, vkeyHex: string): boolean {
-    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
-   */
-  private getRequiredSigners(tx: Core.Transaction): string[] {
-    const requiredSigners = tx.body().requiredSigners();
-    if (!requiredSigners) return [];
-    return Array.from(requiredSigners.values()).map((s) => s.toString());
-  }
-
-  /**
-   * Compute the transaction body hash for display
-   */
-  private getTxBodyHash(tx: Core.Transaction): string {
-    const bodyCbor = tx.body().toCbor();
-    return blake2b_256(bodyCbor);
-  }
-
-  /**
-   * Format a hash for display: first 8 chars + ... + last 8 chars
-   */
-  private formatHash(hash: string): string {
-    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.
-   */
-  private mergeSignatures(
-    target: Core.Transaction,
-    source: Core.Transaction,
-  ): number {
-    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(): TExact<S> {
+    return maskSensitiveFields(this.settings, this.type);
   }
 
   async TxDialog<P extends Provider, W extends Wallet>(
@@ -993,17 +746,17 @@ export class Sprinkle<S extends TSchema> {
 
     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}`);
@@ -1036,11 +789,19 @@ export class Sprinkle<S extends TSchema> {
       choices.push({ name: "Submit transaction", value: "submit" });
       choices.push({ 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) {
@@ -1126,7 +887,7 @@ export class Sprinkle<S extends TSchema> {
           } 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;
@@ -1159,11 +920,11 @@ export class Sprinkle<S extends TSchema> {
       }
 
       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;
         }
@@ -1174,22 +935,22 @@ export class Sprinkle<S extends TSchema> {
           );
 
           // 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;
@@ -1210,13 +971,13 @@ export class Sprinkle<S extends TSchema> {
       }
 
       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;
           }
         }
@@ -1331,7 +1092,7 @@ export class Sprinkle<S extends TSchema> {
       >;
     }
     if (isOptional(type)) {
-      const shouldSet = await select({
+      const shouldSet = await selectCancellable({
         message: Sprinkle.ExtractMessage(
           type,
           `Set value for ${path.join(".")}?`,
@@ -1342,6 +1103,9 @@ export class Sprinkle<S extends TSchema> {
         ],
         default: def !== undefined,
       });
+      if (shouldSet === null) {
+        throw new UserCancelledError();
+      }
       if (!shouldSet) {
         return undefined as TExact<U>;
       }
@@ -1360,7 +1124,7 @@ export class Sprinkle<S extends TSchema> {
           value: variant,
         });
       }
-      const selection = await select({
+      const selectionResult = await selectCancellable({
         message: Sprinkle.ExtractMessage(
           resolved,
           `Enter a choice for ${path.join(".")}`,
@@ -1368,13 +1132,17 @@ export class Sprinkle<S extends TSchema> {
         choices: choices,
         default: def ? `${def}` : undefined,
       });
+      if (selectionResult === null) {
+        throw new UserCancelledError();
+      }
+      const selection = selectionResult as TSchema;
       return this._fillInStruct(selection, path, defs) as Promise<TExact<U>>;
     }
 
     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", value: "existing" },
@@ -1382,11 +1150,19 @@ export class Sprinkle<S extends TSchema> {
           ],
         });
 
+        if (choice === null) {
+          throw new UserCancelledError();
+        }
         if (choice === "generate") {
           return Sprinkle.generateWalletFromMnemonic() as Promise<TExact<U>>;
         }
         // Fall through to password prompt for "existing" choice
-        const answer = await password({ message: "Enter your private key:" });
+        const answer = await passwordCancellable({
+          message: "Enter your private key:",
+        });
+        if (answer === null) {
+          throw new UserCancelledError();
+        }
         return answer as TExact<U>;
       }
 
@@ -1397,18 +1173,23 @@ export class Sprinkle<S extends TSchema> {
         type,
         `Enter a string for ${path.join(".")}`,
       );
-      let answer: string;
+      let answer: string | null;
       if (isSensitive(type)) {
-        answer = await password({ message });
+        answer = await passwordCancellable({ message });
       } else {
-        answer = await input({ message, default: defaultString });
-        this.defaults["string"] = answer;
+        answer = await inputCancellable({ message, default: defaultString });
+        if (answer !== null) {
+          this.defaults["string"] = answer;
+        }
+      }
+      if (answer === null) {
+        throw new UserCancelledError();
       }
       return answer as TExact<U>;
     }
 
     if (isBigInt(type)) {
-      const answer = await input({
+      const answer = await inputCancellable({
         message: Sprinkle.ExtractMessage(
           type,
           `Enter a bigint for ${path.join(".")}`,
@@ -1423,6 +1204,9 @@ export class Sprinkle<S extends TSchema> {
           }
         },
       });
+      if (answer === null) {
+        throw new UserCancelledError();
+      }
       return BigInt(answer) as TExact<U>;
     }
 
@@ -1459,14 +1243,17 @@ export class Sprinkle<S extends TSchema> {
           defs,
         );
         arr.push(itemValue);
-        const continueAnswer = await select({
+        const continueAnswer = await selectCancellable({
           message: `Add another item to ${path.join(".")}?`,
           choices: [
             { name: "Yes", value: true },
             { name: "No", value: false },
           ],
         });
-        addMore = continueAnswer;
+        if (continueAnswer === null) {
+          throw new UserCancelledError();
+        }
+        addMore = continueAnswer as boolean;
       }
       return arr as TExact<U>;
     }