@silentswap/react 0.0.41

package/dist/hooks/silent/useSilentOrders.d.ts

@@ -0,0 +1,174 @@
+import type { SilentSwapClient, AuthRequest, AuthResponse, NonceResponse, OrderRequest, OrderResponse, QuoteRequest, QuoteResponse } from '@silentswap/sdk';
+export interface useSilentOrdersOptions {
+    client: SilentSwapClient;
+}
+export interface useSilentOrdersReturn {
+    isLoading: boolean;
+    error: Error | null;
+    getNonce: (address: `0x${string}`) => Promise<NonceResponse | null>;
+    /**
+     * Authenticates a user with SIWE (Sign-In with Ethereum)
+     *
+     * @param auth - Authentication request containing SIWE message and signature
+     * @returns Promise resolving to authentication response or null on error
+     *
+     * @example
+     * ```typescript
+     * const { authenticate } = useSilentOrders({ client });
+     *
+     * // First get a nonce for the user
+     * const nonceResponse = await getNonce('0x1234567890123456789012345678901234567890');
+     *
+     * // Create SIWE message (using useAuth hook)
+     * const siweMessage = createSignInMessage(
+     *   '0x1234567890123456789012345678901234567890',
+     *   nonceResponse.nonce,
+     *   'example.com'
+     * );
+     *
+     * // Sign the message with wallet
+     * const signature = await wallet.signMessage(siweMessage);
+     *
+     * // Authenticate
+     * const authResponse = await authenticate({
+     *   siwe: {
+     *     message: siweMessage,
+     *     signature: signature as `0x${string}`
+     *   }
+     * });
+     *
+     * if (authResponse) {
+     *   console.log('Authenticated address:', authResponse.address);
+     *   console.log('Secret token:', authResponse.secretToken);
+     * }
+     * ```
+     */
+    authenticate: (auth: AuthRequest) => Promise<AuthResponse | null>;
+    /**
+     * Gets a quote for a SilentSwap order
+     *
+     * @param quote - Quote request containing signer, viewer, and outputs
+     * @returns Promise resolving to quote response or null on error
+     *
+     * @example
+     * ```typescript
+     * const { getQuote } = useSilentOrders({ client });
+     * import {
+     *   createHdFacilitatorGroupFromEntropy,
+     *   FacilitatorKeyType,
+     *   caip19FungibleEvmToken,
+     *   PublicKeyArgGroups,
+     *   DeliveryMethod,
+     * } from '@silentswap/sdk';
+     *
+     * // Generate entropy (in a real app, this would come from a secure source)
+     * const entropy = new Uint8Array(32);
+     * const random = crypto.getRandomValues(entropy);
+     *
+     * // Create HD facilitator group from entropy
+     * const group = await createHdFacilitatorGroupFromEntropy(random, 0);
+     *
+     * // Derive viewer account
+     * const viewer = await group.viewer();
+     *
+     * // Export its public key
+     * const { publicKeyBytes: pk65_viewer } = viewer.exportPublicKey('*', FacilitatorKeyType.SECP256K1);
+     *
+     * // Export public keys for the facilitator group
+     * const groupPublicKeys = await group.exportPublicKeys(1, [
+     *   ...PublicKeyArgGroups.GENERIC,
+     * ]);
+     *
+     * // Define outputs
+     * const outputs = [{
+     *   method: DeliveryMethod.SNIP,
+     *   asset: caip19FungibleEvmToken(1, '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
+     *   facilitatorPublicKeys: groupPublicKeys[0],
+     *   recipient: '0x461ddCA267968eB7A8191c0cDb1684a45b9250c9' as `0x${string}`,
+     *   value: '10000000' as `${bigint}`,
+     * }];
+     *
+     * // Request a quote
+     * const quoteResponse = await getQuote({
+     *   signer: '0x461ddCA267968eB7A8191c0cDb1684a45b9250c9' as `0x${string}`,
+     *   viewer: pk65_viewer,
+     *   outputs: outputs,
+     * });
+     *
+     * if (quoteResponse) {
+     *   console.log('Quote ID:', quoteResponse.quoteId);
+     *   // Store group for later use in order creation
+     * }
+     * ```
+     */
+    getQuote: (quote: QuoteRequest) => Promise<QuoteResponse | null>;
+    /**
+     * Creates a SilentSwap order by submitting a signed quote with all required authorizations
+     *
+     * @param order - Order request containing quote, signatures, and authorizations
+     * @returns Promise resolving to order response with deposit transaction or null on error
+     *
+     * @example
+     * ```typescript
+     * const { createOrder, getQuote } = useSilentOrders({ client });
+     * const { createEip712DocForOrder } = useAuth();
+     * import { createViemSigner } from '@silentswap/sdk';
+     * import type { AuthorizationInstruction } from '@silentswap/sdk';
+     *
+     * // Assume we have a quoteResponse and group from getQuote
+     * const quoteResponse = await getQuote({ /* ... *\/ });
+     * if (!quoteResponse) throw new Error('Failed to get quote');
+     *
+     * // Create signer (using viem/wagmi)
+     * const signer = createViemSigner(
+     *   { address: connectedAddress, type: 'json-rpc' },
+     *   walletClient
+     * );
+     *
+     * // Sign authorizations
+     * const signedAuths = await Promise.all(
+     *   quoteResponse.authorizations.map(async (g_auth: AuthorizationInstruction) => ({
+     *     ...g_auth,
+     *     signature: await (async () => {
+     *       if ('eip3009_deposit' === g_auth.type) {
+     *         return await signer.signEip712TypedData(g_auth.eip712);
+     *       }
+     *       throw Error(`Authorization instruction type not implemented: ${g_auth.type}`);
+     *     })(),
+     *   }))
+     * );
+     *
+     * // Sign the order's EIP-712
+     * const orderDoc = createEip712DocForOrder(quoteResponse);
+     * const signedQuote = await signer.signEip712TypedData(orderDoc);
+     *
+     * // Approve proxy authorizations using the facilitator group
+     * const facilitatorReplies = await group.approveProxyAuthorizations(quoteResponse.facilitators, {
+     *   proxyPublicKey: client.proxyPublicKey,
+     * });
+     *
+     * // Create the order
+     * const orderResponse = await createOrder({
+     *   quote: quoteResponse.quote,
+     *   quoteId: quoteResponse.quoteId,
+     *   authorizations: signedAuths,
+     *   eip712Domain: orderDoc.domain,
+     *   signature: signedQuote,
+     *   facilitators: facilitatorReplies,
+     * });
+     *
+     * if (orderResponse) {
+     *   console.log('Placed order', orderResponse.response.orderId);
+     *   // Use orderResponse.transaction to execute the deposit
+     * }
+     * ```
+     */
+    createOrder: (order: OrderRequest) => Promise<OrderResponse | null>;
+}
+/**
+ * React hook for managing SilentSwap orders and related operations
+ *
+ * @param options - Options containing the SilentSwap client
+ * @returns Object with order management methods and state
+ */
+export declare function useSilentOrders({ client }: useSilentOrdersOptions): useSilentOrdersReturn;

