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

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/actions/kontor/wallet/sign-commit.ts

@@ -8,23 +8,33 @@ 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";
+import type { XOnlyPubKey, Address } from "../../../../sdk/types/misc.js";
+
+export type SignCommitRequest = {
+  psbt: string;
+};
 
 export type SignCommitParameters<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
-> = GetAccountParameter<account> &
-  // TODO: add chainoverride?
-  GetChainParameter<chain> & { psbt: string };
+  chain extends Chain | undefined = Chain,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  accountOverride extends Account | [Address, XOnlyPubKey] | undefined =
+    | Account
+    | [Address, XOnlyPubKey]
+    | undefined,
+> = SignCommitRequest &
+  GetAccountParameter<account, accountOverride, false, true> &
+  GetChainParameter<chain, chainOverride>;
 
 export type SignCommitReturnType = Transaction;
 
 export async function signCommit<
-  // @ts-ignore
   chain extends Chain | undefined,
   account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
 >(
   client: KontorWalletClient<RpcTransport, chain, account>,
-  parameters: SignCommitParameters<chain, account>,
+  parameters: SignCommitParameters<chain, account, chainOverride>,
 ): Promise<SignCommitReturnType> {
   const {
     account: account_ = client.account,
@@ -33,6 +43,7 @@ export async function signCommit<
   } = parameters;
 
   if (!account_) throw new Error("AccountNotFoundError");
+  // TODO: throw if chain is undefined
 
   const account = parseAccount(account_);
 

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

@@ -18,7 +18,7 @@ import type { ParticipantScripts } from "@kontor/kontor-ts";
 export type SignRevealParameters<
   chain extends Chain | undefined,
   account extends Account | undefined,
-> = GetAccountParameter<account> &
+> = GetAccountParameter<account, account, false> &
   // TODO: add chainoverride?
   GetChainParameter<chain> & {
     psbt: string;

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

@@ -52,42 +52,51 @@ import type { HttpTransport } from "../../transports/create-http-transport.js";
 
 export type KontorPublicActions<
   _transport extends HttpTransport = HttpTransport,
-  _chain extends Chain | undefined = Chain | undefined,
-  _account extends Account | undefined = Account | undefined,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
 > = {
   viewContract: <
     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: <chain extends Chain | undefined>(
-    args: CallComposeParameters<chain>,
+  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/decorators/kontor/wallet.ts

@@ -33,8 +33,8 @@ export type KontorWalletActions<
   signPsbt: (
     params: SignPsbtParameters<chain, account>,
   ) => Promise<SignPsbtReturnType>;
-  signCommit: (
-    params: SignCommitParameters<chain, account>,
+  signCommit: <chainOverride extends Chain | undefined>(
+    params: SignCommitParameters<chain, account, chainOverride>,
   ) => Promise<SignCommitReturnType>;
   signReveal: (
     params: SignRevealParameters<chain, account>,

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/clients/kontor/create-public-client.ts

@@ -43,17 +43,17 @@ export type KontorPublicClientConfig<
 export type KontorPublicClient<
   transport extends HttpTransport = HttpTransport,
   chain extends Chain | undefined = Chain | undefined,
-  accountOrAddress extends Account | undefined = Account | undefined,
+  account extends Account | undefined = Account | undefined,
   httpSchema extends HttpSchema | undefined = undefined,
 > = Prettify<
   HttpClient<
     transport,
     chain,
-    accountOrAddress,
+    account,
     httpSchema extends HttpSchema
       ? [...KontorSchemaPublic, ...httpSchema]
       : KontorSchemaPublic,
-    KontorPublicActions
+    KontorPublicActions<transport, chain, account>
   >
 >;
 

package/src/sdk/clients/kontor/create-wallet-client.ts

@@ -44,17 +44,17 @@ export type KontorWalletClientConfig<
 export type KontorWalletClient<
   transport extends RpcTransport = RpcTransport,
   chain extends Chain | undefined = Chain | undefined,
-  accountOrAddress extends Account | undefined = Account | undefined,
+  account extends Account | undefined = Account | undefined,
   rpcSchema extends RpcSchema | undefined = undefined,
 > = Prettify<
   RpcClient<
     transport,
     chain,
-    accountOrAddress,
+    account,
     rpcSchema extends RpcSchema
       ? [...WBIP001Schema, ...rpcSchema]
       : WBIP001Schema,
-    KontorWalletActions
+    KontorWalletActions<chain, account>
   >
 >;
 

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

@@ -120,8 +120,16 @@ test("e2e kontor wallet client", async () => {
 
   const kontorPublicClient = createKontorPublicClient({
     transport: http("https://signet-staging.kontor.network:35000/api"),
+    chain: signet,
+    account,
+  });
+
+  const kontorWalletClient = createKontorWalletClient({
     account,
     chain: signet,
+    transport: custom({
+      request: async (_args: any) => null,
+    }),
   });
 
   const res = await kontorPublicClient.callCompose({
@@ -132,23 +140,32 @@ test("e2e kontor wallet client", async () => {
     satsPerVByte: 1,
   });
 
-  const kontorWalletClient = createKontorWalletClient({
-    account,
-    // TODO: transport is not used for local account.
-    transport: custom({
-      request: async (_args: any) => null,
-    }),
-  });
+  // 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({
-    account: account,
-    chain: signet,
     psbt: res.result.commit_psbt_hex,
   });
 
   const reveal: Transaction = await kontorWalletClient.signReveal({
-    account: account,
-    chain: signet,
     psbt: res.result.reveal_psbt_hex,
     parcipantScripts: res.result.per_participant,
   });

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;
@@ -108,3 +106,8 @@ export type GetChainParameter<
   IsUndefined<chain> extends true
     ? { chain: chainOverride | null }
     : { chain?: chainOverride | null | undefined };
+
+export type DeriveChain<
+  chain extends Chain | undefined,
+  chainOverride extends Chain | undefined,
+> = chainOverride extends Chain ? chainOverride : chain;

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;
 };

package/src/wit/wit-parser/core/utils.ts

@@ -16,10 +16,7 @@ export type ParseOptions = {
   records?: RecordLookup;
   type?: WitItemType | "record";
 };
-//
-// export const witParameterRegex =
-//   /^(?:(?<name>[a-z][a-z0-9-]*)\s*:\s*)?(?<type>(?:borrow|list|option|result|tuple)\s*<[\s\S]+>|[a-z][a-z0-9-]*|(?:record|variant|flags|enum)\s*\{[\s\S]*\})$/;
-//
+
 export const witParameterRegex =
   /^(?:(?<name>[a-z][a-z0-9-]*)\s*:\s*)?(?<type>_|(?:borrow|list|option|result|tuple)\s*<[\s\S]+>|[a-z][a-z0-9-]*|(?:record|variant|flags|enum)\s*\{[\s\S]*\})$/;
 
@@ -60,7 +57,6 @@ export function parseWitParameter(param: string, options?: ParseOptions) {
   if (match.name && isWitKeyword(match.name))
     throw new WitProtectedKeywordError({ param, name: match.name });
 
-  // TODO: smell
   const name = match.name ? { name: match.name } : {};
   const records = options?.records ?? {};
   let type: string;