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

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

@@ -1,49 +1,349 @@
-import { test } from "vitest";
+import { test, vi, expect } 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";
+import { createHttpTransport } from "../clients/transports/create-http-transport.js";
+
+const mockAccount: [string, string] = [
+  "mock_address",
+  "0000000000000000000000000000000000000000000000000000000000000001",
+];
+
+test("native token - view: balance", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return {
+      result: {
+        type: "Ok",
+        value: "some({r0: 1, r1: 0, r2: 0, r3: 0, sign: plus})",
+      },
+    };
+  });
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+  const kontorPublicClient = createKontorPublicClient({
+    transport: mockTransport,
+    chain: signet,
+    account: mockAccount,
+  });
+  const contract = getContract({
+    wit: nativeToken,
+    contractAddress: "token_0_0",
+    client: kontorPublicClient,
+  });
+  const result = await contract.view.balance(["acc123"]);
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "token_0_0" },
+    body: { expr: 'balance("acc123")' },
+  });
+  expect(result).toEqual(["some", [1n, 18]]);
+});
+
+test("native token - proc: mint", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return {
+      result: {
+        type: "Ok",
+        value:
+          'ok({dst: "acc123", amt: {r0: 100, r1: 0, r2: 0, r3: 0, sign: plus}})',
+      },
+    };
+  });
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+  const kontorPublicClient = createKontorPublicClient({
+    transport: mockTransport,
+    chain: signet,
+    account: mockAccount,
+  });
+  const contract = getContract({
+    wit: nativeToken,
+    contractAddress: "token_0_0",
+    client: kontorPublicClient,
+  });
+
+  await contract.proc.mint([[100n, 18]], {
+    utxos: ["utxo1"],
+    gas: 1000n,
+    satsPerVByte: 1,
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/transactions/compose",
+    method: "POST",
+    body: {
+      envelope: null,
+      instructions: [
+        {
+          address: "mock_address",
+          chained_instruction: null,
+          funding_utxo_ids: "utxo1",
+          instruction: {
+            Call: {
+              contract: "token_0_0",
+              expr: "mint({r0: 100, r1: 0, r2: 0, r3: 0, sign: plus})",
+              gas_limit: 1000,
+            },
+          },
+          x_only_public_key:
+            "0000000000000000000000000000000000000000000000000000000000000001",
+        },
+      ],
+      sat_per_vbyte: 1,
+    },
+  });
+});
+
+test("native token - proc: burn", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return {
+      result: {
+        type: "Ok",
+        value:
+          'ok({src: "acc123", amt: {r0: 50, r1: 0, r2: 0, r3: 0, sign: plus}})',
+      },
+    };
+  });
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+  const kontorPublicClient = createKontorPublicClient({
+    transport: mockTransport,
+    chain: signet,
+    account: mockAccount,
+  });
+  const contract = getContract({
+    wit: nativeToken,
+    contractAddress: "token_0_0",
+    client: kontorPublicClient,
+  });
+
+  await contract.proc.burn([[50n, 18]], {
+    utxos: ["utxo2"],
+    gas: 1000n,
+    satsPerVByte: 1,
+  });
 
-test("e2e getContract", async () => {
-  const account = mnemonicToAccount(process.env.TEST_MNEMONIC!, {
-    coinType: 1,
-    networkConfig: signet.networkConfig,
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/transactions/compose",
+    method: "POST",
+    body: {
+      envelope: null,
+      instructions: [
+        {
+          address: "mock_address",
+          chained_instruction: null,
+          funding_utxo_ids: "utxo2",
+          instruction: {
+            Call: {
+              contract: "token_0_0",
+              expr: "burn({r0: 50, r1: 0, r2: 0, r3: 0, sign: plus})",
+              gas_limit: 1000,
+            },
+          },
+          x_only_public_key:
+            "0000000000000000000000000000000000000000000000000000000000000001",
+        },
+      ],
+      sat_per_vbyte: 1,
+    },
   });
+});
 
