Esta guía documenta el mismo flujo de clave de prueba de transacción privada utilizado por timeline.php para pagos de acceso a Timeline. Está diseñado para desarrolladores que necesitan aceptar pagos privados SynX, verificar el monto exacto y mantener los datos de la dirección fuera de su aplicación.

• Lo que recibe del pagador: un 64 caracteres tx_hash y una clave de prueba. La clave de prueba puede ser de 64 hexadecimal sin formato o con el prefijo como PT- más 64 hexadecimales.
• Lo que demuestra el API: si esa clave de prueba es válida para esa transacción y el monto exacto de SynX.
• Lo que el API no revela: dirección del remitente, dirección del destinatario, saldo de la billetera o una ruta de pago pública para transacciones privadas.
• Criterio de valoración principal: POST /explorer/api/verify_proof.php con cuerpo JSON {"tx_hash":"...","proof_key":"..."}.

Implementación de claves de prueba como la línea de tiempo

Timeline acepta pagos visibles del mercado automáticamente. Cuando una transacción es privada u oculta, cambia a verificación con clave de prueba. La clave de comprobante confirma el monto del pago mientras los campos de dirección permanecen sellados.

Verificador PHP estilo línea de tiempo

function normalize_synx_proof_key(string $proofKey): string {
  $proofKey = preg_replace('/\s+/', '', trim($proofKey));
  return $proofKey ?? '';
}

function verify_private_synx_payment(string $txHash, string $proofKey, float $requiredAmount): array {
  $txHash = strtolower(trim($txHash));
  $proofKey = normalize_synx_proof_key($proofKey);

  if (!preg_match('/^[a-f0-9]{64}$/', $txHash)) {
    return ['ok' => false, 'reason' => 'tx_hash must be exactly 64 hex characters'];
  }
  if (!preg_match('/^(PT-)?[a-fA-F0-9]{64}$/', $proofKey)) {
    return ['ok' => false, 'reason' => 'proof_key must be 64 hex characters, with optional PT- prefix'];
  }

  $response = file_get_contents('https://synxcrypto.com/explorer/api/verify_proof.php', false, stream_context_create([
    'http' => [
      'method' => 'POST',
      'header' => "Content-Type: application/json\r\nAccept: application/json\r\n",
      'content' => json_encode(['tx_hash' => $txHash, 'proof_key' => $proofKey]),
      'timeout' => 15,
      'ignore_errors' => true,
    ]
  ]));

  $data = json_decode($response ?: '', true);
  if (!is_array($data) || empty($data['valid'])) {
    return ['ok' => false, 'reason' => $data['hint'] ?? $data['error'] ?? 'proof could not be verified'];
  }

  $paid = is_numeric($data['amount'] ?? null) ? (float)$data['amount'] : 0.0;
  if (abs($paid - $requiredAmount) > 0.0001) {
    return ['ok' => false, 'reason' => "amount mismatch: paid {$paid}, required {$requiredAmount}"];
  }

  return ['ok' => true, 'amount' => $paid, 'currency' => $data['currency'] ?? 'SYNX'];
}

Campos de respuesta de los que depender

🌊 Por qué nunca revelamos al remitente o al destinatario

Este es el principio fundamental. La transparencia del código abierto y la privacidad del usuario son enemigos naturales, a menos que se diseñen los límites correctamente. SynergyX resuelve esto haciendo que el protocolo transparente (cualquiera puede auditar el código) manteniendo identidad permanentemente opaco (no existe ningún mecanismo para revelar al remitente o al destinatario). La clave de prueba es una clave de rompecabezas: desbloquea la cantidad y solo La cantidad. Las identidades detrás de la transacción se disolvieron en el Synergy Sea en el momento en que se selló el bloque.

