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

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

@@ -1,17 +1,12 @@
-import { test } from "vitest";
-// import { procContract } from "./proc-contract.js";
+import { test, vi, expect } from "vitest";
 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 { signet } from "../../../../exports/index.js";
+import { createHttpTransport } from "../../../../sdk/clients/transports/create-http-transport.js";
+import { signet } from "../../../chains/definitions/signet.js";
 
-// define the wit
-const input = [
+// Token Contract WIT
+const tokenWit = [
   "record balance { key: string, value: decimal }",
-  // TODO: barfing on core-context
-  // "export issuance: func(ctx: borrow<core-context>, n: decimal) -> result<_, error>;",
-  // "export hold: func(ctx: borrow<core-context>, n: decimal) -> result<_, error>;",
-  // "export burn-and-release: func(ctx: borrow<core-context>, n: decimal) -> result<_, error>;",
   "export init: func(ctx: borrow<proc-context>);",
   "export mint: func(ctx: borrow<proc-context>, n: decimal) -> result<_, error>;",
   "export burn: func(ctx: borrow<proc-context>, n: decimal) -> result<_, error>;",
@@ -21,28 +16,221 @@ const input = [
   "export total-supply: func(ctx: borrow<view-context>) -> decimal;",
 ] as const;
 
-const wit = parseWit(input);
+const wit = parseWit(tokenWit);
+
+test("mint", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return { result: {} };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+    account: [
+      "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
+      "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
+    ],
+  });
+
+  await client.procContract({
+    wit: wit,
+    functionName: "mint",
+    contractAddress: "token_0_0",
+    args: [[100n, 0]], // decimal is [bigint, number] tuple
+    satsPerVByte: 1,
+    utxos: [
+      "57f1f46857ab12e20f32ecaac780b4096b0951458e15ab08e2ce0992f0521323:0",
+    ],
+    gas: 10n,
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/transactions/compose",
+    method: "POST",
+    body: {
+      envelope: null,
+      instructions: [
+        {
+          address:
+            "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
+          chained_instruction: null,
+          funding_utxo_ids:
+            "57f1f46857ab12e20f32ecaac780b4096b0951458e15ab08e2ce0992f0521323:0",
+          instruction: {
+            Call: {
+              contract: "token_0_0",
+              expr: "mint({r0: 7766279631452241920, r1: 5, r2: 0, r3: 0, sign: plus})",
+              gas_limit: 10,
+            },
+          },
+          x_only_public_key:
+            "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
+        },
+      ],
+      sat_per_vbyte: 1,
+    },
+  });
+});
+
+test("burn", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return { result: {} };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
 
-test.skip("e2e", async () => {
   const client = createPublicClient({
-    transport: http("https://signet.kontor.network:35000/api"),
-    // optional parameter
+    transport: mockTransport,
+    chain: signet,
     account: [
       "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
       "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
     ],
+  });
+
+  await client.procContract({
+    wit: wit,
+    functionName: "burn",
+    contractAddress: "token_0_0",
+    args: [[50n, 0]],
+    satsPerVByte: 1,
+    utxos: [
+      "57f1f46857ab12e20f32ecaac780b4096b0951458e15ab08e2ce0992f0521323:0",
+    ],
+    gas: 10n,
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/transactions/compose",
+    method: "POST",
+    body: {
+      envelope: null,
+      instructions: [
+        {
+          address:
+            "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
+          chained_instruction: null,
+          funding_utxo_ids:
+            "57f1f46857ab12e20f32ecaac780b4096b0951458e15ab08e2ce0992f0521323:0",
+          instruction: {
+            Call: {
+              contract: "token_0_0",
+              expr: "burn({r0: 13106511852580896768, r1: 2, r2: 0, r3: 0, sign: plus})",
+              gas_limit: 10,
+            },
+          },
+          x_only_public_key:
+            "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
+        },
+      ],
+      sat_per_vbyte: 1,
+    },
+  });
+});
+
+test("transfer", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return { result: {} };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
     chain: signet,
+    account: [
+      "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
+      "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
+    ],
   });
 
