Frontier technology · Aurigraph DLT V12 (V11 API) · leader-based CFT Raft consensus over a memory-mapped Write-Ahead Log · status as of 2026-10-20 (production consensus runs in SIMULATE mode)
SIMULATE
HyperRAFT++ is the consensus engine of the Aurigraph DLT platform. It extends the RAFT replicated-log protocol — chosen for its understandability and its strong liveness under crash faults — into an enterprise consensus engine for multi-party distributed ledgers. Today it is a CFT Raft engine: it tolerates crash faults and is not designed to survive lying validators. It layers a majority commit rule, cryptographically-signed leader-election votes, node quarantine, and a high-throughput memory-mapped Write-Ahead Log (WAL) on top of RAFT's leader-and-log foundation. Production runs in SIMULATE mode on a single node.
This paper describes the design honestly: it separates the mechanisms that are implemented and code-verified in the platform — HyperRAFTConsensusService, LeaderElection (real Ed25519 vote signing), LogReplication (parallel follower pipeline), the quorum-math module (quorum math and quarantine), and the memory-mapped WAL with a ParallelFlushManager and group commit — from the throughput and finality targets that the engine is designed to reach. It is deliberate about one further distinction: post-quantum signing in consensus is merged in code but not yet active in production. Vote signatures run in a dual-accept phase (ML-DSA-87 or Ed25519), ML-DSA-87 signing of every replicated log entry is merged but dormant while production consensus runs in simulation mode, and the former QuantumConsensus simulation scaffold has been removed. For the ledger, tokenization, and cryptographic substrate that HyperRAFT++ sits within, see the Aurigraph DLT whitepaper; for the post-quantum cryptography in depth, see the Post-Quantum Cryptography whitepaper.
HyperRAFTConsensusService
LeaderElection
LogReplication
ParallelFlushManager
QuantumConsensus
Every distributed-ledger consensus design negotiates three properties that pull against one another:
Classical designs sit at different corners. Proof-of-Work offers strong adversarial safety and open participation but throttles throughput to single-digit or low transactions per second with minutes-to-hours of probabilistic finality. Simple majority protocols such as RAFT and Paxos deliver high throughput and clean deterministic commit, but only tolerate crash faults — nodes that stop. They assume every node that does respond is telling the truth. That assumption is safe inside one operator's data centre; it is not safe across a consortium of mutually-distrusting parties.
Two-thirds-supermajority protocols (Castro–Liskov, Tendermint, HotStuff) close the adversarial gap with a two-thirds quorum, but historically paid for it in message complexity or fixed block cadence. HyperRAFT++ targets the middle: keep RAFT's leader-based O(n) message pattern and deterministic commit, add signed votes for adversarial safety (a design goal, not yet delivered), and remove the I/O bottleneck with a memory-mapped WAL so that throughput is not sacrificed for safety.
O(n)
RAFT decomposes consensus into three concerns: leader election, log replication, and safety. HyperRAFT++ preserves that decomposition — the platform implements each concern as a distinct component orchestrated by HyperRAFTConsensusService — and hardens each one for a high-throughput setting with untrusted participants.
LeaderElection runs RAFT-style term-based election: a candidate solicits votes, and a term's leader is the node that gathers a quorum of grants. HyperRAFT++ adds cryptographic authenticity to every vote. Each validator registers its public key (registerValidatorKey), and every vote is a NodeVote with a canonical byte representation that is signed with Ed25519; the receiver checks authenticity (isVoteAuthentic) before counting it. This closes the vote-forgery and vote-stuffing attacks that a plain RAFT election is blind to — a malicious node cannot fabricate grants on behalf of others, and equivocating votes are detectable because they are signed over canonical content.
registerValidatorKey
NodeVote
isVoteAuthentic
In textbook RAFT the leader replicates to followers and waits on acknowledgements; naïve implementations serialize this. LogReplication instead drives a parallel follower pipeline. It tracks per-follower state (FollowerState with nextIndex and a running success rate) and pushes entries through a bounded-depth ReplicationPipeline so that many batches are in flight concurrently rather than one-at-a-time. Both single-entry (replicateEntry) and batched (replicateBatch) paths exist, and replication metrics feed back into flow control. Parallelism across followers is the first of the two levers HyperRAFT++ uses to raise throughput.
FollowerState
nextIndex
ReplicationPipeline
replicateEntry
replicateBatch
The second lever is pipelining: proposal, replication, and durable commit are not a strict lock-step per transaction. HyperRAFTConsensusService exposes batch entry points (proposeBatch, proposeAsync) so that transactions are amortized across a single replication-and-commit cycle, and a rate-adaptive path (RateAdaptiveConsensusService) tunes batch sizing to the current load rather than using a fixed block interval. The design intent is that at high load the engine forms larger batches automatically, keeping per-transaction overhead low while preserving deterministic ordering.
proposeBatch
proposeAsync
RateAdaptiveConsensusService
Durability is where many consensus ledgers lose their throughput. Every committed entry must reach stable storage, and a synchronous fsync per entry caps the whole engine at disk latency. HyperRAFT++ addresses this with a purpose-built WAL (consensus.wal.*).
fsync
consensus.wal.*
Append after replication, lock-free. The WAL writes entries after consensus replication, not before — durability records what the cluster has agreed, not what a single leader hopes to propose. Appends use a lock-free working batch handed to a background flush thread (append, appendOptimized), so proposer threads are not blocked on I/O.
append
appendOptimized
Memory-mapped I/O. MemoryMappedWalFile writes through an NIO MappedByteBuffer, letting entries land in the kernel page cache at near-memory latency, with an explicit force() for durability points. This removes the per-entry syscall cost of a naïve append log.
MemoryMappedWalFile
MappedByteBuffer
force()
Group commit. A group-commit batcher (CommitBatcher) coalesces many logical commits into one physical flush, amortizing the durability cost of a force() across a whole batch. Flush cadence and batch ceiling are configurable (aurigraph.wal.flush-interval-ms, default 100 ms; aurigraph.wal.max-batch-size, default 1000).
CommitBatcher
aurigraph.wal.flush-interval-ms
aurigraph.wal.max-batch-size
Parallel flush. ParallelFlushManager spreads flush work across worker threads with dual-path (primary + backup) durability and strict sequence-ordered application, integrating the memory-mapped path and tracking mmap-flush versus fallback counts. Ordering is preserved by sequence tracking even though flushing is concurrent.
Recovery. On restart, RecoveryManager.recover() replays persisted batches via WalReader, verifies checksums, and returns ordered entries for the state machine to replay; recoverFromCheckpoint() and periodic checkpointing (runPeriodicCheckpoint, WalCompactionService) bound recovery time by truncating history that is already durably applied.
RecoveryManager.recover()
WalReader
recoverFromCheckpoint()
runPeriodicCheckpoint
WalCompactionService
WriteAheadLog
RecoveryManager
HyperRAFT++ commits on a majority quorum (n/2 + 1), which is the correct rule for crash faults: nodes that stop. It does not claim safety when nodes lie. Safety against lying nodes would need a two-thirds quorum (2f + 1 of 3f + 1, Lamport–Shostak–Pease, 1982; Castro–Liskov, 1999), and that rule is not the commit rule today. The quorum-math module computes the crash-fault count it tolerates from the live cluster membership. Production runs in SIMULATE mode on a single node.
n/2 + 1
2f + 1
3f + 1
Vote signing. Safety rests not only on quorum size but on vote authenticity — the Ed25519-signed NodeVotes of §2.1 mean the quorum counts only genuine, attributable votes, so a lying node cannot forge agreement.
Message validation and suspicion tracking. Every inbound consensus message is validated (validateMessage); nodes accrue a suspicion level as invalid or conflicting messages arrive (NodeInfo.recordInvalidMessage, getSuspicionLevel), and security events are recorded and reportable (generateReport, getRecentSecurityEvents).
validateMessage
NodeInfo.recordInvalidMessage
getSuspicionLevel
generateReport
getRecentSecurityEvents
Quarantine. A node that crosses the suspicion threshold can be quarantined (quarantineNode) — removed from the counted quorum for a bounded window — and released when the window expires (QuarantineInfo.isExpired, releaseQuarantinedNode). Quarantine turns detection into containment: the protocol degrades gracefully around a misbehaving participant instead of stalling.
quarantineNode
QuarantineInfo.isExpired
releaseQuarantinedNode
When a partition or a burst of crashes pushes the live set below a majority, HyperRAFT++ behaves like every majority-quorum protocol: it pauses liveness to preserve safety. It will not commit a value it cannot prove a majority agreed to. No fork is finalized; progress resumes when quorum is restored.
Where this runs today, and the planned real-consensus design. In production the engine runs in SIMULATE mode (aurigraph.consensus.mode=SIMULATE): a single application node, no independent validators casting votes, and the mode disclosed on the public API. The quorum arithmetic above is therefore exercised in code and tests, not across a live validator set. The design that replaces SIMULATE (AV11-3775, SPEC-CONSENSUS-REAL-001 S3–S6) commits on q = ⌈2N/3⌉ validators with N ≥ 7 and odd in production; validators are lightweight (mobile-class processes over RocksDB — many can run inside one native Quarkus/GraalVM container for test and evaluation); and in production at most f = ⌊(N−1)/3⌋ validators of a channel may share one failure domain, so no host, rack or region can hold a blocking minority. These are planned properties, not shipped ones.
aurigraph.consensus.mode=SIMULATE
Status as of 2026-10-20, stated plainly:
VoteSignatureService
DUAL_ACCEPT
REQUIRE_MLDSA
consensus_vote_sig_phase
SecP384r1MLKEM1024
X25519MLKEM768
scripts/consensus-tls-native-probe/run.sh --native
The cryptography itself is ML-DSA-87 (formerly CRYSTALS-Dilithium, NIST Category 5) and ML-KEM-1024 (formerly CRYSTALS-Kyber), via the BouncyCastle 1.86 FIPS-named API. Until consensus leaves simulation mode and REQUIRE_MLDSA is enforced, this paper does not claim post-quantum consensus as a shipped property. See the Post-Quantum Cryptography whitepaper for the cryptographic design.
We state throughput and finality as engineering targets and design capability, not as measured production benchmarks. The platform's own detailed-design documentation is explicit that the WAL's high-throughput figures are in-code aspirational targets, not benchmarks verified in that document — and this whitepaper adopts the same discipline. Marketing figures quoted elsewhere in the site's feature pages should be read as capability aspirations under this same caveat.
/api/v11/stats
target_tps: 2,000,000
current_tps
2f+1
f
n = 2f+1
The architectural reason to expect high throughput is structural rather than benchmarked: replication is parallel across followers, the WAL avoids per-entry fsync via memory-mapping and group commit, and flush is spread across worker threads while preserving sequence order. Those are the levers that lift the ceiling. What we do not claim is a specific measured transactions-per-second number certified end-to-end; where the platform quotes one, it is a target.
The reason to expect fast, deterministic finality is that HyperRAFT++ is not a probabilistic-finality chain: a block committed on a 2f+1 quorum is final by construction. There is no confirmation-depth waiting game and no reorg risk under the fault bound — the sub-second figure is the latency target for reaching that quorum, and the irreversibility is a protocol guarantee once it is reached.
HyperRAFT++ takes RAFT's understandable leader-and-log core and makes it fast under load. It commits on a majority quorum (CFT Raft, SIMULATE mode on a single node), with signed votes (ML-DSA-87 or Ed25519 today) for vote authenticity, a parallel follower pipeline and batched/pipelined proposal for throughput, node quarantine for graceful degradation, and a memory-mapped, group-committed, parallel-flushed WAL with checksum-verified recovery for durability. Its finality is deterministic on commit rather than probabilistic. It does not tolerate lying validators, and it does not claim safety against them. We have been deliberate about the boundary between what is implemented and what is a target: consensus-layer post-quantum signing is merged but not yet active, full ML-DSA-87 consensus is merged and waits on real consensus mode, and its throughput and finality are not measured on production. They are design targets, to be certified by verified benchmarking rather than asserted.
For the surrounding ledger, tokenization, and cryptographic platform, see the Aurigraph DLT whitepaper and the Post-Quantum Cryptography whitepaper.
Explore: About · Products · Features · Whitepapers · Sustainability · Tokenized carbon credits · Real-world asset tokenization · SDK · Blog · Plain-text site index · Sitemap · Contact: contact@aurigraph.io