El nodo SynX genera la clave de prueba utilizando cifrado de celosía cuántica Kyber-768. La clave está matemáticamente vinculada al monto de la transacción. No se puede falsificar, no se puede aplicar ingeniería inversa y caduca en 30 minutos. El remitente comparte la clave de prueba con el destinatario fuera de la cadena: Signal, PGP, Tor, una servilleta. El destinatario verifica a través de este API. Ese es todo el modelo de confianza. Sin custodia. Sin intermediario. Sin rastro de metadatos.

⛨ Lo que sabe el servidor (Jack)

Seamos honestos acerca de los límites de confianza. Estás golpeando un API. El servidor es una máquina y las máquinas pueden ser confiscadas. Esto es exactamente lo que obtiene un atacante si rootea el cuadro:

Se mitiga el tiempo. Cada respuesta API (GET, POST, éxito, fracaso, 404, todo) se completa con un Techo constante de 500 ms. El servidor mide el tiempo de procesamiento real y luego duerme exactamente 500ms - elapsed. Cada respuesta tarda exactamente 500 ms. No al azar. Constante. d de Cohen entre caminos válidos e inválidos: 0.015 (probado por GhostReaper - estadísticamente invisible). ¿El libro de jugadas del oráculo del tiempo de Chainalysis? Muerto al llegar.

🌊 El Synergy Sea: dos capas de profundidad

Piense en la cadena como un océano. Las transacciones públicas flotan en la superficie. Los privados se hunden. Cuanto más profundizas, más necesitas claves de prueba para ver algo. E incluso a máxima profundidad, sólo el cantidad superficies, nunca direcciones.

No existe ninguna capa más profunda. No hay divulgación de claves de vista, ni auditoría de direcciones, ni mecanismo para revelar quién envió o recibió. La clave de prueba, generada por el nodo SynX mediante cifrado cuántico Kyber-768, decodifica la cantidad exacta. Eso es lo más profundo que cualquiera puede llegar. Las direcciones de remitente y destinatario quedan permanentemente ahogadas en el mar.

Armadura anticorrelación: Las marcas de tiempo están borrosas ±120 s. Tarifas divididas en 5 niveles (micro/bajo/estándar/alto/premium, nunca el monto bruto sat). Alturas de bloque anuladas. Los tiempos de respuesta aumentaron hasta un techo constante de 500 ms. "TX no encontrado" y "TX es privado" devuelven el forma idéntica. Las claves de prueba caducan en 30 minutos – limitar las ventanas de repetición a casi cero. Ni siquiera puedes enumerar qué hashes son reales. Cada consulta de superficie devuelve la misma cantidad de información, ya sea que el TX exista, no exista o esté protegido. Buena suerte, Chainalysis.

—͟͟͞͞★ Verificación de prueba de proveedor: 3 minutos, confianza cero

Eres un vendedor. Un comprador acaba de pagarte en privado SynX. Debes verificar el pago sin ver su dirección, su saldo ni confiar en ningún tercero. Así es como. Sin KYC. Sin custodia. Demuestre que los pagos son ciegos.

# What the buyer sends you (encrypted channel only)
tx_hash:    "a1b2c3d4e5f6789012345678901234567890123456789012345678901234abcd"
proof_key:  "PT-f7e8d9c0b1a23456789012345678901234567890123456789012345678901234"

# cURL — verify the proof key (recommended endpoint)
curl -X POST https://explorer.synxcrypto.com/explorer/api/verify_proof.php \
  -H "Content-Type: application/json" \
  -d '{"tx_hash":"a1b2c3d4e5f6...64hex","proof_key":"f7e8d9c0...64hex"}'

# Through Tor (you should be doing this)
torsocks curl -X POST http://synxexplorer.onion/explorer/api/verify_proof.php \
  -H "Content-Type: application/json" \
  -d '{"tx_hash":"a1b2c3d4...","proof_key":"f7e8d9c0..."}'

# GET also works — quick terminal checks
curl "https://explorer.synxcrypto.com/explorer/api/verify_proof.php?tx_hash=a1b2c3d4...&proof_key=f7e8d9c0..."

