@kontor/kontor-sdk 1.0.0-alpha.0

package/src/sdk/types/btc-rpc.ts

@@ -0,0 +1,39 @@
+import type { Prettify } from "../../wit/type-utils.js";
+
+// import type {
+//   TestMempoolAcceptParams,
+//   TestMempoolAcceptReturnType,
+// } from "../actions/public/test-mempool-accept.js";
+
+import type { RpcRequestFn, RpcSchema, RpcSchemaEntry } from "./rpc-schema.js";
+
+export type SendRawTransactionParams = [
+  hex: string,
+  maxFeeRate?: number | string,
+];
+
+export interface SendRawTransactionReturnType {
+  txid: string;
+}
+
+export type BtcRpcSchema = readonly [
+  RpcSchemaEntry<
+    "sendrawtransaction",
+    SendRawTransactionParams,
+    SendRawTransactionReturnType
+  >,
+  // RpcSchemaEntry<
+  //   "testmempoolaccept",
+  //   // todo add options
+  //   [TestMempoolAcceptParams["rawtx"]],
+  //   string[][]
+  // >,
+];
+
+export type BtcNodeRequestFn<
+  Schema extends RpcSchema | undefined = BtcRpcSchema,
+> = RpcRequestFn<Schema>;
+
+export type BtcNodeProvider = Prettify<{
+  request: BtcNodeRequestFn<BtcRpcSchema>;
+}>;

package/src/sdk/types/chain.ts

@@ -0,0 +1,110 @@
+import type { Prettify } from "../../wit/type-utils.js";
+import type { BtcNetwork } from "./misc.js";
+import type { IsUndefined } from "./utils.js";
+
+export type ChainNetworkConfig = BtcNetwork;
+
+// TODO: is this used a tall
+export type ChainContract = {
+  name: string;
+  blockHeight: number;
+  txIndex: number;
+};
+
+type ChainBlockExplorer = {
+  name: string;
+  url: string;
+  apiUrl?: string | undefined;
+};
+
+type ChainNativeCurrency = {
+  name: string;
+  /** 2-6 characters long */
+  symbol: string;
+  decimals: number;
+};
+
+// const NETWORK_CONFIGS: Record<Network, NetworkConfig> = {
+//   mainnet: {
+//     name: "mainnet",
+//     displayName: "Mainnet",
+//     esplora: process.env.ESPLORA_BASE || "https://blockstream.info/api",
+//     mempool: process.env.MEMPOOL_BASE || "https://mempool.space",
+//     kontor: process.env.KONTOR_BASE || "https://api.kontor.io",
+//     kontorWs: process.env.NEXT_PUBLIC_KONTOR_WS_URL || "wss://api.kontor.io/ws",
+//     bitcoin: process.env.BITCOIN_BASE || "",
+//     currency: "BTC",
+//     coinName: "Bitcoin Mainnet",
+//     theme: {
+//       color: "#f7931a", // Bitcoin orange
+//       bgColor: "#fff7ed", // Light orange
+//       textColor: "#92400e", // Dark orange
+//     },
+//   },
+
+type ChainUrls = {
+  http: readonly string[];
+  webSocket?: readonly string[] | undefined;
+  bitcoinRpc: readonly string[];
+};
+
+export type Chain<
+  custom extends Record<string, unknown> | undefined =
+    | Record<string, unknown>
+    | undefined,
+> = {
+  networkConfig: ChainNetworkConfig;
+  blockExplorers?:
+    | {
+        [key: string]: ChainBlockExplorer;
+        default: ChainBlockExplorer;
+      }
+    | undefined;
+  blockTime?: number | undefined;
+  contracts?:
+    | Prettify<
+        {
+          [key: string]:
+            | ChainContract
+            | { [sourceId: number]: ChainContract | undefined }
+            | undefined;
+        } & {
+          nativeToken?: ChainContract | undefined;
+        }
+      >
+    | undefined;
+  /** ID in number form */
+  id: number;
+  /** Human-readable name */
+  name: string;
+  nativeCurrency: ChainNativeCurrency;
+
+  urls: {
+    [key: string]: ChainUrls;
+    default: ChainUrls;
+  };
+
+  testnet?: boolean | undefined;
+} & ChainConfig<custom>;
+
+export type ChainConfig<
+  custom extends Record<string, unknown> | undefined =
+    | Record<string, unknown>
+    | undefined,
+> = {
+  /** Custom chain data. */
+  custom?: custom | undefined;
+  /** Modifies how fees are derived. */
+  // fees?: ChainFees<formatters | undefined> | undefined
+  /** Modifies how data is formatted and typed (e.g. blocks and transactions) */
+  // formatters?: formatters | undefined
+  /** Modifies how data is serialized (e.g. transactions). */
+};
+
+export type GetChainParameter<
+  chain extends Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+> =
+  IsUndefined<chain> extends true
+    ? { chain: chainOverride | null }
+    : { chain?: chainOverride | null | undefined };

