@sundaeswap/sprinkles 0.8.2 → 0.9.0

package/dist/esm/Sprinkle/index.js

@@ -2,8 +2,8 @@ function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object
 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 { Core, HotWallet } from "@blaze-cardano/sdk";
-import { CborSet, VkeyWitness, TxCBOR } from "@blaze-cardano/core";
-import { selectCancellable, selectWithClear, inputCancellable, inputWithClear, passwordWithClear, confirmCancellable, searchCancellable } from "./prompts.js";
+import { CborSet, VkeyWitness, TxCBOR, wordlist } from "@blaze-cardano/core";
+import { selectCancellable, selectWithClear, inputCancellable, inputWithClear, passwordCancellable, passwordWithClear, confirmCancellable, searchCancellable, select } from "./prompts.js";
 import colors from "yoctocolors-cjs";
 import { OptionalKind } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
@@ -31,7 +31,7 @@ import { GetProvider as GetProviderFn, GetWallet as GetWalletFn, GetBlaze as Get
 export { GetProvider, GetWallet, GetBlaze } from "./wallet.js";
 
 // Import encryption utilities
-import { bigIntReplacer, bigIntReviver, encryptSensitiveFields, decryptSensitiveFields, maskSensitiveFields } from "./encryption.js";
+import { collectSensitivePaths, getNestedValue, setNestedValue, bigIntReplacer, bigIntReviver, encryptSensitiveFields, decryptSensitiveFields, maskSensitiveFields } from "./encryption.js";
 
 // Import tx-dialog utilities
 import { countSignatures, getRequiredSigners, getTxBodyHash, formatHash, mergeSignatures } from "./tx-dialog.js";
@@ -249,9 +249,133 @@ export class Sprinkle {
       }
     }
   }
