@kontor/kontor-sdk 1.0.0-alpha.0

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

@@ -0,0 +1,113 @@
+import type { Wit } from "../../../../wit/wit.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 {
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
+} from "../../../types/contract.js";
+import type { Address, UtxoId, XOnlyPubKey } from "../../../types/misc.js";
+import { getKontorAction } from "../../../utils/get-action.js";
+import {
+  encodeFunctionData,
+  type EncodeFunctionDataParameters,
+} from "../../../utils/wit/encode-function-data.js";
+import { callProc, type CallProcReturnType } from "./call-proc.js";
+
+export type ProcContractParameters<
+  wit extends Wit | readonly unknown[] = Wit,
+  functionName extends ContractFunctionName<wit, "proc"> = ContractFunctionName<
+    wit,
+    "proc"
+  >,
+  args extends ContractFunctionArgs<
+    wit,
+    "proc",
+    functionName
+  > = ContractFunctionArgs<wit, "proc", functionName>,
+> = ContractFunctionParameters<wit, "proc", functionName, args> & {
+  address?: Address;
+  xOnlyPubKey?: XOnlyPubKey;
+  utxos: UtxoId[];
+  gas: bigint;
+  satsPerVByte: number;
+};
+
+export type ProcContractReturnType = CallProcReturnType;
+
+export async function procContract<
+  // chain exhttps://viem.sh/tends Chain | undefined,
+  chain extends Chain | undefined,
+  const wit extends Wit | readonly unknown[],
+  functionName extends ContractFunctionName<wit, "proc">,
+  const args extends ContractFunctionArgs<wit, "proc", functionName>,
+>(
+  client: KontorPublicClient<HttpTransport, chain>,
+  parameters: ProcContractParameters<wit, functionName, args>,
+): Promise<ProcContractReturnType> {
+  const {
+    wit: wit,
+    contractAddress,
+    args,
+    functionName,
+    utxos,
+    gas,
+    satsPerVByte,
+    address = client.account?.address,
+    xOnlyPubKey = client.account?.xOnlyPubKey,
+    // @ts-ignore
+    ...rest
+  } = parameters as ProcContractParameters;
+
+  // @ts-ignore
+  const wave = encodeFunctionData({
+    wit: wit,
+    args,
+    functionName,
+  } as EncodeFunctionDataParameters);
+
+  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");
+  }
+
+  try {
+    const response = await getKontorAction(
+      client,
+      callProc,
+      "callProc",
+    )({
+      contractAddress: contractAddress,
+      wave: wave,
+      utxos,
+      satsPerVByte,
+      address,
+      xOnlyPubKey,
+      gas,
+    });
+
+    return response;
+  } catch (error) {
+    console.log(error);
+    throw error;
+    // throw getContractError(error as BaseError, {
+    //
+    //   abi: wit,
+    //   address,
+    //   args,
+    //   docsPath: "/docs/contract/readContract",
+    //   functionName,
+    // });
+  }
+}

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

@@ -0,0 +1,48 @@
+import { test } from "vitest";
+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";
+
+// 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-staging.kontor.network:35000/api"),
+  });
+
+  // view contract action defined on client
+  // response is correctly typed
+  const res = await client.viewContract({
+    wit: wit,
+    functionName: "balances", // functin name is only valid if it's got a view-context
+    contractAddress: "token_0_0",
+  });
+
+  console.log("res:", res);
+  // inject client directly into view contract action
+  const res2 = await viewContract(client, {
+    wit: wit,
+    functionName: "balance",
+    contractAddress: "token_0_0",
+    args: ["252a90b16b5c25b9f366ab4b518f9f2ce3624d23c05dc26f7649f51515c76e2d"],
+  });
+
+  console.log("res2:", res2);
+});

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