-  // if chain is omittet here
+test("native token - proc: transfer", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return {
+      result: {
+        type: "Ok",
+        value:
+          'ok({src: "acc123", dst: "dst_acc", amt: {r0: 75, r1: 0, r2: 0, r3: 0, sign: plus}})',
+      },
+    };
+  });
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
   const kontorPublicClient = createKontorPublicClient({
-    transport: http("https://signet-staging.kontor.network:35000/api"),
+    transport: mockTransport,
     chain: signet,
-    account,
+    account: mockAccount,
+  });
+  const contract = getContract({
+    wit: nativeToken,
+    contractAddress: "token_0_0",
+    client: kontorPublicClient,
+  });
+
+  await contract.proc.transfer(["dst_acc", [75n, 18]], {
+    utxos: ["utxo3"],
+    gas: 1000n,
+    satsPerVByte: 1,
   });
 
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/transactions/compose",
+    method: "POST",
+    body: {
+      envelope: null,
+      instructions: [
+        {
+          address: "mock_address",
+          chained_instruction: null,
+          funding_utxo_ids: "utxo3",
+          instruction: {
+            Call: {
+              contract: "token_0_0",
+              expr: 'transfer("dst_acc", {r0: 75, r1: 0, r2: 0, r3: 0, sign: plus})',
+              gas_limit: 1000,
+            },
+          },
+          x_only_public_key:
+            "0000000000000000000000000000000000000000000000000000000000000001",
+        },
+      ],
+      sat_per_vbyte: 1,
+    },
+  });
+});
+
+test("native token - proc: attach", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return {
+      result: {
+        type: "Ok",
+        value:
+          'ok({src: "utxo", dst: "contract", amt: {r0: 25, r1: 0, r2: 0, r3: 0, sign: plus}})',
+      },
+    };
+  });
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+  const kontorPublicClient = createKontorPublicClient({
+    transport: mockTransport,
+    chain: signet,
+    account: mockAccount,
+  });
   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();
+  await contract.proc.attach([1n, [25n, 18]], {
+    utxos: ["utxo4"],
+    gas: 1000n,
+    satsPerVByte: 1,
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/transactions/compose",
+    method: "POST",
+    body: {
+      envelope: null,
+      instructions: [
+        {
+          address: "mock_address",
+          chained_instruction: null,
+          funding_utxo_ids: "utxo4",
+          instruction: {
+            Call: {
+              contract: "token_0_0",
+              expr: "attach(1, {r0: 25, r1: 0, r2: 0, r3: 0, sign: plus})",
+              gas_limit: 1000,
+            },
+          },
+          x_only_public_key:
+            "0000000000000000000000000000000000000000000000000000000000000001",
+        },
+      ],
+      sat_per_vbyte: 1,
+    },
+  });
+});
 
-  const balance = await contract.view.balance([
-    "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
-  ]);
+test("native token - proc: detach", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return {
+      result: {
+        type: "Ok",
+        value:
+          'ok({src: "contract", dst: "utxo", amt: {r0: 10, r1: 0, r2: 0, r3: 0, sign: plus}})',
+      },
+    };
+  });
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+  const kontorPublicClient = createKontorPublicClient({
+    transport: mockTransport,
+    chain: signet,
+    account: mockAccount,
+  });
+  const contract = getContract({
+    wit: nativeToken,
+    contractAddress: "token_0_0",
+    client: kontorPublicClient,
+  });
 
-  const composeOutputs = await contract.proc.burn([[1n, 18]], {
-    utxos: [
-      "641c40edf4cf0f1cdaea5c259bf50267bd8743dbade84c98bb9e360c2d0e2a33:1",
-    ],
+  await contract.proc.detach({
+    utxos: ["utxo5", "utxo6"],
     gas: 1000n,
     satsPerVByte: 1,
+    args: [],
   });
 
-  console.log({ balances });
-  console.log({ balance });
-  console.log({ composeOutputs });
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/transactions/compose",
+    method: "POST",
+    body: {
+      envelope: null,
+      instructions: [
+        {
+          address: "mock_address",
+          chained_instruction: null,
+          funding_utxo_ids: "utxo5,utxo6",
+          instruction: {
+            Call: {
+              contract: "token_0_0",
+              expr: "detach()",
+              gas_limit: 1000,
+            },
+          },
+          x_only_public_key:
+            "0000000000000000000000000000000000000000000000000000000000000001",
+        },
+      ],
+      sat_per_vbyte: 1,
+    },
+  });
 });

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

@@ -1,3 +1,4 @@
+import type { Pretty } from "../../../../wit/type-utils.js";
 import type {
   ResultResponse,
   ViewResult,
@@ -15,7 +16,7 @@ export type CallViewParameters<
   wave: string;
 } & GetChainParameter<chain, chainOverride>;
 // TODO: refine this type
