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

package/src/sdk/utils/wit/encode-wit-parameters.test.ts

@@ -1,124 +1,988 @@
-import { expect, test } from "vitest";
+import { expect, test, describe } from "vitest";
 
 import { encodeWitParameters } from "./encode-wit-parameters.js";
 
-test("blank", () => {
-  expect(encodeWitParameters([], [])).toBe("");
+describe("basic encoding", () => {
+  test("blank", () => {
+    expect(encodeWitParameters([], [])).toBe("");
+  });
 });
 
-test("string", () => {
-  expect(encodeWitParameters([{ type: "string" }], ["bc1deadbeef"])).toBe(
-    `"bc1deadbeef"`,
-  );
+// ============================================================================
+// STRING TYPES
+// ============================================================================
+
+describe("string types", () => {
+  test("string", () => {
+    expect(encodeWitParameters([{ type: "string" }], ["bc1deadbeef"])).toBe(
+      `"bc1deadbeef"`,
+    );
+  });
+
+  test("option<string> - some", () => {
+    expect(
+      encodeWitParameters([{ type: "option<string>" }], [["some", "hello"]]),
+    ).toBe(`some("hello")`);
+  });
+
+  test("option<string> - none", () => {
+    expect(encodeWitParameters([{ type: "option<string>" }], [["none"]])).toBe(
+      `none`,
+    );
+  });
+
+  test("list<string>", () => {
+    expect(
+      encodeWitParameters([{ type: "list<string>" }], [["foo", "bar"]]),
+    ).toBe(`["foo", "bar"]`);
+  });
 });
 
-test("integer", () => {
-  expect(encodeWitParameters([{ type: "integer" }], [7n])).toBe(
-    `{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}`,
-  );
+// ============================================================================
+// DECIMAL TYPES
+// ============================================================================
+
+describe("decimal types", () => {
+  test("decimal", () => {
+    expect(encodeWitParameters([{ type: "decimal" }], [[7n, 18]])).toBe(
+      `{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}`,
+    );
+  });
+
+  test("decimal negative", () => {
+    expect(encodeWitParameters([{ type: "decimal" }], [[-7n, 18]])).toBe(
+      `{r0: 7, r1: 0, r2: 0, r3: 0, sign: minus}`,
+    );
+  });
+
+  test("option<decimal> - some", () => {
+    expect(
+      encodeWitParameters([{ type: "option<decimal>" }], [["some", [7n, 18]]]),
+    ).toBe(`some({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})`);
+  });
+
+  test("option<decimal> - none", () => {
+    expect(encodeWitParameters([{ type: "option<decimal>" }], [["none"]])).toBe(
+      `none`,
+    );
+  });
+
+  test("list<decimal>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "list<decimal>" }],
+        [
+          [
+            [7n, 18],
+            [8n, 18],
+          ],
+        ],
+      ),
+    ).toBe(
+      `[{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 8, r1: 0, r2: 0, r3: 0, sign: plus}]`,
+    );
+  });
 });
 
-test("integer negative", () => {
-  expect(encodeWitParameters([{ type: "integer" }], [-7n])).toBe(
-    `{r0: 7, r1: 0, r2: 0, r3: 0, sign: minus}`,
-  );
+// ============================================================================
+// BOOL TYPES
+// ============================================================================
+
+describe("bool types", () => {
+  test("bool - true", () => {
+    expect(encodeWitParameters([{ type: "bool" }], [true])).toBe("true");
+  });
+
+  test("bool - false", () => {
+    expect(encodeWitParameters([{ type: "bool" }], [false])).toBe("false");
+  });
+
+  test("option<bool> - some", () => {
+    expect(
+      encodeWitParameters([{ type: "option<bool>" }], [["some", true]]),
+    ).toBe("some(true)");
+  });
+
+  test("option<bool> - none", () => {
+    expect(encodeWitParameters([{ type: "option<bool>" }], [["none"]])).toBe(
+      "none",
+    );
+  });
+
+  test("list<bool>", () => {
+    expect(
+      encodeWitParameters([{ type: "list<bool>" }], [[true, false, true]]),
+    ).toBe("[true, false, true]");
+  });
 });
 
-test("decimal", () => {
-  expect(encodeWitParameters([{ type: "decimal" }], [[7n, 18]])).toBe(
-    `{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}`,
-    //
-  );
+// ============================================================================
+// INTEGER TYPES
+// ============================================================================
+
+describe("integer types", () => {
+  test("integer", () => {
+    expect(encodeWitParameters([{ type: "integer" }], [7n])).toBe(
+      `{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}`,
+    );
+  });
+
+  test("integer negative", () => {
+    expect(encodeWitParameters([{ type: "integer" }], [-7n])).toBe(
+      `{r0: 7, r1: 0, r2: 0, r3: 0, sign: minus}`,
+    );
+  });
+
+  test("option<integer> - some", () => {
+    expect(
+      encodeWitParameters([{ type: "option<integer>" }], [["some", 42n]]),
+    ).toBe(`some({r0: 42, r1: 0, r2: 0, r3: 0, sign: plus})`);
+  });
+
+  test("option<integer> - none", () => {
+    expect(encodeWitParameters([{ type: "option<integer>" }], [["none"]])).toBe(
+      `none`,
+    );
+  });
+
+  test("list<integer>", () => {
+    expect(encodeWitParameters([{ type: "list<integer>" }], [[7n, 8n]])).toBe(
+      `[{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 8, r1: 0, r2: 0, r3: 0, sign: plus}]`,
+    );
+  });
 });
 
-test("list<string>", () => {
-  expect(
-    encodeWitParameters([{ type: "list<string>" }], [["foo", "bar"]]),
-  ).toBe(`["foo", "bar"]`);
+// ============================================================================
+// UNSIGNED INTEGER TYPES (u8, u16, u32, u64)
+// ============================================================================
+
+describe("unsigned integer types", () => {
+  test("u8", () => {
+    expect(encodeWitParameters([{ type: "u8" }], [255])).toBe("255");
+  });
+
+  test("option<u8>", () => {
+    expect(encodeWitParameters([{ type: "option<u8>" }], [["some", 128]])).toBe(
+      "some(128)",
+    );
+  });
+
+  test("list<u8>", () => {
+    expect(encodeWitParameters([{ type: "list<u8>" }], [[1, 2, 3]])).toBe(
+      "[1, 2, 3]",
+    );
+  });
+
+  test("u16", () => {
+    expect(encodeWitParameters([{ type: "u16" }], [65535])).toBe("65535");
+  });
+
+  test("option<u16>", () => {
+    expect(
+      encodeWitParameters([{ type: "option<u16>" }], [["some", 1000]]),
+    ).toBe("some(1000)");
+  });
+
+  test("list<u16>", () => {
+    expect(encodeWitParameters([{ type: "list<u16>" }], [[100, 200]])).toBe(
+      "[100, 200]",
+    );
+  });
+
+  test("u32", () => {
+    expect(encodeWitParameters([{ type: "u32" }], [4294967295])).toBe(
+      "4294967295",
+    );
+  });
+
+  test("option<u32>", () => {
+    expect(
+      encodeWitParameters([{ type: "option<u32>" }], [["some", 1000000]]),
+    ).toBe("some(1000000)");
+  });
+
+  test("list<u32>", () => {
+    expect(encodeWitParameters([{ type: "list<u32>" }], [[1000, 2000]])).toBe(
+      "[1000, 2000]",
+    );
+  });
+
+  test("u64", () => {
+    expect(encodeWitParameters([{ type: "u64" }], [30n])).toBe("30");
+  });
+
+  test("option<u64>", () => {
+    expect(
+      encodeWitParameters([{ type: "option<u64>" }], [["some", 999n]]),
+    ).toBe("some(999)");
+  });
+
+  test("list<u64>", () => {
+    expect(
+      encodeWitParameters([{ type: "list<u64>" }], [[100n, 200n, 300n]]),
+    ).toBe("[100, 200, 300]");
+  });
 });
 
-test("list<integer>", () => {
-  expect(encodeWitParameters([{ type: "list<integer>" }], [[7n, 8n]])).toBe(
-    `[{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 8, r1: 0, r2: 0, r3: 0, sign: plus}]`,
-  );
+// ============================================================================
+// SIGNED INTEGER TYPES (s8, s16, s32, s64)
+// ============================================================================
+
+describe("signed integer types", () => {
+  test("s8", () => {
+    expect(encodeWitParameters([{ type: "s8" }], [-128])).toBe("-128");
+  });
+
+  test("option<s8>", () => {
+    expect(encodeWitParameters([{ type: "option<s8>" }], [["some", -42]])).toBe(
+      "some(-42)",
+    );
+  });
+
+  test("list<s8>", () => {
+    expect(encodeWitParameters([{ type: "list<s8>" }], [[-1, 0, 1]])).toBe(
+      "[-1, 0, 1]",
+    );
+  });
+
+  test("s16", () => {
+    expect(encodeWitParameters([{ type: "s16" }], [-32768])).toBe("-32768");
+  });
+
+  test("option<s16>", () => {
+    expect(
+      encodeWitParameters([{ type: "option<s16>" }], [["some", -1000]]),
+    ).toBe("some(-1000)");
+  });
+
+  test("list<s16>", () => {
+    expect(encodeWitParameters([{ type: "list<s16>" }], [[-100, 100]])).toBe(
+      "[-100, 100]",
+    );
+  });
+
+  test("s32", () => {
+    expect(encodeWitParameters([{ type: "s32" }], [-2147483648])).toBe(
+      "-2147483648",
+    );
+  });
+
+  test("option<s32>", () => {
+    expect(
+      encodeWitParameters([{ type: "option<s32>" }], [["some", -100000]]),
+    ).toBe("some(-100000)");
+  });
+
+  test("list<s32>", () => {
+    expect(encodeWitParameters([{ type: "list<s32>" }], [[-1000, 1000]])).toBe(
+      "[-1000, 1000]",
+    );
+  });
+
+  test("s64", () => {
+    expect(encodeWitParameters([{ type: "s64" }], [-100n])).toBe("-100");
+  });
+
+  test("option<s64>", () => {
+    expect(
+      encodeWitParameters([{ type: "option<s64>" }], [["some", -999n]]),
+    ).toBe("some(-999)");
+  });
+
+  test("list<s64>", () => {
+    expect(
+      encodeWitParameters([{ type: "list<s64>" }], [[-100n, 0n, 100n]]),
+    ).toBe("[-100, 0, 100]");
+  });
 });
 
-test("list<decimal>", () => {
-  expect(
-    encodeWitParameters(
-      [{ type: "list<decimal>" }],
-      [
+// ============================================================================
+// RECORD TYPES
+// ============================================================================
+
+describe("record types", () => {
+  test("record", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "record",
+            components: [
+              { name: "a", type: "integer" },
+              { name: "b", type: "decimal" },
+            ],
+          },
+        ],
+        [{ a: 7n, b: [7n, 18] }],
+      ),
+    ).toBe(
+      `{a: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, b: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}}`,
+    );
+  });
+
+  test("option<record> - some", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "option<record>",
+            components: [
+              { name: "a", type: "integer" },
+              { name: "b", type: "decimal" },
+            ],
+          },
+        ],
+        [["some", { a: 7n, b: [7n, 18] }]],
+      ),
+    ).toBe(
+      `some({a: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, b: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}})`,
+    );
+  });
+
+  test("option<record> - none", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "option<record>",
+            components: [
+              { name: "x", type: "u32" },
+              { name: "y", type: "u32" },
+            ],
+          },
+        ],
+        [["none"]],
+      ),
+    ).toBe("none");
+  });
+
+  test("list<record>", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "list<record>",
+            components: [
+              { name: "x", type: "u32" },
+              { name: "y", type: "u32" },
+            ],
+          },
+        ],
+        [[{ x: 1, y: 2 }]],
+      ),
+    ).toBe("[{x: 1, y: 2}]");
+  });
+
+  test("record with variant field", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "record",
+            components: [
+              { name: "id", type: "u64" },
+              {
+                name: "status",
+                type: "variant",
+                components: [
+                  { name: "pending", type: "_" },
+                  { name: "completed", type: "string" },
+                ],
+              },
+            ],
+          },
+        ],
+        [
+          {
+            id: 123n,
+            status: ["completed", "done"],
+          },
+        ],
+      ),
+    ).toBe(`{id: 123, status: completed("done")}`);
+  });
+
+  test("record with option<record> - some", () => {
+    expect(
+      encodeWitParameters(
         [
-          [7n, 18],
-          [8n, 10],
+          {
+            type: "record",
+            components: [
+              { name: "a", type: "integer" },
+              {
+                name: "b",
+                type: "option<record>",
+                components: [{ name: "c", type: "integer" }],
+              },
+            ],
+          },
         ],
-      ],
-    ),
-  ).toBe(
-    `[{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 800000000, r1: 0, r2: 0, r3: 0, sign: plus}]`,
-  );
+        [
+          {
+            a: 7n,
+            b: ["some", { c: 3n }],
+          },
+        ],
+      ),
+    ).toBe(
+      `{a: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, ` +
+        `b: some({c: {r0: 3, r1: 0, r2: 0, r3: 0, sign: plus}})}`,
+    );
+  });
+
+  test("record with option<record> - none", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "record",
+            components: [
+              { name: "a", type: "integer" },
+              {
+                name: "b",
+                type: "option<record>",
+                components: [{ name: "c", type: "integer" }],
+              },
+            ],
+          },
+        ],
+        [
+          {
+            a: 7n,
+            b: ["none"],
+          },
+        ],
+      ),
+    ).toBe(`{a: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, b: none}`);
+  });
 });
 
