Deze handleiding documenteert dezelfde privé-transactie-proof-sleutelstroom die wordt gebruikt door timeline.php voor betalingen voor tijdlijntoegang. Het is ontworpen voor ontwikkelaars die privé-SynX-betalingen moeten accepteren, het exacte bedrag moeten verifiëren en adresgegevens buiten hun applicatie moeten houden.

• Wat u ontvangt van de betaler: een 64-teken tx_hash en een proefsleutel. De proefsleutel kan onbewerkt 64-hex zijn of voorafgegaan worden als PT- plus 64 zeskant.
• Wat de API bewijst: of die bewijssleutel geldig is voor die transactie en het exacte SynX-bedrag.
• Wat de API niet onthult: afzenderadres, ontvangeradres, portemonneesaldo of een openbaar betalingspad voor privétransacties.
• Primair eindpunt: POST /explorer/api/verify_proof.php met JSON-body {"tx_hash":"...","proof_key":"..."}.

Bewijssleutels zoals tijdlijn implementeren

Timeline accepteert automatisch zichtbare marktplaatsbetalingen. Wanneer een transactie privé of verborgen is, wordt overgeschakeld naar proof-key-verificatie. De proefsleutel bevestigt het betalingsbedrag terwijl de adresvelden gesloten blijven.

PHP-verificatie in tijdlijnstijl

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

Antwoordvelden waarvan u afhankelijk bent

🌊 Waarom we de afzender of ontvanger nooit openbaar maken

Dit is het kernprincipe. Open source-transparantie en gebruikersprivacy zijn natuurlijke vijanden, tenzij je de grens op de juiste manier afbakent. SynergyX lost dit op door de protocol transparant (iedereen kan de code controleren) terwijl deze behouden blijft identiteit permanent ondoorzichtig (er bestaat geen mechanisme om afzender of ontvanger te onthullen). De proefsleutel is een puzzelsleutel: hij ontgrendelt het bedrag, en alleen het bedrag. De identiteiten achter de transactie losten op in de Synergy Sea op het moment dat het blok werd verzegeld.

Het SynX-knooppunt genereert de bewijssleutel met behulp van quantum Kyber-768-roosterversleuteling. De sleutel is wiskundig gebonden aan het transactiebedrag. Het kan niet worden vervalst, het kan niet worden onderworpen aan reverse-engineering, en verloopt na 30 minuten. De afzender deelt de proefsleutel met de ontvanger buiten de keten: Signal, PGP, Tor, een servet. De ontvanger verifieert via deze API. Dat is het hele vertrouwensmodel. Geen voogdij. Geen tussenpersoon. Geen metadataspoor.

⛨ Wat de server weet (Jack)

Laten we eerlijk zijn over vertrouwensgrenzen. Je raakt een API. De server is een machine en machines kunnen in beslag worden genomen. Dit is precies wat een aanvaller krijgt als hij de box roott:

De timing wordt verzacht. Elke afzonderlijke API-reactie – GET, POST, succes, mislukking, 404, alles – is opgevuld tot een 500 ms constant plafond. De server meet de werkelijke verwerkingstijd en slaapt vervolgens precies 500ms - elapsed. Elke reactie duurt precies 500 ms. Niet willekeurig. Constante. Cohen's d tussen geldige en ongeldige paden: 0.015 (getest door GhostReaper – statistisch onzichtbaar). Het timing-orakel-speelboek van Chainalysis? Dood bij aankomst.

🌊 De Synergy Sea — Twee dieptelagen

Beschouw de keten als een oceaan. Publieke transacties drijven aan de oppervlakte. Privé zinkt. Hoe dieper je gaat, hoe meer je bewijssleutels nodig hebt om iets te zien. En zelfs op maximale diepte kan alleen de hoeveelheid oppervlakken - adresseert nooit.

