Como prevenir fraudes em programas de indicação (referral) com validação de CPF

const express = require("express");
const axios = require("axios");
const crypto = require("crypto");

const app = express();
app.use(express.json());

const CPFHUB_API_URL = "https://api.cpfhub.io/cpf";
const CPFHUB_API_KEY = "SUA_CHAVE_DE_API";
const REQUEST_TIMEOUT = 10000; // 10 segundos

// Simulação de banco de dados
const usuarios = new Map();
const indicacoes = new Map();
const cpfsRegistrados = new Set();

function limparCpf(cpf) {
    return cpf.replace(/\D/g, "");
}

async function consultarCpf(cpf) {
    const cpfLimpo = limparCpf(cpf);

    try {
    const response = await axios.get(`${CPFHUB_API_URL}/${cpfLimpo}`, {
    headers: {
    "x-api-key": CPFHUB_API_KEY,
    Accept: "application/json",
    },
    timeout: REQUEST_TIMEOUT,
    });

    if (response.data.success) {
    return response.data.data;
    }
    return null;
    } catch (error) {
    if (error.code === "ECONNABORTED") {
    throw new Error("Timeout na consulta de CPF");
    }
    if (error.response) {
    const { status } = error.response;
    if (status === 401) throw new Error("API key inválida");
    if (status === 404) return null;
    }
    throw new Error("Erro na consulta de CPF");
    }
}

function gerarCodigoReferral() {
    return crypto.randomBytes(4).toString("hex").toUpperCase();
}

// Endpoint: verificar CPF e habilitar referral
app.post("/api/referral/habilitar", async (req, res) => {
    const { usuarioId, cpf } = req.body;

    if (!usuarioId || !cpf) {
    return res.status(400).json({ erro: "usuarioId e cpf são obrigatórios" });
    }

    const cpfLimpo = limparCpf(cpf);

    // Verifica se CPF já está em uso
    if (cpfsRegistrados.has(cpfLimpo)) {
    const usuarioExistente = [...usuarios.values()].find(
    (u) => u.cpf === cpfLimpo
    );
    if (usuarioExistente && usuarioExistente.id !== usuarioId) {
    return res.status(409).json({
    erro: "Este CPF já está vinculado a outra conta",
    });
    }
    }

    try {
    const dados = await consultarCpf(cpfLimpo);
    if (!dados) {
    return res.status(422).json({
    erro: "CPF não encontrado na base de dados",
    });
    }

    const codigoReferral = gerarCodigoReferral();

    usuarios.set(usuarioId, {
    id: usuarioId,
    cpf: cpfLimpo,
    nome: dados.name,
    dataNascimento: dados.birthDate,
    codigoReferral,
    indicacoesRealizadas: 0,
    bonusAcumulado: 0,
    habilitadoEm: new Date().toISOString(),
    });

    cpfsRegistrados.add(cpfLimpo);

    res.json({
    sucesso: true,
    codigoReferral,
    mensagem: `Referral habilitado para ${dados.name}`,
    });
    } catch (error) {
    res.status(503).json({ erro: error.message });
    }
});

