@kontor/kontor-sdk 1.0.0-alpha.0

package/src/sdk/accounts/utils/sign-psbt.ts

@@ -0,0 +1,43 @@
+import { hex } from "@scure/base";
+import { SigHash, Transaction } from "@scure/btc-signer";
+import type { ErrorType } from "../../errors/utils.js";
+import type { Hex } from "../../types/misc.js";
+
+export type LocalSignPsbtParameters = {
+  privateKey: Hex;
+  psbt: Hex;
+  signInputs: // this is technically optional but required here for simplicity
+  | number[]
+    | {
+        index: number;
+        address?: string;
+        publicKey?: string;
+        allowedSighash?: SigHash[];
+      }[];
+};
+
+export type LocalSignPsbtReturnType = {
+  txid: string;
+  psbt: Hex;
+};
+
+export type LocalSignPsbtErrorType = ErrorType;
+
+export async function signPsbt(
+  params: LocalSignPsbtParameters,
+): Promise<LocalSignPsbtReturnType> {
+  const { privateKey, signInputs, psbt } = params;
+
+  const privKey = hex.decode(privateKey);
+  const tx = Transaction.fromPSBT(hex.decode(psbt));
+
+  for (const input of signInputs) {
+    if (typeof input == "number") {
+      tx.signIdx(privKey, input);
+    } else {
+      tx.signIdx(privKey, input.index, input.allowedSighash);
+    }
+  }
+
+  return { txid: tx.id, psbt: hex.encode(tx.toPSBT()) };
+}

package/src/sdk/actions/get-contract.test-d.ts

@@ -0,0 +1,71 @@
+import { expectTypeOf, test } from "vitest";
+import { parseWit } from "../../wit/wit-parser/parse-wit.js";
+import {
+  // getContract,
+  type GetContractReturnType,
+  type KebabToCamel,
+  type GetViewFunction,
+  // getContract,
+} from "./get-contract.js";
+
+const input = [
+  // TODO: build in record defs should be defined under the hood
+  // "record tool {  name: string, isHammer: bool }",
+  "export fib: func(ctx: borrow<proc-context>, arith-address: contract-address, n: u64) -> u64;",
+  "export fib-of-sub: func(ctx: borrow<proc-context>, arith-address: contract-address, x: string, y: string) -> result<u64, error>;",
+  "export cached-values: func(ctx: borrow<view-context>) -> list<u64>;",
+  "export fib-as-view: func(ctx: borrow<view-context>, n: u64) -> u64;",
+  "export read-with-record-arg: func(ctx: borrow<view-context>, contract-address: contract-address) -> u64;",
+  // "export read-tools: func(ctx: borrow<view-context>) -> list<tool>;",
+] as const;
+
+const wit = parseWit(input);
+
+test("KebabToCamel basic mapping", () => {
+  type A = KebabToCamel<"cached-values">;
+  type B = KebabToCamel<"fib-of-sub">;
+  type C = KebabToCamel<"fib">;
+
+  expectTypeOf<A>().toEqualTypeOf<"cachedValues">();
+  expectTypeOf<B>().toEqualTypeOf<"fibOfSub">();
+  expectTypeOf<C>().toEqualTypeOf<"fib">();
+});
+
+test("GetContractReturnType", () => {
+  expectTypeOf<GetContractReturnType<typeof wit>>().toEqualTypeOf<{
+    view: {
+      cachedValues: never;
+      fibAsView: never;
+      readWithRecordArg: never;
+      readTools: never;
+    };
+  }>;
+});
+test("GetContractReturnType view keys are camelCased", () => {
+  type ViewKeys = keyof GetContractReturnType<typeof wit>["view"];
+
+  // For FibAbi, the only view fn is "cached-values", so this should be just "cachedValues"
+  expectTypeOf<ViewKeys>().toEqualTypeOf<
+    "cachedValues" | "fibAsView" | "readWithRecordArg"
+  >();
+});
+
+test("getContract", async () => {
+  // const contract = getContract({
+  //   wit: wit,
+  // });
+  // const res0 = contract.view.readWithRecordArg(["token_10_11"]);
+  //
+  // const res = contract.view.cachedValues();
+  //
+  // const res_2 = contract.view.fibAsView([10n]);
+  // const re3 = contract.view.readTools();
+});
+
+test("GetViewFunction for cached-values (no inputs)", () => {
+  type Fn = GetViewFunction<true, typeof wit, "cached-values">;
+
+  // return type: Promise<ViewContractReturnType<...>>
+  // kay
+  expectTypeOf<Awaited<ReturnType<Fn>>>().toEqualTypeOf<readonly bigint[]>();
+});

