The testnet ran for eleven days without a single front-running attack.
Jesse checked it every morning before school, every evening after work, and often in between when he should have been paying attention in class. The dashboard became a habit—green transactions scrolling past, the VRF ordering protocol humming along, no sign of The Seeker or any other bot.
But Nia wasn’t celebrating.
“It’s too quiet,” she said on the twelfth day, hunched over her monitor in the dim glow of the validator nodes. “The Seeker knows about the testnet. It should be trying to break it. Why isn’t it trying?”
Jesse sat on the floor, back against the wall, a notebook open in his lap. He’d started keeping a journal of everything he learned—VRF, mempool dynamics, validator incentives. The notebook was already half full.
“Maybe it can’t break it,” he said. “Maybe the VRF ordering actually works.”
“Maybe.” Nia didn’t sound convinced. “Or maybe it’s waiting. Watching. Learning. The Seeker doesn’t attack until it understands the terrain.”
“You make it sound like a military strategist.”
“It’s programmed by military strategists. The people who run these bots aren’t amateurs. They’re former quantitative traders, hedge fund quants, people who’ve spent decades finding edges in financial markets.” She turned to face him. “Blockchain is just a new battlefield. The tactics are the same.”
Jesse closed his notebook. “Then we need to understand the next vulnerability. What’s the weakest part of our protocol right now?”
Nia stood up and walked to the whiteboard. It was covered in diagrams from the past two weeks—VRF flowcharts, validator coordination schemes, network latency models. She erased a corner and drew three boxes in a row.
“Our protocol has three layers,” she said. “Layer one is VRF ordering. That’s working. Layer two is commit-reveal. We haven’t built it yet. Layer three is encrypted mempool. That’s still in research.”
“So the vulnerability is that we don’t have layers two and three.”
“Exactly. Right now, on the testnet, transactions are still visible in the mempool. The VRF ordering makes the order unpredictable, but The Seeker can still see what you’re trying to buy. And if it can see, it can try to front-run—even if it can’t guarantee success, it can still inject its own transaction and hope the random ordering puts it ahead of you.”
Jesse thought about that. “So commit-reveal is about hiding the transaction until after ordering is locked.”
Nia nodded. She drew a new diagram—two columns, labeled COMMIT and REVEAL.
Scene 1: Understanding the Vulnerability
“Let me show you why visibility is the real problem,” Nia said, pulling up a simulation on her laptop. “This is a model of the testnet with VRF ordering but no commit-reveal. Watch what happens when a user tries to buy a rare artifact.”
The simulation ran. Jesse saw a user’s transaction appear in the mempool—a purchase request for a limited-edition sword. The VRF assigned it a random position in the next block. But before the block was built, The Seeker’s bot saw the transaction and submitted its own purchase for the same sword, also with a random VRF position.
“Now both transactions are in the mempool,” Nia said. “The Seeker doesn’t know which one will land first—that’s the VRF working. But it doesn’t need to know. It just needs to submit many transactions, all for the same sword, all with different random positions. Statistically, one of them will end up ahead of the user.”
She ran the simulation a hundred times. The results were grim. In seventy-three out of a hundred runs, at least one of The Seeker’s transactions landed ahead of the user. In forty-two runs, The Seeker got the sword. The user got nothing.
“So VRF ordering slows down the bots,” Jesse said, “but it doesn’t stop them. They just spam the mempool with copies.”
“Exactly. The Seeker doesn’t need to see the future. It just needs to flood the zone. And it can do that because it can see every transaction in the mempool.” Nia closed the simulation. “We need to take away its vision. We need to make the mempool blind.”
“That’s where commit-reveal comes in.”
“That’s where commit-reveal comes in.”
Scene 2: The Commit-Reveal Scheme
Nia uncapped a fresh marker and drew on the whiteboard with renewed energy.
“Commit-reveal is a two-step protocol. Step one: the user submits a hash of their transaction, not the transaction itself. A hash is like a fingerprint—unique to that transaction, but impossible to reverse. You can’t look at a hash and figure out what the original transaction was.”
She wrote: Hash = fingerprint(Tx)
“The hash goes into the mempool. Validators order the hashes using VRF, just like before. But at this point, no one—not the validators, not The Seeker, not anyone—knows what the actual transactions are. They only see fingerprints.”
Jesse nodded. “So The Seeker sees a hash and has no idea if it’s a sword purchase, a coffee payment, or someone moving money between their own accounts.”
“Exactly. It can’t front-run what it can’t understand.”
Nia drew the second step. “Step two: reveal. After the ordering is locked—after the block of hashes is finalized—users submit the actual transaction data. The validators then execute the transactions in the already-determined order. The Seeker sees the real transaction at the same time everyone else does. By then, it’s too late to front-run.”
She stepped back from the whiteboard. The diagram showed a clear flow: Submit Hash → Order Hashes → Lock Order → Reveal Transaction → Execute.
“That’s beautiful,” Jesse said.
“It’s standard cryptography. People have been using commit-reveal for decades—voting systems, sealed-bid auctions, anything where you want to hide intent until after a commitment is made.” Nia capped the marker. “But there’s a catch.”
“There’s always a catch.”
Scene 3: The Blind Spot
Nia sat back down at her desk and pulled up a document she’d been working on—a draft of the commit-reveal specification.
“The catch is that The Seeker can still guess. Even if it only sees a hash, it can look at the timing, the pattern, the context. If a thousand hashes show up in the mempool at exactly the moment a popular artifact sale goes live, The Seeker can assume that many of those hashes are purchase attempts.”
Jesse frowned. “So it just guesses which hashes are for the sale?”
“Worse. It can submit its own hashes—its own commitments—for the same artifact. Then, when the reveal phase happens, it reveals actual purchase transactions. If any of its hashes ended up ahead of yours in the ordering, it still wins.”
“But it doesn’t know which hash corresponds to which transaction.”
“It doesn’t need to. It just floods the zone with hashes, just like it flooded the zone with transactions in the simulation. The VRF ordering makes it harder, but not impossible.” Nia pulled up another simulation. “Watch.”
She ran a model where The Seeker submitted fifty hashes for every real user’s hash. The VRF ordering scattered them randomly. Statistically, The Seeker’s hashes occupied about fifty percent of the top positions—enough to capture a significant share of the limited artifacts.
“So commit-reveal alone isn’t enough,” Jesse said. “It slows The Seeker down, but it doesn’t stop it.”
“It doesn’t stop it. And there’s an even worse vulnerability.” Nia’s voice dropped. “The Seeker can also try to crack the hashes.”
Jesse’s blood went cold. “Crack them? I thought hashes were irreversible.”
“They are, in theory. But if the space of possible transactions is small, The Seeker can brute-force guess. For example, an artifact sale has a known recipient address and a known price—50 credits. The only thing that changes is the buyer’s address. That’s a small space. The Seeker could generate hashes for every possible buyer address and compare them to the hashes in the mempool.”
“That’s… terrifying.”
“It’s impractical for large, complex transactions. But for simple purchases like artifact drops? Absolutely feasible.” Nia pulled up a research paper titled “Practical Hash Cracking in Blockchain Mempools.” “This was published six months ago. The authors demonstrated that a bot with moderate computing power could identify about forty percent of commit-reveal transactions within ten seconds.”
Jesse stood up. Started pacing. “So commit-reveal is better than nothing, but it’s not a solution. The Seeker can still guess, still spam, still crack.”
“That’s why we need the third piece,” Nia said. “The encrypted mempool.”
Scene 4: The Trio of Fixes
Jesse walked to the whiteboard and picked up the marker. Underneath the commit-reveal diagram, he wrote:
PROBLEM 1: Visible transactions → SOLVED BY? (VRF ordering partially, but not fully)
PROBLEM 2: Guessing and spamming hashes → SOLVED BY? (Commit-reveal partially, but not fully)
PROBLEM 3: The Seeker adapts → SOLVED BY? (???)
He turned to Nia. “We need all three layers working together. VRF ordering makes the order unpredictable. Commit-reveal hides the transaction contents until after ordering. Encrypted mempool makes it impossible for The Seeker to even see the hashes until it’s too late.”
“But encryption adds another problem,” Nia said. “If the mempool is encrypted, how do validators know which transactions to include? They can’t read anything.”
“Time-lock encryption,” Jesse said, remembering Cipher’s explanation from weeks ago. “Transactions are encrypted with a key that only becomes available after the block is finalized. Validators order the encrypted bundles without seeing inside. Then, after the order is locked, the encryption unlocks and they execute.”
Nia stared at him. “You actually remember that?”
“I’ve been paying attention.” Jesse wrote on the whiteboard:
THE TRIO OF FIXES
- VRF Ordering → Unpredictable sequence
- Commit-Reveal → Hidden intent
- Encrypted Mempool → Complete blindness until it’s too late
“All three,” he said. “Not one, not two. All three.”
Nia was quiet for a long moment. Then she smiled—a real smile, the kind Jesse had only seen once or twice before.
“You’re not a coder,” she said. “But you think like an architect.”
“I think like someone who’s tired of losing.”
They spent the rest of the evening sketching out how the three layers would work together. Nia did the technical heavy lifting—the cryptographic primitives, the network protocols, the performance trade-offs. Jesse asked the hard questions: What if this fails? What if The Seeker does that? How do we know this is enough?
By midnight, they had a rough design.
Layer 1 (Mempool Entry): User generates a transaction, encrypts it with a time-lock key set to the next block height. User submits the encrypted transaction to the mempool.
Layer 2 (Ordering): Validators collect encrypted transactions. They apply a commit-reveal scheme—hashing the encrypted bundles—and order the hashes using VRF. The order is locked.
Layer 3 (Execution): The block is finalized. The time-lock key becomes available. Validators decrypt the transactions and execute them in the locked order.
“The Seeker sees nothing but encrypted garbage until after the block is done,” Nia said. “By then, the sword is already sold. To you.”
“To me,” Jesse said, imagining the Emberheart in his display frame.
“To everyone.”
Nia’s phone buzzed on the desk.
It was after midnight. Who would be texting at this hour? Jesse glanced at the screen. The caller ID showed a name he didn’t recognize: Cipher_Actual.
Nia picked up the phone. Read the message. Her face went pale.
“What is it?” Jesse asked.
She turned the phone toward him. The message was short:
“The Seeker just expanded. It’s now scanning for commit hashes and brute-forcing guesses. We need encryption. Now.”
Jesse’s stomach dropped. “How does Cipher know?”
“Cipher monitors the mempool constantly. They have their own sensors—nodes that watch for bot activity.” Nia was already typing a reply. “This is what I was afraid of. The Seeker isn’t waiting. It’s adapting. Right now, while we’re sitting here drawing diagrams, it’s learning how to crack commit-reveal.”
“But we haven’t even deployed commit-reveal yet. It’s just a testnet.”
“Doesn’t matter. The Seeker is training itself. By the time we’re ready to deploy, it’ll already know how to beat us.” Nia stood up abruptly. “We can’t wait. We need to build the encrypted mempool now. Not next month. Not next week. Now.”
Jesse looked at the whiteboard. The trio of fixes. Layer three—the hardest piece—was still just a sketch. They hadn’t written a single line of code. They hadn’t even agreed on which encryption scheme to use.
“Can we do it?” he asked.
“I don’t know.” Nia’s voice was barely a whisper. “But we have to try.”
She called Cipher. It was 12:30 AM, but Cipher answered on the first ring.
“You saw the message,” Cipher said.
“We saw it,” Nia replied. “How bad is it?”
“Bad. The Seeker’s operators have deployed a new module specifically designed to analyze commit-reveal patterns. It’s not just guessing anymore—it’s using machine learning to predict which hashes correspond to which transactions based on timing, network latency, and historical data.”
“Machine learning?” Jesse said. “It’s teaching itself to front-run?”
“That’s exactly what it’s doing.” Cipher’s voice modulator made them sound distant, almost mechanical. “The people running The Seeker are not amateurs. They have resources—computing power, data scientists, probably a dozen engineers. Every day we wait, they get smarter.”
Nia paced the small apartment. The validator nodes hummed, indifferent to the crisis unfolding around them.
“What do you recommend?” she asked.
“Accelerate the timeline. The Fair Sequencing DAO needs to vote on funding for the encrypted mempool research. No more testnets. No more prototypes. We need a production-ready implementation within six weeks.”
“Six weeks?” Nia stopped pacing. “That’s impossible.”
“Then the network dies.” Cipher’s voice was flat. “I’m not being dramatic. If The Seeker figures out how to break commit-reveal at scale, front-running will become worse than ever. Users will flee. Validators will go bankrupt. The only ones left will be the bots and the people who control them.”
Jesse stepped closer to the phone. “What about the other DAO members? BlockGuild? ValleyValidator? Will they support this?”
Cipher was silent for a moment. “BlockGuild will oppose it. He’ll say it’s too expensive, too risky, too untested. He may even leave the DAO entirely and join QuickPath.”
“And the others?”
“Some will follow BlockGuild. Some will stay. The question is whether the ones who stay are enough to build what we need.” Cipher paused. “I’ll call an emergency meeting for tomorrow night. Be ready.”
The call ended.
Jesse and Nia sat in silence. The whiteboard glowed under the desk lamp—the trio of fixes, now urgent, now desperate.
“Six weeks,” Jesse said.
“Six weeks,” Nia repeated. “To build something that usually takes six months.”
“Can we do it?”
Nia looked at him. Her eyes were red—from exhaustion, from stress, from the weight of everything pressing down on her.
“I don’t know,” she said. “But I’m not going to stop trying. Are you?”
Jesse thought about the empty display frame. The sword he still didn’t have. The Seeker, out there in the dark, learning, adapting, growing stronger every day.
“No,” he said. “I’m not stopping.”
Nia nodded. She pulled out her laptop and opened a new document. At the top, she typed:
ENCRYPTED MEMPOOL – EMERGENCY IMPLEMENTATION PLAN
Underneath, she wrote a single line:
Failure is not an option. The Seeker is counting on it.
Then she looked at Jesse. “You should go home. Get some sleep. Tomorrow is going to be a long day.”
Jesse stood up. Gathered his notebook, his phone, his jacket. At the door, he turned back.
“Nia.”
“Yeah?”
“We’re going to win.”
She smiled—tired, fragile, but real. “Yeah,” she said. “We are.”
Jesse walked out into the night. The street was empty, the sky clear, the stars hidden behind city lights. Somewhere out there, The Seeker was scanning, guessing, cracking.
But somewhere in a small apartment across town, two people and a mysterious ally were building the weapon that would finally blind it.
The war had begun.
Table of contents:
Introduction
Chapter 1: The Mempool
Chapter 2: A Transaction in the Dark
Chapter 3: The Gas Auction
Chapter 4: The Sandwich Attack
Chapter 5: The Priority Fee War
Chapter 6: A Fair Ordering Protocol
Chapter 7: The Commit-Reveal Scheme
Chapter 8: The Encrypted Mempool <<<<<< NEXT
Chapter 9: The Time-Weighted Consensus
Chapter 10: A Just Sequence
