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

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

@@ -1,33 +1,628 @@
-import { test } from "vitest";
+import { test, vi, expect } from "vitest";
 import { viewContract } from "./view-contract.js";
 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 { nativeToken } from "../../../contracts/wits.js";
+import { createHttpTransport } from "../../../../sdk/clients/transports/create-http-transport.js";
 import { signet } from "../../../chains/definitions/signet.js";
 
-const wit = parseWit(nativeToken.raw);
+// 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>;",
+
+  "export get-color-result: func(ctx: borrow<view-context>, index: u32) -> result<color, error>;",
+] as const;
+
+const colorPalette = parseWit(colorPaletteWit);
+
+test("get-colors", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns list<color> - a list of color variants
+    return {
+      result: {
+        type: "Ok",
+        value: '[hex("#FF5733"), rgb({r: 255, g: 87, b: 51}), named("tomato")]',
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await client.viewContract({
+    wit: colorPalette,
+    functionName: "get-colors",
+    contractAddress: "palette_0_0",
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: "get-colors()" },
+  });
+
+  // Verify deserialized result - list<color> becomes array of variant tuples
+  expect(result).toEqual([
+    ["hex", "#FF5733"],
+    ["rgb", { r: 255, g: 87, b: 51 }],
+    ["named", "tomato"],
+  ]);
+});
+
+test("get-color", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns option<color> - some variant with a color
+    return {
+      result: {
+        type: "Ok",
+        value: 'some(hex("#FF5733"))',
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "get-color",
+    contractAddress: "palette_0_0",
+    args: [0],
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: "get-color(0)" },
+  });
+
+  // Verify deserialized result - option<color> with some
+  expect(result).toEqual(["some", ["hex", "#FF5733"]]);
+});
+
+test("get-color returns none", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return {
+      result: {
+        type: "Ok",
+        value: "none",
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "get-color",
+    contractAddress: "palette_0_0",
+    args: [99],
+  });
+
+  // Verify deserialized result - option with none
+  expect(result).toEqual(["none"]);
+});
+
+test("get-status", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns palette-status enum
+    return {
+      result: {
+        type: "Ok",
+        value: "active",
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "get-status",
+    contractAddress: "palette_0_0",
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: "get-status()" },
+  });
+
+  // Verify deserialized result - enum becomes the string value
+  expect(result).toBe("active");
+});
+
+test("get-info", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns palette-info record
+    return {
+      result: {
+        type: "Ok",
+        value: '{name: "My Palette", size: 5, owner: "user123"}',
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
 
-test("e2e", async () => {
   const client = createPublicClient({
-    transport: http("https://signet-staging.kontor.network:35000/api"),
+    transport: mockTransport,
     chain: signet,
   });
 
-  const res = await client.viewContract({
-    wit: wit,
-    functionName: "balances", // functin name is only valid if it's got a view-context
-    contractAddress: "token_0_0",
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "get-info",
+    contractAddress: "palette_0_0",
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: "get-info()" },
+  });
+
+  // Verify deserialized result - record becomes an object
+  expect(result).toEqual({
+    name: "My Palette",
+    size: 5,
+    owner: "user123",
+  });
+});
+
+test("query-colors with all", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns list<color>
+    return {
+      result: {
+        type: "Ok",
+        value: '[hex("#FF5733"), rgb({r: 10, g: 150, b: 200})]',
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "query-colors",
+    contractAddress: "palette_0_0",
+    args: [["all"]],
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: "query-colors(all)" },
+  });
+
+  // Verify deserialized result
+  expect(result).toEqual([
+    ["hex", "#FF5733"],
+    ["rgb", { r: 10, g: 150, b: 200 }],
+  ]);
+});
+
+test("query-colors with by-name", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns list<color>
+    return {
+      result: {
+        type: "Ok",
+        value: '[named("sunset"), hex("#FF6347")]',
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "query-colors",
+    contractAddress: "palette_0_0",
+    args: [["by-name", "sunset"]],
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: 'query-colors(by-name("sunset"))' },
+  });
+
+  // Verify deserialized result
+  expect(result).toEqual([
+    ["named", "sunset"],
+    ["hex", "#FF6347"],
+  ]);
+});
+
+test("query-colors with by-index", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns list<color>
+    return {
+      result: {
+        type: "Ok",
+        value: "[rgb({r: 255, g: 0, b: 0})]",
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "query-colors",
+    contractAddress: "palette_0_0",
+    args: [["by-index", 5]],
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: "query-colors(by-index(5))" },
+  });
+
+  // Verify deserialized result
+  expect(result).toEqual([["rgb", { r: 255, g: 0, b: 0 }]]);
+});
+
+test("query-colors with by-status", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns list<color>
+    return {
+      result: {
+        type: "Ok",
+        value: '[hex("#00FF00"), named("green")]',
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "query-colors",
+    contractAddress: "palette_0_0",
+    args: [["by-status", "active"]],
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: "query-colors(by-status(active))" },
+  });
+
+  // Verify deserialized result
+  expect(result).toEqual([
+    ["hex", "#00FF00"],
+    ["named", "green"],
+  ]);
+});
+
+test("find-color with hex variant", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns option<u32>
+    return {
+      result: {
+        type: "Ok",
+        value: "some(3)",
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "find-color",
+    contractAddress: "palette_0_0",
+    args: [["hex", "#FF5733"]],
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: 'find-color(hex("#FF5733"))' },
+  });
+
+  // Verify deserialized result - option<u32> with some
+  expect(result).toEqual(["some", 3]);
+});
+
+test("find-color with rgb variant", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns option<u32>
+    return {
+      result: {
+        type: "Ok",
+        value: "some(7)",
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "find-color",
+    contractAddress: "palette_0_0",
+    args: [["rgb", { r: 255, g: 87, b: 51 }]],
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: "find-color(rgb({r: 255, g: 87, b: 51}))" },
+  });
+
+  // Verify deserialized result
+  expect(result).toEqual(["some", 7]);
+});
+
+test("find-color with named variant returns none", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns option<u32> - none in this case
+    return {
+      result: {
+        type: "Ok",
+        value: "none",
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "find-color",
+    contractAddress: "palette_0_0",
+    args: [["named", "tomato"]],
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: 'find-color(named("tomato"))' },
+  });
+
+  // Verify deserialized result - option with none
+  expect(result).toEqual(["none"]);
+});
+
+test("get-recent-events", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    // Returns list<palette-event>
+    return {
+      result: {
+        type: "Ok",
+        value:
+          '[created({name: "Summer Palette", size: 10, owner: "alice"}), color-added(hex("#FF5733")), status-changed(active)]',
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
+  });
+
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "get-recent-events",
+    contractAddress: "palette_0_0",
+    args: [10],
+  });
+
+  expect(transportRequestMock).toHaveBeenCalledWith({
+    route: "/contracts/:contractAddress",
+    method: "POST",
+    path: { contractAddress: "palette_0_0" },
+    body: { expr: "get-recent-events(10)" },
+  });
+
+  expect(result).toEqual([
+    ["created", { name: "Summer Palette", size: 10, owner: "alice" }],
+    ["color-added", ["hex", "#FF5733"]],
+    ["status-changed", "active"],
+  ]);
+});
+
+test("get-color returns none", async () => {
+  const transportRequestMock = vi.fn(async (_request) => {
+    return {
+      result: {
+        type: "Ok",
+        value: `err(validation("color not found"))`,
+      },
+    };
+  });
+
+  const mockTransport = () =>
+    createHttpTransport({
+      key: "mock",
+      name: "Mock Transport",
+      request: transportRequestMock,
+      type: "mock",
+    });
+
+  const client = createPublicClient({
+    transport: mockTransport,
+    chain: signet,
   });
 
-  console.log("res:", res);
-  // inject client directly into view contract action
-  const res2 = await viewContract(client, {
-    wit: wit,
-    functionName: "balance",
-    contractAddress: "token_0_0",
-    args: ["252a90b16b5c25b9f366ab4b518f9f2ce3624d23c05dc26f7649f51515c76e2d"],
+  const result = await viewContract(client, {
+    wit: colorPalette,
+    functionName: "get-color-result",
+    contractAddress: "palette_0_0",
+    args: [99],
   });
 
-  console.log("res2:", res2);
+  // Verify deserialized result - option with none
+  expect(result).toEqual(["err", ["validation", "color not found"]]);
 });

package/src/sdk/chains/definitions/signet.ts

@@ -6,8 +6,8 @@ export const signet = defineChain({
   blockTime: 1_000 * 60 * 10,
   urls: {
     default: {
-      http: ["https://signet-staging.kontor.network:35000/api"],
-      webSocket: ["wss://signet-staging.kontor.network:35000/ws"],
+      http: ["https://signet-staging.kontor.network:35001/api"],
+      webSocket: ["wss://signet-staging.kontor.network:35001/ws"],
       // TODO: maybe need to add auth
       bitcoinRpc: ["https://signet-staging.kontor.network:38332"],
     },

package/src/sdk/clients/base/create-rpc-client.test.ts

@@ -97,10 +97,10 @@ describe("transports", () => {
            "https://signet-staging.kontor.network:38332",
          ],
          "http": [
-           "https://signet-staging.kontor.network:35000/api",
+           "https://signet-staging.kontor.network:35001/api",
          ],
          "webSocket": [
-           "wss://signet-staging.kontor.network:35000/ws",
+           "wss://signet-staging.kontor.network:35001/ws",
          ],
        },
      },

package/src/sdk/clients/create-public-client.test.ts

@@ -100,10 +100,10 @@ test("with chain", () => {
            "https://signet-staging.kontor.network:38332",
          ],
          "http": [
-           "https://signet-staging.kontor.network:35000/api",
+           "https://signet-staging.kontor.network:35001/api",
          ],
          "webSocket": [
-           "wss://signet-staging.kontor.network:35000/ws",
+           "wss://signet-staging.kontor.network:35001/ws",
          ],
        },
      },

package/src/sdk/clients/kontor/create-public-client.test.ts

@@ -5,7 +5,7 @@ import { http } from "../transports/http.js";
 
 test("creates", async () => {
   const { uid, ...client } = createPublicClient({
-    transport: http("https://signet.kontor.network:35000/api"),
+    transport: http("https://signet.kontor.network:35001/api"),
   });
 
   expect(client).toMatchInlineSnapshot(`
@@ -33,7 +33,7 @@ test("creates", async () => {
         "retryDelay": 150,
         "timeout": 10000,
         "type": "http",
-        "url": "https://signet.kontor.network:35000/api",
+        "url": "https://signet.kontor.network:35001/api",
       },
       "type": "kontor-http-client",
       "viewContract": [Function],