package/src/sdk/types/contract.test-d.ts

@@ -0,0 +1,251 @@
+import { expectTypeOf, test } from "vitest";
+import type {
+  ContractFunctionName,
+  ContractFunctionArgs,
+  ContractFunctionReturnType,
+} from "./contract.js";
+
+import { nativeToken } from "~test/src/wits.js";
+
+test("ContractFunctionName", () => {
+  type All = ContractFunctionName<typeof nativeToken>;
+  expectTypeOf<All>().toEqualTypeOf<
+    | "issuance"
+    | "hold"
+    | "release"
+    // | "init" // init is not valid
+    | "mint"
+    | "burn"
+    | "transfer"
+    | "balance"
+    | "balances"
+    | "total-supply"
+    | "attach"
+    | "detach"
+  >;
+
+  type Core = ContractFunctionName<typeof nativeToken, "core">;
+  expectTypeOf<Core>().toEqualTypeOf<"issuance" | "hold" | "release">;
+
+  type View = ContractFunctionName<typeof nativeToken, "view">;
+  expectTypeOf<View>().toEqualTypeOf<"balance" | "balances" | "total-supply">;
+
+  type Proc = ContractFunctionName<typeof nativeToken, "proc">;
+  expectTypeOf<Proc>().toEqualTypeOf<
+    "mint" | "burn" | "transfer" | "attach" | "detach"
+  >;
+});
+
+test("ContractFunctionArgs", () => {
+  type Issuance = ContractFunctionArgs<typeof nativeToken, "core", "issuance">;
+  expectTypeOf<Issuance>().toEqualTypeOf<readonly [[bigint, number]]>;
+
+  type Hold = ContractFunctionArgs<typeof nativeToken, "core", "hold">;
+  expectTypeOf<Hold>().toEqualTypeOf<readonly [[bigint, number]]>;
+
+  type Release = ContractFunctionArgs<typeof nativeToken, "core", "release">;
+  expectTypeOf<Release>().toEqualTypeOf<readonly [[bigint, number]]>;
+
+  type Mint = ContractFunctionArgs<typeof nativeToken, "proc", "mint">;
+  expectTypeOf<Mint>().toEqualTypeOf<readonly [[bigint, number]]>;
+
+  type Burn = ContractFunctionArgs<typeof nativeToken, "proc", "burn">;
+  expectTypeOf<Burn>().toEqualTypeOf<readonly [[bigint, number]]>;
+
+  type Transfer = ContractFunctionArgs<typeof nativeToken, "proc", "transfer">;
+  expectTypeOf<Transfer>().toEqualTypeOf<readonly [string, [bigint, number]]>;
+
+  type Balance = ContractFunctionArgs<typeof nativeToken, "view", "balance">;
+  expectTypeOf<Balance>().toEqualTypeOf<readonly [string]>;
+
+  type Balances = ContractFunctionArgs<typeof nativeToken, "view", "balances">;
+  expectTypeOf<Balances>().toEqualTypeOf<readonly []>;
+
+  type TotalSupply = ContractFunctionArgs<
+    typeof nativeToken,
+    "view",
+    "total-supply"
+  >;
+  expectTypeOf<TotalSupply>().toEqualTypeOf<readonly []>;
+
+  type Attach = ContractFunctionArgs<typeof nativeToken, "proc", "attach">;
+  expectTypeOf<Attach>().toEqualTypeOf<readonly [bigint, [bigint, number]]>;
+
+  type Detach = ContractFunctionArgs<typeof nativeToken, "proc", "detach">;
+  expectTypeOf<Detach>().toEqualTypeOf<readonly []>;
+});
+
+test("ContractFunctionReturnType", () => {
+  type Issuance = ContractFunctionReturnType<
+    typeof nativeToken,
+    "core",
+    "issuance"
+  >;
+  expectTypeOf<Issuance>().toEqualTypeOf<
+    | {
+        ok: false;
+        error: string;
+      }
+    | {
+        ok: true;
+        value: {
+          dst: string;
+          amt: [bigint, number];
+        };
+      }
+  >;
+
+  type Hold = ContractFunctionReturnType<typeof nativeToken, "core", "hold">;
+  expectTypeOf<Hold>().toEqualTypeOf<
+    | {
+        ok: false;
+        error: string;
+      }
+    | {
+        ok: true;
+        value: {
+          src: string;
+          dst: string;
+          amt: [bigint, number];
+        };
+      }
+  >;
+
+  type Release = ContractFunctionReturnType<
+    typeof nativeToken,
+    "core",
+    "release"
+  >;
+  expectTypeOf<Release>().toEqualTypeOf<
+    | {
+        ok: false;
+        error: string;
+      }
+    | {
+        ok: true;
+        value: {
+          src: string;
+          amt: [bigint, number];
+        };
+      }
+  >;
+
+  type Mint = ContractFunctionReturnType<typeof nativeToken, "proc", "mint">;
+  expectTypeOf<Mint>().toEqualTypeOf<
+    | {
+        ok: false;
+        error: string;
+      }
+    | {
+        ok: true;
+        value: {
+          dst: string;
+          amt: [bigint, number];
+        };
+      }
+  >;
+  type Burn = ContractFunctionReturnType<typeof nativeToken, "proc", "burn">;
+  expectTypeOf<Burn>().toEqualTypeOf<
+    | {
+        ok: false;
+        error: string;
+      }
+    | {
+        ok: true;
+        value: {
+          src: string;
+          amt: [bigint, number];
+        };
+      }
+  >;
+
+  type Transfer = ContractFunctionReturnType<
+    typeof nativeToken,
+    "proc",
+    "transfer"
+  >;
+  expectTypeOf<Transfer>().toEqualTypeOf<
+    | {
+        ok: false;
+        error: string;
+      }
+    | {
+        ok: true;
+        value: {
+          src: string;
+          dst: string;
+          amt: [bigint, number];
+        };
+      }
+  >;
+  type Balance = ContractFunctionReturnType<
+    typeof nativeToken,
+    "view",
+    "balance"
+  >;
+  expectTypeOf<Balance>().toEqualTypeOf<
+    | {
+        kind: "none";
+      }
+    | {
+        kind: "some";
+        value: [bigint, number];
+      }
+  >;
+
+  type Balances = ContractFunctionReturnType<
+    typeof nativeToken,
+    "view",
+    "balances"
+  >;
+  expectTypeOf<Balances>().toEqualTypeOf<
+    readonly { acc: string; amt: [bigint, number] }[]
+  >;
+
+  type TotalSupply = ContractFunctionReturnType<
+    typeof nativeToken,
+    "view",
+    "total-supply"
+  >;
+  expectTypeOf<TotalSupply>().toEqualTypeOf<[bigint, number]>;
+
+  type Attach = ContractFunctionReturnType<
+    typeof nativeToken,
+    "proc",
+    "attach"
+  >;
+  expectTypeOf<Attach>().toEqualTypeOf<
+    | {
+        ok: false;
+        error: string;
+      }
+    | {
+        ok: true;
+        value: {
+          src: string;
+          dst: string;
+          amt: [bigint, number];
+        };
+      }
+  >;
+
+  type Detach = ContractFunctionReturnType<
+    typeof nativeToken,
+    "proc",
+    "detach"
+  >;
+  expectTypeOf<Detach>().toEqualTypeOf<
+    | {
+        ok: false;
+        error: string;
+      }
+    | {
+        ok: true;
+        value: {
+          src: string;
+          dst: string;
+          amt: [bigint, number];
+        };
+      }
+  >;
+});

