Cobrá con CVU, conciliá solo y pagá retiros desde tu sistema

{
  "event": "transaction.confirmed",
  "data": {
    "id": "0f5c1e7a-3b2d-4e8f-9a6c-1d2e3f4a5b6c",
    "codigo_coelsa": "MP36D4CPEC9G",
    "monto": 25000,
    "contraparte_nombre": "MICAELA SOSA",
    "contraparte_cuil_cuit": "27402187354",
    "status": "confirmada"
  }
}

{
  "event": "transaction.in_review",
  "data": {
    "id": "2b4d6f8a-0c1e-4a3b-9d5f-7e9a1c3e5b70",
    "codigo_coelsa": "A45B2KP73A9G",
    "monto": 45000,
    "contraparte_nombre": "EZEQUIEL DOMINGUEZ",
    "contraparte_cuil_cuit": "20384551276",
    "status": "en_revision",
    "motivo": "monto_menor"
  }
}

{
  "event": "transaction.refunded",
  "data": {
    "id": "6c8e0a2b-4d6f-4c8e-a0b2-5d7f9b1c3e4a",
    "codigo_coelsa": "QJ7P2WM4ND8K",
    "monto": 35000,
    "contraparte_nombre": "MARTIN CORREA",
    "contraparte_cuil_cuit": "20403321987",
    "status": "devuelta",
    "motivo": "posible_duplicado"
  }
}

{
  "event": "withdrawal.completed",
  "data": {
    "coelsa_id": "N4QX8T2LMC5R",
    "monto": 1500000,
    "cbu": "0070999830004123456781",
    "status": "done"
  }
}

{
  "event": "withdrawal.completed",
  "data": {
    "coelsa_id": "N4QX8T2LMC5R",
    "monto": 1500000,
    "cbu": "0070999830004123456781",
    "status": "done",
    "conciliado": true
  }
}

{
  "event": "withdrawal.pending",
  "data": {
    "coelsa_id": "N4QX8T2LMC5R",
    "monto": 1500000,
    "cbu": "0070999830004123456781",
    "status": "pending"
  }
}

{
  "event": "withdrawal.pending",
  "data": {
    "monto": 1500000,
    "cbu": "0070999830004123456781",
    "status": "unknown"
  }
}

{
  "event": "withdrawal.failed",
  "data": {
    "monto": 92500,
    "cbu": "2850590940090418135209",
    "status": "error"
  }
}

const crypto = require('node:crypto');

// cuerpoCrudo: Buffer con el cuerpo tal cual llegó (antes de cualquier JSON.parse)
function firmaValida(secreto, cuerpoCrudo, encabezado) {
  if (typeof encabezado !== 'string') return false;
  const recibida = encabezado.trim().replace(/^sha256=/i, '').toLowerCase();
  if (!/^[0-9a-f]{64}$/.test(recibida)) return false;
  const esperada = crypto.createHmac('sha256', secreto).update(cuerpoCrudo).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(recibida, 'hex'), Buffer.from(esperada, 'hex'));
}

// Con Express: app.post('/webhooks/cobros', express.raw({ type: 'application/json' }), (req, res) => {
//   if (!firmaValida(process.env.WEBHOOK_SECRET, req.body, req.get('X-Webhook-Signature'))) return res.sendStatus(401);
//   res.sendStatus(200);  // respondé primero, procesá después
// });

// $cuerpoCrudo = file_get_contents('php://input');  (nunca json_encode(json_decode(...)))
function firmaValida(string $secreto, string $cuerpoCrudo, string $encabezado): bool
{
    $recibida = strtolower((string) preg_replace('/^sha256=/i', '', trim($encabezado)));
    if (!preg_match('/^[0-9a-f]{64}$/', $recibida)) {
        return false;
    }
    $esperada = hash_hmac('sha256', $cuerpoCrudo, $secreto);
    return hash_equals($esperada, $recibida);
}

$secreto = getenv('WEBHOOK_SECRET');
if ($secreto === false || $secreto === '') {   // sin secreto, nunca aceptes un aviso
    http_response_code(500);
    exit;
}
$valida = firmaValida(
    $secreto,
    file_get_contents('php://input'),
    $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'] ?? ''
);

import hashlib
import hmac
import re

