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

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

@@ -1,193 +0,0 @@
-// integer.ts
-// TODO: i may want to simplify this later
-//
-import * as z from "zod";
-import type { WaveExpr, CodecInstance, CodecConstructor } from "./types.js";
-
-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" });
-
-export function parseIntegerWaveExpr(expr: string): _Integer.T {
-  const inner = expr
-    .trim()
-    .replace(/^\{\s*/, "")
-    .replace(/\s*\}$/, "");
-  if (!inner) throw new Error("empty integer expression");
-
-  const parts = inner
-    .split(",")
-    .map((p) => p.trim())
-    .filter(Boolean);
-
-  const seen = new Set<string>();
-  // Default middle limbs to 0 for ergonomics; require r0 + sign.
-  let out: Partial<_Integer.T> & {
-    r0?: bigint;
-    r1?: bigint;
-    r2?: bigint;
-    r3?: bigint;
-  } = {
-    r1: 0n,
-    r2: 0n,
-    r3: 0n,
-  };
-
-  for (const part of parts) {
-    const idx = part.indexOf(":");
-    if (idx === -1) {
-      throw new Error(`expected "key: value", got "${part}"`);
-    }
-    const keyRaw = part.slice(0, idx).trim();
-    const valRaw = part.slice(idx + 1).trim();
-
-    if (seen.has(keyRaw)) throw new Error(`duplicate key "${keyRaw}"`);
-    seen.add(keyRaw);
-
-    switch (keyRaw) {
-      case "r0":
-      case "r1":
-      case "r2":
-      case "r3": {
-        const normalized = valRaw.replace(/_/g, "");
-        if (!/^[+-]?\d+$/.test(normalized)) {
-          throw new Error(`invalid integer for ${keyRaw}: "${valRaw}"`);
-        }
-        const limb = BigInt(normalized);
-        if (limb < 0n || limb > U64_MAX) {
-          throw new Error(`value for ${keyRaw} out of u64 range: ${valRaw}`);
-        }
-        (out as any)[keyRaw] = limb;
-        break;
-      }
-      case "sign": {
-        if (valRaw !== "plus" && valRaw !== "minus") {
-          throw new Error(`invalid sign "${valRaw}" (expected plus|minus)`);
-        }
-        (out as any).sign = valRaw;
-        break;
-      }
-      default:
-        throw new Error(`unexpected key "${keyRaw}"`);
-    }
-  }
-
-  if (out.r0 === undefined) throw new Error(`missing required key "r0"`);
-  if (!out.sign) throw new Error(`missing required key "sign"`);
-
-  return _Integer.schema.parse(out);
-}
-
-// function parseIntegerWaveExpr(expr: string): _IntegerRaw.T {
-//   // strip { ... }
-//   const inner = expr.trim().replace(/^\{|\}$/g, "");
-//
-//   // split at commas at top level
-//   // e.g. ["r0: 1337", "r1: 0", "r2: 0", "r3: 0", "sign: Plus"]
-//   const parts = inner.split(",").map((p) => p.trim());
-//
-//   const out: any = {};
-//   for (const part of parts) {
-//     const [keyRaw, valRaw] = part.split(":").map((s) => s.trim());
-//
-//     if (
-//       keyRaw === "r0" ||
-//       keyRaw === "r1" ||
-//       keyRaw === "r2" ||
-//       keyRaw === "r3"
-//     ) {
-//       out[keyRaw] = Number(valRaw);
-//       continue;
-//     }
-//
-//     if (keyRaw === "sign") {
-//       if (valRaw !== "Plus" && valRaw !== "Minus") {
-//         throw new Error(`invalid sign '${valRaw}' in ${expr}`);
-//       }
-//       out.sign = valRaw;
-//       continue;
-//     }
-//
-//     throw new Error(`unexpected key '${keyRaw}' in ${expr}`);
-//   }
-//
-//   // validate with zod, return typed
-//   return _IntegerRaw.schema.parse(out);
-// }
-
-export namespace _Integer {
-  export namespace Sign {
-    export const schema = z.enum(["plus", "minus"]);
-    export type T = z.infer<typeof schema>;
-  }
-
-  export const schema = z.object({
-    r0: U64,
-    r1: U64,
-    r2: U64,
-    r3: U64,
-    sign: Sign.schema,
-  });
-
-  export type T = z.infer<typeof schema>;
-}
-
-// --- IntegerCodec ------------------------------------------------
-
-// Instance class: represents one integer value in limb/sign form,
-// and can render toWave() / toJs().
-class _IntegerCodec implements CodecInstance<bigint> {
-  public readonly data: _Integer.T;
-
-  constructor(data: _Integer.T) {
-    this.data = data;
-  }
-
-  static fromJs(value: bigint | number): _IntegerCodec {
-    let v = BigInt(value);
-
-    const sign: _Integer.Sign.T = v < 0n ? "minus" : "plus";
-    if (v < 0n) v = -v;
-
-    // break absolute value into four 32-bit limbs (little-endian style)
-    const mask32 = (1n << 32n) - 1n;
-    const r0 = v & mask32;
-    const r1 = (v >> 32n) & mask32;
-    const r2 = (v >> 64n) & mask32;
-    const r3 = (v >> 96n) & mask32;
-
-    return new _IntegerCodec({ r0, r1, r2, r3, sign });
-  }
-
-  static fromKontor(data: _Integer.T): _IntegerCodec {
-    return new _IntegerCodec(data);
-  }
-
-  static parseWave(expr: string): _Integer.T {
-    return _Integer.schema.parse(parseIntegerWaveExpr(expr));
-  }
-
-  // instance -> WaveExpr
-  toWave(): WaveExpr {
-    return `{r0: ${this.data.r0}, r1: ${this.data.r1}, r2: ${this.data.r2}, r3: ${this.data.r3}, sign: ${this.data.sign}}` as WaveExpr;
-  }
-
-  // instance -> JS bigint
-  toJs(): bigint {
-    const value =
-      (BigInt(this.data.r3) << 96n) |
-      (BigInt(this.data.r2) << 64n) |
-      (BigInt(this.data.r1) << 32n) |
-      BigInt(this.data.r0);
-
-    return this.data.sign === "minus" ? -value : value;
-  }
-}
-
-export const IntegerCodec = _IntegerCodec as unknown as CodecConstructor<
-  bigint,
-  _IntegerCodec,
-  _Integer.T
->;

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

