Den här guiden dokumenterar samma privata transaktionsprovnyckelflöde som används av timeline.php för betalningar för tidslinjeåtkomst. Den är designad för utvecklare som behöver acceptera privata SynX-betalningar, verifiera det exakta beloppet och hålla adressdata borta från sin applikation.

• Vad du får från betalaren: en 64-tecken tx_hash och en provnyckel. Provnyckeln kan vara rå 64-hex eller ha prefix som PT- plus 64 hex.
• Vad API bevisar: om den bevisnyckeln är giltig för den transaktionen och det exakta SynX-beloppet.
• Vad API inte avslöjar: avsändaradress, mottagaradress, plånbokssaldo eller en offentlig betalningsväg för privata transaktioner.
• Primär slutpunkt: POST /explorer/api/verify_proof.php med JSON-kropp {"tx_hash":"...","proof_key":"..."}.

Implementering av provnycklar som tidslinje

Tidslinjen accepterar synliga marknadsplatsbetalningar automatiskt. När en transaktion är privat eller dold, växlar den till verifiering med korrekturnyckel. Bevisnyckeln bekräftar betalningsbeloppet medan adressfälten förblir förseglade.

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

Svarsfält att bero på

🌊 Varför vi aldrig avslöjar avsändare eller mottagare

Detta är kärnprincipen. Öppen källkodstransparens och användarintegritet är naturliga fiender – såvida du inte utformar gränsen korrekt. SynergyX löser detta genom att göra protokoll transparent (vem som helst kan granska koden) samtidigt som den behålls identitet permanent ogenomskinlig (ingen mekanism finns för att avslöja sändare eller mottagare). Bevisnyckeln är en pusselnyckel — den låser upp beloppet, och endast beloppet. Identiteterna bakom transaktionen upplöstes i Synergy Sea i samma ögonblick som blocket förseglades.

SynX Node genererar bevisnyckeln med hjälp av kvant Kyber-768 gitterkryptering. Nyckeln är matematiskt bunden till transaktionsbeloppet. Det kan inte smidas, kan inte omvändas, och går ut om 30 minuter. Avsändaren delar provnyckeln med mottagaren utanför kedjan — Signal, PGP, Tor, en servett. Mottagaren verifierar via denna API. Det är hela tillitsmodellen. Ingen vårdnad. Ingen mellanhand. Inget metadataspår.

⛨ Vad servern vet (Jack)

Låt oss vara ärliga om förtroendegränser. Du slår en API. Servern är en maskin och maskiner kan beslagtas. Här är exakt vad en angripare får om de rootar rutan:

Tidpunkten är mildrad. Varje enskilt API-svar — GET, POST, framgång, misslyckande, 404, allt — är vadderat till en 500ms konstant tak. Servern mäter den faktiska bearbetningstiden och sover sedan exakt 500ms - elapsed. Varje svar tar exakt 500ms. Inte slumpmässigt. Konstant. Cohens d mellan giltiga och ogiltiga sökvägar: 0.015 (testad av GhostReaper — statistiskt osynlig). Chainalysis's timing oracle playbook? Död vid ankomst.

🌊 Synergy Sea — Två djuplager

Tänk på kedjan som ett hav. Offentliga transaktioner flyter på ytan. Privata sjunker. Ju djupare du går, desto mer behöver du provnycklar för att se någonting. Och även på maximalt djup är det bara belopp ytor — adresserar aldrig.

Det finns inget djupare lager. Det finns ingen visningsnyckel, ingen adressgranskning, ingen mekanism för att avslöja vem som skickade eller tog emot. Bevisnyckeln – genererad av SynX-noden med hjälp av kvant-Kyber-768-kryptering – avkodar den exakta mängden. Det är det djupaste någon kan gå. Avsändar- och mottagaradresser drunknar permanent i havet.

Anti-korrelationsrustning: Tidsstämplar fuzzed ±120s. Avgifterna fördelade på 5 nivåer (mikro/låg/standard/hög/premium – aldrig det råa beloppet). Blockhöjder nollställda. Svarstider vadderade till 500ms konstant tak. "TX not found" och "TX is private" returnerar identisk form. Bevisnycklar löper ut om 30 minuter — begränsa uppspelningsfönster till nära noll. Du kan inte ens räkna upp vilka hash som är riktiga. Varje ytfråga returnerar samma mängd information oavsett om TX existerar, inte existerar eller är avskärmad. Lycka till, Chainalysis.

—͟͟͞͞★ Verifiering av leverantörsbevis — 3 minuter, noll förtroende

