@kontor/kontor-sdk 1.0.0-alpha.0

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

@@ -0,0 +1,92 @@
+import type { Wit } from "../../../wit/wit.js";
+import type { UnionEvaluate } from "../../../wit/type-utils.js";
+import type {
+  ExtractWitItemForArgs,
+  WitItem,
+  WitItemArgs,
+  WitItemName,
+  Widen,
+} from "../../types/contract.js";
+
+type Wave = string;
+
+export type GetWitItemParameters<
+  wit extends Wit | readonly unknown[] = Wit,
+  name extends WitItemName<wit> = WitItemName<wit>,
+  args extends WitItemArgs<wit, name> | undefined = WitItemArgs<wit, name>,
+  ///
+  allArgs = WitItemArgs<wit, name>,
+  allNames = WitItemName<wit>,
+> = {
+  wit: wit;
+  name:
+    | allNames // show all options
+    | (name extends allNames ? name : never) // infer value
+    | Wave; // function selector
+} & UnionEvaluate<
+  readonly [] extends allArgs
+    ? {
+        args?:
+          | allArgs // show all options
+          // infer value, widen inferred value of `args` conditionally to match `allArgs`
+          | (wit extends Wit
+              ? args extends allArgs
+                ? Widen<args>
+                : never
+              : never)
+          | undefined;
+      }
+    : {
+        args?:
+          | allArgs // show all options
+          | (Widen<args> & (args extends allArgs ? unknown : never)) // infer value, widen inferred value of `args` match `allArgs` (e.g. avoid union `args: readonly [123n] | readonly [bigint]`)
+          | undefined;
+      }
+>;
+
+// TODO: refine error
+export type GetWitItemErrorType = any;
+// | IsHexErrorType
+// | ToFunctionSelectorErrorType
+// | WitItemAmbiguityErrorType
+// | ErrorType;
+
+export type GetWitItemReturnType<
+  wit extends Wit | readonly unknown[] = Wit,
+  name extends WitItemName<wit> = WitItemName<wit>,
+  args extends WitItemArgs<wit, name> | undefined = WitItemArgs<wit, name>,
+> = wit extends Wit
+  ? Wit extends wit
+    ? WitItem | undefined
+    : ExtractWitItemForArgs<
+        wit,
+        name,
+        args extends WitItemArgs<wit, name> ? args : WitItemArgs<wit, name>
+      >
+  : WitItem | undefined;
+
+export function getWitItem<
+  const wit extends Wit | readonly unknown[],
+  const Name extends WitItemName<wit>,
+>(parameters: { wit: wit; name: Name }): GetWitItemReturnType<wit, Name> {
+  const { wit: wit, name } = parameters as { wit: Wit; name: string };
+
+  const witItems = wit.filter(
+    (witItem) => "name" in witItem && witItem.name === name,
+  ) as WitItem[];
+
+  if (witItems.length === 0)
+    return undefined as GetWitItemReturnType<wit, Name>;
+
+  if (witItems.length === 1)
+    return witItems[0] as GetWitItemReturnType<wit, Name>;
+
+  // If wit truly has no overloading, hitting this is a spec/parse error.
+  // You can either:
+  //   - throw, or
+  //   - just pick the first and log a warning.
+  // TODO: custom error
+  throw new Error(
+    `Duplicate Wit items for name "${name}". Wit does not support overloading.`,
+  );
+}

package/src/sdk/utils/wit/prepare-encode-function-data.ts

