@diviswap/sdk 1.7.6

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

@@ -0,0 +1,259 @@
+'use server';
+
+import { Diviswap } from '@diviswap/sdk';
+import type { Transaction, Payee } from '@diviswap/sdk';
+import { revalidatePath } from 'next/cache';
+import { cookies } from 'next/headers';
+
+// Initialize Diviswap SDK
+function getDiviswap() {
+  return Diviswap.init({
+    apiKey: process.env.DIVISWAP_API_KEY!,
+    clientId: process.env.DIVISWAP_CLIENT_ID!,
+    environment: (process.env.NEXT_PUBLIC_DIVISWAP_ENV as 'production' | 'sandbox') || 'production',
+    debug: true // Enable debug logging
+  });
+}
+
+// Helper to get session token from cookies
+async function getSessionToken() {
+  const cookieStore = await cookies();
+  const session = cookieStore.get('diviswap_session');
+  return session?.value;
+}
+
+// Transaction Server Actions
+export async function createTransactionAction(data: {
+  type: 'onramp' | 'offramp';
+  amount: number;
+  currency?: string;
+  payeeId?: string;
+  paymentMethodId?: string;
+  // Required for offramp
+  fromAddress?: string;
+  chain?: string;
+}) {
+  try {
+    const sessionToken = await getSessionToken();
+    if (!sessionToken) {
+      return { success: false, error: 'Not authenticated' };
+    }
+
+    const diviswap = getDiviswap();
+    
+    // Use the appropriate method based on transaction type
+    let transaction;
+    if (data.type === 'onramp') {
+      // Note: Onramp is not yet available in v1 API
+      return { success: false, error: 'Onramp transactions are not yet available' };
+    } else {
+      transaction = await diviswap.transactions.offramp({
+        amount: data.amount,
+        currency: data.currency || 'USD',
+        payeeId: data.payeeId!,
+        fromAddress: data.fromAddress!, // Required for offramp
+        chain: data.chain || 'ethereum'
+      });
+    }
+    
+    revalidatePath('/diviswap');
+    return { success: true, transaction };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Transaction creation failed' 
+    };
+  }
+}
+
+export async function getTransactionsAction(filters?: {
+  limit?: number;
+  offset?: number;
+  status?: 'pending' | 'processing' | 'completed' | 'failed';
+  type?: 'onramp' | 'offramp';
+}) {
+  try {
+    const sessionToken = await getSessionToken();
+    if (!sessionToken) {
+      return { success: false, error: 'Not authenticated' };
+    }
+
+    const diviswap = getDiviswap();
+    const transactions = await diviswap.transactions.list(filters);
+    
+    return { success: true, transactions };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Failed to fetch transactions' 
+    };
+  }
+}
+
+// Payee Server Actions
+export async function getPayeesAction() {
+  try {
+    const sessionToken = await getSessionToken();
+    if (!sessionToken) {
+      return { success: false, error: 'Not authenticated' };
+    }
+
+    const diviswap = getDiviswap();
+    const payees = await diviswap.payees.list();
+    
+    return { success: true, payees };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Failed to fetch payees' 
+    };
+  }
+}
+
+export async function createPayeeAction(data: {
+  nickname: string;
+  accountNumber: string;
+  routingNumber: string;
+  accountType: 'checking' | 'savings';
+}) {
+  try {
+    const sessionToken = await getSessionToken();
+    if (!sessionToken) {
+      return { success: false, error: 'Not authenticated' };
+    }
+
+    const diviswap = getDiviswap();
+    const payee = await diviswap.payees.create({
+      nickname: data.nickname,
+      accountNumber: data.accountNumber,
+      routingNumber: data.routingNumber,
+      accountType: data.accountType,
+      setAsDefault: false
+    });
+    
+    revalidatePath('/diviswap');
+    return { success: true, payee };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Payee creation failed' 
+    };
+  }
+}
+
+export async function deletePayeeAction(payeeId: string) {
+  try {
+    const sessionToken = await getSessionToken();
+    if (!sessionToken) {
+      return { success: false, error: 'Not authenticated' };
+    }
+
+    const diviswap = getDiviswap();
+    await diviswap.payees.delete(payeeId);
+    
+    revalidatePath('/diviswap');
+    return { success: true };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Failed to delete payee' 
+    };
+  }
+}
+
+{{#if (includes features "fees")}}
+// Fee Calculation Server Actions
+export async function calculateFeesAction(data: {
+  amount: number;
+  type: 'onramp' | 'offramp';
+  currency?: string;
+}) {
+  try {
+    const diviswap = getDiviswap();
+    const fees = await diviswap.fees.calculateFees({
+      amount: data.amount,
+      userId: undefined // Optional: for per-user fees
+    });
+    
+    return { success: true, fees };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Fee calculation failed' 
+    };
+  }
+}
+
+export async function getIntegratorFeesAction() {
+  try {
+    const sessionToken = await getSessionToken();
+    if (!sessionToken) {
+      return { success: false, error: 'Not authenticated' };
+    }
+
+    const diviswap = getDiviswap();
+    const fees = await diviswap.fees.getFees();
+    
+    return { success: true, fees };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Failed to fetch integrator fees' 
+    };
+  }
+}
+
+export async function updateIntegratorFeeAction(data: {
+  percentage: number;
+  userId?: string;
+}) {
+  try {
+    const sessionToken = await getSessionToken();
+    if (!sessionToken) {
+      return { success: false, error: 'Not authenticated' };
+    }
+
+    const diviswap = getDiviswap();
+    const fee = await diviswap.fees.setFee(data);
+    
+    revalidatePath('/diviswap');
+    return { success: true, fee };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Failed to update fee' 
+    };
+  }
+}
+{{/if}}
+
+// Authentication Server Actions (for server components that need auth status)
+export async function getCurrentUserAction() {
+  try {
+    const sessionToken = await getSessionToken();
+    if (!sessionToken) {
+      return { success: false, user: null };
+    }
+
+    const diviswap = getDiviswap();
+    const user = await diviswap.auth.getProfile();
+    
+    return { success: true, user };
+  } catch (error) {
+    return { success: false, user: null };
+  }
+}
+
+// Utility action for checking API status
+export async function checkApiStatusAction() {
+  try {
+    const diviswap = getDiviswap();
+    // Note: Health check endpoint not available in SDK
+    return { success: true, status: 'OK' };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'API health check failed' 
+    };
+  }
+}

package/dist/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,
+  };
+}