W tym przewodniku opisano ten sam przepływ klucza potwierdzającego transakcję prywatną, z którego korzysta firma timeline.php w przypadku płatności za dostęp do osi czasu. Jest przeznaczony dla programistów, którzy muszą akceptować prywatne płatności SynX, weryfikować dokładną kwotę i przechowywać dane adresowe poza swoją aplikacją.

• Co otrzymujesz od płatnika: 64-znakowy tx_hash i klucz próbny. Klucz sprawdzający może mieć postać surowego 64-szesnastkowego lub mieć prefiks jako PT- plus 64 heksy.
• Co udowadnia API: czy ten klucz potwierdzający jest ważny dla tej transakcji i dokładną kwotę SynX.
• Czego API nie ujawnia: adres nadawcy, adres odbiorcy, saldo portfela lub publiczna ścieżka płatności w przypadku transakcji prywatnych.
• Główny punkt końcowy: POST /explorer/api/verify_proof.php z treścią JSON {"tx_hash":"...","proof_key":"..."}.

Implementowanie kluczy potwierdzających, takich jak oś czasu

Oś czasu automatycznie akceptuje widoczne płatności na rynku. Kiedy transakcja jest prywatna lub ukryta, następuje przejście do weryfikacji za pomocą klucza potwierdzającego. Klucz potwierdzający potwierdza kwotę płatności, a pola adresowe pozostają zapieczętowane.

Weryfikator PHP w stylu osi czasu

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

Pola odpowiedzi, od których można zależeć

🌊 Dlaczego nigdy nie ujawniamy nadawcy ani odbiorcy

To jest podstawowa zasada. Przejrzystość oprogramowania open source i prywatność użytkowników są naturalnymi wrogami — chyba że prawidłowo zaprojektujesz granice. SynergyX rozwiązuje ten problem, tworząc protokół przejrzysty (każdy może sprawdzić kod) przy zachowaniu tożsamość trwale nieprzezroczyste (nie istnieje żaden mechanizm pozwalający ujawnić nadawcę lub odbiorcę). Klucz dowodowy to klucz do puzzli — odblokowuje kwotę i tylko kwota. Tożsamości stojące za transakcją rozpłynęły się w Synergy Sea w momencie zapieczętowania bloku.

Węzeł SynX generuje klucz potwierdzający przy użyciu kwantowego szyfrowania sieciowego Kyber-768. Klucz jest matematycznie powiązany z kwotą transakcji. Nie można go sfałszować, nie można go poddać inżynierii wstecznej i wygasa za 30 minut. Nadawca udostępnia klucz potwierdzający odbiorcy poza łańcuchem — Signal, PGP, Tor, serwetka. Odbiorca dokonuje weryfikacji poprzez ten API. Oto cały model zaufania. Żadnej opieki. Bez pośrednika. Brak śladu metadanych.

⛨ Co wie serwer (Jack)

Bądźmy szczerzy w kwestii granic zaufania. Uderzasz w API. Serwer jest maszyną i maszyny można przejąć. Oto dokładnie, co atakujący otrzyma, jeśli zrootuje skrzynkę:

Czas jest ograniczony. Każda pojedyncza odpowiedź API — GET, POST, sukces, porażka, 404, wszystko — jest dopełniana do Stały sufit 500 ms. Serwer mierzy rzeczywisty czas przetwarzania, po czym dokładnie śpi 500ms - elapsed. Każda odpowiedź trwa dokładnie 500 ms. Nie losowe. Stały. d Cohena pomiędzy prawidłowymi i nieprawidłowymi ścieżkami: 0.015 (testowane przez GhostReaper — statystycznie niewidoczne). Poradnik wyroczni dotyczący czasu Chainalytic? Martwy w dniu przyjazdu.

🌊 Synergy Sea — dwie warstwy głębokości

Pomyśl o łańcuchu jak o oceanie. Transakcje publiczne wypływają na powierzchnię. Prywatne toną. Im głębiej schodzisz, tym bardziej potrzebujesz kluczy dowodowych, aby cokolwiek zobaczyć. I nawet na maksymalnej głębokości tylko kwota powierzchnie — nigdy nie adresuje.

Nie istnieje głębsza warstwa. Nie ma ujawniania klucza widoku, audytu adresu, żadnego mechanizmu ujawniającego, kto wysłał, a kto otrzymał. Klucz potwierdzający — wygenerowany przez węzeł SynX przy użyciu szyfrowania kwantowego Kyber-768 — dekoduje dokładną kwotę. To najgłębszy poziom, jaki można zejść. Adresy nadawcy i odbiorcy są trwale zatopione w morzu.