-test("invalid list<list<integer>>", () => {
-  expect(() =>
-    encodeWitParameters([{ type: "list<list<<integer>>" }], [[[7n, 8n]]]),
-  ).toThrowError(
-    `Type "list<list<<integer>>" is not a valid encoding type.
-Please provide a valid WIT type.
+// ============================================================================
+// ENUM TYPES
+// ============================================================================
 
-Docs: https://docs.kontor.networktk
-Version: kontor-sdk@1.0.0`,
-  );
+describe("enum types", () => {
+  test("enum", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "enum",
+            components: [
+              { name: "red", type: "_" },
+              { name: "green", type: "_" },
+              { name: "blue", type: "_" },
+            ],
+          },
+        ],
+        ["red"],
+      ),
+    ).toBe("red");
+  });
+
+  test("option<enum> - some", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "option<enum>",
+            components: [
+              { name: "red", type: "_" },
+              { name: "green", type: "_" },
+              { name: "blue", type: "_" },
+            ],
+          },
+        ],
+        [["some", "green"]],
+      ),
+    ).toBe("some(green)");
+  });
+
+  test("option<enum> - none", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "option<enum>",
+            components: [
+              { name: "red", type: "_" },
+              { name: "green", type: "_" },
+              { name: "blue", type: "_" },
+            ],
+          },
+        ],
+        [["none"]],
+      ),
+    ).toBe("none");
+  });
+
+  test("list<enum>", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "list<enum>",
+            components: [
+              { name: "red", type: "_" },
+              { name: "green", type: "_" },
+              { name: "blue", type: "_" },
+            ],
+          },
+        ],
+        [["red", "blue", "green"]],
+      ),
+    ).toBe("[red, blue, green]");
+  });
 });
 
