@sundaeswap/sprinkles 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaeswap/sprinkles",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "A TypeScript library for building interactive CLI menus and TUI applications with TypeBox schema validation",
   "type": "module",
   "main": "./dist/cjs/index.js",

package/src/Sprinkle/__tests__/fill-in-struct.test.ts

@@ -1,13 +1,17 @@
-import { describe, expect, test, mock, beforeEach } from "bun:test";
-import { Sprinkle, Type } from "../index.js";
+import { describe, expect, test, mock, beforeEach, spyOn } from "bun:test";
+import { Sprinkle, Type, WalletSettingsSchema } from "../index.js";
 
 // Mock @inquirer/prompts
 const mockSelect = mock();
 const mockInput = mock();
+const mockPassword = mock();
+const mockConfirm = mock();
 
 mock.module("@inquirer/prompts", () => ({
   select: mockSelect,
   input: mockInput,
+  password: mockPassword,
+  confirm: mockConfirm,
 }));
 
 describe("FillInStruct", () => {
@@ -204,4 +208,53 @@ describe("FillInStruct", () => {
     const result = await sprinkle.FillInStruct(schema);
     expect(result).toEqual({ asset: ["policy123", "token456"] });
   });
+
+  test("hot wallet private key shows setup choice", async () => {
+    const schema = Type.String({ title: "Hot Wallet Private Key" });
+
+    // Select "existing" option
+    mockSelect.mockResolvedValueOnce("existing");
+    mockPassword.mockResolvedValueOnce("my-private-key");
+
+    const result = await sprinkle.FillInStruct(schema);
+
+    // Verify select was called with correct options
+    expect(mockSelect.mock.calls[0][0].message).toBe("Hot wallet setup:");
+    expect(mockSelect.mock.calls[0][0].choices).toEqual([
+      { name: "Enter existing private key", value: "existing" },
+      { name: "Generate new wallet", value: "generate" },
+    ]);
+    expect(result).toBe("my-private-key");
+  });
+
+  test("hot wallet existing key prompts for password", async () => {
+    const schema = Type.String({ title: "Hot Wallet Private Key" });
+
+    mockSelect.mockResolvedValueOnce("existing");
+    mockPassword.mockResolvedValueOnce("deadbeef1234");
+
+    const result = await sprinkle.FillInStruct(schema);
+
+    expect(mockPassword).toHaveBeenCalledWith({
+      message: "Enter your private key:",
+    });
+    expect(result).toBe("deadbeef1234");
+  });
+
+  test("full wallet settings schema with existing key", async () => {
+    // Select "hot" variant
+    mockSelect.mockImplementationOnce(async (opts: any) => {
+      return opts.choices[0].value; // hot wallet object
+    });
+    // Select "existing" key option
+    mockSelect.mockResolvedValueOnce("existing");
+    mockPassword.mockResolvedValueOnce("abc123privatekey");
+
+    const result = await sprinkle.FillInStruct(WalletSettingsSchema);
+
+    expect(result).toEqual({
+      type: "hot",
+      privateKey: "abc123privatekey",
+    });
+  });
 });

package/src/Sprinkle/index.ts

@@ -6,7 +6,13 @@ import {
   HotWallet,
   type Wallet,
 } from "@blaze-cardano/sdk";
-import { CborSet, VkeyWitness, blake2b_256, 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,
@@ -167,7 +173,11 @@ export const ProviderSettingsSchema = Type.Union([
 export const WalletSettingsSchema = Type.Union([
   Type.Object({
     type: Type.Literal("hot"),
-    privateKey: Type.String({ minLength: 1, title: "Hot Wallet Private Key" }),
+    privateKey: Type.String({
+      minLength: 1,
+      title: "Hot Wallet Private Key",
+      sensitive: true,
+    }),
   }),
   Type.Object({
     type: Type.Literal("cold"),
@@ -686,6 +696,47 @@ export class Sprinkle<S extends TSchema> {
     return Blaze.from(provider, wallet);
   }
 
+  /**
+   * Generates a new wallet from a BIP39 mnemonic phrase.
+   * Displays the 24-word recovery phrase and requires user confirmation.
+   * @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();
+  }
+
   static async SearchSelect<T>(opts: {
     message: string;
     source: (
@@ -1321,6 +1372,24 @@ export class Sprinkle<S extends TSchema> {
     }
 
     if (isString(type)) {
+      // Special handling for hot wallet private key - offer generation option
+      if (type.title === "Hot Wallet Private Key") {
+        const choice = await select({
+          message: "Hot wallet setup:",
+          choices: [
+            { name: "Enter existing private key", value: "existing" },
+            { name: "Generate new wallet", value: "generate" },
+          ],
+        });
+
+        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:" });
+        return answer as TExact<U>;
+      }
+
       const defaultString = (def ? def : this.defaults["string"]) as
         | string
         | undefined;