Denne vejledning dokumenterer det samme korrekturnøgleflow for private transaktioner, som bruges af timeline.php for tidslinjeadgangsbetalinger. Det er designet til udviklere, der skal acceptere private SynX-betalinger, verificere det nøjagtige beløb og holde adressedata ude af deres applikation.

• Hvad du modtager fra betaleren: en 64-karakterer tx_hash og en prøvenøgle. Korrekturnøglen kan være rå 64-hex eller præfikset som PT- plus 64 hex.
• Hvad API beviser: om denne bevisnøgle er gyldig for den pågældende transaktion og det nøjagtige SynX-beløb.
• Hvad API ikke afslører: afsenderadresse, modtageradresse, tegnebogssaldo eller en offentlig betalingssti for private transaktioner.
• Primært endepunkt: POST /explorer/api/verify_proof.php med JSON body {"tx_hash":"...","proof_key":"..."}.

Implementering af prøvenøgler som tidslinje

Tidslinje accepterer automatisk betalinger fra synlige markedspladser. Når en transaktion er privat eller skjult, skifter den til proof-key-bekræftelse. Korrekturnøglen bekræfter betalingsbeløbet, mens adressefelterne forbliver forseglede.

PHP-verifikator i tidslinjestil

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

Svarfelter at afhænge af

🌊 Hvorfor vi aldrig afslører afsender eller modtager

Dette er kerneprincippet. Open source-gennemsigtighed og brugernes privatliv er naturlige fjender - medmindre du arkitekterer grænsen korrekt. SynergyX løser dette ved at lave protokol gennemsigtig (alle kan revidere koden), mens den opbevares identitet permanent uigennemsigtig (der findes ingen mekanisme til at afsløre afsender eller modtager). Bevisnøglen er en puslespilnøgle - den låser op for beløbet, og kun beløbet. Identiteterne bag transaktionen blev opløst i Synergy Sea i det øjeblik, blokken blev forseglet.

SynX Node genererer bevisnøglen ved hjælp af kvante Kyber-768 gitterkryptering. Nøglen er matematisk bundet til transaktionsbeløbet. Det kan ikke smedes, kan ikke reverse-engineeres, og udløber om 30 minutter. Afsenderen deler korrekturnøglen med modtageren uden for kæden - Signal, PGP, Tor, en serviet. Modtageren verificerer via denne API. Det er hele tillidsmodellen. Ingen forældremyndighed. Ingen mellemmand. Intet metadataspor.

⛨ Hvad serveren ved (Jack)

Lad os være ærlige om tillidsgrænser. Du rammer en API. Serveren er en maskine, og maskiner kan beslaglægges. Her er præcis, hvad en angriber får, hvis de rooter boksen:

Timing afbødes. Hver enkelt API-svar - GET, POST, succes, fiasko, 404, alt - er polstret til en 500ms konstant loft. Serveren måler den faktiske behandlingstid og sover derefter nøjagtigt 500ms - elapsed. Hvert svar tager præcis 500 ms. Ikke tilfældigt. Konstant. Cohens d mellem gyldige og ugyldige stier: 0.015 (testet af GhostReaper — statistisk usynlig). Chainalysis's timing oracle playbook? Død ved ankomsten.

🌊 Synergy Sea — To dybdelag

Tænk på kæden som et hav. Offentlige transaktioner flyder på overfladen. Private synker. Jo dybere du går, jo mere har du brug for korrekturnøgler for at se noget. Og selv ved maksimal dybde er kun den beløb overflader — adresserer aldrig.

Der findes ikke noget dybere lag. Der er ingen visningsnøgleoplysning, ingen adresserevision, ingen mekanisme til at afsløre, hvem der sendte eller modtog. Bevisnøglen - genereret af SynX Node ved hjælp af kvante Kyber-768-kryptering - afkoder den nøjagtige mængde. Det er det dybeste nogen kan gå. Afsender- og modtageradresser druknes permanent i havet.

Anti-korrelations rustning: Tidsstempler fuzzed ±120s. Gebyrer fordelt på 5 niveauer (mikro/lav/standard/høj/premium — aldrig det rå sat beløb). Blokhøjder nulstillet. Svartider polstret til 500ms konstant loft. "TX ikke fundet" og "TX er privat" returnerer identisk form. Bevisnøgler udløber om 30 minutter — begrænsning af afspilningsvinduer til næsten nul. Du kan ikke engang opregne, hvilke hashes der er rigtige. Hver overfladeforespørgsel returnerer den samme mængde information, uanset om TX eksisterer, ikke eksisterer eller er afskærmet. Held og lykke, Chainalysis.

—͟͟͞͞★ Leverandørbevisbekræftelse — 3 minutter, nul tillid