package/src/sdk/actions/get-contract.ts

@@ -0,0 +1,165 @@
+import type { Wit, WitFunction } from "../../wit/wit.js";
+import type {
+  IsNarrowable,
+  Prettify,
+  UnionOmit,
+} from "../../wit/type-utils.js";
+
+import type {
+  ExtractWitFunctionNames,
+  ExtractWitFunction,
+  WitParametersToPrimitiveTypes,
+} from "../../wit/utils.js";
+import type {
+  ContractFunctionArgs,
+  ContractFunctionName,
+} from "../types/contract.js";
+
+// import { getAction } from "../utils/getAction.js";
+import {
+  // viewContract,
+  type ViewContractParameters,
+  type ViewContractReturnType,
+} from "./kontor/public/view-contract.js";
+
+// TODO: move to utils
+function camelToKebab(str: string): string {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+export type KebabToCamel<S extends string> =
+  S extends `${infer Head}-${infer Tail}`
+    ? `${Head}${Capitalize<KebabToCamel<Tail>>}`
+    : S;
+
+export type GetContractParameters<wit extends Wit | readonly unknown[] = Wit> =
+  {
+    wit: wit;
+  };
+
+export type GetViewFunction<
+  narrowable extends boolean,
+  wit extends Wit | readonly unknown[],
+  functionName extends ContractFunctionName<wit, "view">,
+  args extends ContractFunctionArgs<
+    wit,
+    "view",
+    functionName
+  > = ContractFunctionArgs<wit, "view", functionName>,
+  witFunction extends WitFunction = wit extends Wit
+    ? ExtractWitFunction<wit, functionName>
+    : WitFunction,
+  //
+  _args = WitParametersToPrimitiveTypes<witFunction["inputs"]>,
+  _options = Prettify<
+    UnionOmit<
+      ViewContractParameters<wit, functionName, args>,
+      "contractAddress" | "args" | "functionName"
+    >
+  >,
+> = narrowable extends true
+  ? (
+      ...parameters: _args extends readonly []
+        ? [options?: _options]
+        : [args: _args, options?: _options]
+    ) => Promise<ViewContractReturnType<wit, functionName, args>>
+  : (
+      ...parameters:
+        | [options?: _options]
+        | [args: readonly unknown[], options?: _options]
+    ) => Promise<ViewContractReturnType>;
+
+export type GetContractReturnType<
+  wit extends Wit | readonly unknown[] = Wit,
+  _viewFunctionNames extends string = wit extends Wit
+    ? Wit extends wit
+      ? string
+      : ExtractWitFunctionNames<wit, "view">
+    : string,
+  _procFunctionNames extends string = wit extends Wit
+    ? Wit extends wit
+      ? string
+      : ExtractWitFunctionNames<wit, "proc">
+    : string,
+  _narrowable extends boolean = IsNarrowable<wit, Wit>,
+> = {
+  view: {
+    // K is the *original* wit function name ("cached-values")
+    [K in _viewFunctionNames as KebabToCamel<K>]: GetViewFunction<
+      _narrowable,
+      wit,
+      // and we pass K directly into GetViewFunction
+      K extends ContractFunctionName<wit, "view"> ? K : never
+    >;
+  };
+};
+
+export function getContract<const wit extends Wit | readonly unknown[]>({
+  wit: wit,
+}: GetContractParameters<wit>): GetContractReturnType<wit> {
+  const hasPublicClient = true;
+
+  const contract: {
+    [_ in "wit" | "view"]?: unknown;
+  } = {};
+
+  // TODO: actually introspect this
+  let hasReadFunction = true;
+
+  if (hasPublicClient) {
+    if (hasReadFunction) {
+      console.log("we are defining a proxy");
+
+      contract.view = new Proxy(
+        {},
+        {
+          get(_, functionName: string) {
+            // @ts-ignore
+            const witFunctionName = camelToKebab(functionName);
+
+            return (
+              ...parameters: [
+                args?: readonly unknown[] | undefined,
+                options?: UnionOmit<
+                  ViewContractParameters,
+                  "wit" | "contractAddress" | "functionName" | "args"
+                >,
+              ]
+            ) => {
+              // @ts-ignore
+              const { args, options } = getFunctionParameters(parameters);
+
+              // return getAction(
+              //   {
+              //     viewContract: () => {},
+              //     call: () => {},
+              //   },
+              //   viewContract,
+              //   "viewContract",
+              // )({
+              //   wit,
+              //   functionName: witFunctionName,
+              //   // address,
+              //   args,
+              //   ...options,
+              // } as ViewContractParameters);
+            };
+          },
+        },
+      );
+    }
+  }
+
+  contract.wit = wit;
+
+  return contract as unknown as GetContractReturnType<wit>;
+}
+
+export function getFunctionParameters(
+  values: [args?: readonly unknown[] | undefined, options?: object | undefined],
+) {
+  const hasArgs = values.length && Array.isArray(values[0]);
+  const args = hasArgs ? values[0]! : [];
+  const options = (hasArgs ? values[1] : values[0]) ?? {};
+  return { args, options };
+}

package/src/sdk/actions/kontor/public/build-compose-call.ts

@@ -0,0 +1,79 @@
+import type { ResolvedRegister } from "../../../../wit/register.js";
+import type { KontorPublicClient } from "../../../clients/kontor/create-public-client.js";
+import type { HttpTransport } from "../../../clients/transports/create-http-transport.js";
+import type { Chain } from "../../../types/chain.js";
+import type { Address, UtxoId, XOnlyPubKey } from "../../../types/misc.js";
+import {
+  buildInstruction,
+  type BuildInstructionReturnType,
+} from "./build-instruction.js";
+import { getKontorAction } from "../../../utils/get-action.js";
+
+export type BuildComposeCallParameters<
+  _chain extends Chain | undefined = Chain | undefined,
+> = {
+  address?: Address;
+  xOnlyPubKey?: XOnlyPubKey; // TODO: maybe this should be wrapped in a single object
+  utxos: UtxoId[];
+  contractAddress: ResolvedRegister["contractAddress"];
+  wave: string;
+  gas: bigint;
+  satsPerVByte: number;
+};
+
+export type BuildComposeCallReturnType = {
+  instructions: BuildInstructionReturnType[];
+  // TODO: this should be changed upstream or encoded in a formatter
+  sat_per_vbyte: number;
+};
+
+export async function buildComposeCall<
+  chain extends Chain | undefined = Chain | undefined,
+>(
+  client: KontorPublicClient<HttpTransport, chain>,
+  params: BuildComposeCallParameters<chain>,
+): Promise<BuildComposeCallReturnType> {
+  const account = client.account;
+
+  const {
+    contractAddress,
+    wave,
+    gas,
+    utxos,
+    address = account?.address,
+    xOnlyPubKey = account?.xOnlyPubKey,
+  } = params;
+
+  if (!xOnlyPubKey) {
+    // TODO: add custom error
+    throw new Error("x_only_public_key is required");
+  }
+
+  if (!address) {
+    // TODO: add custom error
+    throw new Error("address is required");
+  }
+
+  if (utxos.length === 0) {
+    // TODO: add custom error
+    throw new Error("at least one funding UTXO is required");
+  }
+
+  const instruction = await getKontorAction(
+    client,
+    buildInstruction,
+    "buildInstruction",
+  )({
+    contractAddress,
+    wave,
+    gas,
+    utxos,
+    xOnlyPubKey,
+    address,
+  });
+
+  return {
+    instructions: [instruction],
+    sat_per_vbyte: params.satsPerVByte,
+  };
+}

package/src/sdk/actions/kontor/public/build-instruction.ts

@@ -0,0 +1,91 @@
+import type { InstructionQuery } from "../../../types/kontor.js";
+import type { ResolvedRegister } from "../../../../wit/register.js";
+import type { KontorPublicClient } from "../../../clients/kontor/create-public-client.js";
+import type { HttpTransport } from "../../../clients/transports/create-http-transport.js";
+import type { Chain } from "../../../types/chain.js";
+import type { Address, UtxoId, XOnlyPubKey } from "../../../types/misc.js";
+
+export type BuildInstructionParameters<
+  _chain extends Chain | undefined = Chain | undefined,
+> = {
+  address?: Address;
+  xOnlyPubKey?: XOnlyPubKey; // TODO: maybe this should be wrapped in a single object
+  utxos: UtxoId[];
+  contractAddress: ResolvedRegister["contractAddress"];
+  wave: string;
+  gas: bigint;
+};
+
+export type BuildInstructionReturnType = InstructionQuery;
+
+// TODO: these normalize methods probably belong somewhere else
+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)];
+}
+
+export async function buildInstruction<
+  chain extends Chain | undefined = Chain | undefined,
+>(
+  client: KontorPublicClient<HttpTransport, chain>,
+  params: BuildInstructionParameters<chain>,
+): Promise<BuildInstructionReturnType> {
+  const account = client.account;
+
+  const {
+    contractAddress,
+    wave,
+    gas,
+    utxos,
+    address = account?.address,
+    xOnlyPubKey = account?.xOnlyPubKey,
+  } = params;
+
+  if (!xOnlyPubKey) {
+    // TODO: add custom error
+    throw new Error("x_only_public_key is required");
+  }
+
+  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);
+
+  // const sciptData = buildCallScriptDataBytes(contractAddress, wave, gas);
+
+  return {
+    address: address!,
+    x_only_public_key: xOnly,
+    funding_utxo_ids:
+      fundingIds.length === 1
+        ? (fundingIds[0] as string)
+        : fundingIds.join(","),
+    instruction: {
+      Call: {
+        gas_limit: Number(gas), // TODO: refine type
+        contract: contractAddress,
+        expr: wave,
+      },
+    },
+    chained_instruction: null,
+  };
+}

