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

package/dist/providers/toasts/context.d.ts

@@ -0,0 +1,14 @@
+import { type Writable } from 'svelte/store';
+import type { ToastProps } from '../../types/toast';
+export declare const TOASTS_KEY = "rain:ui-components:toasts";
+/**
+ * Retrieves the toasts store from Svelte's context
+ */
+export declare function getToastsContext(): Writable<ToastProps[]>;
+/**
+ * Sets the toasts store in Svelte's context
+ *
+ * @param {Writable<ToastProps[]>} toasts - The writable store containing all active toast notifications
+ * @returns {void}
+ */
+export declare function setToastsContext(toasts: Writable<ToastProps[]>): void;

package/dist/providers/toasts/context.js

@@ -0,0 +1,22 @@
+import { getContext, setContext } from 'svelte';
+import {} from 'svelte/store';
+export const TOASTS_KEY = 'rain:ui-components:toasts';
+/**
+ * Retrieves the toasts store from Svelte's context
+ */
+export function getToastsContext() {
+    const toasts = getContext(TOASTS_KEY);
+    if (!toasts) {
+        throw new Error('No toasts context found. Did you forget to wrap your component with ToastProvider?');
+    }
+    return toasts;
+}
+/**
+ * Sets the toasts store in Svelte's context
+ *
+ * @param {Writable<ToastProps[]>} toasts - The writable store containing all active toast notifications
+ * @returns {void}
+ */
+export function setToastsContext(toasts) {
+    setContext(TOASTS_KEY, toasts);
+}

package/dist/providers/toasts/useToasts.d.ts

@@ -0,0 +1,16 @@
+import type { ToastProps } from '../../types/toast';
+/**
+ * Hook for managing toast notifications in the application.
+ * Provides functionality to add, remove, and access toast notifications.
+ *
+ * @returns {Object} An object containing:
+ *   - toasts: Writable store containing all active toast notifications
+ *   - addToast: Function to add a new toast notification
+ *   - removeToast: Function to remove a toast notification by index
+ */
+export declare function useToasts(): {
+    toasts: import("svelte/store").Writable<ToastProps[]>;
+    addToast: (toast: ToastProps) => void;
+    removeToast: (index: number) => void;
+    errToast: (message: string, detail?: string) => void;
+};

package/dist/providers/toasts/useToasts.js

@@ -0,0 +1,63 @@
+import { getToastsContext } from './context';
+/**
+ * Hook for managing toast notifications in the application.
+ * Provides functionality to add, remove, and access toast notifications.
+ *
+ * @returns {Object} An object containing:
+ *   - toasts: Writable store containing all active toast notifications
+ *   - addToast: Function to add a new toast notification
+ *   - removeToast: Function to remove a toast notification by index
+ */
+export function useToasts() {
+    const toasts = getToastsContext();
+    /**
+     * Removes a toast notification by its index from the toasts store
+     *
+     * @param {number} index - The index of the toast to remove
+     * @returns {void}
+     */
+    const removeToast = (index) => {
+        toasts.update((toasts) => {
+            if (index < 0 || index >= toasts.length) {
+                return toasts;
+            }
+            return toasts.filter((_, i) => i !== index);
+        });
+    };
+    /**
+     * Adds a new toast notification to the toasts store
+     *
+     * @param {ToastProps} toast - The toast configuration object containing:
+     *   - message: The text to display in the toast
+     *   - type: The type of toast (success, error, warning, info)
+     *   - color: The color theme of the toast (green, red, yellow, blue)
+     *   - links: Optional array of links to display in the toast
+     * @returns {void}
+     */
+    const addToast = (toast) => {
+        toasts.update((toasts) => {
+            const updatedToasts = [...toasts, toast];
+            return updatedToasts;
+        });
+    };
+    /**
+     * Adds a standardized error toast notification
+     *
+     * @param message - The error message to display
+     * @param detail - The detail of the error
+     */
+    const errToast = (message, detail) => {
+        addToast({
+            message,
+            detail,
+            type: 'error',
+            color: 'red'
+        });
+    };
+    return {
+        toasts,
+        addToast,
+        removeToast,
+        errToast
+    };
+}

package/dist/providers/transactions/TransactionManager.d.ts

