@rainlanguage/ui-components 0.0.1-alpha.8 → 0.0.1-alpha.80

package/dist/providers/wallet/context.js

@@ -0,0 +1,47 @@
+import { getContext, setContext } from 'svelte';
+import { readable } from 'svelte/store';
+export const ACCOUNT_KEY = 'account_key';
+/**
+ * Retrieves the account store directly from Svelte's context
+ */
+export const getAccountContext = () => {
+    const account = getContext(ACCOUNT_KEY);
+    if (!account) {
+        throw new Error('No account was found in Svelte context. Did you forget to wrap your component with WalletProvider?');
+    }
+    return account;
+};
+/**
+ * Sets the account store in Svelte's context
+ */
+export const setAccountContext = (account) => {
+    setContext(ACCOUNT_KEY, account);
+};
+if (import.meta.vitest) {
+    const { describe, it, expect, vi, beforeEach } = import.meta.vitest;
+    vi.mock('svelte', async (importOriginal) => ({
+        ...(await importOriginal()),
+        getContext: vi.fn()
+    }));
+    describe('getAccountContext', () => {
+        const mockGetContext = vi.mocked(getContext);
+        beforeEach(() => {
+            mockGetContext.mockReset();
+        });
+        it('should return the account from context when it exists', () => {
+            const mockAccount = readable('0x456');
+            mockGetContext.mockImplementation((key) => {
+                if (key === ACCOUNT_KEY)
+                    return mockAccount;
+                return undefined;
+            });
+            const result = getAccountContext();
+            expect(mockGetContext).toHaveBeenCalledWith(ACCOUNT_KEY);
+            expect(result).toEqual(mockAccount);
+        });
+        it('should throw an error when account is not in context', () => {
+            mockGetContext.mockReturnValue(undefined);
+            expect(() => getAccountContext()).toThrow('No account was found in Svelte context. Did you forget to wrap your component with WalletProvider?');
+        });
+    });
+}

package/dist/providers/wallet/useAccount.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hook to access wallet account information from context
+ * Must be used within a component that is a child of WalletProvider
+ */
+export declare function useAccount(): {
+    account: import("../../types/account").Account;
+    matchesAccount: (otherAddress: string) => boolean;
+};

package/dist/providers/wallet/useAccount.js

