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

package/src/sdk/accounts/private-key-to-account.ts

@@ -36,7 +36,9 @@ import { signPsbt } from "./utils/sign-psbt.js";
 //   signTypedData,
 // } from './utils/signTypedData.js'
 //
-export type PrivateKeyToAccountOptions = {};
+export type PrivateKeyToAccountOptions = {
+  networkConfig?: BtcNetwork;
+};
 //
 export type PrivateKeyToAccountErrorType =
   | PublicKeyToP2TRPaymentErrorType
@@ -48,29 +50,21 @@ export type PrivateKeyToAccountErrorType =
   // | SignTransactionErrorType
   // | SignTypedDataErrorType
   | ErrorType;
-//
-// /**
-//  * @description Creates an Account from a private key.
-//  *
-//  * @returns A Private Key Account.
-//  */
 
-const signet: BtcNetwork = {
-  bech32: "tb",
-  pubKeyHash: 0x6f, // 111 in decimal
-  scriptHash: 0xc4, // 196 in decimal
-  wif: 0xef, // 239 in decimal
-};
 export function privateKeyToAccount(
   privateKey: Hex,
-  _options: PrivateKeyToAccountOptions = {},
+  options: PrivateKeyToAccountOptions = {},
 ): PrivateKeyAccount {
+  console.log({ options });
+
   const publicKey = toHex(
     secp256k1.getPublicKey(hex.decode(privateKey.slice(2)), true),
   );
 
-  // TODO: don't hardcode network
-  const address = publicKeyToP2TRPayment(publicKey.slice(2), signet);
+  const address = publicKeyToP2TRPayment(
+    publicKey.slice(2),
+    options.networkConfig,
+  );
 
   const account = toLocalAccount({
     address: address.address,

package/src/sdk/accounts/to-local-account.ts

@@ -31,11 +31,6 @@ export type ToLocalAccountErrorType =
   | IsAddressErrorType
   | ErrorType;
 
-/**
- * @description Creates an Account from a custom signing implementation.
- *
- * @returns A Local Account.
- */
 export function toLocalAccount<accountSource extends AccountSource>(
   source: accountSource,
 ): GetAccountReturnType<accountSource> {

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

@@ -32,14 +32,15 @@ test("KebabToCamel basic mapping", () => {
 });
 
 test("GetContractReturnType", () => {
-  expectTypeOf<GetContractReturnType<typeof wit>>().toEqualTypeOf<{
-    view: {
-      cachedValues: never;
-      fibAsView: never;
-      readWithRecordArg: never;
-      readTools: never;
-    };
-  }>;
+  // expectTypeOf<GetContractReturnType<typeof wit>>().toEqualTypeOf<{
+  //   view: {
+  //     cachedValues: never;
+  //     fibAsView: never;
+  //     readWithRecordArg: never;
+  //     readTools: never;
+  //   };
+  //   proc: {}
+  // }>;
 });
 test("GetContractReturnType view keys are camelCased", () => {
   type ViewKeys = keyof GetContractReturnType<typeof wit>["view"];
@@ -63,7 +64,7 @@ test("getContract", async () => {
 });
 
 test("GetViewFunction for cached-values (no inputs)", () => {
-  type Fn = GetViewFunction<true, typeof wit, "cached-values">;
+  type Fn = GetViewFunction<true, undefined, typeof wit, "cached-values">;
 
   // return type: Promise<ViewContractReturnType<...>>
   // kay

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

@@ -0,0 +1,49 @@
+import { test } from "vitest";
+import { nativeToken as nativeToken_ } from "../contracts/wits.js";
+import { createPublicClient as createKontorPublicClient } from "../clients/kontor/create-public-client.js";
+
+const nativeToken = nativeToken_.wit;
+
+import { mnemonicToAccount } from "../accounts/mnemonic-to-account.js";
+import { signet } from "../chains/definitions/signet.js";
+import { http } from "../clients/transports/http.js";
+import { getContract } from "./get-contract.js";
+
+test("e2e getContract", async () => {
+  const account = mnemonicToAccount(process.env.TEST_MNEMONIC!, {
+    coinType: 1,
+    networkConfig: signet.networkConfig,
+  });
+
+  // if chain is omittet here
+  const kontorPublicClient = createKontorPublicClient({
+    transport: http("https://signet-staging.kontor.network:35000/api"),
+    chain: signet,
+    account,
+  });
+
+  const contract = getContract({
+    wit: nativeToken,
+    contractAddress: "token_0_0",
+    client: kontorPublicClient,
+  });
+
+  // then options.chain should be required on the view calls
+  const balances = await contract.view.balances();
+
+  const balance = await contract.view.balance([
+    "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
+  ]);
+
+  const composeOutputs = await contract.proc.burn([[1n, 18]], {
+    utxos: [
+      "641c40edf4cf0f1cdaea5c259bf50267bd8743dbade84c98bb9e360c2d0e2a33:1",
+    ],
+    gas: 1000n,
+    satsPerVByte: 1,
+  });
+
+  console.log({ balances });
+  console.log({ balance });
+  console.log({ composeOutputs });
+});

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";
@@ -19,8 +18,6 @@ export type BuildComposeQueryParameters<
     | 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>;

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

@@ -116,7 +116,10 @@ export const wit = parseWit(nativeTokenRaw);
 // });
 
 test("e2e kontor wallet client", async () => {
-  const account = mnemonicToAccount(process.env.TEST_MNEMONIC!);
+  const account = mnemonicToAccount(process.env.TEST_MNEMONIC!, {
+    coinType: 1,
+    networkConfig: signet.networkConfig,
+  });
 
   const kontorPublicClient = createKontorPublicClient({
     transport: http("https://signet-staging.kontor.network:35000/api"),

package/src/sdk/types/contract.ts

@@ -1,5 +1,4 @@
 import type {
-  // Address,
   Wit,
   WitFunction,
   WitParameter,
@@ -26,10 +25,6 @@ export type ContractFunctionName<
       : functionName
     : string;
 
-// AbiParametersToPrimitiveTypes,
-// AbiParameterToPrimitiveType,
-// ExtractAbiFunction,
-
 export type ContractFunctionArgs<
   wit extends Wit | readonly unknown[] = Wit,
   mutability extends WitStateMutability = WitStateMutability,
@@ -107,12 +102,8 @@ export type ContractFunctionParameters<
     mutability,
     functionName
   > = ContractFunctionArgs<wit, mutability, functionName>,
-  // deployless extends boolean = false,
-  ///
   allFunctionNames = ContractFunctionName<wit, mutability>,
   allArgs = ContractFunctionArgs<wit, mutability, functionName>,
-  // when `args` is inferred to `readonly []` ("inputs": []) or `never` (`abi` declared as `Abi` or not inferrable), allow `args` to be optional.
-  // important that both branches return same structural type
 > = {
   wit: wit;
   functionName:
@@ -224,23 +215,21 @@ export type ExtractWitItemForArgs<
   ExtractWitItem<wit, name> extends infer witItem extends WitItem & {
     inputs: readonly WitParameter[];
   }
-    ? IsUnion<witItem> extends true // narrow overloads using `args` by converting to tuple and filtering out overloads that don't match
+    ? IsUnion<witItem> extends true
       ? UnionToTuple<witItem> extends infer witItems extends
           readonly (WitItem & {
             inputs: readonly WitParameter[];
           })[]
         ? {
             [k in keyof witItems]: (
-              readonly [] extends args
-                ? readonly [] // fallback to `readonly []` if `args` has no value (e.g. `args` property not provided)
-                : args
+              readonly [] extends args ? readonly [] : args
             ) extends WitParametersToPrimitiveTypes<
               witItems[k]["inputs"],
               "inputs"
             >
               ? witItems[k]
               : never;
-          }[number] // convert back to union (removes `never` tuple entries: `['foo', never, 'bar'][number]` => `'foo' | 'bar'`)
+          }[number]
         : never
       : witItem
     : never;