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

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

@@ -1,130 +1,153 @@
 import type { WitParameter, WitType } from "../../../wit/wit.js";
 import { InvalidWitEncodingTypeError } from "../../errors/wit.js";
-import { DecimalCodec } from "./codecs/decimal.js";
-import { IntegerCodec } from "./codecs/integer.js";
-import { U64Codec } from "./codecs/u64.js";
-import { S64Codec } from "./codecs/s64.js";
-import { BoolCodec } from "./codecs/bool.js";
-import { StringCodec } from "./codecs/string.js";
-import { OptionCodecFactory } from "./codecs/option.js";
-import { ListCodecFactory } from "./codecs/list.js";
-import {
-  makeDecoder,
-  type CodecConstructor,
-  type CodecInstance,
-  type WaveExpr,
-} from "./codecs/types.js";
+import type { Codec } from "./codecs/types.js";
+import * as C from "./codecs/index.js";
+
+import { WitError } from "../../../wit/built-ins.js";
+
+export type VariantValue = [string, unknown];
+export type RecordValue = Record<string, unknown>;
 
 export function decodeWitParameter(value: string, param: WitParameter) {
   const decoder = decoderForParam(param);
-
   return {
-    decoded: decoder.decode(value),
+    decoded: decoder.decodeWave(value),
   };
 }
 