-  // proc contract action defined on client
-  // response is correctly typed
-  const res = await client.procContract({
+  await client.procContract({
     wit: wit,
-    // can also be injected
+    functionName: "transfer",
+    contractAddress: "token_0_0",
+    args: ["tb1q...", [25n, 0]],
+    satsPerVByte: 1,
+    utxos: [
+      "57f1f46857ab12e20f32ecaac780b4096b0951458e15ab08e2ce0992f0521323:0",
+    ],
+    gas: 10n,
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/transactions/compose",
+    method: "POST",
+    body: {
+      envelope: null,
+      instructions: [
+        {
+          address:
+            "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
+          chained_instruction: null,
+          funding_utxo_ids:
+            "57f1f46857ab12e20f32ecaac780b4096b0951458e15ab08e2ce0992f0521323:0",
+          instruction: {
+            Call: {
+              contract: "token_0_0",
+              expr: 'transfer("tb1q...", {r0: 6553255926290448384, r1: 1, r2: 0, r3: 0, sign: plus})',
+              gas_limit: 10,
+            },
+          },
+          x_only_public_key:
+            "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
+        },
+      ],
+      sat_per_vbyte: 1,
+    },
+  });
+});
+
+test("mint with scientific notation decimal", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return { result: {} };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+    account: [
+      "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
+      "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
+    ],
+  });
 
-    functionName: "mint", // functin name is only valid if it's got a proc-context
+  await client.procContract({
+    wit: wit,
+    functionName: "mint",
     contractAddress: "token_0_0",
-    args: [[7n, 18]],
+    args: [[7n, 18]], // 7 * 10^18
     satsPerVByte: 1,
     utxos: [
       "57f1f46857ab12e20f32ecaac780b4096b0951458e15ab08e2ce0992f0521323:0",
@@ -50,5 +238,30 @@ test.skip("e2e", async () => {
     gas: 10n,
   });
 
-  console.log({ callproc: res.result });
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/transactions/compose",
+    method: "POST",
+    body: {
+      envelope: null,
+      instructions: [
+        {
+          address:
+            "tb1pj2wrjsg0ksmmflec0myf3j7qnqm9myvk2pesqn7y8cqn6sgdg9ls9u6tar",
+          chained_instruction: null,
+          funding_utxo_ids:
+            "57f1f46857ab12e20f32ecaac780b4096b0951458e15ab08e2ce0992f0521323:0",
+          instruction: {
+            Call: {
+              contract: "token_0_0",
+              expr: "mint({r0: 7, r1: 0, r2: 0, r3: 0, sign: plus})",
+              gas_limit: 10,
+            },
+          },
+          x_only_public_key:
+            "2c7b730daa0036e8276cdd8fabe844b2dd324a6d227dd209663805189d03e51f",
+        },
+      ],
+      sat_per_vbyte: 1,
+    },
+  });
 });

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

