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

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,
+  });
 }

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

@@ -34,7 +34,7 @@ export type CallComposeParameters<
     | [Address, XOnlyPubKey]
     | undefined,
 > = CallComposeRequest &
-  GetAccountParameter<account, accountOverride, false, true> &
+  GetAccountParameter<account, accountOverride, true, true> &
   GetChainParameter<chain, chainOverride>;
 
 // TODO: organize these types or just refernece direc
@@ -56,6 +56,7 @@ export async function callCompose<
 ): Promise<CallComposeReturnType> {
   const {
     account: account_ = client.account,
+    chain = client.chain,
     utxos,
     satsPerVByte,
     instruction,
@@ -66,6 +67,10 @@ export async function callCompose<
     throw new Error("Account is required");
   }
 
+  if (!chain) {
+    throw new Error("Chain is required");
+  }
+
   if (utxos.length === 0) {
     // TODO: add custom error
     throw new Error("at least one funding UTXO is required");
@@ -74,15 +79,14 @@ export async function callCompose<
   //
   const account = parseAccount(account_);
 
-  const composeCall = await getKontorAction(
+  const composeCall = getKontorAction(
     client,
     buildComposeQuery,
     "buildComposeQuery",
   )({
     instruction,
     utxos,
-    xOnlyPubKey: account.xOnlyPubKey,
-    address: account.address,
+    account,
     satsPerVByte,
   });
 

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

@@ -5,15 +5,15 @@ import type {
 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 { Chain, GetChainParameter } from "../../../types/chain.js";
 
 export type CallViewParameters<
-  _chain extends Chain | undefined = Chain | undefined,
+  chain extends Chain | undefined = Chain,
+  chainOverride extends Chain | undefined = Chain | undefined,
 > = {
   contractAddress: ResolvedRegister["contractAddress"];
   wave: string;
-};
-
+} & GetChainParameter<chain, chainOverride>;
 // TODO: refine this type
 export type CallViewReturnType = ResultResponse<ViewResult>;
 
@@ -24,6 +24,7 @@ export async function callView<
   params: CallViewParameters<chain>,
 ): Promise<CallViewReturnType> {
   const { contractAddress, wave } = params;
+  // TODO: assert chain
 
   try {
     const response = await client.request({

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

@@ -5,19 +5,34 @@ import type {
 } 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;
+import type { Chain, GetChainParameter } from "../../../types/chain.js";
+// import { assertCurrentChain } from "../../../utils/chain/assert-current-chain.js";
 
+export type InspectParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+> = TransactionHex & GetChainParameter<chain, chainOverride>;
 export type InspectReturnType = ResultResponse<OpWithResult[]>;
 
 export async function inspect<
   chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
 >(
   client: KontorPublicClient<HttpTransport, chain>,
-  params: InspectParameters,
+  params: InspectParameters<chain, chainOverride>,
 ): Promise<InspectReturnType> {
-  const { hex } = params;
+  const {
+    hex,
+    // chain: chain_ = client.chain
+  } = params;
+
+  // TODO: chain assertions everywhere ( need to get current chain )
+
+  // assertCurrentChain({
+  //     currentChain: client.chain,
+  //     chain: chain_
+  // });
+  //
 
   try {
     const response = await client.request({
@@ -27,10 +42,6 @@ export async function inspect<
       body: { hex: hex },
     });
 
-    console.log("callView response:", response);
-
-    // TODO: fix CallViwewReturnType
-    // @ts-ignore
     return response;
   } catch (e) {
     // TODO: augment error handling

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

@@ -31,13 +31,12 @@ test.skip("e2e", async () => {
       "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
       "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
     ],
+    chain: signet,
   });
 
   // proc contract action defined on client
   // response is correctly typed
   const res = await client.procContract({
-    account: client.account!,
-    chain: signet,
     wit: wit,
     // can also be injected
 

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

@@ -18,52 +18,6 @@ import {
 } from "../../../utils/wit/encode-function-data.js";
 import { callCompose, type CallComposeReturnType } from "./call-compose.js";
 
-// export type WriteContractParameters<
-//   abi extends Abi | readonly unknown[] = Abi,
-//   functionName extends ContractFunctionName<
-//     abi,
-//     'nonpayable' | 'payable'
-//   > = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
-//   args extends ContractFunctionArgs<
-//     abi,
-//     'nonpayable' | 'payable',
-//     functionName
-//   > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
-//   chain extends Chain | undefined = Chain | undefined,
-//   account extends Account | undefined = Account | undefined,
-//   chainOverride extends Chain | undefined = Chain | undefined,
-//   ///
-//   allFunctionNames = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
-//   derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
-// > = ContractFunctionParameters<
-//   abi,
-//   'nonpayable' | 'payable',
-//   functionName,
-//   args,
-//   false,
-//   allFunctionNames
-// > &
-//   GetChainParameter<chain, chainOverride> &
-//   Prettify<
-//     GetAccountParameter<account, Account | Address, true, true> &
-//       GetMutabilityAwareValue<
-//         abi,
-//         'nonpayable' | 'payable',
-//         functionName,
-//         FormattedTransactionRequest<derivedChain>['value'],
-//         args
-//       > & {
-//         /** Data to append to the end of the calldata. Useful for adding a ["domain" tag](https://opensea.notion.site/opensea/Seaport-Order-Attributions-ec2d69bf455041a5baa490941aad307f). */
-//         dataSuffix?: Hex | undefined
-//       }
-//   > &
-//   UnionEvaluate<
-//     UnionOmit<
-//       FormattedTransactionRequest<derivedChain>,
-//       'data' | 'from' | 'to' | 'value'
-//     >
-//   >
-
 export type ProcContractParameters<
   wit extends Wit | readonly unknown[] = Wit,
   functionName extends ContractFunctionName<wit, "proc"> = ContractFunctionName<
@@ -78,12 +32,16 @@ export type ProcContractParameters<
   chain extends Chain | undefined = Chain | undefined,
   account extends Account | undefined = Account | undefined,
   chainOverride extends Chain | undefined = Chain | undefined,
+  accountOverride extends Account | [Address, XOnlyPubKey] | undefined =
+    | Account
+    | [Address, XOnlyPubKey]
+    | undefined,
 > = ContractFunctionParameters<wit, "proc", functionName, args> & {
   utxos: UtxoId[];
   gas: bigint;
   satsPerVByte: number;
 } & GetChainParameter<chain, chainOverride> &
-  GetAccountParameter<account, Account | [XOnlyPubKey, Address], true, true>;
+  GetAccountParameter<account, accountOverride, true, true>;
 
 export type ProcContractReturnType = CallComposeReturnType;
 
@@ -93,9 +51,18 @@ export async function procContract<
   const wit extends Wit | readonly unknown[],
   functionName extends ContractFunctionName<wit, "proc">,
   const args extends ContractFunctionArgs<wit, "proc", functionName>,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
 >(
   client: KontorPublicClient<HttpTransport, chain>,
-  parameters: ProcContractParameters<wit, functionName, args>,
+  parameters: ProcContractParameters<
+    wit,
+    functionName,
+    args,
+    chain,
+    account,
+    chainOverride
+  >,
 ): Promise<ProcContractReturnType> {
   const {
     wit: wit,
@@ -111,13 +78,6 @@ export async function procContract<
     ...rest
   } = parameters as ProcContractParameters;
 
-  // @ts-ignore
-  const wave = encodeFunctionData({
-    wit: wit,
-    args,
-    functionName,
-  } as EncodeFunctionDataParameters);
-
   if (!account_) {
     // TODO: add custom error
     throw new Error("account is required");
@@ -128,6 +88,12 @@ export async function procContract<
     throw new Error("at least one funding UTXO is required");
   }
 
+  const wave = encodeFunctionData({
+    wit: wit,
+    args,
+    functionName,
+  } as EncodeFunctionDataParameters);
+
   try {
     const response = await getKontorAction(
       client,

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

@@ -4,16 +4,16 @@ 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";
+import { signet } from "../../../chains/definitions/signet.js";
 
 const wit = parseWit(nativeToken.raw);
 
 test("e2e", async () => {
   const client = createPublicClient({
     transport: http("https://signet-staging.kontor.network:35000/api"),
+    chain: signet,
   });
 
-  // 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

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

@@ -2,7 +2,7 @@ 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 { Chain, GetChainParameter } from "../../../types/chain.js";
 import type {
   ContractFunctionArgs,
   ContractFunctionName,
@@ -11,7 +11,6 @@ import type {
 } 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,
@@ -29,7 +28,10 @@ export type ViewContractParameters<
     "view",
     functionName
   > = ContractFunctionArgs<wit, "view", functionName>,
-> = ContractFunctionParameters<wit, "view", functionName, args>;
+  chain extends Chain | undefined = Chain,
+  chainOverride extends Chain | undefined = Chain | undefined,
+> = ContractFunctionParameters<wit, "view", functionName, args> &
+  GetChainParameter<chain, chainOverride>;
 
 export type ViewContractReturnType<
   wit extends Wit | readonly unknown[] = Wit,
@@ -46,26 +48,24 @@ export type ViewContractReturnType<
 > = 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>,
+  parameters: ViewContractParameters<wit, functionName, args, chain>,
 ): Promise<ViewContractReturnType<wit, functionName, args>> {
   const {
     wit: wit,
     contractAddress,
     args,
     functionName,
-
-    // @ts-ignore
-    ...rest
+    chain: chain_ = client.chain,
   } = parameters as ViewContractParameters;
 
-  // @ts-ignore
+  //TODO: assert chain ( or delegate to downstream call )
+
   const wave = encodeFunctionData({
     wit: wit,
     args,
@@ -80,6 +80,7 @@ export async function viewContract<
     )({
       contractAddress: contractAddress,
       wave: wave,
+      chain: chain_,
     });
 
     console.log(response.result.type);

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

@@ -1,7 +1,6 @@
 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,

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

@@ -78,7 +78,6 @@ describe("transports", () => {
      },
      "fees": undefined,
      "formatters": undefined,
-     "id": 0,
      "name": "signet",
      "nativeCurrency": {
        "decimals": 18,

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

@@ -81,7 +81,6 @@ test("with chain", () => {
      },
      "fees": undefined,
      "formatters": undefined,
-     "id": 0,
      "name": "signet",
      "nativeCurrency": {
        "decimals": 18,

package/src/sdk/clients/decorators/kontor/public.ts

@@ -59,35 +59,44 @@ export type KontorPublicActions<
     const wit extends Wit | readonly unknown[],
     functionName extends ContractFunctionName<wit, "view">,
     const args extends ContractFunctionArgs<wit, "view", functionName>,
+    chainOverride extends Chain | undefined,
   >(
-    args: ViewContractParameters<wit, functionName, args>,
+    args: ViewContractParameters<wit, functionName, args, chain, chainOverride>,
   ) => Promise<ViewContractReturnType<wit, functionName, args>>;
 
   procContract: <
     const wit extends Wit | readonly unknown[],
     functionName extends ContractFunctionName<wit, "proc">,
     const args extends ContractFunctionArgs<wit, "proc", functionName>,
+    chainOverride extends Chain | undefined,
   >(
-    args: ProcContractParameters<wit, functionName, args>,
+    args: ProcContractParameters<
+      wit,
+      functionName,
+      args,
+      chain,
+      account,
+      chainOverride
+    >,
   ) => Promise<ProcContractReturnType>;
 
-  callView: <chain extends Chain | undefined>(
-    args: CallViewParameters<chain>,
+  callView: <chainOverride extends Chain | undefined>(
+    args: CallViewParameters<chain, chainOverride>,
   ) => Promise<CallViewReturnType>;
 
-  buildInstructionQuery: <chain extends Chain | undefined>(
-    args: BuildInstructionQueryParameters<chain>,
-  ) => Promise<BuildInstructionQueryReturnType>;
+  buildInstructionQuery: (
+    args: BuildInstructionQueryParameters<account>,
+  ) => BuildInstructionQueryReturnType;
 
-  buildComposeQuery: <chain extends Chain | undefined>(
-    args: BuildComposeQueryParameters<chain>,
-  ) => Promise<BuildComposeQueryReturnType>;
+  buildComposeQuery: (
+    args: BuildComposeQueryParameters<account>,
+  ) => BuildComposeQueryReturnType;
 
   callCompose: <chainOverride extends Chain | undefined>(
     args: CallComposeParameters<chain, account, chainOverride>,
   ) => Promise<CallComposeReturnType>;
-  inspect: <_chain extends Chain | undefined>(
-    args: InspectParameters,
+  inspect: <chainOverride extends Chain | undefined>(
+    args: InspectParameters<chain, chainOverride>,
   ) => Promise<InspectReturnType>;
 };
 

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

@@ -39,11 +39,4 @@ test("creates", async () => {
       "viewContract": [Function],
     }
   `);
-
-  const x = await client.callView({
-    contractAddress: "token_0_0",
-    wave: "balances()",
-  });
-
-  console.log({ x });
 });

package/src/sdk/errors/chain.ts

@@ -0,0 +1,64 @@
+import type { Chain } from "../types/chain.js";
+
+import { BaseError } from "./base.js";
+
+export type ChainMismatchErrorType = ChainMismatchError & {
+  name: "ChainMismatchError";
+};
+export class ChainMismatchError extends BaseError {
+  constructor({ chain, currentChain }: { chain: Chain; currentChain: Chain }) {
+    super(
+      `The current chain of the wallet (name: ${currentChain.name}) does not match the target chain for the transaction (name: ${chain.name}).`,
+      {
+        metaMessages: [
+          `Current Chain:  ${currentChain.name}`,
+          `Expected Chain: ${chain.name}`,
+        ],
+        name: "ChainMismatchError",
+      },
+    );
+  }
+}
+
+export type ChainNotFoundErrorType = ChainNotFoundError & {
+  name: "ChainNotFoundError";
+};
+export class ChainNotFoundError extends BaseError {
+  constructor() {
+    super(
+      [
+        "No chain was provided to the request.",
+        "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient.",
+      ].join("\n"),
+      {
+        name: "ChainNotFoundError",
+      },
+    );
+  }
+}
+
+export type ClientChainNotConfiguredErrorType =
+  ClientChainNotConfiguredError & {
+    name: "ClientChainNotConfiguredError";
+  };
+export class ClientChainNotConfiguredError extends BaseError {
+  constructor() {
+    super("No chain was provided to the Client.", {
+      name: "ClientChainNotConfiguredError",
+    });
+  }
+}
+
+export type InvalidChainIdErrorType = InvalidChainIdError & {
+  name: "InvalidChainIdError";
+};
+export class InvalidChainIdError extends BaseError {
+  constructor({ chainId }: { chainId?: number | undefined }) {
+    super(
+      typeof chainId === "number"
+        ? `Chain ID "${chainId}" is invalid.`
+        : "Chain ID is invalid.",
+      { name: "InvalidChainIdError" },
+    );
+  }
+}

package/src/sdk/test/e2e.test.ts

@@ -140,6 +140,27 @@ test("e2e kontor wallet client", async () => {
     satsPerVByte: 1,
   });
 
+  // TODO: add separate tests for these
+  // const instructionQuery_ = kontorPublicClient.buildInstructionQuery({
+  //   utxos: [
+  //     "641c40edf4cf0f1cdaea5c259bf50267bd8743dbade84c98bb9e360c2d0e2a33:1",
+  //   ],
+  //   instruction: Instruction.issuance(),
+  // });
+  //
+  // const composeQuery_ = kontorPublicClient.buildComposeQuery({
+  //   utxos: [
+  //     "641c40edf4cf0f1cdaea5c259bf50267bd8743dbade84c98bb9e360c2d0e2a33:1",
+  //   ],
+  //
+  //   instruction: Instruction.issuance(),
+  //   satsPerVByte: 1,
+  // });
+  // const x = await kontorPublicClient.callView({
+  //   contractAddress: "token_0_0",
+  //   wave: "balances()",
+  // });
+
   const commit: Transaction = await kontorWalletClient.signCommit({
     psbt: res.result.commit_psbt_hex,
   });

package/src/sdk/types/chain.ts

@@ -73,8 +73,6 @@ export type Chain<
         }
       >
     | undefined;
-  /** ID in number form */
-  id: number;
   /** Human-readable name */
   name: string;
   nativeCurrency: ChainNativeCurrency;