Du er en sælger. En køber har lige betalt dig privat SynX. Du skal bekræfte betalingen uden at se deres adresse, deres saldo eller have tillid til nogen tredjepart. Sådan gør du. Ingen KYC. Ingen forældremyndighed. Bevis betalinger blindt.

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

𖣐 Fuld verifikationsrite

Trin ④ er det kritiske led. Bevisnøglen skal rejse afsender→modtager gennem en kanal, som API aldrig ser. Signal forsvindende beskeder. PGP-krypteret e-mail. Tor skjult tjeneste. En QR-kode vist på tværs af en tabel. En seddel tapet under en bænk i parken. API er ligeglad med, hvordan hemmeligheden kommer dertil - den verificerer kun matematikken, når modtageren spørger.

POST /verify_proof — Bekræft en korrekturnøgle (anbefales)

STOLPE FÅ OFFENTLIG — Den nemmeste måde at bekræfte en betaling på. Sende tx_hash + proof_key i kroppen (eller som GET params). Returnerer det nøjagtige beløb. Ingen auth. Ingen API nøgle. Ingen konto. Start her.

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

Komplet fejlreference — verify_proof.php

POST /privacy/tx/{hash}/rune-verify — Runekonvolut (rige metadata)

STOLPE OFFENTLIG — Samme bevisnøglebekræftelse med rigere metadata: tidsstempelvindue (±120 sek. fuzzy), udløbsnedtælling, dekrypteringsmetode. Brug denne, når du har brug for mere end blot mængden.

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

Hvad verifikatoren lærer versus hvad der forbliver druknet

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

FÅ OFFENTLIG — Findes denne TX? Returnerer en kryptografisk eksistensforpligtelse. Afslører intet andet.

