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

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,6 +53,40 @@ export const fetchRegistryDotrains = async (url) => {
     }));
     return dotrains;
 };
+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 };
+}
 if (import.meta.vitest) {
     const { describe, it, expect, vi } = import.meta.vitest;
     describe('getFileRegistry', () => {
@@ -130,4 +165,125 @@ file2.rain https://example.com/file2.rain`;
             await expect(fetchRegistryDotrains('https://example.com/registry')).rejects.toThrow('Error fetching dotrain for file1.rain: Network error');
         });
     });
+    describe('validateStrategies', async () => {
+        // Mock the DotrainOrderGui dependency
+        vi.mock('@rainlanguage/orderbook', () => ({
+            DotrainOrderGui: {
+                getStrategyDetails: vi.fn()
+            }
+        }));
+        // Import DotrainOrderGui after mocking
+        const { DotrainOrderGui } = await import('@rainlanguage/orderbook');
+        beforeEach(() => {
+            vi.resetAllMocks();
+        });
+        it('should validate strategies and categorize them properly', async () => {
+            // Input data
+            const registryDotrains = [
+                { name: 'valid.rain', dotrain: 'valid dotrain content' },
+                { name: 'invalid.rain', dotrain: 'invalid dotrain content' },
+                { name: 'another-valid.rain', dotrain: 'another valid content' }
+            ];
+            // Set up mock responses for the DotrainOrderGui
+            DotrainOrderGui.getStrategyDetails
+                .mockResolvedValueOnce({
+                value: { name: 'Valid Strategy', description: 'A valid strategy' },
+                error: null
+            })
+                .mockResolvedValueOnce({
+                error: { msg: 'Invalid syntax' },
+                value: null
+            })
+                .mockResolvedValueOnce({
+                value: { name: 'Another Valid', description: 'Another valid strategy' },
+                error: null
+            });
+            // Call the function with our test data
+            const result = await validateStrategies(registryDotrains);
+            // Verify DotrainOrderGui was called correctly
+            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledTimes(3);
+            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledWith('valid dotrain content');
+            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledWith('invalid dotrain content');
+            expect(DotrainOrderGui.getStrategyDetails).toHaveBeenCalledWith('another valid content');
+            // Verify the valid strategies are processed correctly
+            expect(result.validStrategies).toHaveLength(2);
+            expect(result.validStrategies[0].name).toBe('valid.rain');
+            expect(result.validStrategies[0].dotrain).toBe('valid dotrain content');
+            expect(result.validStrategies[0].details).toEqual({
+                name: 'Valid Strategy',
+                description: 'A valid strategy'
+            });
+            // Verify the invalid strategies are processed correctly
+            expect(result.invalidStrategies).toHaveLength(1);
+            expect(result.invalidStrategies[0].name).toBe('invalid.rain');
+            expect(result.invalidStrategies[0].error).toBe('Invalid syntax');
+        });
+        it('should handle exceptions thrown during strategy validation', async () => {
+            // Input data
+            const registryDotrains = [{ name: 'error.rain', dotrain: 'will throw error' }];
+            // Mock the DotrainOrderGui to throw an exception
+            DotrainOrderGui.getStrategyDetails.mockRejectedValueOnce(new Error('Unexpected parsing error'));
+            // Call the function
+            const result = await validateStrategies(registryDotrains);
+            // Verify results
+            expect(result.validStrategies).toHaveLength(0);
+            expect(result.invalidStrategies).toHaveLength(1);
+            expect(result.invalidStrategies[0].name).toBe('error.rain');
+            expect(result.invalidStrategies[0].error).toBe('Unexpected parsing error');
+        });
+        it('should handle non-Error objects being thrown', async () => {
+            // Input data
+            const registryDotrains = [{ name: 'string-error.rain', dotrain: 'will throw string' }];
+            // Mock the DotrainOrderGui to throw a string instead of an Error
+            DotrainOrderGui.getStrategyDetails.mockRejectedValueOnce('String error message');
+            // Call the function
+            const result = await validateStrategies(registryDotrains);
+            // Verify results
+            expect(result.validStrategies).toHaveLength(0);
+            expect(result.invalidStrategies).toHaveLength(1);
+            expect(result.invalidStrategies[0].name).toBe('string-error.rain');
+            expect(result.invalidStrategies[0].error).toBe('String error message');
+        });
+        it('should process an empty array of strategies', async () => {
+            const result = await validateStrategies([]);
+            expect(result.validStrategies).toEqual([]);
+            expect(result.invalidStrategies).toEqual([]);
+            expect(DotrainOrderGui.getStrategyDetails).not.toHaveBeenCalled();
+        });
+        it('should handle mixed validation results correctly', async () => {
+            // Create a mix of scenarios
+            const registryDotrains = [
+                { name: 'valid1.rain', dotrain: 'valid content 1' },
+                { name: 'error.rain', dotrain: 'will throw error' },
+                { name: 'valid2.rain', dotrain: 'valid content 2' },
+                { name: 'invalid.rain', dotrain: 'invalid content' }
+            ];
+            // Set up mock responses
+            DotrainOrderGui.getStrategyDetails
+                .mockResolvedValueOnce({
+                value: { strategyName: 'Strategy 1', description: 'Description 1' },
+                error: null
+            })
+                .mockRejectedValueOnce(new Error('Processing error'))
+                .mockResolvedValueOnce({
+                value: { strategyName: 'Strategy 2', description: 'Description 2' },
+                error: null
+            })
+                .mockResolvedValueOnce({
+                error: { msg: 'Validation failed' },
+                value: null
+            });
+            // Call the function
+            const result = await validateStrategies(registryDotrains);
+            // Verify results
+            expect(result.validStrategies).toHaveLength(2);
+            expect(result.validStrategies[0].name).toBe('valid1.rain');
+            expect(result.validStrategies[1].name).toBe('valid2.rain');
+            expect(result.invalidStrategies).toHaveLength(2);
+            expect(result.invalidStrategies[0].name).toBe('error.rain');
+            expect(result.invalidStrategies[0].error).toBe('Processing error');
+            expect(result.invalidStrategies[1].name).toBe('invalid.rain');
+            expect(result.invalidStrategies[1].error).toBe('Validation failed');
+        });
+    });
 }

