Questa guida documenta lo stesso flusso di chiave di prova per transazione privata utilizzato da timeline.php per i pagamenti di accesso alla Timeline. È progettato per gli sviluppatori che hanno bisogno di accettare pagamenti SynX privati, verificare l'importo esatto e mantenere i dati dell'indirizzo fuori dalla loro applicazione.

• Cosa ricevi dal pagatore: un 64 caratteri tx_hash e una chiave di prova. La chiave di prova può essere grezza di 64 esadecimali o con il prefisso as PT- più 64 esadecimali.
• Cosa dimostra il API: se la chiave di prova è valida per quella transazione e l'importo esatto di SynX.
• Cosa non rivela il API: indirizzo del mittente, indirizzo del destinatario, saldo del portafoglio o un percorso di pagamento pubblico per transazioni private.
• Endpoint primario: POST /explorer/api/verify_proof.php con corpo JSON {"tx_hash":"...","proof_key":"..."}.

Implementazione di chiavi di prova come la sequenza temporale

Timeline accetta automaticamente i pagamenti visibili sul mercato. Quando una transazione è privata o nascosta, passa alla verifica con chiave di prova. La chiave di prova conferma l'importo del pagamento mentre i campi dell'indirizzo rimangono sigillati.

Verificatore PHP in stile timeline

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'];
}

Campi di risposta da cui dipendere

🌊 Perché non divulghiamo mai il mittente o il destinatario

Questo è il principio fondamentale. La trasparenza open source e la privacy degli utenti sono nemici naturali, a meno che non si progetti correttamente il confine. SynergyX risolve questo problema creando il file protocollo trasparente (chiunque può controllare il codice) mantenendo identità permanentemente opaco (non esiste alcun meccanismo per rivelare il mittente o il destinatario). La chiave di prova è una chiave puzzle: sblocca l'importo e soltanto l'importo. Le identità dietro la transazione si sono dissolte nel Synergy Sea nel momento in cui il blocco è stato sigillato.

Il nodo SynX genera la chiave di prova utilizzando la crittografia reticolare quantistica Kyber-768. La chiave è matematicamente legata all’importo della transazione. Non può essere forgiato, non può essere decodificato e scade tra 30 minuti. Il mittente condivide la chiave di prova con il destinatario fuori catena: Signal, PGP, Tor, un tovagliolo. Il destinatario verifica tramite questo API. Questo è l'intero modello di fiducia. Nessuna custodia. Nessun intermediario. Nessuna traccia di metadati.

⛨ Ciò che sa il server (Jack)

Cerchiamo di essere onesti riguardo ai confini della fiducia. Stai colpendo un API. Il server è una macchina e le macchine possono essere sequestrate. Ecco esattamente cosa ottiene un utente malintenzionato se esegue il root della box:

La tempistica è mitigata. Ogni singola risposta API (GET, POST, successo, fallimento, 404, tutto) viene completata con un Soffitto costante di 500 ms. Il server misura il tempo di elaborazione effettivo, quindi dorme esattamente 500ms - elapsed. Ogni risposta dura esattamente 500 ms. Non casuale. Costante. D di Cohen tra percorsi validi e non validi: 0.015 (testato da GhostReaper – statisticamente invisibile). Il playbook dell'oracolo temporale di Chainalysis? Morto all'arrivo.

🌊 Il Synergy Sea: due strati di profondità

Pensa alla catena come a un oceano. Le transazioni pubbliche galleggiano in superficie. Quelli privati ​​affondano. Più vai in profondità, più hai bisogno di chiavi di prova per vedere qualcosa. E anche alla massima profondità, solo il quantità superfici - non affronta mai.

Non esiste uno strato più profondo. Non esiste alcuna divulgazione della chiave di visualizzazione, nessun controllo degli indirizzi, nessun meccanismo per rivelare chi ha inviato o ricevuto. La chiave di prova, generata dal nodo SynX utilizzando la crittografia quantistica Kyber-768, decodifica l'importo esatto. Questo è il punto più profondo a cui chiunque può arrivare. Gli indirizzi del mittente e del destinatario sono permanentemente annegati nel mare.

Armatura anticorrelazione: I timestamp erano sfocati di ±120 secondi. Tariffe suddivise in 5 livelli (micro/basso/standard/alto/premium – mai l'importo grezzo). Altezza dei blocchi annullata. Tempi di risposta attenuati fino al tetto costante di 500 ms. "TX non trovato" e "TX è privato" restituiscono il file forma identica. Le chiavi di prova scadono tra 30 minuti — limitare le finestre di replay quasi allo zero. Non puoi nemmeno enumerare quali hash sono reali. Ogni query di superficie restituisce la stessa quantità di informazioni indipendentemente dal fatto che la TX esista, non esista o sia protetta. Buona fortuna, Chainalysis.

—͟͟͞͞★ Verifica della prova del fornitore: 3 minuti, Zero Trust

Sei un venditore. Un acquirente ti ha appena pagato in privato SynX. È necessario verificare il pagamento senza vedere il loro indirizzo, il loro saldo o fidarsi di terze parti. Ecco come. Niente KYC. Nessuna custodia. Dimostrare i pagamenti alla cieca.

# 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 di verifica completa

Il passaggio ④ è il collegamento critico. La chiave di prova deve viaggiare tra mittente e destinatario attraverso un canale che il API non vede mai. Messaggi di scomparsa del segnale. E-mail crittografata con PGP. Servizio nascosto Tor. Un codice QR mostrato su una tabella. Un biglietto attaccato sotto una panchina del parco. Al API non interessa come arriva il segreto: verifica i calcoli solo quando il ricevitore lo richiede.

POST /verify_proof: verifica una chiave di prova (consigliato)

INVIARE OTTENERE PUBBLICO — Il modo più semplice per verificare un pagamento. Inviare tx_hash + proof_key nel corpo (o come parametri GET). Restituisce l'importo esatto. Nessuna autenticazione Nessuna chiave API. Nessun conto. Inizia qui.

// 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...\"}"
  }
}