@@ -0,0 +1,94 @@
+import type { Wit, WitStateMutability } from "../../../wit/wit.js";
+import type { IsNarrowable, UnionEvaluate } from "../../../wit/type-utils.js";
+import type {
+  ExtractWitFunction,
+  ExtractWitFunctions,
+} from "../../../wit/utils.js";
+import type {
+  ContractFunctionArgs,
+  ContractFunctionName,
+} from "../../types/contract.js";
+import { getWitItem } from "./get-wit-item.js";
+
+type Wave = string;
+
+export type PrepareEncodeFunctionDataParameters<
+  wit extends Wit | readonly unknown[] = Wit,
+  functionName extends
+    | ContractFunctionName<wit>
+    | undefined = ContractFunctionName<wit>,
+  ///
+  hasFunctions = wit extends Wit
+    ? Wit extends wit
+      ? true
+      : [ExtractWitFunctions<wit>] extends [never]
+        ? false
+        : true
+    : true,
+  allArgs = ContractFunctionArgs<
+    wit,
+    WitStateMutability,
+    functionName extends ContractFunctionName<wit>
+      ? functionName
+      : ContractFunctionName<wit>
+  >,
+  allFunctionNames = ContractFunctionName<wit>,
+> = {
+  wit: wit;
+} & UnionEvaluate<
+  IsNarrowable<wit, Wit> extends true
+    ? wit["length"] extends 1
+      ? { functionName?: functionName | allFunctionNames | Wave | undefined }
+      : { functionName: functionName | allFunctionNames | Wave }
+    : { functionName?: functionName | allFunctionNames | Wave | undefined }
+> &
+  UnionEvaluate<{ args?: allArgs | undefined }> &
+  (hasFunctions extends true ? unknown : never);
+
+export type PrepareEncodeFunctionDataReturnType<
+  wit extends Wit | readonly unknown[] = Wit,
+  functionName extends
+    | ContractFunctionName<wit>
+    | undefined = ContractFunctionName<wit>,
+> = {
+  wit: wit extends Wit
+    ? functionName extends ContractFunctionName<wit>
+      ? [ExtractWitFunction<wit, functionName>]
+      : wit
+    : Wit;
+  functionName: Wave;
+};
+
+export function prepareEncodeFunctionData<
+  const wit extends Wit | readonly unknown[],
+  functionName extends ContractFunctionName<wit> | undefined = undefined,
+>(
+  parameters: PrepareEncodeFunctionDataParameters<wit, functionName>,
+): PrepareEncodeFunctionDataReturnType<wit, functionName> {
+  // TODO: rip out args
+  const {
+    wit: wit,
+    functionName,
+    args: _args,
+  } = parameters as PrepareEncodeFunctionDataParameters;
+
+  let witItem = wit[0];
+  if (functionName) {
+    const item = getWitItem({
+      wit: wit,
+      name: functionName,
+    });
+    // if (!item) throw new WitFunctionNotFoundError(functionName, { docsPath });
+    if (!item) throw new Error("TMP: WitFunctionNotFoundError");
+    witItem = item;
+  }
+
+  if (witItem?.type !== "function")
+    throw new Error("TMP: WitFunctionNotFoundError");
+  // throw new WitFunctionNotFoundError(undefined, { docsPath });
+
+  return {
+    wit: [witItem],
+    functionName: witItem.name,
+  } as unknown as PrepareEncodeFunctionDataReturnType<wit, functionName>;
+}

package/src/wit/error.ts

@@ -0,0 +1,59 @@
+import type { OneOf, Pretty } from "./type-utils.js";
+import { version } from "./version.js";
+
+type BaseErrorArgs = Pretty<
+  {
+    docsPath?: string | undefined;
+    metaMessages?: string[] | undefined;
+  } & OneOf<{ details?: string | undefined } | { cause?: BaseError | Error }>
+>;
+
+export class BaseError extends Error {
+  details: string;
+  docsPath?: string | undefined;
+  metaMessages?: string[] | undefined;
+  shortMessage: string;
+
+  override name = "WitTypeError";
+
+  constructor(shortMessage: string, args: BaseErrorArgs = {}) {
+    const details =
+      args.cause instanceof BaseError
+        ? args.cause.details
+        : args.cause?.message
+          ? args.cause.message
+          : args.details!;
+    const docsPath =
+      args.cause instanceof BaseError
+        ? args.cause.docsPath || args.docsPath
+        : args.docsPath;
+    const message = [
+      shortMessage || "An error occurred.",
+      "",
+      ...(args.metaMessages ? [...args.metaMessages, ""] : []),
+      ...(docsPath ? [`Docs: TODO: add docs path`] : []),
+      ...(details ? [`Details: ${details}`] : []),
+      `Version: kontor-sdk@${version}`,
+    ].join("\n");
+
+    super(message);
+
+    if (args.cause) this.cause = args.cause;
+    this.details = details;
+    this.docsPath = docsPath;
+    this.metaMessages = args.metaMessages;
+    this.shortMessage = shortMessage;
+  }
+}
+
+export type Error_<messages extends string | string[]> = messages extends string
+  ? [
+      // Surrounding with array to prevent `messages` from being widened to `string`
+      `Error: ${messages}`,
+    ]
+  : {
+      [key in keyof messages]: messages[key] extends infer message extends
+        string
+        ? `Error: ${message}`
+        : never;
+    };