-test("option<string>", () => {
-  expect(
-    encodeWitParameters(
-      [{ type: "option<string>" }],
-      [{ kind: "some", value: "foo" }],
-    ),
-  ).toBe(`some("foo")`);
+// ============================================================================
+// VARIANT TYPES
+// ============================================================================
+
+describe("variant types", () => {
+  test("variant with unit case (no payload)", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "variant",
+            components: [
+              { name: "none", type: "_" },
+              { name: "some", type: "integer" },
+            ],
+          },
+        ],
+        [["none"]],
+      ),
+    ).toBe("none");
+  });
+
+  test("variant with integer payload", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "variant",
+            components: [
+              { name: "none", type: "_" },
+              { name: "some", type: "integer" },
+            ],
+          },
+        ],
+        [["some", 42n]],
+      ),
+    ).toBe("some({r0: 42, r1: 0, r2: 0, r3: 0, sign: plus})");
+  });
+
+  test("variant with string payload", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "variant",
+            components: [
+              { name: "error", type: "string" },
+              { name: "success", type: "string" },
+            ],
+          },
+        ],
+        [["error", "something went wrong"]],
+      ),
+    ).toBe(`error("something went wrong")`);
+  });
+
+  test("variant with record payload", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "variant",
+            components: [
+              { name: "none", type: "_" },
+              {
+                name: "person",
+                type: "record",
+                components: [
+                  { name: "name", type: "string" },
+                  { name: "age", type: "u64" },
+                ],
+              },
+            ],
+          },
+        ],
+        [["person", { name: "Alice", age: 30n }]],
+      ),
+    ).toBe(`person({name: "Alice", age: 30})`);
+  });
+
+  test("variant with list payload", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "variant",
+            components: [
+              { name: "empty", type: "_" },
+              { name: "items", type: "list<string>" },
+            ],
+          },
+        ],
+        [["items", ["apple", "banana", "cherry"]]],
+      ),
+    ).toBe(`items(["apple", "banana", "cherry"])`);
+  });
+
+  test("option<variant> - some", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "option<variant>",
+            components: [
+              { name: "red", type: "_" },
+              { name: "blue", type: "_" },
+            ],
+          },
+        ],
+        [["some", ["red" as const]]],
+      ),
+    ).toBe("some(red)");
+  });
+
+  test("option<variant> - none", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "option<variant>",
+            components: [
+              { name: "red", type: "_" },
+              { name: "blue", type: "_" },
+            ],
+          },
+        ],
+        [["none"]],
+      ),
+    ).toBe("none");
+  });
+
+  test("list<variant>", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "list<variant>",
+            components: [
+              { name: "none", type: "_" },
+              { name: "value", type: "u64" },
+            ],
+          },
+        ],
+        [[["none"], ["value", 42n], ["none"]]],
+      ),
+    ).toBe("[none, value(42), none]");
+  });
+
+  test("variant with nested variant payload", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            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" },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+        [["color", ["rgb", { r: 255, g: 0, b: 0 }]]],
+      ),
+    ).toBe("color(rgb({r: 255, g: 0, b: 0}))");
+  });
+
+  test("variant with list<record> payload", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "variant",
+            components: [
+              { name: "none", type: "_" },
+              {
+                name: "addresses",
+                type: "list<record>",
+                components: [
+                  { name: "street", type: "string" },
+                  { name: "city", type: "string" },
+                ],
+              },
+            ],
+          },
+        ],
+        [
+          [
+            "addresses",
+            [
+              { street: "123 Main St", city: "Boston" },
+              { street: "456 Oak Ave", city: "Cambridge" },
+            ],
+          ],
+        ],
+      ),
+    ).toBe(
+      `addresses([{street: "123 Main St", city: "Boston"}, {street: "456 Oak Ave", city: "Cambridge"}])`,
+    );
+  });
 });
 