package/src/sdk/types/contract.ts

@@ -0,0 +1,246 @@
+import type {
+  // Address,
+  Wit,
+  WitFunction,
+  WitParameter,
+  WitStateMutability,
+} from "../../wit/wit.js";
+import type { ResolvedRegister } from "../../wit/register.js";
+import type { IsUnion, UnionToTuple } from "../../wit/type-utils.js";
+import type {
+  ExtractWitFunction,
+  ExtractWitFunctionNames,
+  WitParametersToPrimitiveTypes,
+} from "../../wit/utils.js";
+
+export type ContractFunctionName<
+  wit extends Wit | readonly unknown[] = Wit,
+  mutability extends WitStateMutability = WitStateMutability,
+> =
+  ExtractWitFunctionNames<
+    wit extends Wit ? wit : Wit,
+    mutability
+  > extends infer functionName extends string
+    ? [functionName] extends [never]
+      ? string
+      : functionName
+    : string;
+
+// AbiParametersToPrimitiveTypes,
+// AbiParameterToPrimitiveType,
+// ExtractAbiFunction,
+
+export type ContractFunctionArgs<
+  wit extends Wit | readonly unknown[] = Wit,
+  mutability extends WitStateMutability = WitStateMutability,
+  functionName extends ContractFunctionName<
+    wit,
+    mutability
+  > = ContractFunctionName<wit, mutability>,
+> =
+  WitParametersToPrimitiveTypes<
+    ExtractWitFunction<
+      wit extends Wit ? wit : Wit,
+      functionName,
+      mutability
+    >["inputs"],
+    "inputs"
+  > extends infer args
+    ? [args] extends [never]
+      ? readonly unknown[]
+      : args
+    : readonly unknown[];
+
+export type Widen<T> =
+  // preserve unknown / any
+  | ([unknown] extends [T] ? unknown : never)
+  // preserve functions
+  | (T extends (...args: any[]) => any ? T : never)
+  // bigint-ish -> bigint
+  | (T extends ResolvedRegister["bigIntType"] ? bigint : never)
+  // booleans -> boolean
+  | (T extends boolean ? boolean : never)
+  // int-ish -> number
+  | (T extends ResolvedRegister["intType"] ? number : never)
+  // decimal -> canonical tuple or number (NO string)
+  | (T extends ResolvedRegister["decimalType"]
+      ? ResolvedRegister["decimalType"]
+      : never)
+  // addresses -> registered address type
+  | (T extends ResolvedRegister["addressType"]
+      ? ResolvedRegister["addressType"]
+      : never)
+  // plain strings (non-address)
+  | (T extends string
+      ? T extends ResolvedRegister["addressType"]
+        ? never // already handled above
+        : string
+      : never)
+  // empty tuple
+  | (T extends readonly [] ? readonly [] : never)
+  // object / record types (but not arrays/tuples)
+  | (T extends readonly any[]
+      ? never
+      : T extends Record<string, unknown>
+        ? { [K in keyof T]: Widen<T[K]> }
+        : never)
+  // tuple/array-like types: recursively widen elements
+  | (T extends { length: number }
+      ? {
+          [K in keyof T]: Widen<T[K]>;
+        } extends infer V extends readonly unknown[]
+        ? readonly [...V]
+        : never
+      : never);
+
+export type UnionWiden<type> = type extends any ? Widen<type> : never;
+
+export type ContractFunctionParameters<
+  wit extends Wit | readonly unknown[] = Wit,
+  mutability extends WitStateMutability = WitStateMutability,
+  functionName extends ContractFunctionName<
+    wit,
+    mutability
+  > = ContractFunctionName<wit, mutability>,
+  args extends ContractFunctionArgs<
+    wit,
+    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:
+    | allFunctionNames // show all options
+    | (functionName extends allFunctionNames ? functionName : never); // infer value
+  args?: (wit extends Wit ? UnionWiden<args> : never) | allArgs | undefined;
+} & (readonly [] extends allArgs ? {} : { args: Widen<args> }) & {
+    contractAddress: ResolvedRegister["contractAddress"];
+  };
+
+export type ContractFunctionReturnType<
+  wit extends Wit | readonly unknown[] = Wit,
+  mutability extends WitStateMutability = WitStateMutability,
+  functionName extends ContractFunctionName<
+    wit,
+    mutability
+  > = ContractFunctionName<wit, mutability>,
+  args extends ContractFunctionArgs<
+    wit,
+    mutability,
+    functionName
+  > = ContractFunctionArgs<wit, mutability, functionName>,
+> = wit extends Wit
+  ? Wit extends wit
+    ? unknown
+    : WitParametersToPrimitiveTypes<
+          ExtractWitFunctionForArgs<
+            wit,
+            mutability,
+            functionName,
+            args
+          >["outputs"]
+        > extends infer types
+      ? types extends readonly []
+        ? void
+        : types extends readonly [infer type]
+          ? type
+          : types
+      : never
+  : unknown;
+
+export type ExtractWitFunctionForArgs<
+  wit extends Wit,
+  mutability extends WitStateMutability,
+  functionName extends ContractFunctionName<wit, mutability>,
+  args extends ContractFunctionArgs<wit, mutability, functionName>,
+> =
+  ExtractWitFunction<
+    wit,
+    functionName,
+    mutability
+  > extends infer witFunction extends WitFunction
+    ? IsUnion<witFunction> extends true // narrow overloads using `args` by converting to tuple and filtering out overloads that don't match
+      ? UnionToTuple<witFunction> extends infer witFunctions extends
+          readonly WitFunction[]
+        ? // convert back to union (removes `never` tuple entries)
+          {
+            [k in keyof witFunctions]: CheckArgs<witFunctions[k], args>;
+          }[number]
+        : never
+      : witFunction
+    : never;
+
+type CheckArgs<
+  witFunction extends WitFunction,
+  args,
+  ///
+  targetArgs extends WitParametersToPrimitiveTypes<
+    witFunction["inputs"],
+    "inputs"
+  > = WitParametersToPrimitiveTypes<witFunction["inputs"], "inputs">,
+> = (readonly [] extends args ? readonly [] : args) extends targetArgs // fallback to `readonly []` if `args` has no value (e.g. `args` property not provided)
+  ? witFunction
+  : never;
+
+export type WitItem = Wit[number];
+
+export type ExtractWitItemNames<wit extends Wit> = Extract<
+  wit[number],
+  { name: string }
+>["name"];
+
+export type ExtractWitItem<
+  wit extends Wit,
+  name extends ExtractWitItemNames<wit>,
+> = Extract<wit[number], { name: name }>;
+
+export type WitItemName<wit extends Wit | readonly unknown[] = Wit> =
+  wit extends Wit ? ExtractWitItemNames<wit> : string;
+
+export type WitItemArgs<
+  wit extends Wit | readonly unknown[] = Wit,
+  name extends WitItemName<wit> = WitItemName<wit>,
+> =
+  WitParametersToPrimitiveTypes<
+    ExtractWitItem<wit extends Wit ? wit : Wit, name>["inputs"],
+    "inputs"
+  > extends infer args
+    ? [args] extends [never]
+      ? readonly unknown[]
+      : args
+    : readonly unknown[];
+
+export type ExtractWitItemForArgs<
+  wit extends Wit,
+  name extends WitItemName<wit>,
+  args extends WitItemArgs<wit, name>,
+> =
+  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
+      ? 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
+            ) extends WitParametersToPrimitiveTypes<
+              witItems[k]["inputs"],
+              "inputs"
+            >
+              ? witItems[k]
+              : never;
+          }[number] // convert back to union (removes `never` tuple entries: `['foo', never, 'bar'][number]` => `'foo' | 'bar'`)
+        : never
+      : witItem
+    : never;