Este guia documenta o mesmo fluxo de chave de prova de transação privada utilizado por timeline.php para pagamentos de acesso ao Timeline. Foi concebido para programadores que precisam de aceitar pagamentos privados SynX, verificar o valor exato e manter os dados de endereço fora das suas aplicações.

• O que recebe do pagador: um de 64 caracteres tx_hash e uma chave de prova. A chave de prova pode ser hexadecimal 64 bruta ou prefixada como PT- mais 64 hexadecimais.
• O que o API prova: se essa chave de prova é válida para essa transação e o valor exato de SynX.
• O que o API não revela: endereço do remetente, endereço do destinatário, saldo da carteira ou um caminho de pagamento público para transações privadas.
• Ponto final primário: POST /explorer/api/verify_proof.php com corpo JSON {"tx_hash":"...","proof_key":"..."}.

Implementação de chaves de prova como linha do tempo

A Timeline aceita pagamentos visíveis do mercado automaticamente. Quando uma transação é privada ou oculta, muda para a verificação da chave de prova. A chave de prova confirma o valor do pagamento enquanto os campos de morada permanecem selados.

Verificador PHP estilo linha do tempo

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

Campos de resposta dos quais depender

🌊 Porque é que nunca divulgamos o remetente ou o destinatário

Este é o princípio fundamental. A transparência do código aberto e a privacidade do utilizador são inimigos naturais – a menos que arquiteto os limites corretamente. O SynergyX resolve isso fazendo o protocolo transparente (qualquer pessoa pode auditar o código), mantendo identidade permanentemente opaco (não existe nenhum mecanismo para revelar o remetente ou o destinatário). A chave de prova é uma chave de puzzle – desbloqueia a quantia e apenas Quantidade. As identidades por detrás da transação foram dissolvidas no Synergy Sea no momento em que o bloco foi selado.

O nó SynX gera a chave de prova utilizando a criptografia quântica de rede Kyber-768. A chave está matematicamente ligada ao valor da transação. Não pode ser forjado, não pode ser submetido a engenharia inversa e expira em 30 minutos. O remetente partilha a chave de prova com o destinatário fora da cadeia – Signal, PGP, Tor, um guardanapo. O destinatário verifica através deste API. Esse é todo o modelo de confiança. Sem custódia. Sem intermediário. Sem rasto de metadados.

⛨ O que o servidor sabe (Jack)

Sejamos honestos sobre os limites da confiança. Está a acertar um API. O servidor é uma máquina e as máquinas podem ser apreendidas. Eis exatamente o que um atacante obtém se fizer root na caixa:

O tempo é mitigado. Cada resposta API – GET, POST, sucesso, falha, 404, tudo – é preenchida num Teto constante de 500ms. O servidor mede o tempo real de processamento e depois dorme exatamente 500ms - elapsed. Cada resposta demora exatamente 500 ms. Não é aleatório. Constante. D de Cohen entre caminhos válidos e inválidos: 0.015 (testado pelo GhostReaper — estatisticamente invisível). Manual do oráculo de tempo da Chainalysis? Morto à chegada.

🌊 O Synergy Sea – Duas camadas de profundidade

Pense na cadeia como um oceano. As transações públicas flutuam à superfície. Os privados afundam-se. Quanto mais fundo for, mais precisa de chaves de prova para ver qualquer coisa. E mesmo à profundidade máxima, apenas o montante superfícies – nunca endereços.

Não existe nenhuma camada mais profunda. Não há divulgação da chave de visualização, nem auditoria de endereços, nem mecanismo para revelar quem enviou ou recebeu. A chave de prova – gerada pelo nó SynX usando a criptografia quântica Kyber-768 – descodifica a quantidade exata. Esse é o mais profundo que alguém pode ir. Os endereços do remetente e do destinatário estão permanentemente afogados no mar.

Armadura anticorrelação: Carimbos de data e hora difusos ±120s. Taxas divididas em 5 níveis (micro/baixa/padrão/alta/premium – nunca o valor bruto do sat). Alturas de bloco anuladas. Tempos de resposta preenchidos até um teto constante de 500 ms. "TX não encontrado" e "TX é privado" devolvem o forma idêntica. As chaves de prova expiram em 30 minutos — limitando as janelas de repetição a quase zero. Nem sequer consegue enumerar quais os hashes que são reais. Cada consulta de superfície devolve a mesma quantidade de informação, quer o TX exista, não exista ou seja blindado. Boa sorte, Chainalysis.

—͟͟͞͞★ Verificação da prova do fornecedor – 3 minutos, confiança zero

Você é um fornecedor. Um comprador acabou de lhe pagar em privado SynX. Precisa de verificar o pagamento sem ver o seu endereço, saldo ou confiar em terceiros. Veja como. Não KYC. Sem custódia. Prove pagamentos cegos.

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