@@ -1,76 +0,0 @@
-// s64.ts
-import * as z from "zod";
-import type { WaveExpr, CodecInstance, CodecConstructor } from "./types.js";
-
-// Signed 64-bit range
-const S64_MIN = -(1n << 63n);
-const S64_MAX = (1n << 63n) - 1n;
-
-export const S64 = z
-  .bigint()
-  .min(S64_MIN, { message: "must be ≥ -2^63" })
-  .max(S64_MAX, { message: "must be ≤ 2^63-1" });
-
-/**
- * Parse a Wave expression for an s64.
- *
- * - Accepts optional underscores for readability: -1_000_000
- * - Allows optional leading "-"
- * - Enforces the s64 range via zod
- */
-export function parseS64WaveExpr(expr: string): bigint {
-  const trimmed = expr.trim();
-  if (!trimmed) throw new Error("empty s64 expression");
-
-  // Allow underscores like "-1_000_000"
-  const normalized = trimmed.replace(/_/g, "");
-
-  if (!/^-?[0-9]+$/.test(normalized)) {
-    throw new Error(`invalid s64 literal: "${expr}"`);
-  }
-
-  const value = BigInt(normalized);
-  return S64.parse(value); // range-check via zod
-}
-
-// --- S64Codec ---------------------------------------------------
-
-class _S64Codec implements CodecInstance<bigint> {
-  public readonly value: bigint;
-
-  constructor(value: bigint) {
-    this.value = S64.parse(value);
-  }
-
-  static fromJs(value: bigint | number | string): _S64Codec {
-    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 _S64Codec(v);
-  }
-
-  static fromKontor(data: string | bigint | number): _S64Codec {
-    return _S64Codec.fromJs(data);
-  }
-
-  static parseWave(expr: string): bigint {
-    return parseS64WaveExpr(expr);
-  }
-
-  toWave(): WaveExpr {
-    // Wave syntax for s64: plain decimal, optional leading "-"
-    return `${this.value}` as WaveExpr;
-  }
-
-  toJs(): bigint {
-    return this.value;
-  }
-}
-
-export const S64Codec = _S64Codec as unknown as CodecConstructor<
-  bigint,
-  _S64Codec,
-  bigint
->;

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

@@ -1,73 +0,0 @@
-// 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/wit/wit-parser/core/records.test.ts