{
  "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} — Shadow Transaction Lookup

FÅ OFFENTLIG - Slå ethvert TX op. Private returnerer skyggen - hash synlig, alt andet 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

Seneste TX'er. Private dukker op som skygger (nulfelter). Offentlige viser gennemsigtige data. God til dashboards. Forespørgsel param limit (1-50, standard 20).

GET /privatliv/statistik — Havdybdeaflæsninger

Metrics for overtagelse af privatlivets fred: samlede TX'er, private TX'er, adoption %, feature flag. Ingen godkendelse påkrævet. Overvåg havets dybde fra din egen infrastruktur.

POST /privacy/batch-proof — Batch Verify Multiple Proofs

STOLPE OFFENTLIG — Bekræft op til 50 prøvenøgler i en enkelt anmodning. Samme dæmonverifikation som de enkeltsikre endepunkter, men batchet for effektivitet. Ideel til markedspladser, der behandler flere ordrer eller tegnebøger, der bekræfter flere indgående betalinger på én gang.

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

Batchgrænser og fejlreference

🧅 Tor / .løg — Ruter alt gennem tågen

API er statsløs REST over HTTPS. Ingen cookies. Ingen sessioner. Ingen JS-fingeraftryk. Ingen WebSocket-opgraderinger. Ren anmodning→svar over TLS. Det fungerer over Tor indbygget, fordi vi byggede det på den måde. Ikke som en eftertanke. Hvis du bygger noget privat, og du er ikke routing gennem .onion, lækker du din IP til alle DNS-resolvere mellem dig og serveren. Lad være.

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

📡 Del bevisnøgler via signal — nul metadata

Bevisnøglen skal rejse afsender → modtager uden at røre ved API. Her er OPSEC-hierarkiet for den overdragelse:

Signal Integration 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...")

⚓ Marketplace Payment Rite

Du bygger en suveræn markedsplads. Ingen stribe. Ingen PayPal. Ingen KYC middleware. Kun Synergy Sea og kvanteforseglede prøvenøgler. Sådan bekræfter du betalinger med nøjagtige beløb kun ved at bruge en korrekturnøgle - ingen adresser blev nogensinde afsløret.

# 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 - hvert sprog, hvert mønster

Python — Bekræft en korrekturnøgle

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 – Betalingsverifier (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 — Komplet snydeark

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 - Den ærlige sammenligning

Monero var banebrydende. Ringsignaturer, RingCT, stealth-adresser - alt sammen genialt. Men de blev bygget til en præ-kvanteverden, hvor Ed25519 var ubrydelig og nøjagtige tidsstempler på en opdagelsesrejsende var "fine". Den æra er ved at være slut. Her er hvor de to kæder står, når du sætter dem side om side:

Hvis du stadig bruger Monero i 2026, er du allerede død: du har bare ikke lagt mærke til det.

Dine ringesignaturer? Kædelyset samler dem som kvæg. Præcise tidsstempler? NSA tidsstempler din kaffe. Ed25519? Shor kommer: dine nøgler er støv. Bevisgenerering på klientsiden? Dekompiler tegnebogen og smid beviser hele dagen. Det er arkæologi, ikke sikkerhed.

SynergyX proof nøgler genereres af SynX Node ved hjælp af kvante Kyber-768 gitterkryptering. Genereringsmetoden er forseglet inde i nodens kerne - ingen klient, ingen decompiler, ingen angriber kan få adgang til de interne kvantegitterparametre. Selv en sofistikeret modstander, der fuldt ud dekompilerer tegnebogen, får intet: tegnebogen modtager bevisnøglen fra noden. Det genererer det ikke. Hemmeligheden forlader aldrig noden.

Skyggetransaktioner: afsender, modtager, beløb, blok: null. Ikke tilsløret. Slettet.

Kvantesikre nøgler: Kyber-768 gitterforseglede puslespilsnøgler: bevis den nøjagtige mængde uden at lække, hvem der sendte, hvem der modtog, hvornår (±120s fuzz) eller hvor. Nøglen afkoder nøjagtige beløb — 183,00, ikke "medium". Ingen adresser i beviset. Ingen adresser i API. Ingen adresser nogen steder. Udløber om 30 minutter.

Ingen adresseoplysning: Der er ikke noget visningsnøgleslutpunkt. Intet revisionsendepunkt. Ingen mekanisme til at afsløre afsender eller modtager gennem denne API. Mængden er alt, hvad der dukker op. Identitet forbliver druknet - permanent.

Post-kvante: Kyber-768, SPHINCS+, SHAKE256 — Shor kan kysse din genesis-blok. Ingen køreplan. Ingen "senere vil tilføje kvantetegn." Vi blev født immune.

Vil du have privatliv? Stop med at tigge om skrot. Med Synergy får du quantum stealth og fart i skyggernes hav. Tag bladet.

Fejlkoder

verify_proof.php — HTTP-statuskoder

Runekonvolut (/rune-verify) — HTTP-statuskoder

429 Søgasspjæld — Responsorgan

Alle 429 svar (begge endepunkter) inkluderer en Retry-After HTTP-header (RFC 7231) og et struktureret JSON-legeme med niveauoplysninger:

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

Inputformater (begge endepunkter): TX-hash = nøjagtigt 64 hex-tegn [a-fA-F0-9]{64}. Bevisnøgle = max 67 tegn (med PT- præfiks) eller nøjagtigt 64 hex (rå). API accepterer begge formater - serverstrips PT- automatisk. verify_proof.php accepterer feltnavnet proof_key or proof_token (alias). Alt uden for disse grænser får en hård 400. Ingen trimning. Ingen nåde.

🕳 Nul metadata-garantier - hvad udviklere skal vide

Hvis du integrerer denne API, her er det hårde bevis på det ingen metadatalæk. Hvert krav nedenfor er GhostReaper-revideret (100+ angrebsvektorer, 0 ikke-patchede fund).

Sikkerhedsegenskaber — Udviklertjekliste

Hvad du SKAL gøre som integrator

𖣐 Kod det. Test det. Eje mørket.

Du har nu alt. Seks endepunkter. Ægte kode. Tor routing. Signalkroge. En trusselmodel, der er ærlig omkring, hvad der lækker, og hvad der ikke gør. Quantum Kyber-768 proof keys genereret af SynX Node — uforglemmelige puslespilsnøgler, der afkoder nøjagtige mængder og intet andet. Ingen adresseoplysning – ikke med en visningsnøgle, ikke med en korrekturnøgle, aldrig nogensinde. Tidsstempel fuzzing, der gør timing analyse statistisk meningsløs. Og under det hele, gitterkryptografi, der overlever alle kendte kvanteangreb - ikke fordi vi migrerede, men fordi vi startede der.

Synergy Sea er det post-kvantehav, hvor skygger aldrig kommer til overfladen. Intet datacenter kan være konge, når SynergyX detroniserer dem og troner brugeren. Hver privat transaktion synker ind i Kyber-768-indkapsling, forseglet af SPHINCS+-hypertræer, indekseret af kvantegitter-forpligtelser. Beløb hvisker gennem bevisnøgler - volapyk til observatører, nøjagtige decimaler til nøgleholdere. Udforskeren ser krusninger. API returnerer null, hvor det betyder noget. Korrekturnøglen er den eneste tråd tilbage til beløbet - og beløbet er det alle der dukker op. Afsender og modtager? Druknede. Permanent. Intet endepunkt, ingen nøgle, ingen stævning bringer dem tilbage.

Ingen KYC. Ingen forældremyndighed. Ingen kædeanalyse. Ingen adresseoplysning. Intet centralt fejlpunkt. Ingen migration køreplan, fordi der ikke er noget at migrere fra. First mover i kvanteslutspillet.

Dette er ikke dokumentation. Dette er et våben. Brug det.

𝓢𝔁
Kod det. Test det. Eje de mørke tidevand.

SynergyX Privacy API v2.0 — Quantum Proof Keys — Synergy Sea
Det post-kvante hav, hvor skygger aldrig kommer til overfladen.