@silentswap/react 0.0.41

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

@@ -0,0 +1,34 @@
+import type { Hex, WalletClient } from 'viem';
+import type { Connector } from 'wagmi';
+import { type QuoteResponse, type OrderResponse, type HdFacilitatorGroup, type AuthorizationInstruction, type SilentSwapClient } from '@silentswap/sdk';
+/**
+ * Hook for signing SilentSwap orders and authorizations
+ *
+ * This hook handles the signing process for SilentSwap orders, including:
+ * - EIP-3009 deposit authorizations (for direct USDC deposits)
+ * - EIP-712 order signatures (for order creation)
+ * - Proxy authorization approvals (for facilitator operations)
+ *
+ * @param walletClient - Wallet client for signing operations
+ * @param connector - Wagmi connector for chain switching
+ * @param client - SilentSwap client instance
+ * @param setCurrentStep - Callback to set current step message
+ * @param onStatus - Optional status update callback
+ * @returns Functions for signing authorizations and orders
+ */
+export declare function useOrderSigning(walletClient: WalletClient | undefined, connector: Connector | undefined, client: SilentSwapClient, setCurrentStep: (step: string) => void, onStatus?: (status: string) => void): {
+    signAuthorizations: (authorizations: AuthorizationInstruction[], isDepositingDirectly: boolean) => Promise<Array<AuthorizationInstruction & {
+        signature: Hex;
+    }>>;
+    createOrder: (quoteResponse: QuoteResponse, signedAuths: Array<AuthorizationInstruction & {
+        signature: Hex;
+    }>, metadata: {
+        sourceAsset: {
+            caip19: string;
+            amount: `${bigint}`;
+        };
+        sourceSender: {
+            contactId: string;
+        };
+    }, overrideFacilitatorGroup?: HdFacilitatorGroup) => Promise<OrderResponse>;
+};

package/dist/hooks/silent/useOrderSigning.js