Du är en försäljare. En köpare har precis betalat dig i privat SynX. Du måste verifiera betalningen utan att se deras adress, deras saldo eller lita på någon tredje part. Så här gör du. Ingen KYC. Ingen vårdnad. Bevisa betalningar blinda.

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

𖣐 Fullständig verifieringsrit

Steg ④ är den kritiska länken. Bevisnyckeln måste färdas avsändare→mottagare genom en kanal som API aldrig ser. Signalera meddelanden som försvinner. PGP-krypterad e-post. Tor dold tjänst. En QR-kod visas över en tabell. En lapp tejpad under en parkbänk. API bryr sig inte om hur hemligheten kommer dit - den verifierar bara matematiken när mottagaren frågar.

POST /verify_proof — Verifiera en korrekturnyckel (rekommenderas)

POSTA FÅ OFFENTLIG — Det enklaste sättet att verifiera en betalning. Skicka tx_hash + proof_key i kroppen (eller som GET params). Returnerar det exakta beloppet. Ingen autentisering. Ingen API-nyckel. Inget konto. Börja här.

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

Komplett felreferens — verify_proof.php

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

POSTA OFFENTLIG — Samma bevisnyckelverifiering med rikare metadata: tidsstämpelfönster (±120s fuzzy), utgångsnedräkning, dekrypteringsmetod. Använd detta när du behöver mer än bara 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" }

Vad verifieraren lär sig kontra vad som förblir drunknat

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

FÅ OFFENTLIG — Finns denna TX? Returnerar ett kryptografiskt existensåtagande. Avslöjar inget annat.