-test("option<string> ( none ) ", () => {
-  expect(
-    encodeWitParameters([{ type: "option<string>" }], [{ kind: "none" }]),
-  ).toBe(`none`);
+// ============================================================================
+// UNIT TYPE (special cases)
+// ============================================================================
+
+describe("unit type special cases", () => {
+  test("option<_> - some", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<_>" }],
+        [["some", { _tag: "Unit" }]],
+      ),
+    ).toBe("some(_)");
+  });
+
+  test("option<_> - none", () => {
+    expect(encodeWitParameters([{ type: "option<_>" }], [["none"]])).toBe(
+      "none",
+    );
+  });
 });
 
-test("option<integer>", () => {
-  expect(
-    encodeWitParameters(
-      [{ type: "option<integer>" }],
-      [{ kind: "some", value: 7n }],
-    ),
-  ).toBe(`some({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})`);
+// ============================================================================
+// NESTED OPTION<LIST<T>>
+// ============================================================================
+
+describe("option<list<T>> types", () => {
+  test("option<list<string>> - some", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<string>>" }],
+        [["some", ["a", "b", "c"]]],
+      ),
+    ).toBe(`some(["a", "b", "c"])`);
+  });
+
+  test("option<list<string>> - none", () => {
+    expect(
+      encodeWitParameters([{ type: "option<list<string>>" }], [["none"]]),
+    ).toBe("none");
+  });
+
+  test("option<list<decimal>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<decimal>>" }],
+        [["some", [[1n, 18]]]],
+      ),
+    ).toBe("some([{r0: 1, r1: 0, r2: 0, r3: 0, sign: plus}])");
+  });
+
+  test("option<list<bool>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<bool>>" }],
+        [["some", [true, false]]],
+      ),
+    ).toBe("some([true, false])");
+  });
+
+  test("option<list<integer>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<integer>>" }],
+        [["some", [1n, 2n]]],
+      ),
+    ).toBe(
+      "some([{r0: 1, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 2, r1: 0, r2: 0, r3: 0, sign: plus}])",
+    );
+  });
+
+  test("option<list<u8>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<u8>>" }],
+        [["some", [1, 2, 3]]],
+      ),
+    ).toBe("some([1, 2, 3])");
+  });
+
+  test("option<list<u16>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<u16>>" }],
+        [["some", [100, 200]]],
+      ),
+    ).toBe("some([100, 200])");
+  });
+
+  test("option<list<u32>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<u32>>" }],
+        [["some", [1000, 2000]]],
+      ),
+    ).toBe("some([1000, 2000])");
+  });
+
+  test("option<list<u64>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<u64>>" }],
+        [["some", [100n, 200n]]],
+      ),
+    ).toBe("some([100, 200])");
+  });
+
+  test("option<list<s8>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<s8>>" }],
+        [["some", [-1, 0, 1]]],
+      ),
+    ).toBe("some([-1, 0, 1])");
+  });
+
+  test("option<list<s16>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<s16>>" }],
+        [["some", [-100, 100]]],
+      ),
+    ).toBe("some([-100, 100])");
+  });
+
+  test("option<list<s32>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<s32>>" }],
+        [["some", [-1000, 1000]]],
+      ),
+    ).toBe("some([-1000, 1000])");
+  });
+
+  test("option<list<s64>>", () => {
+    expect(
+      encodeWitParameters(
+        [{ type: "option<list<s64>>" }],
+        [["some", [-100n, 100n]]],
+      ),
+    ).toBe("some([-100, 100])");
+  });
+
+  test("option<list<record>>", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "option<list<record>>",
+            components: [
+              { name: "a", type: "integer" },
+              { name: "b", type: "decimal" },
+            ],
+          },
+        ],
+        [
+          [
+            "some",
+            [
+              { a: 7n, b: [7n, 18] },
+              { a: 1n, b: [2n, 18] },
+            ],
+          ],
+        ],
+      ),
+    ).toBe(
+      `some([{a: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, b: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}}, ` +
+        `{a: {r0: 1, r1: 0, r2: 0, r3: 0, sign: plus}, b: {r0: 2, r1: 0, r2: 0, r3: 0, sign: plus}}])`,
+    );
+  });
+
+  test("option<list<variant>>", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "option<list<variant>>",
+            components: [
+              { name: "none", type: "_" },
+              { name: "value", type: "u32" },
+            ],
+          },
+        ],
+        [["some", [["none"], ["value", 10]]]],
+      ),
+    ).toBe("some([none, value(10)])");
+  });
+
+  test("option<list<enum>>", () => {
+    expect(
+      encodeWitParameters(
+        [
+          {
+            type: "option<list<enum>>",
+            components: [
+              { name: "red", type: "_" },
+              { name: "green", type: "_" },
+              { name: "blue", type: "_" },
+            ],
+          },
+        ],
+        [["some", ["red", "blue"]]],
+      ),
+    ).toBe("some([red, blue])");
+  });
 });
 
