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

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

@@ -1,19 +1,14 @@
 import type { Readable, Writable } from 'svelte/store';
-import type { ConfigSource, OrderbookConfigSource } from '@rainlanguage/orderbook/js_api';
+import type { AccountCfg, Address, Hex } 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>;
-    orderHash: Writable<string>;
+    selectedChainIds: Writable<number[]>;
+    accounts: Readable<Record<string, AccountCfg>>;
+    activeAccountsItems: Writable<Record<string, Address>> | undefined;
+    showInactiveOrders: Writable<boolean>;
+    orderHash: Writable<Hex>;
     hideZeroBalanceVaults: Writable<boolean>;
-    activeNetworkRef: Writable<string | undefined>;
-    activeOrderbookRef: Writable<string | undefined>;
-    activeOrderbook: Readable<OrderbookConfigSource | undefined>;
-    subgraphUrl: Readable<string | undefined>;
-    activeAccounts: Readable<{
-        [k: string]: string;
-    }>;
+    hideInactiveOrdersVaults: Writable<boolean>;
+    activeTokens: Writable<Address[]>;
     showMyItemsOnly: Writable<boolean>;
+    activeOrderbookAddresses: Writable<Address[]>;
 }

package/dist/types/modal.d.ts

@@ -1,20 +1,32 @@
-import type { SgOrder } from '@rainlanguage/orderbook/js_api';
-import type { DepositOrWithdrawArgs, OrderRemoveArgs, DeploymentArgs } from './transaction';
-export type DepositOrWithdrawModalProps = {
+import type { Float, RaindexOrder, RaindexVault } from '@rainlanguage/orderbook';
+import type { VaultActionArgs } from './transaction';
+import type { Hex } from 'viem';
+export type VaultActionModalProps = {
     open: boolean;
-    args: DepositOrWithdrawArgs;
-};
-export type OrderRemoveModalProps = {
-    open: boolean;
-    args: OrderRemoveArgs;
-};
-export type DeployModalProps = {
-    open: boolean;
-    args: DeploymentArgs;
+    args: VaultActionArgs;
+    onSubmit: (amount: Float) => void;
 };
 export type DisclaimerModalProps = {
     open: boolean;
     onAccept: () => void;
 };
-export type QuoteDebugModalHandler = (order: SgOrder, rpcUrl: string, orderbook: string, inputIOIndex: number, outputIOIndex: number, pair: string, blockNumber?: number) => void;
-export type DebugTradeModalHandler = (hash: string, rpcUrl: string) => void;
+export type TransactionConfirmationProps = {
+    open: boolean;
+    modalTitle: string;
+    closeOnConfirm?: boolean;
+    args: {
+        chainId: number;
+        toAddress: Hex;
+        onConfirm: (hash: Hex) => void;
+        entity?: RaindexOrder | RaindexVault;
+        calldata: string;
+    };
+};
+export type QuoteDebugModalHandler = (order: RaindexOrder, inputIOIndex: number, outputIOIndex: number, pair: string, blockNumber?: bigint) => void;
+export type DebugTradeModalHandler = (hash: string, rpcUrls: string[]) => void;
+export type HandleTransactionConfirmationModal = (props: TransactionConfirmationProps, options?: {
+    timeout?: number;
+}) => Promise<{
+    success: boolean;
+    hash?: string;
+}>;

package/dist/types/{strategy.d.ts → order.d.ts}

@@ -1,10 +1,10 @@
-import type { NameAndDescriptionCfg } from '@rainlanguage/orderbook/js_api';
-export type ValidStrategyDetail = {
+import type { NameAndDescriptionCfg } from '@rainlanguage/orderbook';
+export type ValidOrderDetail = {
     details: NameAndDescriptionCfg;
     name: string;
     dotrain: string;
 };
-export type InvalidStrategyDetail = {
+export type InvalidOrderDetail = {
     name: string;
     error: string;
 };

package/dist/types/order.js

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

package/dist/types/toast.d.ts

@@ -0,0 +1,11 @@
+export interface ToastProps {
+    message: string;
+    detail?: string;
+    type: 'success' | 'error' | 'warning' | 'info';
+    color: 'green' | 'red' | 'yellow' | 'blue';
+    links?: ToastLink[];
+}
+export type ToastLink = {
+    link: string;
+    label: string;
+};

package/dist/types/toast.js

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

package/dist/types/tokenBalance.d.ts

@@ -0,0 +1,6 @@
+import type { AccountBalance } from '@rainlanguage/orderbook';
+export interface TokenBalance {
+    value: AccountBalance;
+    loading: boolean;
+    error: string;
+}

package/dist/types/tokenBalance.js

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

package/dist/types/transaction.d.ts

@@ -1,26 +1,71 @@
-import type { ExtendedApprovalCalldata } from '../stores/transactionStore';
 import type { Hex } from 'viem';
-import type { DepositAndAddOrderCalldataResult, SgOrder, SgVault } from '@rainlanguage/orderbook/js_api';
-export type DeploymentArgs = {
-    approvals: ExtendedApprovalCalldata[];
-    deploymentCalldata: DepositAndAddOrderCalldataResult;
-    orderbookAddress: Hex;
-    chainId: number;
-    subgraphUrl: string;
-    network: string;
+import type { RaindexVault } from '@rainlanguage/orderbook';
+import type { ToastLink } from './toast';
+import type { TransactionStoreState } from '../models/Transaction';
+/**
+ * Context provided to the indexing function, allowing it to update
+ * transaction state and trigger callbacks without TransactionStore
+ * knowing the specifics of what's being indexed.
+ */
+export type IndexingContext = {
+    /** Update the transaction state (status, errorDetails, links) */
+    updateState: (partialState: Partial<TransactionStoreState>) => void;
+    /** Callback to invoke on successful indexing */
+    onSuccess: () => void;
+    /** Callback to invoke on indexing failure */
+    onError: () => void;
+    /** Current toast links (useful for prepending new links) */
+    links: ToastLink[];
 };
-export type DepositOrWithdrawArgs = {
-    vault: SgVault;
-    onDepositOrWithdraw: () => void;
-    action: 'deposit' | 'withdraw';
-    chainId: number;
-    rpcUrl: string;
-    subgraphUrl: string;
+/**
+ * Generic indexing function type. TransactionStore calls this function
+ * after the transaction receipt is confirmed, without knowing what
+ * type of indexing is being performed (SDK-based, subgraph, etc.).
+ */
+export type AwaitIndexingFn = (ctx: IndexingContext) => Promise<void>;
+export type VaultActionArgs = {
+    vault: RaindexVault;
+    onDeposit?: () => void;
+    account: Hex;
 };
-export type OrderRemoveArgs = {
-    order: SgOrder;
-    onRemove: () => void;
+export declare enum TransactionName {
+    REMOVAL = "Order Removal",
+    WITHDRAWAL = "Vault Withdrawal",
+    WITHDRAWAL_MULTIPLE = "Vaults Withdrawal",
+    APPROVAL = "Token Approval",
+    DEPOSIT = "Vault Deposit",
+    TAKE_ORDER = "Take Order"
+}
+export declare enum TransactionStatusMessage {
+    IDLE = "Idle",
+    STARTING = "Starting transaction...",
+    CHECKING_ALLOWANCE = "Checking your allowance...",
+    PENDING_WALLET = "Waiting for wallet confirmation...",
+    PENDING_APPROVAL = "Approving token spend...",
+    PENDING_RECEIPT = "Waiting for transaction receipt...",
+    PENDING_DEPLOYMENT = "Deploying your order...",
+    PENDING_WITHDRAWAL = "Withdrawing tokens...",
+    PENDING_DEPOSIT = "Depositing tokens...",
+    PENDING_SUBGRAPH = "Awaiting transaction indexing...",
+    SUCCESS = "Transaction confirmed",
+    ERROR = "Something went wrong"
+}
+export declare enum TransactionStoreErrorMessage {
+    SWITCH_CHAIN_FAILED = "Failed to switch chain.",
+    SUBGRAPH_TIMEOUT_ERROR = "The subgraph took too long to respond. Your transaction may still be processing.",
+    SUBGRAPH_FAILED = "Failed to index transaction.",
+    RECEIPT_FAILED = "Failed to get transaction receipt."
+}
+export type InternalTransactionArgs = {
     chainId: number;
-    orderbookAddress: Hex;
-    subgraphUrl: string;
+    txHash: Hex;
+    queryKey: string;
+};
+export type TransactionArgs = InternalTransactionArgs & {
+    name: string;
+    errorMessage: string;
+    successMessage: string;
+    queryKey: string;
+    toastLinks: ToastLink[];
+    awaitIndexingFn?: AwaitIndexingFn;
 };

package/dist/types/transaction.js

@@ -1 +1,31 @@
-export {};
+export var TransactionName;
+(function (TransactionName) {
+    TransactionName["REMOVAL"] = "Order Removal";
+    TransactionName["WITHDRAWAL"] = "Vault Withdrawal";
+    TransactionName["WITHDRAWAL_MULTIPLE"] = "Vaults Withdrawal";
+    TransactionName["APPROVAL"] = "Token Approval";
+    TransactionName["DEPOSIT"] = "Vault Deposit";
+    TransactionName["TAKE_ORDER"] = "Take Order";
+})(TransactionName || (TransactionName = {}));
+export var TransactionStatusMessage;
+(function (TransactionStatusMessage) {
+    TransactionStatusMessage["IDLE"] = "Idle";
+    TransactionStatusMessage["STARTING"] = "Starting transaction...";
+    TransactionStatusMessage["CHECKING_ALLOWANCE"] = "Checking your allowance...";
+    TransactionStatusMessage["PENDING_WALLET"] = "Waiting for wallet confirmation...";
+    TransactionStatusMessage["PENDING_APPROVAL"] = "Approving token spend...";
+    TransactionStatusMessage["PENDING_RECEIPT"] = "Waiting for transaction receipt...";
+    TransactionStatusMessage["PENDING_DEPLOYMENT"] = "Deploying your order...";
+    TransactionStatusMessage["PENDING_WITHDRAWAL"] = "Withdrawing tokens...";
+    TransactionStatusMessage["PENDING_DEPOSIT"] = "Depositing tokens...";
+    TransactionStatusMessage["PENDING_SUBGRAPH"] = "Awaiting transaction indexing...";
+    TransactionStatusMessage["SUCCESS"] = "Transaction confirmed";
+    TransactionStatusMessage["ERROR"] = "Something went wrong";
+})(TransactionStatusMessage || (TransactionStatusMessage = {}));
+export var TransactionStoreErrorMessage;
+(function (TransactionStoreErrorMessage) {
+    TransactionStoreErrorMessage["SWITCH_CHAIN_FAILED"] = "Failed to switch chain.";
+    TransactionStoreErrorMessage["SUBGRAPH_TIMEOUT_ERROR"] = "The subgraph took too long to respond. Your transaction may still be processing.";
+    TransactionStoreErrorMessage["SUBGRAPH_FAILED"] = "Failed to index transaction.";
+    TransactionStoreErrorMessage["RECEIPT_FAILED"] = "Failed to get transaction receipt.";
+})(TransactionStoreErrorMessage || (TransactionStoreErrorMessage = {}));

package/dist/utils/configHelpers.d.ts

@@ -0,0 +1,4 @@
+import type { AccountCfg } from '@rainlanguage/orderbook';
+export declare function getAccountsAsOptions(accounts?: Map<string, AccountCfg>): {
+    [k: string]: string;
+};

package/dist/utils/configHelpers.js

@@ -0,0 +1,21 @@
+export function getAccountsAsOptions(accounts) {
+    if (!accounts)
+        return {};
+    return Object.fromEntries(Array.from(accounts.entries()).map(([key, value]) => [key, value.address]));
+}
+if (import.meta.vitest) {
+    const { expect, it, describe } = import.meta.vitest;
+    describe('getAccountsAsOptions', () => {
+        it('should return the correct accounts as options', () => {
+            const accounts = new Map([
+                ['account1', { address: '0x1234567890abcdef', key: 'account1' }],
+                ['account2', { address: '0xabcdef1234567890', key: 'account2' }]
+            ]);
+            const result = getAccountsAsOptions(accounts);
+            expect(result).toEqual({
+                account1: '0x1234567890abcdef',
+                account2: '0xabcdef1234567890'
+            });
+        });
+    });
+}

package/dist/utils/constructHashLink.d.ts

@@ -0,0 +1,24 @@
+import type { Address, RaindexOrder, RaindexOrderAsIO, RaindexVault } from '@rainlanguage/orderbook';
+type OrderOrVault = RaindexOrder | RaindexOrderAsIO | RaindexVault;
+/**
+ * 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 chainId - The chain id
+ * @param orderbookAddress - The orderbook address
+ * @returns The constructed link path
+ */
+export declare function constructHashLink(orderOrVault: OrderOrVault, type: 'orders' | 'vaults', chainId: number, orderbookAddress: Address): 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 {};

package/dist/utils/constructHashLink.js

@@ -0,0 +1,115 @@
+import fc from 'fast-check';
+import { test } from '@fast-check/vitest';
+function isOrder(obj) {
+    return obj && 'orderHash' in obj;
+}
+/**
+ * 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 chainId - The chain id
+ * @param orderbookAddress - The orderbook address
+ * @returns The constructed link path
+ */
+export function constructHashLink(orderOrVault, type, chainId, orderbookAddress) {
+    if (!orderOrVault) {
+        return `/${type}`;
+    }
+    const slug = isOrder(orderOrVault) ? orderOrVault.orderHash : orderOrVault.id;
+    return `/${type}/${chainId}-${orderbookAddress}-${slug}`;
+}
+/**
+ * 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 function isOrderOrVaultActive(orderOrVault) {
+    const _isOrder = isOrder(orderOrVault);
+    return _isOrder ? orderOrVault.active : false;
+}
+/**
+ * Extracts the hash value from an order or vault
+ * @param orderOrVault - The order or vault object
+ * @returns The hash value
+ */
+export function extractHash(orderOrVault) {
+    const _isOrder = isOrder(orderOrVault);
+    return _isOrder
+        ? orderOrVault.orderHash
+        : orderOrVault?.id || '';
+}
+if (import.meta.vitest) {
+    const { expect, it, describe } = import.meta.vitest;
+    describe('constructHashLink', () => {
+        test.prop([
+            fc.record({
+                orderHash: fc.string(),
+                active: fc.boolean()
+            }),
+            fc.oneof(fc.constant('orders'), fc.constant('vaults')),
+            fc.integer(),
+            fc.string()
+        ])('constructs correct link for orders', (order, type, chainId, orderbookAddress) => {
+            const result = constructHashLink(order, type, chainId, orderbookAddress);
+            expect(result).toBe(`/${type}/${chainId}-${orderbookAddress}-${order.orderHash}`);
+        });
+        test.prop([
+            fc.record({
+                id: fc.string(),
+                owner: fc.string()
+            }),
+            fc.oneof(fc.constant('orders'), fc.constant('vaults')),
+            fc.integer(),
+            fc.string()
+        ])('constructs correct link for vaults', (vault, type, chainId, orderbookAddress) => {
+            const result = constructHashLink(vault, type, chainId, orderbookAddress);
+            expect(result).toBe(`/${type}/${chainId}-${orderbookAddress}-${vault.id}`);
+        });
+    });
+    describe('isOrderOrVaultActive', () => {
+        test.prop([
+            fc.record({
+                orderHash: fc.string(),
+                active: fc.boolean()
+            })
+        ])('returns correct active status for orders', (order) => {
+            const result = isOrderOrVaultActive(order);
+            expect(result).toBe(order.active);
+        });
+        test.prop([
+            fc.record({
+                id: fc.string(),
+                owner: fc.string()
+            })
+        ])('returns false for vaults', (vault) => {
+            const result = isOrderOrVaultActive(vault);
+            expect(result).toBe(false);
+        });
+    });
+    describe('extractHash', () => {
+        test.prop([
+            fc.record({
+                orderHash: fc.string(),
+                active: fc.boolean()
+            })
+        ])('extracts hash from orders', (order) => {
+            const result = extractHash(order);
+            expect(result).toBe(order.orderHash);
+        });
+        test.prop([
+            fc.record({
+                id: fc.string(),
+                owner: fc.string()
+            })
+        ])('extracts hash from vaults', (vault) => {
+            const result = extractHash(vault);
+            expect(result).toBe(vault.id);
+        });
+        it('handles undefined vault id', () => {
+            // Create a partial vault object with undefined id
+            const vault = { id: undefined };
+            const result = extractHash(vault);
+            expect(result).toBe('');
+        });
+    });
+}

package/dist/utils/getNetworkName.d.ts

@@ -0,0 +1 @@
+export declare function getNetworkName(chainId: number): string | undefined;

package/dist/utils/getNetworkName.js

@@ -0,0 +1,13 @@
+import * as chains from 'viem/chains';
+export function getNetworkName(chainId) {
+    const chain = Object.values(chains).find((chain) => chain.id === chainId);
+    return chain?.name;
+}
+if (import.meta.vitest) {
+    describe('getNetworkName', () => {
+        it('should return the network name for a given chain id', () => {
+            expect(getNetworkName(1)).toBe('Ethereum');
+            expect(getNetworkName(137)).toBe('Polygon');
+        });
+    });
+}

package/dist/utils/number.d.ts

@@ -5,10 +5,3 @@
  * @param decimalPoint - (optional) The number of digits to keep after "." in final result, defaults to valueDecimals
  */
 export declare function bigintStringToPercentage(value: string, valueDecimals: number, finalDecimalsDigits?: number): string;
-/**
- * Converts a bigint value to a floating point number with the specified number of decimals
- * @param value - The bigint value to convert
- * @param decimals - The number of decimal places to use in the conversion
- * @returns The converted floating point number
- */
-export declare function bigintToFloat(value: bigint, decimals: number): number;

package/dist/utils/number.js

@@ -14,30 +14,3 @@ export function bigintStringToPercentage(value, valueDecimals, finalDecimalsDigi
     }
     return valueString;
 }
-/**
- * Converts a bigint value to a floating point number with the specified number of decimals
- * @param value - The bigint value to convert
- * @param decimals - The number of decimal places to use in the conversion
- * @returns The converted floating point number
- */
-export function bigintToFloat(value, decimals) {
-    return parseFloat(formatUnits(value, decimals));
-}
-if (import.meta.vitest) {
-    const { it, expect } = import.meta.vitest;
-    it('should get percentage string from bigint string', () => {
-        const value = '123456000000000000';
-        const decimals = 18;
-        const finalDecimalsDigits = 4;
-        const result = bigintStringToPercentage(value, decimals, finalDecimalsDigits);
-        const expected = '12.3456';
-        expect(result).toEqual(expected);
-    });
-    it('should convert bigint to float', () => {
-        const value = 123456000000000000n;
-        const decimals = 18;
-        const result = bigintToFloat(value, decimals);
-        const expected = 0.123456;
-        expect(result).toEqual(expected);
-    });
-}

package/dist/utils/tokens.d.ts

@@ -0,0 +1,2 @@
+import type { RaindexVaultToken } from '@rainlanguage/orderbook';
+export declare function getTokenDisplayName(token: RaindexVaultToken): string;

package/dist/utils/tokens.js

@@ -0,0 +1,3 @@
+export function getTokenDisplayName(token) {
+    return token.symbol || token.name || 'Unknown Token';
+}

package/dist/utils/vaultBalanceChangeLabels.d.ts

@@ -0,0 +1,4 @@
+import type { RaindexVaultBalanceChangeType, VaultBalanceChangeFilter } from '@rainlanguage/orderbook';
+export declare const VAULT_BALANCE_CHANGE_LABELS: Record<RaindexVaultBalanceChangeType, string>;
+export declare const VAULT_BALANCE_CHANGE_FILTER_LABELS: Record<VaultBalanceChangeFilter, string>;
+export declare function labelForVaultBalanceChangeType(type: RaindexVaultBalanceChangeType): string;