@@ -0,0 +1,107 @@
+import type { Wit } from "../../../../wit/wit.js";
+import type { Prettify } from "../../../../wit/type-utils.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 {
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
+  ContractFunctionReturnType,
+} from "../../../types/contract.js";
+import { getKontorAction } from "../../../utils/get-action.js";
+import { decodeFunctionResult } from "../../../utils/wit/decode-function-result.js";
+// import { getAction } from "../../utils/getAction.js";
+import {
+  encodeFunctionData,
+  type EncodeFunctionDataParameters,
+} from "../../../utils/wit/encode-function-data.js";
+import { callView } from "./call-view.js";
+
+export type ViewContractParameters<
+  wit extends Wit | readonly unknown[] = Wit,
+  functionName extends ContractFunctionName<wit, "view"> = ContractFunctionName<
+    wit,
+    "view"
+  >,
+  args extends ContractFunctionArgs<
+    wit,
+    "view",
+    functionName
+  > = ContractFunctionArgs<wit, "view", functionName>,
+> = ContractFunctionParameters<wit, "view", functionName, args>;
+
+export type ViewContractReturnType<
+  wit extends Wit | readonly unknown[] = Wit,
+  functionName extends ContractFunctionName<wit, "view"> = ContractFunctionName<
+    wit,
+    "view"
+  >,
+  args extends ContractFunctionArgs<
+    wit,
+    "view",
+    functionName
+  > = ContractFunctionArgs<wit, "view", functionName>,
+  // TODO: not 100% sure if this is optimal place to prettify
+> = Prettify<ContractFunctionReturnType<wit, "view", functionName, args>>;
+
+export async function viewContract<
+  // chain exhttps://viem.sh/tends Chain | undefined,
+  chain extends Chain | undefined,
+  const wit extends Wit | readonly unknown[],
+  functionName extends ContractFunctionName<wit, "view">,
+  const args extends ContractFunctionArgs<wit, "view", functionName>,
+>(
+  client: KontorPublicClient<HttpTransport, chain>,
+  parameters: ViewContractParameters<wit, functionName, args>,
+): Promise<ViewContractReturnType<wit, functionName, args>> {
+  const {
+    wit: wit,
+    contractAddress,
+    args,
+    functionName,
+
+    // @ts-ignore
+    ...rest
+  } = parameters as ViewContractParameters;
+
+  // @ts-ignore
+  const wave = encodeFunctionData({
+    wit: wit,
+    args,
+    functionName,
+  } as EncodeFunctionDataParameters);
+
+  try {
+    const response = await getKontorAction(
+      client,
+      callView,
+      "callView",
+    )({
+      contractAddress: contractAddress,
+      wave: wave,
+    });
+
+    if ("Err" in response.result) {
+      throw new Error("Contract view call failed");
+    }
+
+    const value = response.result.Ok.value;
+
+    return decodeFunctionResult({
+      wit: wit,
+      functionName,
+      data: value,
+    }) as ViewContractReturnType<wit, functionName>;
+    //
+  } catch (error) {
+    throw new Error("problems");
+    // throw getContractError(error as BaseError, {
+    //   abi: wit,
+    //   address,
+    //   args,
+    //   docsPath: "/docs/contract/readContract",
+    //   functionName,
+    // });
+  }
+}

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

@@ -0,0 +1,73 @@
+import { Transaction } from "@scure/btc-signer";
+import { hex } from "@scure/base";
+import type { Account } from "../../../accounts/types.js";
+import type { KontorWalletClient } from "../../../clients/kontor/create-wallet-client.js";
+import type { RpcTransport } from "../../../clients/transports/create-rpc-transport.js";
+import type { GetAccountParameter } from "../../../types/account.js";
+import type { Chain, GetChainParameter } from "../../../types/chain.js";
+import { getAction } from "../../..//utils/get-action.js";
+import { signPsbt } from "../../wallet/sign-psbt.js";
+import { parseAccount } from "../../../accounts/utils/parse-account.js";
+
+export type SignCommitParameters<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+> = GetAccountParameter<account> &
+  // TODO: add chainoverride?
+  GetChainParameter<chain> & { psbt: string };
+
+export type SignCommitReturnType = Transaction;
+
+export async function signCommit<
+  // @ts-ignore
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: KontorWalletClient<RpcTransport, chain, account>,
+  parameters: SignCommitParameters<chain, account>,
+): Promise<SignCommitReturnType> {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    ...params
+  } = parameters;
+
+  if (!account_) throw new Error("AccountNotFoundError");
+
+  const account = parseAccount(account_);
+
+  // TODO: assertRequest(account, paramatetrs )
+  // TODO: assertCurrentChain(chanId, chain)
+
+  const tx = Transaction.fromPSBT(hex.decode(params.psbt));
+  const signInputs = Array.from(
+    {
+      length: tx.inputsLength,
+    },
+    (_, i) => i,
+  );
+
+  let signed = account.signPsbt
+    ? await account.signPsbt({
+        psbt: params.psbt,
+        signInputs,
+        broadcast: false,
+      })
+    : await getAction(
+        client,
+        signPsbt,
+        "signPsbt",
+      )({
+        account: account,
+        chain: chain,
+        psbt: params.psbt,
+        signInputs: signInputs,
+        broadcast: false,
+      });
+
+  const signedTx = Transaction.fromPSBT(hex.decode(signed.psbt as string));
+
+  signedTx.finalize();
+
+  return signedTx;
+}

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