-export function decodeTuple(
-  record: Record<string, string>,
-  param: WitParameter,
-): Record<string, string> {
+export function RecordCodec(param: WitParameter): Codec<RecordValue> {
   if (!param.components) {
-    throw new Error("Tuple parameter missing components");
+    throw new Error("Record parameter missing components");
   }
 
-  return param.components.reduce<Record<string, string>>(
-    (acc, component: WitParameter) => {
-      if (!component.name) {
-        throw new Error("Tuple component missing name");
+  return {
+    decodeWave(expr: string): RecordValue {
+      const record = parseWitRecord(expr);
+      const result: Record<string, unknown> = {};
+
+      for (const component of param.components!) {
+        if (!component.name) {
+          throw new Error("Record component missing name");
+        }
+
+        const fieldValue = record[component.name];
+        if (fieldValue === undefined) {
+          throw new Error(`Record missing field "${component.name}"`);
+        }
+
+        const decoder = decoderForParam(component);
+        result[component.name] = decoder.decodeWave(fieldValue);
       }
 
-      const fieldValue = record[component.name];
-      const decoder = decoderForParam(component);
-      // @ts-ignore
-      acc[component.name] = decoder.decode(fieldValue!);
+      return result;
+    },
 
-      return acc;
+    encodeWave(_value: RecordValue): string {
+      throw new Error(
+        "RecordCodec.encodeWave not implemented for decoding context",
+      );
     },
-    {},
-  );
+  };
 }
 
-export class TupleCodecInstance
-  implements CodecInstance<Record<string, string>>
-{
-  // 'data' holds the raw parsed JSON object representing the encoded tuple
-  constructor(
-    public readonly data: Record<string, string>,
-    private readonly param: WitParameter,
-  ) {}
-
-  // Fixes Error 2416: Property 'toWave' must return the branded type WaveExpr
-  toWave(): WaveExpr {
-    // Converts JS data back to the wave format (usually a stringified object)
-    throw new Error("TupleCodec.toWave not implemented for decoding context");
+export function VariantCodec(param: WitParameter): Codec<VariantValue> {
+  if (!param.components) {
+    throw new Error("Variant parameter missing components");
   }
 
-  toJs(): Record<string, string> {
-    // The core decoding step: recursively call decodeTuple
-    return decodeTuple(this.data, this.param);
-  }
-}
+  return {
+    decodeWave(expr: string): VariantValue {
+      // Variant format is either:
+      // - "case-name" (for cases without payload)
+      // - "case-name(value)" (for cases with payload)
+
+      const match = expr.match(/^([a-z][a-z0-9-]*)(?:\((.*)\))?$/s);
+      if (!match) {
+        throw new Error(`Invalid variant format: ${expr}`);
+      }
 
-export function makeTupleCodecConstructor(
-  param: WitParameter,
-): CodecConstructor<
-  Record<string, string>, // JS Type
-  TupleCodecInstance, // Instance Type (now correctly defined outside)
-  Record<string, string> // Wave Data Type (Parsed JSON object)
-> {
-  if (!param.components) {
-    throw new Error("Cannot create TupleCodec: Parameter missing components");
-  }
+      const [, caseName, payload] = match;
+
+      // Find the matching variant case
+      const variantCase = param.components!.find(
+        (c: WitParameter) => c.name === caseName,
+      );
 
-  // 2. Define the CodecConstructor class with static methods
-  // We remove 'implements CodecConstructor<any, any, any>' as the function returns the class itself
-  // (Fixes Error 2420, although the original code had the static methods, this clarifies intent).
-  class TupleCodec {
-    // --- Static CodecConstructor methods ---
+      if (!variantCase) {
+        throw new Error(`Unknown variant case: ${caseName}`);
+      }
 
-    // Called to create an instance from a JavaScript value (e.g., when encoding)
-    static fromJs(_value: Record<string, string>): TupleCodecInstance {
-      // NOTE: Full encoding implementation is omitted for focus
-      throw new Error("TupleCodec.fromJs not implemented for decoding context");
-    }
+      // If the case has no payload (type is "_")
+      if (variantCase.type === "_") {
+        if (payload) {
+          throw new Error(
+            `Variant case ${caseName} expects no payload but got: ${payload}`,
+          );
+        }
+        return [caseName!, undefined];
+      }
 
-    // Called to parse the raw encoded string into a JavaScript object (Wave Data)
-    static parseWave(expr: string): Record<string, string> {
-      // For tuples, the raw encoded string is the JSON representation.
+      // Case expects a payload
+      if (!payload) {
+        throw new Error(
+          `Variant case ${caseName} expects a payload but got none`,
+        );
+      }
 
-      return parseWitRecord(expr) as Record<string, string>;
-    }
+      // Decode the payload according to the case's type
+      const decoder = decoderForParam(variantCase);
+      const decodedValue = decoder.decodeWave(payload);
 
-    // Called to create an instance from the parsed Wave Data
-    static fromKontor(data: Record<string, string>): TupleCodecInstance {
-      // Pass the original parameter definition to the instance for use in toJs()
-      return new TupleCodecInstance(data, param);
-    }
+      return [caseName!, decodedValue];
+    },
 
-    // --- Instance constructor (optional, mainly for type checking compatibility) ---
-    constructor(data: Record<string, string>) {
-      // Delegate to the static factory to ensure the instance is correctly initialized
-      return TupleCodec.fromKontor(data) as TupleCodecInstance;
-    }
+    encodeWave(_value: VariantValue): string {
+      throw new Error(
+        "VariantCodec.encodeWave not implemented for decoding context",
+      );
+    },
+  };
+}
+
+export function EnumCodec(param: WitParameter): Codec<string> {
+  if (!param.components) {
+    throw new Error("Enum parameter missing components (cases)");
   }
 
-  // 3. Cast the class to the correct CodecConstructor type
-  return TupleCodec as unknown as CodecConstructor<
-    Record<string, string>,
-    TupleCodecInstance,
-    Record<string, string>
-  >;
+  const validCases = param.components.map((c) => c.name);
+
+  return {
+    decodeWave(expr: string): string {
+      const caseName = expr.trim();
+
+      // Validate that it's a valid case
+      if (!validCases.includes(caseName)) {
+        throw new Error(
+          `Invalid enum case "${caseName}". Valid cases: ${validCases.join(", ")}`,
+        );
+      }
+
+      return caseName;
+    },
+
+    encodeWave(value: string): string {
+      // Validate that it's a valid case
+      if (!validCases.includes(value)) {
+        throw new Error(
+          `Invalid enum case "${value}". Valid cases: ${validCases.join(", ")}`,
+        );
+      }
+
+      return value;
+    },
+  };
 }
 
-export function parseWitRecord(raw: string) {
+export function parseWitRecord(raw: string): Record<string, string> {
   // Remove leading/trailing whitespace and outer braces
   const trimmed = raw.trim().replace(/^\{|\}$/g, "");
 
-  const result = {};
+  const result: Record<string, string> = {};
   let depth = 0;
   let currentKey = "";
   let currentValue = "";
@@ -147,7 +170,6 @@ export function parseWitRecord(raw: string) {
       continue;
     } else if (char === "," && depth === 0) {
       // Found separator between key-value pairs
-      // @ts-ignore
       result[currentKey.trim()] = currentValue.trim();
       currentKey = "";
       currentValue = "";
@@ -167,170 +189,445 @@ export function parseWitRecord(raw: string) {
 
   // Add the last key-value pair
   if (currentKey.trim()) {
-    // @ts-ignore
     result[currentKey.trim()] = currentValue.trim();
   }
 
   return result;
 }
 
-function decoderForParam(p: WitParameter) {
+export function decoderForParam(p: WitParameter): Codec<unknown> {
   const t = p.type as WitType;
-
   switch (t) {
-    // --- tuples -------------------------------------------------
-    case "tuple":
-      return makeDecoder(makeTupleCodecConstructor(p));
-    case "option<tuple>":
-      return makeDecoder(
-        OptionCodecFactory.create(makeTupleCodecConstructor(p)),
-      );
-    case "list<tuple>":
-      return makeDecoder(ListCodecFactory.create(makeTupleCodecConstructor(p)));
-
-    // --- string -------------------------------------------------
+    // --- variant -----------------------------------------------
+    case "variant":
+      return VariantCodec(p);
+    case "option<variant>":
+      return C.OptionCodec(VariantCodec(p));
+    case "list<variant>":
+      return C.ListCodec(VariantCodec(p));
+    case "result<variant, error>":
+      return C.ResultCodec(VariantCodec(p), VariantCodec(WitError.param));
+
+    // --- record -------------------------------------------------
+    case "record":
+      return RecordCodec(p);
+    case "option<record>":
+      return C.OptionCodec(RecordCodec(p));
+    case "list<record>":
+      return C.ListCodec(RecordCodec(p));
+    case "result<record, error>":
+      return C.ResultCodec(RecordCodec(p), VariantCodec(WitError.param));
+
+    // --- enum --------------------------------------------------
+    case "enum":
+      return EnumCodec(p);
+    case "option<enum>":
+      return C.OptionCodec(EnumCodec(p));
+    case "list<enum>":
+      return C.ListCodec(EnumCodec(p));
+    case "result<enum, error>":
+      return C.ResultCodec(EnumCodec(p), VariantCodec(WitError.param));
+
+    // --- string ------------------------------------------------
     case "string":
-      return makeDecoder(StringCodec);
+      return C.StringCodec;
     case "option<string>":
-      return makeDecoder(OptionCodecFactory.create(StringCodec));
+      return C.OptionCodec(C.StringCodec);
     case "list<string>":
-      return makeDecoder(ListCodecFactory.create(StringCodec));
+      return C.ListCodec(C.StringCodec);
+    case "result<string, error>":
+      return C.ResultCodec(C.StringCodec, VariantCodec(WitError.param));
 
-    // --- decimal ------------------------------------------------
+    // --- decimal -----------------------------------------------
     case "decimal":
-      return makeDecoder(DecimalCodec);
+      return C.DecimalCodec;
     case "option<decimal>":
-      return makeDecoder(OptionCodecFactory.create(DecimalCodec));
+      return C.OptionCodec(C.DecimalCodec);
     case "list<decimal>":
-      return makeDecoder(ListCodecFactory.create(DecimalCodec));
+      return C.ListCodec(C.DecimalCodec);
+    case "result<decimal, error>":
+      return C.ResultCodec(C.DecimalCodec, VariantCodec(WitError.param));
 
-    // --- bool ---------------------------------------------------
+    // --- bool --------------------------------------------------
     case "bool":
-      return makeDecoder(BoolCodec);
+      return C.BoolCodec;
     case "option<bool>":
-      return makeDecoder(OptionCodecFactory.create(BoolCodec));
+      return C.OptionCodec(C.BoolCodec);
     case "list<bool>":
-      return makeDecoder(ListCodecFactory.create(BoolCodec));
-
-    // --- u64 ----------------------------------------------------
-    case "u64":
-      return makeDecoder(U64Codec);
-    case "option<u64>":
-      return makeDecoder(OptionCodecFactory.create(U64Codec));
-    case "list<u64>":
-      return makeDecoder(ListCodecFactory.create(U64Codec));
-
-    // --- s64 ----------------------------------------------------
-    case "s64":
-      return makeDecoder(S64Codec);
-    case "option<s64>":
-      return makeDecoder(OptionCodecFactory.create(S64Codec));
-    case "list<s64>":
-      return makeDecoder(ListCodecFactory.create(S64Codec));
+      return C.ListCodec(C.BoolCodec);
+    case "result<bool, error>":
+      return C.ResultCodec(C.BoolCodec, VariantCodec(WitError.param));
 
-    // --- integer ------------------------------------------------
+    // --- integer -----------------------------------------------
     case "integer":
-      return makeDecoder(IntegerCodec);
+      return C.IntegerCodec;
     case "option<integer>":
-      return makeDecoder(OptionCodecFactory.create(IntegerCodec));
+      return C.OptionCodec(C.IntegerCodec);
     case "list<integer>":
-      return makeDecoder(ListCodecFactory.create(IntegerCodec));
+      return C.ListCodec(C.IntegerCodec);
+    case "result<integer, error>":
+      return C.ResultCodec(C.IntegerCodec, VariantCodec(WitError.param));
 
-    // --- not supported (yet) -----------------------------------
-    case "error":
-    case "contract-address":
-    case "s8":
-    case "s16":
-    case "s32":
+    // --- u8 ----------------------------------------------------
     case "u8":
-    case "u16":
-    case "u32":
-    case "option<s8>":
-    case "option<s16>":
-    case "option<s32>":
+      return C.U8Codec;
     case "option<u8>":
-    case "option<u16>":
-    case "option<u32>":
-    case "option<_>":
-    case "list<s8>":
-    case "list<s16>":
-    case "list<s32>":
+      return C.OptionCodec(C.U8Codec);
     case "list<u8>":
+      return C.ListCodec(C.U8Codec);
+    case "result<u8, error>":
+      return C.ResultCodec(C.U8Codec, VariantCodec(WitError.param));
+
+    // --- u16 ---------------------------------------------------
+    case "u16":
+      return C.U16Codec;
+    case "option<u16>":
+      return C.OptionCodec(C.U16Codec);
     case "list<u16>":
+      return C.ListCodec(C.U16Codec);
+    case "result<u16, error>":
+      return C.ResultCodec(C.U16Codec, VariantCodec(WitError.param));
+
+    // --- u32 ---------------------------------------------------
+    case "u32":
+      return C.U32Codec;
+    case "option<u32>":
+      return C.OptionCodec(C.U32Codec);
     case "list<u32>":
-    case "list<_>":
-    case "result<_, error>":
-    case "result<string, error>":
-    case "result<bool, error>":
+      return C.ListCodec(C.U32Codec);
+    case "result<u32, error>":
+      return C.ResultCodec(C.U32Codec, VariantCodec(WitError.param));
+
+    // --- u64 ---------------------------------------------------
+    case "u64":
+      return C.U64Codec;
+    case "option<u64>":
+      return C.OptionCodec(C.U64Codec);
+    case "list<u64>":
+      return C.ListCodec(C.U64Codec);
+    case "result<u64, error>":
+      return C.ResultCodec(C.U64Codec, VariantCodec(WitError.param));
+
+    // --- s8 ----------------------------------------------------
+    case "s8":
+      return C.S8Codec;
+    case "option<s8>":
+      return C.OptionCodec(C.S8Codec);
+    case "list<s8>":
+      return C.ListCodec(C.S8Codec);
     case "result<s8, error>":
+      return C.ResultCodec(C.S8Codec, VariantCodec(WitError.param));
+
+    // --- s16 ---------------------------------------------------
+    case "s16":
+      return C.S16Codec;
+    case "option<s16>":
+      return C.OptionCodec(C.S16Codec);
+    case "list<s16>":
+      return C.ListCodec(C.S16Codec);
     case "result<s16, error>":
+      return C.ResultCodec(C.S16Codec, VariantCodec(WitError.param));
+
+    // --- s32 ---------------------------------------------------
+    case "s32":
+      return C.S32Codec;
+    case "option<s32>":
+      return C.OptionCodec(C.S32Codec);
+    case "list<s32>":
+      return C.ListCodec(C.S32Codec);
     case "result<s32, error>":
+      return C.ResultCodec(C.S32Codec, VariantCodec(WitError.param));
+
+    // --- s64 ---------------------------------------------------
+    case "s64":
+      return C.S64Codec;
+    case "option<s64>":
+      return C.OptionCodec(C.S64Codec);
+    case "list<s64>":
+      return C.ListCodec(C.S64Codec);
     case "result<s64, error>":
-    case "result<u8, error>":
-    case "result<u16, error>":
-    case "result<u32, error>":
-    case "result<u64, error>":
-    case "result<decimal, error>":
-    case "result<integer, error>":
-    case "result<tuple, error>":
-    case "result<option<string>, error>":
-    case "result<option<bool>, error>":
-    case "result<option<s8>, error>":
-    case "result<option<s16>, error>":
-    case "result<option<s32>, error>":
-    case "result<option<s64>, error>":
-    case "result<option<u8>, error>":
-    case "result<option<u16>, error>":
-    case "result<option<u32>, error>":
-    case "result<option<u64>, error>":
-    case "result<option<decimal>, error>":
-    case "result<option<integer>, error>":
+      return C.ResultCodec(C.S64Codec, VariantCodec(WitError.param));
+
+    // --- unit (special cases) ----------------------------------
+    case "option<_>":
+      return C.OptionCodec(C.UnitCodec);
+    case "result<_, error>":
+      return C.ResultCodec(C.UnitCodec, VariantCodec(WitError.param));
     case "result<option<_>, error>":
-    case "result<option<tuple>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.UnitCodec),
+        VariantCodec(WitError.param),
+      );
+
+    // --- option of list (nested) -------------------------------
     case "option<list<string>>":
+      return C.OptionCodec(C.ListCodec(C.StringCodec));
+    case "option<list<decimal>>":
+      return C.OptionCodec(C.ListCodec(C.DecimalCodec));
     case "option<list<bool>>":
-    case "option<list<s8>>":
-    case "option<list<s16>>":
-    case "option<list<s32>>":
-    case "option<list<s64>>":
+      return C.OptionCodec(C.ListCodec(C.BoolCodec));
+    case "option<list<integer>>":
+      return C.OptionCodec(C.ListCodec(C.IntegerCodec));
     case "option<list<u8>>":
+      return C.OptionCodec(C.ListCodec(C.U8Codec));
     case "option<list<u16>>":
+      return C.OptionCodec(C.ListCodec(C.U16Codec));
     case "option<list<u32>>":
+      return C.OptionCodec(C.ListCodec(C.U32Codec));
     case "option<list<u64>>":
-    case "option<list<decimal>>":
-    case "option<list<integer>>":
-    case "option<list<_>>":
-    case "option<list<tuple>>":
-    case "result<option<list<string>>, error>":
-    case "result<option<list<bool>>, error>":
-    case "result<option<list<s8>>, error>":
-    case "result<option<list<s16>>, error>":
-    case "result<option<list<s32>>, error>":
-    case "result<option<list<s64>>, error>":
-    case "result<option<list<u8>>, error>":
-    case "result<option<list<u16>>, error>":
-    case "result<option<list<u32>>, error>":
-    case "result<option<list<u64>>, error>":
-    case "result<option<list<decimal>>, error>":
-    case "result<option<list<integer>>, error>":
-    case "result<option<list<_>>, error>":
-    case "result<option<list<tuple>>, error>":
+      return C.OptionCodec(C.ListCodec(C.U64Codec));
+    case "option<list<s8>>":
+      return C.OptionCodec(C.ListCodec(C.S8Codec));
+    case "option<list<s16>>":
+      return C.OptionCodec(C.ListCodec(C.S16Codec));
+    case "option<list<s32>>":
+      return C.OptionCodec(C.ListCodec(C.S32Codec));
+    case "option<list<s64>>":
+      return C.OptionCodec(C.ListCodec(C.S64Codec));
+    case "option<list<variant>>":
+      return C.OptionCodec(C.ListCodec(VariantCodec(p)));
+    case "option<list<record>>":
+      return C.OptionCodec(C.ListCodec(RecordCodec(p)));
+    case "option<list<enum>>":
+      return C.OptionCodec(C.ListCodec(EnumCodec(p)));
+    // --- result of option (nested) -----------------------------
+    case "result<option<string>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.StringCodec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<decimal>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.DecimalCodec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<bool>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.BoolCodec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<integer>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.IntegerCodec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<u8>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.U8Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<u16>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.U16Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<u32>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.U32Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<u64>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.U64Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<s8>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.S8Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<s16>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.S16Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<s32>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.S32Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<s64>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.S64Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<variant>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(VariantCodec(p)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<record>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(RecordCodec(p)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<enum>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(EnumCodec(p)),
+        VariantCodec(WitError.param),
+      );
+
+    // --- result of list (nested) -------------------------------
     case "result<list<string>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.StringCodec),
+        VariantCodec(WitError.param),
+      );
+    case "result<list<decimal>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.DecimalCodec),
+        VariantCodec(WitError.param),
+      );
     case "result<list<bool>, error>":
-    case "result<list<s8>, error>":
-    case "result<list<s16>, error>":
-    case "result<list<s32>, error>":
-    case "result<list<s64>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.BoolCodec),
+        VariantCodec(WitError.param),
+      );
+    case "result<list<integer>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.IntegerCodec),
+        VariantCodec(WitError.param),
+      );
     case "result<list<u8>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.U8Codec),
+        VariantCodec(WitError.param),
+      );
     case "result<list<u16>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.U16Codec),
+        VariantCodec(WitError.param),
+      );
     case "result<list<u32>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.U32Codec),
+        VariantCodec(WitError.param),
+      );
     case "result<list<u64>, error>":
-    case "result<list<decimal>, error>":
-    case "result<list<integer>, error>":
-    case "result<list<_>, error>":
-    case "result<list<tuple>, error>":
-      throw new InvalidWitEncodingTypeError(t, { docsPath: "tk" });
+      return C.ResultCodec(
+        C.ListCodec(C.U64Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<list<s8>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.S8Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<list<s16>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.S16Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<list<s32>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.S32Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<list<s64>, error>":
+      return C.ResultCodec(
+        C.ListCodec(C.S64Codec),
+        VariantCodec(WitError.param),
+      );
+    case "result<list<variant>, error>":
+      return C.ResultCodec(
+        C.ListCodec(VariantCodec(p)),
+        VariantCodec(WitError.param),
+      );
+    case "result<list<record>, error>":
+      return C.ResultCodec(
+        C.ListCodec(RecordCodec(p)),
+        VariantCodec(WitError.param),
+      );
+    case "result<list<enum>, error>":
+      return C.ResultCodec(
+        C.ListCodec(EnumCodec(p)),
+        VariantCodec(WitError.param),
+      );
 
+    case "result<option<_>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.UnitCodec),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<string>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.StringCodec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<decimal>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.DecimalCodec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<bool>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.BoolCodec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<integer>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.IntegerCodec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<u8>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.U8Codec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<u16>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.U16Codec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<u32>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.U32Codec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<u64>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.U64Codec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<s8>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.S8Codec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<s16>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.S16Codec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<s32>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.S32Codec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<s64>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(C.S64Codec)),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<variant>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(VariantCodec(p))),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<record>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(RecordCodec(p))),
+        VariantCodec(WitError.param),
+      );
+    case "result<option<list<enum>>, error>":
+      return C.ResultCodec(
+        C.OptionCodec(C.ListCodec(EnumCodec(p))),
+        VariantCodec(WitError.param),
+      );
+    case "error":
+      return VariantCodec(WitError.param);
+    case "contract-address":
+      return C.ContractAddressCodec;
     default: {
       t satisfies never;
       throw new InvalidWitEncodingTypeError(t, { docsPath: "tk" });