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

package/src/interactions/referralEncoder.test.ts

@@ -1,170 +0,0 @@
-/**
- * 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/referralEncoder.ts

@@ -1,47 +0,0 @@
-import { type Address, concatHex, pad, toHex } from "viem";
-import { interactionTypes } from "../constants/interactionTypes";
-import { productTypes } from "../constants/productTypes";
-import type { PreparedInteraction } from "../types";
-
-/**
- * Referral interactions allow you to track user sharing activities.
- * These interactions are essential for platforms looking to grow their user base through user-to-user referrals and reward systems.
- *
- * :::info
- *   To properly handle referral interactions, ensure that the "Referral" product type is enabled in your Business dashboard.
- * :::
- *
- * @description Encode referral related user interactions
- *
- * @group Interactions Encoder
- *
- * @see {@link PreparedInteraction} The prepared interaction object that can be sent
- * @see {@link !actions.sendInteraction | `sendInteraction()`} Action used to send the prepared interaction to the Frak Wallet
- */
-export const ReferralInteractionEncoder = {
-    /**
-     * Records the event of a user creating a referral link. Note that this interaction doesn't actually create the link itself; it only sends an event to track that a link was created.
-     */
-    createLink(): PreparedInteraction {
-        return {
-            handlerTypeDenominator: toHex(productTypes.referral),
-            interactionData: interactionTypes.referral.createLink,
-        };
-    },
-
-    /**
-     * Encode a referred interaction
-     * @param args
-     * @param args.referrer - The Ethereum address of the user who made the referral
-     */
-    referred({ referrer }: { referrer: Address }): PreparedInteraction {
-        const interactionData = concatHex([
-            interactionTypes.referral.referred,
-            pad(referrer, { size: 32 }),
-        ]);
-        return {
-            handlerTypeDenominator: toHex(productTypes.referral),
-            interactionData,
-        };
-    },
-};

package/src/interactions/retailEncoder.test.ts

@@ -1,107 +0,0 @@
-/**
- * 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,37 +0,0 @@
-import { concatHex, type Hex, pad, toHex } from "viem";
-import { interactionTypes } from "../constants/interactionTypes";
-import { productTypes } from "../constants/productTypes";
-import type { PreparedInteraction } from "../types";
-
-/**
- * Retail interactions allow you to track user activities on your retails products.
- *
- * :::info
- *   To properly handle retail interactions, ensure that the "Retail" product type is enabled in your Business dashboard.
- * :::
- *
- * @description Encode retail related user interactions
- *
- * @group Interactions Encoder
- *
- * @see {@link PreparedInteraction} The prepared interaction object that can be sent
- * @see {@link !actions.sendInteraction | `sendInteraction()`} Action used to send the prepared interaction to the Frak Wallet
- */
-export const RetailInteractionEncoder = {
-    /**
-     * Encode a customer meeting retail interaction
-     * @param args
-     * @param args.agencyId - The id of the agency that the customer is meeting with
-     *
-     */
-    customerMeeting({ agencyId }: { agencyId: Hex }): PreparedInteraction {
-        const interactionData = concatHex([
-            interactionTypes.retail.customerMeeting,
-            pad(agencyId, { size: 32 }),
-        ]);
-        return {
-            handlerTypeDenominator: toHex(productTypes.retail),
-            interactionData,
-        };
-    },
-};

package/src/interactions/webshopEncoder.test.ts

@@ -1,56 +0,0 @@
-/**
- * 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]+$/);
-        });
-    });
-});

package/src/interactions/webshopEncoder.ts

@@ -1,30 +0,0 @@
-import { toHex } from "viem";
-import { interactionTypes } from "../constants/interactionTypes";
-import { productTypes } from "../constants/productTypes";
-import type { PreparedInteraction } from "../types";
-
-/**
- * Webshop interactions allow you to track user activities on your webshop.
- *
- * :::info
- *   To properly handle webshop interactions, ensure that the "WebShop" product type is enabled in your Business dashboard.
- * :::
- *
- * @description Encode webshop related user interactions
- *
- * @group Interactions Encoder
- *
- * @see {@link PreparedInteraction} The prepared interaction object that can be sent
- * @see {@link !actions.sendInteraction | `sendInteraction()`} Action used to send the prepared interaction to the Frak Wallet
- */
-export const WebShopInteractionEncoder = {
-    /**
-     * Encode an open webshop interaction
-     */
-    open(): PreparedInteraction {
-        return {
-            handlerTypeDenominator: toHex(productTypes.webshop),
-            interactionData: interactionTypes.webshop.open,
-        };
-    },
-};

package/src/types/rpc/modal/openSession.ts

