@kontor/kontor-sdk 1.0.0-alpha.19 → 1.0.0-alpha.21

package/src/sdk/utils/wit/codecs/u64.ts

@@ -0,0 +1,73 @@
+// u64.ts
+import * as z from "zod";
+import type { WaveExpr, CodecInstance, CodecConstructor } from "./types.js";
+
+// You already have this in integer.ts; you can import it from there instead
+const U64_MAX = (1n << 64n) - 1n;
+export const U64 = z
+  .bigint()
+  .min(0n, { message: "must be ≥ 0" })
+  .max(U64_MAX, { message: "must be ≤ 2^64-1" });
+
+/**
+ * Parse a Wave expression for a u64.
+ *
+ * - Accepts optional underscores for readability: 1_000_000
+ * - Must be a non-negative integer
+ * - Enforces the u64 range via zod
+ */
+export function parseU64WaveExpr(expr: string): bigint {
+  const trimmed = expr.trim();
+  if (!trimmed) throw new Error("empty u64 expression");
+
+  // Allow underscores like "1_000_000"
+  const normalized = trimmed.replace(/_/g, "");
+
+  if (!/^[0-9]+$/.test(normalized)) {
+    throw new Error(`invalid u64 literal: "${expr}"`);
+  }
+
+  const value = BigInt(normalized);
+  return U64.parse(value); // range-check via zod
+}
+
+// --- U64Codec ---------------------------------------------------
+
+class _U64Codec implements CodecInstance<bigint> {
+  public readonly value: bigint;
+
+  constructor(value: bigint) {
+    this.value = U64.parse(value);
+  }
+
+  static fromJs(value: bigint | number | string): _U64Codec {
+    let v: bigint;
+    if (typeof value === "bigint") v = value;
+    else if (typeof value === "number") v = BigInt(value);
+    else v = BigInt(value); // e.g. JSON string "12345"
+
+    return new _U64Codec(v);
+  }
+
+  static fromKontor(data: string | bigint | number): _U64Codec {
+    return _U64Codec.fromJs(data);
+  }
+
+  static parseWave(expr: string): bigint {
+    return parseU64WaveExpr(expr);
+  }
+
+  toWave(): WaveExpr {
+    return `${this.value}` as WaveExpr;
+  }
+
+  toJs(): bigint {
+    return this.value;
+  }
+}
+
+export const U64Codec = _U64Codec as unknown as CodecConstructor<
+  bigint,
+  _U64Codec,
+  bigint
+>;

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

@@ -1,6 +1,7 @@
 import type { WitParameter, WitType } from "../../../wit/wit.js";
 import { InvalidWitEncodingTypeError } from "../../errors/wit.js";
 import { DecimalCodec } from "./codecs/decimal.js";
+import { U64Codec } from "./codecs/u64.js";
 import { StringCodec } from "./codecs/string.js";
 import { OptionCodecFactory } from "./codecs/option.js";
 import { ListCodecFactory } from "./codecs/list.js";
@@ -11,11 +12,14 @@ import {
   type WaveExpr,
 } from "./codecs/types.js";
 
+const u64Decoder = makeDecoder(U64Codec);
+
 const stringDecoder = makeDecoder(StringCodec);
 const decimalDecoder = makeDecoder(DecimalCodec);
 const optionOfDecimalDecoder = makeDecoder(
   OptionCodecFactory.create(DecimalCodec),
 );
+
 const optionOfTupleDecoder = (param: WitParameter) =>
   makeDecoder(OptionCodecFactory.create(makeTupleCodecConstructor(param)));
 
@@ -95,6 +99,7 @@ function decoderForParam(p: WitParameter) {
     case "u16":
     case "u32":
     case "u64":
+      return u64Decoder;
     case "integer":
     case "option<string>":
     case "option<bool>":

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

@@ -4,8 +4,9 @@ import {
   encodeFunctionData,
 } from "./encode-function-data.js";
 
-import { nativeToken } from "~test/src/wits.js";
-import { parseWit } from "src/wit/wit-parser/parse-wit.js";
+import { nativeToken } from "../../contracts/wits.js";
+
+import { parseWit } from "../../../wit/wit-parser/parse-wit.js";
 
 test("single, function name not required", () => {
   const singleRaw = [
@@ -25,23 +26,26 @@ test("single, function name not required", () => {
 });
 
 test("native token", () => {
-  // @ts-expect-error functionName required
-  encodeFunctionData({ wit: nativeToken });
+  try {
+    // @ts-expect-error functionName required
+    encodeFunctionData({ wit: nativeToken });
+  } catch (e) {}
+
+  type P = EncodeFunctionDataParameters<typeof nativeToken.wit>;
 
-  type P = EncodeFunctionDataParameters<typeof nativeToken>;
   expectTypeOf<P["functionName"]>().not.toEqualTypeOf<undefined>();
+
   expectTypeOf<P["functionName"]>().toEqualTypeOf<
+    | "mint"
     | "issuance"
+    | "balance"
+    | "transfer"
+    | "burn"
     | "hold"
     | "release"
-    // | "init" // init is not valid
-    | "mint"
-    | "burn"
-    | "transfer"
-    | "balance"
     | "balances"
     | "total-supply"
-    | "attach"
     | "detach"
+    // | "attach" // TODO: need to handle attach parsing
   >();
 });

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

@@ -119,5 +119,5 @@ test("attach", () => {
       functionName: "attach",
       args: [7n, [7n, 18]],
     }),
-  ).toEqual(`attach()`);
+  ).toEqual("attach(7, {r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})");
 });

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

