@silentswap/react 0.0.41

package/README.md

@@ -0,0 +1,48 @@
+# @silentswap/react
+
+React hooks and utilities for integrating with SilentSwap SDK.
+
+## Installation
+
+```bash
+bun add @silentswap/react @silentswap/sdk
+```
+
+## Usage
+
+```tsx
+import { useSilentClient, useSilentOrders, useAuth } from '@silentswap/react';
+
+function MyComponent() {
+    // Create client
+    const { client } = useSilentClient({
+        config: {
+            environment: 'MAINNET',
+        },
+    });
+
+    // Use order operations
+    const { getQuote, createOrder, isLoading, error } = useSilentOrders({
+        client,
+    });
+
+    // Use auth utilities
+    const { createSignInMessage, createEip712DocForOrder } = useAuth();
+
+    // ... your component logic
+}
+```
+
+## Hooks
+
+### `useSilentClient`
+
+Creates and manages a SilentSwap client instance.
+
+### `useSilentOrders`
+
+Provides methods for order operations including quotes, authentication, and order creation.
+
+### `useAuth`
+
+Provides authentication utilities for sign-in messages and EIP-712 document creation.

package/dist/contexts/AssetsContext.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { type AssetInfo, type ChainInfo } from '@silentswap/sdk';
+export type Chain = ChainInfo;
+export type { ChainInfo };
+export type AssetsContextType = {
+    assets: Record<string, AssetInfo>;
+    chains: Record<string, Chain>;
+    loading: boolean;
+    getAsset: (caip19: string) => AssetInfo | undefined;
+    getFilteredAssets: (filter?: {
+        ingress?: boolean;
+        egress?: boolean;
+    }) => AssetInfo[];
+};
+/**
+ * Provider for asset and chain metadata from the SDK
+ */
+export declare const AssetsProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+/**
+ * Hook to access asset and chain metadata
+ */
+export declare const useAssetsContext: () => AssetsContextType;

package/dist/contexts/AssetsContext.js

@@ -0,0 +1,83 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useCallback, useMemo, useEffect } from 'react';
+import { getAllAssetsArray, getAllChains } from '@silentswap/sdk';
+const AssetsContext = createContext(undefined);
+// Global assets store (similar to Svelte's data.ts)
+let assetsStore = {};
+let chainsStore = {};
+let assetsLoaded = false;
+/**
+ * Provider for asset and chain metadata from the SDK
+ */
+export const AssetsProvider = ({ children }) => {
+    const [assets, setAssets] = useState({});
+    const [chains, setChains] = useState({});
+    const [loading, setLoading] = useState(true);
+    useEffect(() => {
+        const loadAssetsData = () => {
+            if (assetsLoaded) {
+                setAssets(assetsStore);
+                setChains(chainsStore);
+                setLoading(false);
+                return;
+            }
+            try {
+                // Use SDK methods to get assets and chains
+                const allAssets = getAllAssetsArray();
+                const allChains = getAllChains();
+                // Convert to our format
+                const assetsMap = {};
+                allAssets.forEach((asset) => {
+                    assetsMap[asset.caip19] = asset;
+                });
+                const chainsMap = {};
+                Object.entries(allChains).forEach(([caip2, chain]) => {
+                    chainsMap[caip2] = chain;
+                });
+                // Store globally
+                assetsStore = assetsMap;
+                chainsStore = chainsMap;
+                assetsLoaded = true;
+                setAssets(assetsMap);
+                setChains(chainsMap);
+                setLoading(false);
+            }
+            catch (error) {
+                console.error('Failed to load assets:', error);
+                setLoading(false);
+            }
+        };
+        loadAssetsData();
+    }, []);
+    const getAsset = useCallback((caip19) => {
+        return assets[caip19];
+    }, [assets]);
+    const getFilteredAssets = useCallback((filter) => {
+        let filteredAssets = Object.values(assets);
+        // Apply ingress filter (exclude blacklisted chains)
+        if (filter?.ingress) {
+            // For now, just return all - implement blacklist logic if needed
+            filteredAssets = filteredAssets;
+        }
+        return filteredAssets;
+    }, [assets]);
+    const value = useMemo(() => ({
+        assets,
+        chains,
+        loading,
+        getAsset,
+        getFilteredAssets,
+    }), [assets, chains, loading, getAsset, getFilteredAssets]);
+    return _jsx(AssetsContext.Provider, { value: value, children: children });
+};
+/**
+ * Hook to access asset and chain metadata
+ */
+export const useAssetsContext = () => {
+    const context = useContext(AssetsContext);
+    if (context === undefined) {
+        throw new Error('useAssetsContext must be used within an AssetsProvider');
+    }
+    return context;
+};

package/dist/contexts/BalancesContext.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { type AssetInfo } from '@silentswap/sdk';
+export type UserBalance = {
+    asset: AssetInfo;
+    balance: bigint;
+    usdValue: number;
+};
+export type BalancesContextType = {
+    balances: Record<string, UserBalance>;
+    loading: boolean;
+    totalUsdValue: number;
+    errors: Record<string, string>;
+    refetch: () => Promise<void>;
+    refetchChains: (chainIds: (number | 'solana')[]) => Promise<void>;
+};
+/**
+ * Provider for user balances across all supported chains
+ */
+export declare const BalancesProvider: React.FC<{
+    children: React.ReactNode;
+    evmAddress?: string;
+    solAddress?: string;
+    solanaRpcUrl?: string;
+}>;
+/**
+ * Hook to access user balances
+ */
+export declare const useBalancesContext: () => BalancesContextType;