In diesem Handbuch wird der gleiche Proof-Key-Ablauf für private Transaktionen dokumentiert, der von verwendet wird timeline.php für Timeline-Zugriffszahlungen. Es richtet sich an Entwickler, die private SynX-Zahlungen akzeptieren, den genauen Betrag überprüfen und Adressdaten aus ihrer Anwendung fernhalten müssen.

• Was Sie vom Zahler erhalten: ein 64-Zeichen tx_hash und ein Beweisschlüssel. Der Proof-Schlüssel kann ein reines 64-Hex-Format oder das Präfix „as“ haben PT- plus 64 Hex.
• Was der API beweist: ob dieser Nachweisschlüssel für diese Transaktion gültig ist und den genauen SynX-Betrag.
• Was der API nicht verrät: Absenderadresse, Empfängeradresse, Wallet-Guthaben oder ein öffentlicher Zahlungspfad für private Transaktionen.
• Primärer Endpunkt: POST /explorer/api/verify_proof.php mit JSON-Body {"tx_hash":"...","proof_key":"..."}.

Proof-Schlüssel wie Timeline implementieren

Timeline akzeptiert sichtbare Marktplatzzahlungen automatisch. Wenn eine Transaktion privat oder verborgen ist, wechselt sie zur Proof-Key-Verifizierung. Der Nachweisschlüssel bestätigt den Zahlungsbetrag, während die Adressfelder versiegelt bleiben.

PHP-Verifizierer im Timeline-Stil

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

Antwortfelder, auf die man sich verlassen kann

🌊 Warum wir niemals Absender oder Empfänger offenlegen

Dies ist das Kernprinzip. Open-Source-Transparenz und Benutzerdatenschutz sind natürliche Feinde – es sei denn, Sie legen die Grenzen richtig fest. SynergyX löst dieses Problem, indem es das macht Protokoll transparent (jeder kann den Code überprüfen) und gleichzeitig beibehalten Identität dauerhaft undurchsichtig (es gibt keinen Mechanismus, um Absender oder Empfänger offenzulegen). Der Beweisschlüssel ist ein Rätselschlüssel – er schaltet den Betrag frei und nur die Summe. Die Identitäten hinter der Transaktion lösten sich im Synergy Sea auf, sobald der Block versiegelt wurde.

Der SynX-Knoten generiert den Beweisschlüssel mithilfe der Quanten-Kyber-768-Gitterverschlüsselung. Der Schlüssel ist mathematisch an den Transaktionsbetrag gebunden. Es kann nicht gefälscht werden, kann nicht rückentwickelt werden und läuft in 30 Minuten ab. Der Absender teilt den Beweisschlüssel mit dem Empfänger außerhalb der Kette – Signal, PGP, Tor, eine Serviette. Der Empfänger verifiziert sich über diesen API. Das ist das gesamte Vertrauensmodell. Kein Sorgerecht. Kein Vermittler. Keine Metadatenspur.

⛨ Was der Server weiß (Jack)

Seien wir ehrlich, was Vertrauensgrenzen angeht. Du triffst einen API. Der Server ist eine Maschine, und Maschinen können beschlagnahmt werden. Hier erfahren Sie genau, was ein Angreifer erhält, wenn er die Box rootet:

Das Timing wird gemildert. Jede einzelne API-Antwort – GET, POST, Erfolg, Misserfolg, 404, alles – wird mit einem aufgefüllt 500 ms konstante Decke. Der Server misst die tatsächliche Verarbeitungszeit und geht dann genau in den Ruhezustand 500ms - elapsed. Jede Antwort dauert genau 500 ms. Nicht zufällig. Konstante. Cohens d zwischen gültigen und ungültigen Pfaden: 0.015 (getestet von GhostReaper – statistisch unsichtbar). Das Timing-Oracle-Playbook von Chainalysis? Bei der Ankunft tot.

🌊 Der Synergy Sea – Zwei Tiefenschichten

Stellen Sie sich die Kette als einen Ozean vor. Öffentliche Transaktionen schweben an der Oberfläche. Private sinken. Je tiefer Sie gehen, desto mehr Beweisschlüssel benötigen Sie, um etwas zu sehen. Und selbst bei maximaler Tiefe nur die Menge Oberflächen – niemals Adressen.

