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

package/src/sdk/test/e2e.test.ts

@@ -1,194 +0,0 @@
-import { test } from "vitest";
-// import { procContract } from "./proc-contract.js";
-import { parseWit } from "../../wit/wit-parser/parse-wit.js";
-import { createPublicClient as createKontorPublicClient } from "../clients/kontor/create-public-client.js";
-import { http } from "../clients/transports/http.js";
-import { mnemonicToAccount } from "../accounts/mnemonic-to-account.js";
-import { createWalletClient as createKontorWalletClient } from "../clients/kontor/create-wallet-client.js";
-
-import { custom } from "../clients/transports/custom.js";
-import { signet } from "../chains/definitions/signet.js";
-import { Instruction } from "../types/kontor.js";
-
-export const nativeTokenRaw = [
-  "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>;",
-] as const;
-
-export const wit = parseWit(nativeTokenRaw);
-
-// test("e2e kontor wallet client", async () => {
-//   const account = mnemonicToAccount(process.env.TEST_MNEMONIC!);
-//
-//   const kontorPublicClient = createKontorPublicClient({
-//     transport: http("https://signet-staging.kontor.network:35000/api"),
-//     account,
-//     chain: signet,
-//   });
-//
-//   const kontorWalletClient = createKontorWalletClient({
-//     account,
-//     // TODO: transport is not used for local account.
-//     transport: custom({
-//       request: async (_args: any) => null,
-//     }),
-//   });
-//
-//   const res = await kontorPublicClient.procContract({
-//     wit: wit,
-//     // TODO: add optional account override
-//
-//     functionName: "mint", // functin name is only valid if it's got a proc-context
-//     contractAddress: "token_0_0",
-//     args: [[7n, 18]],
-//     satsPerVByte: 1,
-//     utxos: [
-//       "641c40edf4cf0f1cdaea5c259bf50267bd8743dbade84c98bb9e360c2d0e2a33:1",
-//     ],
-//     gas: 10n,
-//   });
-//
-//   const commit: string = await kontorWalletClient.signCommit({
-//     account: account,
-//     chain: signet,
-//     psbt: res.result.commit_psbt_hex,
-//   });
-//
-//   const reveal: string = await kontorWalletClient.signReveal({
-//     account: account,
-//     chain: signet,
-//     psbt: res.result.reveal_psbt_hex,
-//     participantScripts: res.result.per_participant,
-//   });
-//
-//   // const m = await btcPublicClient.testMempoolAccept({
-//   //   rawtx: [hex.encode(commitExtracted), hex.encode(revealExtracted)],
-//   //   options: {},
-//   // });
-//   //
-//
-//   const r = await fetch("https://signet.kontor.network:38332", {
-//     method: "POST",
-//     headers: {
-//       "Content-Type": "application/json",
-//       Authorization: `Basic ${Buffer.from("rpc:rpc").toString("base64")}`,
-//     },
-//     body: JSON.stringify({
-//       method: "testmempoolaccept",
-//       params: [[commit, reveal]],
-//     }),
-//   });
-//
-//   const j = await r.json();
-//
-//   //
-//   // const op = await kontorPublicClient.inspect({
-//   //   hex: hex.encode(revealExtracted),
-//   // });
-//
-//   // console.log(JSON.stringify(op.result[0]!.op));
-//   //
-// });
-
-test("e2e kontor wallet client", async () => {
-  const account = mnemonicToAccount(process.env.TEST_MNEMONIC!, {
-    coinType: 1,
-    networkConfig: signet.networkConfig,
-  });
-
-  const kontorPublicClient = createKontorPublicClient({
-    transport: http("https://signet-staging.kontor.network:35000/api"),
-    chain: signet,
-    account,
-  });
-
-  const kontorWalletClient = createKontorWalletClient({
-    account,
-    chain: signet,
-    transport: custom({
-      request: async (_args: any) => null,
-    }),
-  });
-
-  const res = await kontorPublicClient.callCompose({
-    utxos: [
-      "641c40edf4cf0f1cdaea5c259bf50267bd8743dbade84c98bb9e360c2d0e2a33:1",
-    ],
-    instruction: Instruction.issuance(),
-    satsPerVByte: 1,
-  });
-
-  // TODO: add separate tests for these
-  // const instructionQuery_ = kontorPublicClient.buildInstructionQuery({
-  //   utxos: [
-  //     "641c40edf4cf0f1cdaea5c259bf50267bd8743dbade84c98bb9e360c2d0e2a33:1",
-  //   ],
-  //   instruction: Instruction.issuance(),
-  // });
-  //
-  // const composeQuery_ = kontorPublicClient.buildComposeQuery({
-  //   utxos: [
-  //     "641c40edf4cf0f1cdaea5c259bf50267bd8743dbade84c98bb9e360c2d0e2a33:1",
-  //   ],
-  //
-  //   instruction: Instruction.issuance(),
-  //   satsPerVByte: 1,
-  // });
-  // const x = await kontorPublicClient.callView({
-  //   contractAddress: "token_0_0",
-  //   wave: "balances()",
-  // });
-
-  // TODO: should this return hex
-
-  // TODO: need to handle account override / defaults
-  const commit = await kontorWalletClient.signCommit({
-    psbt: res.result.commit_psbt_hex,
-  });
-
-  const reveal = await kontorWalletClient.signReveal({
-    psbt: res.result.reveal_psbt_hex,
-    participantScripts: res.result.per_participant,
-  });
-
-  // const commitExtracted = commit.extract();
-  // const revealExtracted = reveal.extract();
-
-  const r = await fetch("https://signet.kontor.network:38332", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Basic ${Buffer.from("rpc:rpc").toString("base64")}`,
-    },
-    body: JSON.stringify({
-      method: "testmempoolaccept",
-      params: [[commit, reveal]],
-    }),
-  });
-
-  const mempoolAccept = await r.json();
-
-  console.log({ mempoolAccept: mempoolAccept.result });
-  //
-  const op = await kontorPublicClient.inspect({
-    hex: reveal,
-  });
-
-  console.log(JSON.stringify(op.result[0]!.op));
-  //
-});

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

@@ -1,215 +0,0 @@
-import * as z from "zod";
-
-import type { CodecConstructor, CodecInstance, WaveExpr } from "./types.js";
-
-type Decimal_ = [bigint, number];
-
-const TARGET_SCALE = 18;
-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" });
-
-function pow10n(n: number): bigint {
-  if (n < 0) throw new Error("pow10n expects n ≥ 0");
-  let p = 1n;
-  for (let i = 0; i < n; i++) p *= 10n;
-  return p;
-}
-
-// const fromLimbs = ({ r0, r1, r2, r3 }: _Decimal.T) =>
-//   (r3 << 192n) | (r2 << 128n) | (r1 << 64n) | r0;
-
-function splitToU64Limbs(x: bigint): {
-  r0: bigint;
-  r1: bigint;
-  r2: bigint;
-  r3: bigint;
-} {
-  const r0 = x & U64_MAX;
-  const r1 = (x >> 64n) & U64_MAX;
-  const r2 = (x >> 128n) & U64_MAX;
-  const r3 = (x >> 192n) & U64_MAX;
-
-  // overflow if any higher bits remain
-  if (x >> 256n !== 0n) {
-    throw new Error("decimal magnitude does not fit in 256 bits");
-  }
-
-  return { r0, r1, r2, r3 };
-}
-
-export namespace _Decimal {
-  export namespace Sign {
-    export const schema = z.enum(["plus", "minus"]);
-    export type T = z.infer<typeof schema>;
-  }
-
-  // Raw limbs + sign; limbs are real u64 (bigint), not JS numbers
-  export const schema = z.object({
-    r0: U64,
-    r1: U64,
-    r2: U64,
-    r3: U64,
-    sign: Sign.schema,
-  });
-
-  export type T = z.infer<typeof schema>;
-}
-
-/**
- * Parses a wave-ish struct like:
- *   "{ r0: 1337, r1: 0, r2: 0, r3: 0, sign: plus }"
- * Returns a validated _Decimal.T with bigint limbs.
- */
-export function parseDecimalWaveExpr(expr: string): _Decimal.T {
-  const trimmed = expr.trim();
-  // Optional braces; tolerate with or without
-  const inner = trimmed.replace(/^\{\s*/, "").replace(/\s*\}$/, "");
-
-  if (inner.length === 0) {
-    throw new Error("empty decimal expression");
-  }
-
-  // Split by commas that separate top-level pairs (no nesting expected here)
-  const parts = inner
-    .split(",")
-    .map((p) => p.trim())
-    .filter(Boolean);
-
-  const seen = new Set<string>();
-  // Default r1..r3 to 0 for ergonomics; require r0 + sign at minimum.
-  let out: Partial<_Decimal.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" pair, 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": {
-        // allow underscores for readability, like Rust literals
-        const normalized = valRaw.replace(/_/g, "");
-        // BigInt constructor handles decimal strings; reject non-integers explicitly
-        if (!/^[+-]?\d+$/.test(normalized)) {
-          throw new Error(`invalid integer for ${keyRaw}: "${valRaw}"`);
-        }
-        const limb = BigInt(normalized);
-        // zod will re-validate bounds, but fail fast here for nicer messages
-        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}"`);
-    }
-  }
-
-  // Require at least r0 and sign (r1..r3 default to 0 if not given)
-  if (out.r0 === undefined) {
-    throw new Error(`missing required key "r0"`);
-  }
-  if (!out.sign) {
-    throw new Error(`missing required key "sign"`);
-  }
-
-  // Final validation & typing
-  return _Decimal.schema.parse(out);
-}
-
-class _DecimalCodec implements CodecInstance<Decimal_> {
-  public readonly data: _Decimal.T;
-
-  constructor(data: _Decimal.T) {
-    this.data = data;
-  }
-
-  static fromJs(
-    value: Decimal_,
-    targetScale: number = TARGET_SCALE,
-  ): _DecimalCodec {
-    // dn.Dnum is effectively [coef, decimals]
-    const [coefRaw, decs] = value as unknown as Decimal_;
-
-    const sign: _Decimal.Sign.T = coefRaw < 0n ? "minus" : "plus";
-    const coefAbs = coefRaw < 0n ? -coefRaw : coefRaw;
-
-    if (decs > decs) {
-      // would require rounding; be strict
-      throw new Error(
-        `cannot downscale from ${decs} to ${targetScale} decimals without rounding`,
-      );
-    }
-
-    // upscale to target scale exactly
-    const scaleDelta = targetScale - decs;
-    const scaled = coefAbs * pow10n(scaleDelta);
-
-    const { r0, r1, r2, r3 } = splitToU64Limbs(scaled);
-    const out = _Decimal.schema.parse({ r0, r1, r2, r3, sign });
-    return new _DecimalCodec(out);
-  }
-
-  static fromKontor(data: _Decimal.T): _DecimalCodec {
-    return new _DecimalCodec(data);
-  }
-
-  static parseWave(expr: string): _Decimal.T {
-    return _Decimal.schema.parse(parseDecimalWaveExpr(expr));
-  }
-
-  toJs(): Decimal_ {
-    const mag =
-      (BigInt(this.data.r3) << 192n) |
-      (BigInt(this.data.r2) << 128n) |
-      (BigInt(this.data.r1) << 64n) |
-      BigInt(this.data.r0);
-
-    const signed = this.data.sign === "minus" ? -mag : mag;
-    return [signed, 18];
-  }
-
-  toWave(): WaveExpr {
-    // NOTE: adjust quoting on sign if your Wave syntax needs `"plus"` etc.
-    return `{r0: ${this.data.r0}, r1: ${this.data.r1}, r2: ${this.data.r2}, r3: ${this.data.r3}, sign: ${this.data.sign}}` as WaveExpr;
-  }
-}
-
-export const DecimalCodec = _DecimalCodec as unknown as CodecConstructor<
-  Decimal_,
-  _DecimalCodec,
-  _Decimal.T
->;

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