@@ -0,0 +1,133 @@
+import { useCallback } from 'react';
+import { quoteResponseToEip712Document, ensureChain, NI_CHAIN_ID_AVALANCHE, } from '@silentswap/sdk';
+/**
+ * Hook for signing SilentSwap orders and authorizations
+ *
+ * This hook handles the signing process for SilentSwap orders, including:
+ * - EIP-3009 deposit authorizations (for direct USDC deposits)
+ * - EIP-712 order signatures (for order creation)
+ * - Proxy authorization approvals (for facilitator operations)
+ *
+ * @param walletClient - Wallet client for signing operations
+ * @param connector - Wagmi connector for chain switching
+ * @param client - SilentSwap client instance
+ * @param setCurrentStep - Callback to set current step message
+ * @param onStatus - Optional status update callback
+ * @returns Functions for signing authorizations and orders
+ */
+export function useOrderSigning(walletClient, connector, client, setCurrentStep, onStatus) {
+    /**
+     * Sign authorizations for a quote
+     *
+     * Signs EIP-3009 deposit authorizations if depositing directly to USDC on Avalanche.
+     * For proxy deposits, returns empty signatures as the proxy will handle signing.
+     *
+     * @param authorizations - Array of authorization instructions from the quote
+     * @param isDepositingDirectly - Whether depositing directly to USDC on Avalanche
+     * @returns Promise resolving to signed authorizations
+     */
+    const signAuthorizations = useCallback(async (authorizations, isDepositingDirectly) => {
+        if (!walletClient) {
+            throw new Error('Wallet client required for signing');
+        }
+        setCurrentStep('Signing authorizations');
+        onStatus?.('Signing authorizations');
+        if (!connector) {
+            throw new Error('Connector required for chain switching');
+        }
+        await ensureChain(NI_CHAIN_ID_AVALANCHE, walletClient, connector);
+        return Promise.all(authorizations.map(async (auth) => ({
+            ...auth,
+            signature: await (async () => {
+                // EIP-3009 deposit authorization
+                if (auth.type === 'eip3009_deposit') {
+                    if (isDepositingDirectly) {
+                        // Sign EIP-712 typed data for direct deposit
+                        return await walletClient.signTypedData(auth.eip712);
+                    }
+                    else {
+                        // Will be deposited through proxy, no signature needed
+                        return '0x';
+                    }
+                }
+                throw new Error(`Authorization type not implemented: ${auth.type}`);
+            })(),
+        })));
+    }, [walletClient, connector, setCurrentStep, onStatus]);
+    /**
+     * Create and sign a SilentSwap order
+     *
+     * Creates an order by:
+     * 1. Signing the quote's EIP-712 document
+     * 2. Approving proxy authorizations from facilitators
+     * 3. Submitting the order to the SilentSwap API
+     *
+     * @param quoteResponse - Quote response from getQuote
+     * @param signedAuths - Signed authorization instructions
+     * @param metadata - Order metadata (source asset, sender contact ID)
+     * @param overrideFacilitatorGroup - Optional facilitator group to override the hook's group
+     * @returns Promise resolving to order response
+     */
+    const createOrder = useCallback(async (quoteResponse, signedAuths, metadata, overrideFacilitatorGroup) => {
+        if (!walletClient) {
+            throw new Error('Wallet client required for order creation');
+        }
+        if (!connector) {
+            throw new Error('Connector required for chain switching');
+        }
+        // Use override group if provided, otherwise use hook's group
+        const effectiveGroup = overrideFacilitatorGroup;
+        if (!effectiveGroup) {
+            throw new Error('Facilitator group required for order creation');
+        }
+        // Switch to Ethereum for order signing (orders are signed on Ethereum mainnet)
+        setCurrentStep('Preparing order signature');
+        onStatus?.('Preparing order signature');
+        await ensureChain(1, walletClient, connector); // Ethereum mainnet
+        // Create EIP-712 document for order
+        const orderDoc = quoteResponseToEip712Document(quoteResponse);
+        // Sign the order's EIP-712 document
+        // Note: viem's signTypedData may normalize the domain.chainId to match the wallet client's
+        // chain configuration, which can result in chainId being a BigInt instead of a number.
+        // This happens because viem uses the wallet's chain configuration internally.
+        const orderSignature = await walletClient.signTypedData({
+            ...orderDoc,
+            account: walletClient.account,
+        });
+        // Approve proxy authorizations from facilitators
+        const facilitatorReplies = await effectiveGroup.approveProxyAuthorizations(quoteResponse.facilitators, {
+            proxyPublicKey: client.proxyPublicKey,
+        });
+        setCurrentStep('Placing order');
+        onStatus?.('Placing order');
+        // Convert eip712Domain to serializable format (chainId BigInt -> number)
+        // Why: viem's signTypedData may normalize chainId to BigInt based on wallet client's chain config.
+        // JSON.stringify doesn't handle BigInt, so we need to convert it to a number.
+        // Note: chainId should be safe to convert to number (Ethereum chain IDs are small integers).
+        const domainChainId = orderDoc.domain.chainId;
+        const serializableDomain = {
+            ...orderDoc.domain,
+            chainId: typeof domainChainId === 'bigint'
+                ? Number(domainChainId)
+                : (domainChainId ?? 1), // Default to 1 (Ethereum mainnet) if undefined
+        };
+        // Create the order
+        const [orderError, orderResponse] = await client.order({
+            quote: quoteResponse.quote,
+            quoteId: quoteResponse.quoteId,
+            authorizations: signedAuths,
+            eip712Domain: serializableDomain,
+            signature: orderSignature,
+            facilitators: facilitatorReplies,
+            metadata,
+        });
+        if (orderError || !orderResponse) {
+            throw new Error(`Failed to create order: ${orderError?.error}`);
+        }
+        return orderResponse;
+    }, [walletClient, connector, client, setCurrentStep, onStatus]);
+    return {
+        signAuthorizations,
+        createOrder,
+    };
+}

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