Riferimento completo agli errori: verify_proof.php

POST /privacy/tx/{hash}/rune-verify — Busta runica (metadati ricchi)

INVIARE PUBBLICO — Stessa verifica della chiave di prova con metadati più ricchi: finestra timestamp (±120 secondi fuzzy), conto alla rovescia della scadenza, metodo di decrittografia. Usalo quando hai bisogno di più della semplice quantità.

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" }

Ciò che apprende il verificatore rispetto a ciò che rimane annegato

GET /privacy/tx/{hash}/verify — Esistenza Oracle

OTTENERE PUBBLICO — Esiste questa TX? Restituisce un impegno di esistenza crittografica. Non rivela altro.

{
  "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}: ricerca di transazioni shadow

OTTENERE PUBBLICO - Cerca qualsiasi TX. Quelli privati ​​restituiscono l'ombra: hash visibile, tutto il resto 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
}

GET /privacy/recent — Increspature della superficie

TX recenti. Quelli privati ​​emergono come ombre (campi nulli). Quelli pubblici mostrano dati trasparenti. Buono per i cruscotti. Parametro interrogazione limit (1-50, predefinito 20).

GET /privacy/stats - Letture della profondità del mare

Metriche di adozione della privacy: TX totali, TX private, % di adozione, flag di funzionalità. Nessuna autenticazione richiesta. Monitora la profondità del mare dalla tua infrastruttura.

POST /privacy/batch-proof: verifica in batch di più prove

INVIARE PUBBLICO — Verifica fino a 50 chiavi di prova in un'unica richiesta. Stessa verifica del demone degli endpoint a prova singola, ma raggruppati per efficienza. Ideale per i marketplace che elaborano più ordini o portafogli che verificano più pagamenti in entrata contemporaneamente.

// 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
}

Limiti batch e riferimento agli errori

🧅 Tor / .onion: guida tutto attraverso la nebbia

Il API lo è REST senza stato su HTTPS. Nessun cookie. Nessuna sessione. Nessuna impronta digitale JS. Nessun aggiornamento WebSocket. Richiesta pura→risposta su TLS. Funziona su Tor in modo nativo perché lo abbiamo costruito in questo modo. Non come un ripensamento. Se stai costruendo qualcosa di privato e sei non instradando attraverso .onion, stai perdendo il tuo IP su ogni risolutore DNS tra te e il server. Non.

cURL tramite 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 tramite 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 tramite 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);

📡 Condividi le chiavi di prova tramite Signal: Zero Metadata

La chiave di prova deve viaggiare tra mittente e destinatario senza toccare il API. Ecco la gerarchia OPSEC per tale trasferimento:

