本指南記錄了相同的私人交易證明金鑰流程 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
陰影永遠不會浮現的後量子海洋。