Fluxo de Trabalho KYB

const businessApplication = {
  legalName: "Tech Solutions Sociedade Anônima",
  tradeName: "Tech Solutions",
  registrationNumber: "12.345.678/0001-90",
  taxId: "12.345.678/0001-90",
  incorporationDate: "2020-06-15",
  country: "BR",
  address: {
    street: "Av. Paulista, 1000",
    city: "São Paulo",
    state: "SP",
    postalCode: "01310-100"
  },
  industry: "Software Development",
  website: "https://techsolutions.com.br",
  expectedMonthlyVolume: 250000,
  businessDescription: "B2B SaaS platform for enterprise clients"
};

{
  "success": true,
  "entity": {
    "id": "660e9511-f39c-52e5-b827-557766551111",
    "externalId": "business_12345",
    "type": "company",
    "name": "Tech Solutions Sociedade Anônima",
    "riskScore": 0,
    "status": "under_review",
    "createdAt": "2024-10-03T10:00:00Z"
  }
}

async function uploadBusinessDocuments(entityId, documents) {
  const documentUploads = [];

  for (const doc of documents) {
    const formData = new FormData();
    formData.append('file', doc.file);
    formData.append('documentType', doc.type);
    formData.append('entityId', entityId);

    const response = await fetch('http://api.gu1.ai/documents', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`
      },
      body: formData
    });

    documentUploads.push(await response.json());
  }

  return documentUploads;
}

// Uso
const documents = [
  { file: articlesOfIncorporation, type: 'articles_of_incorporation' },
  { file: businessLicense, type: 'business_license' },
  { file: taxCertificate, type: 'tax_certificate' },
  { file: proofOfAddress, type: 'proof_of_address' }
];

const uploadedDocs = await uploadBusinessDocuments(entityId, documents);

async function requestAIAnalysis(entityId) {
  const response = await fetch(
    `http://api.gu1.ai/entities/${entityId}/ai-analysis`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        analysisType: 'kyb_verification',
        includeDocuments: true,
        checkSanctions: true,
        checkAdverseMedia: true
      })
    }
  );

  return await response.json();
}

{
  "analysisId": "analysis_abc123",
  "entityId": "660e9511-f39c-52e5-b827-557766551111",
  "riskScore": 35,
  "riskLevel": "medium",
  "findings": {
    "documentVerification": {
      "status": "verified",
      "confidence": 0.95,
      "articlesOfIncorporation": "valid",
      "businessLicense": "valid",
      "taxCertificate": "valid"
    },
    "businessLegitimacy": {
      "status": "verified",
      "registrationVerified": true,
      "taxIdValid": true,
      "addressConfirmed": true
    },
    "sanctionsScreening": {
      "status": "clear",
      "listsChecked": ["OFAC", "UN", "EU", "UK"],
      "matches": []
    },
    "adverseMedia": {
      "status": "minor_flags",
      "findings": [
        {
          "source": "news_article",
          "date": "2023-05-15",
          "summary": "Small tax dispute resolved",
          "severity": "low"
        }
      ]
    },
    "riskFactors": [
      {
        "factor": "new_business",
        "impact": 20,
        "description": "Company incorporated less than 5 years ago"
      },
      {
        "factor": "high_growth_industry",
        "impact": 15,
        "description": "Software industry has elevated fraud risk"
      },
      {
        "factor": "clean_compliance_history",
        "impact": -10,
        "description": "No regulatory violations found"
      }
    ]
  },
  "recommendation": "approve_with_monitoring",
  "nextSteps": [
    "Verify beneficial ownership",
    "Set transaction monitoring thresholds",
    "Schedule 6-month review"
  ]
}

async function processKYBDecision(analysisResult) {
  const { riskScore, riskLevel, recommendation } = analysisResult;

  if (riskScore < 30) {
    // Baixo Risco - Auto-aprovação
    return await autoApprove(analysisResult.entityId);

  } else if (riskScore < 70) {
    // Médio Risco - Due Diligence Aprimorada
    return await enhancedDueDiligence(analysisResult.entityId);

  } else {
    // Alto Risco - Revisão Manual Necessária
    return await flagForManualReview(analysisResult.entityId, analysisResult.findings);
  }
}

async function autoApprove(entityId) {
  // Atualizar status da entidade para aprovado
  await fetch(`http://api.gu1.ai/entities/${entityId}`, {
    method: 'PATCH',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      attributes: {
        kybStatus: 'approved',
        approvedAt: new Date().toISOString(),
        approvedBy: 'automated_system',
        reviewNotes: 'Low risk - auto-approved'
      }
    })
  });

  // Enviar notificação de aprovação
  await sendApprovalEmail(entityId);

  // Ativar monitoramento
  await enableOngoingMonitoring(entityId);

  return { status: 'approved', action: 'auto_approved' };
}

async function enhancedDueDiligence(entityId) {
  // Solicitar informações adicionais
  await requestAdditionalDocs(entityId, [
    'financial_statements',
    'ownership_structure',
    'source_of_funds'
  ]);

  // Atualizar status
  await updateEntityStatus(entityId, 'enhanced_due_diligence');

  return { status: 'pending', action: 'edd_required' };
}

