@sundaeswap/sprinkles 0.6.1 → 0.8.0

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");
+  });
+});

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

@@ -0,0 +1,325 @@
+import { describe, expect, test, mock, beforeEach } from "bun:test";
+import { Type } from "@sinclair/typebox";
+import { promptAndExecute } from "../actions/tui-helpers.js";
+import { UserCancelledError } from "../types.js";
+import type { IAction } from "../actions/types.js";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+// Minimal action used throughout these tests
+const greetAction: IAction<{ name: string }, { greeting: string }, any> = {
+  name: "greet",
+  description: "Greets someone",
+  inputSchema: Type.Object({ name: Type.String() }),
+  outputSchema: Type.Object({ greeting: Type.String() }),
+  execute: async (input: { name: string }) => ({
+    greeting: `Hello, ${input.name}!`,
+  }),
+};
+
+// Build a minimal Sprinkle-shaped mock.  promptAndExecute only calls:
+//   - sprinkle.FillInStruct(schema, defaults)
+//   - sprinkle.settings  (read once for context)
+// so we only need those two members.
+function makeMockSprinkle(fillInStructImpl: (schema: any, defaults?: any) => Promise<any>) {
+  return {
+    FillInStruct: mock(fillInStructImpl),
+    settings: { apiUrl: "https://example.com" },
+  } as any;
+}
+
+// ---------------------------------------------------------------------------
+// describe: promptAndExecute – success path
+// ---------------------------------------------------------------------------
+
+describe("promptAndExecute – success path", () => {
+  test("returns success result when FillInStruct resolves", async () => {
+    const sprinkle = makeMockSprinkle(async () => ({ name: "Alice" }));
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data).toEqual({ greeting: "Hello, Alice!" });
+    }
+  });
+
+  test("passes the schema from the action to FillInStruct", async () => {
+    let capturedSchema: any;
+    const sprinkle = makeMockSprinkle(async (schema: any) => {
+      capturedSchema = schema;
+      return { name: "Bob" };
+    });
+
+    await promptAndExecute(sprinkle, greetAction);
+
+    expect(capturedSchema).toBe(greetAction.inputSchema);
+  });
+
+  test("passes action execute function the validated input", async () => {
+    let capturedInput: any;
+    const action = {
+      ...greetAction,
+      execute: async (input: { name: string }) => {
+        capturedInput = input;
+        return { greeting: `Hi, ${input.name}!` };
+      },
+    };
+    const sprinkle = makeMockSprinkle(async () => ({ name: "Charlie" }));
+
+    await promptAndExecute(sprinkle, action);
+
+    expect(capturedInput).toEqual({ name: "Charlie" });
+  });
+
+  test("provides the sprinkle instance via context to execute", async () => {
+    let capturedContext: any;
+    const action = {
+      ...greetAction,
+      execute: async (_input: any, ctx: any) => {
+        capturedContext = ctx;
+        return { greeting: "hi" };
+      },
+    };
+    const sprinkle = makeMockSprinkle(async () => ({ name: "Dan" }));
+
+    await promptAndExecute(sprinkle, action);
+
+    // The context's sprinkle should refer to the same mock instance
+    expect(capturedContext).toBeDefined();
+    expect(capturedContext.sprinkle).toBe(sprinkle);
+  });
+
+  test("provides sprinkle.settings via context to execute", async () => {
+    let capturedSettings: any;
+    const action = {
+      ...greetAction,
+      execute: async (_input: any, ctx: any) => {
+        capturedSettings = ctx.settings;
+        return { greeting: "hi" };
+      },
+    };
+    const sprinkle = makeMockSprinkle(async () => ({ name: "Eve" }));
+
+    await promptAndExecute(sprinkle, action);
+
+    expect(capturedSettings).toEqual({ apiUrl: "https://example.com" });
+  });
+
+  test("returns failure when execute throws an Error", async () => {
+    const action = {
+      ...greetAction,
+      execute: async () => {
+        throw new Error("execute failed");
+      },
+    };
+    const sprinkle = makeMockSprinkle(async () => ({ name: "Fail" }));
+
+    const result = await promptAndExecute(sprinkle, action);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("EXECUTION_ERROR");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// describe: promptAndExecute – defaults parameter
+// ---------------------------------------------------------------------------
+
+describe("promptAndExecute – defaults parameter", () => {
+  test("passes defaults to FillInStruct when provided", async () => {
+    let capturedDefaults: any;
+    const sprinkle = makeMockSprinkle(async (_schema: any, defaults: any) => {
+      capturedDefaults = defaults;
+      return { name: "Frank" };
+    });
+
+    await promptAndExecute(sprinkle, greetAction, { name: "Frank" });
+
+    expect(capturedDefaults).toEqual({ name: "Frank" });
+  });
+
+  test("passes undefined to FillInStruct when defaults are omitted", async () => {
+    let capturedDefaults: any = "sentinel";
+    const sprinkle = makeMockSprinkle(async (_schema: any, defaults: any) => {
+      capturedDefaults = defaults;
+      return { name: "Grace" };
+    });
+
+    await promptAndExecute(sprinkle, greetAction);
+
+    expect(capturedDefaults).toBeUndefined();
+  });
+
+  test("passes partial defaults to FillInStruct", async () => {
+    // Action with multiple fields so we can supply only some defaults
+    const multiAction: IAction<{ name: string; count: number }, { result: string }, any> = {
+      name: "multi",
+      description: "Takes multiple fields",
+      inputSchema: Type.Object({ name: Type.String(), count: Type.Number() }),
+      outputSchema: Type.Object({ result: Type.String() }),
+      execute: async (input) => ({ result: `${input.name}:${input.count}` }),
+    };
+
+    let capturedDefaults: any;
+    const sprinkle = makeMockSprinkle(async (_schema: any, defaults: any) => {
+      capturedDefaults = defaults;
+      return { name: "Henry", count: 42 };
+    });
+
+    await promptAndExecute(sprinkle, multiAction, { name: "Henry" });
+
+    expect(capturedDefaults).toEqual({ name: "Henry" });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// describe: promptAndExecute – UserCancelledError handling
+// ---------------------------------------------------------------------------
+
+describe("promptAndExecute – UserCancelledError handling", () => {
+  test("returns IActionFailure with code USER_CANCELLED when FillInStruct throws UserCancelledError", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new UserCancelledError("cancelled");
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("USER_CANCELLED");
+    }
+  });
+
+  test("does not throw when FillInStruct throws UserCancelledError", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new UserCancelledError();
+    });
+
+    // Should resolve (not reject)
+    await expect(promptAndExecute(sprinkle, greetAction)).resolves.toBeDefined();
+  });
+
+  test("USER_CANCELLED failure has a descriptive message", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new UserCancelledError("user pressed escape");
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(typeof result.error.message).toBe("string");
+      expect(result.error.message.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("USER_CANCELLED failure carries the original UserCancelledError as details", async () => {
+    const cancelled = new UserCancelledError("esc pressed");
+    const sprinkle = makeMockSprinkle(async () => {
+      throw cancelled;
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.details).toBe(cancelled);
+    }
+  });
+
+  test("does not call execute when FillInStruct throws UserCancelledError", async () => {
+    let executeCalled = false;
+    const action = {
+      ...greetAction,
+      execute: async (_input: any) => {
+        executeCalled = true;
+        return { greeting: "hi" };
+      },
+    };
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new UserCancelledError();
+    });
+
+    await promptAndExecute(sprinkle, action);
+
+    expect(executeCalled).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// describe: promptAndExecute – unexpected FillInStruct errors
+// ---------------------------------------------------------------------------
+
+describe("promptAndExecute – unexpected FillInStruct errors", () => {
+  test("returns IActionFailure with code PROMPT_ERROR when FillInStruct throws a non-UserCancelledError", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new Error("TTY not available");
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("PROMPT_ERROR");
+    }
+  });
+
+  test("PROMPT_ERROR message includes the original error message", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new Error("underlying prompt failure");
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.message).toContain("underlying prompt failure");
+    }
+  });
+
+  test("does not throw when FillInStruct throws an unexpected error", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new Error("unexpected");
+    });
+
+    await expect(promptAndExecute(sprinkle, greetAction)).resolves.toBeDefined();
+  });
+
+  test("PROMPT_ERROR result includes non-Error thrown values in message", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      // eslint-disable-next-line @typescript-eslint/only-throw-error
+      throw "some string error";
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("PROMPT_ERROR");
+      expect(result.error.message).toContain("some string error");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// describe: promptAndExecute – input validation
+// ---------------------------------------------------------------------------
+
+describe("promptAndExecute – input validation", () => {
+  test("returns VALIDATION_ERROR when FillInStruct returns data that fails schema validation", async () => {
+    // FillInStruct returns a value that does not conform to the inputSchema
+    const sprinkle = makeMockSprinkle(async () => ({ name: 42 })); // name should be a string
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("VALIDATION_ERROR");
+    }
+  });
+});