package/dist/stores/transactionStore.d.ts

@@ -1,6 +1,7 @@
 import type { Hex } from 'viem';
 import type { Config } from '@wagmi/core';
-import type { ApprovalCalldata, DepositAndAddOrderCalldataResult, DepositCalldataResult, RemoveOrderCalldata, SgVault, WithdrawCalldataResult } from '@rainlanguage/orderbook/js_api';
+import type { ApprovalCalldata, DepositCalldataResult, RemoveOrderCalldata, SgVault, WithdrawCalldataResult } from '@rainlanguage/orderbook';
+import type { DeploymentArgs } from '../types/transaction';
 export declare const ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
 export declare const ONE: bigint;
 export declare enum TransactionStatus {
@@ -19,7 +20,7 @@ export declare enum TransactionStatus {
 export declare enum TransactionErrorMessage {
     BAD_CALLLDATA = "Bad calldata.",
     DEPLOY_FAILED = "Lock transaction failed.",
-    TIMEOUT = "Transaction timed out.",
+    TIMEOUT = "The subgraph took too long to respond.",
     APPROVAL_FAILED = "Approval transaction failed.",
     USER_REJECTED_APPROVAL = "User rejected approval transaction.",
     USER_REJECTED_TRANSACTION = "User rejected the transaction.",
@@ -32,14 +33,9 @@ export declare enum TransactionErrorMessage {
 export type ExtendedApprovalCalldata = ApprovalCalldata & {
     symbol?: string;
 };
-export type DeploymentTransactionArgs = {
+export type DeploymentArgsWithoutAccount = Omit<DeploymentArgs, 'account'>;
+export type DeploymentTransactionArgs = DeploymentArgsWithoutAccount & {
     config: Config;
-    approvals: ExtendedApprovalCalldata[];
-    deploymentCalldata: DepositAndAddOrderCalldataResult;
-    orderbookAddress: Hex;
-    chainId: number;
-    subgraphUrl: string;
-    network: string;
 };
 export type DepositOrWithdrawTransactionArgs = {
     config: Config;
@@ -80,6 +76,7 @@ export type TransactionStore = {
     transactionSuccess: (hash: string, message?: string) => void;
     transactionError: (message: TransactionErrorMessage, hash?: string) => void;
 };
+export declare const initialState: TransactionState;
 declare const _default: {
     subscribe: (this: void, run: import("svelte/store").Subscriber<TransactionState>, invalidate?: import("svelte/store").Invalidator<TransactionState> | undefined) => import("svelte/store").Unsubscriber;
     reset: () => void;
@@ -90,7 +87,7 @@ declare const _default: {
     awaitWalletConfirmation: (message?: string) => void;
     awaitApprovalTx: (hash: string, symbol: string | undefined) => void;
     transactionSuccess: (hash: string, message?: string, newOrderHash?: string, network?: string) => void;
-    transactionError: (message: TransactionErrorMessage, hash?: string) => void;
+    transactionError: (error: TransactionErrorMessage, hash?: string) => void;
     awaitTransactionIndexing: (subgraphUrl: string, txHash: string, successMessage: string) => Promise<void>;
     awaitNewOrderIndexing: (subgraphUrl: string, txHash: string, network?: string) => Promise<void>;
     awaitRemoveOrderIndexing: (subgraphUrl: string, txHash: string) => Promise<void>;

package/dist/stores/transactionStore.js

@@ -1,7 +1,7 @@
 import { writable } from 'svelte/store';
 import { sendTransaction, switchChain, waitForTransactionReceipt } from '@wagmi/core';
-import { getTransaction, getTransactionAddOrders, getTransactionRemoveOrders } from '@rainlanguage/orderbook/js_api';
 import { getExplorerLink } from '../services/getExplorerLink';
+import { awaitSubgraphIndexing, getNewOrderConfig, getRemoveOrderConfig, getTransactionConfig } from '../services/awaitTransactionIndexing';
 export const ADDRESS_ZERO = '0x0000000000000000000000000000000000000000';
 export const ONE = BigInt('1000000000000000000');
 export var TransactionStatus;
@@ -22,7 +22,7 @@ export var TransactionErrorMessage;
 (function (TransactionErrorMessage) {
     TransactionErrorMessage["BAD_CALLLDATA"] = "Bad calldata.";
     TransactionErrorMessage["DEPLOY_FAILED"] = "Lock transaction failed.";
-    TransactionErrorMessage["TIMEOUT"] = "Transaction timed out.";
+    TransactionErrorMessage["TIMEOUT"] = "The subgraph took too long to respond.";
     TransactionErrorMessage["APPROVAL_FAILED"] = "Approval transaction failed.";
     TransactionErrorMessage["USER_REJECTED_APPROVAL"] = "User rejected approval transaction.";
     TransactionErrorMessage["USER_REJECTED_TRANSACTION"] = "User rejected the transaction.";
@@ -32,7 +32,7 @@ export var TransactionErrorMessage;
     TransactionErrorMessage["WITHDRAWAL_FAILED"] = "Failed to withdraw tokens.";
     TransactionErrorMessage["REMOVE_ORDER_FAILED"] = "Failed to remove order.";
 })(TransactionErrorMessage || (TransactionErrorMessage = {}));
-const initialState = {
+export const initialState = {
     status: TransactionStatus.IDLE,
     error: '',
     hash: '',
@@ -50,26 +50,15 @@ const transactionStore = () => {
         update((state) => ({
             ...state,
             status: TransactionStatus.PENDING_SUBGRAPH,
-            message: 'Checking for transaction indexing...'
+            message: 'Waiting for transaction to be indexed...'
         }));
-        let attempts = 0;
-        let newTx;
-        const interval = setInterval(async () => {
-            attempts++;
-            newTx = await getTransaction(subgraphUrl, txHash);
-            if (newTx) {
-                clearInterval(interval);
-                transactionSuccess(txHash, successMessage);
-            }
-            else if (attempts >= 10) {
-                update((state) => ({
-                    ...state,
-                    message: 'The subgraph took too long to respond. Please check again later.'
-                }));
-                clearInterval(interval);
-                return transactionError(TransactionErrorMessage.TIMEOUT);
-            }
-        }, 1000);
+        const result = await awaitSubgraphIndexing(getTransactionConfig(subgraphUrl, txHash, successMessage));
+        if (result.error) {
+            return transactionError(TransactionErrorMessage.TIMEOUT);
+        }
+        if (result.value) {
+            return transactionSuccess(result.value.txHash, result.value.successMessage);
+        }
     };
     const awaitNewOrderIndexing = async (subgraphUrl, txHash, network) => {
         update((state) => ({
@@ -77,23 +66,13 @@ const transactionStore = () => {
             status: TransactionStatus.PENDING_SUBGRAPH,
             message: 'Waiting for new order to be indexed...'
         }));
-        let attempts = 0;
-        const interval = setInterval(async () => {
-            attempts++;
-            const addOrders = await getTransactionAddOrders(subgraphUrl, txHash);
-            if (attempts >= 10) {
-                update((state) => ({
-                    ...state,
-                    message: 'The subgraph took too long to respond. Please check again later.'
-                }));
-                clearInterval(interval);
-                return transactionError(TransactionErrorMessage.TIMEOUT);
-            }
-            else if (addOrders?.length > 0) {
-                clearInterval(interval);
-                return transactionSuccess(txHash, '', addOrders[0].order.orderHash, network);
-            }
-        }, 1000);
+        const result = await awaitSubgraphIndexing(getNewOrderConfig(subgraphUrl, txHash, '', network));
+        if (result.error) {
+            return transactionError(TransactionErrorMessage.TIMEOUT);
+        }
+        if (result.value) {
+            return transactionSuccess(result.value.txHash, result.value.successMessage, result.value.orderHash, result.value.network);
+        }
     };
     const awaitRemoveOrderIndexing = async (subgraphUrl, txHash) => {
         update((state) => ({
@@ -101,23 +80,13 @@ const transactionStore = () => {
             status: TransactionStatus.PENDING_SUBGRAPH,
             message: 'Waiting for order removal to be indexed...'
         }));
-        let attempts = 0;
-        const interval = setInterval(async () => {
-            attempts++;
-            const removeOrders = await getTransactionRemoveOrders(subgraphUrl, txHash);
-            if (attempts >= 10) {
-                update((state) => ({
-                    ...state,
-                    message: 'The subgraph took too long to respond. Please check again later.'
-                }));
-                clearInterval(interval);
-                return transactionError(TransactionErrorMessage.TIMEOUT);
-            }
-            else if (removeOrders?.length > 0) {
-                clearInterval(interval);
-                return transactionSuccess(txHash);
-            }
-        }, 1000);
+        const result = await awaitSubgraphIndexing(getRemoveOrderConfig(subgraphUrl, txHash, 'Order removed successfully'));
+        if (result.error) {
+            return transactionError(TransactionErrorMessage.TIMEOUT);
+        }
+        if (result.value) {
+            return transactionSuccess(result.value.txHash, result.value.successMessage);
+        }
     };
     const checkingWalletAllowance = (message) => update((state) => ({
         ...state,
@@ -152,10 +121,10 @@ const transactionStore = () => {
             network: network || ''
         }));
     };
-    const transactionError = (message, hash) => update((state) => ({
+    const transactionError = (error, hash) => update((state) => ({
         ...state,
         status: TransactionStatus.ERROR,
-        error: message,
+        error: error,
         hash: hash || ''
     }));
     const handleDeploymentTransaction = async ({ config, approvals, deploymentCalldata, orderbookAddress, chainId, subgraphUrl, network }) => {
@@ -200,7 +169,10 @@ const transactionStore = () => {
             const transactionExplorerLink = await getExplorerLink(hash, chainId, 'tx');
             awaitTx(hash, TransactionStatus.PENDING_DEPLOYMENT, transactionExplorerLink);
             await waitForTransactionReceipt(config, { hash });
-            return awaitNewOrderIndexing(subgraphUrl, hash, network);
+            if (subgraphUrl) {
+                return awaitNewOrderIndexing(subgraphUrl, hash, network);
+            }
+            return transactionSuccess(hash, 'Deployment successful. Check the Orders page for your new order.', '', network);
         }
         catch {
             return transactionError(TransactionErrorMessage.DEPLOYMENT_FAILED);
@@ -245,9 +217,10 @@ const transactionStore = () => {
             return transactionError(TransactionErrorMessage.USER_REJECTED_TRANSACTION);
         }
         try {
+            const transactionExplorerLink = await getExplorerLink(hash, chainId, 'tx');
             awaitTx(hash, action === 'deposit'
                 ? TransactionStatus.PENDING_DEPOSIT
-                : TransactionStatus.PENDING_WITHDRAWAL);
+                : TransactionStatus.PENDING_WITHDRAWAL, transactionExplorerLink);
             await waitForTransactionReceipt(config, { hash });
             return awaitTransactionIndexing(subgraphUrl, hash, `The ${action === 'deposit' ? 'deposit' : 'withdrawal'} was successful.`);
         }
@@ -276,7 +249,8 @@ const transactionStore = () => {
             return transactionError(TransactionErrorMessage.USER_REJECTED_TRANSACTION);
         }
         try {
-            awaitTx(hash, TransactionStatus.PENDING_REMOVE_ORDER);
+            const transactionExplorerLink = await getExplorerLink(hash, chainId, 'tx');
+            awaitTx(hash, TransactionStatus.PENDING_REMOVE_ORDER, transactionExplorerLink);
             await waitForTransactionReceipt(config, { hash });
             return awaitRemoveOrderIndexing(subgraphUrl, hash);
         }

package/dist/storesGeneric/cachedWritableStore.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Creates a writable Svelte store that persists its value to localStorage.
+ *
+ * @template T - The type of the value stored in the store
+ * @param {string} key - The localStorage key used to store the value
+ * @param {T} defaultValue - The default value to use when no value is found in localStorage
+ * @param {function(T): string} serialize - Function to convert the store value to a string for storage
+ * @param {function(string): T} deserialize - Function to convert the stored string back to the original type
+ * @returns {import('svelte/store').Writable<T>} A writable store that automatically syncs with localStorage
+ *
+ * @example
+ * // Create a store for a boolean value
+ * const darkMode = cachedWritableStore(
+ *   'darkMode',
+ *   false,
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ *
+ * // Create a store for a complex object
+ * const userPreferences = cachedWritableStore(
+ *   'userPrefs',
+ *   { theme: 'light', fontSize: 14 },
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ */
+export declare function cachedWritableStore<T>(key: string, defaultValue: T, serialize: (value: T) => string, deserialize: (serialized: string) => T): import("svelte/store").Writable<T>;
+export declare const cachedWritableString: (key: string, defaultValue?: string) => import("svelte/store").Writable<string>;
+export declare const cachedWritableInt: (key: string, defaultValue?: number) => import("svelte/store").Writable<number>;
+/**
+ * Creates a writable store that can hold an optional value of type T and persists to localStorage.
+ *
+ * @template T - The type of the value stored
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {T | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @param {function} serialize - Function to convert the value to a string for storage
+ * @param {function} deserialize - Function to convert the stored string back to a value
+ * @returns A writable store that persists to localStorage and can hold undefined values
+ */
+export declare const cachedWritableOptionalStore: <T>(key: string, defaultValue: T | undefined, serialize: (value: T) => string, deserialize: (serialized: string) => T) => import("svelte/store").Writable<T | undefined>;
+/**
+ * Creates a writable store that can hold an optional number value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {number | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional number
+ */
+export declare const cachedWritableIntOptional: (key: string, defaultValue?: undefined) => import("svelte/store").Writable<number | undefined>;
+/**
+ * Creates a writable store that can hold an optional string value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {string | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional string
+ */
+export declare const cachedWritableStringOptional: (key: string, defaultValue?: undefined) => import("svelte/store").Writable<string | undefined>;

package/dist/storesGeneric/cachedWritableStore.js

@@ -0,0 +1,93 @@
+import { writable } from 'svelte/store';
+/**
+ * Creates a writable Svelte store that persists its value to localStorage.
+ *
+ * @template T - The type of the value stored in the store
+ * @param {string} key - The localStorage key used to store the value
+ * @param {T} defaultValue - The default value to use when no value is found in localStorage
+ * @param {function(T): string} serialize - Function to convert the store value to a string for storage
+ * @param {function(string): T} deserialize - Function to convert the stored string back to the original type
+ * @returns {import('svelte/store').Writable<T>} A writable store that automatically syncs with localStorage
+ *
+ * @example
+ * // Create a store for a boolean value
+ * const darkMode = cachedWritableStore(
+ *   'darkMode',
+ *   false,
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ *
+ * // Create a store for a complex object
+ * const userPreferences = cachedWritableStore(
+ *   'userPrefs',
+ *   { theme: 'light', fontSize: 14 },
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ */
+export function cachedWritableStore(key, defaultValue, serialize, deserialize) {
+    const getCache = () => {
+        try {
+            const cached = localStorage.getItem(key);
+            return cached !== null ? deserialize(cached) : defaultValue;
+        }
+        catch {
+            return defaultValue;
+        }
+    };
+    const setCache = (value) => {
+        try {
+            if (value !== undefined) {
+                localStorage.setItem(key, serialize(value));
+            }
+            else {
+                localStorage.removeItem(key);
+            }
+        }
+        catch {
+            // Silently ignore localStorage errors to allow the application to function
+            // without persistence in environments where localStorage is unavailable
+        }
+    };
+    const data = writable(getCache());
+    data.subscribe((value) => {
+        setCache(value);
+    });
+    return data;
+}
+export const cachedWritableString = (key, defaultValue = '') => cachedWritableStore(key, defaultValue, (v) => v, (v) => v);
+export const cachedWritableInt = (key, defaultValue = 0) => cachedWritableStore(key, defaultValue, (v) => v.toString(), (v) => {
+    const parsed = Number.parseInt(v);
+    return isNaN(parsed) ? defaultValue : parsed;
+});
+/**
+ * Creates a writable store that can hold an optional value of type T and persists to localStorage.
+ *
+ * @template T - The type of the value stored
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {T | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @param {function} serialize - Function to convert the value to a string for storage
+ * @param {function} deserialize - Function to convert the stored string back to a value
+ * @returns A writable store that persists to localStorage and can hold undefined values
+ */
+export const cachedWritableOptionalStore = (key, defaultValue = undefined, serialize, deserialize) => cachedWritableStore(key, defaultValue, (v) => (v !== undefined ? serialize(v) : ''), (v) => (v !== '' ? deserialize(v) : undefined));
+/**
+ * Creates a writable store that can hold an optional number value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {number | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional number
+ */
+export const cachedWritableIntOptional = (key, defaultValue = undefined) => cachedWritableOptionalStore(key, defaultValue, (v) => v.toString(), (v) => {
+    const parsed = Number.parseInt(v);
+    return isNaN(parsed) ? (defaultValue ?? 0) : parsed;
+});
+/**
+ * Creates a writable store that can hold an optional string value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {string | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional string
+ */
+export const cachedWritableStringOptional = (key, defaultValue = undefined) => cachedWritableOptionalStore(key, defaultValue, (v) => v, (v) => v);

package/dist/types/account.d.ts

@@ -0,0 +1,3 @@
+import type { Readable } from 'svelte/store';
+import type { Hex } from 'viem';
+export type Account = Readable<Hex | null>;

package/dist/types/account.js

@@ -0,0 +1 @@
+export {};

package/dist/types/appStores.d.ts

@@ -1,11 +1,11 @@
 import type { Readable, Writable } from 'svelte/store';
-import type { ConfigSource, OrderbookConfigSource } from '@rainlanguage/orderbook/js_api';
+import type { ConfigSource, OrderbookConfigSource } from '@rainlanguage/orderbook';
 export interface AppStoresInterface {
     settings: Writable<ConfigSource | undefined>;
     activeSubgraphs: Writable<Record<string, string>>;
     accounts: Readable<Record<string, string>>;
     activeAccountsItems: Writable<Record<string, string>>;
-    activeOrderStatus: Writable<boolean | undefined>;
+    activeOrderStatus: Writable<boolean>;
     orderHash: Writable<string>;
     hideZeroBalanceVaults: Writable<boolean>;
     activeNetworkRef: Writable<string | undefined>;

package/dist/types/modal.d.ts

@@ -1,4 +1,4 @@
-import type { SgOrder } from '@rainlanguage/orderbook/js_api';
+import type { SgOrder } from '@rainlanguage/orderbook';
 import type { DepositOrWithdrawArgs, OrderRemoveArgs, DeploymentArgs } from './transaction';
 export type DepositOrWithdrawModalProps = {
     open: boolean;

package/dist/types/strategy.d.ts

@@ -1,4 +1,4 @@
-import type { NameAndDescriptionCfg } from '@rainlanguage/orderbook/js_api';
+import type { NameAndDescriptionCfg } from '@rainlanguage/orderbook';
 export type ValidStrategyDetail = {
     details: NameAndDescriptionCfg;
     name: string;

package/dist/types/transaction.d.ts

@@ -1,13 +1,12 @@
 import type { ExtendedApprovalCalldata } from '../stores/transactionStore';
-import type { DepositAndAddOrderCalldataResult } from '@rainlanguage/orderbook/js_api';
 import type { Hex } from 'viem';
-import type { SgOrder, SgVault } from '@rainlanguage/orderbook/js_api';
+import type { DepositAndAddOrderCalldataResult, SgOrder, SgVault } from '@rainlanguage/orderbook';
 export type DeploymentArgs = {
     approvals: ExtendedApprovalCalldata[];
     deploymentCalldata: DepositAndAddOrderCalldataResult;
     orderbookAddress: Hex;
     chainId: number;
-    subgraphUrl: string;
+    subgraphUrl?: string;
     network: string;
 };
 export type DepositOrWithdrawArgs = {
@@ -17,6 +16,7 @@ export type DepositOrWithdrawArgs = {
     chainId: number;
     rpcUrl: string;
     subgraphUrl: string;
+    account: Hex;
 };
 export type OrderRemoveArgs = {
     order: SgOrder;

package/dist/utils/constructHashLink.d.ts

@@ -0,0 +1,23 @@
+import type { SgOrder, SgOrderAsIO, SgVault } from '@rainlanguage/orderbook';
+type OrderOrVault = SgOrder | SgOrderAsIO | SgVault;
+/**
+ * Constructs a link path for an order or vault based on its type and network
+ * @param orderOrVault - The order or vault object
+ * @param type - The type of resource ('orders' or 'vaults')
+ * @param network - The network name
+ * @returns The constructed link path
+ */
+export declare function constructHashLink(orderOrVault: OrderOrVault, type: 'orders' | 'vaults', network: string): string;
+/**
+ * Determines if an order or vault is active
+ * @param orderOrVault - The order or vault object
+ * @returns True if the order is active, false otherwise
+ */
+export declare function isOrderOrVaultActive(orderOrVault: OrderOrVault): boolean;
+/**
+ * Extracts the hash value from an order or vault
+ * @param orderOrVault - The order or vault object
+ * @returns The hash value
+ */
+export declare function extractHash(orderOrVault: OrderOrVault): string;
+export {};