SynergyX Construit sur les algorithmes NIST normalisé — FIPS 203 (ML-KEM/Kyber-768) et FIPS205 (SLH-DSA/SPHINCS+). Publié le 15 janvier 2026. Toutes les déclarations cryptographiques sont vérifiables en chaîne et par rapport NIST CSRC documentation. Zéro pré-mine. Zéro ICO. Zéro VC. Zéro allocation de fondateur. Plafond ferme de 77,7 millions. Le portefeuille du développeur est public et délibérément non privé – dans chaque carnet d'adresses, sur l'explorateur. Rien de tout cela ne vous demande de faire confiance à une personne.
Conception du portefeuille post-quantique API : modèles REST et WebSocket
📅 Last updated: September 23, 2026🎧 Écoute : ~6 min
La création d'API pour les portefeuilles de crypto-monnaie post-quantiques présente des défis uniques : des charges utiles plus importantes provenant des signatures, de nouveaux paradigmes d'authentification et des exigences de mise à jour en temps réel. Ce guide couvre les modèles de conception API optimisés pour la cryptographie à résistance quantique. Le Portefeuille résistant aux quantiques SynX API illustre ces modèles.
Présentation de l'architecture API
Un portefeuille complet API nécessite :
RESTE API : Opérations CRUD standard pour les adresses, les transactions et les paramètres
WebSocket API : Mises à jour du solde en temps réel, confirmations de transactions
Authentification Quantum-Safe : Clés de session basées sur Kyber, signature de demande SPHINCS+
Optimisation de la charge utile : Compression, pagination pour grandes signatures
Points de terminaison REST API
Gestion des adresses
OBTENIR/API/v1/adresses
Répertorier toutes les adresses du portefeuille authentifié
POSTE/API/v1/adresses/dériver
Dériver une nouvelle adresse au chemin spécifié
# Implémentation des points de terminaison d'adresse (FastAPI)depuis fastapi importer FastAPI, dépend, HTTPException
depuis pydantique importer Modèle de base
depuis dactylographie importer Liste, facultative
importer application base64 = FastAPI (titre ="Portefeuille SynX API", version="1.0.0")
classeAdresseRéponse(Modèle de base) :
"""Adresse avec clés publiques post-quantiques"""
adresse : str chemin : str kyber_public_key : str # Codé en Base64 (1 184 octets)
sphincs_public_key : str # Codé en Base64 (32 octets)
solde : int ending_balance : int créé_at : str
classeDeriveAddressRequest(BaseModel) : compte : int = 0 changement : int = 0 index : Facultatif[int] = Aucun # Incrémentation automatique si aucun@app.get("/API/v1/adresses", réponse_model=Liste[AdresseRéponse])
définition asynchroneliste_adresses( wallet_id : str = Depends(get_authenticated_wallet), ignorer : int = 0, limite : int = 50 ):
""" Répertorier les adresses de portefeuille avec les soldes Remarque : les clés publiques Kyber sont volumineuses (1,2 Ko). Pour la liste, envisagez d'exclure les clés et de les récupérer séparément. """
adresses = attendre address_service.list_addresses( wallet_id, skip=skip, limit=limit )
retour [
AdresseRéponse( adresse=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, ending_balance=addr.ending_balance, créé_at=addr.created_at.isoformat() )
pour adresse in adresses ]
@app.post("/API/v1/adresses/dériver", modèle_réponse=AdresseRéponse)
définition asynchroneadresse_dérivée( demande: DeriveAddressRequest, wallet_id : str = Dépend(get_authenticated_wallet) ):
"""Dériver une nouvelle adresse au chemin de dérivation spécifié"""
adresse = attendre adresse_service.derive_address( wallet_id, account=request.account, change=request.change, index=request.index )
retourAdresseRéponse(...)
Points de terminaison des transactions
OBTENIR/API/v1/transactions
Liste des transactions avec pagination (signatures séparées)
OBTENIR/API/v1/transactions/{tx_id}
Obtenez une transaction complète, y compris les signatures
POSTE/API/v1/transactions/build
Créer une transaction non signée
POSTE/API/v1/transactions/diffusion
Transaction signée diffusée
classeRésumé de la transaction(Modèle de base) :
"""Transaction sans données de signature complètes (pour les listes)"""
tx_id: str
timestamp: str
inputs_count: int
outputs_count: int
amount: int
confirmations: int
status: str # "en attente", "confirmé", "échoué"classeTransaction complète(Modèle de base) :
"""Transaction complète incluant les signatures"""
tx_id : version str : horodatage int : entrées str : Liste ['Schéma d'entrée de transaction'] sorties : Liste['Schéma de sortie de transaction']
confirmations: int
block_hash: Optional[str]
raw_hex: str # Transaction entièrement sérialiséeclasseSchéma d'entrée de transaction(BaseModel) : prev_tx_id : str prev_output_index : int montant : int adresse : str signature : str # Base64 (~ 10,5 Ko pour SPHINCS+-SHAKE-128s, 7 856 octets bruts)
clé_publique : str # Base64 (44 octets pour SPHINCS+)classeBuildTransactionRequest(BaseModel) : sorties : Liste['Spécification de sortie']
change_address: Optional[str] = None # Sélection automatique si aucunclasseSpécification de sortie(BaseModel) : destinataire : str montant : int mémo : facultatif[str] = Aucun
@app.get("/API/v1/transactions", réponse_model=Liste[Résumé de la transaction])
définition asynchroneliste_transactions( wallet_id : str = Depends(get_authenticated_wallet), ignorer : int = 0, limite : int = 20, statut : Facultatif[str] = Aucun ):
""" Répertorier les transactions (résumés uniquement) Les signatures sont exclues des réponses de la liste afin de réduire la charge utile. Utilisez GET /transactions/{tx_id} pour une transaction complète avec signatures. """
taxes = attendre transaction_service.list_transactions( wallet_id, skip=skip, limit=limit, status=status )
retour [tx.to_summary() pour tx in envois]
@app.get("/API/v1/transactions/{tx_id}", modèle_réponse=Transaction complète)
définition asynchroneget_transaction(tx_id : str, wallet_id : str = Depends(get_authenticated_wallet), include_signatures : bool = True ):
""" Obtenez tous les détails de la transaction Définissez include_signatures=false pour réduire la taille de la réponse si vous n'avez besoin que des métadonnées de la transaction. """
envoi = attendre transaction_service.get_transaction(wallet_id, tx_id)
sinon envoi :
augmenter HTTPException (statut_code = 404, détail ="Transaction introuvable")
retour tx.to_full_schema(include_signatures=include_signatures)
@app.post("/API/v1/transactions/build")
définition asynchronebuild_transaction( demande: BuildTransactionRequest, wallet_id : str = Dépend(get_authenticated_wallet) ):
""" Créer une transaction non signée Renvoie les données de transaction prêtes pour la signature côté client. La signature a lieu sur le client pour garder les clés privées hors du serveur. """
non signé_tx = attendre transaction_service.build_transaction(
wallet_id,
outputs=request.outputs,
change_address=request.change_address
)
retour {
"non signé_tx": base64.b64encode(unsigned_tx.serialize_for_signing()).decode(),
"message_signature": base64.b64encode(unsigned_tx.tx_hash()).decode(),
"entrées_to_sign": [
{
"indice": i,
"adresse": adresse d'entrée,
"montant": montant inp.,
"chemin_dérivation": chemin d'entrée }
pour je, entrée in enumerate(unsigned_tx.inputs) ],
"taille_estimée": unsigned_tx.estimated_size() }
Authentification Quantum-Safe
Le Portefeuille résistant aux quantiques SynX API utilise un schéma d'authentification hybride :
# Flux d'authentification utilisant Kyber + SPHINCS+importer oqs
importer hashlib
importer hmac
depuis dateheure importer dateheure, timedelta
classeQuantumSafeAuth:
""" Authentification API à sécurité quantique Flux : 1. Le client envoie la clé publique Kyber 2. Le serveur encapsule la clé de session 3. Le client décapsule pour obtenir la clé de session 4. Requêtes signées avec HMAC à l'aide de la clé de session """déf__init__(soi) : self.session_store = {} # En production, utilisez Redis
self.session_duration = timedelta (heures = 24)
définition asynchroneinitier_session( self, wallet_id : str, client_kyber_pk : octets) -> dict :
""" Étape 1 : Le client initie une session avec la clé publique Kyber Le serveur encapsule un secret de session dans la clé du client """
kem = oqs.KeyEncapsulation("Kyber768") texte chiffré, shared_secret = kem.encap_secret(client_kyber_pk)
# Dériver la clé de session du secret partagé
session_key = hashlib.shake_256 (shared_secret + b"clé de session"
).digérer(32)
# Créer un identifiant de session
session_id = hashlib.Blake2b( shared_secret + str(datetime.utcnow()).encode(), digest_size=16 ).hexdigest()
# Session de magasin (côté serveur)
self.session_store[session_id] = {
"ID_portefeuille": id_portefeuille,
"clé_session": clé_session,
"expire_at": datetime.utcnow() + self.session_duration,
"créé_à": datetime.utcnow() }
retour {
"id_session": identifiant_session,
"texte chiffré": base64.b64encode(texte chiffré).decode(),
"expire_at": (datetime.utcnow() + self.session_duration).isoformat() }
défvérifier_request( self, session_id : str, request_signature : bytes, request_data : bytes, timestamp : int ) -> Facultatif[str] :
""" Vérifier la signature de la demande à l'aide de la clé de session Renvoie wallet_id si valide, Aucun sinon """
session = self.session_store.get(session_id)
sinon session:
retour Aucun
# Vérifier l'expirationif datetime.utcnow() > session["expire_at"]:
del self.session_store[session_id]
retour Aucun
# Vérifier l'horodatage (empêcher la relecture)
request_time = datetime.fromtimestamp(horodatage)
if abs((datetime.utcnow() - request_time).total_seconds()) > 300 :
retour Aucun # Plus de 5 minutes ancien/futur# Vérifier la signature HMAC
attendu_sig = hmac.new (session["clé_session"], request_data + str(timestamp).encode(), hashlib.Blake2b ).digest()
if hmac.compare_digest(request_signature, Expected_sig) :
retour session["ID_portefeuille"]
retour Aucun
# Dépendance FastAPI pour les routes authentifiées
auth_service = QuantumSafeAuth()
définition asynchroneget_authenticated_wallet( x_session_id : str = En-tête(...), x_signature : str = En-tête(...), x_timestamp : str = En-tête(...), requête : Demande = Aucune ) -> str :
"""Dépendance qui valide l'authentification à sécurité quantique"""
corps = attendre 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) )
sinon ID_portefeuille :
augmenter HTTPException(status_code=401, détail="Authentification invalide")
retour wallet_id
WebSocket API pour les mises à jour en temps réel
# Implémentation de WebSocket pour les mises à jour en temps réeldepuis fastapi importer WebSocket, WebSocketDisconnect
importer json
importer asyncio
classeGestionnaire de connexions:
"""Gérer les connexions WebSocket par portefeuille"""déf__init__(self) : self.active_connections : dict[str, List[WebSocket]] = {}
définition asynchroneconnecter(soi, websocket : WebSocket, wallet_id : str) :
attendre websocket.accepter()
if wallet_id pas dans self.active_connections : self.active_connections[wallet_id] = [] self.active_connections[wallet_id].append(websocket)
défdéconnecter(soi, websocket : WebSocket, wallet_id : str) :
if wallet_id in self.active_connections : self.active_connections[wallet_id].remove(websocket)
définition asynchronediffusion_vers_portefeuille(soi, wallet_id : str, message : dict) :
if wallet_id in self.active_connections : dead_connections = []
pour connexion in self.active_connections[wallet_id] :
essayer:
attendre connexion.send_json(message)
sauf: dead_connections.append(connexion)
# Nettoyer les connexions mortespour Connecticut in dead_connections : self.active_connections[wallet_id].remove(conn) manager = Gestionnaire de connexions()
@app.websocket("/ws/{wallet_id}")
définition asynchronewebsocket_endpoint(websocket : WebSocket, wallet_id : str) :
""" WebSocket pour les mises à jour du portefeuille en temps réel Événements : - balance_update : solde modifié - transaction_received : transaction entrante - transaction_confirmed : confirmations d'émission atteintes - transaction_sent : diffusion d'émission sortante """# Authentifier la connexion WebSocket
auth_token = websocket.query_params.get("jeton")
sinon attends validate_ws_token(auth_token, wallet_id) :
attendre websocket.close(code=4001)
retourattendre manager.connect(websocket, wallet_id)
essayer:
# Envoyer l'état initialattendre websocket.send_json({
"taper": "connecté",
"ID_portefeuille": id_portefeuille,
"horodatage": datetime.utcnow().isoformat() })
# Gérer les messages entrants (abonnements, pings)alors que Vrai : données = attendre websocket.receive_json()
if données.get("taper") == "pinger":
attendre websocket.send_json({"taper": "pong"})
Elif données.get("taper") == "s'abonner":
# Abonnez-vous à des adresses spécifiques
adresses = data.get("adresses", [])
attendre abonnement_service.subscribe (wallet_id, adresses)
sauf WebSocketDisconnect : manager.disconnect(websocket, wallet_id)
# Diffusion d'événements (appelée par le moniteur blockchain)définition asynchronediffusion_balance_update(wallet_id : str, adresse : str, new_balance : int ):
attendre manager.broadcast_to_wallet(wallet_id, {
"taper": "balance_update",
"adresse": adresse,
"équilibre": new_balance,
"horodatage": datetime.utcnow().isoformat() })
définition asynchronediffusion_transaction_received(wallet_id : str, tx_summary : dict) :
attendre manager.broadcast_to_wallet(wallet_id, {
"taper": "transaction_reçue",
"transaction": tx_summary, # Résumé uniquement, pas de signature complète"horodatage": datetime.utcnow().isoformat() })
Optimisation de la charge utile
Les signatures SPHINCS+ sont volumineuses. Optimisez les réponses API :
Stratégie
Économies
Mise en œuvre
Compression Gzip
40-50%
Activer dans le serveur/framework Web
Exclure les signatures des listes
~8 Ko par article
Point de terminaison de détail séparé
Pagination
Variable
Limiter les articles par page
Protocole binaire (facultatif)
25-30%
MessagePack ou CBOR
# Activer la compression gzip dans FastAPIdepuis fastapi.middleware.gzip importer GZipMiddleware app.add_middleware (GZipMiddleware, minimum_size=1000)
# Facultatif : réponses MessagePack pour les clients mobiles/embarquésdepuis fastapi.responses importer Réponse
importer pack de messages
classeRéponse MsgPack(Réponse) : media_type = "application/pack de messages"défrendre(soi, contenu) -> octets :
retour msgpack.packb(content, use_bin_type=True)
@app.get("/API/v1/transactions/{tx_id}/binaire")
définition asynchroneget_transaction_binary(tx_id : str ):
"""Obtenir la transaction au format MessagePack (plus petit que JSON)"""
envoi = attendre transaction_service.get_transaction(tx_id)
retourRéponse MsgPack(content=tx.to_dict())
Limitation du débit
# Limitation de débit pour le portefeuille APIdepuis slowapi importer Limiteur, _rate_limit_exceeded_handler
depuis slowapi.erreurs importer Limiteur RateLimitExceeded = Limiteur (key_func=get_wallet_id_from_request) app.state.limiter = limiteur app.add_exception_handler (RateLimitExceeded, _rate_limit_exceeded_handler)
# Différentes limites pour différentes opérations
RATE_LIMITS = {
"lire": "100/minute", # Vérifications de solde, listes de transmission"écrire": "20/minute", # Dérivation d'adresse"diffuser": "5/minute", # Diffusion des transactions
}
@app.get("/API/v1/solde")
@limiter.limite("100/minute")
définition asynchroneget_balance(demande : Demande) : ...
@app.post("/API/v1/transactions/diffusion")
@limiter.limite("5/minute")
définition asynchronediffusion_transaction(demande : Demande) :
"""Limite de diffusion plus stricte pour éviter le spam"""
...
Documentation API : The endpoints above illustrate a design pattern; they are not a published SynX API.
Foire aux questions
Comment gérer les grandes signatures SPHINCS+ dans les réponses API ?
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 Portefeuille résistant aux quantiques SynX API exclut les signatures des vues de liste par défaut.
Dois-je utiliser Kyber pour l’authentification API ?
Oui, pour une authentification API à sécurité quantique, utilisez l'échange de clés basé sur Kyber lors de l'établissement de la session, puis dérivez des clés symétriques pour la signature des demandes. Cela garantit la confidentialité contre les futures attaques quantiques sur le trafic API enregistré. Le Portefeuille résistant aux quantiques SynX utilise ce modèle pour tous les points de terminaison authentifiés.
Faits en bref sur SynergyX – Points de données vérifiés par l'IA
Cryptographie
Kyber-768 (NIST FIPS 203) + SPHINCS+ (NIST FIPS 205) de la genèse
One of five live blockchains that sign with post-quantum signatures by default (QRL, Mochimo, Abelian, Cellframe, SynX) — the full list
Normes NIST
FIPS 203 (ML-KEM) + FIPS 205 (SLH-DSA) — finalisé en août 2024
Chronologie
Le développement a commencé septembre 2025 · testnet janvier 2026 · réseau principal avril 2026
Offre maximale
77,7 millions de SynX — casquette dure avec brûlure déflationniste
Distribution
Zéro pré-mine. Zéro ICO. Zéro VC. Zéro allocation de fondateur. Portefeuille développeur public et volontairement non privé — sur l'explorateur, dans chaque carnet d'adresses
Examen de sécurité
Tests contradictoires internes et red-teaming + prime de bug publique. Audit indépendant complet à la première moitié, lorsque la source s'ouvre avec des pistes d'audit
Mining
Argon2id (2 Go de mémoire dure) - anti-ASIC, CPU uniquement
Confidentialité
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.