package/src/sdk/actions/kontor/public/call-proc.ts

@@ -0,0 +1,97 @@
+import type { ResolvedRegister } from "../../../../wit/register.js";
+import type { KontorPublicClient } from "../../../clients/kontor/create-public-client.js";
+import type { HttpTransport } from "../../../clients/transports/create-http-transport.js";
+import type { Chain } from "../../../types/chain.js";
+import type {
+  Address,
+  TapLeafScript,
+  UtxoId,
+  XOnlyPubKey,
+} from "../../../types/misc.js";
+
+import { buildComposeCall } from "./build-compose-call.js";
+import { getKontorAction } from "../../../utils/get-action.js";
+import type { ComposeOutputs, ResultResponse } from "../../../types/kontor.js";
+
+export type CallProcParameters<
+  _chain extends Chain | undefined = Chain | undefined,
+> = {
+  address?: Address;
+  xOnlyPubKey?: XOnlyPubKey; // TODO: maybe this should be wrapped in a single object
+  utxos: UtxoId[];
+  contractAddress: ResolvedRegister["contractAddress"];
+  wave: string;
+  gas: bigint;
+  satsPerVByte: number;
+};
+
+// TODO: organize these types or just refernece direc
+export interface TapLeafScript {
+  leafVersion: number;
+  script: number[];
+  controlBlock: number[];
+}
+
+export type CallProcReturnType = ResultResponse<ComposeOutputs>;
+
+export async function callProc<
+  chain extends Chain | undefined = Chain | undefined,
+>(
+  client: KontorPublicClient<HttpTransport, chain>,
+  params: CallProcParameters<chain>,
+): Promise<CallProcReturnType> {
+  const account = client.account;
+
+  const {
+    contractAddress,
+    wave,
+    gas,
+    utxos,
+    address = account?.address,
+    xOnlyPubKey = account?.xOnlyPubKey,
+    satsPerVByte,
+  } = params;
+
+  if (!xOnlyPubKey) {
+    // TODO: add custom error
+    throw new Error("x_only_public_key is required");
+  }
+
+  if (!address) {
+    // TODO: add custom error
+    throw new Error("address is required");
+  }
+
+  if (utxos.length === 0) {
+    // TODO: add custom error
+    throw new Error("at least one funding UTXO is required");
+  }
+  // TODO: wrap in try-catch
+
+  const composeCall = await getKontorAction(
+    client,
+    buildComposeCall,
+    "buildComposeCall",
+  )({
+    contractAddress,
+    wave,
+    gas,
+    utxos,
+    xOnlyPubKey,
+    address,
+    satsPerVByte,
+  });
+
+  console.log(client);
+  console.log(composeCall);
+
+  const response = await client.request({
+    route: "/transactions/compose",
+    method: "POST",
+    // TODO: body type checking is broken
+    body: composeCall,
+  });
+  console.log("resopnse", response);
+
+  return response;
+}

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

