이 가이드는 다음에서 사용하는 것과 동일한 개인 거래 증명 키 흐름을 문서화합니다. timeline.php 타임라인 액세스 결제를 위해. 이는 개인 SynX 결제를 수락하고, 정확한 금액을 확인하고, 애플리케이션에서 주소 데이터를 유지해야 하는 개발자를 위해 설계되었습니다.

• 지불인으로부터 받는 것: 64자 tx_hash 그리고 증명키. 증명 키는 원시 64-16진수이거나 다음과 같이 접두사가 붙을 수 있습니다. PT- 게다가 64진수.
• API가 증명하는 것: 해당 증명 키가 해당 거래에 유효한지 여부와 정확한 SynX 금액.
• API가 공개하지 않는 것: 보내는 사람 주소, 받는 사람 주소, 지갑 잔액 또는 개인 거래를 위한 공개 지불 경로.
• 기본 끝점: POST /explorer/api/verify_proof.php JSON 본문 포함 {"tx_hash":"...","proof_key":"..."}.

타임라인과 같은 증명 키 구현

타임라인은 눈에 보이는 마켓플레이스 결제를 자동으로 허용합니다. 거래가 비공개이거나 숨겨진 경우에는 증명 키 확인으로 전환됩니다. 증명 키는 주소 필드가 봉인된 상태에서 결제 금액을 확인합니다.

타임라인 스타일 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를 통해 확인합니다. 이것이 전체 신뢰 모델입니다. 양육권이 없습니다. 중개자가 없습니다. 메타데이터 트레일이 없습니다.

⛨ 서버가 아는 것(잭)

신뢰 경계에 대해 솔직하게 말씀드리겠습니다. API를 치고 있습니다. 서버는 기계이므로 기계를 탈취할 수 있습니다. 공격자가 상자를 루팅하면 정확히 다음과 같은 결과를 얻을 수 있습니다.

타이밍이 완화됩니다. 모든 단일 API 응답(GET, POST, 성공, 실패, 404 등)은 500ms 일정한 한도. 서버는 실제 처리 시간을 측정한 후 정확히 절전 모드로 전환합니다. 500ms - elapsed. 모든 응답에는 정확히 500ms가 걸립니다. 무작위가 아닙니다. 끊임없는. 유효한 경로와 유효하지 않은 경로 사이의 Cohen의 d: 0.015 (GhostReaper 테스트 — 통계적으로 보이지 않음) 체이널리시스의 타이밍 오라클 플레이북? 도착하자마자 사망.

🌊 Synergy Sea — 두 개의 깊이 레이어

체인을 바다로 생각하십시오. 공개 거래는 표면에 떠 있습니다. 개인은 가라 앉습니다. 더 깊이 들어갈수록 무엇이든 보려면 증명 키가 더 많이 필요합니다. 그리고 최대 깊이에서도 양 표면 — 주소를 지정하지 않습니다.

더 깊은 레이어는 존재하지 않습니다. 보기 키 공개, 주소 감사, 보낸 사람이나 받은 사람을 밝히는 메커니즘이 없습니다. 양자 Kyber-768 암호화를 사용하여 SynX 노드에서 생성된 증명 키는 정확한 양을 디코딩합니다. 그것은 누구나 갈 수 있는 가장 깊은 곳입니다. 발신자와 수신자의 주소는 영구적으로 바다에 잠겨 있습니다.

반상관 방어구: 타임스탬프가 ±120초로 퍼징되었습니다. 수수료는 5개 계층으로 분류됩니다(마이크로/낮음/표준/높음/프리미엄 — 원시 SAT 금액은 아님). 블록 높이가 null입니다. 응답 시간은 500ms 일정한 상한선으로 채워졌습니다. "TX를 찾을 수 없음" 및 "TX가 비공개입니다"는 동일한 모양. 증명 키는 다음 날짜에 만료됩니다. 30분 — 재생 창을 거의 0으로 제한합니다. 어떤 해시가 실제인지 열거할 수도 없습니다. 모든 표면 쿼리는 TX가 존재하는지, 존재하지 않는지 또는 보호되는지에 관계없이 동일한 양의 정보를 반환합니다. 행운을 빕니다, 체이널리시스.