@@ -0,0 +1,235 @@
+import { type Readable } from 'svelte/store';
+import type { QueryClient } from '@tanstack/svelte-query';
+import { type Transaction } from '../../models/Transaction';
+import type { InternalTransactionArgs, IndexingContext } from '../../types/transaction';
+import type { Config } from '@wagmi/core';
+import type { ToastLink, ToastProps } from '../../types/toast';
+import { type RaindexVault, type RaindexOrder, RaindexClient, type Address, Float, type WasmEncodedResult } from '@rainlanguage/orderbook';
+/**
+ * Function type for adding toast notifications to the UI.
+ * @param toast - The toast notification configuration object.
+ * @param toast.message - The message text to display in the toast.
+ * @param toast.type - The type of toast notification ('success', 'error', or 'info').
+ * @param toast.color - The color theme of the toast.
+ * @param toast.links - Optional array of links to display in the toast.
+ */
+export type AddToastFunction = (toast: Omit<ToastProps, 'id'>) => void;
+/**
+ * Creates an indexing function that wraps SDK-based polling logic.
+ * The SDK handles local-DB-first polling followed by subgraph fallback internally,
+ * so we only need to call it once.
+ *
+ * @param options Configuration for SDK-based indexing
+ * @param options.call Function that calls the SDK method (e.g. getAddOrdersForTransaction)
+ * @param options.isSuccess Function to determine if the result indicates success
+ * @param options.buildLinks Optional function to generate toast links from the result
+ * @returns An indexing function compatible with TransactionStore
+ */
+export declare function createSdkIndexingFn<T>(options: {
+    call: () => Promise<WasmEncodedResult<T>>;
+    isSuccess: (value: T) => boolean;
+    buildLinks?: (value: T) => ToastLink[];
+}): (ctx: IndexingContext) => Promise<void>;
+/**
+ * Manages blockchain transactions with toast notifications and query invalidation.
+ * Handles transaction lifecycle, status updates, and UI feedback.
+ * Provides functionality for creating, tracking, and managing blockchain transactions.
+ */
+export declare class TransactionManager {
+    /** Writable store tracking all active transactions. */
+    private transactions;
+    /** Query client for cache invalidation after successful transactions. */
+    private queryClient;
+    /** Function to display toast notifications in the UI. */
+    private addToast;
+    /** Wagmi configuration for blockchain interactions. */
+    private wagmiConfig;
+    /**
+     * Initializes a new TransactionManager instance.
+     * @param queryClient - Query client for cache invalidation.
+     * @param addToast - Function to display toast notifications.
+     * @param wagmiConfig - Wagmi configuration for blockchain interactions.
+     */
+    constructor(queryClient: QueryClient, addToast: AddToastFunction, wagmiConfig: Config);
+    /**
+     * Creates and initializes a new transaction for removing an order from the orderbook.
+     * @param args - Configuration for the remove order transaction.
+     * @param args.txHash - Hash of the transaction to track.
+     * @param args.chainId - Chain ID where the transaction is being executed.
+     * @param args.queryKey - The hash of the order to be removed (used for query invalidation and UI links).
+     * @param args.entity - The `SgOrder` entity associated with this transaction.
+     * @returns A new Transaction instance configured for order removal.
+     * @example
+     * const tx = await manager.createRemoveOrderTransaction({
+     *   txHash: '0x123...',
+     *   chainId: 1,
+     *   queryKey: '0x456...', // Order hash
+     *   entity: sgOrderInstance
+     * });
+     */
+    createRemoveOrderTransaction(args: InternalTransactionArgs & {
+        entity: RaindexOrder;
+        raindexClient: RaindexClient;
+    }): Promise<Transaction>;
+    /**
+     * Creates and initializes a new transaction for withdrawing funds from a vault.
+     * @param args - Configuration for the withdrawal transaction.
+     * @param args.txHash - Hash of the transaction to track.
+     * @param args.chainId - Chain ID where the transaction is being executed.
+     * @param args.queryKey - The ID of the vault from which funds are withdrawn (used for query invalidation and UI links).
+     * @param args.entity - The `SgVault` entity associated with this transaction.
+     * @returns A new Transaction instance configured for withdrawal.
+     * @example
+     * const tx = await manager.createWithdrawTransaction({
+     *   txHash: '0x123...',
+     *   chainId: 1,
+     *   queryKey: '0x789...', // Vault ID
+     *   entity: sgVaultInstance
+     * });
+     */
+    createWithdrawTransaction(args: InternalTransactionArgs & {
+        entity: RaindexVault;
+        raindexClient: RaindexClient;
+    }): Promise<Transaction>;
+    /**
+     * Creates a multicall withdrawal transaction.
+     *
+     * Precondition: all provided vaults must share the same Raindex orderbook.
+     * This is enforced upstream in handleVaultsWithdrawAll.ts:
+     *   if (vaults.some(v => v.orderbook !== vaults[0].orderbook)) { … }
+     *
+     * @param args.chainId the target chain ID
+     * @param args.vaults list of RaindexVault instances (must share an orderbook)
+     * @param args.txHash the transaction hash to wrap
+     * @param args.queryKey cache key for invalidation
+     * @param args.raindexClient Raindex API client	 * @example
+     * const tx = await manager.createVaultsWithdrawAllTransaction({
+     *   txHash: '0x123...',
+     *   chainId: 1,
+     *   queryKey: 'QKEY_VAULTS',
+     *   vaults: [vault1, vault2, vault3],
+     *   raindexClient: clientInstance
+     * });
+     */
+    createVaultsWithdrawAllTransaction(args: InternalTransactionArgs & {
+        vaults: RaindexVault[];
+        raindexClient: RaindexClient;
+    }): Promise<Transaction>;
+    /**
+     * Creates and initializes a new transaction for approving token spend.
+     * @param args - Configuration for the approval transaction.
+     * @param args.txHash - Hash of the transaction to track.
+     * @param args.chainId - Chain ID where the transaction is being executed.
+     * @param args.queryKey - The ID of the vault or context for which approval is made (used for query invalidation and UI links).
+     * @param args.tokenSymbol - The symbol of the token being approved.
+     * @param args.entity - The `SgVault` entity associated with this transaction. (Optional, used for approvals to pre-existing vaults).
+     * @returns A new Transaction instance configured for token approval.
+     * @example
+     * const tx = await manager.createApprovalTransaction({
+     *   txHash: '0xabc...',
+     *   chainId: 1,
+     *   queryKey: '0x789...', // Vault ID
+     *   entity: sgVaultInstance
+     * });
+     */
+    createApprovalTransaction(args: InternalTransactionArgs & {
+        entity?: RaindexVault;
+    }): Promise<Transaction>;
+    /**
+     * Creates and initializes a new transaction for publishing metadata to the metaboard.
+     * @param args - Configuration for the metadata transaction.
+     * @param args.txHash - Hash of the metadata transaction.
+     * @param args.chainId - Chain ID where the transaction is executed.
+     * @param args.queryKey - Identifier used for query invalidation, typically the order hash.
+     */
+    createMetaTransaction(args: InternalTransactionArgs): Promise<Transaction>;
+    /**
+     * Creates and initializes a new transaction for depositing funds into a vault.
+     * @param args - Configuration for the deposit transaction.
+     * @param args.txHash - Hash of the transaction to track.
+     * @param args.chainId - Chain ID where the transaction is being executed.
+     * @param args.queryKey - The ID of the vault into which funds are deposited (used for query invalidation and UI links).
+     * @param args.entity - The `SgVault` entity associated with this transaction.
+     * @param args.amount - The amount of tokens being deposited.
+     * @returns A new Transaction instance configured for deposit.
+     * @example
+     * const tx = await manager.createDepositTransaction({
+     *   txHash: '0xdef...',
+     *   chainId: 1,
+     *   queryKey: '0x789...', // Vault ID
+     *   entity: sgVaultInstance,
+     *   amount: 1000n
+     * });
+     */
+    createDepositTransaction(args: InternalTransactionArgs & {
+        amount: Float;
+        entity: RaindexVault;
+        raindexClient: RaindexClient;
+    }): Promise<Transaction>;
+    /**
+     * Creates and initializes a new transaction for deploying an order.
+     * @param args - Configuration for the deployment transaction.
+     * @param args.txHash - Hash of the transaction to track.
+     * @param args.chainId - Chain ID where the transaction is being executed.
+     * @param args.queryKey - The ID of the vault into which funds are deposited (used for query invalidation and UI links).
+     * @returns A new Transaction instance configured for deposit.
+     * @example
+     * const tx = await manager.createAddOrderTransaction({
+     *   txHash: '0xdeploytxhash',
+     *   chainId: 1,
+     *   queryKey: '0x789...', // Vault ID
+     * });
+     */
+    createAddOrderTransaction(args: InternalTransactionArgs & {
+        orderbook: Address;
+        raindexClient: RaindexClient;
+    }): Promise<Transaction>;
+    /**
+     * Creates and initializes a new transaction for taking orders.
+     * @param args - Configuration for the take order transaction.
+     * @param args.txHash - Hash of the transaction to track.
+     * @param args.chainId - Chain ID where the transaction is being executed.
+     * @param args.queryKey - The hash of the order being taken (used for query invalidation).
+     * @param args.entity - The `RaindexOrder` entity associated with this transaction.
+     * @returns A new Transaction instance configured for taking orders.
+     * @example
+     * const tx = await manager.createTakeOrderTransaction({
+     *   txHash: '0x123...',
+     *   chainId: 1,
+     *   queryKey: '0x456...', // Order hash
+     *   entity: raindexOrderInstance,
+     *   raindexClient: clientInstance
+     * });
+     */
+    createTakeOrderTransaction(args: InternalTransactionArgs & {
+        entity: RaindexOrder;
+        raindexClient: RaindexClient;
+    }): Promise<Transaction>;
+    /**
+     * Creates, initializes, and executes a new transaction instance.
+     * @param args - Configuration for the transaction.
+     * @param args.name - Name or title of the transaction.
+     * @param args.errorMessage - Message to display on transaction failure.
+     * @param args.successMessage - Message to display on transaction success.
+     * @param args.queryKey - Key used for query invalidation.
+     * @param args.toastLinks - Array of links to display in toast notifications.
+     * @param args.awaitIndexingFn - Optional function to await transaction indexing.
+     * @returns A new Transaction instance that has been initialized and started.
+     * @private
+     */
+    private createTransaction;
+    /**
+     * Retrieves the store containing all active transactions.
+     * @returns A readable store containing all active Transaction instances.
+     * @example
+     * const transactionsStore = manager.getTransactions();
+     * transactionsStore.subscribe(transactions => console.log(transactions));
+     */
+    getTransactions(): Readable<Transaction[]>;
+    /**
+     * Removes all transactions from the store, resetting the transaction tracking state.
+     * @example
+     * manager.clearTransactions(); // Clear all tracked transactions
+     */
+    clearTransactions(): void;
+}