@diviswap/sdk 1.7.6

package/src/cli/templates/nextjs-app/layout-wrapper.tsx.hbs

@@ -0,0 +1,13 @@
+import { DiviswapProvider } from '@diviswap/sdk/react';
+
+export default function DiviswapLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <DiviswapProvider>
+      {children}
+    </DiviswapProvider>
+  );
+}

package/src/cli/templates/nextjs-app/layout.tsx.hbs

@@ -0,0 +1,13 @@
+import { DiviswapProvider } from './lbx-provider';
+
+export default function DiviswapLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <DiviswapProvider>
+      {children}
+    </DiviswapProvider>
+  );
+}

package/src/cli/templates/nextjs-app/middleware.ts.hbs

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+// This middleware adds Diviswap session information to requests
+// Note: In middleware, we use request.cookies (not the async cookies() from next/headers)
+export function diviswapMiddleware(request: NextRequest) {
+  // Check for Diviswap session cookie
+  const diviswapSession = request.cookies.get('diviswap_session');
+
+  if (!diviswapSession) {
+    // No session, proceed without authentication
+    return NextResponse.next();
+  }
+
+  // Add session to headers for API routes
+  const requestHeaders = new Headers(request.headers);
+  requestHeaders.set('x-diviswap-session', diviswapSession.value);
+
+  // You can also add other headers or perform additional checks here
+  requestHeaders.set('x-diviswap-client-version', '1.0.0');
+
+  return NextResponse.next({
+    request: {
+      headers: requestHeaders,
+    },
+  });
+}
+
+// Optional: Add route protection
+export function protectDiviswapRoutes(request: NextRequest) {
+  const diviswapSession = request.cookies.get('diviswap_session');
+  
+  // List of protected routes
+  const protectedRoutes = [
+    '/diviswap/dashboard',
+    '/diviswap/transactions',
+    '/diviswap/settings'
+  ];
+
+  const isProtectedRoute = protectedRoutes.some(route => 
+    request.nextUrl.pathname.startsWith(route)
+  );
+
+  if (isProtectedRoute && !diviswapSession) {
+    // Redirect to login page
+    return NextResponse.redirect(new URL('/diviswap', request.url));
+  }
+
+  return diviswapMiddleware(request);
+}

package/src/cli/templates/nextjs-app/provider-wrapper.tsx.hbs

@@ -0,0 +1,8 @@
+'use client';
+
+import { DiviswapProvider } from '@diviswap/sdk/react';
+
+// Wrapper to ensure client-side rendering for Diviswap components
+export function DiviswapClientProvider({ children }: { children: React.ReactNode }) {
+  return <DiviswapProvider>{children}</DiviswapProvider>;
+}

package/src/cli/templates/nextjs-app/provider.tsx.hbs