package/src/wit/narrow.ts

@@ -0,0 +1,30 @@
+/**
+ * Infers embedded primitive type of any type
+ *
+ * @param T - Type to infer
+ * @returns Embedded type of {@link type}
+ *
+ * @example
+ * type Result = Narrow<['foo', 'bar', 1]>
+ */
+// s/o https://twitter.com/hd_nvim/status/1578567206190780417
+export type Narrow<type> =
+  | (unknown extends type ? unknown : never)
+  | (type extends Function ? type : never)
+  | (type extends bigint | boolean | number | string ? type : never)
+  | (type extends [] ? [] : never)
+  | { [K in keyof type]: Narrow<type[K]> };
+
+/**
+ * Infers embedded primitive type of any type
+ * Same as `as const` but without setting the object as readonly and without needing the user to use it.
+ *
+ * @param value - Value to infer
+ * @returns Value with embedded type inferred
+ *
+ * @example
+ * const result = narrow(['foo', 'bar', 1])
+ */
+export function narrow<type>(value: Narrow<type>) {
+  return value;
+}

package/src/wit/regex.ts

@@ -0,0 +1,7 @@
+export function execTyped<type>(regex: RegExp, string: string) {
+  const match = regex.exec(string);
+  return match?.groups as type | undefined;
+}
+
+export const isGenericRegex =
+  /^(?<outer>borrow|list|option|result|tuple)\s*<(?<inner>[\s\S]+)>\s*$/;

package/src/wit/register.ts

@@ -0,0 +1,50 @@
+// biome-ignore lint/suspicious/noEmptyInterface: <explanation>
+export interface Register {}
+
+export type ResolvedRegister = {
+  contractAddress: Register extends { contractAddress: infer type }
+    ? type
+    : DefaultRegister["contractAddress"];
+  strictWitType: Register extends {
+    strictWitType: infer type extends boolean;
+  }
+    ? type
+    : Register extends { StrictWitType: infer type extends boolean }
+      ? type
+      : DefaultRegister["strictWitType"];
+
+  bigIntType: Register extends { bigIntType: infer type }
+    ? type
+    : Register extends { BigIntType: infer type }
+      ? type
+      : DefaultRegister["bigIntType"];
+
+  intType: Register extends { intType: infer type }
+    ? type
+    : Register extends { IntType: infer type }
+      ? type
+      : DefaultRegister["intType"];
+
+  decimalType: Register extends { decimalType: infer type }
+    ? type
+    : Register extends { DecimalType: infer type }
+      ? type
+      : DefaultRegister["decimalType"];
+
+  addressType: Register extends { addressType: infer type }
+    ? type
+    : Register extends { AddressType: infer type }
+      ? type
+      : DefaultRegister["addressType"];
+};
+
+type DefaultContractAddress = `${string}_${number}_${number}`;
+
+export type DefaultRegister = {
+  contractAddress: DefaultContractAddress;
+  strictWitType: false;
+  intType: number;
+  bigIntType: bigint;
+  addressType: string;
+  decimalType: [bigint, number];
+};

package/src/wit/type-utils.ts