# cuerpo_crudo: bytes tal cual llegaron (en Flask: request.get_data(); en Django: request.body)
def firma_valida(secreto: str, cuerpo_crudo: bytes, encabezado) -> bool:
    if not encabezado:
        return False
    recibida = re.sub(r"^sha256=", "", encabezado.strip(), flags=re.IGNORECASE).lower()
    if not re.fullmatch(r"[0-9a-f]{64}", recibida):
        return False
    esperada = hmac.new(secreto.encode("utf-8"), cuerpo_crudo, hashlib.sha256).hexdigest()
    return hmac.compare_digest(esperada, recibida)

// Lucky Cobros · servidor mínimo que recibe los avisos (webhooks) y verifica la firma.
//
// Uso (Node 18 o superior, sin dependencias):
//   WEBHOOK_SECRET="el-mismo-secreto-que-configuraste" node verificar-firma.js
// Escucha en http://localhost:3000/webhooks/cobros (cambiá el puerto con PORT=8080).
//
// Reglas que sigue este ejemplo:
//   1. La firma se calcula sobre el cuerpo CRUDO, byte por byte. No lo parsees ni lo vuelvas a serializar antes.
//   2. La comparación es en tiempo constante (crypto.timingSafeEqual).
//   3. Responde 200 enseguida y procesa después: tu demora retrasa el resto de la operación.
//   4. Deduplica: el mismo aviso no se procesa dos veces.
'use strict';

const http = require('node:http');
const crypto = require('node:crypto');

const SECRETO = process.env.WEBHOOK_SECRET;
const PUERTO = Number(process.env.PORT) || 3000;
const RUTA = '/webhooks/cobros';

if (!SECRETO) {
  console.error('Falta WEBHOOK_SECRET: usá el mismo secreto que configuraste con PUT /external/webhook.');
  process.exit(1);
}

/** true si el encabezado X-Webhook-Signature corresponde a este cuerpo y este secreto. */
function firmaValida(secreto, cuerpoCrudo, encabezado) {
  if (typeof encabezado !== 'string') return false;
  const recibida = encabezado.trim().replace(/^sha256=/i, '').toLowerCase();
  if (!/^[0-9a-f]{64}$/.test(recibida)) return false;
  const esperada = crypto.createHmac('sha256', secreto).update(cuerpoCrudo).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(recibida, 'hex'), Buffer.from(esperada, 'hex'));
}

/** Clave para no procesar dos veces el mismo aviso (null = no hay código para deduplicar). */
function claveDeDuplicado(aviso) {
  const d = aviso.data || {};
  // Un mismo cobro puede recibir transaction.in_review y después confirmed o refunded: la clave lleva el evento.
  if (aviso.event.startsWith('transaction.')) return d.id ? aviso.event + ':' + d.id : null;
  if (aviso.event.startsWith('withdrawal.')) return d.coelsa_id ? aviso.event + ':' + d.coelsa_id : null;
  return null;
}

// En producción guardá las claves en tu base, con un índice único. Acá alcanza con memoria.
const procesados = new Set();

function procesar(aviso) {
  const d = aviso.data;
  switch (aviso.event) {
    case 'transaction.confirmed':
      // Ya está en tu saldo: acreditá d.monto al jugador con CUIT d.contraparte_cuil_cuit.
      console.log(`[cobro] ${aviso.event} · acreditar $ ${d.monto} de ${d.contraparte_nombre} (${d.contraparte_cuil_cuit}) · código ${d.codigo_coelsa}`);
      break;
    case 'transaction.in_review':
    case 'transaction.refunded':
      // No acredites. in_review: queda retenido hasta que tu equipo lo resuelva en el panel (después llega
      // confirmed o refunded con el mismo data.id). refunded: se le devolvió a quien transfirió.
      console.log(`[cobro] ${aviso.event} · no se acredita · $ ${d.monto} de ${d.contraparte_nombre} · motivo ${d.motivo || '-'}`);
      break;
    case 'withdrawal.completed':
    case 'withdrawal.pending':
    case 'withdrawal.failed':
      // Buscá tu retiro abierto por cbu + monto (o por coelsa_id si ya lo tenías) y actualizá su estado.
      console.log(`[retiro] ${aviso.event} · status ${d.status} · $ ${d.monto} a ${d.cbu}${d.coelsa_id ? ' · código ' + d.coelsa_id : ''}`);
      break;
    default:
      console.log(`[aviso] evento nuevo, lo ignoramos: ${aviso.event}`);
  }
}

