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

package/src/wit/utils.ts

@@ -10,13 +10,16 @@ import type {
   TypedData,
   WitParameterKind,
   WitParameter,
-  WitTuple,
+  WitRecord,
   TypedDataType,
   WitOption,
   WitResult,
+  WitVariant,
+  WitEnum,
 } from "./wit.js";
 import type { ResolvedRegister } from "./register.js";
 import type { Merge, Pretty } from "./type-utils.js";
+import type { WitError } from "./built-ins.js";
 
 export type IsWit<wit> = wit extends Wit ? true : false;
 
@@ -40,9 +43,8 @@ type NoBits = "";
 type GreaterThan48Bits = Exclude<MBits, 8 | 16 | 32 | NoBits>;
 type LessThanOrEqualTo48Bits = Exclude<MBits, GreaterThan48Bits | NoBits>;
 
-// TODO: move these somewhere sane
-export type Option<T> = { kind: "none" } | { kind: "some"; value: T };
-export type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
+export type Option<T> = ["none"] | ["some", T];
+export type Result<T, E> = ["ok", T] | ["err", E];
 
 export type WitTypeToPrimitiveType<witType extends WitType> =
   PrimitiveTypeLookup[witType];
@@ -55,7 +57,9 @@ interface PrimitiveTypeLookup
   bool: boolean;
   address: string;
   string: string;
-  tuple: Record<string, unknown>;
+  record: Record<string, unknown>;
+  variant: [string, unknown];
+  enum: string;
   error: unknown;
   integer: ResolvedRegister["bigIntType"];
   decimal: ResolvedRegister["decimalType"];
@@ -75,8 +79,7 @@ type WitListMap = { [_ in WitList]: readonly unknown[] };
 
 type WitOptionMap = { [_ in WitOption]: Option<unknown> };
 