@@ -0,0 +1,98 @@
+export type Filter<
+  items extends readonly unknown[],
+  item,
+  ///
+  acc extends readonly unknown[] = [],
+> = items extends readonly [
+  infer head,
+  ...infer tail extends readonly unknown[],
+]
+  ? [head] extends [item]
+    ? Filter<tail, item, acc>
+    : Filter<tail, item, [...acc, head]>
+  : readonly [...acc];
+
+export type Pretty<type> = { [key in keyof type]: type[key] } & unknown;
+
+// TODO: probably don't need both of these
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+export type Trim<type, chars extends string = " "> = TrimLeft<
+  TrimRight<type, chars>,
+  chars
+>;
+type TrimLeft<t, chars extends string = " "> = t extends `${chars}${infer tail}`
+  ? TrimLeft<tail>
+  : t;
+type TrimRight<
+  t,
+  chars extends string = " ",
+> = t extends `${infer head}${chars}` ? TrimRight<head> : t;
+
+export type OneOf<
+  union extends object,
+  ///
+  allKeys extends KeyofUnion<union> = KeyofUnion<union>,
+> = union extends infer item
+  ? Pretty<item & { [key in Exclude<allKeys, keyof item>]?: never }>
+  : never;
+type KeyofUnion<type> = type extends type ? keyof type : never;
+
+// from viem: https://github.com/wevm/viem/blob/320895cf0e6c654b419d8d61a59c4e7b46674368/src/types/utils.ts#L58
+
+export type IsNever<T> = [T] extends [never] ? true : false;
+
+export type IsNarrowable<T, U> =
+  IsNever<
+    (T extends U ? true : false) & (U extends T ? false : true)
+  > extends true
+    ? false
+    : true;
+
+export type Merge<object1, object2> = Omit<object1, keyof object2> & object2;
+
+export type UnionEvaluate<type> = type extends object ? Prettify<type> : type;
+
+export type UnionToTuple<
+  union,
+  ///
+  last = LastInUnion<union>,
+> = [union] extends [never]
+  ? []
+  : [...UnionToTuple<Exclude<union, last>>, last];
+type LastInUnion<U> =
+  UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (
+    x: infer l,
+  ) => 0
+    ? l
+    : never;
+type UnionToIntersection<union> = (
+  union extends unknown ? (arg: union) => 0 : never
+) extends (arg: infer i) => 0
+  ? i
+  : never;
+
+export type IsUnion<
+  union,
+  ///
+  union2 = union,
+> = union extends union2 ? ([union2] extends [union] ? false : true) : never;
+
+export type UnionOmit<type, keys extends keyof type> = type extends any
+  ? Omit<type, keys>
+  : never;
+
+export type Assign<T, U> = Assign_<T, U> & U;
+type Assign_<T, U> = {
+  [K in keyof T as K extends keyof U
+    ? U[K] extends void
+      ? never
+      : K
+    : K]: K extends keyof U ? U[K] : T[K];
+};
+
+export type ExactPartial<type> = {
+  [key in keyof type]?: type[key] | undefined;
+};

package/src/wit/utils.test-d.ts

@@ -0,0 +1,23 @@
+import { describe, test, assertType } from "vitest";
+import type {
+  // ExtractWitFunctions,
+  IsWit,
+} from "./utils.js";
+import type { Wit } from "./wit.js";
+import { parseWit } from "./wit-parser/parse-wit.js";
+
+const fibWit: Wit = parseWit([
+  "export fib: func(ctx: borrow<proc-context>, arith-address: contract-address, n: u64) -> u64;",
+  "export fib-of-sub: func(ctx: borrow<proc-context>, arith-address: contract-address, x: string, y: string) -> result<u64, error>;",
+  "export cached-values: func(ctx: borrow<view-context>) -> list<u64>;",
+]);
+
+test("IsWit", () => {
+  assertType<IsWit<typeof fibWit>>(true);
+});
+
+describe("Function", () => {
+  test("ExtractWitFunctions", () => {
+    // todo; fill out
+  });
+});