@kontor/kontor-sdk 1.0.0-alpha.0

package/src/sdk/utils/wit/decode-function-result.ts

@@ -0,0 +1,104 @@
+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 { ErrorType } from "../../errors/utils.js";
+import type {
+  // ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionReturnType,
+  // Widen,
+} from "../../types/contract.js";
+import { decodeWitParameter } from "./decode-wit-parameter.js";
+import { getWitItem, type GetWitItemErrorType } from "./get-wit-item.js";
+
+export type DecodeFunctionResultParameters<
+  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,
+  allFunctionNames = ContractFunctionName<wit>,
+> = {
+  wit: wit;
+  data: string; // TODO: make wave exprssion explicitly
+} & UnionEvaluate<
+  IsNarrowable<wit, Wit> extends true
+    ? wit["length"] extends 1
+      ? { functionName?: functionName | allFunctionNames | undefined }
+      : { functionName: functionName | allFunctionNames }
+    : { functionName?: functionName | allFunctionNames | undefined }
+> &
+  (hasFunctions extends true ? unknown : never);
+
+export type DecodeFunctionResultReturnType<
+  wit extends Wit | readonly unknown[] = Wit,
+  functionName extends
+    | ContractFunctionName<wit>
+    | undefined = ContractFunctionName<wit>,
+> = ContractFunctionReturnType<
+  wit,
+  WitStateMutability,
+  functionName extends ContractFunctionName<wit>
+    ? functionName
+    : ContractFunctionName<wit>
+>;
+
+// TODO: add errors
+export type DecodeFunctionResultErrorType =
+  // | WitFunctionNotFoundErrorType
+  // | WitFunctionOutputsNotFoundErrorType
+  // | DecodeWitParametersErrorType
+  GetWitItemErrorType | ErrorType;
+
+export function decodeFunctionResult<
+  const wit extends Wit | readonly unknown[],
+  functionName extends ContractFunctionName<wit> | undefined = undefined,
+>(
+  parameters: DecodeFunctionResultParameters<wit, functionName>,
+): DecodeFunctionResultReturnType<wit, functionName> {
+  const {
+    wit: wit,
+    functionName,
+    data,
+  } = parameters as DecodeFunctionResultParameters;
+
+  let witItem = wit[0];
+  if (functionName) {
+    const item = getWitItem({ wit: wit, name: functionName });
+    // todo: refine error
+    // if (!item) throw new WitFunctionNotFoundError(functionName, { docsPath })
+    if (!item) throw new Error("WitFunctionNotFoundError");
+    witItem = item;
+  }
+
+  if (witItem!.type !== "function")
+    // todo: refine error
+    // throw new WitFunctionNotFoundError(undefined, { docsPath })
+    throw new Error("WitFunctionNotFoundError");
+  if (!witItem!.outputs)
+    // todo: refine error
+    // throw new WitFunctionOutputsNotFoundError(witItem.name, { docsPath })
+    throw new Error("WitFunctionNotFoundError");
+
+  const value = decodeWitParameter(data, witItem!.outputs[0]!);
+  // TODO: sholdn't have to index on `decoded` here
+  return value.decoded as DecodeFunctionResultReturnType<wit, functionName>;
+
+  //
+  // if (values && values.length > 1)
+  //   return values as DecodeFunctionResultReturnType<wit, functionName, args>;
+  // if (values && values.length === 1)
+  //   return values[0] as DecodeFunctionResultReturnType<
+  //     wit,
+  //     functionName,
+  //     args
+  //   >;
+  // return undefined as DecodeFunctionResultReturnType<wit, functionName, args>;
+}

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

