@diviswap/sdk 1.7.6

package/src/cli/templates/nextjs-app/api-hooks.ts.hbs

@@ -0,0 +1,439 @@
+import { useState, useEffect, useCallback } from 'react';
+
+// Authentication context hook (implement based on your auth system)
+export function useAuth() {
+  // Replace this with your actual authentication logic
+  // This could be from a context provider, session storage, etc.
+  const [customerId, setCustomerId] = useState<string | null>(null);
+  const [customerEmail, setCustomerEmail] = useState<string | null>(null);
+  const [isAuthenticated, setIsAuthenticated] = useState(false);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    // Initialize auth state from your auth system
+    // Example: get from session, context, or other auth provider
+    const initAuth = async () => {
+      try {
+        // Your auth initialization logic here
+        // Example:
+        // const session = await getSession();
+        // if (session) {
+        //   setCustomerId(session.customerId);
+        //   setCustomerEmail(session.customerEmail);
+        //   setIsAuthenticated(true);
+        // }
+      } catch (error) {
+        console.error('Auth initialization failed:', error);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    initAuth();
+  }, []);
+
+  const setCustomer = useCallback(async (customerId: string, customerEmail: string) => {
+    try {
+      const response = await fetch('/api/diviswap', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ 
+          action: 'setCustomer', 
+          customerId, 
+          customerEmail 
+        })
+      });
+
+      if (response.ok) {
+        setCustomerId(customerId);
+        setCustomerEmail(customerEmail);
+        setIsAuthenticated(true);
+      }
+    } catch (error) {
+      console.error('Failed to set customer context:', error);
+    }
+  }, []);
+
+  const clearCustomer = useCallback(async () => {
+    try {
+      await fetch('/api/diviswap', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'clearCustomer' })
+      });
+
+      setCustomerId(null);
+      setCustomerEmail(null);
+      setIsAuthenticated(false);
+    } catch (error) {
+      console.error('Failed to clear customer context:', error);
+    }
+  }, []);
+
+  return {
+    customerId,
+    customerEmail,
+    isAuthenticated,
+    loading,
+    setCustomer,
+    clearCustomer
+  };
+}
+
+// Hook for managing transactions
+export function useTransactions() {
+  const { customerId, customerEmail, isAuthenticated } = useAuth();
+  const [transactions, setTransactions] = useState<any[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchTransactions = useCallback(async (filters?: {
+    limit?: number;
+    offset?: number;
+    status?: string;
+    type?: 'onramp' | 'offramp';
+  }) => {
+    if (!isAuthenticated || !customerId) return [];
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const queryParams = new URLSearchParams({
+        resource: 'transactions',
+        customerId,
+        customerEmail,
+        ...filters
+      });
+
+      const response = await fetch(`/api/diviswap?${queryParams}`);
+      if (!response.ok) throw new Error('Failed to fetch transactions');
+
+      const data = await response.json();
+      setTransactions(data);
+      return data;
+    } catch (err) {
+      const error = err as Error;
+      setError(error);
+      console.error('Failed to fetch transactions:', error);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  }, [customerId, customerEmail, isAuthenticated]);
+
+  const createTransaction = useCallback(async (data: any) => {
+    if (!isAuthenticated || !customerId) throw new Error('Not authenticated');
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch('/api/diviswap', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ 
+          action: 'createTransaction', 
+          customerId, 
+          customerEmail, 
+          ...data 
+        })
+      });
+
+      if (!response.ok) throw new Error('Failed to create transaction');
+
+      const transaction = await response.json();
+      // Refresh transactions list
+      await fetchTransactions();
+      return transaction;
+    } catch (err) {
+      const error = err as Error;
+      setError(error);
+      console.error('Failed to create transaction:', error);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  }, [customerId, customerEmail, isAuthenticated, fetchTransactions]);
+
+  return {
+    transactions,
+    loading,
+    error,
+    fetchTransactions,
+    createTransaction,
+    refresh: fetchTransactions,
+  };
+}
+
+// Hook for managing payees
+export function usePayees() {
+  const { customerId, customerEmail, isAuthenticated } = useAuth();
+  const [payees, setPayees] = useState<any[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchPayees = useCallback(async () => {
+    if (!isAuthenticated || !customerId) return [];
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch(`/api/diviswap?resource=payees&customerId=${customerId}&customerEmail=${customerEmail}`);
+      if (!response.ok) throw new Error('Failed to fetch payees');
+
+      const data = await response.json();
+      setPayees(data);
+      return data;
+    } catch (err) {
+      const error = err as Error;
+      setError(error);
+      console.error('Failed to fetch payees:', error);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  }, [customerId, customerEmail, isAuthenticated]);
+
+  const createPayee = useCallback(async (data: any) => {
+    if (!isAuthenticated || !customerId) throw new Error('Not authenticated');
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch('/api/diviswap', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ 
+          action: 'createPayee', 
+          customerId, 
+          customerEmail, 
+          ...data 
+        })
+      });
+
+      if (!response.ok) throw new Error('Failed to create payee');
+
+      const payee = await response.json();
+      // Refresh payees list
+      await fetchPayees();
+      return payee;
+    } catch (err) {
+      const error = err as Error;
+      setError(error);
+      console.error('Failed to create payee:', error);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  }, [customerId, customerEmail, isAuthenticated, fetchPayees]);
+
+  const deletePayee = useCallback(async (id: string) => {
+    if (!isAuthenticated || !customerId) throw new Error('Not authenticated');
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch(`/api/diviswap?resource=payee&id=${id}&customerId=${customerId}&customerEmail=${customerEmail}`, {
+        method: 'DELETE'
+      });
+
+      if (!response.ok) throw new Error('Failed to delete payee');
+
+      // Refresh payees list
+      await fetchPayees();
+    } catch (err) {
+      const error = err as Error;
+      setError(error);
+      console.error('Failed to delete payee:', error);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  }, [customerId, customerEmail, isAuthenticated, fetchPayees]);
+
+  // Auto-load payees when authenticated
+  useEffect(() => {
+    if (isAuthenticated && customerId) {
+      fetchPayees();
+    }
+  }, [isAuthenticated, customerId, fetchPayees]);
+
+  return {
+    payees,
+    loading,
+    error,
+    createPayee,
+    deletePayee,
+    refresh: fetchPayees,
+  };
+}
+
+// Hook for KYC status and submission
+export function useKYC() {
+  const { customerId, customerEmail, isAuthenticated } = useAuth();
+  const [kycStatus, setKycStatus] = useState<any>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchKYCStatus = useCallback(async () => {
+    if (!isAuthenticated || !customerId) return null;
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch(`/api/diviswap?resource=kycStatus&customerId=${customerId}&customerEmail=${customerEmail}`);
+      if (!response.ok) throw new Error('Failed to fetch KYC status');
+
+      const data = await response.json();
+      setKycStatus(data);
+      return data;
+    } catch (err) {
+      const error = err as Error;
+      setError(error);
+      console.error('Failed to fetch KYC status:', error);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  }, [customerId, customerEmail, isAuthenticated]);
+
+  const submitKYC = useCallback(async (kycData: any) => {
+    if (!isAuthenticated || !customerId) throw new Error('Not authenticated');
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch('/api/diviswap', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ 
+          action: 'submitKYC', 
+          customerId, 
+          customerEmail, 
+          ...kycData 
+        })
+      });
+
+      if (!response.ok) throw new Error('Failed to submit KYC');
+
+      const result = await response.json();
+      // Refresh KYC status
+      await fetchKYCStatus();
+      return result;
+    } catch (err) {
+      const error = err as Error;
+      setError(error);
+      console.error('Failed to submit KYC:', error);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  }, [customerId, customerEmail, isAuthenticated, fetchKYCStatus]);
+
+  // Auto-load KYC status when authenticated
+  useEffect(() => {
+    if (isAuthenticated && customerId) {
+      fetchKYCStatus();
+    }
+  }, [isAuthenticated, customerId, fetchKYCStatus]);
+
+  return {
+    kycStatus,
+    loading,
+    error,
+    submitKYC,
+    refresh: fetchKYCStatus,
+    isKycApproved: kycStatus?.kycStatus === 'APPROVED',
+    needsKyc: kycStatus?.requiresAction && kycStatus?.nextStep === 'COMPLETE_KYC'
+  };
+}
+
+{{#if (includes features "fees")}}
+// Hook for fee calculations
+export function useFeeCalculator() {
+  const { customerId, customerEmail, isAuthenticated } = useAuth();
+  const [fees, setFees] = useState<any>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const calculateFees = useCallback(async (amount: number) => {
+    if (!isAuthenticated || !customerId || amount <= 0) {
+      setFees(null);
+      return null;
+    }
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch('/api/diviswap', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ 
+          action: 'calculateFees', 
+          amount,
+          customerId, 
+          customerEmail
+        })
+      });
+
+      if (!response.ok) throw new Error('Failed to calculate fees');
+
+      const calculatedFees = await response.json();
+      setFees(calculatedFees);
+      return calculatedFees;
+    } catch (err) {
+      const error = err as Error;
+      setError(error);
+      setFees(null);
+      console.error('Failed to calculate fees:', error);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  }, [customerId, customerEmail, isAuthenticated]);
+
+  return {
+    fees,
+    loading,
+    error,
+    calculateFees,
+  };
+}
+{{/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,
+  };
+}