Er bestaat geen diepere laag. Er is geen openbaarmaking van de sleutel, geen adrescontrole, geen mechanisme om te onthullen wie heeft verzonden of ontvangen. De proefsleutel – gegenereerd door het SynX-knooppunt met behulp van quantum Kyber-768-codering – decodeert het exacte bedrag. Dat is het diepste dat iemand kan gaan. Afzender- en ontvangeradressen zijn permanent verdronken in de zee.

Anticorrelatiepantser: Tijdstempels zijn ±120s wazig. Kosten onderverdeeld in 5 niveaus (micro/laag/standaard/hoog/premium – nooit het ruwe sat-bedrag). Blokhoogten zijn nul. Reactietijden opgevuld tot een constant plafond van 500 ms. "TX niet gevonden" en "TX is privé" retourneren de identieke vorm. Bewijssleutels verlopen over 30 minuten — beperking van de herhalingsvensters tot bijna nul. Je kunt niet eens opsommen welke hashes echt zijn. Elke oppervlaktequery retourneert dezelfde hoeveelheid informatie, ongeacht of de TX bestaat, niet bestaat of is afgeschermd. Veel succes, Chainanalyse.

—͟͟͞͞★ Leveranciersbestendige verificatie — 3 minuten, nul vertrouwen

Je bent een verkoper. Een koper heeft u zojuist betaald in privé SynX. U moet de betaling verifiëren zonder hun adres of saldo te zien of een derde partij te vertrouwen. Hier is hoe. Geen KYC. Geen voogdij. Bewijs betalingen blind.

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

𖣐 Volledige verificatieritueel

Stap ④ is de kritische schakel. De proefsleutel moet zender → ontvanger door een kanaal sturen dat de API nooit ziet. Signaleer verdwijnende berichten. PGP-gecodeerde e-mail. Tor verborgen dienst. Een QR-code weergegeven op een tafel. Een briefje geplakt onder een bankje in het park. Het maakt de API niet uit hoe het geheim daar terechtkomt; hij verifieert de wiskunde alleen als de ontvanger erom vraagt.

POST /verify_proof — Verifieer een proefsleutel (aanbevolen)

NA KRIJGEN OPENBAAR — De eenvoudigste manier om een ​​betaling te verifiëren. Versturen tx_hash + proof_key in het lichaam (of als GET-params). Retourneert het exacte bedrag. Geen autorisatie Geen API-sleutel. Geen rekening. Begin hier.

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

Volledige foutreferentie — verificatie_proof.php

POST /privacy/tx/{hash}/rune-verify — Runenenvelop (rijke metadata)

NA OPENBAAR — Zelfde bewijssleutelverificatie met rijkere metadata: tijdstempelvenster (±120s vaag), aftelling van de vervaldatum, decoderingsmethode. Gebruik dit als u meer nodig heeft dan alleen de hoeveelheid.

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

Wat de verificateur leert versus wat onder water blijft

GET /privacy/tx/{hash}/verify — Bestaan ​​Oracle

KRIJGEN OPENBAAR — Bestaat deze TX? Retourneert een cryptografisch bestaanstoezegging. Onthult niets anders.