@@ -8,6 +8,8 @@ import {
   InvalidWitEncodingTypeError,
   WitEncodingLengthMismatchError,
 } from "../../errors/wit.js";
+
+import { U64Codec } from "./codecs/u64.js";
 import { DecimalCodec } from "./codecs/decimal.js";
 import { IntegerCodec } from "./codecs/integer.js";
 import { ListCodecFactory } from "./codecs/list.js";
@@ -35,7 +37,6 @@ export function encodeWitParameters<
     params: params as readonly WitParameter[],
     values: values as any,
   });
-
   const encoded = encodeParams(preparedParams);
 
   return encoded;
@@ -242,6 +243,14 @@ function prepareParam<const param extends WitParameter>({
   // if (param.type.startsWith("bytes")) {
   //   return encodeBytes(value as unknown as Hex, { param });
   // }
+  //
+
+  console.log(param);
+
+  if (param.type === "u64") {
+    return encodeU64(value as unknown as bigint);
+  }
+
   if (param.type === "integer") {
     return encodeInteger(value as unknown as bigint);
   }
@@ -298,6 +307,12 @@ export function getResultComponentsStrict(
   return [okType, "error"];
 }
 
+function encodeU64(value: bigint): PreparedParam {
+  return {
+    encoded: U64Codec.fromJs(value).toWave(),
+  };
+}
+
 function encodeInteger(value: bigint): PreparedParam {
   return {
     encoded: IntegerCodec.fromJs(value).toWave(),

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

@@ -32,8 +32,19 @@ describe("getWitItem", () => {
       name: "mint",
       type: "function",
       context: "proc",
-      inputs: [{ type: "decimal", name: "n" }],
-      outputs: [{ type: "result<_, error>" }],
+      inputs: [
+        {
+          internalType: "decimal",
+          type: "decimal",
+          name: "n",
+        },
+      ],
+      outputs: [
+        {
+          internalType: "result<_, error>",
+          type: "result<_, error>",
+        },
+      ],
     });
   });
   test("selects burn function by name", () => {
@@ -46,8 +57,19 @@ describe("getWitItem", () => {
       name: "burn",
       type: "function",
       context: "proc",
-      inputs: [{ type: "decimal", name: "n" }],
-      outputs: [{ type: "result<_, error>" }],
+      inputs: [
+        {
+          internalType: "decimal",
+          type: "decimal",
+          name: "n",
+        },
+      ],
+      outputs: [
+        {
+          internalType: "result<_, error>",
+          type: "result<_, error>",
+        },
+      ],
     });
   });
   test("selects transfer function by name", () => {
@@ -61,10 +83,23 @@ describe("getWitItem", () => {
       type: "function",
       context: "proc",
       inputs: [
-        { type: "string", name: "to" },
-        { type: "decimal", name: "n" },
+        {
+          internalType: "string",
+          type: "string",
+          name: "to",
+        },
+        {
+          internalType: "decimal",
+          type: "decimal",
+          name: "n",
+        },
+      ],
+      outputs: [
+        {
+          internalType: "result<_, error>",
+          type: "result<_, error>",
+        },
       ],
-      outputs: [{ type: "result<_, error>" }],
     });
   });
 
@@ -78,8 +113,19 @@ describe("getWitItem", () => {
       name: "balance",
       type: "function",
       context: "view",
-      inputs: [{ type: "string", name: "acc" }],
-      outputs: [{ type: "option<decimal>" }],
+      inputs: [
+        {
+          internalType: "string",
+          type: "string",
+          name: "acc",
+        },
+      ],
+      outputs: [
+        {
+          internalType: "option<decimal>",
+          type: "option<decimal>",
+        },
+      ],
     });
   });
 
