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

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

@@ -15,12 +15,23 @@ import type {
   ContractFunctionName,
 } from "../types/contract.js";
 
-// import { getAction } from "../utils/getAction.js";
+import { getKontorAction } from "../utils/get-action.js";
 import {
+  viewContract,
   // viewContract,
   type ViewContractParameters,
   type ViewContractReturnType,
 } from "./kontor/public/view-contract.js";
+import type { HttpTransport } from "../clients/transports/create-http-transport.js";
+import type { Chain } from "../types/chain.js";
+import type { Account } from "../accounts/types.js";
+import type { KontorPublicClient } from "../clients/kontor/create-public-client.js";
+import type { ResolvedRegister } from "../../wit/register.js";
+import {
+  procContract,
+  type ProcContractParameters,
+  type ProcContractReturnType,
+} from "./kontor/public/proc-contract.js";
 
 // TODO: move to utils
 function camelToKebab(str: string): string {
@@ -32,45 +43,29 @@ export type KebabToCamel<S extends string> =
     ? `${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 GetContractParameters<
+  transport extends HttpTransport = HttpTransport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  wit extends Wit | readonly unknown[] = Wit,
+  client extends KontorPublicClient<
+    transport,
+    chain,
+    account
+  > = KontorPublicClient<transport, chain, account>,
+  contractAddress extends
+    ResolvedRegister["contractAddress"] = ResolvedRegister["contractAddress"],
+> = {
+  wit: wit;
+  contractAddress: contractAddress;
+  client: client;
+};
 
 export type GetContractReturnType<
   wit extends Wit | readonly unknown[] = Wit,
+  client extends KontorPublicClient = KontorPublicClient,
+  contractAddress extends
+    ResolvedRegister["contractAddress"] = ResolvedRegister["contractAddress"],
   _viewFunctionNames extends string = wit extends Wit
     ? Wit extends wit
       ? string
@@ -85,74 +80,300 @@ export type GetContractReturnType<
 > = {
   view: {
     // K is the *original* wit function name ("cached-values")
-    [K in _viewFunctionNames as KebabToCamel<K>]: GetViewFunction<
+    [functionName in _viewFunctionNames as KebabToCamel<functionName>]: GetViewFunction<
       _narrowable,
+      client["chain"],
       wit,
       // and we pass K directly into GetViewFunction
-      K extends ContractFunctionName<wit, "view"> ? K : never
+      functionName extends ContractFunctionName<wit, "view">
+        ? functionName
+        : never
     >;
   };
+  proc: {
+    // K is the *original* wit function name ("cached-values")
+    [functionName in _procFunctionNames as KebabToCamel<functionName>]: GetProcFunction<
+      _narrowable,
+      client["chain"],
+      client["account"],
+      wit,
+      // and we pass K directly into GetProcFunction
+      functionName extends ContractFunctionName<wit, "proc">
+        ? functionName
+        : never
+    >;
+  };
+  contractAddress: contractAddress;
+  wit: wit;
 };
 
-export function getContract<const wit extends Wit | readonly unknown[]>({
-  wit: wit,
-}: GetContractParameters<wit>): GetContractReturnType<wit> {
-  const hasPublicClient = true;
+type ViewOptions<
+  wit extends Wit | readonly unknown[],
+  functionName extends ContractFunctionName<wit, "view">,
+  args extends ContractFunctionArgs<wit, "view", functionName>,
+  chain extends Chain | undefined,
+  chainOverride extends Chain | undefined,
+> = Prettify<
+  UnionOmit<
+    ViewContractParameters<wit, functionName, args, chain, chainOverride>,
+    "wit" | "contractAddress" | "args" | "functionName"
+  >
+>;
 
+type OptTuple<chain extends Chain | undefined, O> = chain extends Chain
+  ? [options?: O]
+  : [options: O];
+
+export type GetViewFunction<
+  narrowable extends boolean,
+  chain extends Chain | undefined,
+  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"]>,
+> = narrowable extends true
+  ? <chainOverride extends Chain | undefined = undefined>(
+      ...parameters: _args extends readonly []
+        ? OptTuple<
+            chain,
+            ViewOptions<wit, functionName, args, chain, chainOverride>
+          >
+        : [
+            args: _args,
+            ...options: OptTuple<
+              chain,
+              ViewOptions<wit, functionName, args, chain, chainOverride>
+            >,
+          ]
+    ) => Promise<ViewContractReturnType<wit, functionName, args>>
+  : <chainOverride extends Chain | undefined = undefined>(
+      ...parameters:
+        | OptTuple<
+            chain,
+            ViewOptions<wit, functionName, args, chain, chainOverride>
+          >
+        | [
+            args: readonly unknown[],
+            ...options: OptTuple<
+              chain,
+              ViewOptions<wit, functionName, args, chain, chainOverride>
+            >,
+          ]
+    ) => Promise<ViewContractReturnType>;
+
+// export type GetViewFunction<
+//   narrowable extends boolean,
+//   chain extends Chain | undefined,
+//   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"]>,
+// > = narrowable extends true
+//   ? <
+//       chainOverride extends Chain | undefined,
+//       options extends Prettify<
+//         UnionOmit<
+//           ViewContractParameters<wit, functionName, args, chain, chainOverride>,
+//           "wit" | "contractAddress" | "args" | "functionName"
+//         >
+//       >,
+//     >(
+//       ...parameters: _args extends readonly []
+//         ? chain extends Chain
+//           ? [options?: options]
+//           : [options: options]
+//         : [args: _args, options?: options]
+//     ) => Promise<ViewContractReturnType<wit, functionName, args>>
+//   : <
+//       chainOverride extends Chain | undefined,
+//       options extends Prettify<
+//         UnionOmit<
+//           ViewContractParameters<wit, functionName, args, chain, chainOverride>,
+//           "wit" | "contractAddress" | "args" | "functionName"
+//         >
+//       >,
+//       Rest extends unknown[] = [options: options],
+//     >(
+//       ...parameters: chain extends Chain
+//         ? [options?: options] | [args: readonly unknown[], ...parameters: Rest]
+//         : [options: options] | [args: readonly unknown[], ...parameters: Rest]
+//     ) => Promise<ViewContractReturnType>;
+
+export type GetProcFunction<
+  narrowable extends boolean,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  wit extends Wit | readonly unknown[],
+  functionName extends ContractFunctionName<wit, "proc">,
+  args extends ContractFunctionArgs<
+    wit,
+    "proc",
+    functionName
+  > = ContractFunctionArgs<wit, "proc", functionName>,
+  witFunction extends WitFunction = wit extends Wit
+    ? ExtractWitFunction<wit, functionName>
+    : WitFunction,
+  //
+  _args = WitParametersToPrimitiveTypes<witFunction["inputs"]>,
+> = narrowable extends true
+  ? <
+      chainOverride extends Chain | undefined,
+      options extends Prettify<
+        UnionOmit<
+          ProcContractParameters<
+            wit,
+            functionName,
+            args,
+            chain,
+            account,
+            chainOverride
+          >,
+          "wit" | "contractAddress" | "args" | "functionName"
+        >
+      >,
+    >(
+      ...parameters: _args extends readonly []
+        ? [options: options]
+        : [args: _args, options: options]
+    ) => Promise<ProcContractReturnType>
+  : <
+      chainOverride extends Chain | undefined,
+      options extends Prettify<
+        UnionOmit<
+          ProcContractParameters<
+            wit,
+            functionName,
+            args,
+            chain,
+            account,
+            chainOverride
+          >,
+          "contractAddress" | "args" | "functionName"
+        >
+      >,
+      Rest extends unknown[] = [options: options],
+    >(
+      ...parameters:
+        | [options: options]
+        | [args: readonly unknown[], ...parameters: Rest]
+    ) => Promise<ProcContractReturnType>;
+
+export function getContract<
+  transport extends HttpTransport,
+  contractAddress extends ResolvedRegister["contractAddress"],
+  const wit extends Wit | readonly unknown[],
+  const client extends KontorPublicClient<transport, chain, account>,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+>({
+  wit,
+  contractAddress,
+  client: client_,
+}: GetContractParameters<
+  transport,
+  chain,
+  account,
+  wit,
+  client,
+  contractAddress
+>): GetContractReturnType<wit, client, contractAddress> {
   const contract: {
-    [_ in "wit" | "view"]?: unknown;
+    [_ in "wit" | "contractAddress" | "view" | "proc"]?: 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);
-            };
-          },
-        },
-      );
-    }
-  }
+  console.log("we are defining a proxy");
+
+  contract.view = new Proxy(
+    {},
+    {
+      get(_, functionName: string) {
+        const witFunctionName = camelToKebab(functionName);
+
+        return (
+          ...parameters: [
+            args?: readonly unknown[] | undefined,
+            options?: UnionOmit<
+              ViewContractParameters,
+              "wit" | "contractAddress" | "functionName" | "args"
+            >,
+          ]
+        ) => {
+          const { args, options } = getFunctionParameters(parameters);
+
+          return getKontorAction(
+            client_,
+            viewContract,
+            "viewContract",
+          )({
+            wit,
+            functionName: witFunctionName,
+            contractAddress,
+            // address,
+            args,
+            ...options,
+          } as ViewContractParameters);
+        };
+      },
+    },
+  );
+
+  contract.proc = new Proxy(
+    {},
+    {
+      get(_, functionName: string) {
+        const witFunctionName = camelToKebab(functionName);
+
+        return (
+          ...parameters: [
+            args?: readonly unknown[] | undefined,
+            options?: UnionOmit<
+              ProcContractParameters,
+              "wit" | "contractAddress" | "functionName" | "args"
+            >,
+          ]
+        ) => {
+          const { args, options } = getFunctionParameters(parameters);
+
+          return getKontorAction(
+            client_,
+            procContract,
+            "procContract",
+          )({
+            wit,
+            functionName: witFunctionName,
+            contractAddress,
+            args,
+
+            ...options,
+          } as any);
+        };
+      },
+    },
+  );
 
   contract.wit = wit;
+  contract.contractAddress = contractAddress;
 
-  return contract as unknown as GetContractReturnType<wit>;
+  return contract as unknown as GetContractReturnType<
+    wit,
+    client,
+    contractAddress
+  >;
 }
 
 export function getFunctionParameters(

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

@@ -1,4 +1,3 @@
-// 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";
@@ -7,42 +6,40 @@ import { buildInstructionQuery } from "./build-instruction-query.js";
 import { getKontorAction } from "../../../utils/get-action.js";
 import type { ComposeQuery } from "@kontor/kontor-ts";
 import type { Inst } from "../../../../sdk/types/kontor.js";
+import type { GetAccountParameter } from "../../../../sdk/types/account.js";
 
+import type { Account } from "../../../accounts/types.js";
+import { parseAccount } from "../../../accounts/utils/parse-account.js";
 export type BuildComposeQueryParameters<
-  _chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  accountOverride extends Account | [Address, XOnlyPubKey] | undefined =
+    | Account
+    | [Address, XOnlyPubKey]
+    | undefined,
 > = {
   instruction: Inst;
-  address?: Address;
-  xOnlyPubKey?: XOnlyPubKey; // TODO: maybe this should be wrapped in a single object
   utxos: UtxoId[];
   satsPerVByte: number;
-};
-
+} & GetAccountParameter<account, accountOverride, true, true>;
 export type BuildComposeQueryReturnType = ComposeQuery;
 
-export async function buildComposeQuery<
-  chain extends Chain | undefined = Chain | undefined,
+export function buildComposeQuery<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
   client: KontorPublicClient<HttpTransport, chain>,
-  params: BuildComposeQueryParameters<chain>,
-): Promise<BuildComposeQueryReturnType> {
-  const account = client.account;
-
+  params: BuildComposeQueryParameters<account>,
+): BuildComposeQueryReturnType {
   const {
     instruction: inst,
     utxos,
-    address = account?.address,
-    xOnlyPubKey = account?.xOnlyPubKey,
+    satsPerVByte,
+    account: account_ = client.account,
   } = params;
 
-  if (!xOnlyPubKey) {
-    // TODO: add custom error
-    throw new Error("x_only_public_key is required");
-  }
-
-  if (!address) {
+  if (!account_) {
     // TODO: add custom error
-    throw new Error("address is required");
+    throw new Error("Account is required");
   }
 
   if (utxos.length === 0) {
@@ -50,20 +47,21 @@ export async function buildComposeQuery<
     throw new Error("at least one funding UTXO is required");
   }
 
-  const instruction = await getKontorAction(
+  const account = parseAccount(account_);
+
+  const instruction = getKontorAction(
     client,
     buildInstructionQuery,
     "buildInstructionQuery",
   )({
     instruction: inst,
     utxos,
-    xOnlyPubKey,
-    address,
+    account,
   });
 
   return {
     instructions: [instruction],
-    sat_per_vbyte: params.satsPerVByte,
+    sat_per_vbyte: satsPerVByte,
     envelope: null,
   };
 }

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

@@ -2,17 +2,24 @@ import type { Inst, InstructionQuery } 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";
-import type { Address, UtxoId, XOnlyPubKey } from "../../../types/misc.js";
+import type { Address, XOnlyPubKey, UtxoId } from "../../../types/misc.js";
+import type { Account } from "../../../../sdk/accounts/types.js";
+import { buildInstructionQuery as buildInstructionQuery_ } from "../../../utils/kontor/build-instruction-query.js";
+
+import { parseAccount } from "../../../../sdk/accounts/utils/parse-account.js";
+import type { GetAccountParameter } from "../../../../sdk/types/account.js";
 
 // If InstructionQuery already uses this Inst shape internally, you don't need to touch it.
 // Otherwise you can make InstructionQuery generic over Inst and plug this in.
 export type BuildInstructionQueryReturnType = InstructionQuery;
 
 export type BuildInstructionQueryParameters<
-  _chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  accountOverride extends Account | [Address, XOnlyPubKey] | undefined =
+    | Account
+    | [Address, XOnlyPubKey]
+    | undefined,
 > = {
-  address?: Address;
-  xOnlyPubKey?: XOnlyPubKey; // TODO: maybe this should be wrapped in a single object
   utxos: UtxoId[];
   /**
    * The concrete instruction to send (Publish | Call | Issuance).
@@ -26,57 +33,25 @@ export type BuildInstructionQueryParameters<
    * 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}`;
-}
+} & GetAccountParameter<account, accountOverride, true, true>;
 