@@ -0,0 +1,134 @@
+// TODO: refine this type
+import type { Account } from "../../../accounts/types.js";
+import { parseAccount } from "../../../accounts/utils/parse-account.js";
+import type { KontorWalletClient } from "../../../clients/kontor/create-wallet-client.js";
+import type { RpcTransport } from "../../../clients/transports/create-rpc-transport.js";
+import type { GetAccountParameter } from "../../../types/account.js";
+import type { Chain, GetChainParameter } from "../../../types/chain.js";
+import { getAction } from "../../../utils/get-action.js";
+import { signPsbt } from "../../wallet/sign-psbt.js";
+import { p2tr, taprootListToTree, Transaction } from "@scure/btc-signer";
+import { hex } from "@scure/base";
+import type { ParticipantScripts } from "@kontor/kontor-ts";
+
+export type SignRevealParameters<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+> = GetAccountParameter<account> &
+  // TODO: add chainoverride?
+  GetChainParameter<chain> & {
+    psbt: string;
+    parcipantScripts: ParticipantScripts[];
+  };
+
+export type SignRevealReturnType = Transaction;
+
+export async function signReveal<
+  // @ts-ignore
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: KontorWalletClient<RpcTransport, chain, account>,
+  parameters: SignRevealParameters<chain, account>,
+): Promise<SignRevealReturnType> {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    ...params
+  } = parameters;
+
+  if (!account_) throw new Error("AccountNotFoundError");
+
+  const account = parseAccount(account_);
+
+  // TODO: assertRequest(account, paramatetrs )
+  // TODO: assertCurrentChain(chanId, chain)
+
+  const tx = Transaction.fromPSBT(hex.decode(params.psbt), {
+    allowUnknownInputs: true,
+  });
+
+  for (let i = 0; i < params.parcipantScripts.length; i++) {
+    const { commit_tap_leaf_script } = params.parcipantScripts[i]!;
+
+    const tree = taprootListToTree([
+      {
+        // TODO: fix this type error
+        // @ts-ignore
+        script: hex.decode(commit_tap_leaf_script.script),
+        leafVersion: commit_tap_leaf_script.leafVersion,
+      },
+    ]);
+
+    const payment = p2tr(
+      // @ts-ignore
+      undefined,
+      tree,
+      // TODO: must assert chain or default to mainnet
+      chain!.networkConfig,
+      true,
+    );
+
+    tx.updateInput(
+      i,
+      {
+        tapLeafScript: payment.tapLeafScript!,
+        tapInternalKey: payment.tapInternalKey,
+        tapMerkleRoot: payment.tapMerkleRoot,
+      },
+      true,
+    );
+  }
+
+  const signInputs = Array.from(
+    {
+      length: tx.inputsLength,
+    },
+    (_, i) => i,
+  );
+
+  const preparedPsbt = hex.encode(tx.toPSBT());
+
+  const signed = account.signPsbt
+    ? await account.signPsbt({
+        psbt: preparedPsbt,
+        signInputs,
+        broadcast: false,
+      })
+    : await getAction(
+        client,
+        signPsbt,
+        "signPsbt",
+      )({
+        account: account,
+        chain: chain,
+        psbt: preparedPsbt,
+        signInputs: signInputs,
+        broadcast: false,
+      });
+
+  const signedTx = Transaction.fromPSBT(hex.decode(signed.psbt as string), {
+    allowUnknownInputs: true,
+  });
+
+  // this is technically unnecessary as scure/btc-signer
+  // will product this witness by default
+  for (let i = 0; i < params.parcipantScripts.length; i++) {
+    const input = signedTx.getInput(i);
+    const p = params.parcipantScripts[i]!;
+    console.log({ input, tapscriptsig: input.tapScriptSig });
+    signedTx.updateInput(i, {
+      finalScriptWitness: [
+        input.tapScriptSig![0]![1],
+        // @ts-ignore
+        hex.decode(p.commit_tap_leaf_script.script),
+        // @ts-ignore
+        hex.decode(p.commit_tap_leaf_script.controlBlock),
+      ],
+    });
+  }
+
+  signedTx.finalize();
+
+  return signedTx;
+}