@@ -1,69 +0,0 @@
-import { expect, test } from "vitest";
-import { parseRecords } from "./records.js";
-
-test("parse records", () => {
-  expect(
-    parseRecords([
-      "record contract-address {  name: string, height: s64, tx-index: s64 }",
-      "record token-pair {  a: contract-address, b: contract-address }",
-    ]),
-  ).toEqual({
-    "contract-address": [
-      { 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", 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", internalType: "string" },
-          { name: "height", type: "s64", internalType: "s64" },
-          { name: "tx-index", type: "s64", internalType: "s64" },
-        ],
-      },
-    ],
-  });
-});
-
-test("generic", () => {
-  expect(parseRecords(["record generic {  values: list<string> }"])).toEqual({
-    generic: [
-      { name: "values", type: "list<string>", internalType: "list<string>" },
-    ],
-  });
-});
-
-test("generic", () => {
-  expect(
-    parseRecords([
-      "record contract-address {  name: string, height: s64, tx-index: s64 }",
-      "record generic {  values: list<contract-address> }",
-    ]),
-  ).toEqual({
-    "contract-address": [
-      { 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>",
-      },
-    ],
-  });
-});

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

@@ -1,101 +0,0 @@
-import type { WitParameter } from "../../wit.js";
-import { execTyped, isGenericRegex } from "../../regex.js";
-import {
-  InvalidRecordSignatureError,
-  InvalidSignatureError,
-} from "./errors/signature.js";
-import { execRecordSignature, isRecordSignature } from "./signatures.js";
-import type { RecordLookup } from "./types/records.js";
-import { parseWitParameter } from "./utils.js";
-
-export function parseRecords(signatures: readonly string[]) {
-  const shallowRecords: RecordLookup = {};
-  const signaturesLength = signatures.length;
-
-  for (let i = 0; i < signaturesLength; i++) {
-    const signature = signatures[i]!;
-    if (!isRecordSignature(signature)) continue;
-
-    const match = execRecordSignature(signature);
-    if (!match) throw new InvalidSignatureError({ signature, type: "record" });
-
-    const properties = match.properties.split(",");
-
-    const components: WitParameter[] = [];
-
-    const propertiesLength = properties.length;
-    for (let k = 0; k < propertiesLength; k++) {
-      const property = properties[k]!;
-      const trimmed = property.trim();
-      if (!trimmed) continue;
-      const witParameter = parseWitParameter(trimmed, {
-        type: "record",
-      });
-      components.push(witParameter);
-    }
-
-    if (!components.length)
-      throw new InvalidRecordSignatureError({ signature });
-    shallowRecords[match.name] = components;
-  }
-
-  const resolvedRecords: RecordLookup = {};
-  const entries = Object.entries(shallowRecords);
-  const entriesLength = entries.length;
-  for (let i = 0; i < entriesLength; i++) {
-    const [name, parameters] = entries[i]!;
-    resolvedRecords[name] = resolveRecords(parameters, shallowRecords);
-  }
-
-  return resolvedRecords;
-}
-
-// TODO: move?
-// e.g. "list<u8>", "option<signer>", "result<integer, error>", "borrow<proc-context>"
-
-export function isGeneric(type: string): boolean {
-  return isGenericRegex.test(type.trim());
-}
-
-// e.g. "string", "list<u8>", "option<signer>", "result<integer, error>", "borrow<proc-context>"
-const witTypeRegex =
-  /^(?:(?<wrapper>borrow|own)\s*<\s*)?(?<base>[a-zA-Z$_][a-zA-Z0-9$_-]*)(?:\s*<(?<inner>[\s\S]+)>)?\s*(?:>)?$/;
-
-function resolveRecords(
-  witParameters: readonly (WitParameter & { indexed?: true })[],
-  records: RecordLookup,
-  ancestors = new Set<string>(),
-) {
-  const components: WitParameter[] = [];
-  for (const witParameter of witParameters) {
-    const m = execTyped<{
-      wrapper?: string;
-      base?: string;
-      inner?: string;
-    }>(witTypeRegex, witParameter.type);
-
-    // TODO: add custom error
-    if (!m?.base) throw new Error(`Invalid WIT type: ${witParameter.type}`);
-
-    const base = m.base;
-    // If it's a named record, expand it into a tuple of its fields.
-    if (base in records) {
-      // TODO: add custom error
-      if (ancestors.has(base)) throw new Error("Circular reference detected.");
-      components.push({
-        ...witParameter,
-        type: "tuple", // normalize records -> tuple
-        components: resolveRecords(
-          records[base] ?? [],
-          records,
-          new Set([...ancestors, base]),
-        ),
-      });
-      continue;
-    }
-
-    // Otherwise, just pass it through (builtins, generics, etc.)
-    components.push(witParameter);
-  }
-  return components;
-}