@kontor/kontor-sdk 1.0.0-alpha.0

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

@@ -0,0 +1,77 @@
+import type { Wit, WitStateMutability } from "../../../wit/wit.js";
+import type { IsNarrowable, UnionEvaluate } from "../../../wit/type-utils.js";
+import type { ExtractWitFunctions } from "../../../wit/utils.js";
+import type {
+  ContractFunctionArgs,
+  ContractFunctionName,
+} from "../../types/contract.js";
+import { encodeWitParameters } from "./encode-wit-parameters.js";
+import { prepareEncodeFunctionData } from "./prepare-encode-function-data.js";
+
+// TODO: standardize this and maybe use brand.
+type Wave = string;
+
+export type EncodeFunctionDataParameters<
+  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 | undefined }
+      : { functionName: functionName | allFunctionNames }
+    : { functionName?: functionName | allFunctionNames | undefined }
+> &
+  UnionEvaluate<
+    readonly [] extends allArgs
+      ? { args?: allArgs | undefined }
+      : { args: allArgs }
+  > &
+  (hasFunctions extends true ? unknown : never);
+
+export type EncodeFunctionDataReturnType = Wave;
+
+export function encodeFunctionData<
+  const wit extends Wit | readonly unknown[],
+  functionName extends ContractFunctionName<wit> | undefined = undefined,
+>(
+  parameters: EncodeFunctionDataParameters<wit, functionName>,
+): EncodeFunctionDataReturnType {
+  const { args } = parameters as EncodeFunctionDataParameters;
+
+  const { wit: wit, functionName } = (() => {
+    if (
+      parameters.wit.length === 1 &&
+      parameters.functionName?.startsWith("0x")
+    )
+      return parameters as { wit: Wit; functionName: Wave };
+    return prepareEncodeFunctionData(parameters);
+  })();
+
+  const witItem = wit[0]!; // TODO: do some paranoic checks here
+
+  const data =
+    "inputs" in witItem && witItem.inputs
+      ? encodeWitParameters(witItem.inputs, args ?? [])
+      : undefined;
+  return `${functionName}(${data ?? ""})` as Wave;
+}

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

@@ -0,0 +1,124 @@
+import { expect, test } from "vitest";
+
+import { encodeWitParameters } from "./encode-wit-parameters.js";
+
+test("blank", () => {
+  expect(encodeWitParameters([], [])).toBe("");
+});
+
+test("string", () => {
+  expect(encodeWitParameters([{ type: "string" }], ["bc1deadbeef"])).toBe(
+    `"bc1deadbeef"`,
+  );
+});
+
+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("decimal", () => {
+  expect(encodeWitParameters([{ type: "decimal" }], [[7n, 18]])).toBe(
+    `{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}`,
+    //
+  );
+});
+
+test("list<string>", () => {
+  expect(
+    encodeWitParameters([{ type: "list<string>" }], [["foo", "bar"]]),
+  ).toBe(`["foo", "bar"]`);
+});
+
+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<decimal>", () => {
+  expect(
+    encodeWitParameters(
+      [{ type: "list<decimal>" }],
+      [
+        [
+          [7n, 18],
+          [8n, 10],
+        ],
+      ],
+    ),
+  ).toBe(
+    `[{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 800000000, r1: 0, r2: 0, r3: 0, sign: plus}]`,
+  );
+});
+
+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`,
+  );
+});
+
+test("option<string>", () => {
+  expect(
+    encodeWitParameters(
+      [{ type: "option<string>" }],
+      [{ kind: "some", value: "foo" }],
+    ),
+  ).toBe(`some("foo")`);
+});
+
+test("option<string> ( none ) ", () => {
+  expect(
+    encodeWitParameters([{ type: "option<string>" }], [{ kind: "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})`);
+});
+
+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})`);
+});
+
+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}}`,
+  );
+});

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

