@diviswap/sdk 1.7.6

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

@@ -0,0 +1,502 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { Diviswap } from '@diviswap/sdk';
+import { cookies } from 'next/headers';
+import type { Diviswap as DiviswapType } from '@diviswap/sdk';
+
+// Initialize Diviswap SDK with partner authentication
+function getDiviswap() {
+  const config = {
+    mode: 'partner' as const,
+    keyId: process.env.DIVISWAP_PARTNER_KEY_ID!,
+    secretKey: process.env.DIVISWAP_PARTNER_SECRET_KEY!,
+    authMethod: 'hmac' as const,
+    environment: (process.env.NEXT_PUBLIC_DIVISWAP_ENV as 'production' | 'sandbox') || 'sandbox'
+  };
+  
+  return Diviswap.init(config);
+}
+
+// Helper function to handle errors
+function handleError(error: unknown) {
+  console.error('Diviswap API error:', error);
+  
+  if (error instanceof Error) {
+    return NextResponse.json(
+      { error: error.message },
+      { status: 500 }
+    );
+  }
+  
+  return NextResponse.json(
+    { error: 'Internal server error' },
+    { status: 500 }
+  );
+}
+
+// Type definitions for handlers
+type HandlerContext = {
+  diviswap: DiviswapType;
+  cookieStore: Awaited<ReturnType<typeof cookies>>;
+};
+
+type ActionHandler = (params: any, context: HandlerContext) => Promise<NextResponse>;
+type ResourceHandler = (searchParams: URLSearchParams, context: HandlerContext) => Promise<NextResponse>;
+
+// Helper function to set customer context from request
+function setCustomerContext(diviswap: DiviswapType, params: any) {
+  // In partner authentication, you need to identify your user from your session/auth
+  // For this example, we'll expect customerId and customerEmail in the request
+  // In production, you'd get this from your own authentication system
+  
+  const customerId = params.customerId || 'demo-customer-123';
+  const customerEmail = params.customerEmail || 'demo@yourapp.com';
+  
+  diviswap.setCustomer(customerId, customerEmail);
+}
+
+// POST action handlers
+const postHandlers: Record<string, ActionHandler> = {
+  setCustomer: async (params, { diviswap }) => {
+    try {
+      diviswap.setCustomer(params.customerId, params.customerEmail);
+      return NextResponse.json({ 
+        success: true, 
+        customerId: params.customerId,
+        customerEmail: params.customerEmail 
+      });
+    } catch (error: any) {
+      console.error('Set customer error:', error);
+      throw error;
+    }
+  },
+
+  clearCustomer: async (_, { diviswap }) => {
+    try {
+      diviswap.clearCustomer();
+      return NextResponse.json({ success: true });
+    } catch (error: any) {
+      console.error('Clear customer error:', error);
+      throw error;
+    }
+  },
+
+  createTransaction: async (params, { diviswap }) => {
+    // Set customer context before API calls
+    setCustomerContext(diviswap, params);
+
+    // Use the appropriate method based on transaction type
+    let transaction;
+    if (params.type === 'onramp') {
+      // Note: Onramp is not yet available in v1 API
+      return NextResponse.json(
+        { error: 'Onramp transactions are not yet available' },
+        { status: 400 }
+      );
+    } else {
+      // Validate required txHash for offramp
+      // Note: Frontend must send crypto FIRST, get txHash, then call this
+      if (!params.txHash) {
+        return NextResponse.json(
+          { error: 'txHash is required for offramp transactions' },
+          { status: 400 }
+        );
+      }
+
+      // Extract hash if it's an object (failsafe for different wallet types)
+      // Some wallets return {hash: '0x...'} instead of '0x...' directly
+      const txHashString = typeof params.txHash === 'string'
+        ? params.txHash
+        : (params.txHash?.hash || params.txHash);
+
+      const sdkParams = {
+        amount: params.amount,
+        currency: params.currency || 'USD',
+        payeeId: params.payeeId,
+        fromAddress: params.fromAddress,
+        toAddress: params.toAddress,
+        chain: params.chain || 'ethereum',
+        txHash: txHashString
+      };
+
+      // Use environment-appropriate method
+      // Production: uses regular offramp (creates completed transaction)
+      // Sandbox/Development: uses offrampTest (creates pending transaction)
+      const isProduction = process.env.NEXT_PUBLIC_DIVISWAP_ENV === 'production';
+      transaction = isProduction
+        ? await diviswap.transactions.offramp(sdkParams)
+        : await diviswap.transactions.offrampTest(sdkParams);
+    }
+    return NextResponse.json(transaction);
+  },
+
+  createPayee: async (params, { diviswap }) => {
+    // Set customer context before API calls
+    setCustomerContext(diviswap, params);
+
+
+    // Check if the SDK is sending structured debit card data
+    if (params.debitCard) {
+      // New SDK structure - debitCard object is already properly formatted
+      const debitCardPayload = {
+        nickname: params.nickname,
+        accountType: 'debit_card' as const,
+        debitCard: params.debitCard,
+        setAsDefault: params.setAsDefault || false
+      };
+
+      const payee = await diviswap.payees.create(debitCardPayload);
+      return NextResponse.json(payee);
+    }
+    // Handle legacy flat structure for debit cards
+    else if (params.accountType === 'debit_card' || params.payeeType === 'debit') {
+      // Parse expiry date if needed
+      let expirationMonth = params.expirationMonth;
+      let expirationYear = params.expirationYear;
+      
+      // If expiry is in MM/YY format in routingNumber field
+      if (params.routingNumber && params.routingNumber.includes('/')) {
+        const expiryParts = params.routingNumber.split('/');
+        expirationMonth = expiryParts[0];
+        expirationYear = expiryParts[1] ? `20${expiryParts[1]}` : '2025';
+      }
+
+      const debitCardPayload = {
+        nickname: params.nickname,
+        accountType: 'debit_card' as const,
+        debitCard: {
+          number: params.accountNumber?.replace(/\s+/g, '') || '', // Remove spaces
+          expirationMonth: expirationMonth || '12',
+          expirationYear: expirationYear || '2025',
+          cvv: params.cvv || '123'
+        },
+        setAsDefault: params.setAsDefault || false
+      };
+
+      const payee = await diviswap.payees.create(debitCardPayload);
+      return NextResponse.json(payee);
+    } else {
+      // Bank account structure
+      const payee = await diviswap.payees.create({
+        nickname: params.nickname,
+        accountNumber: params.accountNumber,
+        routingNumber: params.routingNumber,
+        accountType: params.accountType || 'checking',
+        setAsDefault: params.setAsDefault || false
+      });
+      return NextResponse.json(payee);
+    }
+  },
+
+{{#if (includes features "fees")}}
+  calculateFees: async (params, { diviswap }) => {
+    const fees = await diviswap.fees.calculateFees({
+      amount: params.amount,
+      userId: undefined
+    });
+    return NextResponse.json(fees);
+  },
+
+  getIntegratorFees: async (_, { diviswap }) => {
+    const fees = await diviswap.fees.getFees();
+    return NextResponse.json(fees);
+  },
+{{/if}}
+
+  submitKYC: async (params, { diviswap }) => {
+    // Set customer context before KYC submission
+    setCustomerContext(diviswap, params);
+
+    try {
+      
+      // Extract data from nested structure
+      const personalInfo = params.personalInfo || {};
+      const address = params.address || {};
+      
+
+      // Validate required address fields
+      if (!address.addressLine1 || !address.city || !address.state || !address.postalCode || !address.country) {
+        console.error('[API Route] Missing required address fields:', {
+          hasAddressLine1: !!address.addressLine1,
+          hasCity: !!address.city,
+          hasState: !!address.state,
+          hasPostalCode: !!address.postalCode,
+          hasCountry: !!address.country,
+          rawAddress: address
+        });
+        return NextResponse.json({
+          success: false,
+          error: 'Missing required address fields'
+        }, { status: 400 });
+      }
+
+      // Clean up the payload - remove undefined/null values and empty strings for optional fields
+      const street = address.addressLine1 + (address.addressLine2 && address.addressLine2.trim() ? ` ${address.addressLine2.trim()}` : '');
+      
+      const kycPayload = {
+        firstName: personalInfo.firstName,
+        lastName: personalInfo.lastName,
+        dateOfBirth: personalInfo.dateOfBirth,
+        ...(personalInfo.ssn && { ssn: personalInfo.ssn }),
+        ...(personalInfo.phone && { phone: personalInfo.phone }),
+        address: {
+          street: street,
+          city: address.city,
+          state: address.state,
+          postalCode: address.postalCode,
+          country: address.country
+        }
+      };
+
+
+      const result = await diviswap.kyc.submitPersonalInfo(kycPayload);
+
+      return NextResponse.json(result);
+    } catch (error: any) {
+      console.error('[API Route] KYC submission failed:', error);
+      
+      // Return the error to the client
+      
+      throw error;
+    }
+  },
+
+  createAddress: async (params, { diviswap }) => {
+    // Set customer context before API call
+    setCustomerContext(diviswap, params);
+
+    try {
+      const address = await diviswap.addresses.create({
+        chain_id: params.chain_id,
+        address: params.address,
+        is_default: params.is_default
+      });
+      
+      return NextResponse.json(address);
+    } catch (error: any) {
+      console.error('[API Route] Address creation failed:', error);
+      throw error;
+    }
+  },
+
+  setDefaultAddress: async (params, { diviswap }) => {
+    // Set customer context before API call
+    setCustomerContext(diviswap, params);
+
+    try {
+      await diviswap.addresses.setDefault({
+        chain_id: params.chain_id,
+        address: params.address
+      });
+      
+      return NextResponse.json({ success: true });
+    } catch (error: any) {
+      console.error('[API Route] Set default address failed:', error);
+      throw error;
+    }
+  },
+
+  deleteAddress: async (params, { diviswap }) => {
+    // Set customer context before API call
+    setCustomerContext(diviswap, params);
+
+    try {
+      await diviswap.addresses.delete({
+        chain_id: params.chain_id,
+        address: params.address
+      });
+      
+      return NextResponse.json({ success: true });
+    } catch (error: any) {
+      console.error('[API Route] Address deletion failed:', error);
+      throw error;
+    }
+  }
+};
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { action, ...params } = body;
+
+    // Get cookies for any cookie-based operations
+    const cookieStore = await cookies();
+
+    // Find and execute handler
+    const handler = postHandlers[action];
+    if (!handler) {
+      return NextResponse.json(
+        { error: 'Invalid action' },
+        { status: 400 }
+      );
+    }
+
+    const diviswap = getDiviswap();
+    return await handler(params, { diviswap, cookieStore });
+  } catch (error) {
+    return handleError(error);
+  }
+}
+
+// GET resource handlers
+const getHandlers: Record<string, ResourceHandler> = {
+  customerStatus: async (searchParams, { diviswap }) => {
+    const customerId = searchParams.get('customerId') || 'demo-customer-123';
+    const customerEmail = searchParams.get('customerEmail') || 'demo@yourapp.com';
+    
+    // Set customer context
+    diviswap.setCustomer(customerId, customerEmail);
+    
+    return NextResponse.json({
+      customerId,
+      customerEmail,
+      authenticated: true,
+      mode: 'partner'
+    });
+  },
+
+  payees: async (searchParams, { diviswap }) => {
+    const customerId = searchParams.get('customerId') || 'demo-customer-123';
+    const customerEmail = searchParams.get('customerEmail') || 'demo@yourapp.com';
+    
+    // Set customer context before API call
+    diviswap.setCustomer(customerId, customerEmail);
+    
+    const payees = await diviswap.payees.list();
+    return NextResponse.json(payees);
+  },
+
+  transactions: async (searchParams, { diviswap }) => {
+    const customerId = searchParams.get('customerId') || 'demo-customer-123';
+    const customerEmail = searchParams.get('customerEmail') || 'demo@yourapp.com';
+    
+    // Set customer context before API call
+    diviswap.setCustomer(customerId, customerEmail);
+    
+    const limit = searchParams.get('limit');
+    const offset = searchParams.get('offset');
+    const status = searchParams.get('status');
+    const type = searchParams.get('type');
+    
+    const transactions = await diviswap.transactions.list({
+      limit: limit ? Number(limit) : 10,
+      offset: offset ? Number(offset) : 0,
+      status: status as 'pending' | 'processing' | 'completed' | 'failed' | undefined,
+      type: type as 'onramp' | 'offramp' | undefined
+    });
+    
+    return NextResponse.json(transactions);
+  },
+
+  kycStatus: async (searchParams, { diviswap }) => {
+    const customerId = searchParams.get('customerId') || 'demo-customer-123';
+    const customerEmail = searchParams.get('customerEmail') || 'demo@yourapp.com';
+    
+    // Set customer context before API call
+    diviswap.setCustomer(customerId, customerEmail);
+    
+    try {
+      
+      const status = await diviswap.kyc.getComplianceStatus();
+      return NextResponse.json(status);
+    } catch (error: any) {
+      console.error('Failed to get KYC status:', error);
+      // Return default status on error
+      return NextResponse.json({
+        kycStatus: 'NOT_STARTED',
+        kybStatus: 'NOT_REQUIRED',
+        canTransact: false,
+        requiresAction: true,
+        verificationLevel: 'none',
+        nextStep: 'COMPLETE_KYC'
+      });
+    }
+  },
+
+  addresses: async (searchParams, { diviswap }) => {
+    const customerId = searchParams.get('customerId') || 'demo-customer-123';
+    const customerEmail = searchParams.get('customerEmail') || 'demo@yourapp.com';
+    
+    // Set customer context before API call
+    diviswap.setCustomer(customerId, customerEmail);
+    
+    const chain_id = searchParams.get('chain_id');
+    const is_default = searchParams.get('is_default');
+    
+    const addresses = await diviswap.addresses.list({
+      ...(chain_id && { chain_id: Number(chain_id) }),
+      ...(is_default !== null && { is_default: is_default === 'true' })
+    });
+    
+    return NextResponse.json(addresses);
+  },
+
+};
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const resource = searchParams.get('resource');
+    const cookieStore = await cookies();
+
+    // Find and execute handler
+    const handler = getHandlers[resource || ''];
+    if (!handler) {
+      return NextResponse.json(
+        { error: 'Invalid resource' },
+        { status: 400 }
+      );
+    }
+
+    const diviswap = getDiviswap();
+    return await handler(searchParams, { diviswap, cookieStore });
+  } catch (error) {
+    return handleError(error);
+  }
+}
+
+{{#if (includes features "webhooks")}}
+// DELETE resource handlers
+const deleteHandlers: Record<string, ResourceHandler> = {
+  payee: async (searchParams, { diviswap }) => {
+    const customerId = searchParams.get('customerId') || 'demo-customer-123';
+    const customerEmail = searchParams.get('customerEmail') || 'demo@yourapp.com';
+    const id = searchParams.get('id');
+    
+    if (!id) {
+      return NextResponse.json(
+        { error: 'Payee ID required' },
+        { status: 400 }
+      );
+    }
+    
+    // Set customer context before API call
+    diviswap.setCustomer(customerId, customerEmail);
+    
+    await diviswap.payees.delete(id);
+    return NextResponse.json({ success: true });
+  },
+};
+
+// DELETE method for cleanup operations
+export async function DELETE(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const resource = searchParams.get('resource');
+    const cookieStore = await cookies();
+
+    // Find and execute handler
+    const handler = deleteHandlers[resource || ''];
+    if (!handler) {
+      return NextResponse.json(
+        { error: 'Invalid resource' },
+        { status: 400 }
+      );
+    }
+
+    const diviswap = getDiviswap();
+    return await handler(searchParams, { diviswap, cookieStore });
+  } catch (error) {
+    return handleError(error);
+  }
+}
+{{/if}}

package/src/cli/templates/nextjs-app/auth-context.tsx.hbs

@@ -0,0 +1,59 @@
+"use client";
+
+import { createContext, useContext, ReactNode } from 'react';
+
+interface {{prefix}}AuthContextType {
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  customerId: string | null;
+  customerEmail: string | null;
+  clearCustomer: () => Promise<void>;
+}
+
+const {{prefix}}AuthContext = createContext<{{prefix}}AuthContextType>({
+  isAuthenticated: false,
+  isLoading: false,
+  customerId: null,
+  customerEmail: null,
+  clearCustomer: async () => {},
+});
+
+interface {{prefix}}AuthProviderProps {
+  children: ReactNode;
+  customerId: string | null;
+  customerEmail: string | null;
+  loading: boolean;
+  clearCustomer: () => Promise<void>;
+}
+
+// This provider receives props instead of using useDiviswap directly
+// to avoid circular dependencies
+export function {{prefix}}AuthProvider({ 
+  children, 
+  customerId, 
+  customerEmail,
+  loading, 
+  clearCustomer 
+}: {{prefix}}AuthProviderProps) {
+  return (
+    <{{prefix}}AuthContext.Provider 
+      value=\{{ 
+        isAuthenticated: !!(customerId && customerEmail), 
+        isLoading: loading, 
+        customerId,
+        customerEmail,
+        clearCustomer
+      }}
+    >
+      {children}
+    </{{prefix}}AuthContext.Provider>
+  );
+}
+
+export const use{{prefix}}Auth = () => {
+  const context = useContext({{prefix}}AuthContext);
+  if (!context) {
+    throw new Error('use{{prefix}}Auth must be used within {{prefix}}AuthProvider');
+  }
+  return context;
+};

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

@@ -0,0 +1,116 @@
+// This file is auto-generated by Diviswap SDK CLI
+// It provides a client for communicating with the Diviswap API routes
+
+export 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 management for partner authentication
+  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?: {
+    limit?: number;
+    offset?: number;
+    status?: string;
+    type?: string;
+  }) {
+    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 calculation methods
+  async calculateFees(data: { amount: number; type: 'onramp' | 'offramp'; currency?: string }) {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'calculateFees', ...data }),
+    });
+  }
+
+  async getIntegratorFees() {
+    return this.request('', {
+      method: 'POST',
+      body: JSON.stringify({ action: 'getIntegratorFees' }),
+    });
+  }
+{{/if}}
+}