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

package/src/sdk/utils/wit/decode-wit-parameter.test.ts

@@ -12,30 +12,393 @@ describe("parseWitRecord", () => {
   });
 });
 
-describe("decodeParameter", () => {
+// ============================================================================
+// STRING TYPES
+// ============================================================================
+
+describe("string types", () => {
   test("string", () => {
     const decoded = decodeWitParameter('"0xdeadbeef"', {
       type: "string",
     });
-
     expect(decoded).toEqual({ decoded: "0xdeadbeef" });
   });
+
+  test("option<string> - some", () => {
+    const decoded = decodeWitParameter('some("hello")', {
+      type: "option<string>",
+    });
+    expect(decoded).toEqual({ decoded: ["some", "hello"] });
+  });
+
+  test("option<string> - none", () => {
+    const decoded = decodeWitParameter("none", {
+      type: "option<string>",
+    });
+    expect(decoded).toEqual({ decoded: ["none"] });
+  });
+
+  test("list<string>", () => {
+    const decoded = decodeWitParameter('["apple", "banana", "cherry"]', {
+      type: "list<string>",
+    });
+    expect(decoded).toEqual({ decoded: ["apple", "banana", "cherry"] });
+  });
+
+  test("result<string, error> - ok", () => {
+    const decoded = decodeWitParameter('ok("success")', {
+      type: "result<string, error>",
+    });
+    expect(decoded).toEqual({ decoded: ["ok", "success"] });
+  });
+
+  test("result<string, error> - err", () => {
+    const decoded = decodeWitParameter('err(message("error occurred"))', {
+      type: "result<string, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["err", ["message", "error occurred"]],
+    });
+  });
+});
+
+// ============================================================================
+// DECIMAL TYPES
+// ============================================================================
+
+describe("decimal types", () => {
   test("decimal", () => {
     const decoded = decodeWitParameter(
       "{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}",
-      {
-        type: "decimal",
-      },
+      { type: "decimal" },
     );
-
     expect(decoded).toEqual({ decoded: [7n, 18] });
   });
 
-  test("tuple", () => {
+  test("option<decimal> - some", () => {
+    const decoded = decodeWitParameter(
+      "some({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})",
+      { type: "option<decimal>" },
+    );
+    expect(decoded).toEqual({ decoded: ["some", [7n, 18]] });
+  });
+
+  test("option<decimal> - none", () => {
+    const decoded = decodeWitParameter("none", { type: "option<decimal>" });
+    expect(decoded).toEqual({ decoded: ["none"] });
+  });
+
+  test("list<decimal>", () => {
+    const decoded = decodeWitParameter(
+      "[{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 8, r1: 0, r2: 0, r3: 0, sign: plus}]",
+      { type: "list<decimal>" },
+    );
+    expect(decoded).toEqual({
+      decoded: [
+        [7n, 18],
+        [8n, 18],
+      ],
+    });
+  });
+
+  test("result<decimal, error> - ok", () => {
+    const decoded = decodeWitParameter(
+      "ok({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})",
+      { type: "result<decimal, error>" },
+    );
+    expect(decoded).toEqual({ decoded: ["ok", [7n, 18]] });
+  });
+
+  test("result<decimal, error> - err", () => {
+    const decoded = decodeWitParameter('err(overflow("too big"))', {
+      type: "result<decimal, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["err", ["overflow", "too big"]],
+    });
+  });
+});
+
+// ============================================================================
+// BOOL TYPES
+// ============================================================================
+
+describe("bool types", () => {
+  test("bool - true", () => {
+    const decoded = decodeWitParameter("true", { type: "bool" });
+    expect(decoded).toEqual({ decoded: true });
+  });
+
+  test("bool - false", () => {
+    const decoded = decodeWitParameter("false", { type: "bool" });
+    expect(decoded).toEqual({ decoded: false });
+  });
+
+  test("option<bool> - some", () => {
+    const decoded = decodeWitParameter("some(true)", { type: "option<bool>" });
+    expect(decoded).toEqual({ decoded: ["some", true] });
+  });
+
+  test("option<bool> - none", () => {
+    const decoded = decodeWitParameter("none", { type: "option<bool>" });
+    expect(decoded).toEqual({ decoded: ["none"] });
+  });
+
+  test("list<bool>", () => {
+    const decoded = decodeWitParameter("[true, false, true]", {
+      type: "list<bool>",
+    });
+    expect(decoded).toEqual({ decoded: [true, false, true] });
+  });
+
+  test("result<bool, error> - ok", () => {
+    const decoded = decodeWitParameter("ok(true)", {
+      type: "result<bool, error>",
+    });
+    expect(decoded).toEqual({ decoded: ["ok", true] });
+  });
+});
+
+// ============================================================================
+// INTEGER TYPES
+// ============================================================================
+
+describe("integer types", () => {
+  test("integer", () => {
+    const decoded = decodeWitParameter(
+      "{r0: 42, r1: 0, r2: 0, r3: 0, sign: plus}",
+      { type: "integer" },
+    );
+    expect(decoded).toEqual({ decoded: 42n });
+  });
+
+  test("option<integer> - some", () => {
+    const decoded = decodeWitParameter(
+      "some({r0: 42, r1: 0, r2: 0, r3: 0, sign: plus})",
+      { type: "option<integer>" },
+    );
+    expect(decoded).toEqual({ decoded: ["some", 42n] });
+  });
+
+  test("list<integer>", () => {
+    const decoded = decodeWitParameter(
+      "[{r0: 1, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 2, r1: 0, r2: 0, r3: 0, sign: plus}]",
+      { type: "list<integer>" },
+    );
+    expect(decoded).toEqual({ decoded: [1n, 2n] });
+  });
+
+  test("result<integer, error> - ok", () => {
+    const decoded = decodeWitParameter(
+      "ok({r0: 42, r1: 0, r2: 0, r3: 0, sign: plus})",
+      { type: "result<integer, error>" },
+    );
+    expect(decoded).toEqual({ decoded: ["ok", 42n] });
+  });
+});
+
+// ============================================================================
+// UNSIGNED INTEGER TYPES (u8, u16, u32, u64)
+// ============================================================================
+
+describe("unsigned integer types", () => {
+  test("u8", () => {
+    const decoded = decodeWitParameter("255", { type: "u8" });
+    expect(decoded).toEqual({ decoded: 255 });
+  });
+
+  test("option<u8>", () => {
+    const decoded = decodeWitParameter("some(128)", { type: "option<u8>" });
+    expect(decoded).toEqual({ decoded: ["some", 128] });
+  });
+
+  test("list<u8>", () => {
+    const decoded = decodeWitParameter("[1, 2, 3]", { type: "list<u8>" });
+    expect(decoded).toEqual({ decoded: [1, 2, 3] });
+  });
+
+  test("result<u8, error>", () => {
+    const decoded = decodeWitParameter("ok(42)", { type: "result<u8, error>" });
+    expect(decoded).toEqual({ decoded: ["ok", 42] });
+  });
+
+  test("u16", () => {
+    const decoded = decodeWitParameter("65535", { type: "u16" });
+    expect(decoded).toEqual({ decoded: 65535 });
+  });
+
+  test("option<u16>", () => {
+    const decoded = decodeWitParameter("some(1000)", { type: "option<u16>" });
+    expect(decoded).toEqual({ decoded: ["some", 1000] });
+  });
+
+  test("list<u16>", () => {
+    const decoded = decodeWitParameter("[100, 200]", { type: "list<u16>" });
+    expect(decoded).toEqual({ decoded: [100, 200] });
+  });
+
+  test("result<u16, error>", () => {
+    const decoded = decodeWitParameter("ok(500)", {
+      type: "result<u16, error>",
+    });
+    expect(decoded).toEqual({ decoded: ["ok", 500] });
+  });
+
+  test("u32", () => {
+    const decoded = decodeWitParameter("4294967295", { type: "u32" });
+    expect(decoded).toEqual({ decoded: 4294967295 });
+  });
+
+  test("option<u32>", () => {
+    const decoded = decodeWitParameter("some(1000000)", {
+      type: "option<u32>",
+    });
+    expect(decoded).toEqual({ decoded: ["some", 1000000] });
+  });
+
+  test("list<u32>", () => {
+    const decoded = decodeWitParameter("[1000, 2000]", { type: "list<u32>" });
+    expect(decoded).toEqual({ decoded: [1000, 2000] });
+  });
+
+  test("result<u32, error>", () => {
+    const decoded = decodeWitParameter("ok(123456)", {
+      type: "result<u32, error>",
+    });
+    expect(decoded).toEqual({ decoded: ["ok", 123456] });
+  });
+
+  test("u64", () => {
+    const decoded = decodeWitParameter("30", { type: "u64" });
+    expect(decoded).toEqual({ decoded: 30n });
+  });
+
+  test("option<u64>", () => {
+    const decoded = decodeWitParameter("some(999)", { type: "option<u64>" });
+    expect(decoded).toEqual({ decoded: ["some", 999n] });
+  });
+
+  test("list<u64>", () => {
+    const decoded = decodeWitParameter("[100, 200, 300]", {
+      type: "list<u64>",
+    });
+    expect(decoded).toEqual({ decoded: [100n, 200n, 300n] });
+  });
+
+  test("result<u64, error>", () => {
+    const decoded = decodeWitParameter("ok(777)", {
+      type: "result<u64, error>",
+    });
+    expect(decoded).toEqual({ decoded: ["ok", 777n] });
+  });
+});
+
+// ============================================================================
+// SIGNED INTEGER TYPES (s8, s16, s32, s64)
+// ============================================================================
+
+describe("signed integer types", () => {
+  test("s8", () => {
+    const decoded = decodeWitParameter("-128", { type: "s8" });
+    expect(decoded).toEqual({ decoded: -128 });
+  });
+
+  test("option<s8>", () => {
+    const decoded = decodeWitParameter("some(-42)", { type: "option<s8>" });
+    expect(decoded).toEqual({ decoded: ["some", -42] });
+  });
+
+  test("list<s8>", () => {
+    const decoded = decodeWitParameter("[-1, 0, 1]", { type: "list<s8>" });
+    expect(decoded).toEqual({ decoded: [-1, 0, 1] });
+  });
+
+  test("result<s8, error>", () => {
+    const decoded = decodeWitParameter("ok(-10)", {
+      type: "result<s8, error>",
+    });
+    expect(decoded).toEqual({ decoded: ["ok", -10] });
+  });
+
+  test("s16", () => {
+    const decoded = decodeWitParameter("-32768", { type: "s16" });
+    expect(decoded).toEqual({ decoded: -32768 });
+  });
+
+  test("option<s16>", () => {
+    const decoded = decodeWitParameter("some(-1000)", { type: "option<s16>" });
+    expect(decoded).toEqual({ decoded: ["some", -1000] });
+  });
+
+  test("list<s16>", () => {
+    const decoded = decodeWitParameter("[-100, 100]", { type: "list<s16>" });
+    expect(decoded).toEqual({ decoded: [-100, 100] });
+  });
+
+  test("result<s16, error>", () => {
+    const decoded = decodeWitParameter("ok(-500)", {
+      type: "result<s16, error>",
+    });
+    expect(decoded).toEqual({ decoded: ["ok", -500] });
+  });
+
+  test("s32", () => {
+    const decoded = decodeWitParameter("-2147483648", { type: "s32" });
+    expect(decoded).toEqual({ decoded: -2147483648 });
+  });
+
+  test("option<s32>", () => {
+    const decoded = decodeWitParameter("some(-100000)", {
+      type: "option<s32>",
+    });
+    expect(decoded).toEqual({ decoded: ["some", -100000] });
+  });
+
+  test("list<s32>", () => {
+    const decoded = decodeWitParameter("[-1000, 1000]", { type: "list<s32>" });
+    expect(decoded).toEqual({ decoded: [-1000, 1000] });
+  });
+
+  test("result<s32, error>", () => {
+    const decoded = decodeWitParameter("ok(-12345)", {
+      type: "result<s32, error>",
+    });
+    expect(decoded).toEqual({ decoded: ["ok", -12345] });
+  });
+
+  test("s64", () => {
+    const decoded = decodeWitParameter("-100", { type: "s64" });
+    expect(decoded).toEqual({ decoded: -100n });
+  });
+
+  test("option<s64>", () => {
+    const decoded = decodeWitParameter("some(-999)", { type: "option<s64>" });
+    expect(decoded).toEqual({ decoded: ["some", -999n] });
+  });
+
+  test("list<s64>", () => {
+    const decoded = decodeWitParameter("[-100, 0, 100]", { type: "list<s64>" });
+    expect(decoded).toEqual({ decoded: [-100n, 0n, 100n] });
+  });
+
+  test("result<s64, error>", () => {
+    const decoded = decodeWitParameter("ok(-777)", {
+      type: "result<s64, error>",
+    });
+    expect(decoded).toEqual({ decoded: ["ok", -777n] });
+  });
+});
+
+// ============================================================================
+// RECORD TYPES
+// ============================================================================
+
+describe("record types", () => {
+  test("record", () => {
     const raw = `{key: "1b39e35044922c2cb2108b9a2a0ff13223471b17ca55e87e307270308dc77ac0", value: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}}`;
     expect(
       decodeWitParameter(raw, {
-        type: "tuple",
+        type: "record",
         components: [
           { name: "key", type: "string" },
           { name: "value", type: "decimal" },
@@ -49,11 +412,35 @@ describe("decodeParameter", () => {
     });
   });
 
-  test("list<tuple>", () => {
+  test("option<record> - some", () => {
+    const decoded = decodeWitParameter("some({x: 10, y: 20})", {
+      type: "option<record>",
+      components: [
+        { name: "x", type: "u32" },
+        { name: "y", type: "u32" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["some", { x: 10, y: 20 }],
+    });
+  });
+
+  test("option<record> - none", () => {
+    const decoded = decodeWitParameter("none", {
+      type: "option<record>",
+      components: [
+        { name: "x", type: "u32" },
+        { name: "y", type: "u32" },
+      ],
+    });
+    expect(decoded).toEqual({ decoded: ["none"] });
+  });
+
+  test("list<record>", () => {
     const raw = `[{key: "1b39e35044922c2cb2108b9a2a0ff13223471b17ca55e87e307270308dc77ac0", value: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}}]`;
     expect(
       decodeWitParameter(raw, {
-        type: "list<tuple>",
+        type: "list<record>",
         components: [
           { name: "key", type: "string" },
           { name: "value", type: "decimal" },
@@ -69,41 +456,886 @@ describe("decodeParameter", () => {
     });
   });
 
-  test("list<decimal>", () => {
-    const decoded = decodeWitParameter(
-      "[{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 8, r1: 0, r2: 0, r3: 0, sign: plus}]",
-      {
-        type: "list<decimal>",
-      },
-    );
+  test("result<record, error> - ok", () => {
+    const decoded = decodeWitParameter('ok({name: "Alice", age: 30})', {
+      type: "result<record, error>",
+      components: [
+        { name: "name", type: "string" },
+        { name: "age", type: "u32" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", { name: "Alice", age: 30 }],
+    });
+  });
 
+  test("record with variant field", () => {
+    const decoded = decodeWitParameter('{id: 123, status: completed("done")}', {
+      type: "record",
+      components: [
+        { name: "id", type: "u64" },
+        {
+          name: "status",
+          type: "variant",
+          components: [
+            { name: "pending", type: "_" },
+            { name: "completed", type: "string" },
+          ],
+        },
+      ],
+    });
     expect(decoded).toEqual({
-      decoded: [
-        [7n, 18],
-        [8n, 18],
+      decoded: {
+        id: 123n,
+        status: ["completed", "done"],
+      },
+    });
+  });
+});
+
+// ============================================================================
+// ENUM TYPES
+// ============================================================================
+
+describe("enum types", () => {
+  test("enum", () => {
+    const decoded = decodeWitParameter("red", {
+      type: "enum",
+      components: [
+        { name: "red", type: "_" },
+        { name: "green", type: "_" },
+        { name: "blue", type: "_" },
       ],
     });
+    expect(decoded).toEqual({ decoded: "red" });
   });
 
-  test("option<decimal>", () => {
-    const decoded = decodeWitParameter(
-      "some({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})",
-      {
-        type: "option<decimal>",
-      },
-    );
+  test("option<enum> - some", () => {
+    const decoded = decodeWitParameter("some(green)", {
+      type: "option<enum>",
+      components: [
+        { name: "red", type: "_" },
+        { name: "green", type: "_" },
+        { name: "blue", type: "_" },
+      ],
+    });
+    expect(decoded).toEqual({ decoded: ["some", "green"] });
+  });
+
+  test("option<enum> - none", () => {
+    const decoded = decodeWitParameter("none", {
+      type: "option<enum>",
+      components: [
+        { name: "red", type: "_" },
+        { name: "green", type: "_" },
+        { name: "blue", type: "_" },
+      ],
+    });
+    expect(decoded).toEqual({ decoded: ["none"] });
+  });
+
+  test("list<enum>", () => {
+    const decoded = decodeWitParameter("[red, blue, green]", {
+      type: "list<enum>",
+      components: [
+        { name: "red", type: "_" },
+        { name: "green", type: "_" },
+        { name: "blue", type: "_" },
+      ],
+    });
+    expect(decoded).toEqual({ decoded: ["red", "blue", "green"] });
+  });
+
+  test("result<enum, error> - ok", () => {
+    const decoded = decodeWitParameter("ok(blue)", {
+      type: "result<enum, error>",
+      components: [
+        { name: "red", type: "_" },
+        { name: "green", type: "_" },
+        { name: "blue", type: "_" },
+      ],
+    });
+    expect(decoded).toEqual({ decoded: ["ok", "blue"] });
+  });
+});
 
-    expect(decoded).toEqual({ decoded: { kind: "some", value: [7n, 18] } });
+// ============================================================================
+// VARIANT TYPES
+// ============================================================================
+
+describe("variant types", () => {
+  test("variant with unit case (no payload)", () => {
+    const decoded = decodeWitParameter("none", {
+      type: "variant",
+      components: [
+        { name: "none", type: "_" },
+        { name: "some", type: "integer" },
+      ],
+    });
+    expect(decoded).toEqual({ decoded: ["none", undefined] });
   });
 
-  test.skip("result<decimal,error>", () => {
+  test("variant with integer payload", () => {
     const decoded = decodeWitParameter(
-      "ok({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})",
+      "some({r0: 42, r1: 0, r2: 0, r3: 0, sign: plus})",
       {
-        type: "result<decimal, error>",
+        type: "variant",
+        components: [
+          { name: "none", type: "_" },
+          { name: "some", type: "integer" },
+        ],
       },
     );
+    expect(decoded).toEqual({ decoded: ["some", 42n] });
+  });
+
+  test("variant with string payload", () => {
+    const decoded = decodeWitParameter('error("something went wrong")', {
+      type: "variant",
+      components: [
+        { name: "error", type: "string" },
+        { name: "success", type: "string" },
+      ],
+    });
+    expect(decoded).toEqual({ decoded: ["error", "something went wrong"] });
+  });
+
+  test("variant with record payload", () => {
+    const decoded = decodeWitParameter('person({name: "Alice", age: 30})', {
+      type: "variant",
+      components: [
+        { name: "none", type: "_" },
+        {
+          name: "person",
+          type: "record",
+          components: [
+            { name: "name", type: "string" },
+            { name: "age", type: "u64" },
+          ],
+        },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["person", { name: "Alice", age: 30n }],
+    });
+  });
+
+  test("variant with list payload", () => {
+    const decoded = decodeWitParameter('items(["apple", "banana", "cherry"])', {
+      type: "variant",
+      components: [
+        { name: "empty", type: "_" },
+        { name: "items", type: "list<string>" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["items", ["apple", "banana", "cherry"]],
+    });
+  });
+
+  test("option<variant> with some", () => {
+    const decoded = decodeWitParameter("some(red)", {
+      type: "option<variant>",
+      components: [
+        { name: "red", type: "_" },
+        { name: "blue", type: "_" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["some", ["red", undefined]],
+    });
+  });
 
-    expect(decoded).toEqual({ decoded: { kind: "some", value: [7n, 18] } });
+  test("option<variant> with none", () => {
+    const decoded = decodeWitParameter("none", {
+      type: "option<variant>",
+      components: [
+        { name: "red", type: "_" },
+        { name: "blue", type: "_" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["none"],
+    });
+  });
+
+  test("list<variant>", () => {
+    const decoded = decodeWitParameter("[none, value(42), none]", {
+      type: "list<variant>",
+      components: [
+        { name: "none", type: "_" },
+        { name: "value", type: "u64" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: [
+        ["none", undefined],
+        ["value", 42n],
+        ["none", undefined],
+      ],
+    });
+  });
+
+  test("result<variant, error> - ok", () => {
+    const decoded = decodeWitParameter('ok(success("all good"))', {
+      type: "result<variant, error>",
+      components: [
+        { name: "success", type: "string" },
+        { name: "failure", type: "string" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["success", "all good"]],
+    });
+  });
+
+  test("variant with nested variant payload", () => {
+    const decoded = decodeWitParameter("color(rgb({r: 255, g: 0, b: 0}))", {
+      type: "variant",
+      components: [
+        { name: "none", type: "_" },
+        {
+          name: "color",
+          type: "variant",
+          components: [
+            { name: "red", type: "_" },
+            {
+              name: "rgb",
+              type: "record",
+              components: [
+                { name: "r", type: "u8" },
+                { name: "g", type: "u8" },
+                { name: "b", type: "u8" },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["color", ["rgb", { r: 255, g: 0, b: 0 }]],
+    });
+  });
+
+  test("variant with list<record> payload", () => {
+    const decoded = decodeWitParameter(
+      'addresses([{street: "123 Main St", city: "Boston"}, {street: "456 Oak Ave", city: "Cambridge"}])',
+      {
+        type: "variant",
+        components: [
+          { name: "none", type: "_" },
+          {
+            name: "addresses",
+            type: "list<record>",
+            components: [
+              { name: "street", type: "string" },
+              { name: "city", type: "string" },
+            ],
+          },
+        ],
+      },
+    );
+    expect(decoded).toEqual({
+      decoded: [
+        "addresses",
+        [
+          { street: "123 Main St", city: "Boston" },
+          { street: "456 Oak Ave", city: "Cambridge" },
+        ],
+      ],
+    });
+  });
+});
+
+// ============================================================================
+// UNIT TYPE (special cases)
+// ============================================================================
+
+describe("unit type special cases", () => {
+  test("option<_> - some", () => {
+    const decoded = decodeWitParameter("some(_)", { type: "option<_>" });
+    expect(decoded).toEqual({
+      decoded: ["some", { _tag: "Unit" }],
+    });
+  });
+
+  test("option<_> - none", () => {
+    const decoded = decodeWitParameter("none", { type: "option<_>" });
+    expect(decoded).toEqual({ decoded: ["none"] });
+  });
+
+  test("result<_, error> - ok", () => {
+    const decoded = decodeWitParameter("ok(_)", { type: "result<_, error>" });
+    expect(decoded).toEqual({
+      decoded: ["ok", { _tag: "Unit" }],
+    });
+  });
+
+  test("result<_, error> - err", () => {
+    const decoded = decodeWitParameter('err(syntax("parse error"))', {
+      type: "result<_, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["err", ["syntax", "parse error"]],
+    });
+  });
+
+  test("result<option<_>, error> - ok with some", () => {
+    const decoded = decodeWitParameter("ok(some(_))", {
+      type: "result<option<_>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", { _tag: "Unit" }]],
+    });
+  });
+
+  test("result<option<_>, error> - ok with none", () => {
+    const decoded = decodeWitParameter("ok(none)", {
+      type: "result<option<_>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["none"]],
+    });
+  });
+});
+
+// ============================================================================
+// NESTED OPTION<LIST<T>>
+// ============================================================================
+
+describe("option<list<T>> types", () => {
+  test("option<list<string>> - some", () => {
+    const decoded = decodeWitParameter('some(["a", "b", "c"])', {
+      type: "option<list<string>>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["some", ["a", "b", "c"]],
+    });
+  });
+
+  test("option<list<decimal>>", () => {
+    const decoded = decodeWitParameter(
+      "some([{r0: 1, r1: 0, r2: 0, r3: 0, sign: plus}])",
+      { type: "option<list<decimal>>" },
+    );
+    expect(decoded).toEqual({
+      decoded: ["some", [[1n, 18]]],
+    });
+  });
+
+  test("option<list<bool>>", () => {
+    const decoded = decodeWitParameter("some([true, false])", {
+      type: "option<list<bool>>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["some", [true, false]],
+    });
+  });
+
+  test("option<list<integer>>", () => {
+    const decoded = decodeWitParameter(
+      "some([{r0: 1, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 2, r1: 0, r2: 0, r3: 0, sign: plus}])",
+      { type: "option<list<integer>>" },
+    );
+    expect(decoded).toEqual({
+      decoded: ["some", [1n, 2n]],
+    });
+  });
+
+  test("option<list<u8>>", () => {
+    const decoded = decodeWitParameter("some([1, 2, 3])", {
+      type: "option<list<u8>>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["some", [1, 2, 3]],
+    });
+  });
+
+  test("option<list<variant>>", () => {
+    const decoded = decodeWitParameter("some([none, value(10)])", {
+      type: "option<list<variant>>",
+      components: [
+        { name: "none", type: "_" },
+        { name: "value", type: "u32" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: [
+        "some",
+        [
+          ["none", undefined],
+          ["value", 10],
+        ],
+      ],
+    });
+  });
+
+  test("option<list<record>>", () => {
+    const decoded = decodeWitParameter("some([{x: 1, y: 2}])", {
+      type: "option<list<record>>",
+      components: [
+        { name: "x", type: "u32" },
+        { name: "y", type: "u32" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["some", [{ x: 1, y: 2 }]],
+    });
+  });
+
+  test("option<list<enum>>", () => {
+    const decoded = decodeWitParameter("some([red, blue])", {
+      type: "option<list<enum>>",
+      components: [
+        { name: "red", type: "_" },
+        { name: "green", type: "_" },
+        { name: "blue", type: "_" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["some", ["red", "blue"]],
+    });
+  });
+});
+
+// ============================================================================
+// NESTED RESULT<OPTION<T>, ERROR>
+// ============================================================================
+
+describe("result<option<T>, error> types", () => {
+  test("result<option<string>, error> - ok with some", () => {
+    const decoded = decodeWitParameter('ok(some("hello"))', {
+      type: "result<option<string>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", "hello"]],
+    });
+  });
+
+  test("result<option<string>, error> - ok with none", () => {
+    const decoded = decodeWitParameter("ok(none)", {
+      type: "result<option<string>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["none"]],
+    });
+  });
+
+  test("result<option<decimal>, error>", () => {
+    const decoded = decodeWitParameter(
+      "ok(some({r0: 5, r1: 0, r2: 0, r3: 0, sign: plus}))",
+      { type: "result<option<decimal>, error>" },
+    );
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [5n, 18]]],
+    });
+  });
+
+  test("result<option<bool>, error>", () => {
+    const decoded = decodeWitParameter("ok(some(true))", {
+      type: "result<option<bool>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", true]],
+    });
+  });
+
+  test("result<option<integer>, error>", () => {
+    const decoded = decodeWitParameter(
+      "ok(some({r0: 99, r1: 0, r2: 0, r3: 0, sign: plus}))",
+      { type: "result<option<integer>, error>" },
+    );
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", 99n]],
+    });
+  });
+
+  test("result<option<u32>, error>", () => {
+    const decoded = decodeWitParameter("ok(some(12345))", {
+      type: "result<option<u32>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", 12345]],
+    });
+  });
+
+  test("result<option<s64>, error>", () => {
+    const decoded = decodeWitParameter("ok(some(-100))", {
+      type: "result<option<s64>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", -100n]],
+    });
+  });
+
+  test("result<option<variant>, error>", () => {
+    const decoded = decodeWitParameter('ok(some(error("fail")))', {
+      type: "result<option<variant>, error>",
+      components: [
+        { name: "error", type: "string" },
+        { name: "success", type: "string" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", ["error", "fail"]]],
+    });
+  });
+
+  test("result<option<record>, error>", () => {
+    const decoded = decodeWitParameter("ok(some({a: 1, b: 2}))", {
+      type: "result<option<record>, error>",
+      components: [
+        { name: "a", type: "u32" },
+        { name: "b", type: "u32" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", { a: 1, b: 2 }]],
+    });
+  });
+
+  test("result<option<enum>, error>", () => {
+    const decoded = decodeWitParameter("ok(some(green))", {
+      type: "result<option<enum>, error>",
+      components: [
+        { name: "red", type: "_" },
+        { name: "green", type: "_" },
+        { name: "blue", type: "_" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", "green"]],
+    });
+  });
+});
+
+// ============================================================================
+// NESTED RESULT<LIST<T>, ERROR>
+// ============================================================================
+
+describe("result<list<T>, error> types", () => {
+  test("result<list<string>, error>", () => {
+    const decoded = decodeWitParameter('ok(["a", "b"])', {
+      type: "result<list<string>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["a", "b"]],
+    });
+  });
+
+  test("result<list<decimal>, error>", () => {
+    const decoded = decodeWitParameter(
+      "ok([{r0: 1, r1: 0, r2: 0, r3: 0, sign: plus}])",
+      { type: "result<list<decimal>, error>" },
+    );
+    expect(decoded).toEqual({
+      decoded: ["ok", [[1n, 18]]],
+    });
+  });
+
+  test("result<list<bool>, error>", () => {
+    const decoded = decodeWitParameter("ok([true, false])", {
+      type: "result<list<bool>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", [true, false]],
+    });
+  });
+
+  test("result<list<integer>, error>", () => {
+    const decoded = decodeWitParameter(
+      "ok([{r0: 1, r1: 0, r2: 0, r3: 0, sign: plus}])",
+      { type: "result<list<integer>, error>" },
+    );
+    expect(decoded).toEqual({
+      decoded: ["ok", [1n]],
+    });
+  });
+
+  test("result<list<u16>, error>", () => {
+    const decoded = decodeWitParameter("ok([100, 200])", {
+      type: "result<list<u16>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", [100, 200]],
+    });
+  });
+
+  test("result<list<s32>, error>", () => {
+    const decoded = decodeWitParameter("ok([-1, 0, 1])", {
+      type: "result<list<s32>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", [-1, 0, 1]],
+    });
+  });
+
+  test("result<list<variant>, error>", () => {
+    const decoded = decodeWitParameter("ok([none, value(5)])", {
+      type: "result<list<variant>, error>",
+      components: [
+        { name: "none", type: "_" },
+        { name: "value", type: "u32" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: [
+        "ok",
+        [
+          ["none", undefined],
+          ["value", 5],
+        ],
+      ],
+    });
+  });
+
+  test("result<list<record>, error>", () => {
+    const decoded = decodeWitParameter("ok([{x: 1, y: 2}])", {
+      type: "result<list<record>, error>",
+      components: [
+        { name: "x", type: "u32" },
+        { name: "y", type: "u32" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", [{ x: 1, y: 2 }]],
+    });
+  });
+
+  test("result<list<enum>, error>", () => {
+    const decoded = decodeWitParameter("ok([red, blue])", {
+      type: "result<list<enum>, error>",
+      components: [
+        { name: "red", type: "_" },
+        { name: "green", type: "_" },
+        { name: "blue", type: "_" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["red", "blue"]],
+    });
+  });
+});
+
+// ============================================================================
+// NESTED RESULT<OPTION<LIST<T>>, ERROR>
+// ============================================================================
+
+describe("result<option<list<T>>, error> types", () => {
+  test("result<option<list<string>>, error> - ok with some", () => {
+    const decoded = decodeWitParameter('ok(some(["a", "b"]))', {
+      type: "result<option<list<string>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", ["a", "b"]]],
+    });
+  });
+
+  test("result<option<list<string>>, error> - ok with none", () => {
+    const decoded = decodeWitParameter("ok(none)", {
+      type: "result<option<list<string>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["none"]],
+    });
+  });
+
+  test("result<option<list<decimal>>, error>", () => {
+    const decoded = decodeWitParameter(
+      "ok(some([{r0: 1, r1: 0, r2: 0, r3: 0, sign: plus}]))",
+      { type: "result<option<list<decimal>>, error>" },
+    );
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [[1n, 18]]]],
+    });
+  });
+
+  test("result<option<list<bool>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([true, false]))", {
+      type: "result<option<list<bool>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [true, false]]],
+    });
+  });
+
+  test("result<option<list<integer>>, error>", () => {
+    const decoded = decodeWitParameter(
+      "ok(some([{r0: 1, r1: 0, r2: 0, r3: 0, sign: plus}]))",
+      { type: "result<option<list<integer>>, error>" },
+    );
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [1n]]],
+    });
+  });
+
+  test("result<option<list<u8>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([1, 2, 3]))", {
+      type: "result<option<list<u8>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [1, 2, 3]]],
+    });
+  });
+
+  test("result<option<list<u16>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([100, 200]))", {
+      type: "result<option<list<u16>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [100, 200]]],
+    });
+  });
+
+  test("result<option<list<u32>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([1000, 2000]))", {
+      type: "result<option<list<u32>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [1000, 2000]]],
+    });
+  });
+
+  test("result<option<list<u64>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([100, 200]))", {
+      type: "result<option<list<u64>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [100n, 200n]]],
+    });
+  });
+
+  test("result<option<list<s8>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([-1, 0, 1]))", {
+      type: "result<option<list<s8>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [-1, 0, 1]]],
+    });
+  });
+
+  test("result<option<list<s16>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([-100, 100]))", {
+      type: "result<option<list<s16>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [-100, 100]]],
+    });
+  });
+
+  test("result<option<list<s32>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([-1000, 1000]))", {
+      type: "result<option<list<s32>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [-1000, 1000]]],
+    });
+  });
+
+  test("result<option<list<s64>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([-100, 100]))", {
+      type: "result<option<list<s64>>, error>",
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [-100n, 100n]]],
+    });
+  });
+
+  test("result<option<list<variant>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([none, value(10)]))", {
+      type: "result<option<list<variant>>, error>",
+      components: [
+        { name: "none", type: "_" },
+        { name: "value", type: "u32" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: [
+        "ok",
+        [
+          "some",
+          [
+            ["none", undefined],
+            ["value", 10],
+          ],
+        ],
+      ],
+    });
+  });
+
+  test("result<option<list<record>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([{x: 1, y: 2}]))", {
+      type: "result<option<list<record>>, error>",
+      components: [
+        { name: "x", type: "u32" },
+        { name: "y", type: "u32" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", [{ x: 1, y: 2 }]]],
+    });
+  });
+
+  test("result<option<list<enum>>, error>", () => {
+    const decoded = decodeWitParameter("ok(some([red, blue]))", {
+      type: "result<option<list<enum>>, error>",
+      components: [
+        { name: "red", type: "_" },
+        { name: "green", type: "_" },
+        { name: "blue", type: "_" },
+      ],
+    });
+    expect(decoded).toEqual({
+      decoded: ["ok", ["some", ["red", "blue"]]],
+    });
+  });
+});
+
+// ============================================================================
+// ERROR TYPE
+// ============================================================================
+
+describe("error type", () => {
+  test("error variant", () => {
+    const decoded = decodeWitParameter('message("something went wrong")', {
+      type: "error",
+    });
+    expect(decoded).toEqual({
+      decoded: ["message", "something went wrong"],
+    });
+  });
+
+  test("error variant - overflow", () => {
+    const decoded = decodeWitParameter('overflow("number too big")', {
+      type: "error",
+    });
+    expect(decoded).toEqual({
+      decoded: ["overflow", "number too big"],
+    });
+  });
+
+  test("error variant - div-by-zero", () => {
+    const decoded = decodeWitParameter('div-by-zero("cannot divide by zero")', {
+      type: "error",
+    });
+    expect(decoded).toEqual({
+      decoded: ["div-by-zero", "cannot divide by zero"],
+    });
+  });
+});
+
+// ============================================================================
+// CONTRACT ADDRESS TYPE
+// ============================================================================
+
+describe("contract-address type", () => {
+  test("contract-address", () => {
+    const decoded = decodeWitParameter(
+      `{ name: "token", height: 0, tx_index: 0, }`,
+      { type: "contract-address" },
+    );
+    expect(decoded).toEqual({
+      decoded: "token_0_0",
+    });
   });
 });