@sundaeswap/sprinkles 0.7.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaeswap/sprinkles",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "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__/builtin-actions.test.ts

@@ -51,14 +51,14 @@ async function makeSprinkle(
 }
 
 describe("getBuiltinActions", () => {
-  test("returns an array of 14 actions", () => {
+  test("returns an array of 21 actions", () => {
     const actions = getBuiltinActions();
-    expect(actions).toHaveLength(14);
+    expect(actions).toHaveLength(21);
   });
 
   test("all actions have a category", () => {
     const actions = getBuiltinActions();
-    const validCategories = ["sprinkles", "wallet", "transaction"];
+    const validCategories = ["sprinkles", "wallet", "transaction", "utility", "addressbook"];
     for (const action of actions) {
       expect(validCategories).toContain((action as any).category);
     }
@@ -89,7 +89,7 @@ describe("getBuiltinActions", () => {
     for (const action of actions) {
       sprinkle.registerAction(action as any);
     }
-    expect(sprinkle.listActions()).toHaveLength(14);
+    expect(sprinkle.listActions()).toHaveLength(21);
   });
 });
 

package/src/Sprinkle/__tests__/cli-adapter.test.ts

@@ -205,9 +205,30 @@ describe("coerceValue", () => {
     expect(coerceValue("not-json", Type.Object({ x: Type.String() }))).toBe("not-json");
   });
 
-  test("returns already-parsed object as-is for Object schema", () => {
-    const obj = { x: 1 };
-    expect(coerceValue(obj, Type.Object({ x: Type.Number() }))).toBe(obj);
+  test("coerces properties of already-parsed object for Object schema", () => {
+    const obj = { x: "1" };
+    expect(coerceValue(obj, Type.Object({ x: Type.Number() }))).toEqual({ x: 1 });
+  });
+
+  test("recursively coerces nested BigInt values inside parsed JSON", () => {
+    const schema = Type.Object({
+      name: Type.String(),
+      reserve_assets: Type.Array(Type.Object({
+        asset: Type.Array(Type.String()),
+        numerator: Type.BigInt(),
+        denominator: Type.BigInt(),
+      })),
+    });
+    const raw = '{"name":"test","reserve_assets":[{"asset":["policy","name"],"numerator":"1","denominator":"2"}]}';
+    const result = coerceValue(raw, schema);
+    expect(result).toEqual({
+      name: "test",
+      reserve_assets: [{
+        asset: ["policy", "name"],
+        numerator: BigInt(1),
+        denominator: BigInt(2),
+      }],
+    });
   });
 
   test("returns malformed JSON string as-is for Object schema", () => {

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

@@ -91,8 +91,30 @@ describe("FillInStruct", () => {
     expect(mockInputCancellable.mock.calls[0][0].default).toBe("99");
   });
 
-  test("throws for unsupported types", async () => {
+  test("fills a boolean field with select", async () => {
+    mockSelectCancellable.mockResolvedValueOnce(true);
+
+    const result = await sprinkle.FillInStruct(Type.Boolean() as any);
+    expect(result).toBe(true);
+  });
+
+  test("boolean field respects default value", async () => {
+    mockSelectCancellable.mockResolvedValueOnce(false);
+
+    await sprinkle.FillInStruct(Type.Boolean() as any, false as any);
+    expect(mockSelectCancellable.mock.calls[0][0].default).toBe(false);
+  });
+
+  test("boolean field throws on cancel", async () => {
+    mockSelectCancellable.mockResolvedValueOnce(null);
+
     expect(sprinkle.FillInStruct(Type.Boolean() as any)).rejects.toThrow(
+      UserCancelledError,
+    );
+  });
+
+  test("throws for unsupported types", async () => {
+    expect(sprinkle.FillInStruct(Type.Null() as any)).rejects.toThrow(
       "Unable to fill in struct",
     );
   });

package/src/Sprinkle/__tests__/mcp-adapter.test.ts

@@ -543,7 +543,7 @@ describe("createMcpServer", () => {
 
   // --- Tool input schema ---
 
-  test("tool input schema is the JSON Schema conversion of the action inputSchema", async () => {
+  test("tool input schema is a Zod raw shape matching the action inputSchema", async () => {
     const sprinkle = makeMockSprinkle([
       {
         name: "typed-action",
@@ -560,10 +560,12 @@ describe("createMcpServer", () => {
     await createMcpServer(sprinkle, "test-server");
 
     const schema = registeredTools[0]!.schema;
-    expect(schema.type).toBe("object");
-    const props = schema.properties as Record<string, unknown>;
-    expect(props.name).toEqual({ type: "string" });
-    expect(props.count).toEqual({ type: "integer" });
+    // Schema is now a Zod raw shape (Record<string, ZodType>)
+    expect(schema).toHaveProperty("name");
+    expect(schema).toHaveProperty("count");
+    // Verify they are Zod schema instances (have _zod internal property)
+    expect((schema as Record<string, unknown>).name).toHaveProperty("_zod");
+    expect((schema as Record<string, unknown>).count).toHaveProperty("_zod");
   });
 
   // --- Tool handler: successful execution ---

package/src/Sprinkle/__tests__/native-script.test.ts

@@ -0,0 +1,341 @@
+import { describe, expect, test, mock } from "bun:test";
+import { ActionError } from "../actions/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks — mirror the Blaze SDK surface used by native-script.ts
+// ---------------------------------------------------------------------------
+
+let provideScriptCalls: any[] = [];
+const mockCompletedTx = { toCbor: () => "mock-tx-cbor" };
+
+mock.module("@blaze-cardano/sdk", () => ({
+  Core: {
+    Ed25519KeyHashHex: (h: string) => h,
+    Slot: (n: number) => n,
+    HexBlob: (s: string) => s,
+    ScriptPubkey: class {
+      hash: string;
+      constructor(h: string) {
+        this.hash = h;
+      }
+    },
+    ScriptAll: class {
+      scripts: any[];
+      constructor(s: any[]) {
+        this.scripts = s;
+      }
+    },
+    ScriptAny: class {
+      scripts: any[];
+      constructor(s: any[]) {
+        this.scripts = s;
+      }
+    },
+    ScriptNOfK: class {
+      scripts: any[];
+      n: number;
+      constructor(s: any[], n: number) {
+        this.scripts = s;
+        this.n = n;
+      }
+    },
+    TimelockExpiry: class {
+      slot: number;
+      constructor(s: number) {
+        this.slot = s;
+      }
+    },
+    TimelockStart: class {
+      slot: number;
+      constructor(s: number) {
+        this.slot = s;
+      }
+    },
+    NativeScript: {
+      fromCbor: (hex: string) => {
+        if (hex === "invalid") throw new Error("Invalid CBOR");
+        return { __fromCbor: hex };
+      },
+      newScriptPubkey: (sp: any) => ({ __type: "pubkey", value: sp }),
+      newScriptAll: (sa: any) => ({ __type: "all", value: sa }),
+      newScriptAny: (sa: any) => ({ __type: "any", value: sa }),
+      newScriptNOfK: (sn: any) => ({ __type: "nofk", value: sn }),
+      newTimelockExpiry: (te: any) => ({ __type: "timelockExpiry", value: te }),
+      newTimelockStart: (ts: any) => ({ __type: "timelockStart", value: ts }),
+    },
+    Script: {
+      newNativeScript: (ns: any) => ({
+        __nativeScript: ns,
+        hash: () => {
+          // Produce a deterministic hex hash from the native script content
+          if (ns?.__type === "pubkey") return ns.value.hash;
+          if (ns?.__fromCbor) return "cbor" + ns.__fromCbor;
+          return "0".repeat(56);
+        },
+      }),
+    },
+  },
+}));
+
+const { toNativeScript, completeWithScripts } = await import(
+  "../actions/builtin/native-script.js"
+);
+
+// ---------------------------------------------------------------------------
+// toNativeScript — CBOR hex input
+// ---------------------------------------------------------------------------
+
+describe("toNativeScript — CBOR hex", () => {
+  test("converts valid CBOR hex string", () => {
+    const result = toNativeScript("82018200");
+    expect(result.__nativeScript).toEqual({ __fromCbor: "82018200" });
+    expect(typeof result.hash).toBe("function");
+  });
+
+  test("throws INVALID_NATIVE_SCRIPT for invalid CBOR", () => {
+    expect(() => toNativeScript("invalid")).toThrow(ActionError);
+    try {
+      toNativeScript("invalid");
+    } catch (err: any) {
+      expect(err.code).toBe("INVALID_NATIVE_SCRIPT");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// toNativeScript — MultisigScript JSON input
+// ---------------------------------------------------------------------------
+
+describe("toNativeScript — MultisigScript JSON", () => {
+  const keyHash = "a".repeat(56);
+
+  test("converts Signature", () => {
+    const result = toNativeScript({ Signature: { key_hash: keyHash } });
+    expect(result.__nativeScript.__type).toBe("pubkey");
+    expect(result.__nativeScript.value.hash).toBe(keyHash);
+  });
+
+  test("converts AllOf with nested scripts", () => {
+    const result = toNativeScript({
+      AllOf: {
+        scripts: [
+          { Signature: { key_hash: keyHash } },
+          { Signature: { key_hash: "b".repeat(56) } },
+        ],
+      },
+    });
+    expect(result.__nativeScript.__type).toBe("all");
+    expect(result.__nativeScript.value.scripts).toHaveLength(2);
+  });
+
+  test("converts AnyOf", () => {
+    const result = toNativeScript({
+      AnyOf: {
+        scripts: [{ Signature: { key_hash: keyHash } }],
+      },
+    });
+    expect(result.__nativeScript.__type).toBe("any");
+  });
+
+  test("converts AtLeast", () => {
+    const result = toNativeScript({
+      AtLeast: {
+        required: 2n,
+        scripts: [
+          { Signature: { key_hash: keyHash } },
+          { Signature: { key_hash: "b".repeat(56) } },
+          { Signature: { key_hash: "c".repeat(56) } },
+        ],
+      },
+    });
+    expect(result.__nativeScript.__type).toBe("nofk");
+    expect(result.__nativeScript.value.n).toBe(2);
+    expect(result.__nativeScript.value.scripts).toHaveLength(3);
+  });
+
+  test("converts Before (TimelockExpiry)", () => {
+    const result = toNativeScript({ Before: { time: 1000n } });
+    expect(result.__nativeScript.__type).toBe("timelockExpiry");
+    expect(result.__nativeScript.value.slot).toBe(1000);
+  });
+
+  test("converts After (TimelockStart)", () => {
+    const result = toNativeScript({ After: { time: 500n } });
+    expect(result.__nativeScript.__type).toBe("timelockStart");
+    expect(result.__nativeScript.value.slot).toBe(500);
+  });
+
+  test("converts Script (script hash reference)", () => {
+    const result = toNativeScript({ Script: { script_hash: keyHash } });
+    expect(result.__nativeScript.__type).toBe("pubkey");
+    expect(result.__nativeScript.value.hash).toBe(keyHash);
+  });
+
+  test("handles deeply nested structures", () => {
+    const result = toNativeScript({
+      AllOf: {
+        scripts: [
+          {
+            AtLeast: {
+              required: 1n,
+              scripts: [
+                { Signature: { key_hash: keyHash } },
+                {
+                  AnyOf: {
+                    scripts: [{ Signature: { key_hash: "b".repeat(56) } }],
+                  },
+                },
+              ],
+            },
+          },
+          { After: { time: 100n } },
+        ],
+      },
+    });
+    expect(result.__nativeScript.__type).toBe("all");
+    expect(result.__nativeScript.value.scripts).toHaveLength(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// completeWithScripts
+// ---------------------------------------------------------------------------
+
+describe("completeWithScripts", () => {
+  function makeTxBuilder() {
+    provideScriptCalls = [];
+    const builder: any = {
+      provideScript: (script: any) => {
+        provideScriptCalls.push(script);
+        return builder;
+      },
+      complete: async () => mockCompletedTx,
+    };
+    return builder;
+  }
+
+  test("completes without scripts when none provided", async () => {
+    const builder = makeTxBuilder();
+    const tx = await completeWithScripts(builder);
+    expect(tx).toBe(mockCompletedTx);
+    expect(provideScriptCalls).toHaveLength(0);
+  });
+
+  test("completes without scripts when empty array provided", async () => {
+    const builder = makeTxBuilder();
+    const tx = await completeWithScripts(builder, []);
+    expect(tx).toBe(mockCompletedTx);
+    expect(provideScriptCalls).toHaveLength(0);
+  });
+
+  test("attaches scripts before completing", async () => {
+    const builder = makeTxBuilder();
+    const keyHash = "a".repeat(56);
+    const tx = await completeWithScripts(builder, [
+      { Signature: { key_hash: keyHash } },
+      "82018200",
+    ]);
+    expect(tx).toBe(mockCompletedTx);
+    expect(provideScriptCalls).toHaveLength(2);
+  });
+
+  test("propagates ActionError from invalid script input", async () => {
+    const builder = makeTxBuilder();
+    await expect(
+      completeWithScripts(builder, ["invalid"]),
+    ).rejects.toMatchObject({ code: "INVALID_NATIVE_SCRIPT" });
+  });
+
+  test("retries with addressbook script on missing script hash error", async () => {
+    const keyHash = "a".repeat(56);
+    const expectedScriptHash = keyHash;
+    let attempt = 0;
+    provideScriptCalls = [];
+    const builder: any = {
+      provideScript: (script: any) => {
+        provideScriptCalls.push(script);
+        return builder;
+      },
+      complete: async () => {
+        attempt++;
+        if (attempt === 1) {
+          throw new Error(
+            `complete: Could not resolve script hash ${expectedScriptHash}`,
+          );
+        }
+        return mockCompletedTx;
+      },
+    };
+
+    const context = {
+      sprinkle: {
+        addressbook: {
+          "my-multisig": { Signature: { key_hash: keyHash } },
+        },
+      },
+      settings: {},
+    } as any;
+
+    const tx = await completeWithScripts(builder, undefined, context);
+    expect(tx).toBe(mockCompletedTx);
+    expect(attempt).toBe(2);
+    expect(provideScriptCalls).toHaveLength(1);
+  });
+
+  test("throws original error when script hash not in addressbook", async () => {
+    const builder: any = {
+      provideScript: () => builder,
+      complete: async () => {
+        throw new Error("complete: Could not resolve script hash deadbeef1234");
+      },
+    };
+
+    const context = {
+      sprinkle: {
+        addressbook: {
+          "unrelated": { Signature: { key_hash: "b".repeat(56) } },
+        },
+      },
+      settings: {},
+    } as any;
+
+    await expect(
+      completeWithScripts(builder, undefined, context),
+    ).rejects.toThrow("Could not resolve script hash deadbeef1234");
+  });
+
+  test("throws original error when no addressbook in context", async () => {
+    const builder: any = {
+      provideScript: () => builder,
+      complete: async () => {
+        throw new Error("complete: Could not resolve script hash deadbeef1234");
+      },
+    };
+
+    await expect(
+      completeWithScripts(builder, undefined, undefined),
+    ).rejects.toThrow("Could not resolve script hash deadbeef1234");
+  });
+
+  test("throws non-script errors without retry", async () => {
+    const builder: any = {
+      provideScript: () => builder,
+      complete: async () => {
+        throw new Error("some other error");
+      },
+    };
+
+    const context = {
+      sprinkle: {
+        addressbook: {
+          "my-sig": { Signature: { key_hash: "a".repeat(56) } },
+        },
+      },
+      settings: {},
+    } as any;
+
+    await expect(
+      completeWithScripts(builder, undefined, context),
+    ).rejects.toThrow("some other error");
+  });
+});