@@ -0,0 +1,98 @@
+import { expect, test, describe } from "vitest";
+
+import { decodeWitParameter, parseWitRecord } from "./decode-wit-parameter.js";
+
+describe("parseWitRecord", () => {
+  test("balance", () => {
+    const raw = `{key: "1b39e35044922c2cb2108b9a2a0ff13223471b17ca55e87e307270308dc77ac0", value: {r0: 10000000000000000000, r1: 0, r2: 0, r3: 0, sign: plus}}`;
+    expect(parseWitRecord(raw)).toEqual({
+      key: '"1b39e35044922c2cb2108b9a2a0ff13223471b17ca55e87e307270308dc77ac0"',
+      value: "{r0: 10000000000000000000, r1: 0, r2: 0, r3: 0, sign: plus}",
+    });
+  });
+});
+
+describe("decodeParameter", () => {
+  test("string", () => {
+    const decoded = decodeWitParameter('"0xdeadbeef"', {
+      type: "string",
+    });
+
+    expect(decoded).toEqual({ decoded: "0xdeadbeef" });
+  });
+  test("decimal", () => {
+    const decoded = decodeWitParameter(
+      "{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}",
+      {
+        type: "decimal",
+      },
+    );
+
+    expect(decoded).toEqual({ decoded: [7n, 18] });
+  });
+
+  test("tuple", () => {
+    const raw = `{key: "1b39e35044922c2cb2108b9a2a0ff13223471b17ca55e87e307270308dc77ac0", value: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}}`;
+    expect(
+      decodeWitParameter(raw, {
+        type: "tuple",
+        components: [
+          { name: "key", type: "string" },
+          { name: "value", type: "decimal" },
+        ],
+      }),
+    ).toEqual({
+      decoded: {
+        key: "1b39e35044922c2cb2108b9a2a0ff13223471b17ca55e87e307270308dc77ac0",
+        value: [7n, 18],
+      },
+    });
+  });
+
+  test("list<tuple>", () => {
+    const raw = `[{key: "1b39e35044922c2cb2108b9a2a0ff13223471b17ca55e87e307270308dc77ac0", value: {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}}]`;
+    expect(
+      decodeWitParameter(raw, {
+        type: "list<tuple>",
+        components: [
+          { name: "key", type: "string" },
+          { name: "value", type: "decimal" },
+        ],
+      }),
+    ).toEqual({
+      decoded: [
+        {
+          key: "1b39e35044922c2cb2108b9a2a0ff13223471b17ca55e87e307270308dc77ac0",
+          value: [7n, 18],
+        },
+      ],
+    });
+  });
+
+  test("list<decimal>", () => {
+    const decoded = decodeWitParameter(
+      "[{r0: 7, r1: 0, r2: 0, r3: 0, sign: plus}, {r0: 8, r1: 0, r2: 0, r3: 0, sign: plus}]",
+      {
+        type: "list<decimal>",
+      },
+    );
+
+    expect(decoded).toEqual({
+      decoded: [
+        [7n, 18],
+        [8n, 18],
+      ],
+    });
+  });
+
+  test("option<decimal>", () => {
+    const decoded = decodeWitParameter(
+      "some({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})",
+      {
+        type: "option<decimal>",
+      },
+    );
+
+    expect(decoded).toEqual({ decoded: { kind: "some", value: [7n, 18] } });
+  });
+});

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