// Endpoint: cadastro via indicação
app.post("/api/referral/cadastro", async (req, res) => {
    const { nome, email, cpf, codigoReferral } = req.body;

    if (!cpf || !codigoReferral) {
    return res.status(400).json({
    erro: "CPF e código de indicação são obrigatórios",
    });
    }

    const cpfLimpo = limparCpf(cpf);

    // Verifica se o código de referral existe
    const indicador = [...usuarios.values()].find(
    (u) => u.codigoReferral === codigoReferral
    );

    if (!indicador) {
    return res.status(404).json({ erro: "Código de indicação inválido" });
    }

    // Proteção 1: CPF do indicado não pode ser igual ao do indicador
    if (cpfLimpo === indicador.cpf) {
    return res.status(403).json({
    erro: "Não é possível usar o próprio código de indicação",
    });
    }

    // Proteção 2: CPF não pode estar em uso
    if (cpfsRegistrados.has(cpfLimpo)) {
    return res.status(409).json({
    erro: "Este CPF já possui uma conta na plataforma",
    });
    }

    // Proteção 3: validar CPF via API
    try {
    const dados = await consultarCpf(cpfLimpo);
    if (!dados) {
    return res.status(422).json({
    erro: "CPF não encontrado na base de dados",
    });
    }

    // Proteção 4: verificar que são pessoas diferentes
    // (mesmo sobrenome + mesma data nascimento pode indicar fraude familiar)
    const sobrenomeIndicador = indicador.nome.split(" ").pop().toUpperCase();
    const sobrenomeIndicado = dados.name.split(" ").pop().toUpperCase();
    const mesmoSobrenome = sobrenomeIndicador === sobrenomeIndicado;
    const mesmaFamilia =
    mesmoSobrenome &&
    dados.birthDate &&
    indicador.dataNascimento &&
    dados.year === indicador.dataNascimento.split("/").pop();

    const novoUsuarioId = crypto.randomUUID();

    usuarios.set(novoUsuarioId, {
    id: novoUsuarioId,
    cpf: cpfLimpo,
    nome: dados.name,
    dataNascimento: dados.birthDate,
    indicadoPor: indicador.id,
    codigoReferral: gerarCodigoReferral(),
    indicacoesRealizadas: 0,
    bonusAcumulado: 0,
    habilitadoEm: new Date().toISOString(),
    });

    cpfsRegistrados.add(cpfLimpo);

    // Registra a indicação (bônus pendente até primeira compra)
    indicacoes.set(`${indicador.id}-${novoUsuarioId}`, {
    indicadorId: indicador.id,
    indicadoId: novoUsuarioId,
    status: "PENDENTE",
    alertaFamiliar: mesmaFamilia,
    criadoEm: new Date().toISOString(),
    });

    res.json({
    sucesso: true,
    usuarioId: novoUsuarioId,
    indicadoPor: indicador.nome,
    bonusPendente: true,
    alertaRevisao: mesmaFamilia,
    mensagem: mesmaFamilia
    ? "Cadastro realizado. Bônus sujeito a revisão manual."
    : "Cadastro realizado. Bônus será liberado após primeira compra.",
    });
    } catch (error) {
    res.status(503).json({ erro: error.message });
    }
});

// Endpoint: liberar bônus após primeira compra
app.post("/api/referral/liberar-bonus", async (req, res) => {
    const { indicadoId, valorCompra } = req.body;

    const indicado = usuarios.get(indicadoId);
    if (!indicado || !indicado.indicadoPor) {
    return res.status(404).json({ erro: "Indicação não encontrada" });
    }

    const chave = `${indicado.indicadoPor}-${indicadoId}`;
    const indicacao = indicacoes.get(chave);

    if (!indicacao || indicacao.status !== "PENDENTE") {
    return res.status(400).json({ erro: "Bônus já processado ou inexistente" });
    }

    // Verifica se a compra atinge o valor mínimo
    const VALOR_MINIMO = 50.0;
    if (valorCompra < VALOR_MINIMO) {
    return res.status(400).json({
    erro: `Compra mínima de R$ ${VALOR_MINIMO} para ativar bônus`,
    });
    }

    // Se há alerta familiar, requer revisão manual
    if (indicacao.alertaFamiliar) {
    indicacao.status = "REVISAO_MANUAL";
    return res.json({
    sucesso: true,
    status: "REVISAO_MANUAL",
    mensagem: "Bônus encaminhado para revisão manual",
    });
    }

    // Libera bônus para ambos
    const BONUS_INDICADOR = 25.0;
    const BONUS_INDICADO = 25.0;

    const indicador = usuarios.get(indicado.indicadoPor);
    indicador.bonusAcumulado += BONUS_INDICADOR;
    indicador.indicacoesRealizadas += 1;
    indicado.bonusAcumulado += BONUS_INDICADO;
    indicacao.status = "LIBERADO";

    res.json({
    sucesso: true,
    bonusIndicador: BONUS_INDICADOR,
    bonusIndicado: BONUS_INDICADO,
    mensagem: "Bônus liberado para ambos os participantes",
    });
});

app.listen(3000, () => {
    console.log("Servidor rodando na porta 3000");
});