@kontor/kontor-sdk 1.0.0-alpha.27 → 1.0.0-alpha.29

package/src/sdk/utils/kontor/build-instruction-query.ts

@@ -0,0 +1,75 @@
+import type { Inst, InstructionQuery } from "../../types/kontor.js";
+import type { Address, UtxoId, XOnlyPubKey } from "../../types/misc.js";
+
+export type BuildInstructionQueryReturnType = InstructionQuery;
+
+export type BuildInstructionQueryParameters = {
+  address: Address;
+  xOnlyPubKey: XOnlyPubKey; // TODO: maybe this should be wrapped in a single object
+  utxos: UtxoId[];
+  /**
+   * The concrete instruction to send (Publish | Call | Issuance).
+   * Example:
+   *   { Call: { gas_limit: 100000, contract: "addr", expr: "balance(...)" } }
+   *   { Publish: { gas_limit: 100000, name: "token", bytes: [0,1,2,...] } }
+   *   "Issuance"
+   */
+  instruction: Inst;
+  /**
+   * Optional chained instruction if you want to send two instructions atomically.
+   */
+  chainedInstruction?: Inst | null;
+};
+
+// ------------------ helpers ------------------
+
+function normalizeXOnly(pub: string): string {
+  if (!/^[0-9a-fA-F]{64}$/.test(pub)) {
+    throw new Error(
+      "x_only_public_key must be 32-byte (64 hex chars) x-only pubkey",
+    );
+  }
+  return pub.toLowerCase();
+}
+
+function normalizeUtxoId(u: UtxoId): string {
+  if (typeof u === "string") return u;
+  if (!u?.txid || typeof u.vout !== "number") {
+    throw new Error("funding UTXO must be 'txid:vout' or { txid, vout }");
+  }
+  return `${u.txid}:${u.vout}`;
+}
+
+function normalizeUtxoIds(u: UtxoId | UtxoId[]): string[] {
+  return Array.isArray(u) ? u.map(normalizeUtxoId) : [normalizeUtxoId(u)];
+}
+
+// ------------------ main builder ------------------
+
+export function buildInstructionQuery(
+  params: BuildInstructionQueryParameters,
+): BuildInstructionQueryReturnType {
+  const {
+    utxos,
+    instruction,
+    chainedInstruction = null,
+    address,
+    xOnlyPubKey,
+  } = params;
+
+  if (utxos.length === 0) {
+    // TODO: add custom error
+    throw new Error("at least one funding UTXO is required");
+  }
+
+  const xOnly = normalizeXOnly(xOnlyPubKey);
+  const fundingIds = normalizeUtxoIds(utxos);
+
+  return {
+    address,
+    x_only_public_key: xOnly,
+    funding_utxo_ids: fundingIds.join(","),
+    instruction,
+    chained_instruction: chainedInstruction ?? null,
+  };
+}

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

@@ -0,0 +1,29 @@
+import type { CodecConstructor, CodecInstance, WaveExpr } from "./types.js";
+
+export const BoolCodec = {
+  fromJs(value: boolean) {
+    return {
+      toWave(): WaveExpr {
+        return `${value}` as WaveExpr;
+      },
+      toJs(): boolean {
+        return value;
+      },
+    };
+  },
+
+  fromKontor(data: boolean) {
+    return {
+      toWave(): WaveExpr {
+        return `${data}` as WaveExpr;
+      },
+      toJs(): boolean {
+        return data as boolean;
+      },
+    };
+  },
+
+  parseWave(expr: string): boolean {
+    return JSON.parse(expr);
+  },
+} as unknown as CodecConstructor<boolean, CodecInstance<boolean>, boolean>;

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

@@ -0,0 +1,76 @@
+// 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/decode-wit-parameter.ts

@@ -1,7 +1,10 @@
 import type { WitParameter, WitType } from "../../../wit/wit.js";
 import { InvalidWitEncodingTypeError } from "../../errors/wit.js";
 import { DecimalCodec } from "./codecs/decimal.js";
+import { IntegerCodec } from "./codecs/integer.js";
 import { U64Codec } from "./codecs/u64.js";
+import { S64Codec } from "./codecs/s64.js";
+import { BoolCodec } from "./codecs/bool.js";
 import { StringCodec } from "./codecs/string.js";
 import { OptionCodecFactory } from "./codecs/option.js";
 import { ListCodecFactory } from "./codecs/list.js";
