@sundaeswap/sprinkles 0.1.1

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

@@ -0,0 +1,159 @@
+import { describe, expect, test, mock, beforeEach } from "bun:test";
+import { Sprinkle, Type } from "../index.js";
+
+// Mock @inquirer/prompts
+const mockSelect = mock();
+const mockInput = mock();
+
+mock.module("@inquirer/prompts", () => ({
+  select: mockSelect,
+  input: mockInput,
+}));
+
+describe("FillInStruct", () => {
+  let sprinkle: Sprinkle<any>;
+
+  beforeEach(() => {
+    const schema = Type.Object({ placeholder: Type.String() });
+    sprinkle = new Sprinkle(schema, "/tmp/test");
+    mockSelect.mockClear();
+    mockInput.mockClear();
+  });
+
+  test("fills a simple string field", async () => {
+    mockInput.mockResolvedValueOnce("hello");
+
+    const result = await sprinkle.FillInStruct(Type.String());
+    expect(result).toBe("hello");
+  });
+
+  test("fills a string with title as prompt", async () => {
+    mockInput.mockResolvedValueOnce("world");
+
+    await sprinkle.FillInStruct(Type.String({ title: "Enter name" }));
+    expect(mockInput.mock.calls[0][0].message).toBe("Enter name");
+  });
+
+  test("fills a bigint field", async () => {
+    mockInput.mockResolvedValueOnce("42");
+
+    const result = await sprinkle.FillInStruct(Type.BigInt());
+    expect(result).toBe(42n);
+  });
+
+  test("fills a literal field without prompting", async () => {
+    const result = await sprinkle.FillInStruct(Type.Literal("fixed"));
+    expect(result).toBe("fixed");
+    expect(mockInput).not.toHaveBeenCalled();
+    expect(mockSelect).not.toHaveBeenCalled();
+  });
+
+  test("fills an object with multiple fields", async () => {
+    const schema = Type.Object({
+      name: Type.String(),
+      age: Type.BigInt(),
+    });
+
+    mockInput
+      .mockResolvedValueOnce("Alice")
+      .mockResolvedValueOnce("30");
+
+    const result = await sprinkle.FillInStruct(schema);
+    expect(result).toEqual({ name: "Alice", age: 30n });
+  });
+
+  test("fills a union type by selecting variant then filling", async () => {
+    const schema = Type.Union([
+      Type.Object({
+        type: Type.Literal("a"),
+        value: Type.String(),
+      }),
+      Type.Object({
+        type: Type.Literal("b"),
+        count: Type.BigInt(),
+      }),
+    ]);
+
+    // Select first variant (the Object with type "a")
+    mockSelect.mockImplementationOnce(async (opts: any) => {
+      return opts.choices[0].value;
+    });
+    mockInput.mockResolvedValueOnce("test-value");
+
+    const result = await sprinkle.FillInStruct(schema);
+    expect(result).toEqual({ type: "a", value: "test-value" });
+  });
+
+  test("fills an array with items", async () => {
+    const schema = Type.Array(Type.String());
+
+    mockInput.mockResolvedValueOnce("first");
+    mockSelect.mockResolvedValueOnce(true); // add another
+    mockInput.mockResolvedValueOnce("second");
+    mockSelect.mockResolvedValueOnce(false); // stop
+
+    const result = await sprinkle.FillInStruct(schema);
+    expect(result).toEqual(["first", "second"]);
+  });
+
+  test("fills an array with single item", async () => {
+    const schema = Type.Array(Type.String());
+
+    mockInput.mockResolvedValueOnce("only");
+    mockSelect.mockResolvedValueOnce(false); // stop
+
+    const result = await sprinkle.FillInStruct(schema);
+    expect(result).toEqual(["only"]);
+  });
+
+  test("uses default value for string", async () => {
+    mockInput.mockResolvedValueOnce("used-default");
+
+    await sprinkle.FillInStruct(
+      Type.String(),
+      "my-default" as any,
+    );
+
+    expect(mockInput.mock.calls[0][0].default).toBe("my-default");
+  });
+
+  test("uses default value for bigint", async () => {
+    mockInput.mockResolvedValueOnce("99");
+
+    await sprinkle.FillInStruct(Type.BigInt(), 99n as any);
+
+    expect(mockInput.mock.calls[0][0].default).toBe("99");
+  });
+
+  test("throws for unsupported types", async () => {
+    expect(
+      sprinkle.FillInStruct(Type.Boolean() as any),
+    ).rejects.toThrow("Unable to fill in struct");
+  });
+
+  test("fills nested objects", async () => {
+    const schema = Type.Object({
+      outer: Type.Object({
+        inner: Type.String(),
+      }),
+    });
+
+    mockInput.mockResolvedValueOnce("deep-value");
+
+    const result = await sprinkle.FillInStruct(schema);
+    expect(result).toEqual({ outer: { inner: "deep-value" } });
+  });
+
+  test("remembers last string input as default", async () => {
+    mockInput
+      .mockResolvedValueOnce("first-input")
+      .mockResolvedValueOnce("second-input");
+
+    await sprinkle.FillInStruct(Type.String());
+    expect(sprinkle.defaults["string"]).toBe("first-input");
+
+    await sprinkle.FillInStruct(Type.String());
+    // Second call should have the first input as default
+    expect(mockInput.mock.calls[1][0].default).toBe("first-input");
+  });
+});