{
  "valid": true,              // ← that's your money, ghost
  "tx_hash": "a1b2c3d4...",  // ← echoed back for confirmation
  "amount": "183.00",        // ← exact amount decoded from quantum lattice seal
  "currency": "SYNX",
  "confirmed_at": 1735689600,  // ← UNIX epoch when TX was inscribed on-chain
  "message": "Payment proof verified — this proof key is valid for the specified transaction"
}

𖣐 Rito de verificación completo

El paso 4 es el enlace crítico. La clave de prueba debe viajar remitente → receptor a través de un canal que el API nunca ve. Mensajes de señal que desaparecen. Correo electrónico cifrado con PGP. Servicio oculto Tor. Un código QR mostrado sobre una mesa. Una nota pegada con cinta adhesiva debajo de un banco del parque. Al API no le importa cómo llega el secreto: solo verifica las matemáticas cuando el receptor lo solicita.

POST /verify_proof: verificar una clave de prueba (recomendado)

CORREO CONSEGUIR PÚBLICO — La forma más sencilla de verificar un pago. Enviar tx_hash + proof_key en el cuerpo (o como GET parámetros). Devuelve la cantidad exacta. Sin autorización. Sin clave API. Sin cuenta. Empiece aquí.

// POST Request (JSON body) — recommended
{
  "tx_hash": "a1b2c3d4e5f6...64hex",
  "proof_key": "f7e8d9c0b1a2...64hex"
}
// "proof_token" also accepted as an alias for "proof_key"
// PT- prefix accepted: "PT-f7e8d9c0..." → server strips it automatically
// Also accepts form-encoded POST data or GET query parameters

// ✓ Response — seal broken, exact amount decoded
{
  "valid": true,
  "tx_hash": "a1b2c3d4...",
  "amount": "183.00",
  "currency": "SYNX",
  "confirmed_at": 1735689600,
  "message": "Payment proof verified — this proof key is valid for the specified transaction"
}

// ✗ Response — wrong proof key
{
  "valid": false,
  "tx_hash": "a1b2c3d4...",
  "error": "Proof key does not match this transaction",
  "hint": "The proof_key provided does not match this transaction. Ensure you received the correct proof key from the payment sender."
}

// ✗ Response — missing or malformed inputs
{
  "valid": false,
  "error": "Missing required parameters: tx_hash and proof_key",
  "hint": "Send tx_hash (64 hex chars) and proof_key (64 hex chars) as GET params, POST form data, or JSON body.",
  "example": {
    "GET": "/explorer/api/verify_proof.php?tx_hash=abc123...&proof_key=def456...",
    "POST": "{\"tx_hash\": \"abc123...\", \"proof_key\": \"def456...\"}"
  }
}

Referencia de errores completa: verificar_proof.php

POST /privacy/tx/{hash}/rune-verify — Sobre rúnico (metadatos enriquecidos)

CORREO PÚBLICO — Verificación de la misma clave de prueba con metadatos más ricos: ventana de marca de tiempo (±120 s difusa), cuenta regresiva de vencimiento, método de descifrado. Úselo cuando necesite más que solo la cantidad.

Alias: /explorer/api/privacy/tx/{hash}/proof

// Request — proof_token in body, tx_hash in URL path
{ "proof_token": "f7e8d9c0b1a2...64hex" }

// Response — seal broken, rich metadata
{
  "valid": true,
  "confirmed": true,
  "timestamp_range": { "earliest": 1735689480, "latest": 1735689720 },
  "amount_decoded": "183.00",
  "rune_lattice": "encrypted",
  "decrypted_by": "runic_proof_token",
  "expires_in_minutes": 24,
  "proof_algorithm": "Kyber-768 quantum lattice seal — addresses never disclosed"
}

// Response — invalid
{ "valid": false, "reason": "Proof token does not match any registered runic proof" }

// Response — expired
{ "valid": false, "reason": "Runic proof has expired" }

Lo que aprende el verificador versus lo que permanece ahogado

GET /privacy/tx/{hash}/verify - Oráculo de existencia