package/src/sdk/actions/public/send-raw-transaction.ts

@@ -0,0 +1,26 @@
+import type { Chain } from "../../types/chain.js";
+
+import type { RpcTransport } from "../../clients/transports/create-rpc-transport.js";
+import type { PublicClient } from "../../clients/create-public-client.js";
+import type { Account } from "../../accounts/types.js";
+
+export interface SendRawTransactionParams {
+  hex: string;
+  maxFeeRate?: number | string;
+}
+export interface SendRawTransactionReturnType {
+  txid: string;
+}
+
+export async function sendRawTransaction<
+  chain extends Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+>(
+  client: PublicClient<RpcTransport, chain, account>,
+  { hex, maxFeeRate }: SendRawTransactionParams,
+): Promise<SendRawTransactionReturnType> {
+  return client.request({
+    method: "sendrawtransaction",
+    params: maxFeeRate ? [hex, maxFeeRate] : [hex],
+  });
+}

package/src/sdk/actions/public/test-mempool-accept.ts

@@ -0,0 +1,43 @@
+// import type { Chain } from "../../types/chain.js";
+//
+// import type { RpcTransport } from "../../clients/transports/create-rpc-transport.js";
+// import type { PublicClient } from "../../clients/create-public-client.js";
+// import type { Account } from "../../accounts/types.js";
+//
+// export type TestMempoolAcceptOptions = {
+//   /** Max feerate in BTC/kvB. If omitted, Core uses default relay feerate. */
+//   maxfeerate?: string | number;
+// };
+//
+// export interface TestMempoolAcceptParams {
+//   rawtx: string | string[];
+//   options: TestMempoolAcceptOptions;
+// }
+// export type TestMempoolAcceptReturnType = any;
+//
+// export async function testMempoolAccept<
+//   chain extends Chain | undefined,
+//   account extends Account | undefined = Account | undefined,
+// >(
+//   client: PublicClient<RpcTransport, chain, account>,
+//   { rawtx, options = {} }: TestMempoolAcceptParams,
+// ): Promise<TestMempoolAcceptReturnType> {
+//   const txs = Array.isArray(rawtx) ? rawtx : [rawtx];
+//
+//   return client.request({
+//     method: "testmempoolaccept",
+//     params: [txs],
+//   });
+// }
+
+// export async function testMempoolAccept(
+//   rawtx: string | string[],
+//   options: TestMempoolAcceptOptions = {}
+// ): Promise<TestMempoolAcceptResult[]> {
+//   const txs = Array.isArray(rawtx) ? rawtx : [rawtx];
+//
+//   const params =
+//     options.maxfeerate !== undefined ? [txs, { maxfeerate: options.maxfeerate }] : [txs];
+//
+//   return rpcCall<TestMempoolAcceptResult[]>("testmempoolaccept", params);
+// }

package/src/sdk/actions/wallet/get-addresses.ts