package/src/Sprinkle/__tests__/schemas.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect, test } from "bun:test";
+import { Value } from "@sinclair/typebox/value";
+import {
+  NetworkSchema,
+  ProviderSettingsSchema,
+  WalletSettingsSchema,
+  MultisigScriptModule,
+} from "../index.js";
+
+describe("Built-in Schemas", () => {
+  describe("NetworkSchema", () => {
+    test("accepts mainnet", () => {
+      expect(Value.Check(NetworkSchema, "mainnet")).toBe(true);
+    });
+
+    test("accepts preview", () => {
+      expect(Value.Check(NetworkSchema, "preview")).toBe(true);
+    });
+
+    test("accepts preprod", () => {
+      expect(Value.Check(NetworkSchema, "preprod")).toBe(true);
+    });
+
+    test("rejects invalid network", () => {
+      expect(Value.Check(NetworkSchema, "testnet")).toBe(false);
+    });
+
+    test("rejects non-string", () => {
+      expect(Value.Check(NetworkSchema, 42)).toBe(false);
+    });
+  });
+
+  describe("ProviderSettingsSchema", () => {
+    test("accepts blockfrost settings", () => {
+      expect(
+        Value.Check(ProviderSettingsSchema, {
+          type: "blockfrost",
+          projectId: "abc123",
+        }),
+      ).toBe(true);
+    });
+
+    test("accepts maestro settings", () => {
+      expect(
+        Value.Check(ProviderSettingsSchema, {
+          type: "maestro",
+          apiKey: "key123",
+        }),
+      ).toBe(true);
+    });
+
+    test("rejects empty projectId for blockfrost", () => {
+      expect(
+        Value.Check(ProviderSettingsSchema, {
+          type: "blockfrost",
+          projectId: "",
+        }),
+      ).toBe(false);
+    });
+
+    test("rejects empty apiKey for maestro", () => {
+      expect(
+        Value.Check(ProviderSettingsSchema, {
+          type: "maestro",
+          apiKey: "",
+        }),
+      ).toBe(false);
+    });
+
+    test("rejects unknown provider type", () => {
+      expect(
+        Value.Check(ProviderSettingsSchema, {
+          type: "unknown",
+          key: "abc",
+        }),
+      ).toBe(false);
+    });
+  });
+
+  describe("WalletSettingsSchema", () => {
+    test("accepts hot wallet settings", () => {
+      expect(
+        Value.Check(WalletSettingsSchema, {
+          type: "hot",
+          privateKey: "deadbeef",
+        }),
+      ).toBe(true);
+    });
+
+    test("accepts cold wallet settings", () => {
+      expect(
+        Value.Check(WalletSettingsSchema, {
+          type: "cold",
+          address: "addr1qtest",
+        }),
+      ).toBe(true);
+    });
+
+    test("rejects empty privateKey for hot wallet", () => {
+      expect(
+        Value.Check(WalletSettingsSchema, {
+          type: "hot",
+          privateKey: "",
+        }),
+      ).toBe(false);
+    });
+
+    test("rejects empty address for cold wallet", () => {
+      expect(
+        Value.Check(WalletSettingsSchema, {
+          type: "cold",
+          address: "",
+        }),
+      ).toBe(false);
+    });
+  });
+
+  describe("MultisigScript", () => {
+    const MultisigScript = MultisigScriptModule.Import("MultisigScript");
+
+    test("accepts Signature variant", () => {
+      expect(
+        Value.Check(MultisigScript, {
+          Signature: { key_hash: "abc123" },
+        }),
+      ).toBe(true);
+    });
+
+    test("accepts AllOf variant with nested scripts", () => {
+      expect(
+        Value.Check(MultisigScript, {
+          AllOf: {
+            scripts: [
+              { Signature: { key_hash: "abc" } },
+              { Signature: { key_hash: "def" } },
+            ],
+          },
+        }),
+      ).toBe(true);
+    });
+
+    test("accepts AnyOf variant", () => {
+      expect(
+        Value.Check(MultisigScript, {
+          AnyOf: {
+            scripts: [{ Signature: { key_hash: "abc" } }],
+          },
+        }),
+      ).toBe(true);
+    });
+
+    test("accepts AtLeast variant", () => {
+      expect(
+        Value.Check(MultisigScript, {
+          AtLeast: {
+            required: 2n,
+            scripts: [
+              { Signature: { key_hash: "a" } },
+              { Signature: { key_hash: "b" } },
+              { Signature: { key_hash: "c" } },
+            ],
+          },
+        }),
+      ).toBe(true);
+    });
+
+    test("accepts Before variant", () => {
+      expect(
+        Value.Check(MultisigScript, {
+          Before: { time: 1000n },
+        }),
+      ).toBe(true);
+    });
+
+    test("accepts After variant", () => {
+      expect(
+        Value.Check(MultisigScript, {
+          After: { time: 2000n },
+        }),
+      ).toBe(true);
+    });
+
+    test("accepts Script variant", () => {
+      expect(
+        Value.Check(MultisigScript, {
+          Script: { script_hash: "hash123" },
+        }),
+      ).toBe(true);
+    });
+
+    test("accepts deeply nested scripts", () => {
+      expect(
+        Value.Check(MultisigScript, {
+          AllOf: {
+            scripts: [
+              {
+                AnyOf: {
+                  scripts: [
+                    { Signature: { key_hash: "nested" } },
+                    {
+                      AtLeast: {
+                        required: 1n,
+                        scripts: [{ Signature: { key_hash: "deep" } }],
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        }),
+      ).toBe(true);
+    });
+  });
+});

package/src/Sprinkle/__tests__/settings-persistence.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { Sprinkle, Type } from "../index.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { withProfile } from "./test-helpers.js";
+
+describe("Settings Persistence", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("SettingsPath returns correct path", () => {
+    const result = Sprinkle.SettingsPath("/some/path");
+    expect(result).toBe(`/some/path${path.sep}settings.json`);
+  });
+
+  test("saveSettings creates directory if missing", () => {
+    const nestedDir = path.join(tmpDir, "nested", "deep");
+    const schema = Type.Object({ name: Type.String() });
+    const sprinkle = withProfile(new Sprinkle(schema, nestedDir));
+    sprinkle.settings = { name: "test" } as any;
+
+    sprinkle.saveSettings();
+
+    expect(fs.existsSync(path.join(nestedDir, "profiles", "test.json"))).toBe(
+      true,
+    );
+  });
+
+  test("saveSettings writes valid JSON with profile format", () => {
+    const schema = Type.Object({ name: Type.String() });
+    const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+    sprinkle.settings = { name: "hello" } as any;
+
+    sprinkle.saveSettings();
+
+    const content = fs.readFileSync(
+      path.join(tmpDir, "profiles", "test.json"),
+      "utf-8",
+    );
+    const parsed = JSON.parse(content);
+    expect(parsed.settings.name).toBe("hello");
+    expect(parsed.defaults).toEqual({});
+    expect(parsed.meta.name).toBe("Test");
+  });
+
+  test("saveSettings serializes BigInt values", () => {
+    const schema = Type.Object({ amount: Type.BigInt() });
+    const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+    sprinkle.settings = { amount: 42n } as any;
+
+    sprinkle.saveSettings();
+
+    const content = fs.readFileSync(
+      path.join(tmpDir, "profiles", "test.json"),
+      "utf-8",
+    );
+    const raw = JSON.parse(content);
+    expect(raw.settings.amount).toBe("42n");
+  });
+
+  test("saveSettings and loadProfile round-trip with BigInt", async () => {
+    const schema = Type.Object({ amount: Type.BigInt() });
+    const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+    sprinkle.settings = { amount: 99n } as any;
+    sprinkle.saveSettings();
+
+    const sprinkle2 = new Sprinkle(schema, tmpDir);
+    await sprinkle2.loadProfile("test");
+
+    expect(sprinkle2.settings).toEqual({ amount: 99n });
+  });
+
+  test("saveSettings preserves defaults", () => {
+    const schema = Type.Object({ name: Type.String() });
+    const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+    sprinkle.settings = { name: "test" } as any;
+    sprinkle.defaults = { string: "last-input" };
+
+    sprinkle.saveSettings();
+
+    const content = fs.readFileSync(
+      path.join(tmpDir, "profiles", "test.json"),
+      "utf-8",
+    );
+    const parsed = JSON.parse(content);
+    expect(parsed.defaults.string).toBe("last-input");
+  });
+
+  test("loadProfile restores defaults", async () => {
+    const schema = Type.Object({ name: Type.String() });
+    const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+    sprinkle.settings = { name: "test" } as any;
+    sprinkle.defaults = { string: "remembered" };
+    sprinkle.saveSettings();
+
+    const sprinkle2 = new Sprinkle(schema, tmpDir);
+    await sprinkle2.loadProfile("test");
+
+    expect(sprinkle2.defaults).toEqual({ string: "remembered" });
+  });
+
+  test("round-trip with nested objects", async () => {
+    const schema = Type.Object({
+      user: Type.Object({
+        name: Type.String(),
+        score: Type.BigInt(),
+      }),
+    });
+    const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+    sprinkle.settings = { user: { name: "alice", score: 100n } } as any;
+    sprinkle.saveSettings();
+
+    const sprinkle2 = new Sprinkle(schema, tmpDir);
+    await sprinkle2.loadProfile("test");
+
+    expect(sprinkle2.settings).toEqual({
+      user: { name: "alice", score: 100n },
+    });
+  });
+
+  test("scanProfiles returns profile entries", () => {
+    const schema = Type.Object({ name: Type.String() });
+    const sprinkle = withProfile(new Sprinkle(schema, tmpDir), "alice");
+    sprinkle.profileMeta.name = "Alice";
+    sprinkle.settings = { name: "test" } as any;
+    sprinkle.saveSettings();
+
+    const profiles = sprinkle.scanProfiles();
+    expect(profiles.length).toBe(1);
+    expect(profiles[0]!.id).toBe("alice");
+    expect(profiles[0]!.meta.name).toBe("Alice");
+  });
+
+  test("sanitizeProfileId handles various inputs", () => {
+    expect(Sprinkle.sanitizeProfileId("Mainnet Alice")).toBe("mainnet-alice");
+    expect(Sprinkle.sanitizeProfileId("test--profile")).toBe("test-profile");
+    expect(Sprinkle.sanitizeProfileId("Hello World!@#$")).toBe("hello-world");
+    expect(Sprinkle.sanitizeProfileId("  ")).toBe("profile");
+    expect(Sprinkle.sanitizeProfileId("simple")).toBe("simple");
+  });
+
+  test("migration converts legacy settings.json to profile", async () => {
+    const schema = Type.Object({ name: Type.String() });
+
+    // Write legacy settings.json
+    fs.mkdirSync(tmpDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, "settings.json"),
+      JSON.stringify({
+        settings: { name: "legacy" },
+        defaults: { string: "old" },
+      }),
+    );
+
+    // Create sprinkle and trigger migration
+    const sprinkle = new Sprinkle(schema, tmpDir);
+    await (sprinkle as any).migrateIfNeeded();
+
+    // Check profile was created
+    expect(fs.existsSync(path.join(tmpDir, "profiles", "default.json"))).toBe(
+      true,
+    );
+    // Check legacy file was backed up
+    expect(fs.existsSync(path.join(tmpDir, "settings.json.bak"))).toBe(true);
+    expect(fs.existsSync(path.join(tmpDir, "settings.json"))).toBe(false);
+
+    // Load the migrated profile
+    await sprinkle.loadProfile("default");
+    expect(sprinkle.settings).toEqual({ name: "legacy" });
+    expect(sprinkle.defaults).toEqual({ string: "old" });
+    expect(sprinkle.profileMeta.name).toBe("Default");
+  });
+});

package/src/Sprinkle/__tests__/show-menu.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, test, mock, beforeEach } from "bun:test";
+import { Sprinkle, Type, type IMenu } from "../index.js";
+import { withProfile } from "./test-helpers.js";
+
+const mockSelect = mock();
+const mockInput = mock();
+
+mock.module("@inquirer/prompts", () => ({
+  select: mockSelect,
+  input: mockInput,
+}));
+
+describe("showMenu", () => {
+  let sprinkle: Sprinkle<any>;
+
+  beforeEach(() => {
+    const schema = Type.Object({ name: Type.String() });
+    sprinkle = withProfile(new Sprinkle(schema, "/tmp/test"));
+    sprinkle.settings = { name: "test" } as any;
+    mockSelect.mockClear();
+    mockInput.mockClear();
+  });
+
+  test("exits when Exit is selected on main menu", async () => {
+    mockSelect.mockResolvedValueOnce(-1);
+
+    const menu: IMenu<any> = {
+      title: "Test Menu",
+      items: [
+        {
+          title: "Action 1",
+          action: async () => {},
+        },
+      ],
+    };
+
+    await sprinkle.showMenu(menu);
+  });
+
+  test("executes action and re-shows menu", async () => {
+    const actionFn = mock(async () => {});
+
+    mockSelect.mockResolvedValueOnce(0).mockResolvedValueOnce(-1);
+
+    const menu: IMenu<any> = {
+      title: "Test Menu",
+      items: [
+        {
+          title: "My Action",
+          action: actionFn,
+        },
+      ],
+    };
+
+    await sprinkle.showMenu(menu);
+    expect(actionFn).toHaveBeenCalledTimes(1);
+  });
+
+  test("main menu includes Settings & Profiles submenu and Exit", async () => {
+    mockSelect.mockResolvedValueOnce(-1);
+
+    const menu: IMenu<any> = {
+      title: "Test",
+      items: [{ title: "Action", action: async () => {} }],
+    };
+
+    await sprinkle.showMenu(menu);
+
+    const choices = mockSelect.mock.calls[0][0].choices;
+    const names = choices.map((c: any) => c.name);
+    expect(names).toContain("Settings & Profiles");
+    expect(names).toContain("Exit");
+    expect(names).not.toContain("Switch profile");
+    expect(names).not.toContain("Manage profiles");
+    expect(names).not.toContain("Edit settings");
+  });
+
+  test("submenu includes Back instead of Exit", async () => {
+    mockSelect
+      .mockResolvedValueOnce(0)
+      .mockResolvedValueOnce(-1)
+      .mockResolvedValueOnce(-1);
+
+    const menu: IMenu<any> = {
+      title: "Main",
+      items: [
+        {
+          title: "Sub",
+          items: [{ title: "Sub Action", action: async () => {} }],
+        },
+      ],
+    };
+
+    await sprinkle.showMenu(menu);
+
+    const subChoices = mockSelect.mock.calls[1][0].choices;
+    const subNames = subChoices.map((c: any) => c.name);
+    expect(subNames).toContain("Back");
+    expect(subNames).not.toContain("Exit");
+  });
+
+  test("action returning sprinkle instance saves settings", async () => {
+    sprinkle.settings = { name: "original" } as any;
+
+    mockSelect.mockResolvedValueOnce(0).mockResolvedValueOnce(-1);
+
+    const menu: IMenu<any> = {
+      title: "Test",
+      items: [
+        {
+          title: "Update",
+          action: async (s: Sprinkle<any>) => {
+            s.settings = { name: "updated" } as any;
+            return s;
+          },
+        },
+      ],
+    };
+
+    await sprinkle.showMenu(menu);
+    expect(sprinkle.settings).toEqual({ name: "updated" });
+  });
+});

package/src/Sprinkle/__tests__/test-helpers.ts

@@ -0,0 +1,14 @@
+import { Sprinkle } from "../index.js";
+
+export function withProfile<S>(
+  sprinkle: Sprinkle<S>,
+  id: string = "test",
+): Sprinkle<S> {
+  sprinkle.profileId = id;
+  sprinkle.profileMeta = {
+    name: "Test",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+  return sprinkle;
+}