+
+  // --- Importing profiles from external files ---
+
+  static globToRegex(pattern) {
+    const escaped = pattern.split("*").map(p => p.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+    return new RegExp(`^${escaped}$`);
+  }
+
+  /**
+   * Scan the current working directory for files matching `importPattern`.
+   * Returns absolute paths. Designed to surface state files committed to a
+   * project repo (e.g. `state.preview.json`) that the consumer might want
+   * to restore from.
+   */
+  findImportableProfiles(cwd = process.cwd()) {
+    if (this.options.importPattern === null) return [];
+    const pattern = this.options.importPattern ?? "state.*.json";
+    const regex = Sprinkle.globToRegex(pattern);
+    try {
+      return fs.readdirSync(cwd).filter(f => regex.test(f)).map(f => path.join(cwd, f));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Read a profile or raw-settings JSON file and save it as a new local
+   * profile. Prompts for missing sensitive fields before writing.
+   */
+  async importProfileFromFile(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content, Sprinkle.bigIntReviver);
+    let importedSettings;
+    let importedMeta;
+    let importedDefaults = {};
+    if (parsed && typeof parsed === "object" && "settings" in parsed && "meta" in parsed) {
+      const obj = parsed;
+      importedMeta = obj.meta;
+      importedSettings = obj.settings;
+      importedDefaults = obj.defaults ?? {};
+    } else {
+      importedSettings = parsed;
+    }
+
+    // If the file came from this same Sprinkle install (same encryption),
+    // decrypt sensitive fields. Otherwise we'll re-prompt for missing ones below.
+    try {
+      importedSettings = await this.decryptSettings(importedSettings);
+    } catch {
+      // ignore - encrypted with a different key, will re-prompt
+    }
+    const baseName = path.basename(filePath).replace(/\.json$/, "");
+    const meta = await this.promptProfileMeta(importedMeta?.name ?? baseName, importedMeta?.description);
+    if (meta === null) return; // user cancelled
+    const {
+      name,
+      description
+    } = meta;
+
+    // Re-prompt any sensitive fields that are missing or look encrypted
+    const sensitivePaths = collectSensitivePaths(this.type);
+    for (const p of sensitivePaths) {
+      const value = getNestedValue(importedSettings, p);
+      if (typeof value !== "string" || value.length === 0) {
+        const entered = await passwordCancellable({
+          message: `Enter value for sensitive field "${p}":`
+        });
+        if (entered === null) return; // user cancelled
+        setNestedValue(importedSettings, p, entered);
+      }
+    }
+    const profilesDir = Sprinkle.profilesDir(this.storagePath);
+    if (!fs.existsSync(profilesDir)) {
+      fs.mkdirSync(profilesDir, {
+        recursive: true
+      });
+    }
+    const id = Sprinkle.findAvailableId(profilesDir, Sprinkle.sanitizeProfileId(name));
+    const now = new Date().toISOString();
+    this.profileId = id;
+    this.profileMeta = {
+      name,
+      description,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.settings = importedSettings;
+    this.defaults = importedDefaults;
+    this.saveProfile();
+    fs.writeFileSync(Sprinkle.activeProfilePath(this.storagePath), id, "utf-8");
+  }
+  async promptImportFromCwd() {
+    const importable = this.findImportableProfiles();
+    if (importable.length === 0) return false;
+    const cancelToken = "__cancel__";
+    const choices = [...importable.map(f => ({
+      name: `Import ${path.basename(f)}`,
+      value: f
+    })), {
+      name: "Enter a different path...",
+      value: "__custom__"
+    }, {
+      name: "Skip import",
+      value: cancelToken
+    }];
+    const choice = await select({
+      message: "Found importable state file(s) in this directory. Restore from one?",
+      choices
+    });
+    if (choice === null || choice === cancelToken) return false;
+    let filePath = choice;
+    if (choice === "__custom__") {
+      const entered = await inputCancellable({
+        message: "Path to state file:",
+        validate: v => v.trim().length > 0 ? true : "Path cannot be empty"
+      });
+      if (entered === null) return false;
+      filePath = entered;
+    }
+    await this.importProfileFromFile(filePath);
+    return true;
+  }
   async selectOrCreateProfile() {
     const profiles = this.scanProfiles();
     if (profiles.length === 0) {
+      const imported = await this.promptImportFromCwd();
+      if (imported) return;
       await this.createProfile();
       return;
     }
@@ -374,8 +498,318 @@ export class Sprinkle {
 
   // --- Menu ---
 
+  async importProfileInteractive() {
+    const importable = this.findImportableProfiles();
+    const customToken = "__custom__";
+    let filePath;
+    if (importable.length > 0) {
+      const choice = await select({
+        message: "Select a file to import:",
+        choices: [...importable.map(f => ({
+          name: path.basename(f),
+          value: f
+        })), {
+          name: "Enter a different path...",
+          value: customToken
+        }]
+      });
+      if (choice === null) return; // user cancelled
+      if (choice === customToken) {
+        const entered = await inputCancellable({
+          message: "Path to state file:",
+          validate: v => v.trim().length > 0 ? true : "Path cannot be empty"
+        });
+        if (entered === null) return;
+        filePath = entered;
+      } else {
+        filePath = choice;
+      }
+    } else {
+      const entered = await inputCancellable({
+        message: "Path to state file:",
+        validate: v => v.trim().length > 0 ? true : "Path cannot be empty"
+      });
+      if (entered === null) return;
+      filePath = entered;
+    }
+    try {
+      await this.importProfileFromFile(filePath);
+      console.log(`Imported profile "${this.profileMeta.name}".`);
+    } catch (error) {
+      console.error(`Import failed: ${error.message}`);
+    }
+  }
+  buildSettingsMenu() {
+    return {
+      title: "Settings & Profiles",
+      items: [{
+        title: "View settings",
+        action: async () => {
+          const jsonStr = JSON.stringify(this.getDisplaySettings(), bigIntReplacer, 2);
+          const jsonLines = jsonStr.split("\n").length;
+          console.log(jsonStr);
+
+          // Wait for user to press Enter
+          await 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 () => {
+          try {
+            this.settings = await this.EditStruct(this.type, this.settings);
+            this.saveSettings();
+          } catch (e) {
+            if (e instanceof UserCancelledError) {
+              return; // User cancelled, return to menu
+            }
+            throw e;
+          }
+        }
+      }, {
+        title: "Switch profile",
+        action: async () => {
+          this.saveSettings();
+          const profiles = this.scanProfiles();
+          if (profiles.length <= 1) {
+            console.log("No other profiles to switch to. Create a new one first.");
+          } else {
+            await this.selectProfile(profiles);
+          }
+        }
+      }, {
+        title: "Create new profile",
+        action: async () => {
+          await this.createProfile();
+        }
+      }, {
+        title: "Duplicate current profile",
+        action: async () => {
+          await this.duplicateProfile();
+        }
+      }, {
+        title: "Rename current profile",
+        action: async () => {
+          await this.renameProfile();
+        }
+      }, {
+        title: "Delete a profile",
+        action: async () => {
+          await this.deleteProfile();
+        }
+      }, {
+        title: "Import profile from file",
+        action: async () => {
+          await this.importProfileInteractive();
+        }
+      }, {
+        title: "Addressbook",
+        items: [{
+          title: "View entries",
+          action: async () => {
+            const entries = Object.entries(this.addressbook);
+            if (entries.length === 0) {
+              console.log("Addressbook is empty.");
+            } else {
+              for (const [name, ms] of entries) {
+                const json = JSON.stringify(ms, bigIntReplacer, 2);
+                let hashStr = "unknown";
+                try {
+                  hashStr = toNativeScript(ms).hash();
+                } catch {/* skip */}
+                console.log(colors.bold(name) + "  " + colors.dim(hashStr));
+                console.log(json);
+                console.log();
+              }
+            }
+            await selectWithClear({
+              message: "Press Enter to continue...",
+              choices: [{
+                name: "Continue",
+                value: "continue"
+              }]
+            });
+          }
+        }, {
+          title: "Add entry",
+          action: async () => {
+            const name = await inputCancellable({
+              message: "Entry name:",
+              validate: v => v.trim().length > 0 ? true : "Name cannot be empty"
+            });
+            if (name === null) return;
+            if (this.addressbook[name]) {
+              const overwrite = await confirmCancellable({
+                message: `Entry "${name}" already exists. Overwrite?`,
+                default: false
+              });
+              if (!overwrite) return;
+            }
+            try {
+              const script = await this.FillInStruct(MultisigScriptSchema);
+              this.addressbook[name] = script;
+              this.saveSettings();
+              console.log(`Added "${name}" to addressbook.`);
+            } catch (e) {
+              if (e instanceof UserCancelledError) return;
+              throw e;
+            }
+          }
+        }, {
+          title: "Edit entry",
+          action: async () => {
+            const entries = Object.keys(this.addressbook);
+            if (entries.length === 0) {
+              console.log("Addressbook is empty.");
+              return;
+            }
+            const selected = await selectCancellable({
+              message: "Select entry to edit:",
+              choices: entries.map(n => ({
+                name: n,
+                value: n
+              }))
+            });
+            if (selected === null) return;
+            const editName = selected;
+            try {
+              const updated = await this.EditStruct(MultisigScriptSchema, this.addressbook[editName]);
+              this.addressbook[editName] = updated;
+              this.saveSettings();
+              console.log(`Updated "${editName}".`);
+            } catch (e) {
+              if (e instanceof UserCancelledError) return;
+              throw e;
+            }
+          }
+        }, {
+          title: "Delete entry",
+          action: async () => {
+            const entries = Object.keys(this.addressbook);
+            if (entries.length === 0) {
+              console.log("Addressbook is empty.");
+              return;
+            }
+            const delSelected = await selectCancellable({
+              message: "Select entry to delete:",
+              choices: entries.map(n => ({
+                name: n,
+                value: n
+              }))
+            });
+            if (delSelected === null) return;
+            const delName = delSelected;
+            const confirmed = await confirmCancellable({
+              message: `Delete "${delName}"?`,
+              default: false
+            });
+            if (!confirmed) return;
+            delete this.addressbook[delName];
+            this.saveSettings();
+            console.log(`Deleted "${delName}".`);
+          }
+        }]
+      }]
+    };
+  }
   async showMenu(menu) {
-    return this._showMenu(menu, true, [menu.title]);
+    return this._searchMenu(menu);
+  }
+
+  // --- Flat search-based top-level menu ---
+
+  _flattenLeaves(menu, prefix, beforeShowChain, isRoot) {
+    // Root's title is omitted from breadcrumbs (no "Main Menu › " prefix on
+    // every leaf). Root's beforeShow is fired by the search loop, not as part
+    // of the leaf chain (otherwise it would fire twice).
+    const chain = !isRoot && menu.beforeShow ? [...beforeShowChain, menu.beforeShow] : beforeShowChain;
+    const breadcrumbPrefix = isRoot ? prefix : [...prefix, menu.title];
+    const leaves = [];
+    for (const item of menu.items) {
+      if ("action" in item) {
+        leaves.push({
+          breadcrumb: [...breadcrumbPrefix, item.title].join(" › "),
+          leafTitle: item.title,
+          action: item.action,
+          beforeShowChain: chain
+        });
+      } else {
+        leaves.push(...this._flattenLeaves(item, breadcrumbPrefix, chain, false));
+      }
+    }
+    return leaves;
+  }
+  static _scoreLeaf(leaf, tokens) {
+    if (tokens.length === 0) return 1;
+    const crumbLower = leaf.breadcrumb.toLowerCase();
+    const titleLower = leaf.leafTitle.toLowerCase();
+    let score = 0;
+    for (const t of tokens) {
+      if (!crumbLower.includes(t)) return 0; // require every token
+      if (titleLower.includes(t)) {
+        score += 3; // matches in the leaf title outrank ancestor matches
+      } else {
+        score += 1;
+      }
+    }
+    return score;
+  }
+  _filterLeaves(leaves, term) {
+    const trimmed = term.trim();
+    if (!trimmed) return leaves;
+    const tokens = trimmed.toLowerCase().split(/\s+/);
+    return leaves.map(leaf => ({
+      leaf,
+      score: Sprinkle._scoreLeaf(leaf, tokens)
+    })).filter(x => x.score > 0).sort((a, b) => b.score - a.score).map(x => x.leaf);
+  }
+  async _searchMenu(menu) {
+    const EXIT_TITLE = "Exit";
+    while (true) {
+      // Root beforeShow fires once per iteration so consumers can refresh any
+      // dynamic state before the search prompt is built.
+      if (menu.beforeShow) {
+        await menu.beforeShow(this);
+      }
+      const userLeaves = this._flattenLeaves(menu, [], [], true);
+      const settingsLeaves = this._flattenLeaves(this.buildSettingsMenu(), [], [], false);
+      const exitLeaf = {
+        breadcrumb: EXIT_TITLE,
+        leafTitle: EXIT_TITLE,
+        action: async () => {},
+        beforeShowChain: [],
+        isExit: true
+      };
+      const allLeaves = [...userLeaves, ...settingsLeaves, exitLeaf];
+      const selected = await searchCancellable({
+        message: "What would you like to do?",
+        source: async term => {
+          return this._filterLeaves(allLeaves, term ?? "").map(leaf => ({
+            name: leaf.breadcrumb,
+            value: leaf
+          }));
+        }
+      });
+      if (selected === null || selected.isExit) return;
+
+      // Fire submenu beforeShow hooks along the path to the selected leaf
+      for (const beforeShow of selected.beforeShowChain) {
+        await beforeShow(this);
+      }
+      const result = await selected.action(this);
+      if (result instanceof Sprinkle) {
+        this.settings = result.settings;
+        this.saveSettings();
+      }
+    }
   }
   async _showMenu(menu, main, path, clearPrevious = false) {
     // Clear previous breadcrumb if coming back from action/submenu
@@ -484,181 +918,7 @@ export class Sprinkle {
       return;
     }
     if (selection === -5) {
-      const settingsMenu = {
-        title: "Settings & Profiles",
-        items: [{
-          title: "View settings",
-          action: async () => {
-            const jsonStr = JSON.stringify(this.getDisplaySettings(), bigIntReplacer, 2);
-            const jsonLines = jsonStr.split("\n").length;
-            console.log(jsonStr);
-
-            // Wait for user to press Enter
-            await 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 () => {
-            try {
-              this.settings = await this.EditStruct(this.type, this.settings);
-              this.saveSettings();
-            } catch (e) {
-              if (e instanceof UserCancelledError) {
-                return; // User cancelled, return to menu
-              }
-              throw e;
-            }
-          }
-        }, {
-          title: "Switch profile",
-          action: async () => {
-            this.saveSettings();
-            const profiles = this.scanProfiles();
-            if (profiles.length <= 1) {
-              console.log("No other profiles to switch to. Create a new one first.");
-            } else {
-              await this.selectProfile(profiles);
-            }
-          }
-        }, {
-          title: "Create new profile",
-          action: async () => {
-            await this.createProfile();
-          }
-        }, {
-          title: "Duplicate current profile",
-          action: async () => {
-            await this.duplicateProfile();
-          }
-        }, {
-          title: "Rename current profile",
-          action: async () => {
-            await this.renameProfile();
-          }
-        }, {
-          title: "Delete a profile",
-          action: async () => {
-            await this.deleteProfile();
-          }
-        }, {
-          title: "Addressbook",
-          items: [{
-            title: "View entries",
-            action: async () => {
-              const entries = Object.entries(this.addressbook);
-              if (entries.length === 0) {
-                console.log("Addressbook is empty.");
-              } else {
-                for (const [name, ms] of entries) {
-                  const json = JSON.stringify(ms, bigIntReplacer, 2);
-                  let hashStr = "unknown";
-                  try {
-                    hashStr = toNativeScript(ms).hash();
-                  } catch {/* skip */}
-                  console.log(colors.bold(name) + "  " + colors.dim(hashStr));
-                  console.log(json);
-                  console.log();
-                }
-              }
-              await selectWithClear({
-                message: "Press Enter to continue...",
-                choices: [{
-                  name: "Continue",
-                  value: "continue"
-                }]
-              });
-            }
-          }, {
-            title: "Add entry",
-            action: async () => {
-              const name = await inputCancellable({
-                message: "Entry name:",
-                validate: v => v.trim().length > 0 ? true : "Name cannot be empty"
-              });
-              if (name === null) return;
-              if (this.addressbook[name]) {
-                const overwrite = await confirmCancellable({
-                  message: `Entry "${name}" already exists. Overwrite?`,
-                  default: false
-                });
-                if (!overwrite) return;
-              }
-              try {
-                const script = await this.FillInStruct(MultisigScriptSchema);
-                this.addressbook[name] = script;
-                this.saveSettings();
-                console.log(`Added "${name}" to addressbook.`);
-              } catch (e) {
-                if (e instanceof UserCancelledError) return;
-                throw e;
-              }
-            }
-          }, {
-            title: "Edit entry",
-            action: async () => {
-              const entries = Object.keys(this.addressbook);
-              if (entries.length === 0) {
-                console.log("Addressbook is empty.");
-                return;
-              }
-              const selected = await selectCancellable({
-                message: "Select entry to edit:",
-                choices: entries.map(n => ({
-                  name: n,
-                  value: n
-                }))
-              });
-              if (selected === null) return;
-              const editName = selected;
-              try {
-                const updated = await this.EditStruct(MultisigScriptSchema, this.addressbook[editName]);
-                this.addressbook[editName] = updated;
-                this.saveSettings();
-                console.log(`Updated "${editName}".`);
-              } catch (e) {
-                if (e instanceof UserCancelledError) return;
-                throw e;
-              }
-            }
-          }, {
-            title: "Delete entry",
-            action: async () => {
-              const entries = Object.keys(this.addressbook);
-              if (entries.length === 0) {
-                console.log("Addressbook is empty.");
-                return;
-              }
-              const delSelected = await selectCancellable({
-                message: "Select entry to delete:",
-                choices: entries.map(n => ({
-                  name: n,
-                  value: n
-                }))
-              });
-              if (delSelected === null) return;
-              const delName = delSelected;
-              const confirmed = await confirmCancellable({
-                message: `Delete "${delName}"?`,
-                default: false
-              });
-              if (!confirmed) return;
-              delete this.addressbook[delName];
-              this.saveSettings();
-              console.log(`Deleted "${delName}".`);
-            }
-          }]
-        }]
-      };
-      await this._showMenu(settingsMenu, false, [...path, "Settings & Profiles"], true);
+      await this._showMenu(this.buildSettingsMenu(), false, [...path, "Settings & Profiles"], true);
       await this._showMenu(menu, main, path, true);
       return;
     }
@@ -700,6 +960,37 @@ export class Sprinkle {
     return GetBlazeFn(network, providerSettings, walletSettings);
   }
 
+  /**
+   * Derive a Bip32 private key hex from a BIP39 mnemonic phrase.
+   * Accepts 12, 15, or 24 word phrases.
+   */
+  static privateKeyFromMnemonic(phrase) {
+    const normalized = phrase.trim().toLowerCase().split(/\s+/).join(" ");
+    const words = normalized.split(" ");
+    if (![12, 15, 24].includes(words.length)) {
+      throw new Error(`Expected 12, 15, or 24 words but got ${words.length}.`);
+    }
+    const entropy = Core.mnemonicToEntropy(normalized, wordlist);
+    const masterKey = Core.Bip32PrivateKey.fromBip39Entropy(Buffer.from(entropy), "");
+    return masterKey.hex();
+  }
+
+  /**
+   * Prompt the user for a recovery phrase and derive the Bip32 private key hex.
+   */
+  static async importWalletFromMnemonic() {
+    const phrase = await passwordCancellable({
+      message: "Enter your recovery phrase (12, 15, or 24 words):"
+    });
+    if (phrase === null) {
+      throw new UserCancelledError();
+    }
+    if (phrase.trim().length === 0) {
+      throw new Error("Recovery phrase cannot be empty");
+    }
+    return Sprinkle.privateKeyFromMnemonic(phrase);
+  }
+
   /**
    * Generates a new wallet from a BIP39 mnemonic phrase.
    * Displays the 24-word recovery phrase and requires user confirmation.
@@ -1280,13 +1571,16 @@ export class Sprinkle {
       return this._fillInStruct(selection, path, defs, matchedDef);
     }
     if (isString(type)) {
-      // Special handling for hot wallet private key - offer generation option
+      // Special handling for hot wallet private key - offer multiple sources
       if (type.title === "Hot Wallet Private Key") {
         const choice = await selectWithClear({
           message: "Hot wallet setup:",
           choices: [{
             name: "Enter existing private key",
             value: "existing"
+          }, {
+            name: "Import from recovery phrase",
+            value: "mnemonic"
           }, {
             name: "Generate new wallet",
             value: "generate"
@@ -1298,6 +1592,9 @@ export class Sprinkle {
         if (choice === "generate") {
           return Sprinkle.generateWalletFromMnemonic();
         }
+        if (choice === "mnemonic") {
+          return Sprinkle.importWalletFromMnemonic();
+        }
         // Fall through to password prompt for "existing" choice
         const answer = await passwordWithClear({
           message: "Enter your private key:"