@@ -0,0 +1,33 @@
+import type { Account } from "../../accounts/types.js";
+import type { WalletClient } from "../../clients/create-wallet-client.js";
+import type { RpcTransport } from "../../clients/transports/create-rpc-transport.js";
+import type { Chain } from "../../types/chain.js";
+import type { GetAddressesReturnType as GetAddressesReturnType_ } from "../../types/wbip001.js";
+
+export type GetAddressesReturnType = GetAddressesReturnType_;
+
+export async function getAddresses<
+  chain extends Chain | undefined,
+  account extends Account | undefined = undefined,
+>(
+  client: WalletClient<RpcTransport, chain, account>,
+): Promise<GetAddressesReturnType_> {
+  if (client.account?.type === "local")
+    return {
+      result: {
+        addresses: [
+          {
+            address: client.account.address,
+            publicKey: client.account.xOnlyPubKey,
+            // TODO: add type
+          },
+        ],
+      },
+    };
+  const addresses = await client.request({
+    method: "getAddresses",
+    params: undefined,
+  });
+
+  return addresses;
+}

package/src/sdk/actions/wallet/sign-psbt.ts

@@ -0,0 +1,67 @@
+import type { Hex } from "@scure/btc-signer/utils.js";
+import type { Account } from "../../accounts/types.js";
+import { parseAccount } from "../../accounts/utils/parse-account.js";
+import type { WalletClient } from "../../clients/create-wallet-client.js";
+import type { RpcTransport } from "../../clients/transports/create-rpc-transport.js";
+import type { GetAccountParameter } from "../../types/account.js";
+import type { Chain, GetChainParameter } from "../../types/chain.js";
+import type { SignPsbtParams } from "../../types/wbip001.js";
+
+export type SignPsbtParameters<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+> = GetAccountParameter<account> &
+  // TODO: add chainoverride?
+  GetChainParameter<chain> &
+  SignPsbtParams;
+
+export type SignPsbtReturnType = {
+  txid: string;
+  psbt: Hex;
+};
+
+export async function signPsbt<
+  // @ts-ignore
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: WalletClient<RpcTransport, chain, account>,
+  parameters: SignPsbtParameters<chain, account>,
+): Promise<SignPsbtReturnType> {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    ...params
+  } = parameters;
+
+  if (!account_) throw new Error("AccountNotFoundError");
+
+  const account = parseAccount(account_);
+
+  // TODO: assertRequest(account, paramatetrs )
+  // TODO: assertCurrentChain(chanId, chain)
+
+  if (account.signPsbt) {
+    const res = await account.signPsbt({
+      psbt: params.psbt,
+      broadcast: params.broadcast,
+      signInputs: params.signInputs,
+    });
+    return res;
+  }
+
+  const res = await client.request(
+    {
+      method: "signPsbt",
+      params: {
+        psbt: params.psbt,
+        broadcast: params.broadcast,
+        signInputs: params.signInputs,
+      },
+    },
+    { retryCount: 0 },
+  );
+
+  // TODO: handle errors here
+  return res.result;
+}

package/src/sdk/chains/definitions/index.ts

@@ -0,0 +1 @@
+export { signet } from "./signet.js";

package/src/sdk/chains/definitions/signet.ts

@@ -0,0 +1,36 @@
+import { defineChain } from "../../utils/chain/defineChain.js";
+
+export const signet = defineChain({
+  id: 0,
+  name: "signet",
+  nativeCurrency: { name: "Kontor", symbol: "KOR", decimals: 18 },
+  blockTime: 1_000 * 60 * 10,
+  urls: {
+    default: {
+      http: ["https://signet-staging.kontor.network:35000/api"],
+      webSocket: ["wss://signet-staging.kontor.network:35000/ws"],
+      // TODO: maybe need to add auth
+      bitcoinRpc: ["https://signet-staging.kontor.network:38332"],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: "mempool.space",
+      url: "https://mempool.space/signet",
+      apiUrl: "https://mempool.space/signet/api",
+    },
+  },
+  contracts: {
+    nativeToken: {
+      name: "token",
+      blockHeight: 0,
+      txIndex: 0,
+    },
+  },
+  networkConfig: {
+    bech32: "tb",
+    pubKeyHash: 0x6f, // 111 in decimal
+    scriptHash: 0xc4, // 196 in decimal
+    wif: 0xef, // 239 in decimal
+  },
+});