@@ -0,0 +1,321 @@
+import type { WitParameter, WitList, WitOption } from "../../../wit/wit.js";
+import type {
+  WitParametersToPrimitiveTypes,
+  WitParameterToPrimitiveType,
+  Option,
+} from "../../../wit/utils.js";
+import {
+  InvalidWitEncodingTypeError,
+  WitEncodingLengthMismatchError,
+} from "../../errors/wit.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";
+
+// TODO: consider renaming to Wave
+export type EncodeWitParametersReturnType = string;
+
+export function encodeWitParameters<
+  const params extends readonly WitParameter[] | readonly unknown[],
+>(
+  params: params,
+  values: params extends readonly WitParameter[]
+    ? WitParametersToPrimitiveTypes<params>
+    : never,
+): EncodeWitParametersReturnType {
+  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);
+
+  return encoded;
+}
+
+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>":
+        // No BoolCodec yet – fail loudly for now.
+        // TODO: change to list speci,fic error
+        throw new InvalidWitEncodingTypeError(param.type, {
+          docsPath: "tk",
+        });
+
+      case "option<string>": {
+        return {
+          encoded: OptionCodecFactory.create(StringCodec)
+            .fromJs(value as unknown as Option<string>)
+            .toWave(),
+        };
+      }
+
+      case "option<integer>": {
+        return {
+          encoded: OptionCodecFactory.create(IntegerCodec)
+            .fromJs(value as unknown as Option<bigint>)
+
+            .toWave(),
+        };
+      }
+
+      case "option<decimal>": {
+        return {
+          encoded: OptionCodecFactory.create(DecimalCodec)
+            .fromJs(value as unknown as Option<[bigint, number]>)
+            .toWave(),
+        };
+      }
+
+      // signed ints
+      case "option<s8>":
+      case "option<s16>":
+      case "option<s32>":
+      case "option<s64>":
+        // TODO: wire up once you have a signed-int codec
+        throw new InvalidWitEncodingTypeError(param.type, {
+          docsPath: "tk",
+        });
+
+      // unsigned ints
+      case "option<u8>":
+      case "option<u16>":
+      case "option<u32>":
+      case "option<u64>":
+        // TODO: wire up once you have an unsigned-int codec
+        throw new InvalidWitEncodingTypeError(param.type, {
+          docsPath: "tk",
+        });
+
+      // tuples
+      case "option<tuple>":
+        // TODO: OptionCodecFactory.create(TupleCodec) once it exists
+        throw new InvalidWitEncodingTypeError(param.type, {
+          docsPath: "tk",
+        });
+
+      default: {
+        // exhaustiveness guard – if WitOption ever gains a new member,
+        // this will start failing at compile time until you add a case.
+        // @ts-ignore
+        const _exhaustive: never = type;
+        throw new InvalidWitEncodingTypeError(param.type, {
+          docsPath: "tk",
+        });
+      }
+    }
+  }
+
+  const isList = getListComponents(param.type);
+  if (isList) {
+    const type = param.type as WitList;
+
+    switch (type) {
+      case "list<bool>":
+        // No BoolCodec yet – fail loudly for now.
+        // TODO: change to list speci,fic error
+        throw new InvalidWitEncodingTypeError(param.type, {
+          docsPath: "tk",
+        });
+
+      case "list<string>": {
+        return {
+          encoded: ListCodecFactory.create(StringCodec)
+            .fromJs(value as unknown as string[])
+            .toWave(),
+        };
+      }
+
+      case "list<integer>": {
+        return {
+          encoded: ListCodecFactory.create(IntegerCodec)
+            .fromJs(value as unknown as bigint[])
+            .toWave(),
+        };
+      }
+
+      case "list<decimal>": {
+        return {
+          encoded: ListCodecFactory.create(DecimalCodec)
+            .fromJs(value as unknown as [bigint, number][])
+            .toWave(),
+        };
+      }
+
+      // signed ints
+      case "list<s8>":
+      case "list<s16>":
+      case "list<s32>":
+      case "list<s64>":
+        // TODO: wire up once you have a signed-int codec
+        throw new InvalidWitEncodingTypeError(param.type, {
+          docsPath: "tk",
+        });
+
+      // unsigned ints
+      case "list<u8>":
+      case "list<u16>":
+      case "list<u32>":
+      case "list<u64>":
+        // TODO: wire up once you have an unsigned-int codec
+        throw new InvalidWitEncodingTypeError(param.type, {
+          docsPath: "tk",
+        });
+
+      // tuples
+      case "list<tuple>":
+        // TODO: ListCodecFactory.create(TupleCodec) once it exists
+        throw new InvalidWitEncodingTypeError(param.type, {
+          docsPath: "tk",
+        });
+
+      default: {
+        // exhaustiveness guard – if WitList ever gains a new member,
+        // this will start failing at compile time until you add a case.
+        // @ts-ignore
+        const _exhaustive: never = type;
+        throw new InvalidWitEncodingTypeError(param.type, {
+          docsPath: "tk",
+        });
+      }
+    }
+  }
+
+  // if (arrayComponents) {
+  //   const [length, type] = arrayComponents;
+  //   return encodeArray(value, { length, param: { ...param, type } });
+  // }
+  // if (param.type === "tuple") {
+  //   return encodeTuple(value as unknown as Tuple, {
+  //     param: param as TupleAbiParameter,
+  //   });
+  // }
+  // if (param.type === "address") {
+  //   return encodeAddress(value as unknown as Hex);
+  // }
+  // if (param.type === "bool") {
+  //   return encodeBool(value as unknown as boolean);
+  // }
+  // if (param.type.startsWith("uint") || param.type.startsWith("int")) {
+  //   const signed = param.type.startsWith("int");
+  //   const [, , size = "256"] = integerRegex.exec(param.type) ?? [];
+  //   return encodeNumber(value as unknown as number, {
+  //     signed,
+  //     size: Number(size),
+  //   });
+  // }
+  // if (param.type.startsWith("bytes")) {
+  //   return encodeBytes(value as unknown as Hex, { param });
+  // }
+  if (param.type === "integer") {
+    return encodeInteger(value as unknown as bigint);
+  }
+
+  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",
+  });
+}
+
+export function getListComponents(type: string): string | undefined {
+  // TODO: add error when nothing inside
+
+  // Matches things like:
+  // - "list<integer>"
+  // - "list<result<string, integer>>"
+  // - "list< list<decimal> >"
+  const matches = type.match(/^list<(.*)>$/);
+
+  return matches ? matches[1]?.trim() : undefined;
+}
+
+export function getOptionComponent(type: string): string | undefined {
+  // Matches:
+  // - "option<integer>"
+  // - "option<list<decimal>>"
+  // - "option< result<string, error> >"
+  const matches = type.match(/^option<(.*)>$/);
+
+  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;
+
+  const okType = matches[1]!.trim();
+  const errType = matches[2]!.trim();
+
+  if (errType !== "error") throw new InvalidResultTypeError(errType);
+
+  return [okType, "error"];
+}
+
+function encodeInteger(value: bigint): PreparedParam {
+  return {
+    encoded: IntegerCodec.fromJs(value).toWave(),
+  };
+}
+
+function encodeDecimal(value: [bigint, number]): PreparedParam {
+  return {
+    encoded: DecimalCodec.fromJs(value).toWave(),
+  };
+}
+
+function encodeString(value: string): PreparedParam {
+  return {
+    encoded: StringCodec.fromJs(value).toWave(),
+  };
+}
+
+function encodeParams(preparedParams: PreparedParam[]): string {
+  return preparedParams.map((p) => p.encoded).join(", ");
+}

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