@@ -1,25 +0,0 @@
-import type { GenericModalStepType } from "./generic";
-
-/**
- * Return type of the open session modal step
- * @inline
- * @ignore
- */
-export type OpenInteractionSessionReturnType = {
-    startTimestamp: number;
-    endTimestamp: number;
-};
-
-/**
- * The open interaction session step for a Modal
- *
- * **Input**: None
- * **Output**: The interactions session period (start and end timestamp)
- *
- * @group Modal Display
- */
-export type OpenInteractionSessionModalStepType = GenericModalStepType<
-    "openSession",
-    object,
-    OpenInteractionSessionReturnType
->;

package/src/types/rpc/productInformation.ts

@@ -1,59 +0,0 @@
-import type { Address, Hex } from "viem";
-import type { FullInteractionTypesKey } from "../../constants/interactionTypes";
-import type { ProductTypesKey } from "../../constants/productTypes";
-
-/**
- * The type for the amount of tokens
- */
-export type TokenAmountType = {
-    amount: number;
-    eurAmount: number;
-    usdAmount: number;
-    gbpAmount: number;
-};
-
-/**
- * Response of the `frak_getProductInformation` RPC method
- * @group RPC Schema
- */
-export type GetProductInformationReturnType = {
-    /**
-     * Current product id
-     */
-    id: Hex;
-    /**
-     * Some metadata
-     */
-    onChainMetadata: {
-        /**
-         * Name of the product on-chain
-         */
-        name: string;
-        /**
-         * Domain of the product on-chain
-         */
-        domain: string;
-        /**
-         * The supported product types
-         */
-        productTypes: ProductTypesKey[];
-    };
-    /**
-     * The max potential reward for the referrer
-     */
-    maxReferrer?: TokenAmountType;
-    /**
-     * The max potential reward for the referee
-     */
-    maxReferee?: TokenAmountType;
-    /**
-     * List of all the potentials reward arround this product
-     */
-    rewards: {
-        token: Address;
-        campaign: Address;
-        interactionTypeKey: FullInteractionTypesKey;
-        referrer: TokenAmountType;
-        referee: TokenAmountType;
-    }[];
-};

package/src/utils/computeProductId.test.ts

@@ -1,80 +0,0 @@
-/**
- * Tests for computeProductId utility function
- * Tests product ID computation from domain names with normalization
- */
-
-import { keccak256, toHex } from "viem";
-import { describe, expect, it } from "../../tests/vitest-fixtures";
-import { computeProductId } from "./computeProductId";
-
-describe("computeProductId", () => {
-    it("should compute product ID from current domain (window.location.host)", () => {
-        // In JSDOM test environment, window.location.host is "localhost:3000"
-        const productId = computeProductId();
-
-        // Should compute keccak256 hash of window.location.host
-        const expectedId = keccak256(toHex(window.location.host));
-        expect(productId).toBe(expectedId);
-    });
-
-    it("should compute product ID from custom domain", () => {
-        const customDomain = "custom-domain.com";
-        const productId = computeProductId({ domain: customDomain });
-
-        // Should compute keccak256 hash of custom domain
-        const expectedId = keccak256(toHex(customDomain));
-        expect(productId).toBe(expectedId);
-    });
-
-    it("should remove www. prefix from domain before hashing", () => {
-        const domainWithWww = "www.example.com";
-        const productId = computeProductId({ domain: domainWithWww });
-
-        // Should compute keccak256 hash of "example.com" (www. removed)
-        const expectedId = keccak256(toHex("example.com"));
-        expect(productId).toBe(expectedId);
-    });
-
-    it("should produce same product ID for domain with and without www", () => {
-        const withWww = computeProductId({ domain: "www.example.com" });
-        const withoutWww = computeProductId({ domain: "example.com" });
-
-        // Both should produce the same hash
-        expect(withWww).toBe(withoutWww);
-    });
-
-    it("should produce different product IDs for different domains", () => {
-        const domain1ProductId = computeProductId({ domain: "domain1.com" });
-        const domain2ProductId = computeProductId({ domain: "domain2.com" });
-
-        // Different domains should produce different hashes
-        expect(domain1ProductId).not.toBe(domain2ProductId);
-    });
-
-    it("should use window.location.host when domain is not provided", () => {
-        // When no domain is provided, it should default to window.location.host
-        const productId = computeProductId();
-
-        // Should produce same result as using window.location.host explicitly
-        const expectedId = keccak256(toHex(window.location.host));
-        expect(productId).toBe(expectedId);
-    });
-
-    it("should handle subdomains correctly", () => {
-        const subdomain = "blog.example.com";
-        const productId = computeProductId({ domain: subdomain });
-
-        // Should compute keccak256 hash of "blog.example.com" (subdomain preserved)
-        const expectedId = keccak256(toHex(subdomain));
-        expect(productId).toBe(expectedId);
-    });
-
-    it("should only remove www prefix, not other w-prefixed subdomains", () => {
-        const domain = "web.example.com";
-        const productId = computeProductId({ domain });
-
-        // Should NOT remove "web." prefix, only "www."
-        const expectedId = keccak256(toHex("web.example.com"));
-        expect(productId).toBe(expectedId);
-    });
-});