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

package/dist/providers/transactions/TransactionManager.js

@@ -0,0 +1,509 @@
+import { writable } from 'svelte/store';
+import { TransactionStore } from '../../models/Transaction';
+import { TransactionName, TransactionStatusMessage, TransactionStoreErrorMessage } from '../../types/transaction';
+import { getExplorerLink } from '../../services/getExplorerLink';
+import { RaindexClient, Float } from '@rainlanguage/orderbook';
+/**
+ * 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 function createSdkIndexingFn(options) {
+    return async (ctx) => {
+        ctx.updateState({ status: TransactionStatusMessage.PENDING_SUBGRAPH });
+        try {
+            const result = await options.call();
+            if (result.error) {
+                const errorMsg = result.error.readableMsg?.toLowerCase() ?? '';
+                if (errorMsg.includes('timeout')) {
+                    ctx.updateState({
+                        status: TransactionStatusMessage.ERROR,
+                        errorDetails: TransactionStoreErrorMessage.SUBGRAPH_TIMEOUT_ERROR
+                    });
+                }
+                else {
+                    ctx.updateState({
+                        status: TransactionStatusMessage.ERROR,
+                        errorDetails: TransactionStoreErrorMessage.SUBGRAPH_FAILED
+                    });
+                }
+                return ctx.onError();
+            }
+            const value = result.value;
+            if (value && options.isSuccess(value)) {
+                const extraLinks = options.buildLinks?.(value) ?? [];
+                if (extraLinks.length > 0) {
+                    ctx.updateState({ links: [...extraLinks, ...ctx.links] });
+                }
+                ctx.updateState({ status: TransactionStatusMessage.SUCCESS });
+                return ctx.onSuccess();
+            }
+            // No valid data after polling
+            ctx.updateState({
+                status: TransactionStatusMessage.ERROR,
+                errorDetails: TransactionStoreErrorMessage.SUBGRAPH_FAILED
+            });
+            return ctx.onError();
+        }
+        catch {
+            ctx.updateState({
+                status: TransactionStatusMessage.ERROR,
+                errorDetails: TransactionStoreErrorMessage.SUBGRAPH_FAILED
+            });
+            return ctx.onError();
+        }
+    };
+}
+/**
+ * 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 class TransactionManager {
+    /** Writable store tracking all active transactions. */
+    transactions;
+    /** Query client for cache invalidation after successful transactions. */
+    queryClient;
+    /** Function to display toast notifications in the UI. */
+    addToast;
+    /** Wagmi configuration for blockchain interactions. */
+    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, addToast, wagmiConfig) {
+        this.queryClient = queryClient;
+        this.addToast = addToast;
+        this.wagmiConfig = wagmiConfig;
+        this.transactions = writable([]);
+    }
+    /**
+     * 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
+     * });
+     */
+    async createRemoveOrderTransaction(args) {
+        const name = TransactionName.REMOVAL;
+        const errorMessage = 'Order removal failed.';
+        const successMessage = 'Order removed successfully.';
+        const { chainId, entity: { orderbook }, queryKey, txHash, raindexClient } = args;
+        const explorerLink = await getExplorerLink(txHash, chainId, 'tx');
+        const toastLinks = [
+            {
+                link: explorerLink,
+                label: 'View on explorer'
+            }
+        ];
+        const awaitIndexingFn = createSdkIndexingFn({
+            call: () => raindexClient.getRemoveOrdersForTransaction(chainId, orderbook, txHash),
+            isSuccess: (orders) => Array.isArray(orders) && orders.length > 0
+        });
+        return this.createTransaction({
+            ...args,
+            name,
+            errorMessage,
+            successMessage,
+            queryKey,
+            toastLinks,
+            awaitIndexingFn
+        });
+    }
+    /**
+     * 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
+     * });
+     */
+    async createWithdrawTransaction(args) {
+        const name = TransactionName.WITHDRAWAL;
+        const errorMessage = 'Withdrawal failed.';
+        const successMessage = 'Withdrawal successful.';
+        const { chainId, entity: { orderbook }, queryKey, txHash, raindexClient } = args;
+        const explorerLink = await getExplorerLink(txHash, chainId, 'tx');
+        const toastLinks = [
+            {
+                link: `/vaults/${chainId}-${orderbook}-${queryKey}`,
+                label: 'View vault'
+            },
+            {
+                link: explorerLink,
+                label: 'View on explorer'
+            }
+        ];
+        const awaitIndexingFn = createSdkIndexingFn({
+            call: () => raindexClient.getTransaction(chainId, orderbook, txHash),
+            isSuccess: (tx) => !!tx
+        });
+        return this.createTransaction({
+            ...args,
+            name,
+            errorMessage,
+            successMessage,
+            queryKey,
+            toastLinks,
+            awaitIndexingFn
+        });
+    }
+    /**
+     * 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
+     * });
+     */
+    async createVaultsWithdrawAllTransaction(args) {
+        const name = TransactionName.WITHDRAWAL_MULTIPLE;
+        const errorMessage = 'Withdrawal failed.';
+        const successMessage = 'Withdrawal successful.';
+        const { chainId, vaults, txHash, queryKey, raindexClient } = args;
+        if (vaults.length === 0) {
+            throw new Error('At least one vault is required for withdrawal');
+        }
+        // All vaults must share the same orderbook for multicall transactions
+        // It should be validated before calling this method
+        const orderbook = vaults[0].orderbook;
+        const explorerLink = await getExplorerLink(txHash, chainId, 'tx');
+        const toastLinks = [
+            {
+                link: '/vaults/',
+                label: 'View all vaults'
+            },
+            {
+                link: explorerLink,
+                label: 'View on explorer'
+            }
+        ];
+        const awaitIndexingFn = createSdkIndexingFn({
+            call: () => raindexClient.getTransaction(chainId, orderbook, txHash),
+            isSuccess: (tx) => !!tx
+        });
+        return this.createTransaction({
+            ...args,
+            name,
+            errorMessage,
+            successMessage,
+            toastLinks,
+            queryKey,
+            awaitIndexingFn
+        });
+    }
+    /**
+     * 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
+     * });
+     */
+    async createApprovalTransaction(args) {
+        const { entity, queryKey, chainId } = args;
+        const tokenSymbol = entity?.token.symbol || 'token';
+        const name = `Approving ${tokenSymbol} spend`;
+        const errorMessage = 'Approval failed.';
+        const successMessage = 'Approval successful.';
+        const explorerLink = await getExplorerLink(args.txHash, args.chainId, 'tx');
+        let toastLinks = [
+            {
+                link: explorerLink,
+                label: 'View on explorer'
+            }
+        ];
+        if (entity) {
+            toastLinks = [
+                {
+                    link: `/vaults/${chainId}-${entity.orderbook}-${queryKey}`,
+                    label: 'View vault'
+                },
+                ...toastLinks
+            ];
+        }
+        return this.createTransaction({
+            ...args,
+            name,
+            errorMessage,
+            successMessage,
+            toastLinks
+        });
+    }
+    /**
+     * 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.
+     */
+    async createMetaTransaction(args) {
+        const name = 'Publishing metadata';
+        const errorMessage = 'Metadata publication failed.';
+        const successMessage = 'Metadata published.';
+        const explorerLink = await getExplorerLink(args.txHash, args.chainId, 'tx');
+        const toastLinks = [
+            {
+                link: explorerLink,
+                label: 'View on explorer'
+            }
+        ];
+        return this.createTransaction({
+            ...args,
+            name,
+            errorMessage,
+            successMessage,
+            toastLinks
+        });
+    }
+    /**
+     * 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
+     * });
+     */
+    async createDepositTransaction(args) {
+        const tokenSymbol = args.entity.token.symbol;
+        const name = `Depositing ${args.amount.format().value} ${tokenSymbol}`;
+        const errorMessage = 'Deposit failed.';
+        const successMessage = 'Deposit successful.';
+        const { chainId, entity: { orderbook }, txHash, queryKey, raindexClient } = args;
+        const explorerLink = await getExplorerLink(txHash, chainId, 'tx');
+        const toastLinks = [
+            {
+                link: `/vaults/${chainId}-${orderbook}-${queryKey}`,
+                label: 'View vault'
+            },
+            {
+                link: explorerLink,
+                label: 'View on explorer'
+            }
+        ];
+        const awaitIndexingFn = createSdkIndexingFn({
+            call: () => raindexClient.getTransaction(chainId, orderbook, txHash),
+            isSuccess: (tx) => !!tx
+        });
+        return this.createTransaction({
+            ...args,
+            name,
+            errorMessage,
+            successMessage,
+            queryKey,
+            toastLinks,
+            awaitIndexingFn
+        });
+    }
+    /**
+     * 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
+     * });
+     */
+    async createAddOrderTransaction(args) {
+        const { queryKey, txHash, chainId, orderbook, raindexClient } = args;
+        const name = 'Deploying order';
+        const errorMessage = 'Deployment failed.';
+        const successMessage = 'Order deployed successfully.';
+        const explorerLink = await getExplorerLink(txHash, chainId, 'tx');
+        const toastLinks = [
+            {
+                link: explorerLink,
+                label: 'View on explorer'
+            }
+        ];
+        // SDK-based indexing - the SDK's getAddOrdersForTransaction handles
+        // local-DB-first polling followed by subgraph fallback internally
+        const awaitIndexingFn = createSdkIndexingFn({
+            call: () => raindexClient.getAddOrdersForTransaction(chainId, orderbook, txHash),
+            isSuccess: (orders) => Array.isArray(orders) && orders.length > 0,
+            buildLinks: (orders) => {
+                if (!Array.isArray(orders) || orders.length === 0)
+                    return [];
+                const firstOrder = orders[0];
+                if (!firstOrder?.orderHash)
+                    return [];
+                return [
+                    {
+                        link: `/orders/${chainId}-${orderbook}-${firstOrder.orderHash}`,
+                        label: 'View order'
+                    }
+                ];
+            }
+        });
+        return this.createTransaction({
+            ...args,
+            name,
+            errorMessage,
+            successMessage,
+            queryKey,
+            toastLinks,
+            awaitIndexingFn
+        });
+    }
+    /**
+     * 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
+     * });
+     */
+    async createTakeOrderTransaction(args) {
+        const name = TransactionName.TAKE_ORDER;
+        const errorMessage = 'Take order failed.';
+        const successMessage = 'Order taken successfully.';
+        const { chainId, entity: { orderbook }, queryKey, txHash, raindexClient } = args;
+        const explorerLink = await getExplorerLink(txHash, chainId, 'tx');
+        const toastLinks = [
+            {
+                link: explorerLink,
+                label: 'View on explorer'
+            }
+        ];
+        const awaitIndexingFn = createSdkIndexingFn({
+            call: () => raindexClient.getTransaction(chainId, orderbook, txHash),
+            isSuccess: (tx) => !!tx
+        });
+        return this.createTransaction({
+            ...args,
+            name,
+            errorMessage,
+            successMessage,
+            queryKey,
+            toastLinks,
+            awaitIndexingFn
+        });
+    }
+    /**
+     * 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
+     */
+    async createTransaction(args) {
+        const createTransactionArgs = {
+            ...args,
+            config: this.wagmiConfig
+        };
+        const onSuccess = () => {
+            if (args.queryKey) {
+                this.queryClient.invalidateQueries({ queryKey: [args.queryKey] });
+            }
+        };
+        const onError = () => {
+            this.addToast({
+                message: args.errorMessage,
+                type: 'error',
+                color: 'red',
+                links: args.toastLinks
+            });
+        };
+        const transactionInstance = new TransactionStore(createTransactionArgs, onSuccess, onError);
+        this.transactions.update((currentTransactions) => [
+            ...currentTransactions,
+            transactionInstance
+        ]);
+        await transactionInstance.execute();
+        return transactionInstance;
+    }
+    /**
+     * 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() {
+        return this.transactions;
+    }
+    /**
+     * Removes all transactions from the store, resetting the transaction tracking state.
+     * @example
+     * manager.clearTransactions(); // Clear all tracked transactions
+     */
+    clearTransactions() {
+        this.transactions.set([]);
+    }
+}