CONSEGUIR PÚBLICO — ¿Existe este TX? Devuelve un compromiso de existencia criptográfica. No revela nada más.

{
  "exists": true,
  "hash": "a1b2c3d4...",
  "confirmed": true,
  "confirmations": 142,
  "block_height": null,   // sealed — private TXs don't surface block info
  "is_private": true,
  "verified_at": 1735689600,
  "existence_proof": "9d4997cb84efc492...",
  "proof_algorithm": "HMAC-SHA256(tx_hash || block_height || date, server_key)"
}

GET /privacy/tx/{hash} — Búsqueda de transacciones en la sombra

CONSEGUIR PÚBLICO — Busque cualquier TX. Los privados devuelven la sombra: hash visible, todo lo demás null.

// Response — TX found (private shadow)
{
  "status": "found",
  "hash": "a1b2c3d4...",
  "message": "Transaction located",
  "transaction": {
    "hash": "a1b2c3d4...",
    "block_height": null,       // hidden
    "timestamp": 1735689600,   // fuzzy ±120s
    "from": null,               // drowned
    "to": null,                 // drowned
    "amount": null,             // drowned
    "fee_tier": "redacted",     // private TXs: fee tier sealed
    "is_private": true,
    "privacy_tier": "shadow",
    "status": "confirmed",
    "confirmations": 142,
    "existence_commitment": "7833cd43..."
  }
}

// Response — TX not found or shielded (identical shape prevents enumeration)
{
  "status": "not_found_or_private",
  "hash": "a1b2c3d4...",
  "message": "Transaction not found or may be shielded",
  "transaction": null
}

OBTENER /privacidad/reciente — Ondas de superficie

TX recientes. Los privados emergen como sombras (campos nulos). Los públicos muestran datos transparentes. Bueno para tableros. parámetro de consulta limit (1-50, predeterminado 20).

GET /privacy/stats — Lecturas de la profundidad del mar

Métricas de adopción de privacidad: TX totales, TX privados, porcentaje de adopción, indicadores de funciones. No se requiere autenticación. Monitoriza la profundidad del Mar desde tu propia infraestructura.

POST /privacy/batch-proof — Verificar por lotes varias pruebas

CORREO PÚBLICO — Verificar hasta 50 llaves de prueba en una sola solicitud. La misma verificación de demonio que los puntos finales de prueba única, pero por lotes para mayor eficiencia. Ideal para mercados que procesan múltiples pedidos o billeteras que verifican varios pagos entrantes a la vez.

// Request — array of proof pairs (max 50)
{
  "proofs": [
    { "tx_hash": "a1b2c3d4...64hex", "proof_token": "f7e8d9c0...64hex" },
    { "tx_hash": "b2c3d4e5...64hex", "proof_token": "PT-e8d9c0b1...67chars" }
  ]
}

// Response — per-proof results with summary
{
  "batch_size": 2,
  "results": [
    {
      "index": 0,
      "valid": true,
      "tx_hash": "a1b2c3d4...",
      "confirmed": true,
      "amount_decoded": "183.00",
      "rune_lattice": "encrypted"
    },
    {
      "index": 1,
      "valid": false,
      "tx_hash": "b2c3d4e5...",
      "reason": "Proof token mismatch"
    }
  ],
  "valid_count": 1,
  "invalid_count": 1
}

Límites de lotes y referencia de errores

🧅 Tor / .onion: encamina todo a través de la niebla

El API es REST sin estado sobre HTTPS. Sin galletas. Sin sesiones. Sin huellas dactilares JS. Sin actualizaciones de WebSocket. Solicitud pura → respuesta sobre TLS. Funciona en Tor de forma nativa porque lo construimos de esa manera. No como una ocurrencia tardía. Si estás construyendo algo privado y estás no al enrutar a través de .onion, está filtrando su IP a cada solucionador de DNS entre usted y el servidor. No.

enrollarse a través de Tor