—͟͟͞͞★ 공급업체 증명 검증 - 3분, 제로 트러스트

당신은 벤더입니다. 구매자가 방금 비공개 SynX로 지불했습니다. 주소나 잔액을 확인하거나 제3자를 신뢰하지 않고 결제를 확인해야 합니다. 방법은 다음과 같습니다. 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로 암호화된 이메일. 토르 히든 서비스. 테이블에 표시된 QR 코드. 공원 벤치 밑에 테이프로 붙인 메모. 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 — 룬문자 봉투(풍부한 메타데이터)

우편 공공의 — 더 풍부한 메타데이터를 사용한 동일한 증명 키 검증: 타임스탬프 창(±120초 퍼지), 만료 카운트다운, 암호 해독 방법. 금액보다 더 필요한 경우에 사용하세요.

별명: /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 — 존재 오라클

얻다 공공의 — 이 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를 그런 식으로 구축했기 때문에 기본적으로 Tor에서 작동합니다. 나중에 생각하는 것이 아닙니다. 당신이 개인적인 것을 만들고 있다면 ~ 아니다 .onion을 통해 라우팅하면 사용자와 서버 사이의 모든 DNS 확인자에게 IP가 유출됩니다. 하지 않다.

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

Tor를 통한 Python(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']}")

Tor를 통한 Node.js

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

✗∑🗡 Code Grimoire — 모든 언어, 모든 패턴

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 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 — 완전한 치트 시트

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를 사용하고 있다면 당신은 이미 죽은 것입니다. 단지 눈치채지 못했을 뿐입니다.

당신의 반지 서명은요? 체이널리시스는 그들을 소처럼 클러스터링합니다. 정확한 타임스탬프? NSA는 커피에 타임스탬프를 찍습니다. Ed25519? Shor가 옵니다. 열쇠는 먼지입니다. 클라이언트 측 증명 생성? 하루 종일 지갑을 디컴파일하고 증거를 위조하세요. 그것은 보안이 아니라 고고학입니다.

SynergyX 증명 키는 다음에 의해 생성됩니다. SynX 노드 양자 Kyber-768 격자 암호화를 사용합니다. 생성 방법은 노드 코어 내부에 봉인되어 있습니다. 클라이언트, 디컴파일러, 공격자는 내부 양자 격자 매개변수에 액세스할 수 없습니다. 지갑을 완전히 디컴파일하는 교묘한 공격자라도 아무것도 얻을 수 없습니다. 지갑 수신 Node의 증명 키. 그것은 그것을 생성하지 않습니다. 비밀은 노드를 떠나지 않습니다.

섀도우 트랜잭션: 보내는 사람, 받는 사람, 금액, 블록: null. 난독화되지 않았습니다. 문질러 지우는.

양자 증거 키: Kyber-768 격자 봉인 퍼즐 키: 누가 보냈는지, 누가 받았는지, 언제(±120초 퍼즈), 어디서 유출 없이 정확한 금액을 증명합니다. 키는 "중간"이 아닌 183.00의 정확한 금액을 디코딩합니다. 증거에는 주소가 없습니다. API에는 주소가 없습니다. 어디에도 주소가 없습니다. 30분 후에 만료됩니다.

주소 공개 없음: 보기 키 엔드포인트가 없습니다. 감사 끝점이 없습니다. 이 API를 통해 발신자 또는 수신자를 공개하는 메커니즘이 없습니다. 금액은 표면에 보이는 전부입니다. 정체성은 영구적으로 익사합니다.

포스트퀀텀: Kyber-768, SPHINCS+, SHAKE256 — Shor는 제네시스 블록에 키스할 수 있습니다. 로드맵이 없습니다. "나중에 양자 신호를 추가할 것입니다." 우리는 면역되어 태어났습니다.

프라이버시를 원하시나요? 스크랩을 구걸하지 마십시오. Synergy를 사용하면 그림자의 바다에서 양자 스텔스와 속도를 얻을 수 있습니다. 칼날을 가져가세요.

오류 코드

verify_proof.php — HTTP 상태 코드

룬 문자 봉투(/rune-verify) - HTTP 상태 코드

429 씨 스로틀 - 응답 본체

모든 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개의 16진수 문자 [a-fA-F0-9]{64}. 증명 키 = 최대 67자(포함) PT- 접두사) 또는 정확히 64진수(원시)입니다. API는 서버 스트립이라는 두 가지 형식을 모두 허용합니다. PT- 자동으로. verify_proof.php 필드 이름을 허용합니다 proof_key or proof_token (별명). 이 범위를 벗어나는 것은 모두 400점을 받습니다. 트리밍은 없습니다. 자비가 없습니다.

