@sundaeswap/sprinkles 0.2.1 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaeswap/sprinkles",
-  "version": "0.2.1",
+  "version": "0.4.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/__tests__/settings-persistence.test.ts

@@ -178,4 +178,112 @@ describe("Settings Persistence", () => {
     expect(sprinkle.defaults).toEqual({ string: "old" });
     expect(sprinkle.profileMeta.name).toBe("Default");
   });
+
+  describe("currentProfile", () => {
+    test("returns null when no profile loaded", () => {
+      const schema = Type.Object({ name: Type.String() });
+      const sprinkle = new Sprinkle(schema, tmpDir);
+
+      expect(sprinkle.currentProfile).toBeNull();
+    });
+
+    test("returns profile info when loaded", () => {
+      const schema = Type.Object({ name: Type.String() });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+
+      const profile = sprinkle.currentProfile;
+      expect(profile).not.toBeNull();
+      expect(profile!.id).toBe("test");
+      expect(profile!.name).toBe("Test");
+      expect(profile!.createdAt).toBeDefined();
+      expect(profile!.updatedAt).toBeDefined();
+    });
+
+    test("includes description when present", () => {
+      const schema = Type.Object({ name: Type.String() });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.profileMeta.description = "Test profile description";
+
+      const profile = sprinkle.currentProfile;
+      expect(profile!.description).toBe("Test profile description");
+    });
+
+    test("has undefined description when not set", () => {
+      const schema = Type.Object({ name: Type.String() });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      delete sprinkle.profileMeta.description;
+
+      const profile = sprinkle.currentProfile;
+      expect(profile!.description).toBeUndefined();
+    });
+  });
+
+  describe("getDisplaySettings", () => {
+    test("masks sensitive fields", () => {
+      const schema = Type.Object({
+        name: Type.String(),
+        secret: Type.String({ sensitive: true }),
+      });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.settings = { name: "visible", secret: "hidden" } as any;
+
+      const display = sprinkle.getDisplaySettings();
+      expect(display.name).toBe("visible");
+      expect(display.secret).toBe("********");
+    });
+
+    test("preserves non-sensitive fields", () => {
+      const schema = Type.Object({
+        name: Type.String(),
+        count: Type.Number(),
+      });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.settings = { name: "test", count: 42 } as any;
+
+      const display = sprinkle.getDisplaySettings();
+      expect(display.name).toBe("test");
+      expect(display.count).toBe(42);
+    });
+
+    test("preserves BigInt values", () => {
+      const schema = Type.Object({
+        amount: Type.BigInt(),
+        secret: Type.String({ sensitive: true }),
+      });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.settings = { amount: 42n, secret: "hidden" } as any;
+
+      const display = sprinkle.getDisplaySettings();
+      expect(display.amount).toBe(42n);
+      expect(display.secret).toBe("********");
+    });
+
+    test("masks nested sensitive fields", () => {
+      const schema = Type.Object({
+        wallet: Type.Object({
+          key: Type.String({ sensitive: true }),
+          address: Type.String(),
+        }),
+      });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.settings = {
+        wallet: { key: "secret", address: "addr1..." },
+      } as any;
+
+      const display = sprinkle.getDisplaySettings();
+      expect(display.wallet.key).toBe("********");
+      expect(display.wallet.address).toBe("addr1...");
+    });
+
+    test("does not mask empty sensitive fields", () => {
+      const schema = Type.Object({
+        secret: Type.String({ sensitive: true }),
+      });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.settings = { secret: "" } as any;
+
+      const display = sprinkle.getDisplaySettings();
+      expect(display.secret).toBe("");
+    });
+  });
 });

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,
@@ -68,6 +74,10 @@ export interface IProfileMeta {
   updatedAt: string;
 }
 
+export interface ICurrentProfile extends IProfileMeta {
+  id: string;
+}
+
 export interface IProfileEntry {
   id: string;
   meta: IProfileMeta;
@@ -167,7 +177,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"),
@@ -201,6 +215,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 {
@@ -686,6 +710,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: (
@@ -814,6 +879,21 @@ export class Sprinkle<S extends TSchema> {
     this.saveProfile();
   }
 
+  getDisplaySettings(): TExact<S> {
+    const clone = JSON.parse(
+      JSON.stringify(this.settings, Sprinkle.bigIntReplacer),
+      Sprinkle.bigIntReviver,
+    );
+    const sensitivePaths = Sprinkle.collectSensitivePaths(this.type);
+    for (const p of sensitivePaths) {
+      const value = Sprinkle.getNestedValue(clone, p);
+      if (typeof value === "string" && value.length > 0) {
+        Sprinkle.setNestedValue(clone, p, "********");
+      }
+    }
+    return clone;
+  }
+
   // --- TxDialog Helpers ---
 
   /**
@@ -1321,6 +1401,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;