const servidor = http.createServer((req, res) => {
  const ruta = (req.url || '').split('?')[0];
  if (req.method !== 'POST' || ruta !== RUTA) {
    res.writeHead(404).end();
    return;
  }

  const partes = [];
  req.on('data', (parte) => partes.push(parte));
  req.on('end', () => {
    const cuerpoCrudo = Buffer.concat(partes);

    if (!firmaValida(SECRETO, cuerpoCrudo, req.headers['x-webhook-signature'])) {
      res.writeHead(401, { 'Content-Type': 'application/json' }).end('{"ok":false,"motivo":"firma inválida"}');
      return;
    }

    let aviso;
    try {
      aviso = JSON.parse(cuerpoCrudo.toString('utf8'));
    } catch {
      res.writeHead(400, { 'Content-Type': 'application/json' }).end('{"ok":false,"motivo":"JSON inválido"}');
      return;
    }

    // 1) Respondé 2xx rápido.
    res.writeHead(200, { 'Content-Type': 'application/json' }).end('{"ok":true}');

    // 2) Procesá después, sin repetir.
    setImmediate(() => {
      const clave = claveDeDuplicado(aviso);
      if (clave && procesados.has(clave)) {
        console.log(`[aviso] repetido, no se procesa de nuevo: ${clave}`);
        return;
      }
      if (clave) procesados.add(clave);
      procesar(aviso);
    });
  });
});

servidor.listen(PUERTO, () => {
  console.log(`Esperando avisos en http://localhost:${PUERTO}${RUTA}`);
});

<?php
// Lucky Cobros · servidor mínimo que recibe los avisos (webhooks) y verifica la firma.
//
// Uso (PHP 7.4 o superior, sin dependencias):
//   WEBHOOK_SECRET="el-mismo-secreto-que-configuraste" php -S localhost:3000 verificar-firma.php
// Escucha en http://localhost:3000/webhooks/cobros
// (En Windows PowerShell: $env:WEBHOOK_SECRET="..."; php -S localhost:3000 verificar-firma.php)
//
// Reglas que sigue este ejemplo:
//   1. La firma se calcula sobre el cuerpo CRUDO (php://input). No uses json_encode para rearmarlo.
//   2. La comparación es en tiempo constante (hash_equals).
//   3. Responde 200 enseguida y procesa después.
//   4. Deduplica: el mismo aviso no se procesa dos veces.
declare(strict_types=1);

const RUTA = '/webhooks/cobros';

$secreto = getenv('WEBHOOK_SECRET') ?: '';
if ($secreto === '') {
    http_response_code(500);
    error_log('Falta WEBHOOK_SECRET: usá el mismo secreto que configuraste con PUT /external/webhook.');
    exit;
}

/** true si el encabezado X-Webhook-Signature corresponde a este cuerpo y este secreto. */
function firmaValida(string $secreto, string $cuerpoCrudo, string $encabezado): bool
{
    $recibida = strtolower((string) preg_replace('/^sha256=/i', '', trim($encabezado)));
    if (!preg_match('/^[0-9a-f]{64}$/', $recibida)) {
        return false;
    }
    $esperada = hash_hmac('sha256', $cuerpoCrudo, $secreto);
    return hash_equals($esperada, $recibida);
}

/** Clave para no procesar dos veces el mismo aviso (null = no hay código para deduplicar). */
function claveDeDuplicado(array $aviso): ?string
{
    $evento = (string) ($aviso['event'] ?? '');
    $d = $aviso['data'] ?? [];
    // Un mismo cobro puede recibir transaction.in_review y después confirmed o refunded: la clave lleva el evento.
    if (strpos($evento, 'transaction.') === 0) {
        return isset($d['id']) ? $evento . ':' . $d['id'] : null;
    }
    if (strpos($evento, 'withdrawal.') === 0) {
        return isset($d['coelsa_id']) ? $evento . ':' . $d['coelsa_id'] : null;
    }
    return null;
}

