@sundaeswap/sprinkles 0.8.0 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaeswap/sprinkles",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "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,5 +1,6 @@
 import { describe, expect, test, mock, beforeEach, spyOn } from "bun:test";
-import { Sprinkle, Type, WalletSettingsSchema } from "../index.js";
+import { Sprinkle, Type, WalletSettingsSchema, MultisigScriptModule } from "../index.js";
+import { MultisigScript } from "../schemas.js";
 import { UserCancelledError } from "../types.js";
 
 // Mock @inquirer/prompts
@@ -638,4 +639,113 @@ describe("FillInStruct", () => {
       UserCancelledError,
     );
   });
+
+  // --- Type.Module / Type.Import ($ref resolution) ---
+
+  test("resolves MultisigScript TImport $ref (Signature variant)", async () => {
+    const hash = "a".repeat(56);
+
+    // Union variant selection: pick Signature
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      const sigVariant = opts.choices.find((c: any) =>
+        c.name === "Signature" || JSON.stringify(c.value).includes("Signature"),
+      );
+      return sigVariant?.value ?? opts.choices[0].value;
+    });
+    // Signature → single-field → key_hash → single-field → string prompt
+    mockInputCancellable.mockResolvedValueOnce(hash);
+    // "Save to addressbook?"
+    mockSelectCancellable.mockResolvedValueOnce(false);
+
+    const result = await sprinkle.FillInStruct(MultisigScript);
+    expect(result).toEqual({ Signature: { key_hash: hash } });
+  });
+
+  test("resolves MultisigScript $ref inside a wrapping schema", async () => {
+    const schema = Type.Object({
+      script: MultisigScript,
+    });
+    const hash = "b".repeat(56);
+
+    // Object has single required field "script" → skips menu
+    // Union variant selection: pick Signature
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      const sigVariant = opts.choices.find((c: any) =>
+        c.name === "Signature" || JSON.stringify(c.value).includes("Signature"),
+      );
+      return sigVariant?.value ?? opts.choices[0].value;
+    });
+    mockInputCancellable.mockResolvedValueOnce(hash);
+    // "Save to addressbook?"
+    mockSelectCancellable.mockResolvedValueOnce(false);
+
+    const result = await sprinkle.FillInStruct(schema);
+    expect(result).toEqual({ script: { Signature: { key_hash: hash } } });
+  });
+
+  test("resolves MultisigScript default matching when editing existing value", async () => {
+    // When editing an existing MultisigScript value, Value.Check is called
+    // to match the default against the selected variant. Variant schemas
+    // contain $ref which requires a references array to resolve.
+    const hash = "e".repeat(56);
+    const existingValue = {
+      AllOf: {
+        scripts: [{ Signature: { key_hash: hash } }],
+      },
+    };
+
+    // Union variant selection: pick AllOf (matches the existing value)
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      const variant = opts.choices.find((c: any) =>
+        c.name === "AllOf" || (c.value?.properties && "AllOf" in c.value.properties),
+      );
+      return variant?.value ?? opts.choices[1].value;
+    });
+    // AllOf → single field → scripts array → items already populated from default
+    // Array menu: Done (keep existing items)
+    mockSelectCancellable.mockResolvedValueOnce("done");
+    // "Save to addressbook?"
+    mockSelectCancellable.mockResolvedValueOnce(false);
+
+    const result = await sprinkle.FillInStruct(MultisigScript, existingValue as any);
+    expect(result).toEqual(existingValue);
+  });
+
+  test("resolves recursive $ref in nested MultisigScript (AllOf with nested Signature)", async () => {
+    const hash1 = "c".repeat(56);
+
+    // Top-level union: pick AllOf
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      const variant = opts.choices.find((c: any) =>
+        c.name === "AllOf" || (c.value?.properties && "AllOf" in c.value.properties),
+      );
+      return variant?.value ?? opts.choices[1].value;
+    });
+    // AllOf → single field → scripts array
+    // Array menu: Add item
+    mockSelectCancellable.mockResolvedValueOnce("add");
+    // Array item is MultisigScript ($ref) → resolves recursively → shows Union
+    // Union: pick Signature
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
+      const sigVariant = opts.choices.find((c: any) =>
+        c.name === "Signature" || (c.value?.properties && "Signature" in c.value.properties),
+      );
+      return sigVariant?.value ?? opts.choices[0].value;
+    });
+    // Fill key_hash
+    mockInputCancellable.mockResolvedValueOnce(hash1);
+    // "Save to addressbook?" for inner MultisigScript
+    mockSelectCancellable.mockResolvedValueOnce(false);
+    // Array menu: Done
+    mockSelectCancellable.mockResolvedValueOnce("done");
+    // "Save to addressbook?" for outer MultisigScript
+    mockSelectCancellable.mockResolvedValueOnce(false);
+
+    const result = await sprinkle.FillInStruct(MultisigScript);
+    expect(result).toEqual({
+      AllOf: {
+        scripts: [{ Signature: { key_hash: hash1 } }],
+      },
+    });
+  });
 });

package/src/Sprinkle/index.ts

@@ -196,7 +196,10 @@ export {
   runMcp,
   getBuiltinActions,
   promptAndExecute,
+  toNativeScript,
+  completeWithScripts,
 } from "./actions/index.js";
+export type { NativeScriptInput } from "./actions/index.js";
 import {
   mintToken,
   simpleSend,
@@ -511,6 +514,7 @@ export class Sprinkle<S extends TSchema> {
       jsonContent,
       "utf-8",
     );
+    await this.loadProfile(id);
     console.log(`Profile "${name}" created as a copy.`);
   }
 
@@ -1539,6 +1543,9 @@ export class Sprinkle<S extends TSchema> {
       // if the literal field values in the selected variant match those in `def`.
       // For non-discriminated unions, fall back to structural matching with Value.Check.
       let matchedDef: unknown = undefined;
+      // Build references array for Value.Check — schemas with $id from defs
+      // so TypeBox can resolve $ref inside variant schemas (e.g. MultisigScript).
+      const references = Object.values(defs).filter((s) => s.$id) as TSchema[];
       if (def !== undefined) {
         if (isObject(selection)) {
           // Check if all literal fields in the selected variant match def
@@ -1556,13 +1563,13 @@ export class Sprinkle<S extends TSchema> {
             }
           } else {
             // No literal discriminators - use structural check
-            if (Value.Check(selection, def)) {
+            if (Value.Check(selection, references, def)) {
               matchedDef = def;
             }
           }
         } else {
           // Non-object variant - use structural check
-          if (Value.Check(selection, def)) {
+          if (Value.Check(selection, references, def)) {
             matchedDef = def;
           }
         }