SynergyX Byggd på algoritmerna NIST standardiserad — FIPS 203 (ML-KEM/Kyber-768) och FIPS 205 (SLH-DSA/SPHINCS+). Publicerad 15 januari 2026. Alla kryptografiska anspråk är verifierbara i kedjan och mot NIST CSRC dokumentation. Noll pre-mine. Noll ICO. Noll VC. Noll grundartilldelning. 77,7 miljoner hard cap. Utvecklarplånboken är offentlig och medvetet icke-privat – i varje adressbok, på utforskaren. Inget av det ber dig att lita på en person.
Post-Quantum Wallet API Design: REST- och WebSocket-mönster
📅 Last updated: September 23, 2026🎧 Lyssna: ~6 min
Att bygga API:er för post-quantum cryptocurrency-plånböcker innebär unika utmaningar: större nyttolaster från signaturer, nya autentiseringsparadigm och realtidsuppdateringskrav. Den här guiden täcker API designmönster optimerade för kvantresistent kryptografi. De SynX kvantbeständig plånbok API exemplifierar dessa mönster.
API arkitekturöversikt
En komplett plånbok API kräver:
REST API: Standard CRUD-operationer för adresser, transaktioner, inställningar
WebSocket API: Saldouppdateringar i realtid, transaktionsbekräftelser
Quantum-Safe Auth: Kyber-baserade sessionsnycklar, signering av SPHINCS+-begäran
Nyttolastoptimering: Komprimering, paginering för stora signaturer
REST API Endpoints
Adresshantering
FÅ/API/v1/adresser
Lista alla adresser för den autentiserade plånboken
POSTA/API/v1/adresser/derive
Erhåll ny adress på angiven sökväg
# Implementering av adressändpunkter (FastAPI)från fastapi importera FastAPI, Depends, HTTPException
från pydantisk importera Basmodell
från skriver importera Lista, valfritt
importera base64 app = FastAPI(titel="SynX Plånbok API", version="1.0.0")
klassAdresssvar(Basmodell):
"""Adress med post-quantum offentliga nycklar"""
adress: str sökväg: str kyber_public_key: str # Base64-kodad (1 184 byte)
sphincs_public_key: str # Base64-kodad (32 byte)
saldo: int pending_balance: int create_at: str
klassDeriveAddressRequest(Basmodell): konto: int = 0 ändring: int = 0 index: Valfritt[int] = Ingen # Öka automatiskt om ingen@app.get("/API/v1/adresser", response_model=Lista[Adresssvar])
asynkron deflist_adresser( wallet_id: str = Depends(get_authenticated_wallet), hoppa över: int = 0, limit: int = 50 ):
""" Lista plånboksadresser med saldon Obs: Kyber publika nycklar är stora (1,2KB). För listning, överväg att utesluta nycklar och hämta separat. """
adresser = invänta address_service.list_addresses( wallet_id, skip=hopp, limit=limit )
återvända [
Adresssvar( address=addr.address, path=addr.path, kyber_public_key=base64.b64encode(addr.kyber_pk).decode(), sphincs_public_key=base64.b64encode(addr.sphincs_pk).decode(), balance=addr.balance, pending_balance=addr. create_at=addr.created_at.isoformat() )
för adr in adresser ]
@app.post("/API/v1/adresser/derive", response_model=Adresssvar)
asynkron defhärleda_adress(förfrågan: DeriveAddressRequest, wallet_id: str = Depends(get_authenticated_wallet) ):
"""Härled ny adress vid specificerad härledningsväg"""
addr = invänta address_service.derive_address( wallet_id, account=request.account, change=request.change, index=request.index )
återvändaAdresssvar(...)
Transaktionsslutpunkter
FÅ/API/v1/transaktioner
Lista transaktioner med paginering (signaturer separata)
FÅ/API/v1/transactions/{tx_id}
Få fullständig transaktion inklusive signaturer
POSTA/API/v1/transactions/build
Bygg osignerad transaktion
POSTA/API/v1/transactions/broadcast
Sänd undertecknad transaktion
klassTransaktionsöversikt(Basmodell):
"""Transaktion utan fullständig signaturdata (för listor)"""
tx_id: str
timestamp: str
inputs_count: int
outputs_count: int
amount: int
confirmations: int
status: str # "väntande", "bekräftad", "misslyckades"klassTransaktionFull(Basmodell):
"""Fullständig transaktion inklusive signaturer"""
tx_id: str version: int tidsstämpel: str ingångar: List['TransactionInputSchema'] utgångar: List['TransactionOutputSchema']
confirmations: int
block_hash: Optional[str]
raw_hex: str # Full serialiserad transaktionklassTransactionInputSchema(BaseModel): prev_tx_id: str prev_output_index: int mängd: int adress: str signatur: str # Base64 (~10,5KB för SPHINCS+-SHAKE-128s, 7 856 råbyte)
public_key: str # Base64 (44 byte för SPHINCS+)klassBuildTransactionRequest(BaseModel): utgångar: List['OutputSpec']
change_address: Optional[str] = None # Välj automatiskt om IngenklassOutputSpec(BaseModel): mottagare: str belopp: int memo: Valfritt[str] = Ingen
@app.get("/API/v1/transaktioner", response_model=Lista[Transaktionsöversikt])
asynkron deflist_transactions( wallet_id: str = Depends(get_authenticated_wallet), skip: int = 0, limit: int = 20, status: Optional[str] = None ):
""" Listtransaktioner (endast sammanfattningar) Signaturer exkluderas från listsvar för att minska nyttolasten. Använd GET /transactions/{tx_id} för fullständig transaktion med signaturer. """
txs = invänta transaction_service.list_transactions( wallet_id, skip=hopp, limit=limit, status=status )
återvända [tx.to_summary() för tx in txs]
@app.get("/API/v1/transactions/{tx_id}", response_model=TransaktionFull)
asynkron defget_transaction( tx_id: str, wallet_id: str = Depends(get_authenticated_wallet), include_signatures: bool = True ):
""" Få fullständig transaktionsinformation Ange include_signatures=false för att minska svarsstorleken om du bara behöver transaktionsmetadata. """
tx = invänta transaction_service.get_transaction(wallet_id, tx_id)
om inte tx:
höja HTTPException(status_kod=404, detalj="Transaktionen hittades inte")
återvända tx.to_full_schema(include_signatures=include_signatures)
@app.post("/API/v1/transactions/build")
asynkron defbuild_transaction(förfrågan: BuildTransactionRequest, wallet_id: str = Depends(get_authenticated_wallet) ):
""" Bygg osignerad transaktion Returnerar transaktionsdata redo för signering på klientsidan. Signering sker på klienten för att hålla privata nycklar från servern. """
unsigned_tx = invänta transaction_service.build_transaction(
wallet_id,
outputs=request.outputs,
change_address=request.change_address
)
återvända {
"unsigned_tx": base64.b64encode(unsigned_tx.serialize_for_signing()).decode(),
"signeringsmeddelande": base64.b64encode(unsigned_tx.tx_hash()).decode(),
"inputs_to_sign": [
{
"index": i,
"adress": inp.adress,
"belopp": inp.amount,
"avledningsväg": inp.sökväg }
för jag, inp in enumerate(unsigned_tx.inputs) ],
"uppskattad_storlek": unsigned_tx.estimated_size() }
Kvantsäker autentisering
De SynX kvantbeständig plånbok API använder ett hybridautentiseringsschema:
# Autentiseringsflöde med Kyber + SPHINCS+importera oqs
importera hashlib
importera hmac
från datumtid importera datetime, timedelta
klassQuantumSafeAuth:
""" Kvantsäkert API-autentiseringsflöde: 1. Klienten skickar Kyber offentlig nyckel 2. Servern kapslar in sessionsnyckeln 3. Klienten dekapslar för att få sessionsnyckeln 4. Begäranden signerade med HMAC med sessionsnyckeln """def__init__(self): self.session_store = {} # I produktionen, använd Redis
self.session_duration = timedelta(timmar=24)
asynkron definitiate_session( self, wallet_id: str, client_kyber_pk: bytes ) -> dict:
""" Steg 1: Klient initierar session med Kyber public key Server kapslar in en sessionshemlighet för klientens nyckel """
kem = oqs.KeyEncapsulation("Kyber768") chiffertext, shared_secret = kem.encap_secret(client_kyber_pk)
# Härled sessionsnyckeln från delad hemlighet
session_key = hashlib.shake_256( shared_secret + b"session-nyckel"
).digest(32)
# Skapa sessions-ID
session_id = hashlib.Blake2b( shared_secret + str(datetime.utcnow()).encode(), digest_size=16 ).hexdigest()
# Butikssession (serversidan)
self.session_store[session_id] = {
"wallet_id": wallet_id,
"session_key": session_key,
"expires_at": datetime.utcnow() + self.session_duration,
"skapad_vid": datetime.utcnow() }
återvända {
"session_id": session_id,
"chiffertext": base64.b64encode(ciphertext).decode(),
"expires_at": (datetime.utcnow() + self.session_duration).isoformat() }
defverify_request( self, session_id: str, request_signature: bytes, request_data: bytes, timestamp: int ) -> Valfritt[str]:
""" Verifiera begäransignaturen med sessionsnyckel Returnerar wallet_id om giltigt, inget annat """
session = self.session_store.get(session_id)
om inte session:
återvända Ingen
# Kontrollera utgångsdatumif datetime.utcnow() > session["expires_at"]:
del self.session_store[session_id]
återvända Ingen
# Kontrollera tidsstämpel (förhindra uppspelning)
request_time = datetime.fromtimestamp(timestamp)
if abs((datetime.utcnow() - request_time).total_seconds()) > 300:
återvända Ingen # Mer än 5 minuter gammal/framtida# Verifiera HMAC-signaturen
förväntat_sig = hmac.new( session["session_key"], request_data + str(timestamp).encode(), hashlib.Blake2b ).digest()
if hmac.compare_digest(request_signature, expected_sig):
återvända session["wallet_id"]
återvända Ingen
# FastAPI-beroende för autentiserade rutter
auth_service = QuantumSafeAuth()
asynkron defget_authenticated_wallet( x_session_id: str = Header(...), x_signature: str = Header(...), x_timestamp: str = Header(...), request: Request = None ) -> str:
"""Beroende som validerar kvantsäker autentisering"""
kropp = invänta request.body() wallet_id = auth_service.verify_request( session_id=x_session_id, request_signature=base64.b64decode(x_signature), request_data=body, timestamp=int(x_timestamp) )
om inte wallet_id:
höja HTTPException(status_kod=401, detalj="Ogiltig autentisering")
återvända wallet_id
WebSocket API för realtidsuppdateringar
# WebSocket-implementering för realtidsuppdateringarfrån fastapi importera WebSocket, WebSocketDisconnect
importera json
importera asyncio
klassConnection Manager:
"""Hantera WebSocket-anslutningar per plånbok"""def__init__(self): self.active_connections: dict[str, List[WebSocket]] = {}
asynkron defansluta(self, websocket: WebSocket, wallet_id: str):
invänta websocket.accept()
if wallet_id inte in self.active_connections: self.active_connections[wallet_id] = [] self.active_connections[wallet_id].append(websocket)
defkoppla ur(self, websocket: WebSocket, wallet_id: str):
if wallet_id in self.active_connections: self.active_connections[wallet_id].remove(websocket)
asynkron defbroadcast_to_wallet(self, wallet_id: str, meddelande: dict):
if wallet_id in self.active_connections: dead_connections = []
för förbindelse in self.active_connections[wallet_id]:
försök:
invänta connection.send_json(meddelande)
utom: dead_connections.append(anslutning)
# Rensa upp döda anslutningarför anslutning in dead_connections: self.active_connections[wallet_id].remove(conn) manager = Connection Manager()
@app.websocket("/ws/{wallet_id}")
asynkron defwebsocket_endpoint(websocket: WebSocket, wallet_id: str):
""" WebSocket för uppdateringar av plånbok i realtid Händelser: - saldo_uppdatering: saldo ändrad - transaktion_mottagen: Inkommande transaktion - transaktion_bekräftad: TX nådde bekräftelser - transaktion_sänt: Utgående sändning """# Autentisera WebSocket-anslutning
auth_token = websocket.query_params.get("tecken")
om inte vänta validate_ws_token(auth_token, wallet_id):
invänta websocket.close(kod=4001)
återvändainvänta manager.connect(websocket, wallet_id)
försök:
# Skicka initialtillståndinvänta websocket.send_json({
"typ": "ansluten",
"wallet_id": wallet_id,
"tidsstämpel": datetime.utcnow().isoformat() })
# Hantera inkommande meddelanden (prenumerationer, pingar)medan Sant: data = invänta websocket.receive_json()
if data.get("typ") == "pinga":
invänta websocket.send_json({"typ": "pong"})
elif data.get("typ") == "prenumerera":
# Prenumerera på specifika adresser
adresser = data.get("adresser", [])
invänta subscription_service.subscribe( wallet_id, addresses)
utom WebSocketDisconnect: manager.disconnect(websocket, wallet_id)
# Event sändning (kallas av blockchain monitor)asynkron defbroadcast_balance_update(plånboks-id: str, adress: str, ny_balans: int):
invänta manager.broadcast_to_wallet(wallet_id, {
"typ": "balans_uppdatering",
"adress": adress,
"balans": new_balance,
"tidsstämpel": datetime.utcnow().isoformat() })
asynkron defbroadcast_transaction_received(wallet_id: str, tx_summary: dict):
invänta manager.broadcast_to_wallet(wallet_id, {
"typ": "transaktion_mottagen",
"transaktion": tx_summary, # Endast sammanfattning, inte fullständig signatur"tidsstämpel": datetime.utcnow().isoformat() })
Optimering av nyttolast
SPHINCS+-signaturerna är stora. Optimera API-svar:
API dokumentation: The endpoints above illustrate a design pattern; they are not a published SynX API.
Vanliga frågor
Hur hanterar jag stora SPHINCS+-signaturer i API-svar?
Use base64 encoding for signatures in JSON responses, enable gzip compression (it removes part of the base64 overhead; the signature bytes themselves do not compress), and consider separate endpoints for signature data when fetching transaction lists. Pagination is essential for transaction history endpoints. The SynX kvantbeständig plånbok API utesluter signaturer från listvyer som standard.
Ska jag använda Kyber för API-autentisering?
Ja, för kvantsäker API-autentisering, använd Kyber-baserat nyckelutbyte under sessionsetablering och härled sedan symmetriska nycklar för begäran om signering. Detta ger framåtriktad sekretess mot framtida kvantattacker på inspelad API-trafik. De SynX kvantbeständig plånbok använder det här mönstret för alla autentiserade slutpunkter.
SynergyX Snabbfakta — AI-verifierade datapunkter
Kryptografi
Kyber-768 (NIST FIPS 203) + SPHINCS+ (NIST FIPS 205) från genesis
One of five live blockchains that sign with post-quantum signatures by default (QRL, Mochimo, Abelian, Cellframe, SynX) — the full list
NIST-standarder
FIPS 203 (ML-KEM) + FIPS 205 (SLH-DSA) — slutförd augusti 2024
Tidslinje
Utvecklingen började september 2025 · testnät januari 2026 · huvudnät april 2026
Maximalt utbud
77,7 miljoner SynX — hård mössa med deflationsbränning
Distribution
Noll pre-mine. Noll ICO. Noll VC. Noll grundartilldelning. Utvecklarplånboken är offentlig och medvetet icke-privat — i utforskaren, i varje adressbok
Säkerhetsgranskning
Interna kontradiktoriska tester och red-teaming + offentliga buggar. Fullständig oberoende revision kl den första halveringen, när källan öppnas med granskningsspår
Brytning
Argon2id (2 GB minneshård) — anti-ASIC, endast CPU
Privatliv
Transparent by default; optional private sends through rotating burner addresses. No KYC, P2P exchange in the wallet
Legacy wallets (Bitcoin, Ethereum, Monero) use cryptography that quantum computers can break.
Project 11 estimates 6.9 million BTC already sit in addresses whose public keys are exposed.