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

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

@@ -1,24 +1,20 @@
-import type { WitParameter, WitList, WitOption } from "../../../wit/wit.js";
+import type {
+  WitError,
+  WitParameter,
+  WitResult,
+  WitType,
+} from "../../../wit/wit.js";
 import type {
   WitParametersToPrimitiveTypes,
-  WitParameterToPrimitiveType,
   Option,
 } from "../../../wit/utils.js";
 import {
   InvalidWitEncodingTypeError,
   WitEncodingLengthMismatchError,
 } from "../../errors/wit.js";
+import * as C from "./codecs/index.js";
+import type { Codec } from "./codecs/types.js";
 
-import { U64Codec } from "./codecs/u64.js";
-import { S64Codec } from "./codecs/s64.js";
-import { DecimalCodec } from "./codecs/decimal.js";
-import { IntegerCodec } from "./codecs/integer.js";
-import { ListCodecFactory } from "./codecs/list.js";
-import { OptionCodecFactory } from "./codecs/option.js";
-import { StringCodec } from "./codecs/string.js";
-import { BoolCodec } from "./codecs/bool.js";
-
-// TODO: consider renaming to Wave
 export type EncodeWitParametersReturnType = string;
 
 export function encodeWitParameters<
@@ -29,310 +25,317 @@ export function encodeWitParameters<
     ? WitParametersToPrimitiveTypes<params>
     : never,
 ): EncodeWitParametersReturnType {
-  if (params.length !== values.length)
+  if (params.length !== values.length) {
     throw new WitEncodingLengthMismatchError({
       expectedLength: params.length as number,
       givenLength: values.length as any,
     });
+  }
 
-  const preparedParams = prepareParams({
-    params: params as readonly WitParameter[],
-    values: values as any,
-  });
-  const encoded = encodeParams(preparedParams);
+  const encodedParams = (params as readonly WitParameter[]).map((param, i) =>
+    encoderForParam(param).encodeWave(values[i] as any),
+  );
 
-  return encoded;
+  return encodedParams.join(", ");
 }
 