@@ -0,0 +1,148 @@
+import { get } from 'svelte/store';
+import { isAddress, isAddressEqual } from 'viem';
+import { getAccountContext } from './context';
+import { readable } from 'svelte/store';
+/**
+ * Hook to access wallet account information from context
+ * Must be used within a component that is a child of WalletProvider
+ */
+export function useAccount() {
+    /**
+     * The account store containing the current wallet address (as a Hex string) or null if not connected.
+     * This is a readable Svelte store that can be subscribed to for reactive updates.
+     * @type {import('svelte/store').Readable<Hex | null>}
+     */
+    const account = getAccountContext();
+    /**
+     * Checks if the provided address matches the currently connected account.
+     * Returns false if no account is connected or if the provided address is invalid.
+     */
+    const matchesAccount = (otherAddress) => {
+        if (!otherAddress)
+            return false;
+        const currentAccount = get(account);
+        if (!currentAccount) {
+            return false;
+        }
+        if (isAddress(currentAccount) &&
+            isAddress(otherAddress) &&
+            isAddressEqual(currentAccount, otherAddress)) {
+            return true;
+        }
+        return false;
+    };
+    return {
+        account,
+        matchesAccount
+    };
+}
+if (import.meta.vitest) {
+    const { describe, it, expect, vi, beforeEach } = import.meta.vitest;
+    vi.mock('viem', async () => {
+        const actual = await vi.importActual('viem');
+        return {
+            ...actual,
+            isAddress: vi.fn(),
+            isAddressEqual: vi.fn()
+        };
+    });
+    vi.mock('./context', () => ({
+        getAccountContext: vi.fn()
+    }));
+    vi.mock('svelte/store', async () => {
+        const actual = await vi.importActual('svelte/store');
+        return {
+            ...actual,
+            get: vi.fn()
+        };
+    });
+    describe('useAccount', () => {
+        const mockGetAccountContext = vi.mocked(getAccountContext);
+        const mockGet = vi.mocked(get);
+        const mockIsAddress = vi.mocked(isAddress);
+        const mockIsAddressEqual = vi.mocked(isAddressEqual);
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should return account wrapped in an object', () => {
+            const mockAccountStore = readable('0x123');
+            mockGetAccountContext.mockReturnValue(mockAccountStore);
+            const result = useAccount();
+            expect(mockGetAccountContext).toHaveBeenCalled();
+            expect(result.account).toBe(mockAccountStore);
+            expect(result.matchesAccount).toBeInstanceOf(Function);
+        });
+        describe('matchesAccount', () => {
+            const mockAccountStore = readable('0x123');
+            const currentAccount = '0x123';
+            const testAddress1 = '0x123';
+            const testAddress2 = '0xdef';
+            const invalidAddress = 'invalid';
+            beforeEach(() => {
+                mockGetAccountContext.mockReturnValue(mockAccountStore);
+            });
+            it('should return true if addresses are valid and equal', () => {
+                // Setup mocks
+                mockGet.mockReturnValue(currentAccount);
+                mockIsAddress.mockReturnValue(true);
+                mockIsAddressEqual.mockReturnValue(true);
+                const { matchesAccount } = useAccount();
+                const result = matchesAccount(testAddress1);
+                expect(mockGet).toHaveBeenCalledWith(mockAccountStore);
+                expect(mockIsAddress).toHaveBeenCalledWith(currentAccount);
+                expect(mockIsAddress).toHaveBeenCalledWith(testAddress1);
+                expect(mockIsAddressEqual).toHaveBeenCalledWith(currentAccount, testAddress1);
+                expect(result).toBe(true);
+            });
+            it('should return false if addresses are valid but not equal', () => {
+                // Setup mocks
+                mockGet.mockReturnValue(currentAccount);
+                mockIsAddress.mockReturnValue(true);
+                mockIsAddressEqual.mockReturnValue(false);
+                const { matchesAccount } = useAccount();
+                const result = matchesAccount(testAddress2);
+                expect(mockGet).toHaveBeenCalledWith(mockAccountStore);
+                expect(mockIsAddress).toHaveBeenCalledWith(currentAccount);
+                expect(mockIsAddress).toHaveBeenCalledWith(testAddress2);
+                expect(mockIsAddressEqual).toHaveBeenCalledWith(currentAccount, testAddress2);
+                expect(result).toBe(false);
+            });
+            it('should return false if current account is not set', () => {
+                // Setup mocks
+                mockGet.mockReturnValue(null);
+                const { matchesAccount } = useAccount();
+                const result = matchesAccount(testAddress1);
+                expect(mockGet).toHaveBeenCalledWith(mockAccountStore);
+                expect(mockIsAddress).not.toHaveBeenCalled();
+                expect(mockIsAddressEqual).not.toHaveBeenCalled();
+                expect(result).toBe(false);
+            });
+            it('should return false if provided address is invalid', () => {
+                // Setup mocks
+                mockGet.mockReturnValue(currentAccount);
+                // This is crucial: we need to ensure short-circuit evaluation works correctly
+                mockIsAddress.mockImplementation((address) => {
+                    return address !== invalidAddress; // Only the invalid address returns false
+                });
+                // This should never be called due to short-circuit evaluation
+                mockIsAddressEqual.mockReturnValue(false);
+                const { matchesAccount } = useAccount();
+                const result = matchesAccount(invalidAddress);
+                expect(mockGet).toHaveBeenCalledWith(mockAccountStore);
+                expect(mockIsAddress).toHaveBeenCalledWith(currentAccount);
+                expect(mockIsAddress).toHaveBeenCalledWith(invalidAddress);
+                expect(mockIsAddressEqual).not.toHaveBeenCalled(); // This should now pass
+                expect(result).toBe(false);
+            });
+            it('should return false if provided address is null', () => {
+                // Setup mocks
+                mockGet.mockReturnValue(currentAccount);
+                const { matchesAccount } = useAccount();
+                const result = matchesAccount(null);
+                expect(mockIsAddress).not.toHaveBeenCalled();
+                expect(mockIsAddressEqual).not.toHaveBeenCalled();
+                expect(result).toBe(false);
+            });
+        });
+    });
+}

package/dist/queries/queryClient.d.ts

@@ -1,3 +1,3 @@
 import { QueryClient } from '@tanstack/svelte-query';
 export declare const queryClient: QueryClient;
-export declare const invalidateIdQuery: (queryClient: QueryClient, id: string) => Promise<void>;
+export declare const invalidateTanstackQueries: (queryClient: QueryClient, queryKey: string[]) => void;