@@ -0,0 +1,131 @@
+import { describe, expect, test } from "vitest";
+import { getWitItem } from "./get-wit-item.js";
+import { parseWit } from "../../../wit/wit-parser/parse-wit.js";
+export const nativeToken = parseWit([
+  "record balance { key: string, value: decimal }",
+  "export mint: func(ctx: borrow<proc-context>, n: decimal) -> result<_, error>;",
+  "export burn: func(ctx: borrow<proc-context>, n: decimal) -> result<_, error>;",
+  "export transfer: func(ctx: borrow<proc-context>, to: string, n: decimal) -> result<_, error>;",
+  "export balance: func(ctx: borrow<view-context>, acc: string) -> option<decimal>;",
+  "export balances: func(ctx: borrow<view-context>) -> list<balance>;",
+  "export total-supply: func(ctx: borrow<view-context>) -> decimal;",
+]);
+
+describe("getWitItem", () => {
+  test("returns undefined for missing item", () => {
+    const item = getWitItem({
+      wit: nativeToken,
+      // @ts-expect-error - "does-not-exist" is not a valid WitItemName
+      name: "does-not-exist",
+    });
+
+    expect(item).toBeUndefined();
+  });
+
+  test("selects mint function by name", () => {
+    const item = getWitItem({
+      wit: nativeToken,
+      name: "mint",
+    });
+
+    expect(item).toStrictEqual({
+      name: "mint",
+      type: "function",
+      context: "proc",
+      inputs: [{ type: "decimal", name: "n" }],
+      outputs: [{ type: "result<_, error>" }],
+    });
+  });
+  test("selects burn function by name", () => {
+    const item = getWitItem({
+      wit: nativeToken,
+      name: "burn",
+    });
+
+    expect(item).toStrictEqual({
+      name: "burn",
+      type: "function",
+      context: "proc",
+      inputs: [{ type: "decimal", name: "n" }],
+      outputs: [{ type: "result<_, error>" }],
+    });
+  });
+  test("selects transfer function by name", () => {
+    const item = getWitItem({
+      wit: nativeToken,
+      name: "transfer",
+    });
+
+    expect(item).toStrictEqual({
+      name: "transfer",
+      type: "function",
+      context: "proc",
+      inputs: [
+        { type: "string", name: "to" },
+        { type: "decimal", name: "n" },
+      ],
+      outputs: [{ type: "result<_, error>" }],
+    });
+  });
+
+  test("selects balance function by name", () => {
+    const item = getWitItem({
+      wit: nativeToken,
+      name: "balance",
+    });
+
+    expect(item).toStrictEqual({
+      name: "balance",
+      type: "function",
+      context: "view",
+      inputs: [{ type: "string", name: "acc" }],
+      outputs: [{ type: "option<decimal>" }],
+    });
+  });
+
+  test("selects balances function by name", () => {
+    const item = getWitItem({
+      wit: nativeToken,
+      name: "balances",
+    });
+
+    expect(item).toStrictEqual({
+      name: "balances",
+      type: "function",
+      context: "view",
+      inputs: [],
+      outputs: [
+        {
+          type: "list<tuple>",
+          components: [
+            {
+              name: "key",
+              type: "string",
+            },
+            {
+              name: "value",
+              type: "decimal",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("selects total-supply function by name (kebab case)", () => {
+    const item = getWitItem({
+      wit: nativeToken,
+      name: "total-supply",
+    });
+
+    expect(item).toBeDefined();
+    expect(item!.name).toBe("total-supply");
+
+    const inputs = (item as any).inputs ?? [];
+    expect(inputs.map((p: any) => p.name)).toEqual([]);
+    expect(inputs.map((p: any) => p.type)).toEqual([]);
+
+    // Optional: assert output type
+    // expect((item as any).outputs?.[0]?.type).toBe("decimal");
+  });
+});