@kontor/kontor-sdk 1.0.0-alpha.39 → 1.0.0-alpha.40

package/src/sdk/types/contract.test-d.ts

@@ -5,9 +5,10 @@ import type {
   ContractFunctionReturnType,
 } from "./contract.js";
 import { nativeToken as nativeToken_ } from "../contracts/wits.js";
+import { parseWit } from "../../wit/wit-parser/parse-wit.js";
+import type { WitError } from "src/wit/built-ins.js";
 
 const nativeToken = nativeToken_.wit;
-
 test("ContractFunctionName", () => {
   type All = ContractFunctionName<typeof nativeToken>;
   expectTypeOf<All>().toEqualTypeOf<
@@ -63,31 +64,25 @@ test("ContractFunctionArgs", () => {
 test("ContractFunctionReturnType", () => {
   type Mint = ContractFunctionReturnType<typeof nativeToken, "proc", "mint">;
   expectTypeOf<Mint>().toEqualTypeOf<
-    | {
-        ok: false;
-        error: string;
-      }
-    | {
-        ok: true;
-        value: {
+    | ["err", WitError.T]
+    | [
+        "ok",
+        {
           dst: string;
           amt: [bigint, number];
-        };
-      }
+        },
+      ]
   >;
   type Burn = ContractFunctionReturnType<typeof nativeToken, "proc", "burn">;
   expectTypeOf<Burn>().toEqualTypeOf<
-    | {
-        ok: false;
-        error: string;
-      }
-    | {
-        ok: true;
-        value: {
+    | ["err", WitError.T]
+    | [
+        "ok",
+        {
           src: string;
           amt: [bigint, number];
-        };
-      }
+        },
+      ]
   >;
 
   type Transfer = ContractFunctionReturnType<
@@ -96,33 +91,22 @@ test("ContractFunctionReturnType", () => {
     "transfer"
   >;
   expectTypeOf<Transfer>().toEqualTypeOf<
-    | {
-        ok: false;
-        error: string;
-      }
-    | {
-        ok: true;
-        value: {
+    | ["err", WitError.T]
+    | [
+        "ok",
+        {
           src: string;
           dst: string;
           amt: [bigint, number];
-        };
-      }
+        },
+      ]
   >;
   type Balance = ContractFunctionReturnType<
     typeof nativeToken,
     "view",
     "balance"
   >;
-  expectTypeOf<Balance>().toEqualTypeOf<
-    | {
-        kind: "none";
-      }
-    | {
-        kind: "some";
-        value: [bigint, number];
-      }
-  >;
+  expectTypeOf<Balance>().toEqualTypeOf<["none"] | ["some", [bigint, number]]>;
 
   type Balances = ContractFunctionReturnType<
     typeof nativeToken,
@@ -146,18 +130,15 @@ test("ContractFunctionReturnType", () => {
     "attach"
   >;
   expectTypeOf<Attach>().toEqualTypeOf<
-    | {
-        ok: false;
-        error: string;
-      }
-    | {
-        ok: true;
-        value: {
+    | ["err", WitError.T]
+    | [
+        "ok",
+        {
           src: string;
           dst: string;
           amt: [bigint, number];
-        };
-      }
+        },
+      ]
   >;
 
   type Detach = ContractFunctionReturnType<
@@ -166,17 +147,470 @@ test("ContractFunctionReturnType", () => {
     "detach"
   >;
   expectTypeOf<Detach>().toEqualTypeOf<
-    | {
-        ok: false;
-        error: string;
-      }
-    | {
-        ok: true;
-        value: {
+    | ["err", WitError.T]
+    | [
+        "ok",
+        {
           src: string;
           dst: string;
           amt: [bigint, number];
-        };
-      }
+        },
+      ]
+  >;
+});
+
+// Color Palette Contract - demonstrates variants and enums in WIT
+const colorPaletteWit = [
+  // Records
+  "record rgb { r: u8, g: u8, b: u8 }",
+  "record hsv { h: u16, s: u8, v: u8 }",
+  "record palette-info { name: string, size: u32, owner: string }",
+
+  // Enums
+  "enum palette-status { active, archived, locked, readonly }",
+  "enum sort-order { alphabetical, creation-date, usage-count }",
+
+  // Variants
+  "variant color { hex(string), rgb(rgb), hsv(hsv), named(string) }",
+  "variant query { by-name(string), by-index(u32), all, by-status(palette-status) }",
+  "variant palette-event { created(palette-info), color-added(color), color-removed(u32), status-changed(palette-status) }",
+
+  // Proc functions
+  "export add-color: func(ctx: borrow<proc-context>, c: color) -> result<list<color>, error>;",
+  "export remove-color: func(ctx: borrow<proc-context>, index: u32) -> result<color, error>;",
+  "export set-status: func(ctx: borrow<proc-context>, status: palette-status) -> result<palette-status, error>;",
+  "export sort-colors: func(ctx: borrow<proc-context>, order: sort-order) -> result<_, error>;",
+
+  // View functions
+  "export get-colors: func(ctx: borrow<view-context>) -> list<color>;",
+  "export get-color: func(ctx: borrow<view-context>, index: u32) -> option<color>;",
+  "export get-status: func(ctx: borrow<view-context>) -> palette-status;",
+  "export get-info: func(ctx: borrow<view-context>) -> palette-info;",
+  "export query-colors: func(ctx: borrow<view-context>, q: query) -> list<color>;",
+  "export find-color: func(ctx: borrow<view-context>, c: color) -> option<u32>;",
+  "export get-recent-events: func(ctx: borrow<view-context>, limit: u32) -> list<palette-event>;",
+] as const;
+
+const colorPalette = parseWit(colorPaletteWit);
+
+test("ContractFunctionName - color palette", () => {
+  type All = ContractFunctionName<typeof colorPalette>;
+  expectTypeOf<All>().toEqualTypeOf<
+    | "add-color"
+    | "remove-color"
+    | "set-status"
+    | "sort-colors"
+    | "get-colors"
+    | "get-color"
+    | "get-status"
+    | "get-info"
+    | "query-colors"
+    | "find-color"
+    | "get-recent-events"
+  >;
+
+  type View = ContractFunctionName<typeof colorPalette, "view">;
+  expectTypeOf<View>().toEqualTypeOf<
+    | "get-colors"
+    | "get-color"
+    | "get-status"
+    | "get-info"
+    | "query-colors"
+    | "find-color"
+    | "get-recent-events"
+  >;
+
+  type Proc = ContractFunctionName<typeof colorPalette, "proc">;
+  expectTypeOf<Proc>().toEqualTypeOf<
+    "add-color" | "remove-color" | "set-status" | "sort-colors"
+  >;
+});
+
+test("ContractFunctionArgs - procs with variants and enums", () => {
+  // Proc with variant parameter
+  //
+  type AddColor = ContractFunctionArgs<
+    typeof colorPalette,
+    "proc",
+    "add-color"
+  >;
+
+  expectTypeOf<AddColor>().toEqualTypeOf<
+    readonly [
+      | ["hex", string]
+      | ["rgb", { r: number; g: number; b: number }]
+      | ["hsv", { h: number; s: number; v: number }]
+      | ["named", string],
+    ]
   >;
+
+  // Proc with simple parameter
+  type RemoveColor = ContractFunctionArgs<
+    typeof colorPalette,
+    "proc",
+    "remove-color"
+  >;
+  expectTypeOf<RemoveColor>().toEqualTypeOf<readonly [number]>;
+
+  // Proc with enum parameter
+  type SetStatus = ContractFunctionArgs<
+    typeof colorPalette,
+    "proc",
+    "set-status"
+  >;
+  expectTypeOf<SetStatus>().toEqualTypeOf<
+    readonly ["active" | "archived" | "locked" | "readonly"]
+  >;
+
+  // Proc with enum parameter
+  type SortColors = ContractFunctionArgs<
+    typeof colorPalette,
+    "proc",
+    "sort-colors"
+  >;
+  expectTypeOf<SortColors>().toEqualTypeOf<
+    readonly ["alphabetical" | "creation-date" | "usage-count"]
+  >;
+});
+test("ContractFunctionArgs - views with variants and enums", () => {
+  // View with no parameters
+  type GetColors = ContractFunctionArgs<
+    typeof colorPalette,
+    "view",
+    "get-colors"
+  >;
+  expectTypeOf<GetColors>().toEqualTypeOf<readonly []>;
+
+  // View with simple parameter
+  type GetColor = ContractFunctionArgs<
+    typeof colorPalette,
+    "view",
+    "get-color"
+  >;
+  expectTypeOf<GetColor>().toEqualTypeOf<readonly [number]>;
+
+  // View with no parameters
+  type GetStatus = ContractFunctionArgs<
+    typeof colorPalette,
+    "view",
+    "get-status"
+  >;
+  expectTypeOf<GetStatus>().toEqualTypeOf<readonly []>;
+
+  // View with no parameters
+  type GetInfo = ContractFunctionArgs<typeof colorPalette, "view", "get-info">;
+  expectTypeOf<GetInfo>().toEqualTypeOf<readonly []>;
+
+  // View with variant parameter
+  type QueryColors = ContractFunctionArgs<
+    typeof colorPalette,
+    "view",
+    "query-colors"
+  >;
+
+  expectTypeOf<QueryColors>().toEqualTypeOf<
+    readonly [
+      | ["by-name", string]
+      | ["by-index", number]
+      | ["all"]
+      | ["by-status", "active" | "archived" | "locked" | "readonly"],
+    ]
+  >;
+
+  // View with variant parameter
+  type FindColor = ContractFunctionArgs<
+    typeof colorPalette,
+    "view",
+    "find-color"
+  >;
+  expectTypeOf<FindColor>().toEqualTypeOf<
+    readonly [
+      | ["hex", string]
+      | ["rgb", { r: number; g: number; b: number }]
+      | ["hsv", { h: number; s: number; v: number }]
+      | ["named", string],
+    ]
+  >;
+
+  // View with simple parameter
+  type GetRecentEvents = ContractFunctionArgs<
+    typeof colorPalette,
+    "view",
+    "get-recent-events"
+  >;
+  expectTypeOf<GetRecentEvents>().toEqualTypeOf<readonly [number]>;
+});
+
+test("ContractFunctionReturnType - procs with variants and enums", () => {});
+// Proc returning list of variants
+// type AddColor = ContractFunctionReturnType<
+//   typeof colorPalette,
+//   "proc",
+//   "add-color"
+// >;
+// expectTypeOf<AddColor>().toEqualTypeOf<
+//   | { ok: false; error: string }
+//   | {
+//       ok: true;
+//       value: readonly (
+//         | { kind: "hex"; value: string }
+//         | { kind: "rgb"; value: { r: number; g: number; b: number } }
+//         | { kind: "hsv"; value: { h: number; s: number; v: number } }
+//         | { kind: "named"; value: string }
+//       )[];
+//     }
+// >;
+//
+//   // Proc returning variant
+//   type RemoveColor = ContractFunctionReturnType<
+//     typeof colorPalette,
+//     "proc",
+//     "remove-color"
+//   >;
+//   expectTypeOf<RemoveColor>().toEqualTypeOf<
+//     | { ok: false; error: string }
+//     | {
+//         ok: true;
+//         value:
+//           | { kind: "hex"; value: string }
+//           | { kind: "rgb"; value: { r: number; g: number; b: number } }
+//           | { kind: "hsv"; value: { h: number; s: number; v: number } }
+//           | { kind: "named"; value: string };
+//       }
+//   >;
+//
+//   // Proc returning enum
+//   type SetStatus = ContractFunctionReturnType<
+//     typeof colorPalette,
+//     "proc",
+//     "set-status"
+//   >;
+//   expectTypeOf<SetStatus>().toEqualTypeOf<
+//     | { ok: false; error: string }
+//     | { ok: true; value: "active" | "archived" | "locked" | "readonly" }
+//   >;
+//
+//   // Proc returning unit (result<_, error>)
+//   type SortColors = ContractFunctionReturnType<
+//     typeof colorPalette,
+//     "proc",
+//     "sort-colors"
+//   >;
+//   expectTypeOf<SortColors>().toEqualTypeOf<
+//     { ok: false; error: string } | { ok: true; value: undefined }
+//   >;
+//
+//   // Proc returning count
+//   type BatchAdd = ContractFunctionReturnType<
+//     typeof colorPalette,
+//     "proc",
+//     "batch-add"
+//   >;
+//   expectTypeOf<BatchAdd>().toEqualTypeOf<
+//     { ok: false; error: string } | { ok: true; value: number }
+//   >;
+// });
+//
+// });
+test("ContractFunctionReturnType - views with variants and enums", () => {
+  // View returning list of variants
+  type GetColors = ContractFunctionReturnType<
+    typeof colorPalette,
+    "view",
+    "get-colors"
+  >;
+  expectTypeOf<GetColors>().toEqualTypeOf<
+    readonly (
+      | ["hex", string]
+      | ["rgb", { r: number; g: number; b: number }]
+      | ["hsv", { h: number; s: number; v: number }]
+      | ["named", string]
+    )[]
+  >;
+
+  // View returning option of variant
+  type GetColor = ContractFunctionReturnType<
+    typeof colorPalette,
+    "view",
+    "get-color"
+  >;
+  expectTypeOf<GetColor>().toEqualTypeOf<
+    | ["none"]
+    | [
+        "some",
+        (
+          | ["hex", string]
+          | ["named", string]
+          | [
+              "rgb",
+              {
+                r: number;
+                g: number;
+                b: number;
+              },
+            ]
+          | [
+              "hsv",
+              {
+                h: number;
+                s: number;
+                v: number;
+              },
+            ]
+        ),
+      ]
+  >;
+
+  // View returning enum
+  type GetStatus = ContractFunctionReturnType<
+    typeof colorPalette,
+    "view",
+    "get-status"
+  >;
+  expectTypeOf<GetStatus>().toEqualTypeOf<
+    "active" | "archived" | "locked" | "readonly"
+  >;
+
+  // View returning record
+  type GetInfo = ContractFunctionReturnType<
+    typeof colorPalette,
+    "view",
+    "get-info"
+  >;
+  expectTypeOf<GetInfo>().toEqualTypeOf<{
+    name: string;
+    size: number;
+    owner: string;
+  }>;
+
+  // View returning list of variants
+  type QueryColors = ContractFunctionReturnType<
+    typeof colorPalette,
+    "view",
+    "query-colors"
+  >;
+  expectTypeOf<QueryColors>().toEqualTypeOf<
+    readonly (
+      | ["hex", string]
+      | ["rgb", { r: number; g: number; b: number }]
+      | ["hsv", { h: number; s: number; v: number }]
+      | ["named", string]
+    )[]
+  >;
+
+  // View returning option of number
+  type FindColor = ContractFunctionReturnType<
+    typeof colorPalette,
+    "view",
+    "find-color"
+  >;
+  expectTypeOf<FindColor>().toEqualTypeOf<["none"] | ["some", number]>;
+
+  // View returning list of variants (events)
+  type GetRecentEvents = ContractFunctionReturnType<
+    typeof colorPalette,
+    "view",
+    "get-recent-events"
+  >;
+  expectTypeOf<GetRecentEvents>().toEqualTypeOf<
+    readonly (
+      | [
+          "created",
+          {
+            name: string;
+            size: number;
+            owner: string;
+          },
+        ]
+      | [
+          "color-added",
+          (
+            | ["hex", string]
+            | ["named", string]
+            | [
+                "rgb",
+                {
+                  r: number;
+                  g: number;
+                  b: number;
+                },
+              ]
+            | [
+                "hsv",
+                {
+                  h: number;
+                  s: number;
+                  v: number;
+                },
+              ]
+          ),
+        ]
+      | ["color-removed", number]
+      | ["status-changed", "active" | "archived" | "locked" | "readonly"]
+    )[]
+  >;
+});
+//
+test("Complex nested variant and enum patterns", () => {
+  // Variant containing an enum
+  type QueryWithEnum = ContractFunctionArgs<
+    typeof colorPalette,
+    "view",
+    "query-colors"
+  >;
+  type QueryVariant = QueryWithEnum[0];
+
+  // Should be able to construct query with enum
+  expectTypeOf<QueryVariant>().toEqualTypeOf<
+    | ["by-name", string]
+    | ["by-index", number]
+    | ["all"]
+    | ["by-status", "active" | "archived" | "locked" | "readonly"]
+  >();
+
+  // Variant containing another variant
+  type EventWithVariant = ContractFunctionReturnType<
+    typeof colorPalette,
+    "view",
+    "get-recent-events"
+  >;
+
+  // Should be able to construct event with nested color variant
+  expectTypeOf<EventWithVariant>().toEqualTypeOf<
+    readonly (
+      | ["color-removed", number]
+      | ["status-changed", "active" | "archived" | "locked" | "readonly"]
+      | [
+          "created",
+          {
+            name: string;
+            size: number;
+            owner: string;
+          },
+        ]
+      | [
+          "color-added",
+          (
+            | ["hex", string]
+            | ["named", string]
+            | [
+                "rgb",
+                {
+                  r: number;
+                  g: number;
+                  b: number;
+                },
+              ]
+            | [
+                "hsv",
+                {
+                  h: number;
+                  s: number;
+                  v: number;
+                },
+              ]
+          ),
+        ]
+    )[]
+  >();
 });

package/src/sdk/types/contract.ts

@@ -89,7 +89,6 @@ export type Widen<T> =
       : never);
 
 export type UnionWiden<type> = type extends any ? Widen<type> : never;
-
 export type ContractFunctionParameters<
   wit extends Wit | readonly unknown[] = Wit,
   mutability extends WitStateMutability = WitStateMutability,
@@ -107,12 +106,12 @@ export type ContractFunctionParameters<
 > = {
   wit: wit;
   functionName:
-    | allFunctionNames // show all options
-    | (functionName extends allFunctionNames ? functionName : never); // infer value
-  args?: (wit extends Wit ? UnionWiden<args> : never) | allArgs | undefined;
-} & (readonly [] extends allArgs ? {} : { args: Widen<args> }) & {
-    contractAddress: ResolvedRegister["contractAddress"];
-  };
+    | allFunctionNames
+    | (functionName extends allFunctionNames ? functionName : never);
+  contractAddress: ResolvedRegister["contractAddress"];
+} & (readonly [] extends allArgs
+  ? { args?: allArgs | undefined } // Changed: allow allArgs (readonly []) or undefined
+  : { args: args });
 
 export type ContractFunctionReturnType<
   wit extends Wit | readonly unknown[] = Wit,

package/src/sdk/utils/wit/codecs/bool.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from "vitest";
+import { BoolCodec } from "./bool.js";
+
+describe("BoolCodec", () => {
+  it("decodes true/false (with whitespace)", () => {
+    expect(BoolCodec.decodeWave("true")).toBe(true);
+    expect(BoolCodec.decodeWave("false")).toBe(false);
+    expect(BoolCodec.decodeWave("  true  ")).toBe(true);
+    expect(BoolCodec.decodeWave("\nfalse\t")).toBe(false);
+  });
+
+  it("encodes true/false", () => {
+    expect(BoolCodec.encodeWave(true)).toBe("true");
+    expect(BoolCodec.encodeWave(false)).toBe("false");
+  });
+
+  it("round-trips", () => {
+    for (const v of [true, false]) {
+      expect(BoolCodec.decodeWave(BoolCodec.encodeWave(v))).toBe(v);
+    }
+  });
+
+  it("throws on invalid input", () => {
+    expect(() => BoolCodec.decodeWave("True")).toThrow("invalid bool: True");
+    expect(() => BoolCodec.decodeWave("0")).toThrow("invalid bool: 0");
+    expect(() => BoolCodec.decodeWave("null")).toThrow("invalid bool: null");
+    expect(() => BoolCodec.decodeWave("")).toThrow("invalid bool:");
+  });
+});

package/src/sdk/utils/wit/codecs/bool.ts

@@ -1,29 +1,14 @@
-import type { CodecConstructor, CodecInstance, WaveExpr } from "./types.js";
+import type { Codec } from "./types.js";
 
-export const BoolCodec = {
-  fromJs(value: boolean) {
-    return {
-      toWave(): WaveExpr {
-        return `${value}` as WaveExpr;
-      },
-      toJs(): boolean {
-        return value;
-      },
-    };
+export const BoolCodec: Codec<boolean> = {
+  decodeWave(expr: string): boolean {
+    const s = expr.trim();
+    if (s === "true") return true;
+    if (s === "false") return false;
+    throw new Error(`invalid bool: ${expr}`);
   },
 
-  fromKontor(data: boolean) {
-    return {
-      toWave(): WaveExpr {
-        return `${data}` as WaveExpr;
-      },
-      toJs(): boolean {
-        return data as boolean;
-      },
-    };
+  encodeWave(value: boolean): string {
+    return value ? "true" : "false";
   },
-
-  parseWave(expr: string): boolean {
-    return JSON.parse(expr);
-  },
-} as unknown as CodecConstructor<boolean, CodecInstance<boolean>, boolean>;
+};