package/dist/providers/transactions/TransactionProvider.svelte

@@ -0,0 +1,11 @@
+<script>import { setTransactionManagerContext } from "./context";
+import { TransactionManager } from "./TransactionManager";
+import { useQueryClient } from "@tanstack/svelte-query";
+export let addToast;
+export let wagmiConfig;
+const queryClient = useQueryClient();
+const manager = new TransactionManager(queryClient, addToast, $wagmiConfig);
+setTransactionManagerContext(manager);
+</script>
+
+<slot />

package/dist/providers/transactions/TransactionProvider.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponent } from "svelte";
+import type { Config } from '@wagmi/core';
+import type { ToastProps } from '../../types/toast';
+import type { Writable } from 'svelte/store';
+declare const __propDef: {
+    props: {
+        addToast: (toast: ToastProps) => void;
+        wagmiConfig: Writable<Config>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type TransactionProviderProps = typeof __propDef.props;
+export type TransactionProviderEvents = typeof __propDef.events;
+export type TransactionProviderSlots = typeof __propDef.slots;
+export default class TransactionProvider extends SvelteComponent<TransactionProviderProps, TransactionProviderEvents, TransactionProviderSlots> {
+}
+export {};

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

@@ -0,0 +1,19 @@
+import { TransactionManager } from './TransactionManager';
+/**
+ * The context key used to store and retrieve the TransactionManager instance
+ */
+export declare const TRANSACTION_MANAGER_CONTEXT_KEY = "rain:ui-components:transactionManager";
+/**
+ * Sets the TransactionManager instance in Svelte's context
+ *
+ * @param {TransactionManager} manager - The TransactionManager instance to store in context
+ * @returns {void}
+ */
+export declare function setTransactionManagerContext(manager: TransactionManager): void;
+/**
+ * Retrieves the TransactionManager instance from Svelte's context
+ *
+ * @returns {TransactionManager} The TransactionManager instance
+ * @throws {Error} If no TransactionManager is found in context
+ */
+export declare function getTransactionManagerContext(): TransactionManager;

package/dist/providers/transactions/context.js

@@ -0,0 +1,28 @@
+import { getContext, setContext } from 'svelte';
+import { TransactionManager } from './TransactionManager';
+/**
+ * The context key used to store and retrieve the TransactionManager instance
+ */
+export const TRANSACTION_MANAGER_CONTEXT_KEY = 'rain:ui-components:transactionManager';
+/**
+ * Sets the TransactionManager instance in Svelte's context
+ *
+ * @param {TransactionManager} manager - The TransactionManager instance to store in context
+ * @returns {void}
+ */
+export function setTransactionManagerContext(manager) {
+    setContext(TRANSACTION_MANAGER_CONTEXT_KEY, manager);
+}
+/**
+ * Retrieves the TransactionManager instance from Svelte's context
+ *
+ * @returns {TransactionManager} The TransactionManager instance
+ * @throws {Error} If no TransactionManager is found in context
+ */
+export function getTransactionManagerContext() {
+    const manager = getContext(TRANSACTION_MANAGER_CONTEXT_KEY);
+    if (!manager) {
+        throw new Error('TransactionManager not found. Did you forget to setTransactionManagerContext?');
+    }
+    return manager;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Hook for accessing the transaction manager in the application.
+ * Provides access to the transactions store for monitoring transaction states.
+ *
+ * This hook connects to the TransactionManager context which handles order removal
+ * transactions and related operations.
+ *
+ * @returns An object containing the transactions store that can be subscribed to
+ */
+export declare function useTransactions(): {
+    manager: import("./TransactionManager").TransactionManager;
+    transactions: import("svelte/store").Readable<import("../../models/Transaction").Transaction[]>;
+};

package/dist/providers/transactions/useTransactions.js

@@ -0,0 +1,18 @@
+import { getTransactionManagerContext } from './context';
+/**
+ * Hook for accessing the transaction manager in the application.
+ * Provides access to the transactions store for monitoring transaction states.
+ *
+ * This hook connects to the TransactionManager context which handles order removal
+ * transactions and related operations.
+ *
+ * @returns An object containing the transactions store that can be subscribed to
+ */
+export function useTransactions() {
+    const manager = getTransactionManagerContext();
+    const transactions = manager.getTransactions();
+    return {
+        manager,
+        transactions
+    };
+}

package/dist/providers/wallet/WalletProvider.svelte

@@ -0,0 +1,7 @@
+<script>import { readable } from "svelte/store";
+import { setAccountContext } from "./context";
+export let account = readable(null);
+setAccountContext(account);
+</script>
+
+<slot />

package/dist/providers/wallet/WalletProvider.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponent } from "svelte";
+import type { Account } from '../../types/account';
+declare const __propDef: {
+    props: {
+        account?: Account;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type WalletProviderProps = typeof __propDef.props;
+export type WalletProviderEvents = typeof __propDef.events;
+export type WalletProviderSlots = typeof __propDef.slots;
+export default class WalletProvider extends SvelteComponent<WalletProviderProps, WalletProviderEvents, WalletProviderSlots> {
+}
+export {};

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

@@ -0,0 +1,10 @@
+import type { Account } from '../../types/account';
+export declare const ACCOUNT_KEY = "account_key";
+/**
+ * Retrieves the account store directly from Svelte's context
+ */
+export declare const getAccountContext: () => Account;
+/**
+ * Sets the account store in Svelte's context
+ */
+export declare const setAccountContext: (account: Account) => void;