# Install torsocks (Debian/Ubuntu)
sudo apt install torsocks

# Verify a payment — sovereign style
torsocks curl -X POST http://synxexplorer.onion/explorer/api/verify_proof.php \
  -H "Content-Type: application/json" \
  -d '{"tx_hash":"a1b2c3d4...","proof_key":"f7e8d9c0..."}'

Python a través de Tor (SOCKS5)

import requests

# pip install requests[socks] PySocks
session = requests.Session()
session.proxies = {
    'http':  'socks5h://127.0.0.1:9050',
    'https': 'socks5h://127.0.0.1:9050',
}

# socks5h = DNS resolution through Tor too (no DNS leak)
API = "http://synxexplorer.onion/explorer/api"

result = session.post(f"{API}/verify_proof.php",
                      json={"tx_hash": "a1b2c3d4...", "proof_key": "f7e8d9c0..."},
                      timeout=30).json()

if result.get("valid"):
    print(f"ᛣ Sealed — amount: {result['amount']} {result['currency']}")

Node.js a través de Tor

const { SocksProxyAgent } = require('socks-proxy-agent');
const fetch = require('node-fetch');

const agent = new SocksProxyAgent('socks5h://127.0.0.1:9050');
const API = 'http://synxexplorer.onion/explorer/api';

const r = await fetch(`${API}/verify_proof.php`, {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({tx_hash: 'a1b2c3d4...', proof_key: 'f7e8d9c0...'}),
  agent,
});
const data = await r.json();
if (data.valid) console.log('𖣐 Sovereign verified', data.amount, data.currency);

📡 Comparta claves de prueba a través de Signal: metadatos cero

La llave de prueba debe viajar remitente → receptor sin tocar el API. Aquí está la jerarquía OPSEC para ese traspaso:

Gancho de integración de señal (bot de Python)

# signal-cli or signal-bot framework — send proof key after payment
import subprocess, json

def send_proof_via_signal(recipient_phone, tx_hash, proof_key):
    """Send proof key through Signal. Disappearing message. Verify within 30 min."""
    msg = json.dumps({
        "tx_hash": tx_hash,
        "proof_key": proof_key,
        "verify_at": f"POST /verify_proof.php with tx_hash + proof_key",
        "expires": "30 minutes from generation — verify NOW",
    })
    subprocess.run([
        "signal-cli", "-u", "+1YOUR_NUMBER",
        "send", "-m", msg, recipient_phone,
        "--expire", "300",  # 5-min disappearing message
    ])

# After private SYNX send:
send_proof_via_signal("+1BUYER_PHONE", "a1b2c3d4...", "PT-f7e8d9c0...")

⚓ Rito de pago del mercado

Estás construyendo un mercado soberano. Sin rayas. Sin PayPal. Sin middleware KYC. Solo el Synergy Sea y las claves de prueba selladas cuánticamente. Así es como verificas los pagos con cantidades exactas usando solo una clave de prueba: nunca se revelaron direcciones.

# Flask marketplace backend: amount-only verification via proof key
import requests

API = "https://explorer.synxcrypto.com/explorer/api"

@app.route('/verify-payment', methods=['POST'])
def verify():
    tx_hash   = request.json['tx_hash']
    proof_key = request.json['proof_key']  # raw 64-hex or PT- prefixed (API accepts both)
    order     = Order.query.filter_by(tx_hash=tx_hash).first()
    if not order:
        return {'status': 'unknown_order'}, 404

    # Step 1: confirm TX exists on-chain
    existence = requests.get(f"{API}/privacy/tx/{tx_hash}/verify", timeout=20).json()
    if not existence.get('exists') or not existence.get('confirmed'):
        return {'status': 'not_confirmed'}, 402

    # Step 2: decode exact amount using proof key (30-min window)
    # Uses verify_proof.php — returns "amount" (not "amount_decoded")
    result = requests.post(f"{API}/verify_proof.php",
                           json={"tx_hash": tx_hash, "proof_key": proof_key}, timeout=20).json()

    if result.get('valid'):
        paid = float(result['amount'])  # ← "amount" not "amount_decoded"
        if paid >= order.total:
            order.status = 'paid'
            db.session.commit()
            return {'status': 'sovereign_paid', 'exact_amount': paid}
        return {'status': 'underpaid', 'sent': paid, 'required': order.total}, 402

    # Error responses include "error" + "hint" — check both
    error = result.get('error', '')
    if 'expired' in error.lower():
        return {'status': 'proof_expired', 'message': 'Proof key expired — ask buyer for a fresh key'}, 410

    return {'status': 'invalid_proof', 'hint': result.get('hint', '')}, 402

