本指南记录了相同的私人交易证明密钥流程 timeline.php 用于时间线访问付款。它专为需要接受私人 SynX 付款、验证确切金额并将地址数据保留在应用程序之外的开发人员而设计。

• 您从付款人处收到的内容： 64 个字符 tx_hash 和证明密钥。证明密钥可以是原始 64 十六进制或前缀为 PT- 加 64 十六进制。
• API 证明了什么： 该证明密钥对于该交易是否有效以及确切的 SynX 金额。
• API 没有透露的内容： 发送者地址、接收者地址、钱包余额或私人交易的公共支付路径。
• 主要终点： POST /explorer/api/verify_proof.php 带有 JSON 主体 {"tx_hash":"...","proof_key":"..."}.

实现像时间线这样的证明密钥

Timeline 自动接受可见的市场付款。当交易是私密或隐藏的时，它会切换到证明密钥验证。证明密钥确认付款金额，同时地址字段保持密封。

时间线风格的 PHP 验证器

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

依赖的响应字段

🌊 为什么我们从不透露发件人或收件人

这是核心原则。开源透明度和用户隐私是天敌——除非你正确地构建了边界。 SynergyX 通过使 协议 透明（任何人都可以审核代码），同时保持 身份 永久不透明（不存在揭示发送者或接收者的机制）。证明钥匙是一把拼图钥匙——它可以解锁金额，并且 仅有的 量。当区块被密封时，交易背后的身份就溶解在 Synergy Sea 中。

SynX 节点使用量子 Kyber-768 晶格加密生成证明密钥。密钥在数学上与交易金额绑定。它不能被伪造，不能被逆向工程，并且 30 分钟后过期。发送者与链外接收者共享证明密钥——Signal、PGP、Tor、餐巾纸。收件人通过此 API 进行验证。这就是整个信任模型。没有监护权。没有中介。没有元数据线索。

⛨ 服务器知道什么（Jack）

让我们诚实地对待信任边界。您正在击中 API。服务器是机器，机器是可以抢占的。这正是攻击者 root 后会得到的结果：

时间安排有所缓解。 每个 API 响应——GET、POST、成功、失败、404，一切——都被填充到 500ms 恒定上限。服务器测量实际处理时间，然后准确休眠 500ms - elapsed。每个响应正好需要 500 毫秒。不是随机的。 持续的。 有效路径和无效路径之间的 Cohen d： 0.015 （由 GhostReaper 测试 - 统计上不可见）。 Chainaanalysis 的时序预言手册？抵达时已死亡。

🌊 Synergy Sea — 两个深度层

将链条想象成一片海洋。公开交易浮在表面。私人的沉了。你走得越深，就越需要证明钥匙才能看到任何东西。即使在最大深度，也只有 数量 表面——从不解决。

不存在更深层次。 没有查看密钥披露，没有地址审计，没有机制来揭示谁发送或接收的。证明密钥由 SynX 节点使用量子 Kyber-768 加密生成，可解码确切的金额。这是任何人都能到达的最深处。发送者和接收者地址永久淹没在大海中。

反相关装甲： 时间戳模糊±120s。费用分为 5 级（微/低/标准/高/溢价 - 绝不是原始饱和金额）。区块高度归零。响应时间填充至 500 毫秒恒定上限。 “未找到 TX”和“TX 是私有的”返回 相同的形状。证明密钥过期时间 30分钟 - 将重播窗口限制为接近零。您甚至无法枚举哪些哈希值是真实的。无论 TX 存在、不存在还是被屏蔽，每个表面查询都会返回相同数量的信息。祝你好运，链分析。

—͟͟͞͞★ 供应商证明验证 — 3 分钟，零信任

你是一个供应商。买家刚刚私下向您付款 SynX。您需要在不查看他们的地址、余额或信任任何第三方的情况下验证付款。方法如下。没有 KYC。没有监护权。证明盲目付款。

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

𖣐 完整的验证仪式

