@diviswap/sdk 1.7.6

package/src/cli/templates/react/api-client-wrapper.ts.hbs

@@ -0,0 +1,89 @@
+/**
+ * API client wrapper for custom backend integration
+ * This allows you to proxy Diviswap API calls through your own backend
+ * for additional security and custom logic
+ */
+
+interface ApiOptions extends RequestInit {
+  params?: Record<string, any>;
+}
+
+class ApiClient {
+  private baseUrl: string;
+
+  constructor(baseUrl = '/api') {
+    this.baseUrl = baseUrl;
+  }
+
+  private async request<T = any>(endpoint: string, options: ApiOptions = {}): Promise<T> {
+    const { params, ...fetchOptions } = options;
+    
+    let url = `${this.baseUrl}${endpoint}`;
+    if (params) {
+      const searchParams = new URLSearchParams(params);
+      url += `?${searchParams.toString()}`;
+    }
+
+    const response = await fetch(url, {
+      headers: {
+        'Content-Type': 'application/json',
+        ...fetchOptions.headers,
+      },
+      ...fetchOptions,
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: 'Request failed' }));
+      throw new Error(error.message || `HTTP ${response.status}`);
+    }
+
+    return response.json();
+  }
+
+  // Diviswap-specific endpoints
+  diviswap = {
+    // Authentication
+    login: (email: string, password: string) =>
+      this.request('/diviswap', {
+        method: 'POST',
+        body: JSON.stringify({ action: 'login', email, password }),
+      }),
+
+    logout: () =>
+      this.request('/diviswap', {
+        method: 'POST',
+        body: JSON.stringify({ action: 'logout' }),
+      }),
+
+    getSession: () =>
+      this.request('/diviswap', { params: { resource: 'session' } }),
+
+    // Transactions
+    createTransaction: (data: any) =>
+      this.request('/diviswap', {
+        method: 'POST',
+        body: JSON.stringify({ action: 'createTransaction', ...data }),
+      }),
+
+    getTransactions: (filters?: any) =>
+      this.request('/diviswap', { params: { resource: 'transactions', ...filters } }),
+
+    // Payees
+    createPayee: (data: any) =>
+      this.request('/diviswap', {
+        method: 'POST',
+        body: JSON.stringify({ action: 'createPayee', ...data }),
+      }),
+
+    getPayees: () =>
+      this.request('/diviswap', { params: { resource: 'payees' } }),
+
+    deletePayee: (id: string) =>
+      this.request('/diviswap', {
+        method: 'DELETE',
+        params: { resource: 'payee', id },
+      }),
+  };
+}
+
+export const apiClient = new ApiClient();

package/src/cli/templates/react/example.tsx.hbs

@@ -0,0 +1,69 @@
+import React from 'react';
+import { DiviswapProvider, useDiviswap } from '@diviswap/sdk/react';
+import { apiClient } from './api-client';
+
+function TransactionDemo() {
+  const { 
+    user, 
+    loading, 
+    error,
+    login,
+    logout,
+    createTransaction,
+    getTransactions
+  } = useDiviswap();
+
+  const handleLogin = async () => {
+    try {
+      await login('user@example.com', 'password');
+    } catch (error) {
+      console.error('Login failed:', error);
+    }
+  };
+
+  const handleOnramp = async () => {
+    try {
+      const transaction = await createTransaction({
+        amount: 100,
+        currency: 'USD',
+        address: '0x...',
+        chain: 'ethereum'
+      });
+      console.log('Transaction created:', transaction);
+    } catch (error) {
+      console.error('Transaction failed:', error);
+    }
+  };
+
+  if (loading) {
+    return <div>Loading...</div>;
+  }
+
+  if (error) {
+    return <div>Error: {error.message}</div>;
+  }
+
+  return (
+    <div className="diviswap-demo">
+      <h1>Diviswap Demo</h1>
+      
+      {!user ? (
+        <button onClick={handleLogin}>Login</button>
+      ) : (
+        <div>
+          <p>Welcome, {user.email}!</p>
+          <button onClick={handleOnramp}>Create Onramp Transaction</button>
+          <button onClick={logout}>Logout</button>
+        </div>
+      )}
+    </div>
+  );
+}
+
+export default function App() {
+  return (
+    <DiviswapProvider>
+      <TransactionDemo />
+    </DiviswapProvider>
+  );
+}

package/src/cli/templates/react/tanstack-hooks.ts.hbs