𖣐 Rito de Verificação Completa

A etapa ④ é o link crítico. A chave de prova deve viajar emissor → receptor através de um canal que o API nunca vê. Mensagens de desaparecimento de sinal. E-mail encriptado por PGP. Serviço oculto Tor. Um código QR mostrado numa tabela. Um bilhete colado debaixo de um banco de jardim. O API não se importa como o segredo chega lá – só verifica a matemática quando o recetor pergunta.

POST /verify_proof – Verificar uma chave de prova (recomendado)

PUBLICAÇÃO OBTER PÚBLICO — A forma mais simples de verificar um pagamento. Enviar tx_hash + proof_key no organismo (ou como parâmetros GET). Retorna o valor exato. Sem autorização. Sem chave API. Nenhuma conta. Comece aqui.

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

Referência de erro completa – verify_proof.php

POST /privacy/tx/{hash}/rune-verify — Envelope Rúnico (Metadados Ricos)

PUBLICAÇÃO PÚBLICO — Verificação da mesma chave de prova com metadados mais ricos: janela de carimbo de data/hora (±120s difusa), contagem decrescente de expiração, método de desencriptação. Use isto quando precisar de mais do que apenas a quantidade.

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

O que o verificador aprende versus o que permanece afogado

GET /privacy/tx/{hash}/verify — Existência Oracle

OBTER PÚBLICO — Esse TX existe? Retorna um compromisso de existência criptográfica. Não revela mais nada.

{
  "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} — Pesquisa de transações ocultas

OBTER PÚBLICO - Procure qualquer TX. Os privados devolvem a sombra – hash visível, tudo o resto 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 – ​​​​Ondulações de superfície

TX recentes. Os privados aparecem como sombras (campos nulos). Os públicos mostram dados transparentes. Bom para painéis. Parâmetro de consulta limit (1-50, padrão 20).

GET /privacy/stats – Leituras da profundidade do mar

Métricas de adoção de privacidade: total de TXs, TXs privados,% de adoção, sinalizadores de recursos. Não é necessária autenticação. Monitorize a profundidade do Mar a partir da sua própria infraestrutura.

POST /privacy/batch-proof — Verificação em lote de provas múltiplas

PUBLICAÇÃO PÚBLICO — Verifique até 50 chaves de prova numa única solicitação. A mesma verificação de daemons que os endpoints de prova única, mas em lote para maior eficiência. Ideal para mercados que processam vários pedidos ou carteiras que verificam vários pagamentos recebidos de uma só vez.

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

Limites de lote e referência de erros

🧅 Tor/. onion – Direcione tudo através do nevoeiro

O API é REST sem estado sobre HTTPS. Sem bolachas. Sem sessões. Sem impressão digital JS. Sem atualização do WebSocket. Pedido → resposta pura por TLS. Funciona nativamente no Tor porque o construímos dessa forma. Não como uma reflexão tardia. Se estiver a construir algo privado e estiver não routing através de . onion, está a vazar o seu IP para todos os resolvedores de DNS entre si e o servidor. Não.

cURL através do 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 através do 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 através do 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);

📡 Partilhar chaves de prova via Signal – Zero metadados

A chave de prova deve viajar remetente → destinatário sem tocar no API. Eis a hierarquia OPSEC para esta transferência:

Gancho de integração de sinal (bot Python)

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

⚓ Rito de pagamento do mercado

Está a construir um mercado soberano. Sem risca. Sem PayPal. Sem middleware KYC. Apenas as chaves de prova Synergy Sea e seladas quânticas. Veja como verifica os pagamentos com quantidades exatas utilizando apenas uma chave de prova – não foi revelado qualquer endereço.

# 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 – Cada linguagem, cada padrão

