Integration Examples

// E-commerce Transaction Flow
import { TrustVerify } from '@trustverify/sdk';

class EcommerceCheckout {
  constructor() {
    this.trustVerify = new TrustVerify({
      apiKey: process.env.TRUSTVERIFY_API_KEY,
      environment: 'production'
    });
  }

  async processOrder(orderData) {
    // Step 1: Create secure transaction
    const transaction = await this.trustVerify.transactions.create({
      title: `Order #${orderData.orderId}`,
      amount: orderData.total,
      currency: orderData.currency,
      buyerEmail: orderData.customer.email,
      sellerEmail: orderData.merchant.email,
      category: 'e_commerce',
      deliveryTimeframe: '7_days'
    });

    // Step 2: Run fraud detection
    const fraudCheck = await this.trustVerify.fraud.analyze({
      transactionId: transaction.id,
      ipAddress: orderData.ipAddress,
      deviceFingerprint: orderData.deviceId,
    });

    if (fraudCheck.riskScore > 0.7) {
      return { status: 'review_required', transaction, fraudCheck };
    }

    return { status: 'success', transaction };
  }

  async confirmDelivery(transactionId, deliveryProof) {
    return await this.trustVerify.transactions.complete({
      transactionId,
      deliveryProof,
      completedBy: 'buyer'
    });
  }
}

// Freelance Marketplace Integration
import { TrustVerify } from '@trustverify/sdk';

class FreelanceMarketplace {
  async createProject(projectData) {
    const trustVerify = new TrustVerify({ apiKey: process.env.TRUSTVERIFY_API_KEY });

    // Verify KYC status for both parties
    const [freelancerKyc, clientKyc] = await Promise.all([
      trustVerify.kyc.getStatus(projectData.freelancerId),
      trustVerify.kyc.getStatus(projectData.clientId)
    ]);

    if (freelancerKyc.level < 'basic' || clientKyc.level < 'basic') {
      return { status: 'kyc_required', freelancerKyc, clientKyc };
    }

    const transaction = await trustVerify.transactions.create({
      title: projectData.title,
      amount: projectData.totalAmount,
      currency: 'USD',
      buyerEmail: projectData.client.email,
      sellerEmail: projectData.freelancer.email,
      category: 'digital_services',
      milestones: projectData.milestones
    });

    return { status: 'created', transaction };
  }

  async approveMilestone(transactionId, milestoneId, feedback) {
    const trustVerify = new TrustVerify({ apiKey: process.env.TRUSTVERIFY_API_KEY });
    return await trustVerify.transactions.approveMilestone({
      transactionId, milestoneId, feedback, releasePayment: true
    });
  }
}

// Fintech Application Integration
import { TrustVerify } from '@trustverify/sdk';

class FintechApplication {
  async processPayment(paymentData) {
    const trustVerify = new TrustVerify({ apiKey: process.env.TRUSTVERIFY_API_KEY });

    // AML/KYC compliance check
    const complianceCheck = await trustVerify.compliance.verify({
      userId: paymentData.userId,
      amount: paymentData.amount,
      currency: paymentData.currency,
      sourceOfFunds: paymentData.sourceOfFunds,
    });

    if (complianceCheck.status === 'requires_review') {
      return { status: 'compliance_review_required', complianceCheck };
    }

    const transaction = await trustVerify.transactions.create({
      title: `Payment to ${paymentData.beneficiary.name}`,
      amount: paymentData.amount,
      currency: paymentData.currency,
      buyerEmail: paymentData.sender.email,
      sellerEmail: paymentData.beneficiary.email,
      category: 'financial_services',
    });

    // Regulatory reporting for large transactions
    if (paymentData.amount >= 10000) {
      await trustVerify.compliance.generateReport({
        transactionId: transaction.id,
        reportType: 'suspicious_activity',
        regulatoryBody: 'FinCEN',
      });
    }

    return { status: 'success', transaction };
  }
}

// Enterprise B2B Integration
import { TrustVerify } from '@trustverify/sdk';

class EnterpriseB2BPlatform {
  async processBulkTransactions(transactions) {
    const trustVerify = new TrustVerify({
      apiKey: process.env.TRUSTVERIFY_API_KEY,
      environment: 'production',
      webhookSecret: process.env.WEBHOOK_SECRET
    });

    const batchSize = 100;
    const results = [];

    for (let i = 0; i < transactions.length; i += batchSize) {
      const batch = transactions.slice(i, i + batchSize);
      const batchResults = await Promise.all(
        batch.map(async (txnData) => {
          const kybVerification = await trustVerify.kyb.verify({
            businessId: txnData.businessId,
            registrationNumber: txnData.registrationNumber,
            beneficialOwners: txnData.beneficialOwners
          });

          if (kybVerification.status !== 'approved') {
            throw new Error(`KYB failed: ${kybVerification.reason}`);
          }

          return await trustVerify.transactions.create({
            title: txnData.contractTitle,
            amount: txnData.contractValue,
            currency: txnData.currency,
            buyerEmail: txnData.buyer.email,
            sellerEmail: txnData.seller.email,
            category: 'enterprise_b2b',
            customWorkflow: { approvalLevels: txnData.approvalLevels }
          });
        })
      );
      results.push(...batchResults);
    }

    return results;
  }
}

// Webhook Handler for Real-time Updates
import express from 'express';
import crypto from 'crypto';

const app = express();

app.post('/webhooks/trustverify', express.raw({type: 'application/json'}), (req, res) => {
  const signature = req.headers['x-trustverify-signature'];
  const expectedSignature = crypto
    .createHmac('sha256', process.env.TRUSTVERIFY_WEBHOOK_SECRET)
    .update(req.body)
    .digest('hex');

  if (signature !== `sha256=${expectedSignature}`) {
    return res.status(401).send('Invalid signature');
  }

  const event = JSON.parse(req.body);

  switch (event.type) {
    case 'transaction.created':
      handleTransactionCreated(event.data);
      break;
    case 'transaction.completed':
      handleTransactionCompleted(event.data);
      break;
    case 'kyc.approved':
      handleKycApproved(event.data);
      break;
    case 'fraud.high_risk_detected':
      handleHighRiskFraud(event.data);
      break;
  }

  res.status(200).send('OK');
});