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

package/src/sdk/actions/kontor/public/view-contract.test-d.ts

@@ -3,24 +3,9 @@ import { viewContract } from "./view-contract.js";
 import { parseWit } from "../../../../wit/wit-parser/parse-wit.js";
 import { createPublicClient } from "../../../clients/kontor/create-public-client.js";
 import { http } from "../../../clients/transports/http.js";
+import { nativeToken } from "../../../contracts/wits.js";
 
-// define the wit
-const input = [
-  "record balance { key: string, value: decimal }",
-  // TODO: barfing on core-context
-  // "export issuance: func(ctx: borrow<core-context>, n: decimal) -> result<_, error>;",
-  // "export hold: func(ctx: borrow<core-context>, n: decimal) -> result<_, error>;",
-  // "export burn-and-release: func(ctx: borrow<core-context>, n: decimal) -> result<_, error>;",
-  "export init: func(ctx: borrow<proc-context>);",
-  "export mint: func(ctx: borrow<proc-context>, n: decimal) -> result<_, error>;",
-  "export burn: func(ctx: borrow<proc-context>, n: decimal) -> result<_, error>;",
-  "export transfer: func(ctx: borrow<proc-context>, to: string, n: decimal) -> result<_, 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;",
-] as const;
-
-const wit = parseWit(input);
+const wit = parseWit(nativeToken.raw);
 
 test("e2e", async () => {
   const client = createPublicClient({

package/src/sdk/actions/kontor/public/view-contract.ts

@@ -82,11 +82,14 @@ export async function viewContract<
       wave: wave,
     });
 
-    if ("Err" in response.result) {
-      throw new Error("Contract view call failed");
+    console.log(response.result.type);
+
+    if (response.result.type == "Err") {
+      // TODO: add custom error
+      throw new Error(response.result.message);
     }
 
-    const value = response.result.Ok.value;
+    const value = response.result.value;
 
     return decodeFunctionResult({
       wit: wit,
@@ -95,7 +98,9 @@ export async function viewContract<
     }) as ViewContractReturnType<wit, functionName>;
     //
   } catch (error) {
+    throw error;
     throw new Error("problems");
+    // TODO: add custom error
     // throw getContractError(error as BaseError, {
     //   abi: wit,
     //   address,

package/src/sdk/actions/kontor/wallet/sign-reveal.ts

@@ -48,9 +48,7 @@ export async function signReveal<
   // TODO: assertRequest(account, paramatetrs )
   // TODO: assertCurrentChain(chanId, chain)
 
-  const tx = Transaction.fromPSBT(hex.decode(params.psbt), {
-    allowUnknownInputs: true,
-  });
+  const tx = Transaction.fromPSBT(hex.decode(params.psbt));
 
   for (let i = 0; i < params.parcipantScripts.length; i++) {
     const { commit_tap_leaf_script } = params.parcipantScripts[i]!;
@@ -103,25 +101,8 @@ export async function signReveal<
         broadcast: false,
       });
 
-  const signedTx = Transaction.fromPSBT(hex.decode(signed.psbt as string), {
-    allowUnknownInputs: true,
-  });
-
-  // for (let i = 0; i < signedTx.inputsLength; i++) {
-  //   const input = signedTx.getInput(i);
-  //   if (input.tapLeafScript && input.tapLeafScript.length > 0) {
-  //     const [cbStruct, scriptWithVersion] = input.tapLeafScript[0]!;
-  //     console.log("SIGNED TAPLEAF", i, {
-  //       cbStruct,
-  //       cbEncoded: hex.encode(TaprootControlBlock.encode(cbStruct)),
-  //       scriptWithVersion: hex.encode(scriptWithVersion),
-  //     });
-  //   }
-  // }
-  //
-  //
-
-  // finalize
+  const signedTx = Transaction.fromPSBT(hex.decode(signed.psbt as string));
+
   for (let i = 0; i < params.parcipantScripts.length; i++) {
     const input = signedTx.getInput(i);
     const p = params.parcipantScripts[i]!;
@@ -129,12 +110,6 @@ export async function signReveal<
     const scriptHex = p.commit_tap_leaf_script.script;
     const cbHex = p.commit_tap_leaf_script.controlBlock;
 
-    // console.log("USING SCRIPT/CB", {
-    //   scriptHex,
-    //   cbHex,
-    //   cbDecodedRoundtrip: hex.encode(hex.decode(cbHex)),
-    // });
-
     signedTx.updateInput(i, {
       finalScriptWitness: [
         input.tapScriptSig![0]![1],
@@ -144,12 +119,5 @@ export async function signReveal<
     });
   }
 
-  // for (let i = 0; i < signedTx.inputsLength; i++) {
-  //   const input = signedTx.getInput(i);
-  //   console.log("FINAL INPUT", i, {
-  //     finalScriptWitness: input.finalScriptWitness?.map((w) => hex.encode(w)),
-  //   });
-  // }
-
   return signedTx;
 }

package/src/sdk/clients/base/create-rpc-client.test.ts

@@ -85,17 +85,23 @@ describe("transports", () => {
        "name": "Kontor",
        "symbol": "KOR",
      },
+     "networkConfig": {
+       "bech32": "tb",
+       "pubKeyHash": 111,
+       "scriptHash": 196,
+       "wif": 239,
+     },
      "serializers": undefined,
      "urls": {
        "default": {
          "bitcoinRpc": [
-           "https://signet.kontor.network:38332",
+           "https://signet-staging.kontor.network:38332",
          ],
          "http": [
-           "https://signet.kontor.network:35000/api",
+           "https://signet-staging.kontor.network:35000/api",
          ],
          "webSocket": [
-           "wss://signet.kontor.network:35000/ws",
+           "wss://signet-staging.kontor.network:35000/ws",
          ],
        },
      },
@@ -115,7 +121,7 @@ describe("transports", () => {
      "retryDelay": 150,
      "timeout": 10000,
      "type": "http-rpc",
-     "url": "https://signet.kontor.network:38332",
+     "url": "https://signet-staging.kontor.network:38332",
    },
    "type": "base",
  }

package/src/sdk/clients/create-public-client.test.ts

@@ -33,6 +33,7 @@ test("creates", () => {
       "pollingInterval": 4000,
       "request": [Function],
       "sendRawTransaction": [Function],
+      "testMempoolAccept": [Function],
       "transport": {
         "key": "mock",
         "methods": undefined,
@@ -87,17 +88,23 @@ test("with chain", () => {
        "name": "Kontor",
        "symbol": "KOR",
      },
+     "networkConfig": {
+       "bech32": "tb",
+       "pubKeyHash": 111,
+       "scriptHash": 196,
+       "wif": 239,
+     },
      "serializers": undefined,
      "urls": {
        "default": {
          "bitcoinRpc": [
-           "https://signet.kontor.network:38332",
+           "https://signet-staging.kontor.network:38332",
          ],
          "http": [
-           "https://signet.kontor.network:35000/api",
+           "https://signet-staging.kontor.network:35000/api",
          ],
          "webSocket": [
-           "wss://signet.kontor.network:35000/ws",
+           "wss://signet-staging.kontor.network:35000/ws",
          ],
        },
      },
@@ -108,6 +115,7 @@ test("with chain", () => {
    "pollingInterval": 4000,
    "request": [Function],
    "sendRawTransaction": [Function],
+   "testMempoolAccept": [Function],
    "transport": {
      "key": "mock",
      "methods": undefined,

package/src/sdk/clients/kontor/create-public-client.test.ts

@@ -11,13 +11,14 @@ test("creates", async () => {
   expect(client).toMatchInlineSnapshot(`
     {
       "account": undefined,
-      "buildComposeCall": [Function],
-      "buildInstruction": [Function],
+      "buildComposeQuery": [Function],
+      "buildInstructionQuery": [Function],
       "cacheTime": 4000,
-      "callProc": [Function],
+      "callCompose": [Function],
       "callView": [Function],
       "chain": undefined,
       "extend": [Function],
+      "inspect": [Function],
       "key": "kontor-http",
       "name": "KONTOR-HTTP Client",
       "pollingInterval": 4000,

package/src/sdk/contracts/wits.ts

@@ -23,7 +23,7 @@ const nativeTokenRaw = [
   "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 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;
 

package/src/sdk/types/contract.test-d.ts

@@ -4,8 +4,9 @@ import type {
   ContractFunctionArgs,
   ContractFunctionReturnType,
 } from "./contract.js";
+import { nativeToken as nativeToken_ } from "../contracts/wits.js";
 
-import { nativeToken } from "~test/src/wits.js";
+const nativeToken = nativeToken_.wit;
 
 test("ContractFunctionName", () => {
   type All = ContractFunctionName<typeof nativeToken>;
@@ -20,7 +21,7 @@ test("ContractFunctionName", () => {
     | "balance"
     | "balances"
     | "total-supply"
-    | "attach"
+    // | "attach"
     | "detach"
   >;
 
@@ -32,7 +33,11 @@ test("ContractFunctionName", () => {
 
   type Proc = ContractFunctionName<typeof nativeToken, "proc">;
   expectTypeOf<Proc>().toEqualTypeOf<
-    "mint" | "burn" | "transfer" | "attach" | "detach"
+    | "mint"
+    | "burn"
+    | "transfer"
+    //| "attach"
+    | "detach"
   >;
 });
 
@@ -68,8 +73,8 @@ test("ContractFunctionArgs", () => {
   >;
   expectTypeOf<TotalSupply>().toEqualTypeOf<readonly []>;
 
-  type Attach = ContractFunctionArgs<typeof nativeToken, "proc", "attach">;
-  expectTypeOf<Attach>().toEqualTypeOf<readonly [bigint, [bigint, number]]>;
+  // type Attach = ContractFunctionArgs<typeof nativeToken, "proc", "attach">;
+  // expectTypeOf<Attach>().toEqualTypeOf<readonly [bigint, [bigint, number]]>;
 
   type Detach = ContractFunctionArgs<typeof nativeToken, "proc", "detach">;
   expectTypeOf<Detach>().toEqualTypeOf<readonly []>;
@@ -209,25 +214,25 @@ test("ContractFunctionReturnType", () => {
   >;
   expectTypeOf<TotalSupply>().toEqualTypeOf<[bigint, number]>;
 
-  type Attach = ContractFunctionReturnType<
-    typeof nativeToken,
-    "proc",
-    "attach"
-  >;
-  expectTypeOf<Attach>().toEqualTypeOf<
-    | {
-        ok: false;
-        error: string;
-      }
-    | {
-        ok: true;
-        value: {
-          src: string;
-          dst: string;
-          amt: [bigint, number];
-        };
-      }
-  >;
+  // type Attach = ContractFunctionReturnType<
+  //   typeof nativeToken,
+  //   "proc",
+  //   "attach"
+  // >;
+  // expectTypeOf<Attach>().toEqualTypeOf<
+  //   | {
+  //       ok: false;
+  //       error: string;
+  //     }
+  //   | {
+  //       ok: true;
+  //       value: {
+  //         src: string;
+  //         dst: string;
+  //         amt: [bigint, number];
+  //       };
+  //     }
+  // >;
 
   type Detach = ContractFunctionReturnType<
     typeof nativeToken,

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",
             },