@kontor/kontor-sdk 1.0.0-alpha.39 → 1.0.0-alpha.40

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

@@ -1,72 +1,452 @@
-import { expectTypeOf, test } from "vitest";
+import { expectTypeOf, test, assertType } from "vitest";
 import { parseWit } from "../../wit/wit-parser/parse-wit.js";
 import {
-  // getContract,
   type GetContractReturnType,
   type KebabToCamel,
   type GetViewFunction,
-  // getContract,
+  type GetProcFunction,
+  getContract,
 } from "./get-contract.js";
+import type { KontorIndexerClient } from "../clients/kontor/create-public-client.js";
+import type { Chain } from "../types/chain.js";
+import type { UtxoId } from "../types/misc.js";
+import type { Account } from "../accounts/types.js";
 
-const input = [
-  // TODO: build in record defs should be defined under the hood
-  // "record tool {  name: string, isHammer: bool }",
-  "export fib: func(ctx: borrow<proc-context>, arith-address: contract-address, n: u64) -> u64;",
-  "export fib-of-sub: func(ctx: borrow<proc-context>, arith-address: contract-address, x: string, y: string) -> result<u64, error>;",
-  "export cached-values: func(ctx: borrow<view-context>) -> list<u64>;",
-  "export fib-as-view: func(ctx: borrow<view-context>, n: u64) -> u64;",
-  "export read-with-record-arg: func(ctx: borrow<view-context>, contract-address: contract-address) -> u64;",
-  // "export read-tools: func(ctx: borrow<view-context>) -> list<tool>;",
+const nativeTokenRaw = [
+  "record balance { acc: string, amt: decimal }",
+  "record transfer { src: string, dst: string, amt: decimal }",
+  "record burn { src: string, amt: decimal }",
+  "record mint { dst: string, amt: decimal }",
+  "export mint: func(ctx: borrow<proc-context>, amt: decimal) -> result<mint, error>;",
+  "export burn: func(ctx: borrow<proc-context>, amt: decimal) -> result<burn, error>;",
+  "export transfer: func(ctx: borrow<proc-context>, dst: string, amt: decimal) -> result<transfer, error>;",
+  "export balance: func(ctx: borrow<view-context>, acc: string) -> option<decimal>;",
+  "export balances: func(ctx: borrow<view-context>) -> list<balance>;",
+  "export total-supply: func(ctx: borrow<view-context>) -> decimal;",
+  "export attach: func(ctx: borrow<proc-context>, vout: u64, amt: decimal) -> result<transfer, error>;",
+  "export detach: func(ctx: borrow<proc-context>) -> result<transfer, error>;",
 ] as const;
 
-const wit = parseWit(input);
+const nativeToken = parseWit(nativeTokenRaw);
 
 test("KebabToCamel basic mapping", () => {
-  type A = KebabToCamel<"cached-values">;
-  type B = KebabToCamel<"fib-of-sub">;
-  type C = KebabToCamel<"fib">;
-
-  expectTypeOf<A>().toEqualTypeOf<"cachedValues">();
-  expectTypeOf<B>().toEqualTypeOf<"fibOfSub">();
-  expectTypeOf<C>().toEqualTypeOf<"fib">();
-});
-
-test("GetContractReturnType", () => {
-  // expectTypeOf<GetContractReturnType<typeof wit>>().toEqualTypeOf<{
-  //   view: {
-  //     cachedValues: never;
-  //     fibAsView: never;
-  //     readWithRecordArg: never;
-  //     readTools: never;
-  //   };
-  //   proc: {}
-  // }>;
+  type A = KebabToCamel<"total-supply">;
+  type B = KebabToCamel<"balance">;
+  expectTypeOf<A>().toEqualTypeOf<"totalSupply">();
+  expectTypeOf<B>().toEqualTypeOf<"balance">();
 });
+
+test("GetContractReturnType has view and proc", () => {
+  type Contract = GetContractReturnType<typeof nativeToken>;
+
+  expectTypeOf<Contract>().toHaveProperty("view");
+  expectTypeOf<Contract>().toHaveProperty("proc");
+  expectTypeOf<Contract>().toHaveProperty("wit");
+  expectTypeOf<Contract>().toHaveProperty("contractAddress");
+});
+
 test("GetContractReturnType view keys are camelCased", () => {
-  type ViewKeys = keyof GetContractReturnType<typeof wit>["view"];
+  type ViewKeys = keyof GetContractReturnType<typeof nativeToken>["view"];
+
+  expectTypeOf<ViewKeys>().toEqualTypeOf<
+    "balance" | "balances" | "totalSupply"
+  >();
+});
+
+test("GetContractReturnType proc keys are camelCased", () => {
+  type ProcKeys = keyof GetContractReturnType<typeof nativeToken>["proc"];
+
+  expectTypeOf<ProcKeys>().toEqualTypeOf<
+    "mint" | "burn" | "transfer" | "attach" | "detach"
+  >();
+});
+
+test("GetViewFunction for balance - function signature", () => {
+  type BalanceFn = GetViewFunction<
+    true,
+    undefined,
+    typeof nativeToken,
+    "balance"
+  >;
+
+  // Test that it accepts the right parameters
+  type Params = Parameters<BalanceFn>;
+
+  // Should accept args array with string
+  expectTypeOf<Params[0]>().toEqualTypeOf<readonly [string]>();
+
+  // Return type should be Promise<option<decimal>>
+  type Return = Awaited<ReturnType<BalanceFn>>;
+  expectTypeOf<Return>().toEqualTypeOf<["none"] | ["some", [bigint, number]]>();
+});
+
+test("GetViewFunction for balances - no args function signature", () => {
+  type BalancesFn = GetViewFunction<
+    true,
+    undefined,
+    typeof nativeToken,
+    "balances"
+  >;
+
+  // Test that it accepts optional empty args
+  type Params = Parameters<BalancesFn>;
+
+  // Should accept optional args
+  expectTypeOf<Params[0]>().toEqualTypeOf<{
+    chain: Chain | null | undefined;
+  }>();
+
+  // Return type should be Promise<list<balance>>
+  type Return = Awaited<ReturnType<BalancesFn>>;
+  expectTypeOf<Return>().toEqualTypeOf<
+    readonly {
+      acc: string;
+      amt: [bigint, number];
+    }[]
+  >();
+});
+
+test("GetViewFunction for totalSupply - return type", () => {
+  type TotalSupplyFn = GetViewFunction<
+    true,
+    undefined,
+    typeof nativeToken,
+    "total-supply"
+  >;
+
+  type Return = Awaited<ReturnType<TotalSupplyFn>>;
+  expectTypeOf<Return>().toEqualTypeOf<[bigint, number]>();
+});
+
+test("GetProcFunction for mint - function signature", () => {
+  type MintFn = GetProcFunction<
+    true,
+    undefined,
+    undefined,
+    typeof nativeToken,
+    "mint"
+  >;
+
+  // Test parameters
+  type Params = Parameters<MintFn>;
+
+  expectTypeOf<Params[0]>().toEqualTypeOf<readonly [[bigint, number]]>();
+});
+
+test("GetProcFunction for transfer - multiple args", () => {
+  type TransferFn = GetProcFunction<
+    true,
+    undefined,
+    undefined,
+    typeof nativeToken,
+    "transfer"
+  >;
+
+  type Params = Parameters<TransferFn>;
+
+  // Should accept dst string and decimal amount
+  assertType<Params[0]>(["recipient_address", [75n, 18]]);
+
+  expectTypeOf<Params[1]>().toEqualTypeOf<{
+    account: [string, string] | Account | null;
+    chain: Chain | null | undefined;
+    utxos: UtxoId[];
+    gas: bigint;
+    satsPerVByte: number;
+  }>();
+});
+
+test("GetProcFunction for detach - no args function", () => {
+  type DetachFn = GetProcFunction<
+    true,
+    undefined,
+    undefined,
+    typeof nativeToken,
+    "detach"
+  >;
+
+  type Params = Parameters<DetachFn>;
+
+  expectTypeOf<Params[0]>().toEqualTypeOf<{
+    account: [string, string] | Account | null;
+    chain: Chain | null | undefined;
+    utxos: UtxoId[];
+    gas: bigint;
+    satsPerVByte: number;
+  }>();
+});
+
+test("GetContractReturnType - actual function types on contract object", () => {
+  type Contract = GetContractReturnType<typeof nativeToken>;
+
+  // Test view functions
+  type BalanceFunc = Contract["view"]["balance"];
+  type BalancesFunc = Contract["view"]["balances"];
+  type TotalSupplyFunc = Contract["view"]["totalSupply"];
+
+  // Balance should be a function
+  expectTypeOf<BalanceFunc>().toBeFunction();
+  expectTypeOf<BalancesFunc>().toBeFunction();
+  expectTypeOf<TotalSupplyFunc>().toBeFunction();
+
+  // Test proc functions
+  type MintFunc = Contract["proc"]["mint"];
+  type BurnFunc = Contract["proc"]["burn"];
+  type TransferFunc = Contract["proc"]["transfer"];
+  type AttachFunc = Contract["proc"]["attach"];
+  type DetachFunc = Contract["proc"]["detach"];
+
+  expectTypeOf<MintFunc>().toBeFunction();
+  expectTypeOf<BurnFunc>().toBeFunction();
+  expectTypeOf<TransferFunc>().toBeFunction();
+  expectTypeOf<AttachFunc>().toBeFunction();
+  expectTypeOf<DetachFunc>().toBeFunction();
+});
+
+test("getContract runtime - contract structure", () => {
+  const mockClient = {} as KontorIndexerClient;
+
+  const contract = getContract({
+    wit: nativeToken,
+    contractAddress: "token_0_0",
+    client: mockClient,
+  });
+
+  // Test that properties exist at type level
+  expectTypeOf(contract).toHaveProperty("view");
+  expectTypeOf(contract).toHaveProperty("proc");
+  expectTypeOf(contract).toHaveProperty("wit");
+  expectTypeOf(contract).toHaveProperty("contractAddress");
+
+  // Test that view functions have correct names
+  expectTypeOf(contract.view).toHaveProperty("balance");
+  expectTypeOf(contract.view).toHaveProperty("balances");
+  expectTypeOf(contract.view).toHaveProperty("totalSupply");
+
+  // Test that proc functions have correct names
+  expectTypeOf(contract.proc).toHaveProperty("mint");
+  expectTypeOf(contract.proc).toHaveProperty("burn");
+  expectTypeOf(contract.proc).toHaveProperty("transfer");
+  expectTypeOf(contract.proc).toHaveProperty("attach");
+  expectTypeOf(contract.proc).toHaveProperty("detach");
+});
+
+// ─────────────────────────────────────────────────────────────────
+// Storage Agreement Contract Tests
+// ─────────────────────────────────────────────────────────────────
+
+const storageAgreementRaw = [
+  "record agreement-data { agreement-id: string, file-id: string, root: list<u8>, depth: u64, active: bool }",
+  "record create-agreement-result { agreement-id: string }",
+  "record join-agreement-result { agreement-id: string, node-id: string, activated: bool }",
+  "record leave-agreement-result { agreement-id: string, node-id: string }",
+  "export init: func(ctx: borrow<proc-context>);",
+  "export create-agreement: func(ctx: borrow<proc-context>, descriptor: raw-file-descriptor) -> result<create-agreement-result, error>;",
+  "export get-agreement: func(ctx: borrow<view-context>, agreement-id: string) -> option<agreement-data>;",
+  "export agreement-count: func(ctx: borrow<view-context>) -> u64;",
+  "export join-agreement: func(ctx: borrow<proc-context>, agreement-id: string, node-id: string) -> result<join-agreement-result, error>;",
+  "export leave-agreement: func(ctx: borrow<proc-context>, agreement-id: string, node-id: string) -> result<leave-agreement-result, error>;",
+  "export get-agreement-nodes: func(ctx: borrow<view-context>, agreement-id: string) -> option<list<string>>;",
+  "export is-node-in-agreement: func(ctx: borrow<view-context>, agreement-id: string, node-id: string) -> bool;",
+  "export get-min-nodes: func(ctx: borrow<view-context>) -> u64;",
+] as const;
+
+const storageAgreement = parseWit(storageAgreementRaw);
+
+test("Storage Agreement - view keys are camelCased", () => {
+  type ViewKeys = keyof GetContractReturnType<typeof storageAgreement>["view"];
 
-  // For FibAbi, the only view fn is "cached-values", so this should be just "cachedValues"
   expectTypeOf<ViewKeys>().toEqualTypeOf<
-    "cachedValues" | "fibAsView" | "readWithRecordArg"
+    | "getAgreement"
+    | "agreementCount"
+    | "getAgreementNodes"
+    | "isNodeInAgreement"
+    | "getMinNodes"
+  >();
+});
+
+test("Storage Agreement - proc keys are camelCased", () => {
+  type ProcKeys = keyof GetContractReturnType<typeof storageAgreement>["proc"];
+
+  expectTypeOf<ProcKeys>().toEqualTypeOf<
+    "createAgreement" | "joinAgreement" | "leaveAgreement"
+  >();
+});
+
+test("Storage Agreement - get-agreement view function", () => {
+  type GetAgreementFn = GetViewFunction<
+    true,
+    undefined,
+    typeof storageAgreement,
+    "get-agreement"
+  >;
+
+  type Params = Parameters<GetAgreementFn>;
+  expectTypeOf<Params[0]>().toEqualTypeOf<readonly [string]>();
+
+  type Return = Awaited<ReturnType<GetAgreementFn>>;
+
+  expectTypeOf<Return>().toEqualTypeOf<
+    | [
+        "some",
+        {
+          ["agreement-id"]: string;
+          ["file-id"]: string;
+          root: readonly number[];
+          depth: bigint;
+          active: boolean;
+        },
+      ]
+    | ["none"]
   >();
 });
 
-test("getContract", async () => {
-  // const contract = getContract({
-  //   wit: wit,
-  // });
-  // const res0 = contract.view.readWithRecordArg(["token_10_11"]);
-  //
-  // const res = contract.view.cachedValues();
-  //
-  // const res_2 = contract.view.fibAsView([10n]);
-  // const re3 = contract.view.readTools();
+test("Storage Agreement - agreement-count view function", () => {
+  type AgreementCountFn = GetViewFunction<
+    true,
+    undefined,
+    typeof storageAgreement,
+    "agreement-count"
+  >;
+
+  type Params = Parameters<AgreementCountFn>;
+  expectTypeOf<Params[0]>().toEqualTypeOf<{
+    chain: Chain | null | undefined;
+  }>();
+
+  type Return = Awaited<ReturnType<AgreementCountFn>>;
+  expectTypeOf<Return>().toEqualTypeOf<bigint>();
 });
 
-test("GetViewFunction for cached-values (no inputs)", () => {
-  type Fn = GetViewFunction<true, undefined, typeof wit, "cached-values">;
+test("Storage Agreement - get-agreement-nodes view function", () => {
+  type GetAgreementNodesFn = GetViewFunction<
+    true,
+    undefined,
+    typeof storageAgreement,
+    "get-agreement-nodes"
+  >;
+
+  type Params = Parameters<GetAgreementNodesFn>;
+  expectTypeOf<Params[0]>().toEqualTypeOf<readonly [string]>();
+
+  type Return = Awaited<ReturnType<GetAgreementNodesFn>>;
+  expectTypeOf<Return>().toEqualTypeOf<
+    ["some", readonly string[]] | ["none"]
+  >();
+});
+
+test("Storage Agreement - is-node-in-agreement view function", () => {
+  type IsNodeInAgreementFn = GetViewFunction<
+    true,
+    undefined,
+    typeof storageAgreement,
+    "is-node-in-agreement"
+  >;
+
+  type Params = Parameters<IsNodeInAgreementFn>;
+  expectTypeOf<Params[0]>().toEqualTypeOf<readonly [string, string]>();
+
+  type Return = Awaited<ReturnType<IsNodeInAgreementFn>>;
+  expectTypeOf<Return>().toEqualTypeOf<boolean>();
+});
+
+test("Storage Agreement - get-min-nodes view function", () => {
+  type GetMinNodesFn = GetViewFunction<
+    true,
+    undefined,
+    typeof storageAgreement,
+    "get-min-nodes"
+  >;
+
+  type Params = Parameters<GetMinNodesFn>;
+  expectTypeOf<Params[0]>().toEqualTypeOf<{
+    chain: Chain | null | undefined;
+  }>();
+
+  type Return = Awaited<ReturnType<GetMinNodesFn>>;
+  expectTypeOf<Return>().toEqualTypeOf<bigint>();
+});
+
+test("Storage Agreement - create-agreement proc function", () => {
+  type CreateAgreementFn = GetProcFunction<
+    true,
+    undefined,
+    undefined,
+    typeof storageAgreement,
+    "create-agreement"
+  >;
+
+  type Params = Parameters<CreateAgreementFn>;
+  // raw-file-descriptor is an unknown type
+  expectTypeOf<Params[0]>().toEqualTypeOf<readonly [unknown]>();
+  expectTypeOf<Params[1]>().toEqualTypeOf<{
+    account: [string, string] | Account | null;
+    chain: Chain | null | undefined;
+    utxos: UtxoId[];
+    gas: bigint;
+    satsPerVByte: number;
+  }>();
+});
+
+test("Storage Agreement - join-agreement proc function", () => {
+  type JoinAgreementFn = GetProcFunction<
+    true,
+    undefined,
+    undefined,
+    typeof storageAgreement,
+    "join-agreement"
+  >;
+
+  type Params = Parameters<JoinAgreementFn>;
+  assertType<Params[0]>(["agreement-123", "node-456"]);
+
+  expectTypeOf<Params[1]>().toEqualTypeOf<{
+    account: [string, string] | Account | null;
+    chain: Chain | null | undefined;
+    utxos: UtxoId[];
+    gas: bigint;
+    satsPerVByte: number;
+  }>();
+});
+
+test("Storage Agreement - leave-agreement proc function", () => {
+  type LeaveAgreementFn = GetProcFunction<
+    true,
+    undefined,
+    undefined,
+    typeof storageAgreement,
+    "leave-agreement"
+  >;
+
+  type Params = Parameters<LeaveAgreementFn>;
+  assertType<Params[0]>(["agreement-123", "node-456"]);
+
+  expectTypeOf<Params[1]>().toEqualTypeOf<{
+    account: [string, string] | Account | null;
+    chain: Chain | null | undefined;
+    utxos: UtxoId[];
+    gas: bigint;
+    satsPerVByte: number;
+  }>();
+});
+
+test("Storage Agreement - getContract runtime structure", () => {
+  const mockClient = {} as KontorIndexerClient;
+
+  const contract = getContract({
+    wit: storageAgreement,
+    contractAddress: "agreement_0_0",
+    client: mockClient,
+  });
+
+  // Test view functions
+  expectTypeOf(contract.view).toHaveProperty("getAgreement");
+  expectTypeOf(contract.view).toHaveProperty("agreementCount");
+  expectTypeOf(contract.view).toHaveProperty("getAgreementNodes");
+  expectTypeOf(contract.view).toHaveProperty("isNodeInAgreement");
+  expectTypeOf(contract.view).toHaveProperty("getMinNodes");
 
-  // return type: Promise<ViewContractReturnType<...>>
-  // kay
-  expectTypeOf<Awaited<ReturnType<Fn>>>().toEqualTypeOf<readonly bigint[]>();
+  expectTypeOf(contract.proc).toHaveProperty("createAgreement");
+  expectTypeOf(contract.proc).toHaveProperty("joinAgreement");
+  expectTypeOf(contract.proc).toHaveProperty("leaveAgreement");
 });