@rainlanguage/ui-components 0.0.1-alpha.21 → 0.0.1-alpha.210

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/keys.d.ts

@@ -7,3 +7,4 @@ export declare const QKEY_ORDER_TRADES_LIST = "orderTradesList";
 export declare const QKEY_ORDER_QUOTE = "orderQuote";
 export declare const QKEY_VAULTS_VOL_LIST = "orderVaultsVolumeList";
 export declare const QKEY_ORDER_APY = "orderApy";
+export declare const QKEY_TOKENS = "tokens";

package/dist/queries/keys.js

@@ -7,3 +7,4 @@ export const QKEY_ORDER_TRADES_LIST = 'orderTradesList';
 export const QKEY_ORDER_QUOTE = 'orderQuote';
 export const QKEY_VAULTS_VOL_LIST = 'orderVaultsVolumeList';
 export const QKEY_ORDER_APY = 'orderApy';
+export const QKEY_TOKENS = 'tokens';

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,107 @@
+/**
+ * @module awaitTransactionIndexing
+ * @description Utilities for waiting for transactions to be indexed by a subgraph
+ */
+import type { WasmEncodedResult, RaindexTransaction, RaindexOrder, Address, Hex } from '@rainlanguage/orderbook';
+export type AwaitSubgraphConfig = {
+    chainId: number;
+    orderbook: Address;
+    txHash: Hex;
+    successMessage: string;
+    fetchEntityFn: (chainId: number, orderbook: Address, txHash: Hex) => Promise<WasmEncodedResult<RaindexTransaction | RaindexOrder[] | null | undefined>>;
+    isSuccess: (data: RaindexTransaction | RaindexOrder[]) => 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: Hex;
+        /**
+         * Message to display on successful indexing
+         */
+        successMessage: string;
+        /**
+         * Optional order hash if available
+         */
+        orderHash?: Hex;
+        /**
+         * 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.chainId Chain ID to query
+ * @param options.orderbook Orderbook address 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: {
+    /**
+     * Chain ID to query
+     */
+    chainId: number;
+    /**
+     * Orderbook address to query
+     */
+    orderbook: Address;
+    /**
+     * Transaction hash to check for indexing
+     */
+    txHash: Hex;
+    /**
+     * 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 chainId Chain ID to query
+     * @param orderbook Orderbook address to query
+     * @param txHash Transaction hash to query
+     */
+    fetchEntityFn: (chainId: number, orderbook: Address, txHash: Hex) => 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,58 @@
+/**
+ * @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.chainId Chain ID to query
+ * @param options.orderbook Orderbook address 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 { chainId, orderbook, txHash, successMessage, maxAttempts = 10, interval = 1000, network, fetchEntityFn, isSuccess } = options;
+    const checkIndexing = async (attempt) => {
+        try {
+            const data = await fetchEntityFn(chainId, orderbook, 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]?.orderHash) {
+                    newOrderHash = data.value[0].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/getExplorerLink.d.ts

@@ -1 +1 @@
-export declare const getExplorerLink: (hash: string, chainId: number, type: "tx" | "address") => Promise<string>;
+export declare const getExplorerLink: (hash: string, chainId: number, type: "tx" | "address") => string;

package/dist/services/getExplorerLink.js

@@ -1,10 +1,8 @@
 import * as chains from 'viem/chains';
-export const getExplorerLink = async (hash, chainId, type) => {
+export const getExplorerLink = (hash, chainId, type) => {
     const chain = Object.values(chains).find((chain) => chain.id === chainId);
     if (chain?.blockExplorers) {
         return chain.blockExplorers.default.url + `/${type}/${hash}`;
     }
-    else {
-        return '';
-    }
+    return '';
 };

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,11 +1,11 @@
-import type { SgTrade } from '@rainlanguage/orderbook/js_api';
+import type { RaindexTrade } from '@rainlanguage/orderbook';
 import type { UTCTimestamp } from 'lightweight-charts';
 export type HistoricalOrderChartData = {
     value: number;
     time: UTCTimestamp;
     color?: string;
 }[];
-export declare function prepareHistoricalOrderChartData(takeOrderEntities: SgTrade[], colorTheme: string): {
+export declare function prepareHistoricalOrderChartData(takeOrderEntities: RaindexTrade[], colorTheme: string): {
     value: number;
     time: UTCTimestamp;
     color?: string;