@diviswap/sdk 1.7.6

package/dist/cli/templates/nextjs-app/hooks.ts.hbs

@@ -0,0 +1,252 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useDiviswap } from '{{providerImportPath}}';
+import type { Transaction, Payee, TransactionStatus } from '{{typesImportPath}}';
+
+// IMPORTANT: These hooks use direct SDK calls which may not work properly 
+// with partner authentication. For partner authentication, use the API route 
+// pattern demonstrated in api-hooks.ts instead.
+
+// Re-export the main hook
+export { useDiviswap };
+
+// Convenience hook for authentication
+export function useAuth() {
+  const { user, login, logout, register, loading, error } = useDiviswap();
+  
+  return {
+    user,
+    login,
+    logout,
+    register,
+    loading,
+    error,
+    isAuthenticated: !!user,
+    isLoading: loading,
+  };
+}
+
+// Hook for managing transactions
+export function useTransactions() {
+  const { createTransaction, getTransactions, error } = useDiviswap();
+  const [transactions, setTransactions] = useState<Transaction[]>([]);
+  const [loading, setLoading] = useState(false);
+  
+  const fetchTransactions = useCallback(async (filters?: {
+    limit?: number;
+    offset?: number;
+    status?: TransactionStatus;
+    type?: 'onramp' | 'offramp';
+  }) => {
+    setLoading(true);
+    try {
+      const data = await getTransactions(filters);
+      setTransactions(data);
+      return data;
+    } catch (err) {
+      console.error('Failed to fetch transactions:', err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [getTransactions]);
+  
+  const create = useCallback(async (data: any) => {
+    setLoading(true);
+    try {
+      const transaction = await createTransaction(data);
+      // Refresh transactions list
+      await fetchTransactions();
+      return transaction;
+    } catch (err) {
+      console.error('Failed to create transaction:', err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [createTransaction, fetchTransactions]);
+  
+  return {
+    transactions,
+    loading,
+    error,
+    create,
+    refresh: fetchTransactions,
+  };
+}
+
+// Hook for managing payees
+export function usePayees() {
+  const { getPayees, createPayee, deletePayee, error } = useDiviswap();
+  const [payees, setPayees] = useState<Payee[]>([]);
+  const [loading, setLoading] = useState(false);
+  
+  const fetchPayees = useCallback(async () => {
+    setLoading(true);
+    try {
+      const data = await getPayees();
+      setPayees(data);
+      return data;
+    } catch (err) {
+      console.error('Failed to fetch payees:', err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [getPayees]);
+  
+  const create = useCallback(async (data: any) => {
+    setLoading(true);
+    try {
+      const payee = await createPayee(data);
+      // Refresh payees list
+      await fetchPayees();
+      return payee;
+    } catch (err) {
+      console.error('Failed to create payee:', err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [createPayee, fetchPayees]);
+  
+  const remove = useCallback(async (id: string) => {
+    setLoading(true);
+    try {
+      await deletePayee(id);
+      // Refresh payees list
+      await fetchPayees();
+    } catch (err) {
+      console.error('Failed to delete payee:', err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [deletePayee, fetchPayees]);
+  
+  // Auto-load payees on mount
+  useEffect(() => {
+    fetchPayees();
+  }, [fetchPayees]);
+  
+  return {
+    payees,
+    loading,
+    error,
+    create,
+    remove,
+    refresh: fetchPayees,
+  };
+}
+
+{{#if (includes features "fees")}}
+// Hook for fee calculations
+export function useFeeCalculator() {
+  const { calculateFees } = useDiviswap();
+  const [fees, setFees] = useState<any>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  
+  const calculate = useCallback(async (
+    amount: number,
+    type: 'onramp' | 'offramp',
+    currency: string = 'USD'
+  ) => {
+    if (amount <= 0) {
+      setFees(null);
+      return null;
+    }
+    
+    setLoading(true);
+    setError(null);
+    
+    try {
+      const calculatedFees = await calculateFees(amount, type, currency);
+      setFees(calculatedFees);
+      return calculatedFees;
+    } catch (err) {
+      setError(err as Error);
+      setFees(null);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [calculateFees]);
+  
+  return {
+    fees,
+    loading,
+    error,
+    calculate,
+  };
+}
+{{/if}}
+
+{{#if (includes features "realtime")}}
+// Hook for real-time transaction updates
+export function useTransactionUpdates(transactionId?: string) {
+  const { socket, subscribeToTransaction, unsubscribeFromTransaction } = useDiviswap();
+  const [updates, setUpdates] = useState<any[]>([]);
+  const [latestStatus, setLatestStatus] = useState<TransactionStatus | null>(null);
+  
+  useEffect(() => {
+    if (!socket || !transactionId) return;
+    
+    // Subscribe to updates
+    subscribeToTransaction(transactionId);
+    
+    // Listen for updates
+    const handleUpdate = (data: any) => {
+      if (data.transactionId === transactionId) {
+        setUpdates(prev => [...prev, data]);
+        if (data.status) {
+          setLatestStatus(data.status);
+        }
+      }
+    };
+    
+    socket.on('transaction:update', handleUpdate);
+    
+    // Cleanup
+    return () => {
+      unsubscribeFromTransaction(transactionId);
+      socket.off('transaction:update', handleUpdate);
+    };
+  }, [socket, transactionId, subscribeToTransaction, unsubscribeFromTransaction]);
+  
+  return {
+    updates,
+    latestStatus,
+    isConnected: !!socket?.connected,
+  };
+}
+{{/if}}
+
+// Hook for handling async operations with loading states
+export function useAsyncOperation<T extends (...args: any[]) => Promise<any>>() {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  
+  const execute = useCallback(async <TResult>(
+    operation: T,
+    ...args: Parameters<T>
+  ): Promise<TResult | undefined> => {
+    setLoading(true);
+    setError(null);
+    
+    try {
+      const result = await operation(...args);
+      return result as TResult;
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  
+  return {
+    loading,
+    error,
+    execute,
+  };
+}

package/dist/cli/templates/nextjs-app/kyc-hooks.ts.hbs

@@ -0,0 +1,87 @@
+"use client";
+
+import { useState } from 'react';
+import { use{{prefix}}Auth } from '~/context/diviswap-auth-context';
+
+interface KYCFormData {
+  firstName: string;
+  lastName: string;
+  email: string;
+  dobYear: string;
+  dobMonth: string;
+  dobDay: string;
+  idType: 'ssn' | 'tin' | 'passport';
+  idNumber: string;
+  addressLine1: string;
+  addressLine2?: string;
+  city: string;
+  state: string;
+  postalCode: string;
+  country: string;
+}
+
+export function use{{prefix}}KYC() {
+  const { customerId, customerEmail } = use{{prefix}}Auth();
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  
+  const submitKYC = async (formData: KYCFormData) => {
+    setIsSubmitting(true);
+    
+    try {
+      // Format date of birth
+      const dateOfBirth = `${formData.dobYear}-${formData.dobMonth.padStart(2, '0')}-${formData.dobDay.padStart(2, '0')}`;
+      
+      // Prepare KYC data
+      const kycData = {
+        personalInfo: {
+          firstName: formData.firstName,
+          lastName: formData.lastName,
+          email: formData.email,
+          dateOfBirth,
+          ssn: formData.idType === 'ssn' ? formData.idNumber.replace(/-/g, '') : undefined,
+          tin: formData.idType === 'tin' ? formData.idNumber : undefined,
+          passport: formData.idType === 'passport' ? formData.idNumber : undefined,
+        },
+        address: {
+          addressLine1: formData.addressLine1,
+          addressLine2: formData.addressLine2,
+          city: formData.city,
+          state: formData.state,
+          postalCode: formData.postalCode,
+          country: formData.country,
+        }
+      };
+      
+      // Call API to submit KYC
+      const response = await fetch('/api/diviswap', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ 
+          action: 'submitKYC',
+          customerId,
+          customerEmail,
+          ...kycData 
+        }),
+      });
+      
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error || 'KYC submission failed');
+      }
+      
+      const result = await response.json();
+      return result;
+      
+    } catch (error: any) {
+      console.error('KYC submission error:', error);
+      throw error;
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  
+  return {
+    submitKYC,
+    isSubmitting
+  };
+}