@@ -0,0 +1,331 @@
+import type { WitParameter, WitType } from "../../../wit/wit.js";
+import { InvalidWitEncodingTypeError } from "../../errors/wit.js";
+import { DecimalCodec } from "./codecs/decimal.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";
+
+const stringDecoder = makeDecoder(StringCodec);
+const decimalDecoder = makeDecoder(DecimalCodec);
+const optionOfDecimalDecoder = makeDecoder(
+  OptionCodecFactory.create(DecimalCodec),
+);
+const optionOfTupleDecoder = (param: WitParameter) =>
+  makeDecoder(OptionCodecFactory.create(makeTupleCodecConstructor(param)));
+
+const listOfDecimalDecoder = makeDecoder(ListCodecFactory.create(DecimalCodec));
+
+const listOfTupleDecoder = (param: WitParameter) =>
+  makeDecoder(ListCodecFactory.create(makeTupleCodecConstructor(param)));
+
+const tupleDecoder = (param: WitParameter) =>
+  makeDecoder(makeTupleCodecConstructor(param));
+
+//
+
+export function decodeWitParameter(value: string, param: WitParameter) {
+  // TODO: type cast
+  const decoder = decoderForParam(param);
+
+  return {
+    decoded: decoder.decode(value),
+  };
+}
+
+export function decodeTuple(
+  record: Record<string, string>,
+  param: WitParameter,
+): Record<string, string> {
+  if (!param.components) {
+    throw new Error("Tuple parameter missing components");
+  }
+  console.log("value");
+
+  return param.components.reduce<Record<string, string>>(
+    (acc, component: WitParameter) => {
+      if (!component.name) {
+        throw new Error("Tuple component missing name");
+      }
+
+      const fieldValue = record[component.name];
+      const decoder = decoderForParam(component);
+      // @ts-ignore
+      acc[component.name] = decoder.decode(fieldValue!);
+
+      return acc;
+    },
+    {},
+  );
+}
+
+function decoderForParam(p: WitParameter) {
+  const t = p.type as WitType;
+  console.log({ t });
+
+  switch (t) {
+    case "tuple":
+      return tupleDecoder(p);
+    case "string":
+      return stringDecoder;
+    case "decimal":
+      return decimalDecoder;
+    case "option<decimal>":
+      return optionOfDecimalDecoder;
+    case "option<tuple>":
+      return optionOfTupleDecoder(p);
+    case "list<decimal>":
+      return listOfDecimalDecoder;
+    case "list<tuple>":
+      return listOfTupleDecoder(p);
+
+    case "error":
+    case "contract-address":
+    case "bool":
+    case "s8":
+    case "s16":
+    case "s32":
+    case "s64":
+    case "u8":
+    case "u16":
+    case "u32":
+    case "u64":
+    case "integer":
+    case "option<string>":
+    case "option<bool>":
+    case "option<s8>":
+    case "option<s16>":
+    case "option<s32>":
+    case "option<s64>":
+    case "option<u8>":
+    case "option<u16>":
+    case "option<u32>":
+    case "option<u64>":
+    case "option<integer>":
+    case "option<_>":
+
+    case "list<string>":
+    case "list<bool>":
+    case "list<s8>":
+    case "list<s16>":
+    case "list<s32>":
+    case "list<s64>":
+    case "list<u8>":
+    case "list<u16>":
+    case "list<u32>":
+    case "list<u64>":
+    case "list<integer>":
+    case "list<_>":
+    case "result<_, error>":
+    case "result<string, error>":
+    case "result<bool, error>":
+    case "result<s8, error>":
+    case "result<s16, error>":
+    case "result<s32, error>":
+    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>":
+    case "result<option<_>, error>":
+    case "result<option<tuple>, error>":
+    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<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>":
+    case "result<list<string>, error>":
+    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>":
+    case "result<list<u8>, error>":
+    case "result<list<u16>, error>":
+    case "result<list<u32>, error>":
+    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 Error("not implemented");
+
+    default:
+      const exhaustive: never = t;
+      void exhaustive;
+      throw new InvalidWitEncodingTypeError(t, {
+        docsPath: "tk",
+      });
+    //
+  }
+}
+
+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");
+  }
+
+  toJs(): Record<string, string> {
+    // The core decoding step: recursively call decodeTuple
+    return decodeTuple(this.data, this.param);
+  }
+}
+
+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");
+  }
+
+  // 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 ---
+
+    // 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");
+    }
+
+    // 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.
+      console.log("parsing tuple wave expr:", expr);
+
+      return parseWitRecord(expr) as Record<string, string>;
+    }
+
+    // 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);
+    }
+
+    // --- 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;
+    }
+  }
+
+  // 3. Cast the class to the correct CodecConstructor type
+  return TupleCodec as unknown as CodecConstructor<
+    Record<string, string>,
+    TupleCodecInstance,
+    Record<string, string>
+  >;
+}
+
+export function parseWitRecord(raw: string) {
+  // Remove leading/trailing whitespace and outer braces
+  const trimmed = raw.trim().replace(/^\{|\}$/g, "");
+
+  const result = {};
+  let depth = 0;
+  let currentKey = "";
+  let currentValue = "";
+  let inKey = true;
+  let i = 0;
+
+  while (i < trimmed.length) {
+    const char = trimmed[i];
+
+    if (char === "{" || char === "[") {
+      depth++;
+      if (!inKey) currentValue += char;
+    } else if (char === "}" || char === "]") {
+      depth--;
+      if (!inKey) currentValue += char;
+    } else if (char === ":" && depth === 0 && inKey) {
+      // Found the separator between key and value
+      inKey = false;
+      i++;
+      continue;
+    } else if (char === "," && depth === 0) {
+      // Found separator between key-value pairs
+      // @ts-ignore
+      result[currentKey.trim()] = currentValue.trim();
+      currentKey = "";
+      currentValue = "";
+      inKey = true;
+      i++;
+      continue;
+    } else {
+      if (inKey) {
+        currentKey += char;
+      } else {
+        currentValue += char;
+      }
+    }
+
+    i++;
+  }
+
+  // Add the last key-value pair
+  if (currentKey.trim()) {
+    // @ts-ignore
+    result[currentKey.trim()] = currentValue.trim();
+  }
+
+  return result;
+}

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