🕳 제로 메타데이터 보장 - 개발자가 알아야 할 사항

이 API를 통합하는 경우 여기에 확실한 증거가 있습니다. 메타데이터 유출 없음. 아래의 모든 주장은 GhostReaper 감사를 거쳤습니다(100개 이상의 공격 벡터, 패치되지 않은 결과 0개).

보안 속성 - 개발자 체크리스트

통합자로서 반드시 해야 할 일

𖣐 코드잇. 테스트해 보세요. 어둠을 소유하세요.

이제 당신은 모든 것을 가졌습니다. 6개의 끝점. 실제 코드. 토르 라우팅. 신호 후크. 유출되는 것과 유출되지 않는 것에 대해 정직한 위협 모델. SynX 노드에서 생성된 Quantum Kyber-768 증명 키 — 정확한 양만 해독하는 위조 불가능한 퍼즐 키입니다. 주소 공개가 없습니다. 보기 키나 증명 키가 아닌 절대 아닙니다. 타이밍 분석을 통계적으로 의미 없게 만드는 타임스탬프 퍼징입니다. 그리고 그 밑에는 알려진 모든 양자 공격에서 살아남는 격자 암호화가 있습니다. 이는 우리가 마이그레이션했기 때문이 아니라 그곳에서 시작했기 때문입니다.

Synergy Sea는 그림자가 결코 표면화되지 않는 포스트 양자 바다입니다. SynergyX가 데이터 센터를 무너뜨리고 사용자를 왕좌에 올려놓으면 어떤 데이터 센터도 왕이 될 수 없습니다. 모든 개인 거래는 양자 격자 약속으로 인덱싱된 SPHINCS+ 하이퍼트리로 봉인된 Kyber-768 캡슐화에 들어갑니다. 증거 키를 통해 속삭이는 금액 — 관찰자에게는 횡설수설, 키 보유자에게는 정확한 소수점. 탐험가는 잔물결을 봅니다. API는 중요한 경우 null을 반환합니다. 증명 키는 금액으로 돌아가는 유일한 스레드이며 금액은 다음과 같습니다. 모두 그 표면. 발신자와 수신자? 익사. 영구적으로. 엔드포인트도 없고, 열쇠도 없고, 소환장도 없습니다.

KYC가 없습니다. 양육권이 없습니다. 체인 분석이 없습니다. 주소 공개는 하지 않습니다. 중앙 실패 지점이 없습니다. 마이그레이션할 항목이 없기 때문에 마이그레이션 로드맵이 없습니다. 양자 엔드게임의 퍼스트 무버.

이것은 문서가 아닙니다. 이것은 무기입니다. 그것을 사용하십시오.

𝓢𝔁
코딩하세요. 테스트해보세요. 어둠의 파도를 소유하세요.

SynergyX 개인 정보 보호 API v2.0 — 양자 증명 키 — Synergy Sea
그림자가 결코 표면화되지 않는 포스트퀀텀 바다.