Es existiert keine tiefere Schicht. Es gibt keine Offenlegung des Ansichtsschlüssels, keine Adressprüfung, keinen Mechanismus, um offenzulegen, wer gesendet oder empfangen hat. Der vom SynX-Knoten mithilfe der Quanten-Kyber-768-Verschlüsselung generierte Beweisschlüssel entschlüsselt den genauen Betrag. Das ist das Tiefste, was jemand erreichen kann. Sender- und Empfängeradressen gehen dauerhaft im Meer unter.

Anti-Korrelations-Rüstung: Zeitstempel um ±120 s verfälscht. Die Gebühren sind in 5 Stufen unterteilt (Mikro/Niedrig/Standard/Hoch/Premium – niemals der reine Sat-Betrag). Blockhöhen auf Null gesetzt. Reaktionszeiten auf eine konstante Obergrenze von 500 ms aufgefüllt. „TX nicht gefunden“ und „TX ist privat“ geben das zurück identische Form. Proof-Schlüssel laufen ab 30 Minuten – Begrenzung der Wiedergabefenster auf nahezu Null. Sie können nicht einmal aufzählen, welche Hashes echt sind. Jede Oberflächenabfrage gibt die gleiche Menge an Informationen zurück, unabhängig davon, ob der TX existiert, nicht existiert oder abgeschirmt ist. Viel Glück, Chainalysis.

—͟͟͞͞★ Überprüfung des Lieferantennachweises – 3 Minuten, Zero Trust

Sie sind ein Verkäufer. Ein Käufer hat Ihnen gerade privat SynX bezahlt. Sie müssen die Zahlung überprüfen, ohne deren Adresse oder Kontostand zu sehen oder Dritten zu vertrauen. Hier erfahren Sie, wie. Kein KYC. Kein Sorgerecht. Beweisen Sie Zahlungen 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"
}

𖣐 Vollständiger Verifizierungsritus

Schritt ④ ist der kritische Link. Der Beweisschlüssel muss vom Sender zum Empfänger über einen Kanal wandern, den der API nie sieht. Signalisieren Sie verschwindende Nachrichten. PGP-verschlüsselte E-Mail. Versteckter Tor-Dienst. Ein QR-Code, der auf einem Tisch angezeigt wird. Eine Notiz, die unter einer Parkbank befestigt ist. Dem API ist es egal, wie das Geheimnis dorthin gelangt – er überprüft die Mathematik nur, wenn der Empfänger danach fragt.

POST /verify_proof – Überprüfen eines Proof-Schlüssels (empfohlen)

POST ERHALTEN ÖFFENTLICH — Der einfachste Weg, eine Zahlung zu überprüfen. Schicken tx_hash + proof_key im Körper (oder als GET-Parameter). Gibt den genauen Betrag zurück. Keine Autorisierung. Kein API-Schlüssel. Kein Konto. Beginnen Sie 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...\"}"
  }
}

Vollständige Fehlerreferenz – verify_proof.php

POST /privacy/tx/{hash}/rune-verify – Runic Envelope (Rich Metadata)

POST ÖFFENTLICH – Gleiche Schlüsselüberprüfung mit umfassenderen Metadaten: Zeitstempelfenster (±120 Sekunden unscharf), Ablauf-Countdown, Entschlüsselungsmethode. Verwenden Sie dies, wenn Sie mehr als nur die Menge benötigen.

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

Was der Prüfer lernt und was untergeht

GET /privacy/tx/{hash}/verify – Existenz Oracle

ERHALTEN ÖFFENTLICH — Existiert dieser TX? Gibt eine kryptografische Existenzverpflichtung zurück. Verrät nichts anderes.