package/dist/queries/queryClient.js

@@ -7,9 +7,9 @@ export const queryClient = new QueryClient({
         }
     }
 });
-export const invalidateIdQuery = async (queryClient, id) => {
-    await queryClient.invalidateQueries({
-        queryKey: [id],
+export const invalidateTanstackQueries = (queryClient, queryKey) => {
+    queryClient.invalidateQueries({
+        queryKey,
         refetchType: 'all',
         exact: false
     });

package/dist/services/awaitTransactionIndexing.d.ts

@@ -0,0 +1,163 @@
+/**
+ * @module awaitTransactionIndexing
+ * @description Utilities for waiting for transactions to be indexed by a subgraph
+ */
+import type { SgAddOrderWithOrder, SgRemoveOrderWithOrder, SgTransaction } from '@rainlanguage/orderbook';
+/**
+ * Error message when subgraph indexing times out
+ */
+export declare const TIMEOUT_ERROR = "The subgraph took too long to respond. Your transaction may still be processing.";
+/**
+ * Result of a subgraph indexing operation
+ * @template T The type of data returned by the subgraph
+ */
+export type IndexingResult<T> = {
+    /**
+     * The successful result of the indexing operation
+     */
+    value?: {
+        /**
+         * The transaction hash
+         */
+        txHash: string;
+        /**
+         * Message to display on successful indexing
+         */
+        successMessage: string;
+        /**
+         * Optional order hash if available
+         */
+        orderHash?: string;
+        /**
+         * Optional network key
+         */
+        network?: string;
+        /**
+         * Optional data returned from the subgraph
+         */
+        data?: T;
+    };
+    /**
+     * Error message if indexing failed
+     */
+    error?: string;
+};
+/**
+ * Generic function to handle waiting for subgraph indexing
+ * Returns a promise that resolves with an object containing either value or error
+ *
+ * @template T The type of data returned by the subgraph
+ * @param options Configuration options for the indexing operation
+ * @returns Promise resolving to an IndexingResult
+ */
+export declare const awaitSubgraphIndexing: <T>(options: {
+    /**
+     * URL of the subgraph to query
+     */
+    subgraphUrl: string;
+    /**
+     * Transaction hash to check for indexing
+     */
+    txHash: string;
+    /**
+     * Message to display on successful indexing
+     */
+    successMessage: string;
+    /**
+     * Maximum number of attempts before timing out
+     */
+    maxAttempts?: number;
+    /**
+     * Interval between attempts in milliseconds
+     */
+    interval?: number;
+    /**
+     * Optional network identifier
+     */
+    network?: string;
+    /**
+     * Function to fetch data from the subgraph
+     * @param subgraphUrl URL of the subgraph
+     * @param txHash Transaction hash to query
+     */
+    fetchData: (subgraphUrl: string, txHash: string) => Promise<T | null | undefined>;
+    /**
+     * Function to determine if the fetched data indicates success
+     * @param data The data returned from the subgraph
+     */
+    isSuccess: (data: T) => boolean;
+}) => Promise<IndexingResult<T>>;
+/**
+ * Configuration for transaction indexing
+ * @template T The type of data returned by the subgraph
+ */
+export interface TransactionConfig<T> {
+    /**
+     * URL of the subgraph to query
+     */
+    subgraphUrl: string;
+    /**
+     * Transaction hash to check for indexing
+     */
+    txHash: string;
+    /**
+     * Message to display on successful indexing
+     */
+    successMessage: string;
+    /**
+     * Optional network key
+     */
+    network?: string;
+    /**
+     * Maximum number of attempts before timing out
+     */
+    maxAttempts?: number;
+    /**
+     * Interval between attempts in milliseconds
+     */
+    interval?: number;
+    /**
+     * Function to fetch data from the subgraph
+     */
+    fetchData: (subgraphUrl: string, txHash: string) => Promise<T>;
+    /**
+     * Function to determine if the fetched data indicates success
+     */
+    isSuccess: (data: T) => boolean;
+}
+/**
+ * Creates a configuration for checking general transaction indexing
+ *
+ * @param subgraphUrl URL of the subgraph to query
+ * @param txHash Transaction hash to check for indexing
+ * @param successMessage Message to display on successful indexing
+ * @param network Optional network key
+ * @param maxAttempts Maximum number of attempts before timing out
+ * @param interval Interval between attempts in milliseconds
+ * @returns Configuration for transaction indexing
+ */
+export declare const getTransactionConfig: (subgraphUrl: string, txHash: string, successMessage: string, network?: string, maxAttempts?: number, interval?: number) => TransactionConfig<SgTransaction>;
+/**
+ * Creates a configuration for checking new order indexing
+ *
+ * @param subgraphUrl URL of the subgraph to query
+ * @param txHash Transaction hash to check for indexing
+ * @param successMessage Message to display on successful indexing
+ * @param network Optional network key
+ * @param maxAttempts Maximum number of attempts before timing out
+ * @param interval Interval between attempts in milliseconds
+ * @returns Configuration for new order indexing
+ */
+export declare const getNewOrderConfig: (subgraphUrl: string, txHash: string, successMessage: string, network?: string, maxAttempts?: number, interval?: number) => TransactionConfig<SgAddOrderWithOrder[]>;
+/**
+ * Creates a configuration for checking order removal indexing
+ *
+ * @param subgraphUrl URL of the subgraph to query
+ * @param txHash Transaction hash to check for indexing
+ * @param successMessage Message to display on successful indexing
+ * @param network Optional network key
+ * @param maxAttempts Maximum number of attempts before timing out
+ * @param interval Interval between attempts in milliseconds
+ * @returns Configuration for order removal indexing
+ */
+export declare const getRemoveOrderConfig: (subgraphUrl: string, txHash: string, successMessage: string, network?: string, maxAttempts?: number, interval?: number) => TransactionConfig<SgRemoveOrderWithOrder[]>;

package/dist/services/awaitTransactionIndexing.js

@@ -0,0 +1,120 @@
+/**
+ * @module awaitTransactionIndexing
+ * @description Utilities for waiting for transactions to be indexed by a subgraph
+ */
+import { getTransaction, getTransactionAddOrders, getTransactionRemoveOrders } from '@rainlanguage/orderbook';
+/**
+ * Error message when subgraph indexing times out
+ */
+export const TIMEOUT_ERROR = 'The subgraph took too long to respond. Your transaction may still be processing.';
+/**
+ * Generic function to handle waiting for subgraph indexing
+ * Returns a promise that resolves with an object containing either value or error
+ *
+ * @template T The type of data returned by the subgraph
+ * @param options Configuration options for the indexing operation
+ * @returns Promise resolving to an IndexingResult
+ */
+export const awaitSubgraphIndexing = async (options) => {
+    const { subgraphUrl, txHash, successMessage, maxAttempts = 10, interval = 1000, network, fetchData, isSuccess } = options;
+    return new Promise((resolve) => {
+        let attempts = 0;
+        const checkInterval = setInterval(async () => {
+            attempts++;
+            try {
+                const data = await fetchData(subgraphUrl, txHash);
+                if (data && isSuccess(data)) {
+                    clearInterval(checkInterval);
+                    let orderHash;
+                    // Extract orderHash from order data if it exists in the expected format
+                    if (Array.isArray(data) && data.length > 0 && data[0]?.order?.orderHash) {
+                        orderHash = data[0].order.orderHash;
+                    }
+                    resolve({
+                        value: {
+                            txHash,
+                            successMessage,
+                            orderHash,
+                            network,
+                            data
+                        }
+                    });
+                    return;
+                }
+            }
+            catch {
+                // Continue with the next attempt
+            }
+            if (attempts >= maxAttempts) {
+                clearInterval(checkInterval);
+                resolve({
+                    error: TIMEOUT_ERROR
+                });
+                return;
+            }
+        }, interval);
+    });
+};
+/**
+ * Creates a configuration for checking general transaction indexing
+ *
+ * @param subgraphUrl URL of the subgraph to query
+ * @param txHash Transaction hash to check for indexing
+ * @param successMessage Message to display on successful indexing
+ * @param network Optional network key
+ * @param maxAttempts Maximum number of attempts before timing out
+ * @param interval Interval between attempts in milliseconds
+ * @returns Configuration for transaction indexing
+ */
+export const getTransactionConfig = (subgraphUrl, txHash, successMessage, network, maxAttempts, interval) => ({
+    subgraphUrl,
+    txHash,
+    successMessage,
+    network,
+    maxAttempts,
+    interval,
+    fetchData: getTransaction,
+    isSuccess: (tx) => !!tx
+});
+/**
+ * Creates a configuration for checking new order indexing
+ *
+ * @param subgraphUrl URL of the subgraph to query
+ * @param txHash Transaction hash to check for indexing
+ * @param successMessage Message to display on successful indexing
+ * @param network Optional network key
+ * @param maxAttempts Maximum number of attempts before timing out
+ * @param interval Interval between attempts in milliseconds
+ * @returns Configuration for new order indexing
+ */
+export const getNewOrderConfig = (subgraphUrl, txHash, successMessage, network, maxAttempts, interval) => ({
+    subgraphUrl,
+    txHash,
+    successMessage,
+    network,
+    maxAttempts,
+    interval,
+    fetchData: getTransactionAddOrders,
+    isSuccess: (addOrders) => addOrders?.length > 0
+});
+/**
+ * Creates a configuration for checking order removal indexing
+ *
+ * @param subgraphUrl URL of the subgraph to query
+ * @param txHash Transaction hash to check for indexing
+ * @param successMessage Message to display on successful indexing
+ * @param network Optional network key
+ * @param maxAttempts Maximum number of attempts before timing out
+ * @param interval Interval between attempts in milliseconds
+ * @returns Configuration for order removal indexing
+ */
+export const getRemoveOrderConfig = (subgraphUrl, txHash, successMessage, network, maxAttempts, interval) => ({
+    subgraphUrl,
+    txHash,
+    successMessage,
+    network,
+    maxAttempts,
+    interval,
+    fetchData: getTransactionRemoveOrders,
+    isSuccess: (removeOrders) => removeOrders?.length > 0
+});

package/dist/services/handleShareChoices.d.ts

@@ -1,2 +1,2 @@
-import type { DotrainOrderGui } from '@rainlanguage/orderbook/js_api';
-export declare function handleShareChoices(gui: DotrainOrderGui): Promise<void>;
+import type { DotrainOrderGui } from '@rainlanguage/orderbook';
+export declare function handleShareChoices(gui: DotrainOrderGui, registryUrl: string): Promise<void>;

package/dist/services/handleShareChoices.js

@@ -1,10 +1,15 @@
 import { page } from '$app/stores';
 import { get } from 'svelte/store';
-export async function handleShareChoices(gui) {
+export async function handleShareChoices(gui, registryUrl) {
     // get the current url
     const url = get(page).url;
     // get the current state
-    const state = gui?.serializeState();
+    const result = gui.serializeState();
+    if (result.error) {
+        throw new Error(result.error.msg);
+    }
+    const state = result.value;
     url.searchParams.set('state', state || '');
+    url.searchParams.set('registry', registryUrl);
     navigator.clipboard.writeText(url.toString());
 }

package/dist/services/historicalOrderCharts.d.ts

@@ -1,4 +1,4 @@
-import type { SgTrade } from '@rainlanguage/orderbook/js_api';
+import type { SgTrade } from '@rainlanguage/orderbook';
 import type { UTCTimestamp } from 'lightweight-charts';
 export type HistoricalOrderChartData = {
     value: number;

package/dist/services/index.d.ts

@@ -1,2 +1,2 @@
-export { fetchParseRegistry, fetchRegistryDotrains } from './registry';
+export { fetchParseRegistry, fetchRegistryDotrains, validateStrategies } from './registry';
 export type { RegistryDotrain, RegistryFile } from './registry';

package/dist/services/index.js

@@ -1 +1 @@
-export { fetchParseRegistry, fetchRegistryDotrains } from './registry';
+export { fetchParseRegistry, fetchRegistryDotrains, validateStrategies } from './registry';

package/dist/services/registry.d.ts

@@ -1,3 +1,4 @@
+import type { InvalidStrategyDetail, ValidStrategyDetail } from '../types/strategy';
 export type RegistryFile = {
     name: string;
     url: string;
@@ -6,6 +7,10 @@ export type RegistryDotrain = {
     name: string;
     dotrain: string;
 };
+export interface StrategyValidationResult {
+    validStrategies: ValidStrategyDetail[];
+    invalidStrategies: InvalidStrategyDetail[];
+}
 /**
  * Fetches and parses a file registry from a given URL.
  * The registry is expected to be a text file where each line contains a file name and URL separated by a space.
@@ -23,3 +28,4 @@ export declare const fetchParseRegistry: (url: string) => Promise<{
     url: string;
 }[]>;
 export declare const fetchRegistryDotrains: (url: string) => Promise<RegistryDotrain[]>;
+export declare function validateStrategies(registryDotrains: RegistryDotrain[]): Promise<StrategyValidationResult>;