{
  "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} — Zoeken naar schaduwtransacties

KRIJGEN OPENBAAR - Zoek een TX op. Privé-exemplaren geven de schaduw terug – hash zichtbaar, al het andere 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 — Surface Ripples

Recente TX's. Privévelden verschijnen als schaduwen (nulvelden). Publieke data tonen transparante data. Goed voor dashboards. Vraagparam limit (1-50, standaard 20).

GET /privacy/stats - Zeedieptemetingen

Statistieken over privacy-acceptatie: totaal aantal TX's, privé-TX's, adoptiepercentage, functievlaggen. Geen autorisatie vereist. Bewaak de diepte van de zee vanaf uw eigen infrastructuur.

POST /privacy/batch-proof - Verifieer meerdere proefdrukken in batch

NA OPENBAAR — Verifieer tot 50 proefsleutels in één enkel verzoek. Dezelfde daemonverificatie als de single-proof eindpunten, maar in batches voor efficiëntie. Ideaal voor marktplaatsen die meerdere bestellingen verwerken of portemonnees die meerdere inkomende betalingen tegelijk verifiëren.

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

Batchlimieten en foutreferentie

🧅 Tor / .onion — Leid alles door de mist

De API wel staatloze REST via HTTPS. Geen koekjes. Geen sessies. Geen JS-vingerafdruk. Geen WebSocket-upgrades. Puur verzoek → antwoord via TLS. Het werkt standaard via Tor omdat we het op die manier hebben gebouwd. Niet als bijzaak. Als je iets privé aan het bouwen bent en dat ben je niet Als u via .onion routert, lekt u uw IP-adres naar elke DNS-resolver tussen u en de server. Niet doen.

krul 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);

📡 Deel proefsleutels via Signal - Geen metadata

De proefsleutel moet van zender naar ontvanger reizen zonder de API aan te raken. Hier is de OPSEC-hiërarchie voor die overdracht:

Signaalintegratiehaak (Python-bot)

# 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...")

⚓ Marktplaatsbetalingsritueel

Je bouwt een soevereine marktplaats. Geen streep. Geen PayPal. Geen KYC-middleware. Alleen de Synergy Sea en kwantumverzegelde proof-sleutels. Zo verifieert u betalingen met exacte bedragen met alleen een proefsleutel - er zijn nooit adressen onthuld.

# 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 - Elke taal, elk patroon