{
  "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} – Suche nach Schattentransaktionen

ERHALTEN ÖFFENTLICH – Suchen Sie nach TX. Private geben den Schatten zurück – Hash sichtbar, alles 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 – ​​Oberflächenwellen

Aktuelle TXs. Private erscheinen als Schatten (Nullfelder). Öffentliche zeigen transparente Daten. Gut für Dashboards. Abfrageparameter limit (1-50, Standard 20).

GET /privacy/stats – Meerestiefenwerte

Metriken zur Datenschutzakzeptanz: TXs insgesamt, private TXs, Akzeptanz %, Feature-Flags. Keine Authentifizierung erforderlich. Überwachen Sie die Tiefe des Meeres von Ihrer eigenen Infrastruktur aus.

POST /privacy/batch-proof – Mehrere Proofs stapelweise überprüfen

POST ÖFFENTLICH — Überprüfen Sie bis zu 50 Proof-Schlüssel in einer einzigen Anfrage. Gleiche Daemon-Überprüfung wie die Single-Proof-Endpunkte, jedoch aus Effizienzgründen stapelweise. Ideal für Marktplätze, die mehrere Bestellungen verarbeiten, oder für Wallets, die mehrere Zahlungseingänge gleichzeitig überprüfen.

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

Batch-Grenzwerte und Fehlerreferenz

🧅 Tor / .onion – Leite alles durch den Nebel

Der API ist Zustandsloses REST über HTTPS. Keine Kekse. Keine Sitzungen. Kein JS-Fingerabdruck. Keine WebSocket-Upgrades. Reine Anfrage→Antwort über TLS. Es funktioniert nativ über Tor, weil wir es so erstellt haben. Nicht als nachträglicher Einfall. Wenn Sie etwas Privates bauen und es ist nicht Beim Routing über .onion geben Sie Ihre IP-Adresse an jeden DNS-Resolver zwischen Ihnen und dem Server weiter. Nicht.

cURL über 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 über 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 über 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);

📡 Teilen Sie Proof-Schlüssel über Signal – keine Metadaten

Der Prüfschlüssel muss Sender → Empfänger bewegen, ohne den API zu berühren. Hier ist die OPSEC-Hierarchie für diese Übergabe:

Signalintegrations-Hook (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...")

⚓ Marktplatz-Zahlungsritus

Sie bauen einen souveränen Marktplatz auf. Kein Streifen. Kein PayPal. Keine KYC-Middleware. Nur der Synergy Sea und die quantenversiegelten Proof-Schlüssel. So verifizieren Sie Zahlungen mit genaue Beträge Es wird nur ein Beweisschlüssel verwendet – es werden nie Adressen preisgegeben.

# 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 – Jede Sprache, jedes Muster

Python – Überprüfen Sie einen Proof-Schlüssel

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 – Zahlungsverifizierer (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 – Vollständiger Spickzettel

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 – Der ehrliche Vergleich

Monero leistete Pionierarbeit. Ringsignaturen, RingCT, Stealth-Adressen – alles brillant. Aber sie wurden für eine Welt vor der Quantentheorie gebaut, in der Ed25519 unzerbrechlich war und genaue Zeitstempel auf einem Explorer „in Ordnung“ waren. Diese Ära geht zu Ende. So stehen die beiden Ketten, wenn man sie nebeneinander legt:

Wenn Sie Monero im Jahr 2026 noch verwenden, sind Sie bereits tot: Sie haben es nur nicht bemerkt.

Ihre Ringsignaturen? Die Kettenanalyse gruppiert sie wie Vieh. Genaue Zeitstempel? Die NSA versieht Ihren Kaffee mit einem Zeitstempel. Ed25519? Shor kommt: Ihre Schlüssel sind Staub. Clientseitige Beweiserstellung? Dekompilieren Sie die Brieftasche und fälschen Sie den ganzen Tag Beweise. Das ist Archäologie, nicht Sicherheit.

SynergyX-Proof-Schlüssel werden von generiert SynX-Knoten unter Verwendung der Quanten-Kyber-768-Gitterverschlüsselung. Die Generierungsmethode ist im Kern des Knotens versiegelt – kein Client, kein Dekompiler, kein Angreifer kann auf die internen Quantengitterparameter zugreifen. Selbst ein raffinierter Gegner, der das Wallet vollständig dekompiliert, bekommt nichts: das Wallet erhält den Beweisschlüssel vom Knoten. Es erzeugt es nicht. Das Geheimnis verlässt niemals den Knoten.

Schattentransaktionen: Absender, Empfänger, Betrag, Block: null. Nicht verschleiert. Gelöscht.

Quantenbeweisschlüssel: Kyber-768-Rätselschlüssel mit Gitterversiegelung: Beweisen Sie den genauen Betrag, ohne preiszugeben, wer gesendet, wer wann (±120 Sekunden Fuzz) oder wo empfangen hat. Der Schlüssel entschlüsselt genaue Beträge – 183,00, nicht „mittel“. Keine Adressen im Beweis. Keine Adressen im API. Nirgendwo Adressen. Läuft in 30 Minuten ab.

Keine Adressauskunft: Es gibt keinen View-Key-Endpunkt. Kein Audit-Endpunkt. Kein Mechanismus zur Offenlegung von Sender oder Empfänger über dieses API. Die Menge ist alles, was auftaucht. Die Identität bleibt untergehen – und zwar für immer.

Postquantum: Kyber-768, SPHINCS+, SHAKE256 – Shor kann Ihren Genesis-Block küssen. Keine Roadmap. Kein „Später werden Quantensignale hinzugefügt.“ Wir wurden immun geboren.

Du möchtest Privatsphäre? Hören Sie auf, um Essensreste zu betteln. Mit Synergy erhalten Sie Quanten-Stealth und Geschwindigkeit im Meer der Schatten. Nimm die Klinge.

Fehlercodes

verify_proof.php – HTTP-Statuscodes

Runenumschlag (/rune-verify) – HTTP-Statuscodes

429 Sea Throttle – Reaktionskörper

Alle 429 Antworten (beide Endpunkte) umfassen a Retry-After HTTP-Header (RFC 7231) und ein strukturierter JSON-Body mit Ebeneninformationen:

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

Eingabeformate (beide Endpunkte): TX-Hash = genau 64 Hexadezimalzeichen [a-fA-F0-9]{64}. Proof-Schlüssel = max. 67 Zeichen (mit PT- Präfix) oder genau 64 Hex (roh). Der API akzeptiert beide Formate – Server-Strips PT- automatisch. verify_proof.php akzeptiert den Feldnamen proof_key or proof_token (alias). Alles außerhalb dieser Grenzen erhält eine harte 400. Kein Trimmen. Keine Gnade.

🕳 Null-Metadaten-Garantien – Was Entwickler wissen müssen

Wenn Sie diesen API integrieren, finden Sie hier den harten Beweis dafür Keine Metadatenlecks. Jeder unten aufgeführte Anspruch wurde von GhostReaper geprüft (mehr als 100 Angriffsvektoren, 0 ungepatchte Ergebnisse).

Sicherheitseigenschaften – Checkliste für Entwickler

Was Sie als Integrator tun MÜSSEN

𖣐 Codieren Sie es. Testen Sie es. Besitze die Dunkelheit.

Du hast jetzt alles. Sechs Endpunkte. Echter Code. Tor-Routing. Signalhaken. Ein Bedrohungsmodell, das ehrlich darüber ist, was durchsickert und was nicht. Quantum Kyber-768-Proof-Schlüssel, die vom SynX-Knoten generiert werden – fälschungssichere Puzzle-Schlüssel, die genaue Beträge und sonst nichts entschlüsseln. Keine Offenlegung der Adresse – nicht mit einem Ansichtsschlüssel, nicht mit einem Beweisschlüssel, niemals. Zeitstempel-Fuzzing, das die Zeitanalyse statistisch bedeutungslos macht. Und dahinter steckt eine Gitterkryptographie, die jeden bekannten Quantenangriff übersteht – nicht weil wir migriert sind, sondern weil wir dort angefangen haben.

Der Synergy Sea ist der Post-Quanten-Ozean, in dem niemals Schatten auftauchen. Kein Rechenzentrum kann König sein, wenn SynergyX es entthront und den Benutzer auf den Thron setzt. Jede private Transaktion versinkt in der Kyber-768-Kapselung, versiegelt durch SPHINCS+-Hyperbäume, indiziert durch Quantengitterverpflichtungen. Beträge flüstern durch Beweisschlüssel – Kauderwelsch für Beobachter, exakte Dezimalzahlen für Schlüsselinhaber. Der Entdecker sieht Wellen. Der API gibt Null zurück, wenn es darauf ankommt. Der Beweisschlüssel ist der einzige Hinweis auf den Betrag – und der Betrag ist es alle das taucht auf. Sender und Empfänger? Ertrunken. Permanent. Kein Endpunkt, kein Schlüssel, keine Vorladung bringt sie zurück.

Kein KYC. Kein Sorgerecht. Keine Kettenanalyse. Keine Adressoffenlegung. Kein zentraler Fehlerpunkt. Keine Migrations-Roadmap, da es nichts gibt, von dem man migrieren könnte. First Mover im Quantenendspiel.

Dies ist keine Dokumentation. Das ist eine Waffe. Benutze es.

𝓢𝔁
Codieren Sie es. Testen Sie es. Besitze die dunklen Gezeiten.

SynergyX-Datenschutz API v2.0 – Quantensichere Schlüssel – Der Synergy Sea
Der Post-Quanten-Ozean, in dem niemals Schatten auftauchen.