✗∑🗡 Code Grimoire: cada idioma, cada patrón

Python: verificar una clave de prueba

import requests

API  = "https://explorer.synxcrypto.com/explorer/api"
SOCKS = {'http': 'socks5h://127.0.0.1:9050', 'https': 'socks5h://127.0.0.1:9050'}

def verify(tx_hash, proof_key, tor=False):
    """Verify a SYNX proof key — decodes exact amount, reveals nothing else.
    
    The SYNX Node generates proof keys using quantum Kyber-768 lattice encryption.
    Keys expire in 30 minutes. Verify immediately upon receipt.
    Uses verify_proof.php — the recommended endpoint.
    """
    s = requests.Session()
    if tor: s.proxies = SOCKS
    return s.post(f"{API}/verify_proof.php",
                  json={"tx_hash": tx_hash, "proof_key": proof_key},
                  timeout=20).json()

def check_exists(tx_hash, tor=False):
    """Check if a TX exists on-chain. Reveals nothing about amounts or addresses."""
    s = requests.Session()
    if tor: s.proxies = SOCKS
    return s.get(f"{API}/privacy/tx/{tx_hash}/verify", timeout=20).json()

# Usage — the whole rite (amount-only verification)
# Buyer sends you: tx_hash + proof_key (off-chain, via Signal/PGP/Tor)
result = verify("a1b2c3d4...", "f7e8d9c0...", tor=True)  # raw or PT- prefixed
if result.get("valid"):
    print(f"𖣐 Payment confirmed — exact amount: {result['amount']} {result['currency']}")
    # No addresses revealed — ever. Only the amount surfaces.
elif result.get('error'):
    print(f"⚠ {result['error']}")
    if result.get('hint'): print(f"  Hint: {result['hint']}")

# The SYNX Node generates the proof key. You just verify it.
# Proof key = quantum puzzle key. Amount = the only answer.
# Sender? Drowned. Receiver? Drowned. That's the deal.

Node.js: Verificador de pagos (Middleware Express)

const fetch = require('node-fetch');
const API = 'https://explorer.synxcrypto.com/explorer/api';

async function verifyPayment(txHash, proofKey) {
  // Proof key generated by SYNX Node — quantum Kyber-768 sealed
  // Expires in 30 minutes — verify immediately
  const r = await fetch(`${API}/verify_proof.php`, {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({ tx_hash: txHash, proof_key: proofKey }),
  });
  return r.json();
}

// Express middleware — drop into any route
async function requirePayment(req, res, next) {
  const { tx_hash, proof_key } = req.body;
  const result = await verifyPayment(tx_hash, proof_key);
  if (!result.valid) {
    // Error responses include "error" + "hint" fields
    return res.status(result.error?.includes('expired') ? 410 : 402).json({
      error: result.error,
      hint: result.hint,
    });
  }
  req.paymentAmount = result.amount;  // ← "amount" (not "amount_decoded")
  req.paymentCurrency = result.currency;
  next();
}

cURL - Hoja de trucos completa

BASE="https://explorer.synxcrypto.com/explorer/api"

# Sea depth readings
curl $BASE/privacy/stats

# Recent shadow transactions
curl "$BASE/privacy/recent?limit=10"

# Shadow lookup (private TX)
curl $BASE/privacy/tx/a1b2c3d4e5f6...