-type PreparedParam = { encoded: string };
-
-function prepareParams<const params extends readonly WitParameter[]>({
-  params,
-  values,
-}: {
-  params: params;
-  values: WitParametersToPrimitiveTypes<params>;
-}) {
-  const preparedParams: PreparedParam[] = [];
-  for (let i = 0; i < params.length; i++) {
-    preparedParams.push(prepareParam({ param: params[i]!, value: values[i] }));
-  }
-  return preparedParams;
-}
-function prepareParam<const param extends WitParameter>({
-  param,
-  value,
-}: {
-  param: param;
-  value: WitParameterToPrimitiveType<param>;
-}): PreparedParam {
-  // TODO: this is a little smelly
-
-  const isOption = getOptionComponent(param.type);
-  if (isOption) {
-    const type = param.type as WitOption;
-
-    switch (type) {
-      case "option<bool>":
-        return {
-          encoded: OptionCodecFactory.create(BoolCodec)
-            .fromJs(value as unknown as Option<boolean>)
-            .toWave(),
-        };
-
-      case "option<string>": {
-        return {
-          encoded: OptionCodecFactory.create(StringCodec)
-            .fromJs(value as unknown as Option<string>)
-            .toWave(),
-        };
-      }
+// ============================================================================
+// CODEC BUILDER HELPERS - Reduce duplication while keeping explicit switches
+// ============================================================================
 
-      case "option<integer>": {
-        return {
-          encoded: OptionCodecFactory.create(IntegerCodec)
-            .fromJs(value as unknown as Option<bigint>)
-            .toWave(),
-        };
-      }
+/** Wraps a codec in an OptionCodec */
+function option<T>(codec: Codec<T>): Codec<Option<T>> {
+  return C.OptionCodec(codec);
+}
 
-      case "option<decimal>": {
-        return {
-          encoded: OptionCodecFactory.create(DecimalCodec)
-            .fromJs(value as unknown as Option<[bigint, number]>)
-            .toWave(),
-        };
-      }
+/** Wraps a codec in a ListCodec */
+function list<T>(codec: Codec<T>): Codec<T[]> {
+  return C.ListCodec(codec);
+}
 
-      // signed ints
-      case "option<s8>":
-      case "option<s16>":
-      case "option<s32>":
-        throw new InvalidWitEncodingTypeError(param.type, {
-          docsPath: "tk",
-        });
-      case "option<s64>":
-        return {
-          encoded: OptionCodecFactory.create(S64Codec)
-            .fromJs(value as unknown as Option<bigint>)
-            .toWave(),
-        };
-      case "option<u64>":
-        return {
-          encoded: OptionCodecFactory.create(U64Codec)
-            .fromJs(value as unknown as Option<bigint>)
-            .toWave(),
-        };
-
-      case "option<u8>":
-      case "option<u16>":
-      case "option<u32>":
-      case "option<list<string>>":
-      case "option<list<bool>>":
-      case "option<list<s8>>":
-      case "option<list<s16>>":
-      case "option<list<s32>>":
-      case "option<list<s64>>":
-      case "option<list<u8>>":
-      case "option<list<u16>>":
-      case "option<list<u32>>":
-      case "option<list<u64>>":
-      case "option<list<integer>>":
-      case "option<list<decimal>>":
-      case "option<list<_>>":
-      case "option<list<tuple>>":
-      case "option<_>":
-      case "option<tuple>":
-        // TODO: OptionCodecFactory.create(TupleCodec) once it exists
-        throw new InvalidWitEncodingTypeError(param.type, {
-          docsPath: "tk",
-        });
-
-      default: {
-        const _: never = type;
-
-        throw new InvalidWitEncodingTypeError(_, {
-          docsPath: "tk",
-        });
-      }
+// ============================================================================
+// ENCODER FACTORY - Single explicit switch showing all supported types
+// ============================================================================
+
+export function encoderForParam(param: WitParameter): Codec<unknown> {
+  const type = param.type as Exclude<WitType, WitResult | WitError>;
+
+  switch (type) {
+    // --- BASE TYPES -------------------------------------------------
+    case "bool":
+      return C.BoolCodec;
+    case "string":
+      return C.StringCodec;
+    case "integer":
+      return C.IntegerCodec;
+    case "decimal":
+      return C.DecimalCodec;
+    case "u8":
+      return C.U8Codec;
+    case "u16":
+      return C.U16Codec;
+    case "u32":
+      return C.U32Codec;
+    case "u64":
+      return C.U64Codec;
+    case "s8":
+      return C.S8Codec;
+    case "s16":
+      return C.S16Codec;
+    case "s32":
+      return C.S32Codec;
+    case "s64":
+      return C.S64Codec;
+    case "contract-address":
+      return C.ContractAddressCodec;
+
+    // --- OPTION<BASE> -----------------------------------------------
+    case "option<bool>":
+      return option(C.BoolCodec);
+    case "option<string>":
+      return option(C.StringCodec);
+    case "option<integer>":
+      return option(C.IntegerCodec);
+    case "option<decimal>":
+      return option(C.DecimalCodec);
+    case "option<u8>":
+      return option(C.U8Codec);
+    case "option<u16>":
+      return option(C.U16Codec);
+    case "option<u32>":
+      return option(C.U32Codec);
+    case "option<u64>":
+      return option(C.U64Codec);
+    case "option<s8>":
+      return option(C.S8Codec);
+    case "option<s16>":
+      return option(C.S16Codec);
+    case "option<s32>":
+      return option(C.S32Codec);
+    case "option<s64>":
+      return option(C.S64Codec);
+    case "option<_>":
+      return option(C.UnitCodec);
+
+    // --- LIST<BASE> -------------------------------------------------
+    case "list<bool>":
+      return list(C.BoolCodec);
+    case "list<string>":
+      return list(C.StringCodec);
+    case "list<integer>":
+      return list(C.IntegerCodec);
+    case "list<decimal>":
+      return list(C.DecimalCodec);
+    case "list<u8>":
+      return list(C.U8Codec);
+    case "list<u16>":
+      return list(C.U16Codec);
+    case "list<u32>":
+      return list(C.U32Codec);
+    case "list<u64>":
+      return list(C.U64Codec);
+    case "list<s8>":
+      return list(C.S8Codec);
+    case "list<s16>":
+      return list(C.S16Codec);
+    case "list<s32>":
+      return list(C.S32Codec);
+    case "list<s64>":
+      return list(C.S64Codec);
+
+    // --- OPTION<LIST<BASE>> -----------------------------------------
+    case "option<list<bool>>":
+      return option(list(C.BoolCodec));
+    case "option<list<string>>":
+      return option(list(C.StringCodec));
+    case "option<list<integer>>":
+      return option(list(C.IntegerCodec));
+    case "option<list<decimal>>":
+      return option(list(C.DecimalCodec));
+    case "option<list<u8>>":
+      return option(list(C.U8Codec));
+    case "option<list<u16>>":
+      return option(list(C.U16Codec));
+    case "option<list<u32>>":
+      return option(list(C.U32Codec));
+    case "option<list<u64>>":
+      return option(list(C.U64Codec));
+    case "option<list<s8>>":
+      return option(list(C.S8Codec));
+    case "option<list<s16>>":
+      return option(list(C.S16Codec));
+    case "option<list<s32>>":
+      return option(list(C.S32Codec));
+    case "option<list<s64>>":
+      return option(list(C.S64Codec));
+
+    // --- COMPLEX TYPES ----------------------------------------------
+    case "record":
+      return RecordCodec(param);
+    case "option<record>":
+      return option(RecordCodec(param));
+    case "list<record>":
+      return list(RecordCodec(param));
+    case "option<list<record>>":
+      return option(list(RecordCodec(param)));
+
+    case "variant":
+      return VariantCodec(param);
+    case "option<variant>":
+      return option(VariantCodec(param));
+    case "list<variant>":
+      return list(VariantCodec(param));
+    case "option<list<variant>>":
+      return option(list(VariantCodec(param)));
+
+    case "enum":
+      return EnumCodec(param);
+    case "option<enum>":
+      return option(EnumCodec(param));
+    case "list<enum>":
+      return list(EnumCodec(param));
+    case "option<list<enum>>":
+      return option(list(EnumCodec(param)));
+
+    default: {
+      const _: never = type;
+      throw new InvalidWitEncodingTypeError(_, { docsPath: "tk" });
     }
   }
+}
 
-  const isList = getListComponents(param.type);
-  if (isList) {
-    const type = param.type as WitList;
-
-    switch (type) {
-      case "list<bool>":
-        return {
-          encoded: ListCodecFactory.create(BoolCodec)
-            .fromJs(value as unknown as boolean[])
-            .toWave(),
-        };
-
-      case "list<string>": {
-        return {
-          encoded: ListCodecFactory.create(StringCodec)
-            .fromJs(value as unknown as string[])
-            .toWave(),
-        };
-      }
+// ============================================================================
+// COMPLEX TYPE CODECS
+// ============================================================================
 
-      case "list<integer>": {
-        return {
-          encoded: ListCodecFactory.create(IntegerCodec)
-            .fromJs(value as unknown as bigint[])
-            .toWave(),
-        };
-      }
+export type RecordJs = Record<string, unknown>;
+export type VariantJs = [string] | [string, unknown];
 
-      case "list<decimal>": {
-        return {
-          encoded: ListCodecFactory.create(DecimalCodec)
-            .fromJs(value as unknown as [bigint, number][])
-            .toWave(),
-        };
-      }
-
-      case "list<s64>":
-        return {
-          encoded: ListCodecFactory.create(S64Codec)
-            .fromJs(value as unknown as bigint[])
-            .toWave(),
-        };
-      case "list<u64>":
-        return {
-          encoded: ListCodecFactory.create(U64Codec)
-            .fromJs(value as unknown as bigint[])
-            .toWave(),
-        };
-
-      case "list<_>":
-      case "list<u8>":
-      case "list<u16>":
-      case "list<u32>":
-      case "list<tuple>":
-      case "list<s8>":
-      case "list<s16>":
-      case "list<s32>":
-        // TODO: ListCodecFactory.create(TupleCodec) once it exists
-        throw new InvalidWitEncodingTypeError(param.type, {
-          docsPath: "tk",
-        });
-
-      default: {
-        const _: never = type;
-
-        throw new InvalidWitEncodingTypeError(_, {
-          docsPath: "tk",
-        });
-      }
-    }
+export function RecordCodec(param: WitParameter): Codec<RecordJs> {
+  if (!param.components) {
+    throw new Error("Record parameter missing components");
   }
 
-  if (param.type === "bool") {
-    return encodeBool(value as unknown as boolean);
-  }
+  return {
+    decodeWave(_: string): RecordJs {
+      throw new Error("not implemented");
+    },
 
-  if (param.type === "u64") {
-    return encodeU64(value as unknown as bigint);
-  }
+    encodeWave(value: RecordJs): string {
+      const fields = param.components!.map((component) => {
+        if (!component.name) {
+          throw new Error("Record component missing name");
+        }
 
-  if (param.type === "s64") {
-    return encodeS64(value as unknown as bigint);
-  }
+        const fieldValue = value[component.name];
+        if (fieldValue === undefined) {
+          throw new Error(`Record missing field "${component.name}"`);
+        }
 
-  if (param.type === "integer") {
-    return encodeInteger(value as unknown as bigint);
-  }
+        const codec = encoderForParam(component);
+        const encoded = codec.encodeWave(fieldValue);
 
-  if (param.type === "decimal") {
-    return encodeDecimal(value as unknown as [bigint, number]);
-  }
-  if (param.type === "string") {
-    return encodeString(value as unknown as string);
-  }
-  throw new InvalidWitEncodingTypeError(param.type, {
-    docsPath: "tk",
-  });
+        return `${component.name}: ${encoded}`;
+      });
+
+      return `{${fields.join(", ")}}`;
+    },
+  };
 }
 
-export function getListComponents(type: string): string | undefined {
-  // TODO: add error when nothing inside
+export function VariantCodec(param: WitParameter): Codec<VariantJs> {
+  if (!param.components) {
+    throw new Error("Variant parameter missing components");
+  }
 
-  // Matches things like:
-  // - "list<integer>"
-  // - "list<result<string, integer>>"
-  // - "list< list<decimal> >"
-  const matches = type.match(/^list<(.*)>$/);
+  return {
+    decodeWave(_: string): VariantJs {
+      throw new Error("not implemented");
+    },
 
-  return matches ? matches[1]?.trim() : undefined;
-}
+    encodeWave(value: VariantJs): string {
+      const [caseName, payload] = value;
 
-export function getOptionComponent(type: string): string | undefined {
-  // Matches:
-  // - "option<integer>"
-  // - "option<list<decimal>>"
-  // - "option< result<string, error> >"
-  const matches = type.match(/^option<(.*)>$/);
+      const variantCase = param.components!.find(
+        (c: WitParameter) => c.name === caseName,
+      );
 
-  return matches ? matches[1]?.trim() : undefined;
-}
-export class InvalidResultTypeError extends Error {
-  constructor(type: string) {
-    super(`Invalid result type "${type}". The error channel must be "error".`);
-  }
-}
-
-export function getResultComponentsStrict(
-  type: string,
-): [okType: string, errorType: "error"] | undefined {
-  const matches = type.match(/^result<(.*?),(.*?)>$/);
-  if (!matches) return undefined;
+      if (!variantCase) {
+        throw new Error(`Unknown variant case: ${caseName}`);
+      }
 
-  const okType = matches[1]!.trim();
-  const errType = matches[2]!.trim();
+      // Unit case (no payload)
+      if (variantCase.type === "_") {
+        if (payload !== undefined) {
+          throw new Error(
+            `Variant case ${caseName} expects no payload but got: ${payload}`,
+          );
+        }
+        return caseName;
+      }
 
-  if (errType !== "error") throw new InvalidResultTypeError(errType);
+      // Case with payload
+      if (payload === undefined) {
+        throw new Error(
+          `Variant case ${caseName} expects a payload but got undefined`,
+        );
+      }
 
-  return [okType, "error"];
-}
+      const codec = encoderForParam(variantCase);
+      const encoded = codec.encodeWave(payload);
 
-function encodeBool(value: boolean): PreparedParam {
-  return {
-    encoded: BoolCodec.fromJs(value).toWave(),
+      return `${caseName}(${encoded})`;
+    },
   };
 }
 
-function encodeU64(value: bigint): PreparedParam {
-  return {
-    encoded: U64Codec.fromJs(value).toWave(),
-  };
-}
+export function EnumCodec(param: WitParameter): Codec<string> {
+  if (!param.components) {
+    throw new Error("Enum parameter missing components (cases)");
+  }
+
+  const validCases = param.components.map((c) => c.name);
 
-function encodeS64(value: bigint): PreparedParam {
-  return {
-    encoded: S64Codec.fromJs(value).toWave(),
-  };
-}
-function encodeInteger(value: bigint): PreparedParam {
   return {
-    encoded: IntegerCodec.fromJs(value).toWave(),
+    decodeWave(expr: string): string {
+      const caseName = expr.trim();
+      if (!validCases.includes(caseName)) {
+        throw new Error(
+          `Invalid enum case "${caseName}". Valid cases: ${validCases.join(", ")}`,
+        );
+      }
+      return caseName;
+    },
+
+    encodeWave(value: string): string {
+      if (!validCases.includes(value)) {
+        throw new Error(
+          `Invalid enum case "${value}". Valid cases: ${validCases.join(", ")}`,
+        );
+      }
+      return value;
+    },
   };
 }
 
-function encodeDecimal(value: [bigint, number]): PreparedParam {
-  return {
-    encoded: DecimalCodec.fromJs(value).toWave(),
-  };
+// ============================================================================
+// DEPRECATED - Keep for backward compatibility if needed
+// ============================================================================
+
+/** @deprecated Use encoderForParam instead */
+export function getListComponents(type: string): string | undefined {
+  const matches = type.match(/^list<(.*)>$/);
+  return matches ? matches[1]?.trim() : undefined;
 }
 
-function encodeString(value: string): PreparedParam {
-  return {
-    encoded: StringCodec.fromJs(value).toWave(),
-  };
+/** @deprecated Use encoderForParam instead */
+export function getOptionComponent(type: string): string | undefined {
+  const matches = type.match(/^option<(.*)>$/);
+  return matches ? matches[1]?.trim() : undefined;
 }
 
-function encodeParams(preparedParams: PreparedParam[]): string {
-  return preparedParams.map((p) => p.encoded).join(", ");
+export class InvalidResultTypeError extends Error {
+  constructor(type: string) {
+    super(`Invalid result type "${type}". The error channel must be "error".`);
+  }
 }

package/src/sdk/utils/wit/get-wit-item.test.ts

@@ -142,7 +142,7 @@ describe("getWitItem", () => {
       inputs: [],
       outputs: [
         {
-          type: "list<tuple>",
+          type: "list<record>",
           internalType: "list<balance>",
           components: [
             {

package/src/wit/built-ins.ts

@@ -0,0 +1,23 @@
+import type { WitParameter } from "./wit.js";
+
+export namespace WitError {
+  export const param: WitParameter = {
+    name: "error",
+    type: "variant",
+    internalType: "error",
+    components: [
+      { name: "message", type: "string" },
+      { name: "overflow", type: "string" },
+      { name: "div-by-zero", type: "string" },
+      { name: "syntax", type: "string" },
+      { name: "validation", type: "string" },
+    ],
+  };
+
+  export type T =
+    | ["message", string]
+    | ["overflow", string]
+    | ["div-by-zero", string]
+    | ["syntax", string]
+    | ["validation", string];
+}

package/src/wit/regex.ts

@@ -4,4 +4,4 @@ export function execTyped<type>(regex: RegExp, string: string) {
 }
 
 export const isGenericRegex =
-  /^(?<outer>borrow|list|option|result|tuple)\s*<(?<inner>[\s\S]+)>\s*$/;
+  /^(?<outer>borrow|list|option|result)\s*<(?<inner>[\s\S]+)>\s*$/;