@@ -97,12 +143,15 @@ describe("getWitItem", () => {
       outputs: [
         {
           type: "list<tuple>",
+          internalType: "list<balance>",
           components: [
             {
+              internalType: "string",
               name: "key",
               type: "string",
             },
             {
+              internalType: "decimal",
               name: "value",
               type: "decimal",
             },

package/src/wit/wit-parser/core/records.test.ts

@@ -9,27 +9,29 @@ test("parse records", () => {
     ]),
   ).toEqual({
     "contract-address": [
-      { name: "name", type: "string" },
-      { name: "height", type: "s64" },
-      { name: "tx-index", type: "s64" },
+      { name: "name", type: "string", internalType: "string" },
+      { name: "height", type: "s64", internalType: "s64" },
+      { name: "tx-index", type: "s64", internalType: "s64" },
     ],
     "token-pair": [
       {
         type: "tuple",
         name: "a",
+        internalType: "contract-address",
         components: [
-          { name: "name", type: "string" },
-          { name: "height", type: "s64" },
-          { name: "tx-index", type: "s64" },
+          { name: "name", type: "string", internalType: "string" },
+          { name: "height", type: "s64", internalType: "s64" },
+          { name: "tx-index", type: "s64", internalType: "s64" },
         ],
       },
       {
         type: "tuple",
         name: "b",
+        internalType: "contract-address",
         components: [
-          { name: "name", type: "string" },
-          { name: "height", type: "s64" },
-          { name: "tx-index", type: "s64" },
+          { name: "name", type: "string", internalType: "string" },
+          { name: "height", type: "s64", internalType: "s64" },
+          { name: "tx-index", type: "s64", internalType: "s64" },
         ],
       },
     ],
@@ -38,7 +40,9 @@ test("parse records", () => {
 
 test("generic", () => {
   expect(parseRecords(["record generic {  values: list<string> }"])).toEqual({
-    generic: [{ name: "values", type: "list<string>" }],
+    generic: [
+      { name: "values", type: "list<string>", internalType: "list<string>" },
+    ],
   });
 });
 
@@ -50,10 +54,16 @@ test("generic", () => {
     ]),
   ).toEqual({
     "contract-address": [
-      { type: "string", name: "name" },
-      { type: "s64", name: "height" },
-      { type: "s64", name: "tx-index" },
+      { name: "name", type: "string", internalType: "string" },
+      { name: "height", type: "s64", internalType: "s64" },
+      { name: "tx-index", type: "s64", internalType: "s64" },
+    ],
+    generic: [
+      {
+        name: "values",
+        type: "list<contract-address>",
+        internalType: "list<contract-address>",
+      },
     ],
-    generic: [{ name: "values", type: "list<contract-address>" }],
   });
 });

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

@@ -1,5 +1,6 @@
 import { expectTypeOf, test } from "vitest";
 
+// TODO: audit discrepancies in this whole file
 import type {
   ParseRecords,
   ParseRecord,
@@ -25,28 +26,65 @@ test("ParseRecords", () => {
     >
   >().toEqualTypeOf<{
     "contract-address": readonly [
-      { readonly name: "name"; readonly type: "string" },
-      { readonly name: "height"; readonly type: "s64" },
-      { readonly name: "tx-index"; readonly type: "s64" },
+      {
+        readonly name: "name";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "height";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
+      {
+        readonly name: "tx-index";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
     ];
 
     "token-pair": readonly [
       {
         readonly type: "tuple";
         readonly name: "a";
+        // TODO: should include internalType
         readonly components: readonly [
-          { readonly name: "name"; readonly type: "string" },
-          { readonly name: "height"; readonly type: "s64" },
-          { readonly name: "tx-index"; readonly type: "s64" },
+          {
+            readonly name: "name";
+            readonly type: "string";
+            readonly internalType: "string";
+          },
+          {
+            readonly name: "height";
+            readonly type: "s64";
+            readonly internalType: "s64";
+          },
+          {
+            readonly name: "tx-index";
+            readonly type: "s64";
+            readonly internalType: "s64";
+          },
         ];
       },
       {
         readonly type: "tuple";
         readonly name: "b";
         readonly components: readonly [
-          { readonly name: "name"; readonly type: "string" },
-          { readonly name: "height"; readonly type: "s64" },
-          { readonly name: "tx-index"; readonly type: "s64" },
+          {
+            readonly name: "name";
+            readonly type: "string";
+            readonly internalType: "string";
+          },
+          {
+            readonly name: "height";
+            readonly type: "s64";
+            readonly internalType: "s64";
+          },
+          {
+            readonly name: "tx-index";
+            readonly type: "s64";
+            readonly internalType: "s64";
+          },
         ];
       },
     ];
@@ -60,9 +98,21 @@ test("ParseRecords", () => {
     >
   >().toEqualTypeOf<{
     "contract-address": readonly [
-      { readonly name: "name"; readonly type: "string" },
-      { readonly name: "height"; readonly type: "s64" },
-      { readonly name: "tx-index"; readonly type: "s64" },
+      {
+        readonly name: "name";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "height";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
+      {
+        readonly name: "tx-index";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
     ];
 
     "token-pair": readonly [
@@ -95,9 +145,21 @@ test("ParseRecord", () => {
   >().toEqualTypeOf<{
     readonly name: "contract-address";
     readonly components: [
-      { readonly name: "name"; readonly type: "string" },
-      { readonly name: "height"; readonly type: "s64" },
-      { readonly name: "tx-index"; readonly type: "s64" },
+      {
+        readonly name: "name";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "height";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
+      {
+        readonly name: "tx-index";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
     ];
   }>();
 
@@ -106,8 +168,16 @@ test("ParseRecord", () => {
   >().toEqualTypeOf<{
     readonly name: "token-pair";
     readonly components: [
-      { readonly name: "a"; readonly type: "contract-address" },
-      { readonly name: "b"; readonly type: "contract-address" },
+      {
+        readonly name: "a";
+        readonly type: "contract-address";
+        readonly internalType: "contract-address";
+      },
+      {
+        readonly name: "b";
+        readonly type: "contract-address";
+        readonly internalType: "contract-address";
+      },
     ];
   }>();
 
@@ -122,19 +192,40 @@ test("ParseRecord", () => {
       {
         readonly type: "tuple";
         readonly name: "a";
+        readonly internalType: "contract-address";
         readonly components: readonly [
-          { readonly name: "name"; readonly type: "string" },
-          { readonly name: "height"; readonly type: "s64" },
-          { readonly name: "tx-index"; readonly type: "s64" },
+          {
+            // TODO: why aren't we getting internalType here
+            readonly name: "name";
+            readonly type: "string";
+          },
+          {
+            readonly name: "height";
+            readonly type: "s64";
+          },
+          {
+            readonly name: "tx-index";
+            readonly type: "s64";
+          },
         ];
       },
       {
         readonly type: "tuple";
         readonly name: "b";
+        readonly internalType: "contract-address";
         readonly components: readonly [
-          { readonly name: "name"; readonly type: "string" },
-          { readonly name: "height"; readonly type: "s64" },
-          { readonly name: "tx-index"; readonly type: "s64" },
+          {
+            readonly name: "name";
+            readonly type: "string";
+          },
+          {
+            readonly name: "height";
+            readonly type: "s64";
+          },
+          {
+            readonly name: "tx-index";
+            readonly type: "s64";
+          },
         ];
       },
     ];
@@ -146,9 +237,21 @@ test("ParseRecordProperties", () => {
     ParseRecordProperties<"name: string, height: s64, tx-index: s64">
   >().toEqualTypeOf<
     [
-      { readonly name: "name"; readonly type: "string" },
-      { readonly name: "height"; readonly type: "s64" },
-      { readonly name: "tx-index"; readonly type: "s64" },
+      {
+        readonly name: "name";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "height";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
+      {
+        readonly name: "tx-index";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
     ]
   >();
 
@@ -156,8 +259,16 @@ test("ParseRecordProperties", () => {
     ParseRecordProperties<"a: contract-address, b: contract-address">
   >().toEqualTypeOf<
     [
-      { readonly name: "a"; readonly type: "contract-address" },
-      { readonly name: "b"; readonly type: "contract-address" },
+      {
+        readonly name: "a";
+        readonly type: "contract-address";
+        readonly internalType: "contract-address";
+      },
+      {
+        readonly name: "b";
+        readonly type: "contract-address";
+        readonly internalType: "contract-address";
+      },
     ]
   >();
 
@@ -168,6 +279,7 @@ test("ParseRecordProperties", () => {
       {
         readonly type: "tuple";
         readonly name: "a";
+        readonly internalType: "contract-address";
         readonly components: readonly [
           { readonly name: "name"; readonly type: "string" },
           { readonly name: "height"; readonly type: "s64" },
@@ -177,6 +289,7 @@ test("ParseRecordProperties", () => {
       {
         readonly type: "tuple";
         readonly name: "b";
+        readonly internalType: "contract-address";
         readonly components: readonly [
           { readonly name: "name"; readonly type: "string" },
           { readonly name: "height"; readonly type: "s64" },