@@ -0,0 +1,185 @@
+/**
+ * Example of using TanStack Query with Diviswap API routes
+ * This provides automatic caching, background refetching, and optimistic updates
+ */
+
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { apiClient } from './api-client';
+
+// Query keys for cache invalidation
+const queryKeys = {
+  user: ['diviswap', 'user'],
+  transactions: (filters?: any) => ['diviswap', 'transactions', filters],
+  payees: ['diviswap', 'payees'],
+  fees: (amount: number) => ['diviswap', 'fees', amount],
+};
+
+// User hooks
+export function useUser() {
+  return useQuery({
+    queryKey: queryKeys.user,
+    queryFn: () => apiClient.diviswap.getSession(),
+    retry: false,
+    staleTime: 5 * 60 * 1000, // 5 minutes
+  });
+}
+
+export function useLogin() {
+  const queryClient = useQueryClient();
+  
+  return useMutation({
+    mutationFn: ({ email, password }: { email: string; password: string }) =>
+      apiClient.diviswap.login(email, password),
+    onSuccess: (data) => {
+      queryClient.setQueryData(queryKeys.user, data.user);
+      queryClient.invalidateQueries({ queryKey: queryKeys.transactions() });
+      queryClient.invalidateQueries({ queryKey: queryKeys.payees });
+    },
+  });
+}
+
+export function useLogout() {
+  const queryClient = useQueryClient();
+  
+  return useMutation({
+    mutationFn: () => apiClient.diviswap.logout(),
+    onSuccess: () => {
+      queryClient.clear(); // Clear all cached data
+    },
+  });
+}
+
+// Transaction hooks
+export function useTransactions(filters?: any) {
+  const { data: user } = useUser();
+  
+  return useQuery({
+    queryKey: queryKeys.transactions(filters),
+    queryFn: () => apiClient.diviswap.getTransactions(filters),
+    enabled: !!user, // Only fetch if user is authenticated
+    staleTime: 30 * 1000, // 30 seconds
+  });
+}
+
+export function useCreateTransaction() {
+  const queryClient = useQueryClient();
+  
+  return useMutation({
+    mutationFn: (data: any) => apiClient.diviswap.createTransaction(data),
+    onSuccess: () => {
+      // Invalidate and refetch transactions
+      queryClient.invalidateQueries({ queryKey: queryKeys.transactions() });
+    },
+    onError: (error) => {
+      console.error('Transaction failed:', error);
+    },
+  });
+}
+
+// Payee hooks
+export function usePayees() {
+  const { data: user } = useUser();
+  
+  return useQuery({
+    queryKey: queryKeys.payees,
+    queryFn: () => apiClient.diviswap.getPayees(),
+    enabled: !!user,
+    staleTime: 60 * 1000, // 1 minute
+  });
+}
+
+export function useCreatePayee() {
+  const queryClient = useQueryClient();
+  
+  return useMutation({
+    mutationFn: (data: any) => apiClient.diviswap.createPayee(data),
+    onSuccess: (newPayee) => {
+      // Optimistically add the new payee to the cache
+      queryClient.setQueryData(queryKeys.payees, (old: any[] = []) => {
+        return [...old, newPayee];
+      });
+    },
+  });
+}
+
+export function useDeletePayee() {
+  const queryClient = useQueryClient();
+  
+  return useMutation({
+    mutationFn: (id: string) => apiClient.diviswap.deletePayee(id),
+    onMutate: async (deletedId) => {
+      // Cancel in-flight queries
+      await queryClient.cancelQueries({ queryKey: queryKeys.payees });
+      
+      // Snapshot current value
+      const previousPayees = queryClient.getQueryData(queryKeys.payees);
+      
+      // Optimistically remove the payee
+      queryClient.setQueryData(queryKeys.payees, (old: any[] = []) => {
+        return old.filter(payee => payee.id !== deletedId);
+      });
+      
+      return { previousPayees };
+    },
+    onError: (err, deletedId, context) => {
+      // Rollback on error
+      if (context?.previousPayees) {
+        queryClient.setQueryData(queryKeys.payees, context.previousPayees);
+      }
+    },
+    onSettled: () => {
+      // Always refetch after error or success
+      queryClient.invalidateQueries({ queryKey: queryKeys.payees });
+    },
+  });
+}
+
+{{#if (includes features "fees")}}
+// Fee calculation hooks
+export function useFeeCalculation(amount: number, enabled = true) {
+  return useQuery({
+    queryKey: queryKeys.fees(amount),
+    queryFn: () => apiClient.diviswap.calculateFees(amount),
+    enabled: enabled && amount > 0,
+    staleTime: 5 * 60 * 1000, // 5 minutes
+    gcTime: 10 * 60 * 1000, // 10 minutes (formerly cacheTime)
+  });
+}
+{{/if}}
+
+// Example usage in a component:
+/*
+function MyComponent() {
+  const { data: user, isLoading: userLoading } = useUser();
+  const { data: transactions, isLoading: txLoading } = useTransactions({ limit: 10 });
+  const createTx = useCreateTransaction();
+  
+  const handleCreateTransaction = async () => {
+    try {
+      await createTx.mutateAsync({
+        amount: 100,
+        type: 'onramp',
+        // ... other params
+      });
+      // Success! Transactions will automatically refetch
+    } catch (error) {
+      // Error handled by mutation
+    }
+  };
+  
+  if (userLoading || txLoading) return <div>Loading...</div>;
+  
+  return (
+    <div>
+      <h1>Welcome {user?.email}</h1>
+      <button 
+        onClick={handleCreateTransaction}
+        disabled={createTx.isPending}
+      >
+        {createTx.isPending ? 'Creating...' : 'Create Transaction'}
+      </button>
+      {transactions?.map(tx => <div key={tx.id}>{tx.amount}</div>)}
+    </div>
+  );
+}
+*/

package/src/cli/templates/shared/client.ts

@@ -0,0 +1,78 @@
+export class LiberExClient {
+  constructor(private baseUrl: string = '/api/liberex') {}
+
+  private async request(endpoint: string, options: RequestInit = {}) {
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || 'Request failed');
+    }
+
+    return response.json();
+  }
+
+  async login(email: string, password: string) {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'login', email, password }),
+    });
+  }
+
+  async logout() {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'logout' }),
+    });
+  }
+
+  async register(data: any) {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'register', ...data }),
+    });
+  }
+
+  async checkSession() {
+    try {
+      return await this.request('?resource=session');
+    } catch {
+      return null;
+    }
+  }
+
+  async createTransaction(data: any) {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'createTransaction', ...data }),
+    });
+  }
+
+  async getPayees() {
+    return this.request('?resource=payees');
+  }
+
+  async getTransactions(params?: { limit?: number; offset?: number }) {
+    const searchParams = new URLSearchParams({
+      resource: 'transactions',
+      ...(params && {
+        limit: params.limit?.toString() || '10',
+        offset: params.offset?.toString() || '0',
+      }),
+    });
+    return this.request(`?${searchParams}`);
+  }
+
+  async calculateFees(data: { amount: number; type: 'onramp' | 'offramp' }) {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'calculateFees', ...data }),
+    });
+  }
+}