@@ -0,0 +1,54 @@
+import type { ResolvedRegister } from "../../../../wit/register.js";
+import type { KontorPublicClient } from "../../../clients/kontor/create-public-client.js";
+import type { HttpTransport } from "../../../clients/transports/create-http-transport.js";
+import type { Chain } from "../../../types/chain.js";
+
+export type CallViewParameters<
+  _chain extends Chain | undefined = Chain | undefined,
+> = {
+  contractAddress: ResolvedRegister["contractAddress"];
+  wave: string;
+};
+
+// TODO: refine this type
+export type CallViewReturnType =
+  | {
+      result: {
+        Ok: {
+          value: string;
+        };
+      };
+    }
+  | {
+      result: {
+        Err: unknown;
+      };
+    };
+
+export async function callView<
+  chain extends Chain | undefined = Chain | undefined,
+>(
+  client: KontorPublicClient<HttpTransport, chain>,
+  params: CallViewParameters<chain>,
+): Promise<CallViewReturnType> {
+  const { contractAddress, wave } = params;
+
+  try {
+    const response = await client.request({
+      route: "/contracts/:contractAddress",
+      method: "POST",
+      path: { contractAddress },
+      // TODO: body tdype checking is busted
+      body: { expr: wave },
+    });
+
+    console.log("callView response:", response);
+
+    // TODO: fix CallViwewReturnType
+    // @ts-ignore
+    return response;
+  } catch (e) {
+    // TODO: augment error handling
+    throw e;
+  }
+}