@@ -12,29 +15,7 @@ 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)));
-
-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 {
@@ -49,7 +30,6 @@ export function decodeTuple(
   if (!param.components) {
     throw new Error("Tuple parameter missing components");
   }
-  console.log("value");
 
   return param.components.reduce<Record<string, string>>(
     (acc, component: WitParameter) => {
@@ -68,146 +48,6 @@ export function decodeTuple(
   );
 }
 
-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 "u64":
-      return u64Decoder;
-
-    case "error":
-    case "contract-address":
-    case "bool":
-    case "s8":
-    case "s16":
-    case "s32":
-    case "s64":
-    case "u8":
-    case "u16":
-    case "u32":
-    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>>
 {
@@ -255,7 +95,6 @@ export function makeTupleCodecConstructor(
     // 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>;
     }
@@ -334,3 +173,167 @@ export function parseWitRecord(raw: string) {
 
   return result;
 }
+
+function decoderForParam(p: WitParameter) {
+  const t = p.type as WitType;
+
+  switch (t) {
+    // --- tuples -------------------------------------------------
+    case "tuple":
+      return makeDecoder(makeTupleCodecConstructor(p));
+    case "option<tuple>":
+      return makeDecoder(
+        OptionCodecFactory.create(makeTupleCodecConstructor(p)),
+      );
+    case "list<tuple>":
+      return makeDecoder(ListCodecFactory.create(makeTupleCodecConstructor(p)));
+
+    // --- string -------------------------------------------------
+    case "string":
+      return makeDecoder(StringCodec);
+    case "option<string>":
+      return makeDecoder(OptionCodecFactory.create(StringCodec));
+    case "list<string>":
+      return makeDecoder(ListCodecFactory.create(StringCodec));
+
+    // --- decimal ------------------------------------------------
+    case "decimal":
+      return makeDecoder(DecimalCodec);
+    case "option<decimal>":
+      return makeDecoder(OptionCodecFactory.create(DecimalCodec));
+    case "list<decimal>":
+      return makeDecoder(ListCodecFactory.create(DecimalCodec));
+
+    // --- bool ---------------------------------------------------
+    case "bool":
+      return makeDecoder(BoolCodec);
+    case "option<bool>":
+      return makeDecoder(OptionCodecFactory.create(BoolCodec));
+    case "list<bool>":
+      return makeDecoder(ListCodecFactory.create(BoolCodec));
+
+    // --- u64 ----------------------------------------------------
+    case "u64":
+      return makeDecoder(U64Codec);
+    case "option<u64>":
+      return makeDecoder(OptionCodecFactory.create(U64Codec));
+    case "list<u64>":
+      return makeDecoder(ListCodecFactory.create(U64Codec));
+
+    // --- s64 ----------------------------------------------------
+    case "s64":
+      return makeDecoder(S64Codec);
+    case "option<s64>":
+      return makeDecoder(OptionCodecFactory.create(S64Codec));
+    case "list<s64>":
+      return makeDecoder(ListCodecFactory.create(S64Codec));
+
+    // --- integer ------------------------------------------------
+    case "integer":
+      return makeDecoder(IntegerCodec);
+    case "option<integer>":
+      return makeDecoder(OptionCodecFactory.create(IntegerCodec));
+    case "list<integer>":
+      return makeDecoder(ListCodecFactory.create(IntegerCodec));
+
+    // --- not supported (yet) -----------------------------------
+    case "error":
+    case "contract-address":
+    case "s8":
+    case "s16":
+    case "s32":
+    case "u8":
+    case "u16":
+    case "u32":
+    case "option<s8>":
+    case "option<s16>":
+    case "option<s32>":
+    case "option<u8>":
+    case "option<u16>":
+    case "option<u32>":
+    case "option<_>":
+    case "list<s8>":
+    case "list<s16>":
+    case "list<s32>":
+    case "list<u8>":
+    case "list<u16>":
+    case "list<u32>":
+    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 InvalidWitEncodingTypeError(t, { docsPath: "tk" });
+
+    default: {
+      t satisfies never;
+      throw new InvalidWitEncodingTypeError(t, { docsPath: "tk" });
+    }
+  }
+}