@@ -0,0 +1,47 @@
+import { expectTypeOf, test } from "vitest";
+import {
+  type EncodeFunctionDataParameters,
+  encodeFunctionData,
+} from "./encode-function-data.js";
+
+import { nativeToken } from "~test/src/wits.js";
+import { parseWit } from "src/wit/wit-parser/parse-wit.js";
+
+test("single, function name not required", () => {
+  const singleRaw = [
+    "record mint { dst: string, amt: decimal }",
+
+    "export issuance: func(ctx: borrow<core-context>, amt: decimal) -> result<mint, error>;",
+  ] as const;
+
+  const single = parseWit(singleRaw);
+
+  // single entry does not require functionName
+  encodeFunctionData({ wit: single, args: [[7n, 18]] });
+
+  type P = EncodeFunctionDataParameters<typeof single>;
+
+  expectTypeOf<P["functionName"]>().toEqualTypeOf<"issuance" | undefined>();
+});
+
+test("native token", () => {
+  // @ts-expect-error functionName required
+  encodeFunctionData({ wit: nativeToken });
+
+  type P = EncodeFunctionDataParameters<typeof nativeToken>;
+  expectTypeOf<P["functionName"]>().not.toEqualTypeOf<undefined>();
+  expectTypeOf<P["functionName"]>().toEqualTypeOf<
+    | "issuance"
+    | "hold"
+    | "release"
+    // | "init" // init is not valid
+    | "mint"
+    | "burn"
+    | "transfer"
+    | "balance"
+    | "balances"
+    | "total-supply"
+    | "attach"
+    | "detach"
+  >();
+});

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

@@ -0,0 +1,123 @@
+import { expect, test } from "vitest";
+import { encodeFunctionData } from "./encode-function-data.js";
+import { parseWit } from "../../../wit/wit-parser/parse-wit.js";
+
+export const nativeToken = parseWit([
+  "record balance { acc: string, amt: decimal }",
+  "record transfer { src: string, dst: string, amt: decimal }",
+  "record burn { src: string, amt: decimal }",
+  "record mint { dst: string, amt: decimal }",
+  "export issuance: func(ctx: borrow<core-context>, amt: decimal) -> result<mint, error>;",
+  "export hold: func(ctx: borrow<core-context>, amt: decimal) -> result<transfer, error>;",
+  "export release: func(ctx: borrow<core-context>, burn-amt: decimal) -> result<burn, error>;",
+  "export init: func(ctx: borrow<proc-context>);",
+  "export mint: func(ctx: borrow<proc-context>, amt: decimal) -> result<mint, error>;",
+  "export burn: func(ctx: borrow<proc-context>, amt: decimal) -> result<burn, error>;",
+  "export transfer: func(ctx: borrow<proc-context>, dst: string, amt: decimal) -> result<transfer, 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;",
+  "export attach: func(ctx: borrow<proc-context>, vout: u64, amt: decimal) -> result<transfer, error>;",
+  "export detach: func(ctx: borrow<proc-context>) -> result<transfer, error>;",
+]);
+
+//TODO: change functionName to func
+test("issuance", () => {
+  expect(
+    encodeFunctionData({
+      wit: nativeToken,
+      functionName: "issuance",
+      args: [[7n, 18]],
+    }),
+  ).toEqual("issuance({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})");
+});
+
+test("hold", () => {
+  expect(
+    encodeFunctionData({
+      wit: nativeToken,
+      functionName: "hold",
+      args: [[7n, 18]],
+    }),
+  ).toEqual("hold({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})");
+});
+
+test("release", () => {
+  expect(
+    encodeFunctionData({
+      wit: nativeToken,
+      functionName: "release",
+      args: [[7n, 18]],
+    }),
+  ).toEqual("release({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})");
+});
+
+test("mint", () => {
+  expect(
+    encodeFunctionData({
+      wit: nativeToken,
+      functionName: "mint",
+      args: [[7n, 18]],
+    }),
+  ).toEqual("mint({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})");
+});
+
+test("burn", () => {
+  expect(
+    encodeFunctionData({
+      wit: nativeToken,
+      functionName: "burn",
+      args: [[7n, 18]],
+    }),
+  ).toEqual("burn({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})");
+});
+
+test("transfer", () => {
+  expect(
+    encodeFunctionData({
+      wit: nativeToken,
+      functionName: "transfer",
+      args: ["bc1deadbeef", [7n, 18]],
+    }),
+  ).toEqual(
+    `transfer("bc1deadbeef", {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})`,
+  );
+});
+
+test("balance", () => {
+  expect(
+    encodeFunctionData({
+      wit: nativeToken,
+      functionName: "balance",
+      args: ["bc1deadbeef"],
+    }),
+  ).toEqual(`balance("bc1deadbeef")`);
+});
+
+test("balances", () => {
+  expect(
+    encodeFunctionData({
+      wit: nativeToken,
+      functionName: "balances",
+    }),
+  ).toEqual(`balances()`);
+});
+
+test("totalSupply", () => {
+  expect(
+    encodeFunctionData({
+      wit: nativeToken,
+      functionName: "total-supply",
+    }),
+  ).toEqual(`total-supply()`);
+});
+
+test("attach", () => {
+  expect(
+    encodeFunctionData({
+      wit: nativeToken,
+      functionName: "attach",
+      args: [7n, [7n, 18]],
+    }),
+  ).toEqual(`attach()`);
+});