@@ -0,0 +1,174 @@
+import type { SilentSwapClient } from '@silentswap/sdk';
+/**
+ * Output stage enum matching Svelte's OutputStage (string values)
+ */
+export declare enum OutputStage {
+    NONE = "NONE",
+    INIT = "INIT",
+    FUNDED = "FUNDED",
+    REDEEMED = "REDEEMED",
+    IBC_SENT = "IBC_SENT",
+    IBC_RCVD = "IBC_RCVD",
+    BRIDGE_SENT = "BRIDGE_SENT",
+    BRIDGE_CFRM = "BRIDGE_CFRM",
+    BRIDGE_RCVD = "BRIDGE_RCVD",
+    SWAP_USDC_GAS = "SWAP_USDC_GAS",
+    SWAP_USDC_TRG = "SWAP_USDC_TRG",
+    LTRL_TRG_SENT = "LTRL_TRG_SENT",
+    LTRL_TRG_RCVD = "LTRL_TRG_RCVD",
+    SWAP_TRG_DST = "SWAP_TRG_DST",
+    XFER_TRG_DST = "XFER_TRG_DST",
+    REFUND_NATIVE = "REFUND_NATIVE",
+    FINALIZED = "FINALIZED"
+}
+/**
+ * Deposit information
+ */
+export type OrderDeposit = {
+    amount: string;
+    timestamp: number;
+    duration: number;
+    orderId?: string;
+    tx?: string;
+};
+/**
+ * Output status information
+ */
+export type OutputStatus = {
+    index: number;
+    stage: OutputStage;
+    timestamp: number;
+    recipient?: string;
+    asset?: {
+        caip19: string;
+        amount: string;
+        decimals: number;
+        priceUsd?: number;
+    };
+    txs?: OrderTransactions;
+};
+/**
+ * Order transactions
+ */
+export type OrderTransactions = {
+    RECEIPT?: {
+        chain: string;
+        txId: string;
+    };
+    REFUND?: {
+        chain: string;
+        txId: string;
+    };
+};
+/**
+ * Order tracking status (matches Svelte's OrderStatus)
+ */
+export type OrderStatus = {
+    priority?: string;
+    signer: string;
+    deposit: OrderDeposit;
+    outputs: Array<{
+        stage: OutputStage;
+        timestamp: number;
+        asset: string;
+        value: string;
+        recipient: string;
+        txs?: OrderTransactions;
+        output?: {
+            caip19: string;
+            amount: string;
+            decimals: number;
+            priceUsd?: number;
+        };
+    }>;
+    metadata?: {
+        sourceAsset?: {
+            caip19: string;
+            amount: string;
+        };
+        sourceSender?: {
+            contactId: string;
+        };
+    };
+};
+/**
+ * Status update types (matches Svelte's StatusUpdate)
+ */
+export type StatusUpdate = {
+    type: 'deposit';
+    data: OrderDeposit;
+} | {
+    type: 'stage';
+    data: {
+        orderId: string;
+        index: number;
+        stage: OutputStage;
+        timestamp: number;
+        asset?: {
+            caip19: string;
+            amount: string;
+            decimals: number;
+            priceUsd?: number;
+        };
+    };
+} | {
+    type: 'transaction';
+    data: {
+        orderId: string;
+        index: number;
+        chain: string;
+        txId: string;
+        kind: keyof OrderTransactions;
+    };
+} | {
+    type: 'error';
+    data: {
+        orderId: string;
+        message: string;
+        index?: number;
+    };
+};
+/**
+ * JSON-RPC error type
+ */
+export type JsonRpcError = {
+    code: number;
+    message: string;
+    data?: unknown;
+};
+export interface UseOrderTrackingOptions {
+    client?: SilentSwapClient;
+    orderId?: string;
+    viewingAuth?: string;
+    onStatusUpdate?: (status: OrderStatus) => void;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+}
+export interface UseOrderTrackingReturn {
+    isConnected: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    orderStatus: OrderStatus | null;
+    deposit: OrderDeposit | null;
+    outputs: OutputStatus[];
+    progresses: (number | undefined)[];
+    statusTexts: string[];
+    completedTimestamp: number | null;
+    isComplete: boolean;
+    connect: (orderId: string, auth: string) => void;
+    disconnect: () => void;
+    getStatusText: (stage: OutputStage) => string;
+    getProgress: (stage: OutputStage) => number;
+}
+/**
+ * Get human-readable status text from output stage
+ */
+export declare function getStatusTextFromStage(stage: OutputStage): string;
+/**
+ * Get progress value (0-1) from output stage
+ */
+export declare function getProgressFromStage(stage: OutputStage): number;
+/**
+ * React hook for tracking SilentSwap orders via WebSocket
+ */
+export declare function useOrderTracking({ client, orderId: initialOrderId, viewingAuth: initialAuth, onStatusUpdate, onError, onComplete, }?: UseOrderTrackingOptions): UseOrderTrackingReturn;