@@ -0,0 +1,408 @@
+'use client';
+
+import React, { createContext, useContext, useEffect, useState, useCallback } from 'react';
+import type { User, Transaction, Payee, TransactionStatus } from './lbx-types';
+{{#if (includes features "realtime")}}
+import io, { Socket } from 'socket.io-client';
+{{/if}}
+
+interface DiviswapContextValue {
+  // Customer state (for partner authentication)
+  customerId: string | null;
+  customerEmail: string | null;
+  loading: boolean;
+  error: Error | null;
+  
+  // Customer context methods
+  setCustomer: (customerId: string, customerEmail: string) => Promise<void>;
+  clearCustomer: () => Promise<void>;
+  getCustomerStatus: () => Promise<any>;
+  
+  // Transaction methods
+  createTransaction: (data: {
+    type: 'onramp' | 'offramp';
+    amount: number;
+    currency?: string;
+    payeeId?: string;
+    paymentMethodId?: string;
+  }) => Promise<Transaction>;
+  getTransactions: (filters?: {
+    limit?: number;
+    offset?: number;
+    status?: TransactionStatus;
+    type?: 'onramp' | 'offramp';
+  }) => Promise<Transaction[]>;
+  getTransaction: (id: string) => Promise<Transaction>;
+  
+  // Payee methods
+  getPayees: () => Promise<Payee[]>;
+  createPayee: (data: {
+    nickname: string;
+    network: string;
+    address: string;
+    type: 'crypto' | 'bank';
+  }) => Promise<Payee>;
+  deletePayee: (id: string) => Promise<void>;
+  
+{{#if (includes features "fees")}}
+  // Fee calculation
+  calculateFees: (amount: number, type: 'onramp' | 'offramp', currency?: string) => Promise<{
+    baseFee: number;
+    networkFee: number;
+    integratorFee?: number;
+    totalFee: number;
+    finalAmount: number;
+  }>;
+{{/if}}
+  
+{{#if (includes features "realtime")}}
+  // Real-time updates
+  socket: Socket | null;
+  subscribeToTransaction: (transactionId: string) => void;
+  unsubscribeFromTransaction: (transactionId: string) => void;
+{{/if}}
+}
+
+const DiviswapContext = createContext<DiviswapContextValue | null>(null);
+
+// API client class
+class DiviswapClient {
+  constructor(private baseUrl: string = '/api/diviswap') {}
+
+  private async request<T = any>(
+    endpoint: string,
+    options: RequestInit = {}
+  ): Promise<T> {
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: 'Request failed' }));
+      throw new Error(error.error || error.message || 'Request failed');
+    }
+
+    return response.json();
+  }
+
+  // Customer context methods
+  async setCustomer(customerId: string, customerEmail: string) {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'setCustomer', customerId, customerEmail }),
+    });
+  }
+
+  async clearCustomer() {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'clearCustomer' }),
+    });
+  }
+
+  async getCustomerStatus(customerId: string, customerEmail: string) {
+    try {
+      return await this.request(`?resource=customerStatus&customerId=${encodeURIComponent(customerId)}&customerEmail=${encodeURIComponent(customerEmail)}`);
+    } catch {
+      return null;
+    }
+  }
+
+  // Transaction methods
+  async createTransaction(data: any) {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'createTransaction', ...data }),
+    });
+  }
+
+  async getTransactions(customerId: string, customerEmail: string, params?: any) {
+    const searchParams = new URLSearchParams({
+      resource: 'transactions',
+      customerId,
+      customerEmail,
+      ...(params && {
+        limit: params.limit?.toString() || '10',
+        offset: params.offset?.toString() || '0',
+        ...(params.status && { status: params.status }),
+        ...(params.type && { type: params.type }),
+      }),
+    });
+    return this.request(`?${searchParams}`);
+  }
+
+  async getTransaction(id: string) {
+    return this.request(`?resource=transaction&id=${id}`);
+  }
+
+  // Payee methods
+  async getPayees(customerId: string, customerEmail: string) {
+    return this.request(`?resource=payees&customerId=${encodeURIComponent(customerId)}&customerEmail=${encodeURIComponent(customerEmail)}`);
+  }
+
+  async createPayee(data: any) {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'createPayee', ...data }),
+    });
+  }
+
+  async deletePayee(id: string, customerId: string, customerEmail: string) {
+    return this.request(`?resource=payee&id=${id}&customerId=${encodeURIComponent(customerId)}&customerEmail=${encodeURIComponent(customerEmail)}`, {
+      method: 'DELETE',
+    });
+  }
+
+{{#if (includes features "fees")}}
+  // Fee methods
+  async calculateFees(data: { amount: number; type: 'onramp' | 'offramp'; currency?: string }) {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'calculateFees', ...data }),
+    });
+  }
+{{/if}}
+}
+
+export function DiviswapProvider({ children }: { children: React.ReactNode }) {
+  const [customerId, setCustomerId] = useState<string | null>(null);
+  const [customerEmail, setCustomerEmail] = useState<string | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+{{#if (includes features "realtime")}}
+  const [socket, setSocket] = useState<Socket | null>(null);
+{{/if}}
+
+  const client = new DiviswapClient('/api/diviswap');
+
+  // Initialize with demo customer for development
+  useEffect(() => {
+    // In production, you would get customer context from your authentication system
+    // For demo purposes, we'll use placeholder values
+    setCustomerId('demo-customer-123');
+    setCustomerEmail('demo@yourapp.com');
+  }, []);
+
+{{#if (includes features "realtime")}}
+  // Initialize WebSocket connection when customer is set
+  useEffect(() => {
+    if (customerId && customerEmail) {
+      const socketInstance = io(
+        process.env.NEXT_PUBLIC_DIVISWAP_WS_URL || 'wss://ws.diviswap.io',
+        {
+          auth: {
+            customerId,
+            customerEmail
+          },
+          reconnection: true,
+          reconnectionAttempts: 5,
+          reconnectionDelay: 1000,
+        }
+      );
+
+      socketInstance.on('connect', () => {
+        console.log('Connected to Diviswap WebSocket');
+      });
+
+      socketInstance.on('disconnect', () => {
+        console.log('Disconnected from Diviswap WebSocket');
+      });
+
+      socketInstance.on('transaction:update', (data) => {
+        console.log('Transaction update:', data);
+        // You can emit custom events or update local state here
+      });
+
+      setSocket(socketInstance);
+
+      return () => {
+        socketInstance.disconnect();
+      };
+    }
+  }, [customerId, customerEmail]);
+{{/if}}
+
+  const setCustomer = useCallback(async (newCustomerId: string, newCustomerEmail: string) => {
+    try {
+      setError(null);
+      setLoading(true);
+      await client.setCustomer(newCustomerId, newCustomerEmail);
+      setCustomerId(newCustomerId);
+      setCustomerEmail(newCustomerEmail);
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  const clearCustomer = useCallback(async () => {
+    try {
+      setError(null);
+      setLoading(true);
+      await client.clearCustomer();
+      setCustomerId(null);
+      setCustomerEmail(null);
+{{#if (includes features "realtime")}}
+      socket?.disconnect();
+      setSocket(null);
+{{/if}}
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [{{#if (includes features "realtime")}}socket{{/if}}]);
+
+  const getCustomerStatus = useCallback(async () => {
+    if (!customerId || !customerEmail) {
+      throw new Error('Customer context not set');
+    }
+    try {
+      setError(null);
+      return await client.getCustomerStatus(customerId, customerEmail);
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    }
+  }, [customerId, customerEmail]);
+
+  const createTransaction = useCallback(async (data: any) => {
+    try {
+      setError(null);
+      return await client.createTransaction(data);
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    }
+  }, []);
+
+  const getTransactions = useCallback(async (filters?: any) => {
+    if (!customerId || !customerEmail) {
+      throw new Error('Customer context not set');
+    }
+    try {
+      setError(null);
+      return await client.getTransactions(customerId, customerEmail, filters);
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    }
+  }, [customerId, customerEmail]);
+
+  const getTransaction = useCallback(async (id: string) => {
+    try {
+      setError(null);
+      return await client.getTransaction(id);
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    }
+  }, []);
+
+  const getPayees = useCallback(async () => {
+    if (!customerId || !customerEmail) {
+      throw new Error('Customer context not set');
+    }
+    try {
+      setError(null);
+      return await client.getPayees(customerId, customerEmail);
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    }
+  }, [customerId, customerEmail]);
+
+  const createPayee = useCallback(async (data: any) => {
+    try {
+      setError(null);
+      return await client.createPayee(data);
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    }
+  }, []);
+
+  const deletePayee = useCallback(async (id: string) => {
+    if (!customerId || !customerEmail) {
+      throw new Error('Customer context not set');
+    }
+    try {
+      setError(null);
+      await client.deletePayee(id, customerId, customerEmail);
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    }
+  }, [customerId, customerEmail]);
+
+{{#if (includes features "fees")}}
+  const calculateFees = useCallback(async (
+    amount: number,
+    type: 'onramp' | 'offramp',
+    currency: string = 'USD'
+  ) => {
+    try {
+      setError(null);
+      return await client.calculateFees({ amount, type, currency });
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    }
+  }, []);
+{{/if}}
+
+{{#if (includes features "realtime")}}
+  const subscribeToTransaction = useCallback((transactionId: string) => {
+    socket?.emit('subscribe:transaction', transactionId);
+  }, [socket]);
+
+  const unsubscribeFromTransaction = useCallback((transactionId: string) => {
+    socket?.emit('unsubscribe:transaction', transactionId);
+  }, [socket]);
+{{/if}}
+
+  const value: DiviswapContextValue = {
+    customerId,
+    customerEmail,
+    loading,
+    error,
+    setCustomer,
+    clearCustomer,
+    getCustomerStatus,
+    createTransaction,
+    getTransactions,
+    getTransaction,
+    getPayees,
+    createPayee,
+    deletePayee,
+{{#if (includes features "fees")}}
+    calculateFees,
+{{/if}}
+{{#if (includes features "realtime")}}
+    socket,
+    subscribeToTransaction,
+    unsubscribeFromTransaction,
+{{/if}}
+  };
+
+  return (
+    <DiviswapContext.Provider value={value}>
+      {children}
+    </DiviswapContext.Provider>
+  );
+}
+
+export function useDiviswap() {
+  const context = useContext(DiviswapContext);
+  if (!context) {
+    throw new Error('useDiviswap must be used within a DiviswapProvider');
+  }
+  return context;
+}

package/src/cli/templates/nextjs-app/setup-provider.tsx.hbs

@@ -0,0 +1,25 @@
+/**
+ * Add this to your root layout.tsx to enable Diviswap functionality
+ * 
+ * Example:
+ * 
+ * import { DiviswapProvider } from '@diviswap/sdk/react';
+ * 
+ * export default function RootLayout({
+ *   children,
+ * }: {
+ *   children: React.ReactNode;
+ * }) {
+ *   return (
+ *     <html lang="en">
+ *       <body>
+ *         <DiviswapProvider>
+ *           {children}
+ *         </DiviswapProvider>
+ *       </body>
+ *     </html>
+ *   );
+ * }
+ */
+
+// This file is for reference only - please add the provider to your root layout

package/src/cli/templates/nextjs-app/types.ts.hbs

@@ -0,0 +1,159 @@
+export interface User {
+  id: string;
+  email: string;
+  firstName?: string;
+  lastName?: string;
+  accessToken?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  kycStatus?: 'pending' | 'approved' | 'rejected';
+}
+
+export interface Payee {
+  id: string;
+  nickname: string;
+  network: string;
+  address: string;
+  type: 'crypto' | 'bank';
+  isDefault?: boolean;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export type TransactionStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+export type TransactionType = 'onramp' | 'offramp';
+
+export interface Transaction {
+  id: string;
+  type: TransactionType;
+  status: TransactionStatus;
+  amount: number;
+  currency: string;
+  payeeId?: string;
+  paymentMethodId?: string;
+  fees?: TransactionFees;
+  metadata?: Record<string, any>;
+  createdAt: string;
+  updatedAt: string;
+  completedAt?: string;
+  failureReason?: string;
+}
+
+export interface TransactionFees {
+  baseFee: number;
+  networkFee: number;
+  integratorFee?: number;
+  totalFee: number;
+  currency: string;
+}
+
+export interface PaymentMethod {
+  id: string;
+  type: 'bank_account' | 'debit_card' | 'credit_card' | 'wire_transfer';
+  last4?: string;
+  bankName?: string;
+  isDefault?: boolean;
+  createdAt: string;
+}
+
+{{#if (includes features "fees")}}
+export interface IntegratorFee {
+  id: string;
+  type: 'percentage' | 'flat';
+  value: number;
+  transactionType: TransactionType;
+  minAmount?: number;
+  maxAmount?: number;
+  currency?: string;
+  isActive: boolean;
+}
+
+export interface FeeCalculation {
+  baseFee: number;
+  networkFee: number;
+  integratorFee?: number;
+  totalFee: number;
+  finalAmount: number;
+  exchangeRate?: number;
+  currency: string;
+}
+{{/if}}
+
+{{#if (includes features "webhooks")}}
+export interface WebhookEvent {
+  id: string;
+  type: 'transaction.created' | 'transaction.updated' | 'transaction.completed' | 'transaction.failed' | 'payee.created' | 'payee.deleted';
+  data: any;
+  timestamp: string;
+}
+{{/if}}
+
+{{#if (includes features "realtime")}}
+export interface RealtimeEvent {
+  type: 'transaction:update' | 'transaction:status' | 'fee:update';
+  transactionId?: string;
+  data: any;
+  timestamp: string;
+}
+{{/if}}
+
+// API Response Types
+export interface ApiResponse<T = any> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  message?: string;
+}
+
+export interface PaginatedResponse<T> {
+  items: T[];
+  total: number;
+  limit: number;
+  offset: number;
+  hasMore: boolean;
+}
+
+// Form Input Types
+export interface LoginCredentials {
+  email: string;
+  password: string;
+}
+
+export interface RegistrationData {
+  email: string;
+  password: string;
+  firstName: string;
+  lastName: string;
+  individual: {
+    firstName: string;
+    lastName: string;
+    dateOfBirth: string;
+    address: {
+      street1: string;
+      street2?: string;
+      city: string;
+      state: string;
+      postalCode: string;
+      country: string;
+    };
+    ssn?: string;
+    phone?: string;
+  };
+}
+
+export interface CreatePayeeData {
+  nickname: string;
+  network: string;
+  address: string;
+  type: 'crypto' | 'bank';
+  metadata?: Record<string, any>;
+}
+
+export interface CreateTransactionData {
+  type: TransactionType;
+  amount: number;
+  currency?: string;
+  payeeId?: string;
+  paymentMethodId?: string;
+  metadata?: Record<string, any>;
+}