Python – verificar uma chave de prova

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 – Verificador de pagamentos (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 – Folha de dicas completa

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 – A comparação honesta

Monero foi pioneiro. Assinaturas de anel, RingCT, endereços furtivos – tudo brilhante. Mas foram construídos para um mundo pré-quântico onde o Ed25519 era inquebrável e os carimbos de data e hora exatos num explorador eram “ótimos”. Essa era está a acabar. É aqui que ficam as duas correntes quando as coloca lado a lado:

Se ainda usa o Monero em 2026, já está morto: só não se apercebeu.

As suas assinaturas de anel? A Chainalysis agrupa-os como gado. Carimbos de data e hora exatos? A NSA regista a data e hora do seu café. Ed25519? O Shor está a chegar: as suas chaves viraram pó. Geração de prova do lado do cliente? Descompile a carteira e forje provas durante todo o dia. Isto é arqueologia, não é segurança.

As chaves de prova SynergyX são geradas pelo Nó SynX usando a criptografia de rede quântica Kyber-768. O método de geração é selado dentro do núcleo do Node – nenhum cliente, nenhum descompilador, nenhum atacante pode aceder aos parâmetros internos da rede quântica. Mesmo um adversário sofisticado que descompila totalmente a carteira não ganha nada: a carteira recebe a chave de prova do Nó. Não gera isso. O segredo nunca sai do Node.

Transações sombra: remetente, destinatário, valor, bloco: null. Não ofuscado. Apagado.

Chaves de prova quântica: Chaves de puzzle seladas em treliça Kyber-768: prove a quantidade exata sem vazar quem enviou, quem recebeu, quando (±120s fuzz) ou onde. A chave descodifica valores exatos – 183,00, e não “médio”. Não há endereços na prova. Sem endereço no API. Sem endereço em lugar nenhum. Expira em 30 minutos.

Sem divulgação de morada: Não existe ponto de extremidade da chave de visualização. Sem ponto de extremidade de auditoria. Nenhum mecanismo para revelar o remetente ou destinatário através deste API. A quantidade é tudo o que surge. A identidade permanece afogada – permanentemente.

Pós-quântico: Kyber-768, SPHINCS+, SHAKE256 – Shor pode beijar o seu bloco de génese. Sem guião. Não "mais tarde adicionaremos assinaturas quânticas". Nascemos imunes.

Quer privacidade? Pare de implorar por restos. Com o Synergy obtém furtividade quântica e velocidade no mar de sombras. Pegue na lâmina.

Códigos de erro

verify_proof.php — Códigos de estado HTTP

Envelope Rúnico (/rune-verify) — Códigos de estado HTTP

429 Sea Throttle - Corpo de Resposta

Todas as 429 respostas (ambos os pontos finais) incluem um Retry-After Cabeçalho HTTP (RFC 7231) e um corpo JSON estruturado com informação de camada:

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

Formatos de entrada (ambos os pontos finais): Hash TX = exatamente 64 caracteres hexadecimais [a-fA-F0-9]{64}. Chave de prova = máximo de 67 caracteres (com PT- prefixo) ou exactamente 64 hexadecimais (bruto). O API aceita ambos os formatos – server strips PT- automaticamente. verify_proof.php aceita o nome do campo proof_key or proof_token (alias). Qualquer coisa fora destes limites obtém 400. Sem corte. Sem piedade.

🕳 Garantia zero de metadados – O que os programadores devem saber

Se estiver a integrar este API, aqui está a prova concreta de que sem fugas de metadados. Cada reivindicação abaixo foi auditada pelo GhostReaper (mais de 100 vetores de ataque, 0 descobertas não corrigidas).

Propriedades de segurança — Lista de verificação do programador

O que DEVE fazer como integrador

𖣐 Codifique. Teste. Domine o escuro.

Agora tem tudo. Seis pontos finais. Código real. Encaminhamento Tor. Ganchos de sinalização. Um modelo de ameaça que é honesto sobre o que vaza e o que não vaza. Chaves de prova Quantum Kyber-768 geradas pelo nó SynX – chaves de puzzle infalsáveis ​​que descodificam quantidades exatas e nada mais. Sem divulgação de endereço – nem com uma chave de visualização, nem com uma chave de prova, nem nunca. Fuzzing de carimbo de data/hora que torna a análise de tempo estatisticamente sem sentido. E por baixo de tudo isto, a criptografia em rede que sobrevive a todos os ataques quânticos conhecidos – não porque migramos, mas porque começamos aí.

O Synergy Sea é o oceano pós-quântico onde as sombras nunca surgem. Nenhum data center pode ser rei quando o SynergyX os destrona e entroniza o utilizador. Cada transação privada afunda no encapsulamento Kyber-768, selado por hiperárvores SPHINCS+, indexado por compromissos de rede quântica. Os valores sussurram através de chaves de prova – algo sem sentido para os observadores, decimais exatos para os detentores de chaves. O explorador vê ondulações. O API retorna nulo onde é importante. A chave de prova é o único caminho para o valor - e o valor é tudo que surge. Remetente e destinatário? Afogado. Permanentemente. Nenhum ponto final, nenhuma chave, nenhuma intimação os traz de volta.

Não KYC. Sem custódia. Sem análise de cadeia. Sem divulgação de morada. Sem ponto central de falha. Sem roteiro de migração porque não há nada para migrar. Pioneiro no jogo final quântico.

Isto não é documentação. Isto é uma arma. Use-o.

𝓢𝔁
Codifique-o. Teste. Domine as marés negras.

Privacidade SynergyX API v2.0 — Chaves de prova quântica — O Synergy Sea
O oceano pós-quântico onde as sombras nunca vêm ao de cima.