Security · design paper · status as of 2026-10-20
Implementation status. MEV Shield is a design. The Aurigraph V12 tree contains no consensus-layer encrypted mempool, threshold-encryption scheme or fair-ordering implementation; what exists is an SDK client stub (MevShieldClient) and a marketplace listing. Every mechanism, guarantee and figure in this paper is therefore a design target, not shipped behaviour, and production consensus itself currently runs in SIMULATE mode on a single node.
V12
MevShieldClient
SIMULATE
Maximal Extractable Value (MEV) is the profit that miners, validators, or bots can extract by reordering, inserting, or censoring transactions before they are finalized. Left unchecked, it functions as an invisible tax on every user of a public ledger — degrading execution quality, eroding trust, and concentrating value in the hands of whoever controls transaction ordering. Aurigraph's MEV Shield is designed to neutralize this threat through three complementary mechanisms that operate at the consensus layer: a private (encrypted) memory pool, threshold encryption that splits transaction data across validators, and a fair, deterministic ordering algorithm that no single party can manipulate. Because protection would be enforced by all validators, it would work transparently for every transaction with no application changes required. This paper describes the MEV problem, the threat model MEV Shield is designed against, the approach and architecture, and — importantly — an honest account of what the design does and does not prevent, and of the fact that none of it is implemented yet.
In traditional blockchain systems, validators can see pending transactions before they are confirmed. That visibility, combined with the power to decide ordering, creates opportunities to extract value at users' expense. MEV Shield targets the classic forms of this abuse:
The economic damage is large and cumulative: MEV costs users billions annually across all blockchains. The harm is not only direct value loss on individual trades — it is the systemic distortion of markets, where the price a user actually receives depends on who is watching the mempool and how they choose to order the block. For decentralized exchanges, lending protocols, and any fair-market application, this undermines the core promise of neutral, rules-based settlement.
MEV Shield is designed against an adversary who is a participant in the transaction pipeline, not merely an outside observer. Concretely, the threat model assumes:
The model assumes that no single validator should be trusted with the plaintext of a pending transaction, and that ordering must not be under the unilateral control of any one participant. It rests on a separate trust assumption, stated on its own terms: a bounded set of validators will not collude to reconstruct the threshold key material before commitment. The model does not attempt to defend against adversaries who already possess the user's private keys, nor against off-chain information advantages (e.g., a user telegraphing their intent outside the protocol) — those are outside MEV Shield's scope and are discussed in Section 5.
MEV Shield uses three complementary mechanisms. Each addresses a different link in the MEV extraction chain: seeing the transaction, decrypting it prematurely, and choosing its position in the block.
Transactions are encrypted and stored in a private memory pool that is not visible to validators until commitment. Extraction strategies like front-running and sandwiching depend on the attacker being able to read a pending transaction's contents before it is locked into a block. By keeping transactions encrypted in the pool, MEV Shield removes the information that these attacks require. Only once a block is finalized are the transactions decrypted and processed in a predetermined order — after the ordering decision can no longer be influenced by their contents.
To ensure that "private" does not simply mean "trust one validator," transaction data is split across multiple validators using threshold cryptography. No single validator can access transaction details; only the network collectively can decrypt them. This is what makes the encrypted mempool robust against an adversarial validator: even a validator who is producing the block cannot unilaterally peek at the transactions it is ordering. Decryption becomes an action the network performs together, after commitment, rather than a capability any one party holds in advance.
Finally, transaction ordering follows a transparent, verifiable algorithm that cannot be manipulated. The site describes this ordering as:
Aurigraph's fair-markets design further layers bundle randomization to make ordering unpredictable, and relies on the platform's sub-second deterministic finality target (the "0.5 s" figure quoted on the site is a design target; the platform publishes no measured finality) so that there is effectively no time window in which to re-order transactions for profit. The combination of a short finality window and an ordering rule that is fixed and unpredictable is what would close the gap that reordering attacks exploit.
Design direction. The site describes the ordering algorithm at the level of its properties (deterministic, unpredictable, timestamp-fair) rather than specifying a named scheme, and describes threshold encryption without pinning a specific cryptosystem. The concrete instantiation — the exact threshold-encryption construction, the commit/reveal cadence, and the precise fair-ordering rule — is design direction to be fixed and published against a running consensus implementation, not asserted here as a settled protocol detail. None of these mechanisms exists in the V12 consensus code today.
MEV Shield is designed to operate at the consensus layer and be enforced by all validators. This is a deliberate architectural choice: MEV is fundamentally a property of who orders transactions and what they can see, so the defense belongs where ordering and validation happen, not bolted on at the application layer.
Two consequences follow:
Architecturally, the designed flow is: a client's transaction enters the pool encrypted; its plaintext is shared across validators via threshold cryptography so that no single validator holds it; the block's transaction order is fixed by the deterministic, unpredictable, timestamp-fair algorithm; and only after commitment/finalization are transactions decrypted and executed in that predetermined order. The product page states a design target of under 100 ms of added latency, which is not measured on production, since the mechanism is not implemented. The only MEV-related code in V12 today is an SDK client stub (MevShieldClient) that models order submission through a protected path against a server surface that does not yet exist.
An honest security document must state both what a mechanism guarantees and where its guarantees end.
What MEV Shield is designed to prevent:
Limitations and boundaries (honest scope):
Stating these boundaries is not a weakness of the design — it is what lets integrators reason correctly about the protection they are getting.
MEV Shield's protection is most valuable wherever transaction ordering directly affects the price or outcome a user receives:
MEV is an ordering problem, and MEV Shield is designed to answer it where ordering lives — at the consensus layer. By encrypting transactions until commitment, splitting their contents across validators via threshold cryptography, and fixing block order with a deterministic, unpredictable, timestamp-fair algorithm, the design removes the visibility and the discretion that front-running, sandwiching, reordering, and targeted censoring all depend on. Enforced by every validator and requiring no application changes, it is intended to deliver this protection transparently, within a design-target latency budget of under 100 ms (not measured on production), on a ledger with design-target sub-second finality. The design is deliberately explicit about its boundaries: it targets the modeled ordering attacks under stated validator-collusion assumptions, leaves key compromise and off-chain information leakage out of scope, and — most importantly — is not yet implemented in the Aurigraph consensus layer. For decentralized exchanges, minting platforms, lending markets, and any application that depends on neutral settlement, MEV Shield is the plan for turning fair ordering from an aspiration into a property enforced by the protocol itself, once real multi-node consensus ships.
content/products/mev-shield.md
content/sustainability/fair-markets.md
content/features/hyperraft-consensus.md
content/features/defi-suite.md
Explore: About · Products · Features · Whitepapers · Sustainability · Tokenized carbon credits · Real-world asset tokenization · SDK · Blog · Plain-text site index · Sitemap · Contact: contact@aurigraph.io