Python — Verifieer een bewijssleutel

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 — Betalingsverificatie (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 - Compleet spiekbriefje

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 versus Monero – de eerlijke vergelijking

Monero was een pionier. Ringhandtekeningen, RingCT, stealth-adressen – allemaal briljant. Maar ze zijn gebouwd voor een pre-kwantumwereld waarin Ed25519 onbreekbaar was en de exacte tijdstempels op een ontdekkingsreiziger 'prima' waren. Dat tijdperk loopt ten einde. Hier staan ​​de twee kettingen als je ze naast elkaar legt:

Als je in 2026 nog steeds Monero gebruikt, ben je al dood: je hebt het gewoon niet gemerkt.

Jouw ringhandtekeningen? Chainalysis clustert ze als vee. Exacte tijdstempels? De NSA geeft een tijdstempel aan uw koffie. Ed25519? Shor komt eraan: je sleutels zijn stof. Bewijs genereren aan de clientzijde? Decompileer de portemonnee en vervals de hele dag proefdrukken. Dat is archeologie, geen veiligheid.

SynergyX-proefsleutels worden gegenereerd door de SynX-knooppunt met behulp van quantum Kyber-768-roosterversleuteling. De generatiemethode is verzegeld in de kern van het knooppunt: geen enkele client, geen decompiler, geen aanvaller heeft toegang tot de interne kwantumroosterparameters. Zelfs een geavanceerde tegenstander die de portemonnee volledig decompileert, krijgt niets: de portemonnee ontvangt de bewijssleutel van het knooppunt. Het genereert het niet. Het geheim verlaat de Node nooit.

Schaduwtransacties: afzender, ontvanger, bedrag, blok: null. Niet versluierd. Gewist.

Kwantumbestendige sleutels: Kyber-768-puzzelsleutels met traliewerk: bewijs het exacte aantal zonder te lekken wie heeft verzonden, wie heeft ontvangen, wanneer (± 120s fuzz) of waar. De sleutel decodeert exacte bedragen: 183,00, niet "medium". Geen adressen in het bewijs. Geen adressen in de API. Nergens adressen. Verloopt over 30 minuten.

Geen adres openbaarmaking: Er is geen weergavesleuteleindpunt. Geen auditeindpunt. Geen mechanisme om afzender of ontvanger te onthullen via deze API. Het bedrag is het enige dat naar boven komt. Identiteit blijft verdrinken – permanent.

Post-kwantum: Kyber-768, SPHINCS+, SHAKE256 - Shor kan je genesisblok kussen. Geen routekaart. Geen "later zal quantum sigs toevoegen." We zijn immuun geboren.

Wil je privacy? Stop met bedelen om restjes. Met Synergy krijg je kwantumstealth en snelheid in de zee van schaduwen. Neem het mes.

Foutcodes

verificatie_proof.php — HTTP-statuscodes

Runenenvelop (/rune-verify) — HTTP-statuscodes

429 Zeegaspedaal - Reactielichaam

Alle 429 antwoorden (beide eindpunten) omvatten: Retry-After HTTP-header (RFC 7231) en een gestructureerde JSON-body met laaginformatie:

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

Invoerformaten (beide eindpunten): TX-hash = precies 64 hexadecimale tekens [a-fA-F0-9]{64}. Proefsleutel = max. 67 tekens (met PT- voorvoegsel) of precies 64 hex (onbewerkt). De API accepteert beide formaten: serverstrips PT- automatisch. verify_proof.php accepteert de veldnaam proof_key or proof_token (alias). Alles buiten deze grenzen krijgt een harde 400. Er wordt niet bijgesneden. Geen genade.

🕳 Zero Metadata-garanties: wat ontwikkelaars moeten weten

Als u deze API integreert, is hier het harde bewijs daarvan geen metadatalekken. Elke claim hieronder is door GhostReaper gecontroleerd (meer dan 100 aanvalsvectoren, 0 niet-gepatchte bevindingen).

Beveiligingseigenschappen — Controlelijst voor ontwikkelaars

Wat u MOET doen als integrator

𖣐 Codeer het. Test het. Bezit het donker.

Je hebt nu alles. Zes eindpunten. Echte code. Tor-routering. Signaal haken. Een dreigingsmodel dat eerlijk is over wat lekt en wat niet. Quantum Kyber-768-proof sleutels gegenereerd door de SynX Node - onvervalste puzzelsleutels die exacte hoeveelheden decoderen en niets anders. Geen adresopenbaarmaking – niet met een weergavesleutel, niet met een proefsleutel, nooit. Tijdstempelfuzzing die timinganalyse statistisch betekenisloos maakt. En daaronder bevindt zich een roostercryptografie die elke bekende kwantumaanval overleeft – niet omdat we zijn gemigreerd, maar omdat we daar zijn begonnen.

De Synergy Sea is de post-kwantumoceaan waar schaduwen nooit aan de oppervlakte komen. Geen enkel datacenter kan koning zijn als SynergyX ze onttroont en de gebruiker op de troon zet. Elke privétransactie zinkt weg in de Kyber-768-inkapseling, verzegeld door SPHINCS+-hypertrees, geïndexeerd door kwantumroosterverplichtingen. Bedragen fluisteren door proefsleutels – onzin voor waarnemers, exacte decimalen voor sleutelhouders. De ontdekkingsreiziger ziet rimpelingen. De API retourneert nul waar het er toe doet. De bewijssleutel is de enige rode draad naar het bedrag – en het bedrag is dat ook alle dat oppervlak. Afzender en ontvanger? Verdronken. Permanent. Geen eindpunt, geen sleutel, geen dagvaarding brengt ze terug.

Geen KYC. Geen voogdij. Geen ketenanalyse. Geen adres openbaarmaking. Geen centraal faalpunt. Geen migratieroutekaart omdat er niets is om van te migreren. First mover in het kwantumeindspel.

Dit is geen documentatie. Dit is een wapen. Gebruik het.

𝓢𝔁
Codeer het. Test het. Bezit de donkere getijden.

SynergyX Privacy API v2.0 — Kwantumbestendige sleutels — De Synergy Sea
De post-kwantumoceaan waar schaduwen nooit aan de oppervlakte komen.