Aptos Encrypted Mempool: How It Limits MEV
Aptos has made encrypted transactions optional on mainnet to limit frontrunning and sandwich attacks. See how it works, what it costs, and its trade-offs.

Aptos Adds an Encrypted Mempool to Limit MEV Attacks
A pending blockchain transaction can leak more than the sender expects. Before execution, it may reveal what function is being called, which assets and amounts are involved, and what contracts it touches. That's enough for bots to monitor mempool activity and try to move their trades ahead of yours. For traders, that can mean worse execution; for protocols and institutions, it can make big transactions easier to anticipate.
Aptos has launched an optional encrypted mempool on mainnet to reduce that visibility. If a compatible wallet or application opts in, transaction details stay encrypted while validators agree on transaction order. The validators decrypt the transactions only after ordering is finalized. Aptos says this makes frontrunning and sandwich attacks harder, without relying on a separate decryption committee or trusted block builders.
It's a meaningful shift, but it's not a universal fix - or a free upgrade. Encrypted transactions come with a higher minimum gas price, and the protection only helps if wallets and apps support and enable the feature. Here's how Aptos's approach works, where it's likely to help, and what to check before relying on it.
Why visible pending transactions create MEV risk
A mempool is the waiting area for transactions that have been submitted to a blockchain but haven't been included in a block yet. On many networks, transaction information is visible to participants before execution. That transparency helps the network run, but it also gives automated traders a chance to react before the original transaction lands.
The value extracted by changing transaction ordering, inserting transactions, or responding to pending activity is often described as maximal extractable value, or MEV. MEV isn't one single attack - it's an umbrella. Some strategies reflect normal competition. Others force a cost onto users who thought their transaction would execute at a particular price.
What happens in a sandwich attack
A sandwich attack is one common example. A bot watches a pending trade that's likely to move an asset's price. It submits a buy transaction first, then another transaction to sell after the user's trade executes. The user ends up executing in the middle - often at a worse price than they would have gotten without the bot's activity.
Frontrunning is related, but broader. A bot watches a pending transaction and tries to execute its own transaction first, betting on the expected market move. Both depend on visibility into pending activity and on the ability to influence or exploit transaction order. They can matter most when a trade is large compared with available liquidity.
How big the problem is depends on the chain, the market, and how it's measured. Cointelegraph's analysis of EigenPhi data reported about $60 million in costs from sandwich attacks on Ethereum over the 12 months through October 2025. Bitquery's review of Solana over 11 months found nearly 6.9 million attacks affecting about 2.2 million wallets, with bots generating $29.7 million. Those numbers aren't directly comparable - they cover different periods and use different methods - but they do illustrate why mempool visibility is a practical design concern, not just a theoretical one.
Why transaction privacy can change execution risk
The key distinction is between hiding a transaction while it's pending and hiding it forever. Aptos's feature does the former. It conceals transaction information during the ordering stage, then decrypts it so the transaction can be executed and recorded onchain.
That timing matters. If a bot can't read a pending order's contents before its position in the block is set, it has less ability to craft a trade around that specific order. So encrypted mempools mainly target one part of certain MEV strategies: early access to pending order details.
Still, encrypted transactions don't eliminate all MEV. Bots can use other inputs, like public market data, activity on other networks, and timing. And encryption doesn't guarantee a particular execution price. It narrows what's visible during a specific window of the transaction lifecycle - it doesn't erase market risk.
How the Aptos encrypted mempool works
Aptos says its Encrypted Mempool is live on mainnet as an optional feature. Users need a compatible wallet or application to opt in. Encryption happens on the user's device before the transaction is sent to the network, so the transaction enters the mempool with its contents concealed.
Aptos also separates transaction ordering from transaction disclosure. Validators can participate in deciding the order without seeing the encrypted contents. After ordering is finalized, validators decrypt the transactions so they can be executed and recorded onchain.
The transaction flow
In broad terms, the flow looks like this:
- The user opts in. A compatible wallet or app prepares the transaction for the encrypted mempool.
- The transaction is encrypted on the device. Asset and amount details are hidden before submission.
- Validators agree on ordering. The encrypted transaction sits in the mempool while validators determine its position in the sequence.
- Validators collectively decrypt it. Decryption happens after ordering is finalized; Aptos says no single validator can decrypt a pending transaction by itself.
- The transaction executes and is recorded. Once decrypted, it can be processed and written to the blockchain.
This sequencing is the main security idea. Validators need to decide which transaction comes first, but they don't need to inspect the hidden contents to do that. By the time the contents are available, the ordering decision that bots would otherwise try to exploit is already made.
What remains visible
"Encrypted" doesn't mean every piece of transaction metadata disappears. Aptos says the sender's address and gas fee stay visible, while details like assets and amounts are hidden. That's important if you're thinking of this as something like general-purpose privacy.
The feature is intended to reduce how visible transaction contents are during the ordering window. It isn't the same as an anonymous transaction system, and it shouldn't be described that way. Users and institutions should still evaluate what metadata the network exposes and what can be inferred from surrounding activity.
Aptos says the feature targets institutions submitting large transactions, traders trying to avoid MEV risk, AI agents, and developers building applications. All of those share a practical goal: stop pending order details from becoming a simple signal for automated strategies. But the protection only applies when the wallet or application supports the encrypted flow and the user actually enables it.
Costs, limits, and design trade-offs
Encrypted mempools come with costs alongside the protection. Aptos developer documentation says encrypted transactions require a minimum gas price set at twice the network's base minimum. In other words, users pay extra for a different execution path designed to reduce exposure to certain transaction-ordering risks.
Aptos also reported that tests involving 50 nodes added about 20 milliseconds per block compared with its existing consensus implementation. That's useful evidence of overhead in that specific test setup, but it isn't a promise of end-to-end latency for every application or network condition. What a user experiences can include more than just the consensus overhead measured in a lab run.
When the extra cost may be worth it
The feature is most compelling when the expected cost of having transaction details exposed is higher than the added fee and any operational complexity. For example, a large trade in a thinner market may be more sensitive to surrounding bot activity than a small, routine transfer. A business sending repeated transactions may also prefer more predictable execution enough to change how it submits transactions.
That doesn't mean every trade should use encryption. If the transaction is small, the market is deep, or the application's execution logic already handles the relevant risk, paying a higher minimum gas price may not make economic sense. The trade-off isn't simply "encrypted vs. not encrypted." It's the likely reduction in a specific risk versus the total additional cost for your situation.
Before opting in, users and application teams should check:
- Whether their wallet or application supports Aptos's encrypted mempool.
- Whether encrypted submission is enabled for the specific transaction, not just assumed.
- The minimum gas price requirement and the total expected transaction cost.
- Whether trade size and market conditions make MEV exposure a real concern.
- What transaction metadata stays visible, and what privacy the feature does not provide.
The adoption problem is real
An optional protocol feature only helps if it's actually available where people transact. Wallet integration, application support, clear settings, and fee transparency all affect whether users can use it safely and consistently. If the experience is confusing - say, users can't tell whether their transaction is encrypted - the security model might be solid, but the real-world outcome won't match.
For builders, integration is also practical work: can the app use the encrypted path without disrupting its normal transaction flow? Teams need to test signing, submission, error handling, fee estimation, and what users see in the UI. A technically elegant protection that's hard to integrate can easily end up unused, especially when the "normal" option is already familiar.
A practical standard is simple: make the protection explicit, show the cost, and give a clear fallback when the feature isn't available. Then users can choose based on the transaction, not on vague promises.
How Aptos compares with other MEV protections
Aptos isn't the first network to try reducing harmful MEV by limiting access to pending transaction details. Gnosis Chain launched an encrypted mempool using Shutter in July 2024. On Ethereum, Flashbots Protect routes transactions privately to block builders instead of exposing them through the public transaction flow in the same way.
All of these share the goal of reducing bots' ability to act on visible pending transactions, but the trust and operating models differ. Private routing can depend on whoever receives transactions (providers, builders, or relays). An encrypted mempool, by contrast, keeps transaction contents hidden while the network determines ordering and then reveals them for execution.
Aptos describes its approach as using its existing validators for both ordering and decryption. It doesn't rely on a separate decryption committee or trusted builders. That could reduce the need for an extra intermediary group, but you still have to evaluate implementation details, validator coordination, wallet support, and how failures are handled.
There's no one MEV protection that fits every chain or app. A useful way to compare is to ask:
- Who can see transaction contents, and when? Privacy may be temporary or depend on private submission.
- Who sets transaction order? Ordering affects how well the protection works and what parties users must trust.
- Who can decrypt a transaction? Threshold or collective processes distribute responsibility differently from a single intermediary.
- What does the user pay? Fees, latency, and integration costs can determine whether the trade-off is worth it.
- What happens if the feature isn't available? If it silently falls back to public submission, users might not get the protection they expected.
For traders, the choice usually happens through the wallet or application, not by manually selecting a protocol mechanism. For developers and institutions, the job is broader: understand the assumptions, test the integration, and explain the limits clearly. Encrypted or private transaction paths can reduce one type of exposure, but they shouldn't be marketed as a guarantee against all MEV.
Conclusion
Aptos's encrypted mempool targets a specific weakness in transparent transaction handling: bots can use visible pending orders to position trades before those orders execute. By keeping transaction contents encrypted until validators finalize ordering, Aptos aims to reduce that opportunity while using its existing validator set for ordering and decryption.
The trade-offs are straightforward. Encrypted transactions require a higher minimum gas price, and the feature protects against a defined source of MEV exposure rather than every kind of trading risk. It also depends on wallet and application support, and on users understanding when encryption is actually enabled.
If you trade or build on Aptos, check whether your wallet supports the feature, compare the fee increase to the likely risk for your specific transaction, and treat encryption as one layer of execution protection - not a guarantee. For implementation details, see the Aptos developer documentation and the original report on the launch.