# Existence oracle
curl $BASE/privacy/tx/a1b2c3d4e5f6.../verify

# Verify a proof key — RECOMMENDED (simple endpoint)
# Returns: {"valid":true, "amount":"183.00", "currency":"SYNX", ...}
curl -X POST $BASE/verify_proof.php \
  -H "Content-Type: application/json" \
  -d '{"tx_hash":"a1b2c3d4...","proof_key":"f7e8d9c0..."}'

# GET also works (quick terminal check):
curl "$BASE/verify_proof.php?tx_hash=a1b2c3d4...&proof_key=f7e8d9c0..."

# PT- prefix also works in proof_key:
# "proof_key":"PT-f7e8d9c0..." or "proof_token":"f7e8d9c0..."

# Runic Envelope (richer metadata: timestamp range, expiry)
curl -X POST $BASE/privacy/tx/a1b2c3d4.../rune-verify \
  -H "Content-Type: application/json" \
  -d '{"proof_token":"f7e8d9c0..."}'

# All of the above, through Tor:
torsocks curl http://synxexplorer.onion/explorer/api/verify_proof.php \
  -d '{"tx_hash":"a1b2...","proof_key":"f7e8..."}'

⚔ SynergyX vs Monero: la comparación honesta

Monero fue pionero. Firmas de anillo, RingCT, direcciones ocultas: todo brillante. Pero fueron construidos para un mundo precuántico donde Ed25519 era irrompible y las marcas de tiempo exactas en un explorador estaban "bien". El fin de esa era. Aquí es donde se encuentran las dos cadenas cuando las pones una al lado de la otra:

Si todavía usas Monero en 2026, ya estás muerto: simplemente no te has dado cuenta.

¿Tus firmas de anillos? El análisis en cadena los agrupa como ganado. ¿Marcas de tiempo exactas? La NSA marca la hora de su café. ¿Ed25519? Se acerca el Shor: tus llaves son polvo. ¿Generación de pruebas del lado del cliente? Descompila la billetera y falsifica pruebas todo el día. Eso es arqueología, no seguridad.

Las claves de prueba SynergyX son generadas por el Nodo SynX utilizando cifrado de celosía cuántica Kyber-768. El método de generación está sellado dentro del núcleo del Nodo: ningún cliente, ningún descompilador ni ningún atacante puede acceder a los parámetros internos de la red cuántica. Incluso un adversario sofisticado que descompila completamente la billetera no obtiene nada: la billetera recibe la clave de prueba del Node. No lo genera. El secreto nunca sale del Nodo.

Transacciones sombra: remitente, receptor, monto, bloque: null. No ofuscado. Borrado.

Claves de prueba cuántica: Claves de rompecabezas selladas con celosía Kyber-768: demuestra la cantidad exacta sin filtrar quién envió, quién recibió, cuándo (±120s fuzz) o dónde. La clave decodifica cantidades exactas: 183,00, no "media". No hay direcciones en la prueba. No hay direcciones en el API. No hay direcciones en ninguna parte. Caduca en 30 minutos.

Sin divulgación de dirección: No hay ningún punto final de clave de vista. Sin punto final de auditoría. No hay ningún mecanismo para revelar al remitente o al receptor a través de este API. La cantidad es todo lo que aflora. La identidad permanece ahogada, permanentemente.

Postcuántico: Kyber-768, SPHINCS+, SHAKE256: Shor puede besar tu bloque génesis. Sin hoja de ruta. No "luego agregaremos señales cuánticas". Nacimos inmunes.

¿Quieres privacidad? Deja de pedir sobras. Con Synergy obtienes sigilo cuántico y velocidad en el mar de sombras. Toma la espada.

Códigos de error

verificar_proof.php — Códigos de estado HTTP

Sobre rúnico (/rune-verify) — Códigos de estado HTTP

429 Acelerador de mar - Cuerpo de respuesta