package/dist/hooks/silent/useSilentOrders.js

@@ -0,0 +1,73 @@
+import { useCallback, useState } from 'react';
+/**
+ * React hook for managing SilentSwap orders and related operations
+ *
+ * @param options - Options containing the SilentSwap client
+ * @returns Object with order management methods and state
+ */
+export function useSilentOrders({ client }) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const handleAsyncOperation = useCallback(async (operation, errorMessage) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const result = await operation();
+            return result ?? null;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(errorMessage);
+            setError(error);
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    const getNonce = useCallback(async (address) => {
+        return handleAsyncOperation(async () => {
+            const [error, response] = await client.nonce(address);
+            if (error) {
+                throw new Error(`Failed to get nonce: ${error.error}`);
+            }
+            return response;
+        }, 'Failed to fetch nonce');
+    }, [client, handleAsyncOperation]);
+    const authenticate = useCallback(async (auth) => {
+        return handleAsyncOperation(async () => {
+            const [error, response] = await client.authenticate(auth);
+            if (error) {
+                throw new Error(`Authentication failed: ${error.error}`);
+            }
+            return response;
+        }, 'Authentication failed');
+    }, [client, handleAsyncOperation]);
+    const getQuote = useCallback(async (quote) => {
+        return handleAsyncOperation(async () => {
+            const [error, response] = await client.quote(quote);
+            if (error) {
+                throw new Error(`Failed to get quote: ${error.error}`);
+            }
+            return response;
+        }, 'Failed to fetch quote');
+    }, [client, handleAsyncOperation]);
+    const createOrder = useCallback(async (order) => {
+        return handleAsyncOperation(async () => {
+            const [error, response] = await client.order(order);
+            if (error) {
+                throw new Error(`Failed to create order: ${error.error}`);
+            }
+            return response;
+        }, 'Failed to create order');
+    }, [client, handleAsyncOperation]);
+    return {
+        // State
+        isLoading,
+        error,
+        // Methods
+        getNonce,
+        authenticate,
+        getQuote,
+        createOrder,
+    };
+}