async function flagForManualReview(entityId, findings) {
  // Criar tarefa de revisão
  await createReviewTask({
    entityId,
    priority: 'high',
    assignTo: 'compliance_team',
    findings,
    dueDate: new Date(Date.now() + 24 * 60 * 60 * 1000) // 24 horas
  });

  return { status: 'manual_review', action: 'flagged_for_review' };
}

async function verifyBeneficialOwners(entityId, owners) {
  const verifiedOwners = [];

  for (const owner of owners) {
    // Criar entidade pessoa para cada UBO
    const uboEntity = await fetch('http://api.gu1.ai/entities', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        type: 'person',
        externalId: `ubo_${owner.id}`,
        name: `${owner.firstName} ${owner.lastName}`,
        countryCode: owner.nationality,
        entityData: {
          person: {
            firstName: owner.firstName,
            lastName: owner.lastName,
            dateOfBirth: owner.dateOfBirth,
            nationality: owner.nationality
          }
        },
        attributes: {
          ownershipPercentage: owner.ownership,
          isPEP: owner.isPEP,
          relationshipToCompany: 'beneficial_owner'
        }
      })
    });

    const ubo = await uboEntity.json();

    // Executar verificações KYC no UBO
    const kycResult = await runKYCCheck(ubo.entity.id);

    // Criar relacionamento entre empresa e UBO
    await createRelationship({
      fromEntityId: entityId,
      toEntityId: ubo.entity.id,
      relationshipType: 'beneficial_owner',
      ownershipPercentage: owner.ownership
    });

    verifiedOwners.push({
      ...ubo.entity,
      kycStatus: kycResult.status,
      riskScore: kycResult.riskScore
    });
  }

  return verifiedOwners;
}

async function setupOngoingMonitoring(entityId) {
  // Configurar regras de monitoramento
  await fetch('http://api.gu1.ai/rules', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: `KYB Monitoring - ${entityId}`,
      entityId: entityId,
      rules: [
        {
          type: 'sanctions_screening',
          frequency: 'daily',
          action: 'alert_compliance_team'
        },
        {
          type: 'adverse_media',
          frequency: 'weekly',
          action: 'create_review_task'
        },
        {
          type: 'ownership_changes',
          frequency: 'realtime',
          action: 'trigger_reverification'
        },
        {
          type: 'transaction_anomalies',
          threshold: 'high',
          action: 'flag_for_review'
        }
      ]
    })
  });

  // Configurar notificações por webhook
  await configureWebhook({
    entityId,
    events: [
      'sanctions_match',
      'adverse_media_found',
      'ownership_change',
      'transaction_anomaly'
    ],
    url: 'https://your-app.com/webhooks/kyb-alerts'
  });
}

async function sendStatusUpdate(entityId, status, details) {
  // Obter detalhes da entidade
  const entity = await getEntity(entityId);

  // Enviar notificação por e-mail
  await sendEmail({
    to: entity.attributes.contactEmail,
    subject: `Atualização de Verificação KYB - ${status}`,
    template: 'kyb_status_update',
    data: {
      companyName: entity.name,
      status: status,
      details: details,
      nextSteps: getNextSteps(status),
      dashboardUrl: `https://app.gu1.ai/onboarding/${entityId}`
    }
  });

  // Enviar webhook para seu sistema
  await sendWebhook({
    event: 'kyb_status_changed',
    entityId: entityId,
    status: status,
    timestamp: new Date().toISOString(),
    details: details
  });
}

// Exemplos de atualização de status
await sendStatusUpdate(entityId, 'documents_received', {
  message: 'Recebemos seus documentos e estamos processando-os.'
});

await sendStatusUpdate(entityId, 'approved', {
  message: 'Sua empresa foi verificada e aprovada!',
  approvalDate: new Date().toISOString()
});

await sendStatusUpdate(entityId, 'additional_info_required', {
  message: 'Precisamos de informações adicionais para concluir sua verificação.',
  requiredDocuments: ['financial_statements', 'ownership_structure']
});

async function executeKYBWorkflow(applicationData) {
  try {
    // Etapas 1 e 2: Criar entidade
    console.log('Criando entidade empresarial...');
    const entity = await createBusinessEntity(applicationData);

    // Etapa 3: Fazer upload de documentos
    console.log('Fazendo upload de documentos de verificação...');
    await uploadBusinessDocuments(entity.id, applicationData.documents);

    // Etapa 4: Solicitar análise por IA
    console.log('Executando análise por IA...');
    const analysis = await requestAIAnalysis(entity.id);

    // Etapa 5: Tomar decisão baseada em risco
    console.log('Processando decisão KYB...');
    const decision = await processKYBDecision(analysis);

    if (decision.status === 'approved') {
      // Etapa 6: Verificar UBOs (para entidades aprovadas)
      console.log('Verificando beneficiários finais...');
      await verifyBeneficialOwners(entity.id, applicationData.beneficialOwners);

      // Etapa 7: Configurar monitoramento
      console.log('Configurando monitoramento contínuo...');
      await setupOngoingMonitoring(entity.id);
    }

    // Etapa 8: Enviar atualização de status
    console.log('Enviando notificação de status...');
    await sendStatusUpdate(entity.id, decision.status, analysis.findings);

    return {
      success: true,
      entityId: entity.id,
      status: decision.status,
      riskScore: analysis.riskScore,
      decision: decision
    };

  } catch (error) {
    console.error('Erro no fluxo de trabalho KYB:', error);
    return {
      success: false,
      error: error.message
    };
  }
}