Hook di integrazione del segnale (bot 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 di pagamento sul mercato

Stai costruendo un mercato sovrano. Nessuna striscia. Niente PayPal. Nessun middleware KYC. Solo il Synergy Sea e le chiavi a prova di sigillo quantico. Ecco come verificare i pagamenti con importi esatti utilizzando solo una chiave di prova: nessun indirizzo mai rivelato.

# 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: ogni lingua, ogni modello

Python: verifica una chiave di prova

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 — Verificatore di pagamenti (Express Middleware)

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: foglio informativo completo

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: il confronto onesto

Monero è stato il pioniere. Firme degli squilli, RingCT, indirizzi invisibili: tutto geniale. Ma sono stati costruiti per un mondo pre-quantistico in cui Ed25519 era indistruttibile e i timestamp esatti su un esploratore andavano "bene". Quell'era sta finendo. Ecco dove si trovano le due catene quando le metti una accanto all'altra:

Se usi ancora Monero nel 2026, sei già morto: semplicemente non te ne sei accorto.

Le tue firme sugli anelli? La catena dell’analisi li raggruppa come bestiame. Timestamp esatti? La NSA timbra il tuo caffè. Ed25519? Shor sta arrivando: le tue chiavi sono polvere. Generazione di prove lato client? Decompila il portafoglio e falsifica prove tutto il giorno. Questa è archeologia, non sicurezza.

Le chiavi di prova SynergyX sono generate dal file Nodo SynX utilizzando la crittografia reticolare quantistica Kyber-768. Il metodo di generazione è sigillato all'interno del nucleo del Nodo: nessun client, nessun decompilatore o nessun utente malintenzionato può accedere ai parametri interni del reticolo quantistico. Anche un avversario sofisticato che decompila completamente il portafoglio non ottiene nulla: il portafoglio riceve la chiave di prova dal Node. Non lo genera. Il segreto non lascia mai il Nodo.

Transazioni ombra: mittente, destinatario, importo, blocco: null. Non offuscato. Cancellato.

Chiavi di prova quantistica: Chiavi puzzle sigillate a reticolo Kyber-768: dimostra l'importo esatto senza rivelare chi ha inviato, chi ha ricevuto, quando (± 120 secondi di fuzz) o dove. La chiave decodifica gli importi esatti: 183,00, non "medio". Nessun indirizzo nella prova. Nessun indirizzo nel API. Nessun indirizzo da nessuna parte. Scade tra 30 minuti.

Nessuna divulgazione dell'indirizzo: Non esiste un endpoint chiave di visualizzazione. Nessun endpoint di controllo. Nessun meccanismo per rivelare il mittente o il destinatario tramite questo API. L'importo è tutto ciò che emerge. L’identità rimane annegata – permanentemente.

Post-quantistico: Kyber-768, SPHINCS+, SHAKE256 — Shor può baciare il tuo blocco genesi. Nessuna tabella di marcia. No "più tardi aggiungerò segni quantici". Siamo nati immuni.

Vuoi privacy? Smettila di elemosinare gli avanzi. Con Synergy ottieni furtività quantistica e velocità nel mare delle ombre. Prendi la lama.

Codici di errore

verify_proof.php — Codici di stato HTTP

Busta runica (/rune-verify): codici di stato HTTP

429 Sea Throttle - Corpo di risposta

Tutte le 429 risposte (entrambi gli endpoint) includono a Retry-After Intestazione HTTP (RFC 7231) e un corpo JSON strutturato con informazioni sul livello:

// 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."
}

Formati di input (entrambi gli endpoint): Hash TX = esattamente 64 caratteri esadecimali [a-fA-F0-9]{64}. Chiave di prova = max 67 caratteri (con PT- prefisso) o esattamente 64 esadecimale (grezzo). Il API accetta entrambi i formati: server strip PT- automaticamente. verify_proof.php accetta il nome del campo proof_key or proof_token (alias). Qualunque cosa al di fuori di questi limiti ottiene un duro 400. Nessun taglio. Nessuna pietà.

🕳 Garanzie zero metadati: cosa devono sapere gli sviluppatori

Se stai integrando questo API, ecco la prova concreta nessuna perdita di metadati. Ogni affermazione riportata di seguito è controllata da GhostReaper (oltre 100 vettori di attacco, 0 risultati senza patch).

Proprietà di sicurezza: elenco di controllo per sviluppatori

Cosa DEVI fare come integratore

𖣐 Codificalo. Provalo. Possedere l'oscurità.

Ora hai tutto. Sei endpoint. Codice reale. Instradamento Tor. Ganci di segnalazione. Un modello di minaccia onesto su ciò che viene trapelato e cosa no. Chiavi di prova Quantum Kyber-768 generate dal nodo SynX: chiavi puzzle non falsificabili che decodificano importi esatti e nient'altro. Nessuna divulgazione dell'indirizzo: né con una chiave di visualizzazione, né con una chiave di prova, mai. Fuzzing del timestamp che rende l'analisi temporale statisticamente priva di significato. E al di sotto di tutto ciò, la crittografia reticolare che sopravvive a ogni attacco quantistico conosciuto, non perché siamo migrati, ma perché abbiamo iniziato da lì.

Il Synergy Sea è l'oceano post-quantistico dove le ombre non emergono mai. Nessun data center può essere re quando SynergyX li detronizza e mette sul trono l'utente. Ogni transazione privata affonda nell'incapsulamento Kyber-768, sigillato da iperalberi SPHINCS+, indicizzati da impegni di reticolo quantistico. Gli importi sussurrano attraverso le chiavi di prova: incomprensibili per gli osservatori, decimali esatti per i detentori delle chiavi. L'esploratore vede le increspature. Il API restituisce null dove conta. La chiave di prova è l’unico collegamento con l’importo – e l’importo lo è Tutto che affiora. Mittente e destinatario? Annegato. Permanentemente. Nessun punto finale, nessuna chiave, nessuna citazione li riporta indietro.

Niente KYC. Nessuna custodia. Nessuna analisi di catena. Nessuna divulgazione dell'indirizzo. Nessun punto centrale di fallimento. Nessuna tabella di marcia per la migrazione perché non c'è nulla da cui migrare. La prima mossa nel gioco finale quantistico.

Questa non è documentazione. Questa è un'arma. Usalo.

𝓢𝔁
Codificalo. Provalo. Possiedi le maree oscure.

Privacy di SynergyX API v2.0 — Tasti a prova di Quantum — Synergy Sea
L’oceano post-quantistico dove le ombre non emergono mai.