/** Devuelve true la primera vez que ve la clave. En producción, usá tu base con un índice único. */
function primeraVez(string $clave): bool
{
    // Fuera de la carpeta pública del servidor web: si quedara adentro, se podría descargar.
    $archivo = sys_get_temp_dir() . '/lucky-cobros-avisos-procesados.txt';
    $fp = fopen($archivo, 'c+');
    flock($fp, LOCK_EX);
    $vistos = array_filter(explode("\n", (string) stream_get_contents($fp)));
    $nueva = !in_array($clave, $vistos, true);
    if ($nueva) {
        fseek($fp, 0, SEEK_END);
        fwrite($fp, $clave . "\n");
    }
    flock($fp, LOCK_UN);
    fclose($fp);
    return $nueva;
}

function procesar(array $aviso): void
{
    $d = $aviso['data'] ?? [];
    switch ($aviso['event']) {
        case 'transaction.confirmed':
            // Ya está en tu saldo: acreditá $d['monto'] al jugador con CUIT $d['contraparte_cuil_cuit'].
            error_log(sprintf('[cobro] %s · acreditar $ %s de %s (%s) · código %s', $aviso['event'], $d['monto'],
                $d['contraparte_nombre'] ?? '', $d['contraparte_cuil_cuit'] ?? '', $d['codigo_coelsa'] ?? ''));
            break;
        case 'transaction.in_review':
        case 'transaction.refunded':
            // No acredites. in_review: queda retenido hasta que tu equipo lo resuelva en el panel (después llega
            // confirmed o refunded con el mismo data.id). refunded: se le devolvió a quien transfirió.
            error_log(sprintf('[cobro] %s · no se acredita · $ %s de %s · motivo %s', $aviso['event'], $d['monto'],
                $d['contraparte_nombre'] ?? '', $d['motivo'] ?? '-'));
            break;
        case 'withdrawal.completed':
        case 'withdrawal.pending':
        case 'withdrawal.failed':
            // Buscá tu retiro abierto por cbu + monto (o por coelsa_id) y actualizá su estado.
            error_log(sprintf('[retiro] %s · status %s · $ %s a %s', $aviso['event'], $d['status'], $d['monto'], $d['cbu']));
            break;
        default:
            error_log('[aviso] evento nuevo, lo ignoramos: ' . $aviso['event']);
    }
}

$ruta = parse_url($_SERVER['REQUEST_URI'] ?? '/', PHP_URL_PATH);
if (($_SERVER['REQUEST_METHOD'] ?? '') !== 'POST' || $ruta !== RUTA) {
    http_response_code(404);
    exit;
}

$cuerpoCrudo = (string) file_get_contents('php://input');
$firma = $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'] ?? '';

header('Content-Type: application/json');

if (!firmaValida($secreto, $cuerpoCrudo, $firma)) {
    http_response_code(401);
    echo '{"ok":false,"motivo":"firma inválida"}';
    exit;
}

$aviso = json_decode($cuerpoCrudo, true);
if (!is_array($aviso) || !isset($aviso['event'])) {
    http_response_code(400);
    echo '{"ok":false,"motivo":"JSON inválido"}';
    exit;
}

// 1) Respondé 2xx rápido.
http_response_code(200);
echo '{"ok":true}';
if (function_exists('fastcgi_finish_request')) {
    fastcgi_finish_request(); // con PHP-FPM, corta la respuesta acá y sigue procesando
} else {
    flush();
}

// 2) Procesá después, sin repetir.
$clave = claveDeDuplicado($aviso);
if ($clave !== null && !primeraVez($clave)) {
    error_log('[aviso] repetido, no se procesa de nuevo: ' . $clave);
    exit;
}
procesar($aviso);

"""Lucky Cobros · servidor mínimo que recibe los avisos (webhooks) y verifica la firma.

Uso (Python 3.8 o superior, solo biblioteca estándar):
    WEBHOOK_SECRET="el-mismo-secreto-que-configuraste" python verificar-firma.py
Escucha en http://localhost:3000/webhooks/cobros (cambiá el puerto con PORT=8080).
(En Windows PowerShell: $env:WEBHOOK_SECRET="..."; python verificar-firma.py)

Reglas que sigue este ejemplo:
  1. La firma se calcula sobre el cuerpo CRUDO (bytes). No lo parsees ni lo vuelvas a serializar antes.
  2. La comparación es en tiempo constante (hmac.compare_digest).
  3. Responde 200 enseguida y procesa después.
  4. Deduplica: el mismo aviso no se procesa dos veces.
"""
import hashlib
import hmac
import json
import os
import re
import sys
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