-export type CallViewReturnType = ResultResponse<ViewResult>;
+export type CallViewReturnType = Pretty<ResultResponse<ViewResult>>;
 
 export async function callView<
   chain extends Chain | undefined = Chain | undefined,

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

@@ -0,0 +1,107 @@
+import { expectTypeOf, test } from "vitest";
+import { parseWit } from "../../../../wit/wit-parser/parse-wit.js";
+import type { ProcContractParameters } from "./proc-contract.js";
+
+// Color Palette Contract - demonstrates variants and enums in WIT
+const colorPaletteWit = [
+  // Records
+  "record rgb { r: u8, g: u8, b: u8 }",
+  "record hsv { h: u16, s: u8, v: u8 }",
+  "record palette-info { name: string, size: u32, owner: string }",
+  // Enums
+  "enum palette-status { active, archived, locked, readonly }",
+  "enum sort-order { alphabetical, creation-date, usage-count }",
+  // Variants
+  "variant color { hex(string), rgb(rgb), hsv(hsv), named(string) }",
+  "variant query { by-name(string), by-index(u32), all, by-status(palette-status) }",
+  "variant palette-event { created(palette-info), color-added(color), color-removed(u32), status-changed(palette-status) }",
+  // Proc functions
+  "export add-color: func(ctx: borrow<proc-context>, c: color) -> result<list<color>, error>;",
+  "export remove-color: func(ctx: borrow<proc-context>, index: u32) -> result<color, error>;",
+  "export set-status: func(ctx: borrow<proc-context>, status: palette-status) -> result<palette-status, error>;",
+  "export sort-colors: func(ctx: borrow<proc-context>, order: sort-order) -> result<_, error>;",
+  // View functions
+  "export get-colors: func(ctx: borrow<view-context>) -> list<color>;",
+  "export get-color: func(ctx: borrow<view-context>, index: u32) -> option<color>;",
+  "export get-status: func(ctx: borrow<view-context>) -> palette-status;",
+  "export get-info: func(ctx: borrow<view-context>) -> palette-info;",
+  "export query-colors: func(ctx: borrow<view-context>, q: query) -> list<color>;",
+  "export find-color: func(ctx: borrow<view-context>, c: color) -> option<u32>;",
+  "export get-recent-events: func(ctx: borrow<view-context>, limit: u32) -> list<palette-event>;",
+] as const;
+
+const colorPalette = parseWit(colorPaletteWit);
+test("add-color argument type - color variant", () => {
+  type Params = ProcContractParameters<typeof colorPalette, "add-color">;
+
+  expectTypeOf<Params["args"]>().toEqualTypeOf<
+    readonly [
+      | ["hex", string]
+      | [
+          "rgb",
+          {
+            r: number;
+            g: number;
+            b: number;
+          },
+        ]
+      | [
+          "hsv",
+          {
+            h: number;
+            s: number;
+            v: number;
+          },
+        ]
+      | ["named", string],
+    ]
+  >;
+});
+
+test("remove-color argument type", () => {
+  type Params = ProcContractParameters<typeof colorPalette, "remove-color">;
+
+  expectTypeOf<Params["args"]>().toEqualTypeOf<readonly [number]>();
+});
+
+test("set-status argument type - enum", () => {
+  type Params = ProcContractParameters<typeof colorPalette, "set-status">;
+
+  expectTypeOf<Params["args"]>().toEqualTypeOf<
+    readonly ["active" | "archived" | "locked" | "readonly"]
+  >;
+});
+
+test("sort-colors argument type - enum", () => {
+  type Params = ProcContractParameters<typeof colorPalette, "sort-colors">;
+
+  expectTypeOf<Params["args"]>().toEqualTypeOf<
+    readonly ["alphabetical" | "creation-date" | "usage-count"]
+  >;
+});
+
+test("add-color argument type - color variant", () => {
+  type Params = ProcContractParameters<typeof colorPalette, "add-color">;
+  expectTypeOf<Params["args"]>().toEqualTypeOf<
+    readonly [
+      | ["hex", string]
+      | [
+          "rgb",
+          {
+            r: number;
+            g: number;
+            b: number;
+          },
+        ]
+      | [
+          "hsv",
+          {
+            h: number;
+            s: number;
+            v: number;
+          },
+        ]
+      | ["named", string],
+    ]
+  >;
+});