步骤④是关键环节。 证明密钥必须通过 API 从未见过的通道传输发送者→接收者。信号消失的消息。 PGP 加密的电子邮件。 Tor 隐藏服务。表格上显示的二维码。一张贴在公园长椅下的便条。 API 并不关心秘密是如何到达那里的——它只在接收者询问时验证数学。

POST /verify_proof — 验证证明密钥（推荐）

邮政 得到 民众 — 验证付款的最简单方法。发送 tx_hash + proof_key 在正文中（或作为 GET 参数）。返回准确的金额。没有授权。没有 API 密钥。没有帐户。 从这里开始。

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

完整的错误参考 — verify_proof.php

POST /privacy/tx/{hash}/rune-verify — 符文信封（丰富元数据）

邮政 民众 — 具有更丰富元数据的相同证明密钥验证：时间戳窗口（±120s模糊）、到期倒计时、解密方法。当您需要的不仅仅是金额时，请使用此选项。

别名： /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" }

验证者学到的东西与被淹没的东西

GET /privacy/tx/{hash}/verify — 存在 Oracle

得到 民众 — 这个 TX 存在吗？返回加密存在承诺。没有透露任何其他信息。

{
  "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} — 影子交易查找

得到 民众 — 查找任何 TX。私有的返回影子——散列可见，其他一切 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 — 表面波纹

最近的 TX。私有的表面显示为阴影（空字段）。公开的显示透明的数据。适合仪表板。查询参数 limit （1-50，默认 20）。

GET /privacy/stats — 海深读数

隐私采用指标：总 TX、私有 TX、采用百分比、功能标记。无需授权。从您自己的基础设施监控海洋的深度。

POST /privacy/batch-proof — 批量验证多重证明

邮政 民众 — 验证最多 50把证明钥匙 在单个请求中。与单一证明端点相同的守护进程验证，但为了提高效率而进行了批处理。非常适合处理多个订单的市场或同时验证多个收款的钱包。

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

批次限制和错误参考

🧅 Tor / .onion — 穿过迷雾路由一切

API 是 通过 HTTPS 的无状态 REST。没有饼干。没有会议。没有 JS 指纹识别。没有 WebSocket 升级。通过 TLS 的纯请求→响应。它本身就可以在 Tor 上运行，因为我们就是这样构建的。不是事后的想法。如果您正在构建任何私有的东西并且您 不是 通过 .onion 进行路由，您会将 IP 泄露给您和服务器之间的每个 DNS 解析器。不。

通过 Tor 进行 cURL

# 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 通过 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 通过 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);

📡 通过信号共享证明密钥——零元数据

验证密钥必须在不接触 API 的情况下穿过发送器 → 接收器。以下是该切换的 OPSEC 层次结构：

信号集成挂钩（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...")

⚓ 市场支付仪式

您正在建立一个主权市场。没有条纹。没有贝宝。无 KYC 中间件。只有 Synergy Sea 和量子密封的证明密钥。以下是您验证付款的方法 确切的金额 仅使用证明密钥——没有泄露任何地址。

# 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

✗∑🗡 魔法典代码——每种语言，每种模式

Python——验证证明密钥

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 — 支付验证器（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 — 完整备忘单

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 与 Monero — 诚实的比较

Monero 首创。环签名、RingCT、隐形地址——全都很棒。但它们是为前量子世界而构建的，在这个世界中，Ed25519 是牢不可破的，并且探险家的精确时间戳“很好”。那个时代结束了。当您将两条链条并排放置时，它们的位置如下：

如果您在 2026 年仍在使用 Monero，那么您已经死了：您只是没有注意到。

你的环签名？链分析将它们像牛一样聚集在一起。准确的时间戳？美国国家安全局给你的咖啡打上时间戳。 Ed25519？ Shor 来了：您的钥匙已化为灰尘。客户端证明生成？整天反编译钱包、伪造证明。这是考古学，不是安全学。

SynergyX 证明密钥由 SynX节点 使用量子Kyber-768晶格加密。生成方法被密封在节点的核心内部——没有客户端，没有反编译器，没有攻击者可以访问内部量子晶格参数。即使是完全反编译钱包的老练对手也一无所获：钱包 收到 来自节点的证明密钥。它不会生成它。秘密永远不会离开节点。

影子交易： 发送者、接收者、金额、区块： null。没有混淆。 已删除。

量子证明密钥： Kyber-768 格子密封拼图密钥：证明确切的金额，而不会泄漏谁发送、谁接收、何时（±120 秒模糊）或地点。密钥解码准确的金额 - 183.00，而不是“中”。证明中没有地址。 API 中没有地址。到处都没有地址。 30 分钟后到期。

没有地址泄露： 没有视图关键端点。无审核端点。没有机制可以通过此 API 显示发送者或接收者。金额就是表面的全部。身份永远被淹没。

后量子： Kyber-768、SPHINCS+、SHAKE256 — Shor 可以亲吻你的创世块。没有路线图。没有“稍后会添加量子信号”。我们生来就有免疫力。

你想要隐私吗？别再乞讨碎片了。借助 Synergy，您可以在阴影之海中获得量子隐形和速度。 拿起刀片。

错误代码

verify_proof.php — HTTP 状态代码

Runic Envelope (/rune-verify) — HTTP 状态代码

429 Sea Throttle — 响应体

所有 429 响应（两个端点）都包含 Retry-After HTTP 标头 (RFC 7231) 和包含层信息的结构化 JSON 正文：

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

输入格式（两个端点）： TX 哈希 = 正好 64 个十六进制字符 [a-fA-F0-9]{64}。证明密钥 = 最多 67 个字符（其中 PT- 前缀）或正好 64 十六进制（原始）。 API 接受两种格式 — 服务器条带 PT- 自动地。 verify_proof.php 接受字段名称 proof_key or proof_token （别名）。任何超出这些范围的内容都会得到硬性 400 分。不得进行修剪。没有怜悯。

🕳 零元数据保证——开发人员必须了解的内容

如果您要集成这个 API，这里有确凿的证据 无元数据泄漏。下面的每项声明均经过 GhostReaper 审核（100 多个攻击向量，0 个未修补的发现）。

安全属性 — 开发人员清单

作为集成商您必须做什么

𖣐 编码它。测试一下。拥有黑暗。

你现在拥有了一切。六个端点。真实的代码。 Tor 路由。信号挂钩。一个诚实地判断哪些内容泄露、哪些内容不泄露的威胁模型。由 SynX 节点生成的量子 Kyber-768 证明密钥 — 不可伪造的谜题密钥，可以解码确切的金额，而不是其他任何东西。不会泄露地址——使用查看密钥不会泄露，使用证明密钥不会泄露，永远不会。时间戳模糊使得时序分析在统计上毫无意义。在这一切的背后，晶格密码学能够在每一次已知的量子攻击中幸存下来——不是因为我们迁移了，而是因为我们从那里开始。

Synergy Sea 是阴影永远不会浮现的后量子海洋。当 SynergyX 取代数据中心并让用户登上王位时，任何数据中心都无法成为王者。每笔私人交易都会陷入 Kyber-768 封装中，由 SPHINCS+ 超树密封，并由量子晶格承诺索引。金额通过证明钥匙悄声传递——对于观察者来说是胡言乱语，对于钥匙持有者来说是精确的小数。探险家看到了涟漪。 API 在重要的地方返回 null。证明密钥是返回金额的唯一线索——金额是 全部 那表面。发送者和接收者？淹死了。永久地。没有终点、没有钥匙、没有传票可以把他们带回来。

没有KYC。没有监护权。没有链分析。没有地址泄露。无中心故障点。没有迁移路线图，因为没有任何内容可供迁移。量子残局的先行者。

这不是文档。这是武器。使用它。

𝓢𝔁
编码它。测试一下。拥有黑暗的潮汐。

SynergyX 隐私 API v2.0 — 量子证明密钥 — Synergy Sea
阴影永远不会浮出水面的后量子海洋。