{
  "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å upp vilken TX som helst. Privata ger tillbaka skuggan - hash synlig, allt annat 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

Senaste TX. Privata dyker upp som skuggor (nollfält). Offentliga visar transparenta data. Bra för instrumentpaneler. Fråga param limit (1-50, standard 20).

GET /privacy/stats — Havsdjupsavläsningar

Mätvärden för antagande av sekretess: totala TX, privata TX, adoptionsprocent, funktionsflaggor. Ingen autentisering krävs. Övervaka havets djup från din egen infrastruktur.

POST /privacy/batch-proof — Batchverifiera flera bevis

POSTA OFFENTLIG — Verifiera upp till 50 provnycklar i en enda begäran. Samma demonverifiering som de enkelsäkra slutpunkterna, men batchad för effektivitet. Idealisk för marknadsplatser som behandlar flera beställningar eller plånböcker som verifierar flera inkommande betalningar samtidigt.

// 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 och felreferens

🧅 Tor / .onion — Led allt genom dimman

API är statslös REST över HTTPS. Inga kakor. Inga sessioner. Inget JS-fingeravtryck. Inga WebSocket-uppgraderingar. Ren begäran→svar över TLS. Det fungerar över Tor inbyggt eftersom vi byggde det på det sättet. Inte som en eftertanke. Om du bygger något privat och du gör det inte routing genom .onion, läcker du din IP till alla DNS-lösare mellan dig och servern. Gör det inte.

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

📡 Dela bevisnycklar via signal — noll metadata

Bevisnyckeln måste färdas avsändare → mottagare utan att vidröra API. Här är OPSEC-hierarkin för den överlämnandet:

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 marknadsplats. Ingen Stripe. Ingen PayPal. Ingen KYC mellanprogram. Bara Synergy Sea och kvantförseglade proof-nycklar. Så här verifierar du betalningar med exakta belopp med endast en korrekturnyckel — inga adresser avslöjas någonsin.

# 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 — Varje språk, varje mönster

Python — Verifiera en korrekturnyckel

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 – Betalningsverifierare (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 — Komplett fuskblad

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 ärliga jämförelsen

Monero var pionjär. Ringsignaturer, RingCT, stealth-adresser – allt briljant. Men de byggdes för en pre-kvantvärld där Ed25519 var okrossbar och exakta tidsstämplar på en utforskare var "bra". Den eran är över. Här är de två kedjorna när du sätter dem sida vid sida:

Om du fortfarande använder Monero 2026 är du redan död: du har bara inte märkt det.

Dina ringsignaturer? Kedjeanalys samlar dem som boskap. Exakta tidsstämplar? NSA tidsstämplar ditt kaffe. Ed25519? Shor kommer: dina nycklar är damm. Bevisgenerering på klientsidan? Dekompilera plånboken och förfalska korrektur hela dagen. Det är arkeologi, inte säkerhet.

SynergyX proof-nycklar genereras av SynX Nod använder kvant Kyber-768 gitterkryptering. Genereringsmetoden är förseglad inuti nodens kärna — ingen klient, ingen dekompilator, ingen angripare kan komma åt de interna kvantgitterparametrarna. Även en sofistikerad motståndare som helt dekompilerar plånboken får ingenting: plånboken tar emot provnyckeln från noden. Det genererar det inte. Hemligheten lämnar aldrig noden.

Skuggtransaktioner: avsändare, mottagare, belopp, block: null. Inte obfuscerad. Raderad.

Kvantsäkra nycklar: Kyber-768 gitterförseglade pusselnycklar: bevisa den exakta mängden utan att läcka vem som skickade, vem tog emot, när (±120s fuzz) eller var. Nyckeln avkodar exakta belopp — 183,00, inte "medium". Inga adresser i beviset. Inga adresser i API. Inga adresser någonstans. Går ut om 30 minuter.

Ingen adressupplysning: Det finns ingen vynyckelslutpunkt. Ingen revisionsändpunkt. Ingen mekanism för att avslöja sändare eller mottagare genom denna API. Mängden är allt som dyker upp. Identitet förblir drunknade — permanent.

Postkvantum: Kyber-768, SPHINCS+, SHAKE256 — Shor kan kyssa ditt genesisblock. Ingen färdplan. Inga "senare kommer att lägga till kvant-sig." Vi föddes immuna.

Vill du ha integritet? Sluta tigga om skrot. Med Synergy får du quantum stealth och fart i havet av skuggor. Ta bladet.

Felkoder

verify_proof.php — HTTP-statuskoder

Runiskt kuvert (/rune-verify) — HTTP-statuskoder

429 Sea Throttle — Response Body

Alla 429 svar (båda endpoints) inkluderar en Retry-After HTTP-huvud (RFC 7231) och en strukturerad JSON-kropp med nivåinformation:

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

Indataformat (båda slutpunkter): TX-hash = exakt 64 hexadecken [a-fA-F0-9]{64}. Bevisnyckel = max 67 tecken (med PT- prefix) eller exakt 64 hex (rå). API accepterar båda formaten - serverremsor PT- automatiskt. verify_proof.php accepterar fältnamnet proof_key or proof_token (alias). Allt utanför dessa gränser får en hård 400. Ingen trimning. Ingen nåd.

🕳 Noll metadata-garantier – vad utvecklare måste veta

Om du integrerar denna API, här är det hårda beviset på det inga metadataläckor. Alla påståenden nedan är GhostReaper-reviderade (100+ attackvektorer, 0 opatchade fynd).

Säkerhetsegenskaper — Utvecklarchecklista

Vad du MÅSTE göra som integratör

𖣐 Koda det. Testa det. Äga mörkret.

Nu har du allt. Sex slutpunkter. Riktig kod. Tor routing. Signalkrokar. En hotmodell som är ärlig om vad som läcker och inte. Quantum Kyber-768 proof-nycklar genererade av SynX Node — oförglömliga pusselnycklar som avkodar exakta mängder och inget annat. Ingen adressupplysning – inte med en vynyckel, inte med en korrekturnyckel, aldrig någonsin. Tidsstämpel fuzzing som gör timing analys statistiskt meningslös. Och under allt, gitterkryptografi som överlever alla kända kvantattacker - inte för att vi migrerade, utan för att vi började där.

Synergy Sea är postkvanthavet där skuggor aldrig kommer upp till ytan. Inget datacenter kan vara kung när SynergyX detroniserar dem och tronar användaren. Varje privat transaktion sjunker in i Kyber-768-inkapsling, förseglad av SPHINCS+-hyperträd, indexerad av kvantnätsåtaganden. Belopp viskar genom korrekturnycklar - snålhet till observatörer, exakta decimaler till nyckelinnehavare. Utforskaren ser krusningar. API returnerar null där det är viktigt. Korrekturnyckeln är den enda tråden tillbaka till beloppet - och beloppet är det alla som dyker upp. Avsändare och mottagare? Dränkte. Permanent. Ingen slutpunkt, ingen nyckel, ingen stämning tar dem tillbaka.

Ingen KYC. Ingen vårdnad. Ingen kedjeanalys. Ingen adressupplysning. Ingen central punkt för misslyckande. Ingen migreringsfärdplan eftersom det inte finns något att migrera från. First mover i quantum slutspelet.

Det här är inte dokumentation. Det här är ett vapen. Använd den.

𝓢𝔁
Koda den. Testa det. Äg det mörka tidvattnet.

SynergyX Privacy API v2.0 — Quantum Proof Keys — Synergy Sea
Postkvanthavet där skuggor aldrig kommer upp till ytan.