-test("option<decimal>", () => {
-  expect(
-    encodeWitParameters(
-      [{ type: "option<decimal>" }],
-      [{ kind: "some", value: [7n, 18] }],
-    ),
-  ).toBe(`some({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})`);
+// ============================================================================
+// CONTRACT ADDRESS TYPE
+// ============================================================================
+
+describe("contract-address type", () => {
+  test("contract-address", () => {
+    expect(
+      encodeWitParameters([{ type: "contract-address" }], ["token_0_0"]),
+    ).toBe(`{name: "token", height: 0, tx_index: 0}`);
+  });
 });
 
-test.skip("tuple", () => {
-  expect(
-    encodeWitParameters(
-      [
-        {
-          type: "tuple",
-          components: [
-            { name: "a", type: "integer" },
-            { name: "b", type: "decimal" },
-          ],
-        },
-      ],
-      [{ a: 7n, b: [7n, 18] }],
-    ),
-  ).toBe(
-    `{a: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, b: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}}`,
-  );
+// ============================================================================
+// ERROR CASES
+// ============================================================================
+
+describe("error cases", () => {
+  test("invalid list<list<integer>>", () => {
+    expect(() =>
+      encodeWitParameters([{ type: "list<list<integer>>" }], [[[7n, 8n]]]),
+    ).toThrowError(
+      `Type "list<list<integer>>" is not a valid encoding type.
+Please provide a valid WIT type.
+
+Docs: https://docs.kontor.networktk
+Version: kontor-sdk@1.0.0`,
+    );
+  });
 });