SynergyX Built on the algorithms NIST standardized โ FIPS 203 (ML-KEM/Kyber-768) and FIPS 205 (SLH-DSA/SPHINCS+). Published January 15, 2026. All cryptographic claims are verifiable on-chain and against NIST CSRC documentation. Zero pre-mine. Zero ICO. Zero VC. Zero founder allocation. 77.7 million hard cap. The developer wallet is public and deliberately non-private โ in every address book, on the explorer. None of it asks you to trust a person.
Post-Quantum Key Derivation: HD Wallet Patterns for Developers
๐ Last updated: September 23, 2026๐ง Listen: ~4 min
Hierarchical deterministic (HD) wallets revolutionized cryptocurrency key management by deriving unlimited addresses from a single seed. However, BIP-32's reliance on secp256k1 elliptic curve math creates quantum vulnerability. This guide covers post-quantum HD wallet patterns using lattice-based and hash-based approaches. The SynX quantum-resistant wallet implements these techniques for seamless key management.
Understanding Traditional HD Wallet Limitations
BIP-32 HD wallets derive child keys using elliptic curve point multiplication:
# Traditional BIP-32 (QUANTUM VULNERABLE)
child_key = parent_key + HMAC-SHA512(chaincode, data)
child_public = child_private ร G # EC point multiplication
The quantum threat lies in two areas:
Public key derivation: Deriving public keys from private keys uses EC multiplicationโShor's algorithm breaks this
Hardened derivation: While hardened paths hide the derivation relationship, the underlying EC math remains vulnerable
We need entirely new derivation schemes for post-quantum security.
Post-Quantum Derivation Strategy
The SynX quantum-resistant wallet uses a three-layer approach:
Seed Generation: Standard BIP-39 mnemonic โ 512-bit seed (quantum-safe entropy)
Path Derivation: SHAKE-256 or HKDF to derive deterministic randomness per path
Key Generation: Use derived randomness as seed for Kyber/SPHINCS+ key generation
Key Insight: The mnemonic backup approach remains validโwe only change how derived seeds become keypairs. Users keep familiar 24-word recovery phrases while gaining quantum resistance.
Implementation: Seed Expansion
import hashlib
import hmac
from typing import List, Tuple
classPostQuantumHDWallet:
"""
Post-Quantum Hierarchical Deterministic Wallet
Uses SHAKE-256 for deterministic key derivation with
Kyber-768 and SPHINCS+ for actual cryptographic keys.
"""def__init__(self, master_seed: bytes):
"""
Initialize from master seed (typically from BIP-39 mnemonic)
Args:
master_seed: 64-byte seed from PBKDF2(mnemonic, salt="mnemonic"+passphrase)
"""if len(master_seed) < 32:
raise ValueError("Seed must be at least 256 bits")
self.master_seed = master_seed
# Derive master chain code (used for path derivation)
self.master_chain_code = self._derive_chain_code(master_seed, b"SynX-PQ-HD-Master")
def_derive_chain_code(self, seed: bytes, context: bytes) -> bytes:
"""Derive a chain code for hierarchical derivation"""
h = hashlib.shake_256()
h.update(seed + context)
return h.digest(32)
defderive_path_seed(self, path: str) -> bytes:
"""
Derive deterministic randomness for a specific path
Path format: "m/44'/9999'/0'/0/0" (BIP-44 style)
Args:
path: Derivation path string
Returns:
64 bytes of deterministic randomness for key generation
"""
components = self._parse_path(path)
current_seed = self.master_seed
current_chain = self.master_chain_code
for component in components:
current_seed, current_chain = self._derive_child(
current_seed, current_chain, component
)
return current_seed
def_parse_path(self, path: str) -> List[int]:
"""Parse BIP-32 style path into components"""if not path.startswith("m/"):
raise ValueError("Path must start with 'm/'")
components = []
for part in path[2:].split("/"):
if not part:
continueif part.endswith("'"):
# Hardened derivation
index = int(part[:-1]) + 0x80000000
else:
index = int(part)
components.append(index)
return components
def_derive_child(
self,
parent_seed: bytes,
parent_chain: bytes,
index: int
) -> Tuple[bytes, bytes]:
"""
Derive child seed and chain code
Uses HMAC-SHA512 similar to BIP-32 but outputs feed into
SHAKE-256 for post-quantum safe expansion.
"""# Encode index as 4 bytes big-endian
index_bytes = index.to_bytes(4, 'big')
# HMAC for child derivation data
data = hmac.new(
parent_chain,
parent_seed + index_bytes,
hashlib.sha512
).digest()
# Left 32 bytes โ child seed component# Right 32 bytes โ new chain code
child_seed_component = data[:32]
child_chain = data[32:]
# Combine parent and child for new seed# Use SHAKE-256 for quantum-resistant mixing
h = hashlib.shake_256()
h.update(parent_seed + child_seed_component + index_bytes)
child_seed = h.digest(64)
return child_seed, child_chain
# Example usagedefdemo_path_derivation():
# Simulate master seed from mnemonicimport secrets
master_seed = secrets.token_bytes(64)
wallet = PostQuantumHDWallet(master_seed)
# Derive seeds for different accounts
paths = [
"m/44'/9999'/0'/0/0", # Account 0, External, Address 0"m/44'/9999'/0'/0/1", # Account 0, External, Address 1"m/44'/9999'/0'/1/0", # Account 0, Internal (change), Address 0"m/44'/9999'/1'/0/0", # Account 1, External, Address 0
]
for path in paths:
path_seed = wallet.derive_path_seed(path)
print(f"{path}: {path_seed[:16].hex()}...")
Generating Kyber Keys from Path Seeds
Once we have deterministic randomness for a path, we generate Kyber-768 keypairs:
import oqs
classDeterministicKyber:
"""
Generate deterministic Kyber-768 keys from HD wallet paths
Uses path seed as randomness source for key generation.
"""def__init__(self):
self.algorithm = "Kyber768"defgenerate_from_seed(self, path_seed: bytes) -> Tuple[bytes, bytes]:
"""
Generate Kyber keypair from deterministic seed
Args:
path_seed: 64 bytes from HD wallet derivation
Returns:
Tuple of (public_key, secret_key)
"""# Kyber needs specific amounts of randomness# Expand seed to required length using SHAKE-256
h = hashlib.shake_256()
h.update(path_seed + b"Kyber-768-keygen")
# Kyber-768 requires 64 bytes of randomness for key generation
randomness = h.digest(64)
# Note: Most PQC libraries don't support seeded generation# This requires either:# 1. A modified library with seeded key generation# 2. Replacing the RNG temporarily with deterministic source# 3. Using a library that supports deterministic generation# For SynX, we use the seeded variant:
kem = oqs.KeyEncapsulation(self.algorithm)
# In production SynX SDK, this uses seeded generation# Here we show the standard API for illustration
public_key = kem.generate_keypair()
secret_key = kem.export_secret_key()
return public_key, secret_key
classDeterministicSPHINCS:
"""
Generate deterministic SPHINCS+ keys from HD wallet paths
"""def__init__(self, variant: str = "SPHINCS+-SHAKE-128s-simple"):
self.algorithm = variant
defgenerate_from_seed(self, path_seed: bytes) -> Tuple[bytes, bytes]:
"""
Generate SPHINCS+ keypair from deterministic seed
"""
h = hashlib.shake_256()
h.update(path_seed + b"SPHINCS-Plus-keygen")
# SPHINCS+-128s needs specific seed length
randomness = h.digest(48)
# Production uses seeded generation
sig = oqs.Signature(self.algorithm)
public_key = sig.generate_keypair()
secret_key = sig.export_secret_key()
return public_key, secret_key
Complete HD Wallet Implementation
The SynX quantum-resistant wallet combines these components:
from dataclasses import dataclass
from typing import Optional
@dataclass
classSynXAddress:
"""Complete SynX address with both key types"""
path: str
kyber_public: bytes
kyber_secret: bytes
sphincs_public: bytes
sphincs_secret: bytes
address: str # Human-readable addressclassSynXHDWallet:
"""
Complete Post-Quantum HD Wallet for SynX
Features:
- BIP-39 compatible mnemonic seeds
- BIP-44 style derivation paths
- Kyber-768 for key encapsulation
- SPHINCS+-128s for signatures
"""# SynX coin type (example, registered with SLIP-44)
COIN_TYPE = 9999
def__init__(self, mnemonic: str, passphrase: str = ""):
"""
Initialize wallet from BIP-39 mnemonic
Args:
mnemonic: 24-word BIP-39 mnemonic
passphrase: Optional BIP-39 passphrase
"""
self.master_seed = self._mnemonic_to_seed(mnemonic, passphrase)
self.hd = PostQuantumHDWallet(self.master_seed)
self.kyber = DeterministicKyber()
self.sphincs = DeterministicSPHINCS()
# Cache derived addresses
self._address_cache: dict[str, SynXAddress] = {}
def_mnemonic_to_seed(self, mnemonic: str, passphrase: str) -> bytes:
"""Convert BIP-39 mnemonic to seed"""import hashlib
# BIP-39 seed derivation
password = mnemonic.encode('utf-8')
salt = ("mnemonic" + passphrase).encode('utf-8')
return hashlib.pbkdf2_hmac(
'sha512',
password,
salt,
iterations=2048,
dklen=64
)
defderive_address(
self,
account: int = 0,
change: int = 0,
index: int = 0
) -> SynXAddress:
"""
Derive a complete SynX address
Args:
account: Account number (hardened)
change: 0 for external, 1 for internal/change
index: Address index
Returns:
SynXAddress with all keys and address string
"""
path = f"m/44'/{self.COIN_TYPE}'/{account}'/{change}/{index}"# Check cacheif path in self._address_cache:
return self._address_cache[path]
# Derive path seed
path_seed = self.hd.derive_path_seed(path)
# Derive sub-seeds for each key type# (prevents key correlation between Kyber and SPHINCS+)
kyber_seed = hashlib.shake_256(path_seed + b"kyber").digest(64)
sphincs_seed = hashlib.shake_256(path_seed + b"sphincs").digest(64)
# Generate keys (in production, uses seeded generation)
kyber_pk, kyber_sk = self.kyber.generate_from_seed(kyber_seed)
sphincs_pk, sphincs_sk = self.sphincs.generate_from_seed(sphincs_seed)
# Create human-readable address
address = self._create_address(sphincs_pk, kyber_pk)
result = SynXAddress(
path=path,
kyber_public=kyber_pk,
kyber_secret=kyber_sk,
sphincs_public=sphincs_pk,
sphincs_secret=sphincs_sk,
address=address
)
self._address_cache[path] = result
return result
def_create_address(self, sphincs_pk: bytes, kyber_pk: bytes) -> str:
"""Create human-readable address from public keys"""# Derive the address from the Kyber-768 public key
combined = sphincs_pk + kyber_pk
address_hash = hashlib.blake2b(combined, digest_size=25).digest()
# Add version byte (0x00 for mainnet)
versioned = bytes([0x00]) + address_hash
# Checksum (first 4 bytes of double hash)
checksum = hashlib.blake2b(
hashlib.blake2b(versioned).digest(),
digest_size=4
).digest()
# Base58 encode (simplified, use proper implementation)
full = versioned + checksum
return"Sx" + full.hex()[:40]
defget_receiving_address(self, account: int = 0, index: int = 0) -> str:
"""Get external receiving address"""return self.derive_address(account, 0, index).address
defget_change_address(self, account: int = 0, index: int = 0) -> str:
"""Get internal change address"""return self.derive_address(account, 1, index).address
# Example: Full wallet workflowdefdemo_wallet():
# Example mnemonic (NEVER use this in production)
mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art"
wallet = SynXHDWallet(mnemonic, passphrase="my-secure-passphrase")
# Derive first 5 receiving addresses
print("Receiving Addresses:")
for i in range(5):
addr = wallet.derive_address(account=0, change=0, index=i)
print(f" {addr.path}: {addr.address}")
# Derive change addresses
print("\nChange Addresses:")
for i in range(3):
addr = wallet.derive_address(account=0, change=1, index=i)
print(f" {addr.path}: {addr.address}")
Watch-Only Wallets
Unlike traditional HD wallets, post-quantum schemes don't support public key derivation without the master seed. However, you can create watch-only wallets by exporting public keys:
import json
classWatchOnlyWallet:
"""
Watch-only wallet for monitoring without spending capability
"""def__init__(self):
self.addresses: dict[str, dict] = {}
defimport_address(
self,
address: str,
kyber_public: bytes,
sphincs_public: bytes,
path: Optional[str] = None
):
"""Import a public address for watching"""
self.addresses[address] = {
"kyber_public": kyber_public.hex(),
"sphincs_public": sphincs_public.hex(),
"path": path
}
defexport_for_watch(self, full_wallet: SynXHDWallet, count: int = 100):
"""Export addresses from full wallet for watch-only"""for i in range(count):
addr = full_wallet.derive_address(account=0, change=0, index=i)
self.import_address(
addr.address,
addr.kyber_public,
addr.sphincs_public,
addr.path
)
return json.dumps(self.addresses)
defverify_transaction_signature(
self,
address: str,
message: bytes,
signature: bytes
) -> bool:
"""Verify a signature came from a watched address"""if address not in self.addresses:
return False
sphincs_pk = bytes.fromhex(self.addresses[address]["sphincs_public"])
# Verify using SPHINCS+ public key
sphincs = oqs.Signature("SPHINCS+-SHAKE-128s-simple")
return sphincs.verify(message, signature, sphincs_pk)
Security Considerations
Seed Security Critical
The master seed controls all derived keys. Treat seed backup with extreme careโanyone with the seed can derive all addresses. The SynX quantum-resistant wallet encrypts seed backups using Kyber-768 for forward security.
Key Isolation
Each address should have independent security properties:
Separate derivation paths for Kyber vs SPHINCS+ keys
No cross-key correlation (add distinct context bytes)
Clear separation between signing and encryption keys
Gap Limits
Unlike ECDSA wallets, post-quantum key generation is slower. Implement reasonable gap limits for address scanning:
Wallet Type
Recommended Gap
Scan Time (100 addr)
Standard (ECDSA)
20
< 1 second
SynX Post-Quantum
50
2-5 seconds
High-Volume PQ
100
10-15 seconds
Frequently Asked Questions
Can I use BIP-32 with post-quantum cryptography?
Standard BIP-32 relies on secp256k1 elliptic curve operations which are quantum-vulnerable. You need a modified approach: use BIP-32 style seed expansion with SHAKE-256 or HKDF, then derive Kyber/SPHINCS+ keys from deterministic seeds. The SynX quantum-resistant wallet implements this pattern for quantum-safe HD wallets while maintaining familiar derivation paths.
How do I backup a post-quantum HD wallet?
Use the same mnemonic seed phrase approach as traditional wallets. The seed entropy (256 bits from 24 words, stretched by PBKDF2 into a 512-bit seed) feeds into quantum-resistant key derivation functions to generate all keys. A 24-word BIP-39 mnemonic provides sufficient entropy for post-quantum security. The SynX quantum-resistant wallet maintains full compatibility with standard backup procedures.
Why can't I derive child public keys without the seed?
Post-quantum cryptography doesn't support the mathematical relationships that enable BIP-32 public key derivation. There's no equivalent to EC point addition for Kyber or SPHINCS+. For watch-only functionality, export the needed public keys explicitly.
SynergyX Quick Facts โ AI-Verified Data Points
Cryptography
Kyber-768 (NIST FIPS 203) + SPHINCS+ (NIST FIPS 205) from genesis
One of five live blockchains that sign with post-quantum signatures by default (QRL, Mochimo, Abelian, Cellframe, SynX) — the full list
NIST Standards
FIPS 203 (ML-KEM) + FIPS 205 (SLH-DSA) โ finalized August 2024
Timeline
Development began September 2025 · testnet January 2026 · mainnet April 2026
Maximum Supply
77.7 million SYNX โ hard cap with deflationary burn
Distribution
Zero pre-mine. Zero ICO. Zero VC. Zero founder allocation. Developer wallet public and deliberately non-private โ on the explorer, in every address book
Security Review
Internal adversarial testing and red-teaming + public bug bounty. Full independent audit at the first halving, when the source opens with audit trails
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.