@frak-labs/core-sdk 0.1.1 → 0.2.0-beta.7898df5b

package/src/actions/sendInteraction.test.ts

@@ -1,219 +0,0 @@
-/**
- * Tests for sendInteraction action
- * Tests sending user interactions via RPC
- */
-
-import type { Hex } from "viem";
-import { vi } from "vitest";
-
-// Mock computeProductId - must be before imports
-vi.mock("../utils/computeProductId", () => ({
-    computeProductId: vi.fn(
-        () =>
-            "0xcomputed1234567890123456789012345678901234567890123456789012" as Hex
-    ),
-}));
-
-import { describe, expect, it } from "../../tests/vitest-fixtures";
-import type {
-    FrakClient,
-    PreparedInteraction,
-    SendInteractionParamsType,
-    SendInteractionReturnType,
-} from "../types";
-import { sendInteraction } from "./sendInteraction";
-
-describe("sendInteraction", () => {
-    const mockInteraction: PreparedInteraction = {
-        interactionData: "0xdata" as Hex,
-        handlerTypeDenominator: "0x01" as Hex,
-    };
-
-    describe("with productId provided", () => {
-        it("should use provided productId", async () => {
-            const mockResponse: SendInteractionReturnType = {
-                delegationId: "delegation-123",
-            };
-
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                productId:
-                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
-                interaction: mockInteraction,
-            };
-
-            await sendInteraction(mockClient, params);
-
-            expect(mockClient.request).toHaveBeenCalledWith({
-                method: "frak_sendInteraction",
-                params: [
-                    "0xprovidedid567890123456789012345678901234567890123456789012",
-                    mockInteraction,
-                    undefined,
-                ],
-            });
-        });
-
-        it("should return delegationId", async () => {
-            const mockResponse: SendInteractionReturnType = {
-                delegationId: "delegation-456",
-            };
-
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                productId:
-                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
-                interaction: mockInteraction,
-            };
-
-            const result = await sendInteraction(mockClient, params);
-
-            expect(result).toEqual(mockResponse);
-            expect(result.delegationId).toBe("delegation-456");
-        });
-
-        it("should include validation signature when provided", async () => {
-            const mockResponse: SendInteractionReturnType = {
-                delegationId: "delegation-789",
-            };
-
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                productId:
-                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
-                interaction: mockInteraction,
-                validation: "0xsignature1234567890" as Hex,
-            };
-
-            await sendInteraction(mockClient, params);
-
-            expect(mockClient.request).toHaveBeenCalledWith({
-                method: "frak_sendInteraction",
-                params: [
-                    "0xprovidedid567890123456789012345678901234567890123456789012",
-                    mockInteraction,
-                    "0xsignature1234567890",
-                ],
-            });
-        });
-    });
-
-    describe("without productId provided", () => {
-        it("should compute productId from client.config", async () => {
-            const { computeProductId } = await import(
-                "../utils/computeProductId"
-            );
-
-            const mockResponse: SendInteractionReturnType = {
-                delegationId: "delegation-computed",
-            };
-
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                interaction: mockInteraction,
-            };
-
-            await sendInteraction(mockClient, params);
-
-            expect(computeProductId).toHaveBeenCalledWith(mockClient.config);
-            expect(mockClient.request).toHaveBeenCalledWith({
-                method: "frak_sendInteraction",
-                params: [
-                    "0xcomputed1234567890123456789012345678901234567890123456789012",
-                    mockInteraction,
-                    undefined,
-                ],
-            });
-        });
-
-        it("should work with different interaction types", async () => {
-            const mockResponse: SendInteractionReturnType = {
-                delegationId: "delegation-different",
-            };
-
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockResolvedValue(mockResponse),
-            } as unknown as FrakClient;
-
-            const differentInteraction: PreparedInteraction = {
-                interactionData: "0xdifferentdata" as Hex,
-                handlerTypeDenominator: "0x02" as Hex,
-            };
-
-            const params: SendInteractionParamsType = {
-                interaction: differentInteraction,
-            };
-
-            const result = await sendInteraction(mockClient, params);
-
-            expect(result).toEqual(mockResponse);
-        });
-    });
-
-    describe("error handling", () => {
-        it("should propagate errors from client.request", async () => {
-            const error = new Error("Send interaction failed");
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockRejectedValue(error),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                productId:
-                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
-                interaction: mockInteraction,
-            };
-
-            await expect(sendInteraction(mockClient, params)).rejects.toThrow(
-                "Send interaction failed"
-            );
-        });
-
-        it("should handle network errors", async () => {
-            const error = new Error("Network timeout");
-            const mockClient = {
-                config: {
-                    domain: "example.com",
-                },
-                request: vi.fn().mockRejectedValue(error),
-            } as unknown as FrakClient;
-
-            const params: SendInteractionParamsType = {
-                interaction: mockInteraction,
-            };
-
-            await expect(sendInteraction(mockClient, params)).rejects.toThrow(
-                "Network timeout"
-            );
-        });
-    });
-});