-// TODO: change string to error type
-type WitResultMap = { [_ in WitResult]: Result<unknown, string> };
+type WitResultMap = { [_ in WitResult]: Result<unknown, WitError.T> };
 
 type BitsTypeLookup = {
   [key in MBits]: ResolvedRegister[key extends LessThanOrEqualTo48Bits
@@ -84,61 +87,21 @@ type BitsTypeLookup = {
     : "bigIntType"];
 };
 
-// TODO: add record / option
 type WitBasicType = Exclude<
   WitType,
-  WitTuple | WitList | WitResult | WitOption
+  WitRecord | WitList | WitResult | WitOption | WitVariant | WitEnum
 >;
 
 export type WitParametersToPrimitiveTypes<
   witParameters extends readonly WitParameter[],
   witParameterKind extends WitParameterKind = WitParameterKind,
 > = Pretty<{
-  // TODO: Convert to labeled tuple so parameter names show up in autocomplete
-  // e.g. [foo: string, bar: string]
-  // https://github.com/microsoft/TypeScript/issues/44939
   [key in keyof witParameters]: WitParameterToPrimitiveType<
     witParameters[key],
     witParameterKind
   >;
 }>;
 
-export type WitParameterToPrimitiveType<
-  witParameter extends WitParameter | { name: string; type: unknown },
-  witParameterKind extends WitParameterKind = WitParameterKind,
-> =
-  // 1. Basic type (non-tuple, non-list) – uses PrimitiveTypeLookup (ints, bool, string, option<string>, result<u64,error>, etc.)
-  witParameter["type"] extends WitBasicType
-    ? WitTypeToPrimitiveType<witParameter["type"]>
-    : // 2. Explicit tuple with components
-      witParameter extends {
-          type: WitTuple;
-          components: infer components extends readonly WitParameter[];
-        }
-      ? WitComponentsToPrimitiveType<components, witParameterKind>
-      : // 3. list<...>
-        MaybeExtractListParameterType<
-            witParameter["type"]
-          > extends infer head extends string
-        ? WitListToPrimitiveType<witParameter, witParameterKind, head>
-        : // 4. option<...>
-          MaybeExtractOptionParameterType<
-              witParameter["type"]
-            > extends infer inner extends string
-          ? WitOptionToPrimitiveType<witParameter, witParameterKind, inner>
-          : // 5. result<Ok, Err>
-            MaybeExtractResultParameterType<witParameter["type"]> extends [
-                infer ok extends string,
-                infer _err extends string,
-              ]
-            ? WitResultToPrimitiveType<witParameter, witParameterKind, ok>
-            : // 6. Fallback / error
-              ResolvedRegister["strictWitType"] extends true
-              ? Error_<`Unknown type '${witParameter["type"] & string}'.`>
-              : witParameter extends { components: Error_<string> }
-                ? witParameter["components"]
-                : unknown;
-
 type MaybeExtractListParameterType<T> = T extends `list<${infer Inner}>`
   ? Inner
   : undefined;
@@ -174,35 +137,121 @@ type WitResultToPrimitiveType<
   witParameter extends WitParameter | { name: string; type: unknown },
   witParameterKind extends WitParameterKind,
   ok extends string,
-  // TODO: error always treated as a string for now
-  // err extends string,
-> = Result<
-  WitParameterToPrimitiveType<
-    Merge<witParameter, { type: ok }>,
-    witParameterKind
-  >,
-  string
->;
+> =
+  Result<
+    WitParameterToPrimitiveType<
+      Merge<witParameter, { type: ok }>,
+      witParameterKind
+    >,
+    WitError.T
+  > extends infer R
+    ? R
+    : never;
+
+export type WitParameterToPrimitiveType<
+  witParameter extends WitParameter | { name: string; type: unknown },
+  witParameterKind extends WitParameterKind = WitParameterKind,
+> =
+  // 1. Basic type
+  witParameter["type"] extends WitBasicType
+    ? WitTypeToPrimitiveType<witParameter["type"]>
+    : // 2. Variant (discriminated union)
+      witParameter extends {
+          type: "variant";
+          components?: infer components extends readonly WitParameter[];
+        }
+      ? WitVariantToPrimitiveType<components, witParameterKind>
+      : // 3. Enum (string literal union)
+        witParameter extends {
+            type: "enum";
+            // components?: infer components extends readonly {
+            //   name: string;
+            //   type: "_";
+            // }[];
+          }
+        ? witParameter extends {
+            components?: infer components extends readonly WitParameter[];
+          }
+          ? WitEnumToPrimitiveType<components>
+          : never
+        : // 4. Explicite record with components
+          witParameter extends {
+              type: WitRecord;
+              components: infer components extends readonly WitParameter[];
+            }
+          ? WitComponentsToPrimitiveType<components, witParameterKind>
+          : // 5. list<...>
+            MaybeExtractListParameterType<
+                witParameter["type"]
+              > extends infer head extends string
+            ? WitListToPrimitiveType<witParameter, witParameterKind, head>
+            : // 6. option<...>
+              MaybeExtractOptionParameterType<
+                  witParameter["type"]
+                > extends infer inner extends string
+              ? WitOptionToPrimitiveType<witParameter, witParameterKind, inner>
+              : // 7. result<Ok, Err>
+                MaybeExtractResultParameterType<witParameter["type"]> extends [
+                    infer ok extends string,
+                    infer _err extends "error",
+                  ]
+                ? WitResultToPrimitiveType<witParameter, witParameterKind, ok>
+                : ResolvedRegister["strictWitType"] extends true
+                  ? Error_<`Unknown type '${witParameter["type"] & string}'.`>
+                  : witParameter extends { components: Error_<string> }
+                    ? witParameter["components"]
+                    : unknown;
+
+type WitVariantToPrimitiveType<
+  components extends readonly WitParameter[],
+  witParameterKind extends WitParameterKind,
+> = {
+  [K in keyof components]: components[K] extends {
+    name: infer CaseName extends string;
+  }
+    ? components[K] extends { type: "_" }
+      ? [CaseName] // Unit case (no value)
+      : components[K] extends {
+            type: WitRecord;
+            name: string;
+            components?: infer components extends readonly WitParameter[];
+          }
+        ? [CaseName, WitComponentsToPrimitiveType<components, witParameterKind>]
+        : [
+            CaseName,
+            WitParameterToPrimitiveType<components[K], witParameterKind>,
+            // components[K],
+          ]
+    : never;
+}[number];
+
+type WitEnumToPrimitiveType<components extends readonly WitParameter[]> =
+  Readonly<{
+    [K in keyof components]: components[K] extends {
+      name: infer CaseName extends string;
+    }
+      ? components[K] extends { type: "_" }
+        ? CaseName
+        : never
+      : never;
+  }>[number];
+
 type WitComponentsToPrimitiveType<
   components extends readonly WitParameter[],
   witParameterKind extends WitParameterKind,
 > = components extends readonly []
   ? []
-  : // Compare the original set of names to a "validated"
-    // set where each name is coerced to a string and undefined|"" are excluded
-    components[number]["name"] extends Exclude<
+  : components[number]["name"] extends Exclude<
         components[number]["name"] & string,
         undefined | ""
       >
-    ? // If all the original names are present, all tuple parameters are named so return as object
-      {
+    ? {
         [component in components[number] as component["name"] & {}]: WitParameterToPrimitiveType<
           component,
           witParameterKind
         >;
       }
-    : // Otherwise, has unnamed tuple parameters so return as array
-      {
+    : {
         [key in keyof components]: WitParameterToPrimitiveType<
           components[key],
           witParameterKind
@@ -215,10 +264,9 @@ export type TypedDataToPrimitiveTypes<
   keyReferences extends { [_: string]: unknown } | unknown = unknown,
 > = {
   [key in keyof typedData]: {
-    // Map over typed data values and turn into key-value pairs
-    [key2 in typedData[key][number] as key2["name"]]: key2["type"] extends key // 1. Eliminate self-referencing structs
+    [key2 in typedData[key][number] as key2["name"]]: key2["type"] extends key
       ? Error_<`Cannot convert self-referencing struct '${key2["type"]}' to primitive type.`>
-      : key2["type"] extends keyof typedData // 2. Check if type is struct
+      : key2["type"] extends keyof typedData
         ? key2["type"] extends keyof keyReferences
           ? Error_<`Circular reference detected. '${key2["type"]}' is a circular reference.`>
           : TypedDataToPrimitiveTypes<
@@ -226,13 +274,12 @@ export type TypedDataToPrimitiveTypes<
               witParameterKind,
               keyReferences & { [_ in key2["type"] | key]: true }
             >[key2["type"]]
-        : // 3. Check if type is array of structs
-          key2["type"] extends `${infer type extends keyof typedData &
+        : key2["type"] extends `${infer type extends keyof typedData &
               string}[${infer tail}]`
           ? WitParameterToPrimitiveType<
               {
                 name: key2["name"];
-                type: `tuple[${tail}]`;
+                type: `record[${tail}]`;
                 components: _TypedDataParametersToWitParameters<
                   typedData[type],
                   typedData,
@@ -241,11 +288,10 @@ export type TypedDataToPrimitiveTypes<
               },
               witParameterKind
             >
-          : key2["type"] extends TypedDataType // 4. Known type to convert
+          : key2["type"] extends TypedDataType
             ? WitParameterToPrimitiveType<key2, witParameterKind>
             : Error_<`Cannot convert unknown type '${key2["type"]}' to primitive type.`>;
   };
-  // Ensure the result is "Prettied"
 } & unknown;
 
 type _TypedDataParametersToWitParameters<
@@ -261,7 +307,7 @@ type _TypedDataParametersToWitParameters<
     ? typedDataParameter["type"] extends keyof typedData & string
       ? {
           name: typedDataParameter["name"];
-          type: "tuple";
+          type: "record";
           components: typedDataParameter["type"] extends keyof keyReferences
             ? Error_<`Circular reference detected. '${typedDataParameter["type"]}' is a circular reference.`>
             : _TypedDataParametersToWitParameters<
@@ -274,7 +320,7 @@ type _TypedDataParametersToWitParameters<
             keyof typedData & string}[${infer tail}]`
         ? {
             name: typedDataParameter["name"];
-            type: `tuple[${tail}]`;
+            type: `record[${tail}]`;
             components: type extends keyof keyReferences
               ? Error_<`Circular reference detected. '${typedDataParameter["type"]}' is a circular reference.`>
               : _TypedDataParametersToWitParameters<

package/src/wit/wit-parser/core/errors/signature.ts

@@ -9,7 +9,7 @@ export class InvalidSignatureError extends BaseError {
     type,
   }: {
     signature: string;
-    type: WitItemType | "record";
+    type: WitItemType | "record" | "variant" | "enum";
   }) {
     super(`Invalid ${type} signature.`, {
       details: signature,
@@ -28,7 +28,7 @@ export class UnknownSignatureError extends BaseError {
 }
 
 export class InvalidRecordSignatureError extends BaseError {
-  override name = "InvalidStructSignatureError";
+  override name = "InvalidRecordSignatureError";
 
   constructor({ signature }: { signature: string }) {
     super("Invalid record signature.", {
@@ -37,3 +37,14 @@ export class InvalidRecordSignatureError extends BaseError {
     });
   }
 }
+
+export class InvalidVariantSignatureError extends BaseError {
+  override name = "InvalidVariantSignatureError";
+
+  constructor({ signature }: { signature: string }) {
+    super("Invalid variant signature.", {
+      details: signature,
+      metaMessages: ["No variant cases"],
+    });
+  }
+}

package/src/wit/wit-parser/core/signatures.ts

@@ -50,3 +50,31 @@ export function execRecordSignature(signature: string) {
     properties: string;
   }>(witRecordSignatureRegex, signature);
 }
+
+const witVariantSignatureRegex =
+  /^variant\s+(?<name>[a-zA-Z$_][a-zA-Z0-9$_-]*)\s*\{(?<cases>[\s\S]*?)\}$/;
+
+export function isVariantSignature(signature: string) {
+  return witVariantSignatureRegex.test(signature);
+}
+
+export function execVariantSignature(signature: string) {
+  return execTyped<{
+    name: string;
+    cases: string;
+  }>(witVariantSignatureRegex, signature);
+}
+
+const witEnumSignatureRegex =
+  /^enum\s+(?<name>[a-zA-Z$_][a-zA-Z0-9$_-]*)\s*\{(?<cases>[\s\S]*?)\}$/;
+
+export function isEnumSignature(signature: string) {
+  return witEnumSignatureRegex.test(signature);
+}
+
+export function execEnumSignature(signature: string) {
+  return execTyped<{
+    name: string;
+    cases: string;
+  }>(witEnumSignatureRegex, signature);
+}

package/src/wit/wit-parser/core/types/signatures.test-d.ts

@@ -3,6 +3,8 @@ import { assertType, test } from "vitest";
 import type {
   IsFunctionSignature,
   IsRecordSignature,
+  IsEnumSignature,
+  IsVariantSignature,
   IsSignature,
 } from "./signatures.js";
 
@@ -29,6 +31,17 @@ test("IsRecordSignature", () => {
     IsRecordSignature<"record token-pair { a: contract-address, b: contract-address }">
   >(true);
 });
+
+test("IsEnumSignature", () => {
+  assertType<IsEnumSignature<"enum color { hot-pink, lime-green, nave-blue }">>;
+});
+
+test("IsVariantSignature", () => {
+  assertType<
+    IsVariantSignature<"variant allowed-destinations { none, any, restricted(list<address>) }">
+  >;
+});
+
 test("IsSignature", () => {
   assertType<
     IsSignature<"record contract-address { name: string, height: s64, tx-index: s64 }">
@@ -49,4 +62,12 @@ test("IsSignature", () => {
   assertType<
     IsSignature<"export cached-values: func(ctx: borrow<view-context>) -> list<u64>;">
   >(true);
+
+  assertType<IsSignature<"enum color { hot-pink, lime-green, nave-blue }">>(
+    true,
+  );
+
+  assertType<
+    IsSignature<"variant allowed-destinations { none, any, restricted(list<address>) }">
+  >(true);
 });

package/src/wit/wit-parser/core/types/signatures.ts

@@ -2,7 +2,9 @@ import type { Error_ } from "../../../error.js";
 
 export type IsSignature<type extends string> =
   | (IsFunctionSignature<type> extends true ? true : never)
-  | (IsRecordSignature<type> extends true ? true : never);
+  | (IsRecordSignature<type> extends true ? true : never)
+  | (IsVariantSignature<type> extends true ? true : never)
+  | (IsEnumSignature<type> extends true ? true : never);
 
 export type Signature<
   string1 extends string,
@@ -28,6 +30,22 @@ export type RecordSignature<
 export type IsRecordSignature<signature extends string> =
   signature extends RecordSignature<infer name> ? IsName<name> : false;
 
+export type VariantSignature<
+  name extends string = string,
+  cases extends string = string,
+> = `variant ${name} { ${cases} }`;
+
+export type IsVariantSignature<signature extends string> =
+  signature extends VariantSignature<infer name> ? IsName<name> : false;
+
+export type EnumSignature<
+  name extends string = string,
+  cases extends string = string,
+> = `enum ${name} { ${cases} }`;
+
+export type IsEnumSignature<signature extends string> =
+  signature extends EnumSignature<infer name> ? IsName<name> : false;
+
 export type FunctionSignature<
   name extends string = string,
   tail extends string = string,
@@ -98,7 +116,6 @@ export type WitKeyword =
   | "variant"
   | "option"
   | "result"
-  | "tuple"
   | "bool"
   | "s8"
   | "s16"