@@ -0,0 +1,240 @@
+import { expectTypeOf, test } from "vitest";
+import { parseWit } from "../../../../wit/wit-parser/parse-wit.js";
+import type {
+  ViewContractReturnType,
+  ViewContractParameters,
+} from "./view-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("get-colors return type", () => {
+  type Result = ViewContractReturnType<typeof colorPalette, "get-colors">;
+
+  expectTypeOf<Result>().toEqualTypeOf<
+    readonly (
+      | ["hex", string]
+      | [
+          "rgb",
+          {
+            r: number;
+            g: number;
+            b: number;
+          },
+        ]
+      | [
+          "hsv",
+          {
+            h: number;
+            s: number;
+            v: number;
+          },
+        ]
+      | ["named", string]
+    )[]
+  >();
+});
+
+test("get-color return type", () => {
+  type Result = ViewContractReturnType<typeof colorPalette, "get-color">;
+
+  expectTypeOf<Result>().toEqualTypeOf<
+    | ["none"]
+    | [
+        "some",
+        (
+          | ["hex", string]
+          | [
+              "rgb",
+              {
+                r: number;
+                g: number;
+                b: number;
+              },
+            ]
+          | [
+              "hsv",
+              {
+                h: number;
+                s: number;
+                v: number;
+              },
+            ]
+          | ["named", string]
+        ),
+      ]
+  >();
+});
+
+test("get-status return type", () => {
+  type Result = ViewContractReturnType<typeof colorPalette, "get-status", []>;
+
+  expectTypeOf<Result>().toEqualTypeOf<
+    "active" | "archived" | "locked" | "readonly"
+  >();
+});
+
+test("get-info return type", () => {
+  type Result = ViewContractReturnType<typeof colorPalette, "get-info", []>;
+
+  expectTypeOf<Result>().toEqualTypeOf<{
+    name: string;
+    size: number;
+    owner: string;
+  }>();
+});
+
+test("query-colors argument type - should be discriminated union", () => {
+  type Params = ViewContractParameters<typeof colorPalette, "query-colors">;
+
+  expectTypeOf<Params["args"]>().toEqualTypeOf<
+    readonly [
+      | ["by-name", string]
+      | ["by-index", number]
+      | ["all"]
+      | ["by-status", "active" | "archived" | "locked" | "readonly"],
+    ]
+  >;
+});
+
+test("query-colors return type", () => {
+  type Result = ViewContractReturnType<typeof colorPalette, "query-colors">;
+
+  expectTypeOf<Result>().toEqualTypeOf<
+    readonly (
+      | ["hex", string]
+      | [
+          "rgb",
+          {
+            r: number;
+            g: number;
+            b: number;
+          },
+        ]
+      | [
+          "hsv",
+          {
+            h: number;
+            s: number;
+            v: number;
+          },
+        ]
+      | ["named", string]
+    )[]
+  >();
+});
+
+test("find-color argument type - color variant", () => {
+  type Params = ViewContractParameters<typeof colorPalette, "find-color">;
+
+  expectTypeOf<Params["args"]>().toEqualTypeOf<
+    readonly [
+      | ["hex", string]
+      | ["named", string]
+      | [
+          "rgb",
+          {
+            r: number;
+            g: number;
+            b: number;
+          },
+        ]
+      | [
+          "hsv",
+          {
+            h: number;
+            s: number;
+            v: number;
+          },
+        ],
+    ]
+  >;
+});
+
+test("find-color return type", () => {
+  type Result = ViewContractReturnType<
+    typeof colorPalette,
+    "find-color",
+    [
+      | ["hex", string]
+      | ["rgb", { r: number; g: number; b: number }]
+      | ["hsv", { h: number; s: number; v: number }]
+      | ["named", string],
+    ]
+  >;
+
+  expectTypeOf<Result>().toEqualTypeOf<["none"] | ["some", number]>();
+});
+
+test("get-recent-events return type", () => {
+  type Result = ViewContractReturnType<
+    typeof colorPalette,
+    "get-recent-events",
+    [number]
+  >;
+
+  expectTypeOf<Result>().toEqualTypeOf<
+    readonly (
+      | [
+          "created",
+          {
+            name: string;
+            size: number;
+            owner: string;
+          },
+        ]
+      | [
+          "color-added",
+          (
+            | ["hex", string]
+            | [
+                "rgb",
+                {
+                  r: number;
+                  g: number;
+                  b: number;
+                },
+              ]
+            | [
+                "hsv",
+                {
+                  h: number;
+                  s: number;
+                  v: number;
+                },
+              ]
+            | ["named", string]
+          ),
+        ]
+      | ["color-removed", number]
+      | ["status-changed", "active" | "archived" | "locked" | "readonly"]
+    )[]
+  >();
+});