package/src/constants/interactionTypes.test.ts

@@ -1,128 +0,0 @@
-/**
- * Tests for interactionTypes constants
- * Tests interaction type definitions and type utilities
- */
-
-import { describe, expect, it } from "vitest";
-import { interactionTypes } from "./interactionTypes";
-
-describe("interactionTypes", () => {
-    describe("structure", () => {
-        it("should have all expected categories", () => {
-            expect(interactionTypes).toHaveProperty("press");
-            expect(interactionTypes).toHaveProperty("dapp");
-            expect(interactionTypes).toHaveProperty("webshop");
-            expect(interactionTypes).toHaveProperty("referral");
-            expect(interactionTypes).toHaveProperty("purchase");
-            expect(interactionTypes).toHaveProperty("retail");
-        });
-
-        it("should have press interactions", () => {
-            expect(interactionTypes.press).toEqual({
-                openArticle: "0xc0a24ffb",
-                readArticle: "0xd5bd0fbe",
-            });
-        });
-
-        it("should have dapp interactions", () => {
-            expect(interactionTypes.dapp).toEqual({
-                proofVerifiableStorageUpdate: "0x2ab2aeef",
-                callableVerifiableStorageUpdate: "0xa07da986",
-            });
-        });
-
-        it("should have webshop interactions", () => {
-            expect(interactionTypes.webshop).toEqual({
-                open: "0xb311798f",
-            });
-        });
-
-        it("should have referral interactions", () => {
-            expect(interactionTypes.referral).toEqual({
-                referred: "0x010cc3b9",
-                createLink: "0xb2c0f17c",
-            });
-        });
-
-        it("should have purchase interactions", () => {
-            expect(interactionTypes.purchase).toEqual({
-                started: "0xd87e90c3",
-                completed: "0x8403aeb4",
-                unsafeCompleted: "0x4d5b14e0",
-            });
-        });
-
-        it("should have retail interactions", () => {
-            expect(interactionTypes.retail).toEqual({
-                customerMeeting: "0x74489004",
-            });
-        });
-    });
-
-    describe("interaction values", () => {
-        it("should have all interaction values as hex strings", () => {
-            Object.values(interactionTypes).forEach((category) => {
-                Object.values(category).forEach((value) => {
-                    expect(value).toMatch(/^0x[a-f0-9]{8}$/);
-                });
-            });
-        });
-
-        it("should have unique interaction values across all categories", () => {
-            const allValues = Object.values(interactionTypes).flatMap(
-                (category) => Object.values(category)
-            );
-            const uniqueValues = new Set(allValues);
-            expect(allValues.length).toBe(uniqueValues.size);
-        });
-    });
-
-    describe("specific interactions", () => {
-        it("should have correct press.openArticle value", () => {
-            expect(interactionTypes.press.openArticle).toBe("0xc0a24ffb");
-        });
-
-        it("should have correct press.readArticle value", () => {
-            expect(interactionTypes.press.readArticle).toBe("0xd5bd0fbe");
-        });
-
-        it("should have correct webshop.open value", () => {
-            expect(interactionTypes.webshop.open).toBe("0xb311798f");
-        });
-
-        it("should have correct referral.referred value", () => {
-            expect(interactionTypes.referral.referred).toBe("0x010cc3b9");
-        });
-
-        it("should have correct purchase.completed value", () => {
-            expect(interactionTypes.purchase.completed).toBe("0x8403aeb4");
-        });
-
-        it("should have correct purchase.unsafeCompleted value", () => {
-            expect(interactionTypes.purchase.unsafeCompleted).toBe(
-                "0x4d5b14e0"
-            );
-        });
-
-        it("should have correct retail.customerMeeting value", () => {
-            expect(interactionTypes.retail.customerMeeting).toBe("0x74489004");
-        });
-    });
-
-    describe("type safety", () => {
-        it("should be readonly (as const)", () => {
-            // TypeScript ensures this is readonly, but we can verify structure
-            expect(Object.isFrozen(interactionTypes)).toBe(false);
-            // The values should be consistent
-            expect(typeof interactionTypes.press.openArticle).toBe("string");
-        });
-
-        it("should have consistent structure across categories", () => {
-            Object.values(interactionTypes).forEach((category) => {
-                expect(typeof category).toBe("object");
-                expect(category).not.toBeNull();
-                expect(Array.isArray(category)).toBe(false);
-            });
-        });
-    });
-});