package/dist/hooks/silent/useSilentQuote.d.ts

@@ -0,0 +1,88 @@
+import type { SilentSwapClient, QuoteResponse, AssetInfo } from '@silentswap/sdk';
+import type { WalletClient } from 'viem';
+import type { Connector } from 'wagmi';
+import type { SolanaWalletConnector, SolanaConnection } from './solana-transaction.js';
+import { type SwapTransaction } from '../useTransaction.js';
+import type { SilentSwapWallet } from './useWallet.js';
+export type { SwapTransaction };
+export interface Destination {
+    asset: string;
+    contact: string;
+    amount: string;
+    priceUsd?: number;
+}
+/**
+ * Result of executing a swap
+ */
+export interface SwapResult {
+    orderId: string;
+    viewingAuth: string;
+    depositTransaction: SwapTransaction;
+    bridgeTransaction?: SwapTransaction;
+}
+/**
+ * Options for useSilentQuote hook
+ */
+export interface useSilentQuoteOptions {
+    /** EVM address */
+    evmAddress: `0x${string}` | string;
+    /** Solana address */
+    solAddress: string;
+    /** SilentSwap client instance */
+    client: SilentSwapClient;
+    /** User's address (EVM hex address or Solana base58 address) */
+    address: `0x${string}` | string;
+    /** Wallet client for signing operations */
+    walletClient?: WalletClient;
+    /** Wagmi connector */
+    connector?: Connector;
+    /** SilentSwap wallet instance */
+    wallet: SilentSwapWallet | null;
+    /** Whether wallet is currently being generated (to prevent swap execution before wallet is ready) */
+    walletLoading?: boolean;
+    /** Facilitator group for the swap, or a function that resolves it */
+    /** Status update callback */
+    onStatus?: (status: string) => void;
+    /** Solana wallet connector (required for Solana swaps) */
+    solanaConnector?: SolanaWalletConnector;
+    /** Solana RPC connection (required for Solana swaps) */
+    solanaConnection?: SolanaConnection;
+    /** Solana RPC URL (optional, will create connection if not provided) */
+    solanaRpcUrl?: string;
+    /** Get price function */
+    getPrice: (asset: AssetInfo) => Promise<number>;
+    setDestinations: (updater: Destination[] | ((prev: Destination[]) => Destination[])) => void;
+}
+/**
+ * Return type for useSilentQuote hook
+ */
+export interface useSilentQuoteReturn {
+    isLoading: boolean;
+    isSwapping: boolean;
+    currentStep: string;
+    quote: QuoteResponse | null;
+    error: Error | null;
+    orderId: string | null;
+    viewingAuth: string | null;
+    executeSwap: (params: ExecuteSwapParams) => Promise<SwapResult | null>;
+    clearQuote: () => void;
+    loadingAmounts: boolean;
+    depositAmountUsdc: number;
+}
+/**
+ * Parameters for executing a swap
+ * Simplified interface - quote fetching and calculations are handled internally
+ */
+export interface ExecuteSwapParams {
+    /** Source asset CAIP-19 identifier */
+    sourceAsset: string;
+    /** Source amount (in human-readable units, e.g., "1.5") */
+    sourceAmount: string;
+    /** Destinations array */
+    destinations: Destination[];
+    /** Splits array for destination amounts */
+    splits: number[];
+    /** Contact ID of the sender (e.g., "caip10:eip155:*:0x...") */
+    senderContactId: string;
+}
+export declare function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, getPrice, setDestinations, }: useSilentQuoteOptions): useSilentQuoteReturn;