SECRETO = os.environ.get("WEBHOOK_SECRET", "")
PUERTO = int(os.environ.get("PORT", "3000"))
RUTA = "/webhooks/cobros"

if not SECRETO:
    sys.exit("Falta WEBHOOK_SECRET: usá el mismo secreto que configuraste con PUT /external/webhook.")

HEX64 = re.compile(r"^[0-9a-f]{64}$")


def firma_valida(secreto: str, cuerpo_crudo: bytes, encabezado) -> bool:
    """True si el encabezado X-Webhook-Signature corresponde a este cuerpo y este secreto."""
    if not encabezado:
        return False
    recibida = re.sub(r"^sha256=", "", encabezado.strip(), flags=re.IGNORECASE).lower()
    if not HEX64.match(recibida):
        return False
    esperada = hmac.new(secreto.encode("utf-8"), cuerpo_crudo, hashlib.sha256).hexdigest()
    return hmac.compare_digest(esperada, recibida)


def clave_de_duplicado(aviso: dict):
    """Clave para no procesar dos veces el mismo aviso (None = no hay código para deduplicar)."""
    evento = aviso.get("event", "")
    d = aviso.get("data") or {}
    # Un mismo cobro puede recibir transaction.in_review y después confirmed o refunded: la clave lleva el evento.
    if evento.startswith("transaction."):
        return f"{evento}:{d['id']}" if d.get("id") else None
    if evento.startswith("withdrawal."):
        return f"{evento}:{d['coelsa_id']}" if d.get("coelsa_id") else None
    return None


# En producción guardá las claves en tu base, con un índice único. Acá alcanza con memoria.
procesados = set()
candado = threading.Lock()


def procesar(aviso: dict) -> None:
    evento, d = aviso["event"], aviso.get("data") or {}
    if evento == "transaction.confirmed":
        # Ya está en tu saldo: acreditá d["monto"] al jugador con CUIT d["contraparte_cuil_cuit"].
        print(f"[cobro] {evento} · acreditar $ {d.get('monto')} de {d.get('contraparte_nombre')} "
              f"({d.get('contraparte_cuil_cuit')}) · código {d.get('codigo_coelsa')}", flush=True)
    elif evento in ("transaction.in_review", "transaction.refunded"):
        # No acredites. in_review: queda retenido hasta que tu equipo lo resuelva en el panel (después llega
        # confirmed o refunded con el mismo data.id). refunded: se le devolvió a quien transfirió.
        print(f"[cobro] {evento} · no se acredita · $ {d.get('monto')} de {d.get('contraparte_nombre')} "
              f"· motivo {d.get('motivo') or '-'}", flush=True)
    elif evento.startswith("withdrawal."):
        # Buscá tu retiro abierto por cbu + monto (o por coelsa_id) y actualizá su estado.
        print(f"[retiro] {evento} · status {d.get('status')} · $ {d.get('monto')} a {d.get('cbu')}", flush=True)
    else:
        print(f"[aviso] evento nuevo, lo ignoramos: {evento}", flush=True)


def procesar_sin_repetir(aviso: dict) -> None:
    clave = clave_de_duplicado(aviso)
    if clave:
        with candado:
            if clave in procesados:
                print(f"[aviso] repetido, no se procesa de nuevo: {clave}", flush=True)
                return
            procesados.add(clave)
    procesar(aviso)