-function normalizeUtxoIds(u: UtxoId | UtxoId[]): string[] {
-  return Array.isArray(u) ? u.map(normalizeUtxoId) : [normalizeUtxoId(u)];
-}
-
-// ------------------ main builder ------------------
-
-export async function buildInstructionQuery<
-  chain extends Chain | undefined = Chain | undefined,
+export function buildInstructionQuery<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
   client: KontorPublicClient<HttpTransport, chain>,
-  params: BuildInstructionQueryParameters<chain>,
-): Promise<BuildInstructionQueryReturnType> {
-  const account = client.account;
-
+  params: BuildInstructionQueryParameters<account>,
+): BuildInstructionQueryReturnType {
   const {
     utxos,
     instruction,
     chainedInstruction = null,
-    address = account?.address,
-    xOnlyPubKey = account?.xOnlyPubKey,
+    account: account_ = client.account,
   } = params;
 
-  if (!xOnlyPubKey) {
+  if (!account_) {
     // 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");
+    throw new Error("Account is required");
   }
 
   if (utxos.length === 0) {
@@ -84,14 +59,13 @@ export async function buildInstructionQuery<
     throw new Error("at least one funding UTXO is required");
   }
 
-  const xOnly = normalizeXOnly(xOnlyPubKey);
-  const fundingIds = normalizeUtxoIds(utxos);
+  const account = parseAccount(account_);
 
-  return {
-    address,
-    x_only_public_key: xOnly,
-    funding_utxo_ids: fundingIds.join(","),
+  return buildInstructionQuery_({
+    utxos,
     instruction,
-    chained_instruction: chainedInstruction ?? null,
-  };
+    chainedInstruction,
+    address: account.address,
+    xOnlyPubKey: account.xOnlyPubKey,
+  });
 }