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

package/src/sdk/utils/chain/assert-current-chain.ts

@@ -0,0 +1,28 @@
+import {
+  ChainMismatchError,
+  type ChainMismatchErrorType,
+  ChainNotFoundError,
+  type ChainNotFoundErrorType,
+} from "../../errors/chain.js";
+
+import type { ErrorType } from "../../errors/utils.js";
+import type { Chain } from "../../types/chain.js";
+
+export type AssertCurrentChainParameters = {
+  chain?: Chain | undefined;
+  currentChain: Chain;
+};
+
+export type AssertCurrentChainErrorType =
+  | ChainNotFoundErrorType
+  | ChainMismatchErrorType
+  | ErrorType;
+
+export function assertCurrentChain({
+  chain,
+  currentChain,
+}: AssertCurrentChainParameters): void {
+  if (!chain) throw new ChainNotFoundError();
+  if (currentChain.name !== chain.name)
+    throw new ChainMismatchError({ chain, currentChain });
+}

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

@@ -0,0 +1,33 @@
+import type { Address, UtxoId, XOnlyPubKey } from "../../types/misc.js";
+import type { ComposeQuery } from "@kontor/kontor-ts";
+import type { Inst } from "../../../sdk/types/kontor.js";
+import { buildInstructionQuery } from "./build-instruction-query.js";
+
+export type BuildComposeQueryParameters = {
+  instruction: Inst;
+  address: Address;
+  xOnlyPubKey: XOnlyPubKey; // TODO: maybe this should be wrapped in a single object
+  utxos: UtxoId[];
+  satsPerVByte: number;
+};
+
+export type BuildComposeQueryReturnType = ComposeQuery;
+
+export function buildComposeQuery(
+  params: BuildComposeQueryParameters,
+): BuildComposeQueryReturnType {
+  const { instruction: inst, utxos, address, xOnlyPubKey } = params;
+
+  const instruction = buildInstructionQuery({
+    instruction: inst,
+    utxos,
+    xOnlyPubKey,
+    address,
+  });
+
+  return {
+    instructions: [instruction],
+    sat_per_vbyte: params.satsPerVByte,
+    envelope: null,
+  };
+}

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/wit/type-utils.ts

@@ -40,8 +40,6 @@ export type OneOf<
   : never;
 type KeyofUnion<type> = type extends type ? keyof type : never;
 
-// from viem: https://github.com/wevm/viem/blob/320895cf0e6c654b419d8d61a59c4e7b46674368/src/types/utils.ts#L58
-
 export type IsNever<T> = [T] extends [never] ? true : false;
 
 export type IsNarrowable<T, U> =

package/src/wit/utils.ts

@@ -264,8 +264,7 @@ type _TypedDataParametersToWitParameters<
       name: string;
       type: unknown;
     }
-    ? // 1. Check if type is record
-      typedDataParameter["type"] extends keyof typedData & string
+    ? typedDataParameter["type"] extends keyof typedData & string
       ? {
           name: typedDataParameter["name"];
           type: "tuple";
@@ -277,8 +276,7 @@ type _TypedDataParametersToWitParameters<
                 keyReferences & { [_ in typedDataParameter["type"]]: true }
               >;
         }
-      : // 2. Check if type is array of structs
-        typedDataParameter["type"] extends `${infer type extends
+      : typedDataParameter["type"] extends `${infer type extends
             keyof typedData & string}[${infer tail}]`
         ? {
             name: typedDataParameter["name"];
@@ -291,7 +289,6 @@ type _TypedDataParametersToWitParameters<
                   keyReferences & { [_ in type]: true }
                 >;
           }
-        : // 3. Type is already ABI parameter
-          typedDataParameter
+        : typedDataParameter
     : never;
 };