Las 429 respuestas (ambos criterios de valoración) incluyen un Retry-After Encabezado HTTP (RFC 7231) y un cuerpo JSON estructurado con información de niveles:

// 429 Response — sea throttle or ban active
// Retry-After: 60  (HTTP header — seconds until retry)
{
  "error": "Sea throttled — incremental ban tiers protect the Sea",
  "throttle_tier": "standard",     // "standard" | "tier1" | "tier2" | "active_ban"
  "retry_after": 60,              // seconds until you can retry
  "message": "100 req/min exceeded — exponential backoff (60s). Cool down and come back.",
  "tiers": {
    "standard": "100 req/min — exponential backoff",
    "tier1":    "500 req/min — 5-minute ban",
    "tier2":    "1500 req/min — 1-hour ban"
  }
}

// Example: active ban (hit 500+ req/min earlier)
// Retry-After: 253
{
  "throttle_tier": "active_ban",
  "retry_after": 253,
  "message": "Active ban — 253s remaining. Keep pushing and the Sea pushes back harder."
}

Formatos de entrada (ambos puntos finales): hash TX = exactamente 64 caracteres hexadecimales [a-fA-F0-9]{64}. Clave de prueba = máximo 67 caracteres (con PT- prefijo) o exactamente 64 hexadecimal (sin formato). El API acepta ambos formatos: tiras de servidor PT- automáticamente. verify_proof.php acepta el nombre del campo proof_key or proof_token (alias). Cualquier cosa que esté fuera de estos límites obtiene un duro 400. Sin recortes. Sin piedad.

🕳 Garantías de cero metadatos: lo que los desarrolladores deben saber

Si está integrando este API, aquí está la prueba contundente de que sin fugas de metadatos. Cada reclamo a continuación está auditado por GhostReaper (más de 100 vectores de ataque, 0 hallazgos sin parches).

Propiedades de seguridad: lista de verificación del desarrollador

Lo que DEBES hacer como integrador

𖣐 Codifíquelo. Pruébalo. Posee la oscuridad.

Ahora lo tienes todo. Seis puntos finales. Código real. Enrutamiento Tor. Ganchos de señal. Un modelo de amenazas que sea honesto sobre lo que se filtra y lo que no. Claves de prueba Quantum Kyber-768 generadas por el nodo SynX: claves de rompecabezas inolvidables que decodifican cantidades exactas y nada más. Sin divulgación de dirección, ni con una clave de vista, ni con una clave de prueba, nunca. Borrosidad de la marca de tiempo que hace que el análisis de tiempos carezca de significado estadístico. Y debajo de todo esto, la criptografía reticular que sobrevive a cada ataque cuántico conocido, no porque hayamos migrado, sino porque comenzamos allí.

El Synergy Sea es el océano poscuántico donde las sombras nunca emergen. Ningún centro de datos puede ser rey cuando SynergyX lo destrona y entroniza al usuario. Cada transacción privada se hunde en la encapsulación Kyber-768, sellada por hiperárboles SPHINCS+, indexada por compromisos de red cuántica. Las cantidades se susurran a través de las claves de prueba: galimatías para los observadores, decimales exactos para los poseedores de las claves. El explorador ve ondas. El API devuelve nulo donde importa. La clave de la prueba es el único hilo conductor que conduce a la cantidad, y la cantidad es todo que emerge. ¿Remitente y receptor? Ahogue. Permanentemente. Ningún punto final, ninguna clave, ninguna citación los traerá de vuelta.

Sin KYC. Sin custodia. Sin análisis de cadena. Sin divulgación de dirección. No hay un punto central de falla. No hay hoja de ruta de migración porque no hay nada desde dónde migrar. El primero en avanzar hacia el final cuántico.

Esto no es documentación. Esta es un arma. Úselo.

𝓢𝔁
Codifícalo. Pruébalo. Posee las mareas oscuras.

SynergyX Privacidad API v2.0 - Teclas a prueba de cuánticas - El Synergy Sea
El océano poscuántico donde las sombras nunca afloran.