@silentswap/react 0.0.41

package/dist/contexts/BalancesContext.js

@@ -0,0 +1,533 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useCallback, useMemo, useEffect } from 'react';
+import { erc20Abi, createPublicClient, http, getAddress } from 'viem';
+import { createSolanaRpc } from '@solana/rpc';
+import { address } from '@solana/kit';
+import { getAssociatedTokenAddress } from '@solana/spl-token';
+import { PublicKey } from '@solana/web3.js';
+import { useAssetsContext } from './AssetsContext.js';
+import { usePrices } from '../hooks/usePrices.js';
+import { isSolanaAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, isEvmNativeToken, SB58_CHAIN_ID_SOLANA_MAINNET, A_VIEM_CHAINS, } from '@silentswap/sdk';
+const BalancesContext = createContext(undefined);
+// Custom RPC endpoints from 0xrpc.io (fast, free, private public RPC)
+// Reference: https://0xrpc.io
+const CUSTOM_RPC_ENDPOINTS = {
+    1: 'https://red-old-fog.quiknode.pro/7a0bdad6750af42fb7fb312cabd90f196594e700/', // Ethereum Mainnet
+    10: 'https://cold-white-mountain.optimism.quiknode.pro/dd00719b96a7c719aa6065c476ef928e465c6799/', // Optimism L2 Mainnet
+};
+// Utility: Create viem client with custom RPC endpoints where available
+const createViemClient = (chain) => {
+    const customRpc = CUSTOM_RPC_ENDPOINTS[chain.id];
+    const chainWithCustomRpc = customRpc
+        ? {
+            ...chain,
+            rpcUrls: {
+                ...chain.rpcUrls,
+                default: {
+                    http: [customRpc],
+                },
+            },
+        }
+        : chain;
+    return createPublicClient({
+        chain: chainWithCustomRpc,
+        transport: http(), // viem http transport with default timeout
+    });
+};
+// Utility: Separate EVM assets into ERC-20 and native
+const separateEvmAssets = (chainAssets) => {
+    const a_assets_erc20 = [];
+    const a_assets_native = [];
+    for (const asset of chainAssets) {
+        if (asset.caip19.includes('/erc20:')) {
+            a_assets_erc20.push(asset);
+        }
+        else if (isEvmNativeToken(asset.caip19)) {
+            a_assets_native.push(asset);
+        }
+    }
+    return { a_assets_erc20, a_assets_native };
+};
+// Utility: Separate Solana assets into native and SPL tokens
+const separateSolanaAssets = (solanaAssets) => {
+    const a_assets_native = [];
+    const a_assets_tokens = [];
+    for (const asset of solanaAssets) {
+        const parsed = parseSolanaCaip19(asset.caip19);
+        if (!parsed)
+            continue;
+        if (parsed.chainId !== SB58_CHAIN_ID_SOLANA_MAINNET)
+            continue;
+        if (isSolanaNativeToken(asset.caip19)) {
+            a_assets_native.push(asset);
+        }
+        else if (isSplToken(asset.caip19)) {
+            a_assets_tokens.push(asset);
+        }
+    }
+    return { a_assets_native, a_assets_tokens };
+};
+// Utility: Fetch ERC-20 balance for a single token (fallback when multicall not available)
+const fetchSingleErc20Balance = async (y_client, s0x_account, k_asset, getUnitValueUsd) => {
+    try {
+        const tokenAddress = k_asset.caip19.split('/erc20:')[1];
+        const xg_balance = await y_client.readContract({
+            address: tokenAddress,
+            abi: erc20Abi,
+            functionName: 'balanceOf',
+            args: [s0x_account],
+        });
+        const g_update = {
+            asset: k_asset,
+            balance: BigInt(xg_balance),
+            usdValue: 0,
+        };
+        try {
+            const x_value_usd = await getUnitValueUsd(k_asset, g_update.balance);
+            g_update.usdValue = x_value_usd;
+        }
+        catch (error) {
+            // USD calculation failed, but we still have the balance
+        }
+        return g_update;
+    }
+    catch (error) {
+        // Individual token fetch failed - return null to skip this token
+        if (process.env.NODE_ENV === 'development') {
+            console.warn(`Failed to fetch balance for ${k_asset.caip19}:`, error);
+        }
+        return null;
+    }
+};
+// Utility: Fetch ERC-20 balances for a chain using multicall (preferred method)
+const fetchEvmErc20Balances = async (y_client, s0x_account, a_assets_erc20, getUnitValueUsd) => {
+    const updatedBalances = {};
+    if (a_assets_erc20.length === 0)
+        return updatedBalances;
+    try {
+        const a_balances = await y_client.multicall({
+            contracts: a_assets_erc20.map((k_asset) => ({
+                address: k_asset.caip19.split('/erc20:')[1],
+                abi: erc20Abi,
+                functionName: 'balanceOf',
+                args: [s0x_account],
+            })),
+        });
+        await Promise.all(a_assets_erc20.slice(0, a_balances.length).map(async (k_asset, i_call) => {
+            const g_result = a_balances[i_call];
+            const si_caip19 = k_asset.caip19;
+            const g_update = {
+                asset: k_asset,
+                balance: 0n,
+                usdValue: 0,
+            };
+            if (g_result.status === 'success' && g_result.result) {
+                const xg_balance = BigInt(g_result.result);
+                try {
+                    const x_value_usd = await getUnitValueUsd(k_asset, xg_balance);
+                    g_update.balance = xg_balance;
+                    g_update.usdValue = x_value_usd;
+                }
+                catch (error) {
+                    g_update.balance = xg_balance;
+                }
+            }
+            updatedBalances[si_caip19] = g_update;
+        }));
+    }
+    catch (error) {
+        // Log error for debugging but don't throw - allow other chains to continue
+        if (process.env.NODE_ENV === 'development') {
+            console.warn(`Failed to fetch ERC20 balances via multicall:`, error);
+        }
+    }
+    return updatedBalances;
+};
+// Utility: Fetch ERC-20 balances one by one (fallback when multicall not supported)
+const fetchEvmErc20BalancesOneByOne = async (y_client, s0x_account, a_assets_erc20, getUnitValueUsd) => {
+    const updatedBalances = {};
+    if (a_assets_erc20.length === 0)
+        return updatedBalances;
+    // Fetch balances one by one with Promise.allSettled to handle individual failures
+    const results = await Promise.allSettled(a_assets_erc20.map((k_asset) => fetchSingleErc20Balance(y_client, s0x_account, k_asset, getUnitValueUsd)));
+    results.forEach((result, index) => {
+        if (result.status === 'fulfilled' && result.value) {
+            updatedBalances[a_assets_erc20[index].caip19] = result.value;
+        }
+    });
+    return updatedBalances;
+};
+// Utility: Fetch native EVM balances for a chain
+const fetchEvmNativeBalances = async (y_client, s0x_account, a_assets_native, getUnitValueUsd) => {
+    const updatedBalances = {};
+    if (a_assets_native.length === 0)
+        return updatedBalances;
+    try {
+        const xg_balance = await y_client.getBalance({ address: s0x_account });
+        await Promise.all(a_assets_native.map(async (k_asset) => {
+            let x_value_usd = 0;
+            try {
+                x_value_usd = await getUnitValueUsd(k_asset, xg_balance);
+            }
+            catch (error) {
+                // console.warn(`Failed to calculate USD value for native ${k_asset.caip19}:`, error);
+            }
+            updatedBalances[k_asset.caip19] = {
+                asset: k_asset,
+                balance: xg_balance,
+                usdValue: x_value_usd,
+            };
+        }));
+    }
+    catch (error) {
+        // Log error for debugging but don't throw - allow other chains to continue
+        if (process.env.NODE_ENV === 'development') {
+            console.warn(`Failed to fetch native balance:`, error);
+        }
+    }
+    return updatedBalances;
+};
+// Utility: Fetch balances for a single EVM chain
+const fetchEvmChainBalances = async (g_chain, s0x_account, assets, getUnitValueUsd) => {
+    try {
+        const y_client = createViemClient(g_chain);
+        const si_chain = `${g_chain.id}`;
+        const chainAssets = Object.values(assets).filter((asset) => asset.caip19.startsWith(`eip155:${si_chain}/`));
+        if (chainAssets.length === 0)
+            return { balances: {} };
+        const { a_assets_erc20, a_assets_native } = separateEvmAssets(chainAssets);
+        const hasMulticall = !!g_chain.contracts?.multicall3;
+        // Use multicall if available, otherwise fetch one by one
+        const erc20BalancePromise = hasMulticall
+            ? fetchEvmErc20Balances(y_client, s0x_account, a_assets_erc20, getUnitValueUsd)
+            : fetchEvmErc20BalancesOneByOne(y_client, s0x_account, a_assets_erc20, getUnitValueUsd);
+        // Use Promise.allSettled to handle partial failures gracefully
+        const [erc20Result, nativeResult] = await Promise.allSettled([
+            erc20BalancePromise,
+            fetchEvmNativeBalances(y_client, s0x_account, a_assets_native, getUnitValueUsd),
+        ]);
+        const erc20Balances = erc20Result.status === 'fulfilled' ? erc20Result.value : {};
+        const nativeBalances = nativeResult.status === 'fulfilled' ? nativeResult.value : {};
+        // Collect errors if any
+        const errors = [];
+        if (erc20Result.status === 'rejected') {
+            errors.push(`ERC20: ${erc20Result.reason?.message || 'Unknown error'}`);
+        }
+        if (nativeResult.status === 'rejected') {
+            errors.push(`Native: ${nativeResult.reason?.message || 'Unknown error'}`);
+        }
+        if (!hasMulticall && a_assets_erc20.length > 0) {
+            // Note that we're using fallback method (not an error, just informational)
+            if (process.env.NODE_ENV === 'development') {
+                console.info(`Chain ${g_chain.id} (${g_chain.name}) doesn't support multicall, fetching ERC20 balances one by one`);
+            }
+        }
+        return {
+            balances: { ...erc20Balances, ...nativeBalances },
+            error: errors.length > 0 ? errors.join('; ') : undefined,
+        };
+    }
+    catch (error) {
+        const errorMsg = `Failed to fetch balances for chain ${g_chain.id}: ${error instanceof Error ? error.message : String(error)}`;
+        if (process.env.NODE_ENV === 'development') {
+            console.error(errorMsg, error);
+        }
+        return { balances: {}, error: errorMsg };
+    }
+};
+// Utility: Fetch Solana native balances
+const fetchSolanaNativeBalances = async (rpc, ownerAddress, a_assets_native, getUnitValueUsd) => {
+    const updatedBalances = {};
+    if (a_assets_native.length === 0)
+        return updatedBalances;
+    try {
+        const response = await rpc.getBalance(address(ownerAddress), { commitment: 'confirmed' }).send();
+        const x_balance_native = response.value;
+        const xg_balance = BigInt(x_balance_native);
+        await Promise.all(a_assets_native.map(async (k_asset) => {
+            let x_value_usd = 0;
+            try {
+                x_value_usd = await getUnitValueUsd(k_asset, xg_balance);
+            }
+            catch (error) {
+                // console.warn(`Failed to calculate USD value for native ${k_asset.caip19}:`, error);
+            }
+            updatedBalances[k_asset.caip19] = {
+                asset: k_asset,
+                balance: xg_balance,
+                usdValue: x_value_usd,
+            };
+        }));
+    }
+    catch (error) {
+        // Log error for debugging but don't throw - allow other operations to continue
+        if (process.env.NODE_ENV === 'development') {
+            console.warn(`Failed to fetch native SOL balance:`, error);
+        }
+    }
+    return updatedBalances;
+};
+// Utility: Fetch Solana SPL token balances
+const fetchSolanaTokenBalances = async (rpc, ownerAddress, a_assets_tokens, getUnitValueUsd) => {
+    const updatedBalances = {};
+    if (a_assets_tokens.length === 0)
+        return updatedBalances;
+    const ownerPubkey = new PublicKey(ownerAddress);
+    const ataPromises = a_assets_tokens.map(async (k_asset) => {
+        try {
+            const parsed = parseSolanaCaip19(k_asset.caip19);
+            if (!parsed || !parsed.tokenAddress)
+                return null;
+            const mintPubkey = new PublicKey(parsed.tokenAddress);
+            const ataAddress = await getAssociatedTokenAddress(mintPubkey, ownerPubkey);
+            return { asset: k_asset, ata: ataAddress };
+        }
+        catch (error) {
+            return null;
+        }
+    });
+    const ataResults = await Promise.all(ataPromises);
+    await Promise.all(ataResults.map(async (result) => {
+        if (!result)
+            return;
+        const { asset: k_asset, ata: ataAddress } = result;
+        try {
+            const response = await rpc.getTokenAccountBalance(address(ataAddress.toBase58()), { commitment: 'confirmed' }).send();
+            if (response.value && Number(response.value.amount) > 0) {
+                const xg_balance = BigInt(response.value.amount);
+                let x_value_usd = 0;
+                try {
+                    x_value_usd = await getUnitValueUsd(k_asset, xg_balance);
+                }
+                catch (error) {
+                    // console.warn(`Failed to calculate USD value for token ${k_asset.caip19}:`, error);
+                }
+                updatedBalances[k_asset.caip19] = {
+                    asset: k_asset,
+                    balance: xg_balance,
+                    usdValue: x_value_usd,
+                };
+            }
+        }
+        catch (error) {
+            const isAccountNotFound = error?.code === 32602 ||
+                (typeof error?.message === 'string' && error.message.toLowerCase().includes('could not find account'));
+            if (!isAccountNotFound && process.env.NODE_ENV === 'development') {
+                console.warn(`Failed to fetch token balance for ${k_asset.caip19}:`, error);
+            }
+        }
+    }));
+    return updatedBalances;
+};
+// Utility: Fetch all Solana balances
+const fetchSolanaBalances = async (solAddress, solanaRpcUrl, assets, getUnitValueUsd) => {
+    try {
+        const rpc = createSolanaRpc(solanaRpcUrl);
+        const solanaAssets = Object.values(assets).filter((asset) => isSolanaAsset(asset.caip19));
+        const { a_assets_native, a_assets_tokens } = separateSolanaAssets(solanaAssets);
+        // Use Promise.allSettled to handle partial failures gracefully
+        const [nativeResult, tokenResult] = await Promise.allSettled([
+            fetchSolanaNativeBalances(rpc, solAddress, a_assets_native, getUnitValueUsd),
+            fetchSolanaTokenBalances(rpc, solAddress, a_assets_tokens, getUnitValueUsd),
+        ]);
+        const nativeBalances = nativeResult.status === 'fulfilled' ? nativeResult.value : {};
+        const tokenBalances = tokenResult.status === 'fulfilled' ? tokenResult.value : {};
+        // Collect errors if any
+        const errors = [];
+        if (nativeResult.status === 'rejected') {
+            errors.push(`Native: ${nativeResult.reason?.message || 'Unknown error'}`);
+        }
+        if (tokenResult.status === 'rejected') {
+            errors.push(`Tokens: ${tokenResult.reason?.message || 'Unknown error'}`);
+        }
+        return {
+            balances: { ...nativeBalances, ...tokenBalances },
+            error: errors.length > 0 ? errors.join('; ') : undefined,
+        };
+    }
+    catch (error) {
+        const errorMsg = `Failed to fetch Solana balances: ${error instanceof Error ? error.message : String(error)}`;
+        if (process.env.NODE_ENV === 'development') {
+            console.error(errorMsg, error);
+        }
+        return { balances: {}, error: errorMsg };
+    }
+};
+/**
+ * Provider for user balances across all supported chains
+ */
+export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUrl }) => {
+    const { assets, loading: assetsLoading } = useAssetsContext();
+    const { getUnitValueUsd } = usePrices();
+    const [balances, setBalances] = useState({});
+    const [loading, setLoading] = useState(false);
+    const [errors, setErrors] = useState({});
+    const updateBalances = useCallback(async () => {
+        if (assetsLoading)
+            return;
+        setLoading(true);
+        setErrors({}); // Clear previous errors
+        try {
+            // Track promises with their chain IDs for better error handling
+            const balanceTasks = [];
+            // Process EVM balances if EVM address is available
+            if (evmAddress) {
+                const s0x_account = getAddress(evmAddress);
+                A_VIEM_CHAINS.forEach((g_chain) => {
+                    balanceTasks.push({
+                        chainId: g_chain.id,
+                        promise: fetchEvmChainBalances(g_chain, s0x_account, assets, getUnitValueUsd),
+                    });
+                });
+            }
+            // Process Solana balances if Solana address is available
+            if (solAddress && solanaRpcUrl) {
+                balanceTasks.push({
+                    chainId: 'solana',
+                    promise: fetchSolanaBalances(solAddress, solanaRpcUrl, assets, getUnitValueUsd),
+                });
+            }
+            // Use Promise.allSettled to handle partial failures gracefully
+            // This ensures one chain failure doesn't prevent others from updating
+            const results = await Promise.allSettled(balanceTasks.map((task) => task.promise));
+            const updatedBalances = {};
+            const newErrors = {};
+            results.forEach((result, index) => {
+                const { chainId } = balanceTasks[index];
+                if (result.status === 'fulfilled') {
+                    const { balances: chainBalances, error } = result.value;
+                    Object.assign(updatedBalances, chainBalances);
+                    if (error) {
+                        newErrors[String(chainId)] = error;
+                    }
+                }
+                else {
+                    // If the promise itself was rejected, track the error with chain ID
+                    const errorMsg = result.reason?.message || 'Unknown error';
+                    newErrors[String(chainId)] = errorMsg;
+                    if (process.env.NODE_ENV === 'development') {
+                        console.error(`Failed to fetch balances for chain ${chainId}:`, result.reason);
+                    }
+                }
+            });
+            // Merge with existing balances to preserve balances from other chains
+            setBalances((prev) => ({ ...prev, ...updatedBalances }));
+            setErrors(newErrors);
+        }
+        catch (error) {
+            if (process.env.NODE_ENV === 'development') {
+                console.error('Failed to update balances:', error);
+            }
+            setErrors({ global: error instanceof Error ? error.message : 'Failed to update balances' });
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [evmAddress, solAddress, solanaRpcUrl, assets, assetsLoading, getUnitValueUsd]);
+    // Refetch balances for specific chains only
+    const refetchChains = useCallback(async (chainIds) => {
+        if (assetsLoading || chainIds.length === 0)
+            return;
+        setLoading(true);
+        try {
+            // Track promises with their chain IDs for better error handling
+            const balanceTasks = [];
+            // Separate EVM and Solana chain IDs
+            const evmChainIds = chainIds.filter((id) => typeof id === 'number');
+            const shouldRefetchSolana = chainIds.includes('solana');
+            // Process EVM balances for specific chains
+            if (evmAddress && evmChainIds.length > 0) {
+                const s0x_account = getAddress(evmAddress);
+                const chainsToFetch = A_VIEM_CHAINS.filter((g_chain) => evmChainIds.includes(g_chain.id));
+                chainsToFetch.forEach((g_chain) => {
+                    balanceTasks.push({
+                        chainId: g_chain.id,
+                        promise: fetchEvmChainBalances(g_chain, s0x_account, assets, getUnitValueUsd),
+                    });
+                });
+            }
+            // Process Solana balances if requested
+            if (solAddress && solanaRpcUrl && shouldRefetchSolana) {
+                balanceTasks.push({
+                    chainId: 'solana',
+                    promise: fetchSolanaBalances(solAddress, solanaRpcUrl, assets, getUnitValueUsd),
+                });
+            }
+            // Use Promise.allSettled to handle partial failures gracefully
+            const results = await Promise.allSettled(balanceTasks.map((task) => task.promise));
+            const newBalances = {};
+            const newErrors = {};
+            results.forEach((result, index) => {
+                const { chainId } = balanceTasks[index];
+                if (result.status === 'fulfilled') {
+                    const { balances: chainBalances, error } = result.value;
+                    Object.assign(newBalances, chainBalances);
+                    if (error) {
+                        newErrors[String(chainId)] = error;
+                    }
+                }
+                else {
+                    const errorMsg = result.reason?.message || 'Unknown error';
+                    newErrors[String(chainId)] = errorMsg;
+                    if (process.env.NODE_ENV === 'development') {
+                        console.error(`Failed to refetch balances for chain ${chainId}:`, result.reason);
+                    }
+                }
+            });
+            // Merge with existing balances (only update the chains we refetched)
+            setBalances((prev) => ({ ...prev, ...newBalances }));
+            // Update errors only for refetched chains
+            setErrors((prev) => {
+                const updated = { ...prev };
+                chainIds.forEach((id) => {
+                    const key = String(id);
+                    if (newErrors[key]) {
+                        updated[key] = newErrors[key];
+                    }
+                    else {
+                        delete updated[key]; // Clear error if refetch succeeded
+                    }
+                });
+                return updated;
+            });
+        }
+        catch (error) {
+            if (process.env.NODE_ENV === 'development') {
+                console.error('Failed to refetch chain balances:', error);
+            }
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [evmAddress, solAddress, solanaRpcUrl, assets, assetsLoading, getUnitValueUsd]);
+    // Calculate total USD value
+    const totalUsdValue = useMemo(() => {
+        return Object.values(balances).reduce((total, balance) => total + balance.usdValue, 0);
+    }, [balances]);
+    // Auto-update balances when address, solAddress, or assets change
+    useEffect(() => {
+        if ((evmAddress || solAddress) && !assetsLoading) {
+            updateBalances();
+        }
+    }, [evmAddress, solAddress, solanaRpcUrl, assetsLoading, updateBalances]);
+    const value = useMemo(() => ({
+        balances,
+        loading: loading || assetsLoading,
+        totalUsdValue,
+        errors,
+        refetch: updateBalances,
+        refetchChains,
+    }), [balances, loading, assetsLoading, totalUsdValue, errors, updateBalances, refetchChains]);
+    return _jsx(BalancesContext.Provider, { value: value, children: children });
+};
+/**
+ * Hook to access user balances
+ */
+export const useBalancesContext = () => {
+    const context = useContext(BalancesContext);
+    if (context === undefined) {
+        throw new Error('useBalancesContext must be used within a BalancesProvider');
+    }
+    return context;
+};

package/dist/contexts/OrdersContext.d.ts

@@ -0,0 +1,53 @@
+import React from 'react';
+import type { NaiveBase58, RefundEligibility } from '@silentswap/sdk';
+import type { SilentSwapWallet } from '../hooks/silent/useWallet.js';
+export type OrdersContextOrderMetadata = {
+    sourceAsset?: {
+        caip19: string;
+        amount: string;
+    };
+    sourceSender?: {
+        contactId: string;
+    };
+};
+export type OrdersContextOrder = {
+    orderId: string;
+    status: string;
+    modified?: number;
+    metadata?: OrdersContextOrderMetadata;
+    deposit?: {
+        amount: string;
+        timestamp: number;
+    };
+    auth?: NaiveBase58;
+};
+export type FacilitatorGroup = () => Promise<{
+    viewer: () => Promise<{
+        evmSigner: () => Promise<{
+            address: string;
+        }>;
+    }>;
+}>;
+export declare const useWalletFacilitatorGroups: (wallet: SilentSwapWallet | null, setFacilitatorGroups: (groups: FacilitatorGroup[]) => void) => void;
+export type OrdersContextType = {
+    orders: OrdersContextOrder[];
+    loading: boolean;
+    facilitatorGroups: FacilitatorGroup[];
+    orderIdToViewingAuth: Record<string, NaiveBase58>;
+    orderIdToDefaultPublicKey: Record<string, string>;
+    addFacilitatorGroup: (group: FacilitatorGroup) => void;
+    setFacilitatorGroups: (groups: FacilitatorGroup[]) => void;
+    clearFacilitatorGroups: () => void;
+    setOrderDefaultPublicKey: (orderId: string, publicKey: string) => void;
+    refreshOrders: () => void;
+    getOrderAgeText: (modified?: number) => string;
+    getStatusInfo: (status: string, refundEligibility?: RefundEligibility | null) => {
+        text: string;
+        pulsing: boolean;
+        color: string;
+    };
+};
+export declare const OrdersProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useOrdersContext: () => OrdersContextType;