Ce guide documente le même flux de clé de preuve de transaction privée utilisé par timeline.php pour les paiements d’accès à la chronologie. Il est conçu pour les développeurs qui doivent accepter les paiements privés SynX, vérifier le montant exact et conserver les données d'adresse hors de leur application.

• Ce que vous recevez du payeur : un 64 caractères tx_hash et une clé de preuve. La clé de preuve peut être brute de 64 hexadécimaux ou préfixée comme PT- plus 64 hexagones.
• Ce que prouve le API : si cette clé de preuve est valide pour cette transaction et le montant exact de SynX.
• Ce que le API ne révèle pas : adresse de l'expéditeur, adresse du destinataire, solde du portefeuille ou mode de paiement public pour les transactions privées.
• Critère principal : POST /explorer/api/verify_proof.php avec corps JSON {"tx_hash":"...","proof_key":"..."}.

Implémentation de clés de preuve comme la chronologie

Timeline accepte automatiquement les paiements visibles sur le marché. Lorsqu'une transaction est privée ou cachée, elle passe à la vérification par clé de preuve. La clé de preuve confirme le montant du paiement tandis que les champs d'adresse restent scellés.

Vérificateur PHP de style chronologie

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

Champs de réponse dont dépendre

🌊 Pourquoi nous ne divulguons jamais l'expéditeur ou le destinataire