package/src/constants/productTypes.test.ts

@@ -1,130 +0,0 @@
-/**
- * Tests for productTypes constants
- * Tests product type definitions and bitmask calculations
- */
-
-import { describe, expect, it } from "vitest";
-import { productTypes, productTypesMask } from "./productTypes";
-
-describe("productTypes", () => {
-    describe("structure", () => {
-        it("should have all expected product types", () => {
-            expect(productTypes).toHaveProperty("dapp");
-            expect(productTypes).toHaveProperty("press");
-            expect(productTypes).toHaveProperty("webshop");
-            expect(productTypes).toHaveProperty("retail");
-            expect(productTypes).toHaveProperty("referral");
-            expect(productTypes).toHaveProperty("purchase");
-        });
-
-        it("should have correct numeric values", () => {
-            expect(productTypes.dapp).toBe(1);
-            expect(productTypes.press).toBe(2);
-            expect(productTypes.webshop).toBe(3);
-            expect(productTypes.retail).toBe(4);
-            expect(productTypes.referral).toBe(30);
-            expect(productTypes.purchase).toBe(31);
-        });
-    });
-
-    describe("productTypesMask", () => {
-        it("should have masks for all product types", () => {
-            expect(productTypesMask).toHaveProperty("dapp");
-            expect(productTypesMask).toHaveProperty("press");
-            expect(productTypesMask).toHaveProperty("webshop");
-            expect(productTypesMask).toHaveProperty("retail");
-            expect(productTypesMask).toHaveProperty("referral");
-            expect(productTypesMask).toHaveProperty("purchase");
-        });
-
-        it("should calculate correct bitmask for dapp (value 1)", () => {
-            expect(productTypesMask.dapp).toBe(BigInt(1) << BigInt(1));
-            expect(productTypesMask.dapp).toBe(BigInt(2));
-        });
-
-        it("should calculate correct bitmask for press (value 2)", () => {
-            expect(productTypesMask.press).toBe(BigInt(1) << BigInt(2));
-            expect(productTypesMask.press).toBe(BigInt(4));
-        });
-
-        it("should calculate correct bitmask for webshop (value 3)", () => {
-            expect(productTypesMask.webshop).toBe(BigInt(1) << BigInt(3));
-            expect(productTypesMask.webshop).toBe(BigInt(8));
-        });
-
-        it("should calculate correct bitmask for retail (value 4)", () => {
-            expect(productTypesMask.retail).toBe(BigInt(1) << BigInt(4));
-            expect(productTypesMask.retail).toBe(BigInt(16));
-        });
-
-        it("should calculate correct bitmask for referral (value 30)", () => {
-            expect(productTypesMask.referral).toBe(BigInt(1) << BigInt(30));
-            expect(productTypesMask.referral).toBe(BigInt(1073741824));
-        });
-
-        it("should calculate correct bitmask for purchase (value 31)", () => {
-            expect(productTypesMask.purchase).toBe(BigInt(1) << BigInt(31));
-            expect(productTypesMask.purchase).toBe(BigInt(2147483648));
-        });
-
-        it("should have all masks as BigInt values", () => {
-            Object.values(productTypesMask).forEach((mask) => {
-                expect(typeof mask).toBe("bigint");
-            });
-        });
-
-        it("should have unique mask values", () => {
-            const maskValues = Object.values(productTypesMask);
-            const uniqueValues = new Set(maskValues);
-            expect(maskValues.length).toBe(uniqueValues.size);
-        });
-    });
-
-    describe("bitmask calculation", () => {
-        it("should correctly calculate bitmask from product type value", () => {
-            // Verify the formula: 1 << value
-            expect(productTypesMask.dapp).toBe(
-                BigInt(1) << BigInt(productTypes.dapp)
-            );
-            expect(productTypesMask.press).toBe(
-                BigInt(1) << BigInt(productTypes.press)
-            );
-            expect(productTypesMask.webshop).toBe(
-                BigInt(1) << BigInt(productTypes.webshop)
-            );
-            expect(productTypesMask.retail).toBe(
-                BigInt(1) << BigInt(productTypes.retail)
-            );
-            expect(productTypesMask.referral).toBe(
-                BigInt(1) << BigInt(productTypes.referral)
-            );
-            expect(productTypesMask.purchase).toBe(
-                BigInt(1) << BigInt(productTypes.purchase)
-            );
-        });
-
-        it("should have masks that are powers of 2", () => {
-            Object.values(productTypesMask).forEach((mask) => {
-                // A power of 2 has exactly one bit set
-                // Check: mask & (mask - 1n) should be 0n
-                const isPowerOfTwo = mask > 0n && (mask & (mask - 1n)) === 0n;
-                expect(isPowerOfTwo).toBe(true);
-            });
-        });
-    });
-
-    describe("type safety", () => {
-        it("should have consistent structure", () => {
-            const productKeys = Object.keys(productTypes);
-            const maskKeys = Object.keys(productTypesMask);
-            expect(productKeys.sort()).toEqual(maskKeys.sort());
-        });
-
-        it("should have numeric values for product types", () => {
-            Object.values(productTypes).forEach((value) => {
-                expect(typeof value).toBe("number");
-                expect(Number.isInteger(value)).toBe(true);
-            });
-        });
-    });
-});

package/src/constants/productTypes.ts

@@ -1,33 +0,0 @@
-/**
- * The keys for each product types
- * @inline
- */
-export type ProductTypesKey = keyof typeof productTypes;
-
-/**
- * List of the product types per denominator
- */
-export const productTypes = {
-    // content type
-    dapp: 1,
-    press: 2,
-    webshop: 3,
-    retail: 4,
-
-    // feature type
-    referral: 30,
-    purchase: 31,
-};
-
-/**
- * Bitmask for each product types
- */
-export const productTypesMask: Record<ProductTypesKey, bigint> = Object.entries(
-    productTypes
-).reduce(
-    (acc, [key, value]) => {
-        acc[key as ProductTypesKey] = BigInt(1) << BigInt(value);
-        return acc;
-    },
-    {} as Record<ProductTypesKey, bigint>
-);

package/src/interactions/index.ts

@@ -1,5 +0,0 @@
-export { PressInteractionEncoder } from "./pressEncoder";
-export { PurchaseInteractionEncoder } from "./purchaseEncoder";
-export { ReferralInteractionEncoder } from "./referralEncoder";
-export { RetailInteractionEncoder } from "./retailEncoder";
-export { WebShopInteractionEncoder } from "./webshopEncoder";