Pancerz antykorelacyjny: Sygnatury czasowe zamazane ±120 s. Opłaty podzielone na 5 poziomów (mikro/niski/standardowy/wysoki/premium — nigdy nie jest to surowa kwota sat). Wysokości bloków wyzerowane. Czasy reakcji doprowadzono do stałego pułapu 500 ms. „Nie znaleziono TX” i „TX jest prywatny” zwracają identyczny kształt. Klucze próbne wygasają w 30 minut — ograniczenie okien powtórek do prawie zera. Nie możesz nawet wyliczyć, które skróty są prawdziwe. Każde zapytanie powierzchniowe zwraca tę samą ilość informacji niezależnie od tego, czy TX istnieje, nie istnieje, czy jest ekranowany. Powodzenia, Chainalytic.

—͟͟͞͞★ Weryfikacja dowodu dostawcy — 3 minuty, zero zaufania

Jesteś sprzedawcą. Kupujący właśnie zapłacił Ci prywatnym SynX. Musisz zweryfikować płatność, nie sprawdzając adresu, salda ani nie ufając osobom trzecim. Oto jak to zrobić. Nie KYC. Żadnej opieki. Udowodnij, że płatności są ślepe.

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

𖣐 Pełny rytuał weryfikacji

Krok ④ to łącze krytyczne. Klucz potwierdzający musi podróżować od nadawcy do odbiorcy kanałem, którego API nigdy nie widzi. Sygnalizacja znikających wiadomości. E-mail szyfrowany PGP. Ukryta usługa Tor. Kod QR wyświetlony w poprzek tabeli. Notatka przyklejona taśmą pod ławką w parku. API nie interesuje, w jaki sposób tajemnica tam dotrze — weryfikuje obliczenia tylko wtedy, gdy odbiorca o to poprosi.

POST /verify_proof — zweryfikuj klucz próbny (zalecane)

POST DOSTAWAĆ PUBLICZNY — Najprostszy sposób weryfikacji płatności. Wysłać tx_hash + proof_key w ciele (lub jako parametry GET). Zwraca dokładną kwotę. Brak autoryzacji. Brak klucza API. Brak konta. Zacznij tutaj.

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

Kompletna dokumentacja błędów — Verify_proof.php

POST /privacy/tx/{hash}/rune-verify — Koperta Runiczna (bogate metadane)

POST PUBLICZNY — Ta sama weryfikacja klucza potwierdzającego z bogatszymi metadanymi: okno sygnatury czasowej (rozmyte ± 120 s), odliczanie wygaśnięcia, metoda deszyfrowania. Użyj tego, jeśli potrzebujesz czegoś więcej niż tylko kwoty.

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

Czego dowiaduje się weryfikator, a co pozostaje utopione

GET /privacy/tx/{hash}/verify — Wyrocznia istnienia

DOSTAWAĆ PUBLICZNY — Czy ten Teksas istnieje? Zwraca zobowiązanie istnienia kryptograficznego. Nie ujawnia niczego więcej.

