@rainlanguage/ui-components 0.0.1-alpha.13 → 0.0.1-alpha.131

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[]) => Promise<void>;

package/dist/queries/queryClient.js

@@ -7,10 +7,15 @@ export const queryClient = new QueryClient({
         }
     }
 });
-export const invalidateIdQuery = async (queryClient, id) => {
-    await queryClient.invalidateQueries({
-        queryKey: [id],
-        refetchType: 'all',
-        exact: false
-    });
+export const invalidateTanstackQueries = async (queryClient, queryKey) => {
+    try {
+        await queryClient.invalidateQueries({
+            queryKey,
+            refetchType: 'all',
+            exact: false
+        });
+    }
+    catch {
+        throw new Error('Failed to refresh data.');
+    }
 };

package/dist/services/awaitTransactionIndexing.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @module awaitTransactionIndexing
+ * @description Utilities for waiting for transactions to be indexed by a subgraph
+ */
+import type { getTransactionRemoveOrders, getTransaction, getTransactionAddOrders, WasmEncodedResult, SgTransaction, SgRemoveOrderWithOrder } from '@rainlanguage/orderbook';
+export type AwaitSubgraphConfig = {
+    subgraphUrl: string;
+    txHash: string;
+    successMessage: string;
+    fetchEntityFn: typeof getTransaction | typeof getTransactionRemoveOrders | typeof getTransactionAddOrders;
+    isSuccess: (data: SgTransaction | SgRemoveOrderWithOrder[]) => boolean;
+};
+/**
+ * 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
+ * @param options.subgraphUrl URL of the subgraph to query
+ * @param options.txHash Transaction hash to check for indexing
+ * @param options.successMessage Message to display on successful indexing
+ * @param options.maxAttempts Maximum number of attempts before timing out (default: 10)
+ * @param options.interval Interval between attempts in milliseconds (default: 1000)
+ * @param options.network Optional network identifier
+ * @param options.fetchEntityFn Function to fetch data from the subgraph
+ * @param options.isSuccess Function to determine if the fetched data indicates success
+ * @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
+     */
+    fetchEntityFn: (subgraphUrl: string, txHash: string) => Promise<WasmEncodedResult<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>>;

package/dist/services/awaitTransactionIndexing.js

@@ -0,0 +1,57 @@
+/**
+ * @module awaitTransactionIndexing
+ * @description Utilities for waiting for transactions to be indexed by a subgraph
+ */
+import { TransactionStoreErrorMessage } from '../types/transaction';
+/**
+ * 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
+ * @param options.subgraphUrl URL of the subgraph to query
+ * @param options.txHash Transaction hash to check for indexing
+ * @param options.successMessage Message to display on successful indexing
+ * @param options.maxAttempts Maximum number of attempts before timing out (default: 10)
+ * @param options.interval Interval between attempts in milliseconds (default: 1000)
+ * @param options.network Optional network identifier
+ * @param options.fetchEntityFn Function to fetch data from the subgraph
+ * @param options.isSuccess Function to determine if the fetched data indicates success
+ * @returns Promise resolving to an IndexingResult
+ */
+export const awaitSubgraphIndexing = async (options) => {
+    const { subgraphUrl, txHash, successMessage, maxAttempts = 10, interval = 1000, network, fetchEntityFn, isSuccess } = options;
+    const checkIndexing = async (attempt) => {
+        try {
+            const data = await fetchEntityFn(subgraphUrl, txHash);
+            if (data.value && isSuccess(data.value)) {
+                let newOrderHash;
+                // Extract orderHash from order data if it exists in the expected format
+                // This only applies to addOrder transactions
+                if (Array.isArray(data.value) && data.value.length > 0 && data.value[0]?.order?.orderHash) {
+                    newOrderHash = data.value[0].order.orderHash;
+                }
+                return {
+                    value: {
+                        txHash,
+                        successMessage,
+                        orderHash: newOrderHash,
+                        network,
+                        data: data.value
+                    }
+                };
+            }
+        }
+        catch {
+            // Continue with the next attempt
+        }
+        if (attempt >= maxAttempts) {
+            return {
+                error: TransactionStoreErrorMessage.SUBGRAPH_TIMEOUT_ERROR
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval));
+        return checkIndexing(attempt + 1);
+    };
+    return checkIndexing(1);
+};

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/historicalOrderCharts.js

@@ -1,4 +1,4 @@
-import { timestampSecondsToUTCTimestamp } from '../utils/time';
+import { timestampSecondsToUTCTimestamp } from '../services/time';
 import { sortBy } from 'lodash';
 import { formatUnits } from 'viem';
 export function prepareHistoricalOrderChartData(takeOrderEntities, colorTheme) {

package/dist/services/index.d.ts

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

package/dist/services/index.js

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

package/dist/services/loadRegistryUrl.d.ts

@@ -0,0 +1,2 @@
+import { RegistryManager } from '../providers/registry/RegistryManager';
+export declare function loadRegistryUrl(url: string, registryManager: RegistryManager): Promise<void>;

package/dist/services/loadRegistryUrl.js

@@ -0,0 +1,19 @@
+import { RegistryManager } from '../providers/registry/RegistryManager';
+import { fetchRegistryDotrains } from './registry';
+export async function loadRegistryUrl(url, registryManager) {
+    if (!url) {
+        throw new Error('No URL provided');
+    }
+    if (!registryManager) {
+        throw new Error('Registry manager is required');
+    }
+    try {
+        await fetchRegistryDotrains(url);
+        registryManager.setRegistry(url);
+        window.location.reload();
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : 'Failed to update registry URL';
+        throw new Error(errorMessage);
+    }
+}

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>;

package/dist/services/registry.js

@@ -1,3 +1,4 @@
+import { DotrainOrderGui } from '@rainlanguage/orderbook';
 /**
  * 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.
@@ -52,82 +53,37 @@ export const fetchRegistryDotrains = async (url) => {
     }));
     return dotrains;
 };
-if (import.meta.vitest) {
-    const { describe, it, expect, vi } = import.meta.vitest;
-    describe('getFileRegistry', () => {
-        it('should parse registry file content correctly', async () => {
-            const mockResponse = `file1.js https://example.com/file1.js
-file2.js https://example.com/file2.js`;
-            global.fetch = vi.fn().mockResolvedValue({
-                ok: true,
-                text: () => Promise.resolve(mockResponse)
-            });
-            const result = await fetchParseRegistry('https://example.com/registry');
-            expect(result).toEqual([
-                { name: 'file1.js', url: 'https://example.com/file1.js' },
-                { name: 'file2.js', url: 'https://example.com/file2.js' }
-            ]);
-        });
-        it('should handle failed fetch response', async () => {
-            global.fetch = vi.fn().mockResolvedValue({
-                ok: false
-            });
-            await expect(fetchParseRegistry('https://example.com/registry')).rejects.toThrow('Failed to fetch registry');
-        });
-        it('should handle network errors', async () => {
-            global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-            await expect(fetchParseRegistry('https://example.com/registry')).rejects.toThrow('Network error');
-        });
-    });
-    describe('fetchRegistryDotrains', () => {
-        it('should fetch and parse dotrains correctly', async () => {
-            const mockRegistry = `file1.rain https://example.com/file1.rain
-file2.rain https://example.com/file2.rain`;
-            const mockDotrain1 = 'content of file1';
-            const mockDotrain2 = 'content of file2';
-            global.fetch = vi
-                .fn()
-                .mockResolvedValueOnce({
-                ok: true,
-                text: () => Promise.resolve(mockRegistry)
-            })
-                .mockResolvedValueOnce({
-                ok: true,
-                text: () => Promise.resolve(mockDotrain1)
-            })
-                .mockResolvedValueOnce({
-                ok: true,
-                text: () => Promise.resolve(mockDotrain2)
-            });
-            const result = await fetchRegistryDotrains('https://example.com/registry');
-            expect(result).toEqual([
-                { name: 'file1.rain', dotrain: mockDotrain1 },
-                { name: 'file2.rain', dotrain: mockDotrain2 }
-            ]);
-        });
-        it('should handle failed dotrain fetch', async () => {
-            const mockRegistry = `file1.rain https://example.com/file1.rain`;
-            global.fetch = vi
-                .fn()
-                .mockResolvedValueOnce({
-                ok: true,
-                text: () => Promise.resolve(mockRegistry)
-            })
-                .mockResolvedValueOnce({
-                ok: false
-            });
-            await expect(fetchRegistryDotrains('https://example.com/registry')).rejects.toThrow('Failed to fetch dotrain for file1.rain');
-        });
-        it('should handle network errors during dotrain fetch', async () => {
-            const mockRegistry = `file1.rain https://example.com/file1.rain`;
-            global.fetch = vi
-                .fn()
-                .mockResolvedValueOnce({
-                ok: true,
-                text: () => Promise.resolve(mockRegistry)
-            })
-                .mockRejectedValueOnce(new Error('Network error'));
-            await expect(fetchRegistryDotrains('https://example.com/registry')).rejects.toThrow('Error fetching dotrain for file1.rain: Network error');
-        });
+export async function validateStrategies(registryDotrains) {
+    const strategiesPromises = registryDotrains.map(async (registryDotrain) => {
+        try {
+            const result = await DotrainOrderGui.getStrategyDetails(registryDotrain.dotrain);
+            if (result.error) {
+                throw new Error(result.error.msg);
+            }
+            return {
+                valid: true,
+                data: {
+                    ...registryDotrain,
+                    details: result.value
+                }
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                data: {
+                    name: registryDotrain.name,
+                    error: error instanceof Error ? error.message : String(error)
+                }
+            };
+        }
     });
+    const strategiesResults = await Promise.all(strategiesPromises);
+    const validStrategies = strategiesResults
+        .filter((result) => result.valid)
+        .map((result) => result.data);
+    const invalidStrategies = strategiesResults
+        .filter((result) => !result.valid)
+        .map((result) => result.data);
+    return { validStrategies, invalidStrategies };
 }

package/dist/services/time.d.ts

@@ -1,6 +1,18 @@
+import type { UTCTimestamp } from 'lightweight-charts';
 export declare const TIME_DELTA_24_HOURS: number;
 export declare const TIME_DELTA_48_HOURS: number;
 export declare const TIME_DELTA_7_DAYS: number;
 export declare const TIME_DELTA_30_DAYS: number;
 export declare const TIME_DELTA_1_YEAR: number;
 export declare function dateTimestamp(date: Date): number;
+export declare function formatTimestampSecondsAsLocal(timestampSeconds: bigint): string;
+export declare function timestampSecondsToUTCTimestamp(timestampSeconds: bigint): UTCTimestamp;
+/**
+ * Method to put a timeout on a promise, throws the exception if promise is not settled within the time
+ * @param promise - The original promise
+ * @param time - The time in ms
+ * @param exception - The exception to reject with if time runs out before original promise settlement
+ * @returns A new promise that gets settled with initial promise settlement or rejected with exception value
+ * if the time runs out before the main promise settlement
+ */
+export declare function promiseTimeout<T>(promise: Promise<T>, time: number, exception: unknown): Promise<T>;