package/src/sdk/actions/kontor/public/inspect.ts

@@ -0,0 +1,39 @@
+import type {
+  OpWithResult,
+  ResultResponse,
+  TransactionHex,
+} from "../../../types/kontor.js";
+import type { KontorPublicClient } from "../../../clients/kontor/create-public-client.js";
+import type { HttpTransport } from "../../../clients/transports/create-http-transport.js";
+import type { Chain } from "../../../types/chain.js";
+
+export type InspectParameters = TransactionHex;
+
+export type InspectReturnType = ResultResponse<OpWithResult[]>;
+
+export async function inspect<
+  chain extends Chain | undefined = Chain | undefined,
+>(
+  client: KontorPublicClient<HttpTransport, chain>,
+  params: InspectParameters,
+): Promise<InspectReturnType> {
+  const { hex } = params;
+
+  try {
+    const response = await client.request({
+      route: "/transactions/inspect",
+      method: "POST",
+      // TODO: body tdype checking is busted
+      body: { hex: hex },
+    });
+
+    console.log("callView response:", response);
+
+    // TODO: fix CallViwewReturnType
+    // @ts-ignore
+    return response;
+  } catch (e) {
+    // TODO: augment error handling
+    throw e;
+  }
+}

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

@@ -0,0 +1,52 @@
+import { test } from "vitest";
+// import { procContract } from "./proc-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";
+
+// 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);
+
+test("e2e", async () => {
+  const client = createPublicClient({
+    transport: http("https://signet.kontor.network:35000/api"),
+    // optional parameter
+    account: [
+      "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
+      "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
+    ],
+  });
+
+  // proc contract action defined on client
+  // response is correctly typed
+  const res = await client.procContract({
+    wit: wit,
+    // can also be injected
+
+    functionName: "mint", // functin name is only valid if it's got a proc-context
+    contractAddress: "token_0_0",
+    args: [[7n, 18]],
+    satsPerVByte: 1,
+    utxos: [
+      "57f1f46857ab12e20f32ecaac780b4096b0951458e15ab08e2ce0992f0521323:0",
+    ],
+    gas: 10n,
+  });
+
+  console.log({ callproc: res.result });
+});