C’est le principe de base. La transparence open source et la confidentialité des utilisateurs sont des ennemis naturels, à moins que vous ne définissiez correctement les limites. SynergyX résout ce problème en rendant le protocole transparent (n'importe qui peut auditer le code) tout en gardant identité opaque en permanence (aucun mécanisme n’existe pour révéler l’expéditeur ou le destinataire). La clé de preuve est une clé de puzzle : elle déverrouille le montant, et seulement la quantité. Les identités derrière la transaction se sont dissoutes dans le Synergy Sea au moment où le bloc a été scellé.

Le nœud SynX génère la clé de preuve à l’aide du cryptage quantique en réseau Kyber-768. La clé est mathématiquement liée au montant de la transaction. Il ne peut pas être falsifié, ni soumis à une ingénierie inverse, et expire dans 30 minutes. L'expéditeur partage la clé de preuve avec le destinataire hors chaîne – Signal, PGP, Tor, une serviette. Le destinataire vérifie via ce API. C'est tout le modèle de confiance. Pas de garde. Aucun intermédiaire. Aucune trace de métadonnées.

⛨ Ce que sait le serveur (Jack)

Soyons honnêtes sur les limites de confiance. Vous frappez un API. Le serveur est une machine, et les machines peuvent être saisies. Voici exactement ce qu'un attaquant obtient s'il roote la boîte :

Le timing est mitigé. Chaque réponse API (GET, POST, succès, échec, 404, tout) est complétée par un Plafond constant de 500 ms. Le serveur mesure le temps de traitement réel, puis se met en veille exactement 500ms - elapsed. Chaque réponse prend exactement 500 ms. Pas au hasard. Constante. Cohen's d entre les chemins valides et invalides : 0.015 (testé par GhostReaper — statistiquement invisible). Le manuel de jeu de l'oracle de timing de Chainalysis ? Mort à l'arrivée.

🌊 Le Synergy Sea — Deux couches de profondeur

Considérez la chaîne comme un océan. Les transactions publiques flottent à la surface. Les privés coulent. Plus vous allez en profondeur, plus vous avez besoin de clés de preuve pour voir quoi que ce soit. Et même à profondeur maximale, seul le montant surfaces – jamais d’adresses.

Aucune couche plus profonde n'existe. Il n'y a aucune divulgation de clé de vue, aucun audit d'adresse, aucun mécanisme pour révéler qui a envoyé ou reçu. La clé de preuve — générée par le nœud SynX à l'aide du cryptage quantique Kyber-768 — décode le montant exact. C'est le plus profond que l'on puisse aller. Les adresses des expéditeurs et des destinataires sont définitivement noyées dans la mer.

Armure anti-corrélation : Les horodatages sont flous ± 120 s. Frais répartis en 5 niveaux (micro/faible/standard/élevé/premium – jamais le montant brut sat). Hauteurs de bloc annulées. Temps de réponse rembourrés jusqu'à un plafond constant de 500 ms. "TX not found" et "TX is private" renvoient le forme identique. Les clés de preuve expirent dans 30 minutes - limiter les fenêtres de relecture à près de zéro. Vous ne pouvez même pas énumérer quels hachages sont réels. Chaque requête de surface renvoie la même quantité d'informations, que le TX existe, n'existe pas ou soit protégé. Bonne chance, Chainalysis.

—͟͟͞͞★ Vérification de la preuve du fournisseur – 3 minutes, Zero Trust

Vous êtes un vendeur. Un acheteur vient de vous payer en privé SynX. Vous devez vérifier le paiement sans voir leur adresse, leur solde ou faire confiance à un tiers. Voici comment. Pas de KYC. Pas de garde. Prouvez les paiements à l’aveugle.

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

𖣐 Rite de vérification complète

L'étape ④ est le lien critique. La clé de preuve doit voyager entre l'expéditeur et le récepteur via un canal que le API ne voit jamais. Messages de disparition du signal. E-mail crypté par PGP. Service caché Tor. Un code QR affiché sur un tableau. Une note enregistrée sous un banc de parc. Le API ne se soucie pas de la façon dont le secret parvient – ​​il ne vérifie les calculs que lorsque le récepteur le demande.

POST /verify_proof — Vérifier une clé de preuve (recommandé)

POSTE OBTENIR PUBLIQUE — Le moyen le plus simple de vérifier un paiement. Envoyer tx_hash + proof_key dans le corps (ou en tant que paramètres GET). Renvoie le montant exact. Aucune authentification. Pas de clé API. Aucun compte. Commencez ici.

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

Référence complète des erreurs — verify_proof.php

POST /privacy/tx/{hash}/rune-verify — Enveloppe runique (métadonnées riches)

POSTE PUBLIQUE — Même vérification de clé de preuve avec des métadonnées plus riches : fenêtre d'horodatage (± 120 s floue), compte à rebours d'expiration, méthode de décryptage. Utilisez-le lorsque vous avez besoin de plus que le montant.

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

Ce que le vérificateur apprend par rapport à ce qui reste noyé

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

OBTENIR PUBLIQUE — Est-ce que ce TX existe ? Renvoie un engagement d'existence cryptographique. Ne révèle rien d'autre.

{
  "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} — Recherche de transaction fantôme

OBTENIR PUBLIQUE - Recherchez n'importe quel TX. Les privés renvoient l'ombre - hachage visible, tout le reste 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 — Ondulations de surface

TX récents. Les champs privés font surface sous forme d’ombres (champs nuls). Les publics affichent des données transparentes. Bon pour les tableaux de bord. Paramètre de requête limit (1-50, par défaut 20).

GET /privacy/stats — Lectures de la profondeur de la mer

Métriques d'adoption de la confidentialité : nombre total d'émissions, émissions privées, pourcentage d'adoption, indicateurs de fonctionnalités. Aucune authentification requise. Surveillez la profondeur de la mer depuis votre propre infrastructure.

POST /privacy/batch-proof — Vérifier par lots plusieurs preuves

POSTE PUBLIQUE — Vérifiez jusqu'à 50 clés d'épreuve en une seule demande. Même vérification du démon que les points de terminaison à preuve unique, mais par lots pour plus d'efficacité. Idéal pour les marchés traitant plusieurs commandes ou les portefeuilles vérifiant plusieurs paiements entrants à la fois.

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

Limites de lots et référence d'erreur

🧅 Tor / .onion – Acheminez tout à travers le brouillard

Le API est REST sans état sur HTTPS. Pas de cookies. Aucune séance. Pas d'empreinte digitale JS. Aucune mise à niveau WebSocket. Requête pure → réponse sur TLS. Cela fonctionne nativement sur Tor parce que nous l'avons construit de cette façon. Pas après coup. Si vous construisez quelque chose de privé et que vous êtes pas en routant via .onion, vous divulguez votre adresse IP à chaque résolveur DNS entre vous et le serveur. Ne le faites pas.

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

📡 Partager des clés de preuve via Signal – Zéro métadonnées

La clé de preuve doit voyager expéditeur → récepteur sans toucher le API. Voici la hiérarchie OPSEC pour ce transfert :

Hook d’intégration de signal (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...")

⚓ Rite de paiement du marché

Vous construisez un marché souverain. Pas de rayures. Pas de PayPal. Pas de middleware KYC. Juste le Synergy Sea et les clés d’épreuve scellées quantiquement. Voici comment vérifier les paiements avec montants exacts en utilisant uniquement une clé de preuve – aucune adresse n’a jamais été révélée.

# 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 – Chaque langage, chaque modèle

Python - Vérifier une clé de preuve

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 — Vérificateur de paiement (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 — Aide-mémoire complet

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 comparaison honnête

Monero a été pionnier. Signatures d'anneau, RingCT, adresses furtives - tout est génial. Mais ils ont été construits pour un monde pré-quantique où Ed25519 était incassable et où les horodatages exacts sur un explorateur étaient « corrects ». Cette époque est terminée. Voici où se situent les deux chaînes lorsque vous les mettez côte à côte :

Si vous utilisez encore Monero en 2026, vous êtes déjà mort : vous ne l'avez tout simplement pas remarqué.

Vos signatures de bague ? Chainalysis les regroupe comme du bétail. Des horodatages exacts ? La NSA horodatage votre café. Ed25519? Shor arrive : vos clés sont poussière. Génération de preuves côté client ? Décompilez le portefeuille et falsifiez des preuves toute la journée. C'est de l'archéologie, pas de la sécurité.

Les clés de preuve SynergyX sont générées par le Nœud SynX en utilisant le cryptage quantique sur réseau Kyber-768. La méthode de génération est scellée au cœur du nœud : aucun client, aucun décompilateur, aucun attaquant ne peut accéder aux paramètres internes du réseau quantique. Même un adversaire sophistiqué qui décompile complètement le portefeuille n'obtient rien : le portefeuille reçoit la clé de preuve du nœud. Cela ne le génère pas. Le secret ne quitte jamais le Node.

Transactions fantômes : expéditeur, destinataire, montant, blocage : null. Pas obscurci. Effacé.

Clés de preuve quantique : Clés de puzzle scellées en treillis Kyber-768 : prouvez le montant exact sans fuite qui a envoyé, qui a reçu, quand (± 120 s de fuzz) ou où. La clé décode les montants exacts : 183,00, et non "moyens". Aucune adresse dans le justificatif. Aucune adresse dans le API. Aucune adresse nulle part. Expire dans 30 minutes.

Aucune divulgation d'adresse : Il n’y a pas de point de terminaison de clé d’affichage. Aucun point final d’audit. Aucun mécanisme pour révéler l'expéditeur ou le destinataire via ce API. Le montant est tout ce qui fait surface. L’identité reste noyée – pour toujours.

Post-quantique : Kyber-768, SPHINCS+, SHAKE256 — Shor peut embrasser votre bloc de genèse. Aucune feuille de route. Non "plus tard, j'ajouterai des signatures quantiques". Nous sommes nés immunisés.

Vous voulez de l'intimité ? Arrêtez de mendier des restes. Avec Synergy, vous bénéficiez d'une furtivité et d'une vitesse quantiques dans la mer des ombres. Prenez la lame.

Codes d'erreur

verify_proof.php — Codes d'état HTTP

Enveloppe runique (/rune-verify) — Codes d'état HTTP

429 Sea Throttle — Corps d’intervention

Les 429 réponses (les deux critères) incluent un Retry-After En-tête HTTP (RFC 7231) et corps JSON structuré avec informations sur les niveaux :

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

Formats d'entrée (les deux points de terminaison) : Hachage TX = exactement 64 caractères hexadécimaux [a-fA-F0-9]{64}. Clé de preuve = max 67 caractères (avec PT- préfixe) ou exactement 64 hex (brut). Le API accepte les deux formats : bandes de serveur PT- automatiquement. verify_proof.php accepte le nom du champ proof_key or proof_token (alias). Tout ce qui se situe en dehors de ces limites obtient un 400 dur. Pas de coupe. Aucune pitié.

🕳 Garanties zéro métadonnées : ce que les développeurs doivent savoir

Si vous intégrez ce API, voici la preuve tangible que aucune fuite de métadonnées. Chaque réclamation ci-dessous est auditée par GhostReaper (plus de 100 vecteurs d'attaque, 0 résultat non corrigé).

Propriétés de sécurité – Liste de contrôle du développeur

Ce que vous DEVEZ faire en tant qu'intégrateur

𖣐 Codez-le. Testez-le. Possédez l'obscurité.

Vous avez maintenant tout. Six points finaux. Du vrai code. Routage Tor. Crochets de signalisation. Un modèle de menace honnête quant à ce qui fuit ou non. Clés de preuve Quantum Kyber-768 générées par le nœud SynX – clés de puzzle infalsifiables qui décodent les montants exacts et rien d'autre. Aucune divulgation d'adresse - ni avec une clé d'affichage, ni avec une clé de preuve, jamais. Fuzzing de l’horodatage qui rend l’analyse temporelle statistiquement dénuée de sens. Et au-dessous de tout cela, une cryptographie en treillis qui survit à toutes les attaques quantiques connues – non pas parce que nous avons migré, mais parce que nous avons commencé là-bas.

Le Synergy Sea est l’océan post-quantique où les ombres ne font jamais surface. Aucun centre de données ne peut être roi lorsque SynergyX le détrône et trône l'utilisateur. Chaque transaction privée s'enfonce dans l'encapsulation Kyber-768, scellée par des hyperarbres SPHINCS+, indexés par des engagements de réseau quantique. Les montants chuchotent à travers les clés de preuve – du charabia pour les observateurs, des décimales exactes pour les détenteurs de clés. L'explorateur voit des ondulations. Le API renvoie null là où cela compte. La clé de preuve est le seul fil conducteur vers le montant – et le montant est tous qui fait surface. Expéditeur et destinataire ? Noyé. En permanence. Aucun point final, aucune clé, aucune assignation à comparaître ne les ramène.

Pas de KYC. Pas de garde. Aucune analyse de chaîne. Aucune divulgation d'adresse. Aucun point central de défaillance. Pas de feuille de route de migration car il n'y a rien à partir duquel migrer. Premier arrivé dans la phase finale quantique.

Ce n'est pas de la documentation. C'est une arme. Utilisez-le.

𝓢𝔁
Codez-le. Testez-le. Possédez les marées sombres.

SynergyX Confidentialité API v2.0 — Clés à preuve quantique — Le Synergy Sea
L’océan post-quantique où les ombres ne font jamais surface.