@frak-labs/core-sdk 0.1.0-beta.8d103039 → 0.1.0-beta.d9302e66

package/src/interactions/purchaseEncoder.test.ts

@@ -0,0 +1,291 @@
+/**
+ * Tests for PurchaseInteractionEncoder
+ * Tests encoding of purchase-related user interactions
+ */
+
+import type { Hex } from "viem";
+import { encodeAbiParameters, pad, toHex } from "viem";
+import { describe, expect, test } from "../../tests/vitest-fixtures";
+import { interactionTypes } from "../constants/interactionTypes";
+import { productTypes } from "../constants/productTypes";
+import { PurchaseInteractionEncoder } from "./purchaseEncoder";
+
+describe("PurchaseInteractionEncoder", () => {
+    describe("startPurchase", () => {
+        test("should encode start purchase interaction with correct structure", ({
+            mockPurchaseId,
+        }) => {
+            const interaction = PurchaseInteractionEncoder.startPurchase({
+                purchaseId: mockPurchaseId,
+            });
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        test("should use purchase product type in handlerTypeDenominator", ({
+            mockPurchaseId,
+        }) => {
+            const interaction = PurchaseInteractionEncoder.startPurchase({
+                purchaseId: mockPurchaseId,
+            });
+
+            // Should use purchase product type (31)
+            const expectedDenominator = toHex(productTypes.purchase);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        test("should include started interaction type in data", ({
+            mockPurchaseId,
+        }) => {
+            const interaction = PurchaseInteractionEncoder.startPurchase({
+                purchaseId: mockPurchaseId,
+            });
+
+            // Should start with started interaction type
+            expect(interaction.interactionData).toContain(
+                interactionTypes.purchase.started
+            );
+        });
+
+        test("should pad purchase ID to 32 bytes", ({ mockPurchaseId }) => {
+            const interaction = PurchaseInteractionEncoder.startPurchase({
+                purchaseId: mockPurchaseId,
+            });
+
+            // Purchase ID should be padded to 32 bytes
+            const paddedPurchaseId = pad(mockPurchaseId, { size: 32 });
+            expect(interaction.interactionData).toContain(
+                paddedPurchaseId.slice(2)
+            );
+        });
+
+        test("should produce consistent output for same purchase ID", ({
+            mockPurchaseId,
+        }) => {
+            const interaction1 = PurchaseInteractionEncoder.startPurchase({
+                purchaseId: mockPurchaseId,
+            });
+            const interaction2 = PurchaseInteractionEncoder.startPurchase({
+                purchaseId: mockPurchaseId,
+            });
+
+            // Same input should produce same output
+            expect(interaction1).toEqual(interaction2);
+        });
+    });
+
+    describe("completedPurchase", () => {
+        test("should encode completed purchase with proof", ({
+            mockPurchaseId,
+            mockProof,
+        }) => {
+            const interaction = PurchaseInteractionEncoder.completedPurchase({
+                purchaseId: mockPurchaseId,
+                proof: mockProof,
+            });
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        test("should use purchase product type in handlerTypeDenominator", ({
+            mockPurchaseId,
+            mockProof,
+        }) => {
+            const interaction = PurchaseInteractionEncoder.completedPurchase({
+                purchaseId: mockPurchaseId,
+                proof: mockProof,
+            });
+
+            // Should use purchase product type (31)
+            const expectedDenominator = toHex(productTypes.purchase);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        test("should include completed interaction type in data", ({
+            mockPurchaseId,
+            mockProof,
+        }) => {
+            const interaction = PurchaseInteractionEncoder.completedPurchase({
+                purchaseId: mockPurchaseId,
+                proof: mockProof,
+            });
+
+            // Should start with completed interaction type
+            expect(interaction.interactionData).toContain(
+                interactionTypes.purchase.completed
+            );
+        });
+
+        test("should use ABI encoding for inner data", ({
+            mockPurchaseId,
+            mockProof,
+        }) => {
+            const interaction = PurchaseInteractionEncoder.completedPurchase({
+                purchaseId: mockPurchaseId,
+                proof: mockProof,
+            });
+
+            // Inner data should be ABI encoded (uint256 + bytes32[])
+            const expectedInnerData = encodeAbiParameters(
+                [{ type: "uint256" }, { type: "bytes32[]" }],
+                [BigInt(mockPurchaseId), mockProof]
+            );
+            expect(interaction.interactionData).toContain(
+                expectedInnerData.slice(2)
+            );
+        });
+
+        test("should handle empty proof array", ({ mockPurchaseId }) => {
+            const interaction = PurchaseInteractionEncoder.completedPurchase({
+                purchaseId: mockPurchaseId,
+                proof: [],
+            });
+
+            // Should still encode properly with empty proof
+            expect(interaction.interactionData).toBeDefined();
+            expect(interaction.handlerTypeDenominator).toBe(
+                toHex(productTypes.purchase)
+            );
+        });
+
+        test("should handle multiple proof elements", ({ mockPurchaseId }) => {
+            const largeProof: Hex[] = [
+                "0x0000000000000000000000000000000000000000000000000000000000000001",
+                "0x0000000000000000000000000000000000000000000000000000000000000002",
+                "0x0000000000000000000000000000000000000000000000000000000000000003",
+                "0x0000000000000000000000000000000000000000000000000000000000000004",
+                "0x0000000000000000000000000000000000000000000000000000000000000005",
+            ];
+
+            const interaction = PurchaseInteractionEncoder.completedPurchase({
+                purchaseId: mockPurchaseId,
+                proof: largeProof,
+            });
+
+            // Should handle larger proof arrays
+            expect(interaction.interactionData).toBeDefined();
+            expect(interaction.handlerTypeDenominator).toBe(
+                toHex(productTypes.purchase)
+            );
+        });
+    });
+
+    describe("unsafeCompletedPurchase", () => {
+        test("should encode unsafe completed purchase", ({
+            mockPurchaseId,
+        }) => {
+            const interaction =
+                PurchaseInteractionEncoder.unsafeCompletedPurchase({
+                    purchaseId: mockPurchaseId,
+                });
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        test("should use purchase product type in handlerTypeDenominator", ({
+            mockPurchaseId,
+        }) => {
+            const interaction =
+                PurchaseInteractionEncoder.unsafeCompletedPurchase({
+                    purchaseId: mockPurchaseId,
+                });
+
+            // Should use purchase product type (31)
+            const expectedDenominator = toHex(productTypes.purchase);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        test("should include unsafeCompleted interaction type in data", ({
+            mockPurchaseId,
+        }) => {
+            const interaction =
+                PurchaseInteractionEncoder.unsafeCompletedPurchase({
+                    purchaseId: mockPurchaseId,
+                });
+
+            // Should start with unsafeCompleted interaction type
+            expect(interaction.interactionData).toContain(
+                interactionTypes.purchase.unsafeCompleted
+            );
+        });
+
+        test("should pad purchase ID to 32 bytes", ({ mockPurchaseId }) => {
+            const interaction =
+                PurchaseInteractionEncoder.unsafeCompletedPurchase({
+                    purchaseId: mockPurchaseId,
+                });
+
+            // Purchase ID should be padded to 32 bytes
+            const paddedPurchaseId = pad(mockPurchaseId, { size: 32 });
+            expect(interaction.interactionData).toContain(
+                paddedPurchaseId.slice(2)
+            );
+        });
+
+        test("should differ from safe completed purchase", ({
+            mockPurchaseId,
+        }) => {
+            const safeInteraction =
+                PurchaseInteractionEncoder.completedPurchase({
+                    purchaseId: mockPurchaseId,
+                    proof: [],
+                });
+            const unsafeInteraction =
+                PurchaseInteractionEncoder.unsafeCompletedPurchase({
+                    purchaseId: mockPurchaseId,
+                });
+
+            // Unsafe and safe versions should be different
+            expect(unsafeInteraction.interactionData).not.toBe(
+                safeInteraction.interactionData
+            );
+        });
+    });
+
+    describe("interaction data format", () => {
+        test("should produce valid hex strings", ({ mockPurchaseId }) => {
+            const startInteraction = PurchaseInteractionEncoder.startPurchase({
+                purchaseId: mockPurchaseId,
+            });
+            const unsafeInteraction =
+                PurchaseInteractionEncoder.unsafeCompletedPurchase({
+                    purchaseId: mockPurchaseId,
+                });
+
+            // Both should be valid hex strings starting with 0x
+            expect(startInteraction.interactionData).toMatch(/^0x[0-9a-f]+$/);
+            expect(unsafeInteraction.interactionData).toMatch(/^0x[0-9a-f]+$/);
+        });
+
+        test("should handle different purchase IDs correctly", () => {
+            const purchaseId1 =
+                "0x0000000000000000000000000000000000000000000000000000000000000001" as const;
+            const purchaseId2 =
+                "0x0000000000000000000000000000000000000000000000000000000000000002" as const;
+
+            const interaction1 = PurchaseInteractionEncoder.startPurchase({
+                purchaseId: purchaseId1,
+            });
+            const interaction2 = PurchaseInteractionEncoder.startPurchase({
+                purchaseId: purchaseId2,
+            });
+
+            // Different purchase IDs should produce different interaction data
+            expect(interaction1.interactionData).not.toBe(
+                interaction2.interactionData
+            );
+        });
+    });
+});

package/src/interactions/purchaseEncoder.ts

@@ -1,4 +1,4 @@
-import { type Hex, concatHex, encodeAbiParameters, pad, toHex } from "viem";
+import { concatHex, encodeAbiParameters, type Hex, pad, toHex } from "viem";
 import { interactionTypes } from "../constants/interactionTypes";
 import { productTypes } from "../constants/productTypes";
 import type { PreparedInteraction } from "../types";
@@ -59,7 +59,10 @@ export const PurchaseInteractionEncoder = {
     completedPurchase({
         purchaseId,
         proof,
-    }: { purchaseId: Hex; proof: Hex[] }): PreparedInteraction {
+    }: {
+        purchaseId: Hex;
+        proof: Hex[];
+    }): PreparedInteraction {
         const innerData = encodeAbiParameters(
             [{ type: "uint256" }, { type: "bytes32[]" }],
             [BigInt(purchaseId), proof]
@@ -81,7 +84,9 @@ export const PurchaseInteractionEncoder = {
      */
     unsafeCompletedPurchase({
         purchaseId,
-    }: { purchaseId: Hex }): PreparedInteraction {
+    }: {
+        purchaseId: Hex;
+    }): PreparedInteraction {
         const interactionData = concatHex([
             interactionTypes.purchase.unsafeCompleted,
             pad(purchaseId, { size: 32 }),

package/src/interactions/referralEncoder.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Tests for ReferralInteractionEncoder
+ * Tests encoding of referral-related user interactions
+ */
+
+import { pad, toHex } from "viem";
+import { describe, expect, it, test } from "../../tests/vitest-fixtures";
+import { interactionTypes } from "../constants/interactionTypes";
+import { productTypes } from "../constants/productTypes";
+import { ReferralInteractionEncoder } from "./referralEncoder";
+
+describe("ReferralInteractionEncoder", () => {
+    describe("createLink", () => {
+        it("should encode create link interaction with correct structure", () => {
+            const interaction = ReferralInteractionEncoder.createLink();
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        it("should use referral product type in handlerTypeDenominator", () => {
+            const interaction = ReferralInteractionEncoder.createLink();
+
+            // Should use referral product type (30)
+            const expectedDenominator = toHex(productTypes.referral);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        it("should use createLink interaction type in data", () => {
+            const interaction = ReferralInteractionEncoder.createLink();
+
+            // Should use createLink interaction type
+            expect(interaction.interactionData).toBe(
+                interactionTypes.referral.createLink
+            );
+        });
+
+        it("should produce consistent output (no parameters)", () => {
+            const interaction1 = ReferralInteractionEncoder.createLink();
+            const interaction2 = ReferralInteractionEncoder.createLink();
+
+            // Should always produce the same output
+            expect(interaction1).toEqual(interaction2);
+        });
+    });
+
+    describe("referred", () => {
+        test("should encode referred interaction with correct structure", ({
+            mockReferrerAddress,
+        }) => {
+            const interaction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        test("should use referral product type in handlerTypeDenominator", ({
+            mockReferrerAddress,
+        }) => {
+            const interaction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Should use referral product type (30)
+            const expectedDenominator = toHex(productTypes.referral);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        test("should include referred interaction type in data", ({
+            mockReferrerAddress,
+        }) => {
+            const interaction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Should start with referred interaction type
+            expect(interaction.interactionData).toContain(
+                interactionTypes.referral.referred
+            );
+        });
+
+        test("should pad referrer address to 32 bytes", ({
+            mockReferrerAddress,
+        }) => {
+            const interaction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Referrer address should be padded to 32 bytes
+            const paddedAddress = pad(mockReferrerAddress, { size: 32 });
+            expect(interaction.interactionData).toContain(
+                paddedAddress.slice(2)
+            );
+        });
+
+        test("should produce different output for different referrers", () => {
+            const referrer1 =
+                "0x1234567890123456789012345678901234567890" as const;
+            const referrer2 =
+                "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as const;
+
+            const interaction1 = ReferralInteractionEncoder.referred({
+                referrer: referrer1,
+            });
+            const interaction2 = ReferralInteractionEncoder.referred({
+                referrer: referrer2,
+            });
+
+            // Different referrers should produce different interaction data
+            expect(interaction1.interactionData).not.toBe(
+                interaction2.interactionData
+            );
+        });
+
+        test("should produce consistent output for same referrer", ({
+            mockReferrerAddress,
+        }) => {
+            const interaction1 = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+            const interaction2 = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Same referrer should produce same output
+            expect(interaction1).toEqual(interaction2);
+        });
+    });
+
+    describe("interaction data format", () => {
+        test("should produce valid hex strings", ({ mockReferrerAddress }) => {
+            const createLinkInteraction =
+                ReferralInteractionEncoder.createLink();
+            const referredInteraction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Both should be valid hex strings starting with 0x
+            expect(createLinkInteraction.interactionData).toMatch(
+                /^0x[0-9a-f]+$/
+            );
+            expect(referredInteraction.interactionData).toMatch(
+                /^0x[0-9a-f]+$/
+            );
+        });
+
+        test("should have different interaction types", ({
+            mockReferrerAddress,
+        }) => {
+            const createLinkInteraction =
+                ReferralInteractionEncoder.createLink();
+            const referredInteraction = ReferralInteractionEncoder.referred({
+                referrer: mockReferrerAddress,
+            });
+
+            // Different interaction types should produce different data
+            expect(createLinkInteraction.interactionData).not.toBe(
+                referredInteraction.interactionData
+            );
+        });
+    });
+});

package/src/interactions/retailEncoder.test.ts

@@ -0,0 +1,107 @@
+/**
+ * Tests for RetailInteractionEncoder
+ * Tests encoding of retail-related user interactions
+ */
+
+import { pad, toHex } from "viem";
+import { describe, expect, test } from "../../tests/vitest-fixtures";
+import { interactionTypes } from "../constants/interactionTypes";
+import { productTypes } from "../constants/productTypes";
+import { RetailInteractionEncoder } from "./retailEncoder";
+
+describe("RetailInteractionEncoder", () => {
+    describe("customerMeeting", () => {
+        test("should encode customer meeting interaction with correct structure", ({
+            mockAgencyId,
+        }) => {
+            const interaction = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        test("should use retail product type in handlerTypeDenominator", ({
+            mockAgencyId,
+        }) => {
+            const interaction = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Should use retail product type (4)
+            const expectedDenominator = toHex(productTypes.retail);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        test("should include customerMeeting interaction type in data", ({
+            mockAgencyId,
+        }) => {
+            const interaction = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Should start with customerMeeting interaction type
+            expect(interaction.interactionData).toContain(
+                interactionTypes.retail.customerMeeting
+            );
+        });
+
+        test("should pad agency ID to 32 bytes", ({ mockAgencyId }) => {
+            const interaction = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Agency ID should be padded to 32 bytes
+            const paddedAgencyId = pad(mockAgencyId, { size: 32 });
+            expect(interaction.interactionData).toContain(
+                paddedAgencyId.slice(2)
+            );
+        });
+
+        test("should produce consistent output for same agency ID", ({
+            mockAgencyId,
+        }) => {
+            const interaction1 = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+            const interaction2 = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Same input should produce same output
+            expect(interaction1).toEqual(interaction2);
+        });
+
+        test("should produce different output for different agency IDs", () => {
+            const agencyId1 =
+                "0x0000000000000000000000000000000000000000000000000000000000000001" as const;
+            const agencyId2 =
+                "0x0000000000000000000000000000000000000000000000000000000000000002" as const;
+
+            const interaction1 = RetailInteractionEncoder.customerMeeting({
+                agencyId: agencyId1,
+            });
+            const interaction2 = RetailInteractionEncoder.customerMeeting({
+                agencyId: agencyId2,
+            });
+
+            // Different agency IDs should produce different interaction data
+            expect(interaction1.interactionData).not.toBe(
+                interaction2.interactionData
+            );
+        });
+
+        test("should produce valid hex string", ({ mockAgencyId }) => {
+            const interaction = RetailInteractionEncoder.customerMeeting({
+                agencyId: mockAgencyId,
+            });
+
+            // Should be valid hex string starting with 0x
+            expect(interaction.interactionData).toMatch(/^0x[0-9a-f]+$/);
+        });
+    });
+});

package/src/interactions/retailEncoder.ts

@@ -1,4 +1,4 @@
-import { type Hex, concatHex, pad, toHex } from "viem";
+import { concatHex, type Hex, pad, toHex } from "viem";
 import { interactionTypes } from "../constants/interactionTypes";
 import { productTypes } from "../constants/productTypes";
 import type { PreparedInteraction } from "../types";

package/src/interactions/webshopEncoder.test.ts

@@ -0,0 +1,56 @@
+/**
+ * Tests for WebShopInteractionEncoder
+ * Tests encoding of webshop-related user interactions
+ */
+
+import { toHex } from "viem";
+import { describe, expect, it } from "../../tests/vitest-fixtures";
+import { interactionTypes } from "../constants/interactionTypes";
+import { productTypes } from "../constants/productTypes";
+import { WebShopInteractionEncoder } from "./webshopEncoder";
+
+describe("WebShopInteractionEncoder", () => {
+    describe("open", () => {
+        it("should encode open webshop interaction with correct structure", () => {
+            const interaction = WebShopInteractionEncoder.open();
+
+            // Should return PreparedInteraction structure
+            expect(interaction).toHaveProperty("handlerTypeDenominator");
+            expect(interaction).toHaveProperty("interactionData");
+        });
+
+        it("should use webshop product type in handlerTypeDenominator", () => {
+            const interaction = WebShopInteractionEncoder.open();
+
+            // Should use webshop product type (3)
+            const expectedDenominator = toHex(productTypes.webshop);
+            expect(interaction.handlerTypeDenominator).toBe(
+                expectedDenominator
+            );
+        });
+
+        it("should use open interaction type in data", () => {
+            const interaction = WebShopInteractionEncoder.open();
+
+            // Should use open interaction type
+            expect(interaction.interactionData).toBe(
+                interactionTypes.webshop.open
+            );
+        });
+
+        it("should produce consistent output (no parameters)", () => {
+            const interaction1 = WebShopInteractionEncoder.open();
+            const interaction2 = WebShopInteractionEncoder.open();
+
+            // Should always produce the same output
+            expect(interaction1).toEqual(interaction2);
+        });
+
+        it("should produce valid hex string", () => {
+            const interaction = WebShopInteractionEncoder.open();
+
+            // Should be valid hex string starting with 0x
+            expect(interaction.interactionData).toMatch(/^0x[0-9a-f]+$/);
+        });
+    });
+});