class Receptor(BaseHTTPRequestHandler):
    def _responder(self, codigo: int, cuerpo: dict) -> None:
        datos = json.dumps(cuerpo, ensure_ascii=False).encode("utf-8")
        self.send_response(codigo)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(datos)))
        self.end_headers()
        self.wfile.write(datos)

    def _leer_cuerpo(self) -> bytes:
        """Cuerpo crudo, venga con Content-Length o en partes (Transfer-Encoding: chunked)."""
        if "chunked" in (self.headers.get("Transfer-Encoding") or "").lower():
            partes = []
            while True:
                tam = int(self.rfile.readline().split(b";")[0].strip() or b"0", 16)
                if tam == 0:
                    while self.rfile.readline() not in (b"\r\n", b"\n", b""):
                        pass  # encabezados finales, si los hay
                    return b"".join(partes)
                partes.append(self.rfile.read(tam))
                self.rfile.readline()  # fin de línea de cada parte
        return self.rfile.read(int(self.headers.get("Content-Length") or 0))

    def do_GET(self):  # los avisos siempre llegan por POST
        self._responder(404, {"ok": False})

    def do_POST(self):
        if self.path.split("?")[0] != RUTA:
            self._responder(404, {"ok": False})
            return

        cuerpo_crudo = self._leer_cuerpo()

        if not firma_valida(SECRETO, cuerpo_crudo, self.headers.get("X-Webhook-Signature")):
            self._responder(401, {"ok": False, "motivo": "firma inválida"})
            return

        try:
            aviso = json.loads(cuerpo_crudo.decode("utf-8"))
        except ValueError:
            self._responder(400, {"ok": False, "motivo": "JSON inválido"})
            return

        # 1) Respondé 2xx rápido.  2) Procesá después, sin repetir.
        self._responder(200, {"ok": True})
        threading.Thread(target=procesar_sin_repetir, args=(aviso,), daemon=True).start()

    def log_message(self, formato, *args):  # silencia el log por pedido
        pass


if __name__ == "__main__":
    print(f"Esperando avisos en http://localhost:{PUERTO}{RUTA}", flush=True)
    ThreadingHTTPServer(("0.0.0.0", PUERTO), Receptor).serve_forever()

// 1) El jugador pide depositar $ 25.000 en tu sitio
const respuesta = await fetch('https://api.luckycobros.com.ar/api/v1/external/deposit/create', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.LUCKY_API_KEY,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    monto: 25000,
    contraparte_cuil_cuit: jugador.cuit,           // 11 dígitos, sin guiones
    traffic_type: jugador.yaDeposito ? 'std' : 'ftd',
  }),
});
const deposito = await respuesta.json(); // hoy solo llegan id, cvu y expires_at

// 2) Guardalo y mostrale el CVU al jugador
await db.depositos.insert({
  id: deposito.id, jugadorId: jugador.id, cuit: jugador.cuit,
  monto: 25000, cvu: deposito.cvu, estado: 'esperando',
});
mostrar('Transferí $ 25.000,00 al CVU ' + deposito.cvu + ' desde una cuenta a tu nombre.');

// 1) El jugador pide depositar $ 25.000 en tu sitio
$ch = curl_init('https://api.luckycobros.com.ar/api/v1/external/deposit/create');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => ['X-API-Key: ' . getenv('LUCKY_API_KEY'), 'Content-Type: application/json'],
    CURLOPT_POSTFIELDS => json_encode([
        'monto' => 25000,
        'contraparte_cuil_cuit' => $jugador['cuit'],   // 11 dígitos, sin guiones
        'traffic_type' => $jugador['ya_deposito'] ? 'std' : 'ftd',
    ]),
]);
$deposito = json_decode(curl_exec($ch), true); // hoy solo llegan id, cvu y expires_at
curl_close($ch);

// 2) Guardalo y mostrale el CVU al jugador
$db->insert('depositos', [
    'id' => $deposito['id'], 'jugador_id' => $jugador['id'], 'cuit' => $jugador['cuit'],
    'monto' => 25000, 'cvu' => $deposito['cvu'], 'estado' => 'esperando',
]);

import os
import requests

# 1) El jugador pide depositar $ 25.000 en tu sitio
deposito = requests.post(
    "https://api.luckycobros.com.ar/api/v1/external/deposit/create",
    headers={"X-API-Key": os.environ["LUCKY_API_KEY"]},
    json={
        "monto": 25000,
        "contraparte_cuil_cuit": jugador["cuit"],      # 11 dígitos, sin guiones
        "traffic_type": "std" if jugador["ya_deposito"] else "ftd",
    },
    timeout=30,
).json()  # hoy solo llegan id, cvu y expires_at

# 2) Guardalo y mostrale el CVU al jugador
db.depositos.insert(id=deposito["id"], jugador_id=jugador["id"], cuit=jugador["cuit"],
                    monto=25000, cvu=deposito["cvu"], estado="esperando")