{
  "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} — Wyszukiwanie transakcji w tle

DOSTAWAĆ PUBLICZNY — Wyszukaj dowolny TX. Prywatne zwracają cień — widoczny skrót, wszystko inne 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 — Fale powierzchniowe

Ostatnie TX. Prywatne pojawiają się jako cienie (pola zerowe). Publiczne pokazują przejrzyste dane. Dobry do dashboardów. Parametr zapytania limit (1-50, domyślnie 20).

GET /privacy/stats — Odczyty głębokości morza

Wskaźniki przyjęcia prywatności: łączna liczba TX, prywatne TX, procent przyjęcia, flagi funkcji. Nie jest wymagane żadne uwierzytelnienie. Monitoruj głębokość morza za pomocą własnej infrastruktury.

POST /privacy/batch-proof — wsadowa weryfikacja wielu dowodów

POST PUBLICZNY — Sprawdź do 50 kluczy próbnych w jednym żądaniu. Ta sama weryfikacja demona, co w przypadku punktów końcowych typu single-proof, ale wsadowa pod kątem wydajności. Idealny dla platform handlowych przetwarzających wiele zamówień lub portfeli weryfikujących kilka płatności przychodzących jednocześnie.

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

Limity partii i odniesienie do błędów

🧅 Tor / .onion — Przeprowadź wszystko przez mgłę

API jest bezstanowy REST przez HTTPS. Żadnych plików cookie. Brak sesji. Brak odcisków palców JS. Brak aktualizacji protokołu WebSocket. Czyste żądanie → odpowiedź przez TLS. Działa natywnie przez Tor, ponieważ tak go zbudowaliśmy. Nie jako refleksja. Jeśli budujesz coś prywatnego i jesteś nie routingu przez .onion, wyciekasz swój adres IP do każdego modułu rozpoznawania nazw DNS między tobą a serwerem. Nie.

cURL przez Tora

# 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 przez 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 przez Tora

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

📡 Udostępnij klucze próbne za pośrednictwem Signal — zero metadanych

Klucz potwierdzający musi przemieszczać się nadawca → odbiorca bez dotykania API. Oto hierarchia OPSEC dla tego przekazania:

Hook do integracji sygnału (bot Pythona)

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

⚓ Rytuał płatności na rynku

Budujecie suwerenny rynek. Brak paska. Brak PayPala. Brak oprogramowania pośredniego KYC. Tylko Synergy Sea i klucze próbne z uszczelnieniem kwantowym. Oto jak zweryfikować płatności za pomocą dokładne kwoty używając jedynie klucza potwierdzającego – nigdy nie ujawniono żadnych adresów.

# 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 — każdy język, każdy wzór

Python — zweryfikuj klucz próbny

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 — weryfikator płatności (oprogramowanie pośredniczące Express)

const fetch = require('node-fetch');
const API = 'https://explorer.synxcrypto.com/explorer/api';

async function verifyPayment(txHash, proofKey) {
  // Proof key generated by SYNX Node — quantum Kyber-768 sealed
  // Expires in 30 minutes — verify immediately
  const r = await fetch(`${API}/verify_proof.php`, {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({ tx_hash: txHash, proof_key: proofKey }),
  });
  return r.json();
}

// Express middleware — drop into any route
async function requirePayment(req, res, next) {
  const { tx_hash, proof_key } = req.body;
  const result = await verifyPayment(tx_hash, proof_key);
  if (!result.valid) {
    // Error responses include "error" + "hint" fields
    return res.status(result.error?.includes('expired') ? 410 : 402).json({
      error: result.error,
      hint: result.hint,
    });
  }
  req.paymentAmount = result.amount;  // ← "amount" (not "amount_decoded")
  req.paymentCurrency = result.currency;
  next();
}

cURL — Kompletna ściągawka

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 — uczciwe porównanie

Monero był pionierem. Podpisy pierścieniowe, RingCT, ukryte adresy – wszystko genialne. Zostały jednak zbudowane dla świata przedkwantowego, w którym Ed25519 był niezniszczalny, a dokładne znaczniki czasu badacza były „w porządku”. Ta era się kończy. Oto miejsce, w którym znajdują się dwa łańcuchy, gdy umieścisz je obok siebie:

Jeśli w 2026 roku nadal będziesz używać Monero, już nie żyjesz: po prostu tego nie zauważyłeś.

Twoje podpisy na pierścionku? Analiza łańcuchowa grupuje ich jak bydło. Dokładne znaczniki czasu? NSA oznacza czas Twojej kawy. Ed25519? Nadchodzi Shor: Twoje klucze są w kurzu. Generowanie dowodu po stronie klienta? Dekompiluj portfel i fałszuj dowody przez cały dzień. To archeologia, a nie bezpieczeństwo.

Klucze sprawdzające SynergyX są generowane przez Węzeł SynX przy użyciu kwantowego szyfrowania sieciowego Kyber-768. Metoda generowania jest zapieczętowana w rdzeniu węzła — żaden klient, żaden dekompilator, żaden atakujący nie może uzyskać dostępu do wewnętrznych parametrów sieci kwantowej. Nawet wyrafinowany przeciwnik, który całkowicie dekompiluje portfel, nie otrzymuje nic: portfela otrzymuje klucz potwierdzający z węzła. Nie generuje tego. Sekret nigdy nie opuszcza węzła.

Transakcje w tle: nadawca, odbiorca, kwota, blok: null. Nie zaciemnione. Wymazany.

Klucze kwantowe: Klucze logiczne Kyber-768 z uszczelnioną kratką: udowodnij dokładną kwotę bez ujawniania, kto wysłał, kto otrzymał, kiedy (± 120 s) i gdzie. Klucz dekoduje dokładne kwoty — 183,00, a nie „średnie”. Brak adresów w dowodzie. Brak adresów w API. Nigdzie nie ma adresów. Wygasa za 30 minut.

Brak ujawnienia adresu: Nie ma punktu końcowego klucza widoku. Brak punktu końcowego audytu. Brak mechanizmu ujawniającego nadawcę lub odbiorcę za pośrednictwem tego API. Ta ilość to wszystko, co się pojawia. Tożsamość pozostaje utopiona – na stałe.

Postkwantowe: Kyber-768, SPHINCS+, SHAKE256 — Shor może pocałować twój blok genezy. Brak planu działania. Nie, „później dodam sygnały kwantowe”. Urodziliśmy się odporni.

Chcesz prywatności? Przestań błagać o resztki. Dzięki Synergy zyskujesz kwantową dyskrecję i prędkość w morzu cieni. Weź ostrze.

Kody błędów

zweryfikować_proof.php — Kody stanu HTTP

Koperta Runiczna (/rune-verify) — kody stanu HTTP

429 Przepustnica morska — korpus reagujący

Wszystkie 429 odpowiedzi (oba punkty końcowe) obejmują: Retry-After Nagłówek HTTP (RFC 7231) i ustrukturyzowana treść JSON z informacjami o poziomie:

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

Formaty wejściowe (oba punkty końcowe): Hash TX = dokładnie 64 znaki szesnastkowe [a-fA-F0-9]{64}. Klucz sprawdzający = maksymalnie 67 znaków (z PT- prefiks) lub dokładnie 64 hex (surowe). API akceptuje oba formaty — paski serwerowe PT- automatycznie. verify_proof.php akceptuje nazwę pola proof_key or proof_token (alias). Wszystko poza tymi granicami dostaje twarde 400. Żadnego przycinania. Żadnej litości.

🕳 Gwarancja zerowych metadanych — co muszą wiedzieć programiści

Jeśli integrujesz API, oto niezbity dowód na to żadnych wycieków metadanych. Każde roszczenie poniżej zostało sprawdzone przez GhostReaper (ponad 100 wektorów ataku, 0 niezałatanych wyników).

Właściwości zabezpieczeń — lista kontrolna dla programistów

Co MUSISZ zrobić jako Integrator

𖣐 Zakoduj to. Przetestuj. Posiadaj ciemność.

Teraz masz wszystko. Sześć punktów końcowych. Prawdziwy kod. Routing Tora. Haczyki sygnalizacyjne. Model zagrożeń, który uczciwie określa, co wycieka, a co nie. Klucze sprawdzające Quantum Kyber-768 generowane przez węzeł SynX — niemożliwe do podrobienia klucze logiczne, które dekodują dokładne kwoty i nic więcej. Żadnego ujawniania adresu — ani za pomocą klucza widoku, ani za pomocą klucza potwierdzającego, nigdy. Rozmycie znacznika czasu, które sprawia, że ​​analiza czasu jest statystycznie bez znaczenia. A pod tym wszystkim kryptografia sieciowa, która przetrwa każdy znany atak kwantowy – nie dlatego, że migrowaliśmy, ale dlatego, że tam zaczęliśmy.

Synergy Sea to ocean postkwantowy, w którym cienie nigdy się nie pojawiają. Żadne centrum danych nie może być królem, gdy SynergyX je detronizuje i troni użytkownika. Każda prywatna transakcja jest zatapiana w enkapsulacji Kyber-768, zapieczętowana przez hiperdrzewa SPHINCS+, indeksowane przez zobowiązania w sieci kwantowej. Kwoty szepczą przez klucze dowodowe — bełkot dla obserwatorów, dokładne liczby dziesiętne dla posiadaczy kluczy. Odkrywca widzi zmarszczki. API zwraca wartość null tam, gdzie ma to znaczenie. Klucz potwierdzający jest jedynym wątkiem prowadzącym do kwoty – a kwota jest Wszystko które powierzchnie. Nadawca i odbiorca? Utonął. Na stałe. Żaden punkt końcowy, żaden klucz, żadne wezwanie nie przywrócą ich z powrotem.

Nie KYC. Żadnej opieki. Brak analizy łańcucha. Brak ujawnienia adresu. Brak centralnego punktu awarii. Brak planu migracji, ponieważ nie ma z czego przeprowadzić migracji. Pierwszy gracz w kwantowej grze końcowej.

To nie jest dokumentacja. To jest broń. Użyj tego.

𝓢𝔁
Zakoduj to. Przetestuj to. Posiadaj ciemne przypływy.

SynergyX Privacy API v2.0 — Kwantowe klucze — Synergy Sea
Ocean postkwantowy, w którym cienie nigdy się nie pojawiają.