package/src/cli/templates/webhooks/nextjs.hbs

@@ -0,0 +1,98 @@
+import { NextRequest, NextResponse } from 'next/server';
+import crypto from 'crypto';
+
+// Verify webhook signature
+function verifyWebhookSignature(
+  payload: string,
+  signature: string,
+  secret: string
+): boolean {
+  const expectedSignature = crypto
+    .createHmac('sha256', secret)
+    .update(payload)
+    .digest('hex');
+  
+  return crypto.timingSafeEqual(
+    Buffer.from(signature),
+    Buffer.from(expectedSignature)
+  );
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    // Get the raw body
+    const rawBody = await request.text();
+    
+    // Get signature from headers
+    const signature = request.headers.get('x-diviswap-signature');
+    
+    if (!signature) {
+      return NextResponse.json(
+        { error: 'Missing webhook signature' },
+        { status: 401 }
+      );
+    }
+    
+    // Verify signature
+    const webhookSecret = process.env.DIVISWAP_WEBHOOK_SECRET;
+    if (!webhookSecret) {
+      console.error('DIVISWAP_WEBHOOK_SECRET not configured');
+      return NextResponse.json(
+        { error: 'Webhook secret not configured' },
+        { status: 500 }
+      );
+    }
+    
+    const isValid = verifyWebhookSignature(rawBody, signature, webhookSecret);
+    if (!isValid) {
+      return NextResponse.json(
+        { error: 'Invalid webhook signature' },
+        { status: 401 }
+      );
+    }
+    
+    // Parse the webhook payload
+    const webhook = JSON.parse(rawBody);
+    
+    // Handle different webhook events
+    switch (webhook.event) {
+      case 'transaction.created':
+        console.log('Transaction created:', webhook.data);
+        // Handle new transaction
+        break;
+        
+      case 'transaction.updated':
+        console.log('Transaction updated:', webhook.data);
+        // Handle transaction update
+        break;
+        
+      case 'transaction.completed':
+        console.log('Transaction completed:', webhook.data);
+        // Handle completed transaction
+        break;
+        
+      case 'transaction.failed':
+        console.log('Transaction failed:', webhook.data);
+        // Handle failed transaction
+        break;
+        
+      case 'kyc.updated':
+        console.log('KYC status updated:', webhook.data);
+        // Handle KYC update
+        break;
+        
+      default:
+        console.log('Unknown webhook event:', webhook.event);
+    }
+    
+    // Return success response
+    return NextResponse.json({ received: true });
+    
+  } catch (error) {
+    console.error('Webhook error:', error);
+    return NextResponse.json(
+      { error: 'Webhook processing failed' },
+      { status: 500 }
+    );
+  }
+}