@@ -1,114 +0,0 @@
-import * as z from "zod";
-
-export namespace Enum {
-  export namespace Parens {
-    export const schema = z.templateLiteral([
-      z.literal("("),
-      z.string(),
-      z.literal(")"),
-    ]);
-  }
-
-  export namespace Option {
-    // some(foo) or some( foo bar ) or even some()
-    // also allow just "some" ??? we'll decide below.
-    export const waveRegex =
-      /^(?<kind>some)(?:\((?<value>[\s\S]*?)\))$|^(?<none>none)$/;
-
-    // We'll keep these tiny sub-schemas because they're readable elsewhere.
-    export namespace None {
-      export const schema = z.literal("none");
-    }
-
-    export namespace Some {
-      // NOTE: we REQUIRE parens for "some(...)"
-      // If you want plain "some" to be valid, we could relax later.
-      export const schema = z.templateLiteral([
-        z.literal("some"),
-        Parens.schema,
-      ]);
-    }
-
-    // Raw union of the spellings we accept as input
-    // e.g. "none" or "some(<stuff>)"
-    const rawSchema = z.union([None.schema, Some.schema]);
-
-    // Transform raw string -> { kind: "none" | "some"; value: string | null }
-    // Then pipe into a discriminated union so .infer<> is nice & strict.
-    export const schema = rawSchema
-      .transform((expr) => {
-        const trimmed = expr.trim();
-
-        // Fast path for "none"
-        if (trimmed === "none") {
-          return {
-            kind: "none" as const,
-          };
-        }
-
-        // else parse "some(...)"
-        const match = /^some\((?<value>[\s\S]*?)\)$/.exec(trimmed);
-        if (!match?.groups) {
-          throw new Error(`invariant: invalid wave option expression: ${expr}`);
-        }
-
-        const value = match.groups.value?.trim() ?? "";
-        return {
-          kind: "some" as const,
-          value: value === "" ? null : value,
-        };
-      })
-      .pipe(
-        z.discriminatedUnion("kind", [
-          z.object({
-            kind: z.literal("none"),
-          }),
-          z.object({
-            kind: z.literal("some"),
-            value: z.string().nullable(), // raw value contents or null (for `some()`)
-          }),
-        ]),
-      );
-
-    export type T = z.infer<typeof schema>;
-  }
-
-  export namespace Result {
-    export const waveRegex = /^(?<_tag>ok|err)(?:\((?<value>[\s\S]*?)\))?$/;
-
-    export namespace Ok {
-      export const schema = z.literal("ok");
-    }
-    export namespace Err {
-      export const schema = z.literal("err");
-    }
-
-    export const schema = z
-      .templateLiteral([
-        z.union([Ok.schema, Err.schema]),
-        Parens.schema.optional(),
-      ])
-      .transform((expr) => {
-        const match = waveRegex.exec(expr.trim());
-        if (!match?.groups) {
-          throw new Error(`invariant: invalid wave expression: ${expr}`);
-        }
-        const { _tag, value } = match.groups;
-        return { _tag, value: value?.trim() || null };
-      })
-      .pipe(
-        // lock the output into a discriminated union so z.infer<> is nice
-        z.discriminatedUnion("_tag", [
-          z.object({
-            _tag: Ok.schema, // "ok"
-            value: z.string().nullable(), // raw value text (we haven't parsed r0..sign here)
-          }),
-          z.object({
-            _tag: Err.schema, // "err"
-            value: z.string().nullable(), // err(message("...")) -> 'message("...")' or null
-          }),
-        ]),
-      );
-    export type T = z.infer<typeof schema>;
-  }
-}