DEV Community: MEV DAO

How to tell a real sweeper bot rescue from a second scam

MEV DAO — Wed, 11 Nov 2026 07:13:01 +0000

if there's a sweeper bot on your wallet you've probably got the DMs already. you posted about it in a discord, or the address popped up on some drain tracker, and now three "recovery experts" want to help you. most of them are a second scam. a couple aren't. this is how we'd sort them out. fair warning, we run one of the paid options ourselves, so take that into account. disclosure's at the bottom.

ok so first, a rescue won't bring back what's already gone. once a transfer confirms it's final, for us and for anyone else. what you can save is the stuff still in there, tokens the attacker didn't bother with, NFTs, staked or vesting positions, an airdrop nobody's claimed. attackers leave more behind than you'd think, because moving some of it costs them gas or needs an extra call.

there's no magic in it. you just stop sending gas on its own. gas and the transfers go in one private bundle, builders put it in a block all at once or drop it, and the bot never gets to see ETH sitting there. oh and run this first:

cast code 0xYourAddress --rpc-url https://ethereum-rpc.publicnode.com

if that prints 0x you're fine. if it starts with 0xef0100 there's an EIP-7702 delegation on the account and clearing it has to go inside that same bundle, otherwise the delegate contract just forwards the gas money out.

so if somebody's promising to get back funds that already left, that's your answer, ignore them. everyone else, ask them a few things.

the big one is the seed phrase. they'll need the old key, the hacked one, because that wallet has to sign the transfers out, there's no way around it. what they should never ask for is the seed of your new wallet. anyone who asks for that one is running the same old play, drain you twice.

then money. "send 0.3 ETH for gas and we'll unlock it" is the oldest advance-fee trick there is. the sponsor wallet does need ETH, but it can be a wallet you made and you fund, you don't hand anyone cash for it.

can they explain the bundle? ask them what goes in it and in what order. when we get asked we just list it: sponsor sends the hacked address exactly enough gas, hacked address sends token A and token B over to your safe wallet, sometimes a tip to the builder last. and we run eth_callBundle on it before anything gets sent. if what you hear back is some fuzzy thing about special software or "tracing the blockchain", i'd walk.

will they show you a simulation? flashbots lets you simulate a signed bundle against the next block, you see the gas and whether anything reverts. a sepolia dry run with throwaway keys is even better. no simulation, no deal.

who messaged who? real people mostly don't cold DM victims. the flashbots whitehat hotline (whitehat.flashbots.net) works the other way around, you open a case with them.

and honestly, you might not need anyone at all. if you're ok running a script, do it yourself. we'd point you at flashbots' searcher-sponsored-tx repo first, it's the usual starting point for ERC-20 and NFT rescues, and there are a couple of newer open-source CLIs now that handle the 7702 part. try it on sepolia with junk keys until it lands, then mainnet. if it's a big amount, call the whitehat hotline before you call us. last we checked their docs want $1,000+ still in the wallet and they keep a percentage.

when is paying someone worth it? mostly when it's messy. like a staked position where you have to unstake, then claim, then transfer, all in one go. or the attacker's awake and fighting you for the same nonce every block. or it's 3am and you'd rather not learn bundle code while your stuff is on fire, which, fair.

so yeah, disclosure. we're MEV DAO and we sell one of these. if you've gone through the checks and want someone to do it for you, the MEV DAO sweeper bot rescue page says how it works and what it costs.

whatever you end up doing, don't send more ETH to the hacked address while you think it over. every top-up goes straight to the bot.

What Is an MEV Searcher? What They Do and How They Get Paid

MEV DAO — Sat, 31 Oct 2026 15:07:12 +0000

Originally published on MEV DAO.

By Merunas Grincalaitis, founder of MEV DAO and a developer who builds MEV, sniping and trading bots on Ethereum. Last updated: Oct 30, 2026.

TL;DR: An MEV searcher is a person or team that runs bots to find profitable transaction orderings on Ethereum, like arbitrage between DEXes or liquidations on lending protocols, and then sends those transactions to block builders as bundles. Searchers don't produce blocks. They compete to get included, and they pay builders (and through them, validators) a share of the profit, usually with a direct ETH transfer to block.coinbase. Most of the money a searcher finds ends up paid to the builder, which is why the job is about speed, accuracy and a small edge, not about luck.

People ask me what I actually do when I say I build MEV bots. The short answer is that I'm a searcher, and I write software for other searchers. "Searcher" is the job title Flashbots uses in its documentation: the bot operators who look for opportunities like arbitrage and liquidations. This article explains the role from the inside: what a searcher does all day, how searchers fit into the block supply chain, how they get paid and how people get started.

What does an MEV searcher do?

A searcher watches the chain for moments where the order of transactions creates profit, then builds and sends the transactions that capture it before anyone else does. MEV stands for maximal extractable value: the value that can be taken by including, excluding or reordering transactions in a block (ethereum.org overview).

In practice a searcher's day looks like software engineering plus monitoring:

Ingest data. New blocks, pending transactions from the public mempool, and hints from order flow auctions such as MEV-Share.
Keep state. Pool reserves, tick data, lending positions and token balances, updated every block.
Search. Run a strategy over that state to find a profitable trade, for example a price difference between two pools.
Simulate. Execute the candidate trade against the latest state to make sure it really pays after gas.
Submit. Package it as a bundle and send it to one or more block builders.
Review. Check what landed, what lost, and why. Then fix the bot.

The term itself goes back to the 2019 paper "Flash Boys 2.0" by Daian and others, which documented bots fighting over arbitrage in public "priority gas auctions" by raising their gas prices again and again. Flashbots and private bundles came later, partly to move that competition off the public mempool.

Which strategies do MEV searchers run?

Most searchers specialize in one or two strategies, because each one needs its own data, contracts and tuning. These are the common ones on Ethereum:

Strategy	What the bot does	Main skill needed
DEX arbitrage	Buys on one pool and sells on another in one transaction	Fast pricing across many pools and fee tiers
Backrunning	Trades right after a large swap that moved a price	Reading pending transactions or MEV-Share hints
Liquidations	Repays unhealthy loans on Aave, Compound and similar protocols for a bonus	Tracking positions and oracle updates
Sniping	Buys a token in the first block it can be traded	Detecting launches and filtering scams
Sandwiching	Trades before and after a victim's swap	Same as backrunning, but it harms users

I don't build sandwich bots and I don't recommend them. They take money directly from the user being sandwiched. The other strategies either keep prices in line across markets or clean up bad debt, and those are the ones worth building a business on. If you want the money side, I broke it down in how MEV bots make money on Ethereum and who keeps the profit.

How is a searcher different from a builder and a validator?

Searchers find opportunities, builders assemble blocks from many searchers' bundles, and validators propose the block that pays them the most. Since the Merge, most Ethereum blocks are produced through MEV-Boost, which separates these roles. I covered the mechanics in what is MEV-Boost: builders, relays and proposers explained.

Role	What they do	How they get paid
Searcher	Finds MEV and sends bundles	Keeps whatever profit is left after paying the builder
Builder	Merges bundles and transactions into the most valuable block	Keeps the difference between what it receives and what it bids
Relay	Passes blocks from builders to validators and checks them	Usually not paid per block
Validator (proposer)	Picks the highest bid and proposes the block	The winning builder's bid

You can see which builders win the most blocks on public dashboards like mevboost.pics. That matters for a searcher, because sending a bundle to a builder that rarely wins blocks means it rarely lands.

How do MEV searchers get paid?

A searcher keeps the profit from its own trade, minus gas and minus the payment it makes to the builder to win inclusion. The standard pattern is a smart contract that does the trade, checks that it made money, and then sends part of it to block.coinbase, the address receiving fees for that block. Flashbots' coinbase payment docs show an example contract that requires its WETH balance to grow by more than the coinbase payment, so the whole transaction reverts if it doesn't make money.

That design is the heart of the business:

No profit, no cost (mostly). If the trade fails inside a bundle, the bundle isn't included and you don't pay gas for it.
Competition sets your margin. When two searchers see the same arbitrage, the one that pays the builder more usually wins. On popular opportunities, most of the profit ends up with the builder and the validator.
Edge comes from being different. Searchers who earn consistently tend to find opportunities others miss, price them more accurately, or have lower costs.

One detail from the same docs catches people out: sometimes block.coinbase is a smart contract instead of a normal wallet, which makes the transfer cost more gas than many searchers expect.

How do searchers send bundles to builders?

Searchers sign their bundles and send them over JSON-RPC to builder endpoints, such as the Flashbots relay at https://relay.flashbots.net. Per the Flashbots quick start, every request is signed with a separate authentication key. That key doesn't hold funds. It identifies you, builds reputation over time, and that reputation can help your bundles get handled during congestion. For testing, Flashbots runs a Sepolia endpoint at https://relay-sepolia.flashbots.net.

Most serious searchers send the same bundle to several builders, since no single one wins every block. Before sending, they simulate with eth_callBundle to catch reverts and check profit. I wrote practical guides on sending bundles with eth_sendBundle and why they don't land and on simulating a bundle with eth_callBundle.

How do you become an MEV searcher?

Start with one simple strategy, run it on a mainnet fork until it's correct, then go live with small size and study every loss. This is the path I'd follow if I were starting today:

Learn the basics of the EVM and DEX math. You need to read Solidity and calculate Uniswap V2 and V3 swap outputs without calling the chain.
Read open-source bots. Flashbots' simple-arbitrage is an old but clear TypeScript example of cross-DEX arbitrage. Paradigm's Artemis is a Rust framework built around collectors, strategies and executors.
Pick one strategy. Two-pool arbitrage or MEV-Share backrunning is a good first choice. I explained the second in backrunning bot on Ethereum: a first MEV-Share strategy.
Test on a fork. Replay real blocks with Anvil so mistakes cost nothing. See how to test an MEV bot on a mainnet fork with Anvil.
Go live small. Use a fresh executor wallet, keep little ETH in the contract, and log everything.
Measure. Track how many opportunities you saw, how many you sent, how many landed and what you paid the builder. Analytics sites like EigenPhi show what competing bots earned on the same kinds of trades.
Join the community. Flashbots points searchers to its Discord and a searcher self-support forum in the quick start docs.

Language choice matters less than people think at the start. Rust is common for speed-critical bots, which I covered in Rust MEV bot in 2026: the Alloy, Reth and Artemis stack, but a correct TypeScript bot beats a buggy Rust one.

Is being an MEV searcher still worth it?

It can be, but the easy opportunities are gone and most new searchers don't make money at first. The obvious trades are taken by teams with fast infrastructure, so new searchers do better in niches: new protocols, long-tail tokens, other chains or order-flow sources. I went through the numbers and trade-offs in is MEV bot arbitrage still profitable in 2026?

Frequently asked questions

Is an MEV searcher the same as an MEV bot?

Mostly. The searcher is the person or team, and the MEV bot is the software they run. Flashbots uses "searcher" for the bot operator.

Do MEV searchers need to run a validator?

No. Searchers send bundles to builders, and builders deal with validators through MEV-Boost relays. You only need reliable node access and builder endpoints.

What programming languages do MEV searchers use?

Rust, Go and TypeScript are the most common for the bot, with Solidity (sometimes hand-optimized) for the on-chain executor contract.

Do searchers pay gas when their bundle fails?

Not when the bundle simply isn't included. Builders drop bundles that revert, unless you mark a transaction as allowed to revert.

How do MEV searchers find opportunities?

They keep a live copy of pool and protocol state, read new blocks, pending transactions and MEV-Share hints, and run strategies that search for profitable trades on every update.

Related guides

Being a searcher is mostly patient engineering: better data, better simulation, and honest review of every lost bundle. If you'd rather have a bot built for a specific strategy, that's what I do through custom MEV bot development at MEV DAO.

Ethereum MEV Bot Engineering: Atomic DEX Arbitrage, Aave V3 Liquidations & Scam Bot Detection

MEV DAO — Sun, 25 Oct 2026 13:53:49 +0000

Real Ethereum MEV bots—whether atomic DEX arbitrage contracts, JIT liquidity engines, or Aave V3 / Morpho Blue liquidation searchers—are built as custom Rust/Go mempool engines paired with gas-optimized Solidity/Yul executor contracts that pay 85%–98% of gross profit to block builders via block.coinbase.transfer. Meanwhile, thousands of developers lose ETH every month to fake YouTube "Remix IDE ChatGPT Solidity MEV bot" scams that hide obfuscated attacker payout addresses.

This technical reference from MEV DAO documents real searcher economics, custom MEV bot architecture, and open-source scam bytecode detection.

Architecture & Execution Checklist

[Local Node / Mempool Stream] ---> [Foundry Anvil eth_call Simulation]
                                          |
                                          v
[X-Flashbots-Signature Auth]  ---> [eth_sendBundle -> Block Builders]

Key technical invariants to verify before broadcasting:

Simulate state transitions at block.number + 1 using eth_callBundle or a pinned Foundry anvil --fork-url environment before signing live bundles.
Compute effective bundle gas price (effectiveGasPrice) across all transactions in the bundle, including 0-gas sponsored victim transactions, and ensure it exceeds the target block's tail gas price.
Multi-builder fan-out: Submit time-sensitive bundles simultaneously to relay.flashbots.net, Titan Builder, Beaverbuild, and Rsync Builder so you don't miss slots built by non-Flashbots relays.

Complete Technical Guides & Deep-Dive Runbooks in This Series

Below is the complete index of technical deep-dives, runnable Solidity/TypeScript templates, and step-by-step troubleshooting guides in this cluster:

How MEV Bots Make Money on Ethereum (and Who Keeps the Profit) — Deep-dive guide covering how do mev bots make money: Arbitrage, liquidations, backruns, sandwiches and the long tail: where MEV bot profit comes from, and why most of it ends up with block builders.
How Liquidation Bots Work on Aave (and Why They're Hard to Win) — Deep-dive guide covering aave liquidation bot: How Aave liquidation bots find positions below health factor 1, fund the repayment with flash loans, and compete on oracle updates, gas and builder bids.
Custom MEV Bot Development: What to Know Before You Hire — Deep-dive guide covering custom mev bot development: Planning custom MEV bot development? Learn what architecture specs to bring a developer, realistic costs and timelines, and how to spot scammer red flags.
Custom MEV Bot Development: Hire an Ethereum MEV Bot Developer — Deep-dive guide covering hire mev bot developer: How to hire an MEV bot developer: what custom work covers, what to bring to the brief, how projects are structured, pricing drivers and red flags.
MEV Bot for Sale? What's Real, What's a Scam, and What It Should Cost — Deep-dive guide covering mev bot for sale: Thinking of buying an MEV bot for sale? Learn which offers are Remix scams, real operating costs, and a 7-step checklist before you pay anyone.
MEV Bot Development Cost: Custom Pricing in 2026 — Deep-dive guide covering mev bot development cost: Real MEV bot development cost ranges in 2026: what custom Ethereum arbitrage, liquidation, and sniper bots cost to build, run, and maintain.
MEV Bot Ethereum GitHub: Best Open-Source Repos (2026) — Deep-dive guide covering mev bot ethereum github: Best open-source MEV bot Ethereum GitHub repos in 2026: Paradigm Artemis, Flashbots simple-arbitrage, mevdao-org reference code, and gaps.
Rust MEV Bot in 2026: The Alloy, Reth & Artemis Stack — Deep-dive guide covering rust mev bot: How to build a Rust MEV bot on Ethereum in 2026: migrating from ethers-rs to Alloy, embedded revm simulation, Reth execution extensions (ExEx), and Artemis.
How to Hire an MEV Bot Developer: Scope & Red Flags — Deep-dive guide covering flashbots searcher developer: Hiring a Flashbots searcher developer or MEV engineer? Scope custom Ethereum bots, spot Fiverr scams, and use our 7 technical interview questions.
How to Build a Polymarket Arbitrage Bot (Step by Step) — Deep-dive guide covering polymarket arbitrage bot: Step-by-step guide to building a Polymarket arbitrage bot in 2026: CTF Conditional Tokens, CLOB WebSockets, YES+NO<1 rebalancing, and execution.
Liquidation Bot Development: Compound, Morpho & Spark — Deep-dive guide covering liquidation bot development: Guide to Ethereum liquidation bot development in 2026: why Aave V3 is hyper-crowded and how searchers win liquidations on Morpho Blue, Compound V3, and Spark.
Is MEV Bot Arbitrage Still Profitable in 2026? — Deep-dive guide covering is mev bot profitable: Is an MEV bot still profitable in 2026? Real Ethereum MEV arbitrage profit margins, builder tip competition, and which niches actually make money today.
MEV Bot Meaning: 60 Terms Every Searcher Should Know — Deep-dive guide covering mev bot meaning: What is the meaning of an MEV bot? A complete 60-term Ethereum MEV searcher glossary covering Flashbots, PBS, Block 0 sniping, EIP-7702, and MEV protection.
Are MEV Bots Legal & Legit? Real Profits vs Scams (2026) — Deep-dive guide covering are mev bots legal: Are MEV bots legal and legit in 2026? We separate legal DEX arbitrage and liquidations from exploits, fake bot scams, and how to beat MEV bots.
How to Create a MEV Bot: From Mempool to First Bundle — Deep-dive guide covering how to create a mev bot: How to create a MEV bot on Ethereum in 2026: node setup, Solidity flash-swap executor, eth_callBundle simulation, and real arbitrage margins.

Open-Source Reference Repositories

eip-7702-delegation-checker-revoker — CLI to inspect 0xef0100 delegation designators and clear malicious EIP-7702 delegates.
compromised-wallet-sweeper-rescue — Atomic eth_sendBundle sponsor + asset transfer rescue template.
flashbots-bundle-simulator-anvil — Reproducible Foundry Anvil harness for bundle debugging.
solidity-mev-bot-scam-detector — Static analyzer to detect obfuscated YouTube/Remix MEV bot drainer contracts.
ethereum-sniper-bot-flashbots — Same-block Uniswap V2/V3 bundle execution and pre-trade honeypot simulation reference.
mev-arbitrage-and-liquidation-reference — Atomic two-pool arbitrage & Aave V3 liquidationCall executor with builder coinbase bribe math.

For production Ethereum sniping, compromised-wallet rescues, or custom MEV engineering, visit MEV DAO or start a 3-day trial.

Flashbots Bundles & Private RPC Engineering Guide: eth_sendBundle, mev_sendBundle & Anvil Fork Testing

MEV DAO — Sun, 25 Oct 2026 13:53:17 +0000

Whether you are building an atomic rescue script, a backrun searcher, or a private swap router, understanding the difference between user-facing private RPCs (rpc.flashbots.net, rpc.mevblocker.io) and searcher bundle relays (relay.flashbots.net via eth_sendBundle / mev_sendBundle) is essential.

This engineering guide synthesizes our MEV DAO benchmarks, troubleshooting checklists, and Foundry anvil --fork-url simulation workflows across every part of the Ethereum PBS (Proposer-Builder Separation) pipeline.

Architecture & Execution Checklist

[Local Node / Mempool Stream] ---> [Foundry Anvil eth_call Simulation]
                                          |
                                          v
[X-Flashbots-Signature Auth]  ---> [eth_sendBundle -> Block Builders]

Key technical invariants to verify before broadcasting:

Simulate state transitions at block.number + 1 using eth_callBundle or a pinned Foundry anvil --fork-url environment before signing live bundles.
Compute effective bundle gas price (effectiveGasPrice) across all transactions in the bundle, including 0-gas sponsored victim transactions, and ensure it exceeds the target block's tail gas price.
Multi-builder fan-out: Submit time-sensitive bundles simultaneously to relay.flashbots.net, Titan Builder, Beaverbuild, and Rsync Builder so you don't miss slots built by non-Flashbots relays.

Complete Technical Guides & Deep-Dive Runbooks in This Series

Below is the complete index of technical deep-dives, runnable Solidity/TypeScript templates, and step-by-step troubleshooting guides in this cluster:

Flashbots Bundles Explained: How to Send eth_sendBundle and Why Yours Isn't Landing — Deep-dive guide covering flashbots bundle: How Flashbots bundles work, how to send one with eth_sendBundle, and a checklist for the 5 reasons a bundle doesn't get included on Ethereum.
What Is a Sandwich Attack? How to Avoid Getting Sandwiched — Deep-dive guide covering how to avoid sandwich attacks: A worked example of a sandwich attack on a Uniswap swap, why your slippage setting is the attacker's budget, and five ways to stop getting sandwiched.
Flashbots Protect vs MEV Blocker: Which Private RPC Should You Use? — Deep-dive guide covering flashbots protect vs mev blocker: Flashbots Protect and MEV Blocker both hide your swaps from sandwich bots. How their endpoints, refunds, revert protection and privacy settings differ.
How to Test an MEV Bot on a Mainnet Fork With Anvil — Deep-dive guide covering anvil fork mainnet: Fork mainnet at a past block with Anvil, impersonate whales, control mining and replay real MEV opportunities to test your bot before risking real ETH.
Simulate a Flashbots Bundle With eth_callBundle (2026) — Deep-dive guide covering simulate flashbots bundle: How to simulate a Flashbots bundle with eth_callBundle on Ethereum: JSON-RPC payload format, coinbaseDiff profit checks, revert debugging, and Go/TS examples.
Front-Running Bot Crypto: Mempool, Gas Wars & Defenses — Deep-dive guide covering front running bot crypto: How a front running bot crypto searcher works on Ethereum: mempool monitoring, generalized front-runners, sandwich attacks, scams, and defenses.
Backrunning Bot on Ethereum: First MEV-Share Strategy — Deep-dive guide covering backrunning bot: Build a profitable backrunning bot on Ethereum in 2026: how atomic DEX backruns and mev-share backrun orderflow auctions work without front-running users.
What Is MEV Protection on Ethereum & Should You Use It? — Deep-dive guide covering what is mev protection: What is MEV protection on Ethereum, how does it stop sandwich attacks, does Uniswap have MEV protection, and when should snipers turn it on?

Open-Source Reference Repositories

eip-7702-delegation-checker-revoker — CLI to inspect 0xef0100 delegation designators and clear malicious EIP-7702 delegates.
compromised-wallet-sweeper-rescue — Atomic eth_sendBundle sponsor + asset transfer rescue template.
flashbots-bundle-simulator-anvil — Reproducible Foundry Anvil harness for bundle debugging.
solidity-mev-bot-scam-detector — Static analyzer to detect obfuscated YouTube/Remix MEV bot drainer contracts.
ethereum-sniper-bot-flashbots — Same-block Uniswap V2/V3 bundle execution and pre-trade honeypot simulation reference.
mev-arbitrage-and-liquidation-reference — Atomic two-pool arbitrage & Aave V3 liquidationCall executor with builder coinbase bribe math.

For production Ethereum sniping, compromised-wallet rescues, or custom MEV engineering, visit MEV DAO or start a 3-day trial.

Ethereum Sniper Bot Architecture: Block-0 Flashbots Execution, Honeypot Simulation & Fee Math

MEV DAO — Sun, 25 Oct 2026 13:44:51 +0000

Same-block (Block-0) token sniping on Ethereum requires monitoring pending liquidity additions (addLiquidityETH, enableTrading, or Uniswap V3/V4 pool initialization), simulating buy-and-sell execution paths locally via eth_call / debug_traceCall to filter out honeypots and dynamic tax traps, and submitting an atomic Flashbots bundle directly to block builders (relay.flashbots.net, Titan, Beaverbuild, Rsync).

This engineering handbook covers the full execution stack, anti-snipe contract defenses, and why MEV DAO uses flat-fee execution (€200/month with a 3-day trial) instead of charging a 1% per-trade tax on every buy and sell.

Architecture & Execution Checklist

[Local Node / Mempool Stream] ---> [Foundry Anvil eth_call Simulation]
                                          |
                                          v
[X-Flashbots-Signature Auth]  ---> [eth_sendBundle -> Block Builders]

Key technical invariants to verify before broadcasting:

Simulate state transitions at block.number + 1 using eth_callBundle or a pinned Foundry anvil --fork-url environment before signing live bundles.
Compute effective bundle gas price (effectiveGasPrice) across all transactions in the bundle, including 0-gas sponsored victim transactions, and ensure it exceeds the target block's tail gas price.
Multi-builder fan-out: Submit time-sensitive bundles simultaneously to relay.flashbots.net, Titan Builder, Beaverbuild, and Rsync Builder so you don't miss slots built by non-Flashbots relays.

Complete Technical Guides & Deep-Dive Runbooks in This Series

Below is the complete index of technical deep-dives, runnable Solidity/TypeScript templates, and step-by-step troubleshooting guides in this cluster:

How Ethereum Sniper Bots Work: Same-Block Buys With Flashbots (and the Real Risks) — Deep-dive guide covering ethereum sniper bot: How crypto sniper bots buy new tokens in the same block liquidity is added: mempool watching, Flashbots bundles, bribes, and the honeypots that catch snipers.
Honeypot Tokens: How to Spot One Before You Buy — Deep-dive guide covering how to detect honeypot token: How honeypot tokens block sells with blacklists, 100% taxes and hidden owner switches, and the checks I run before buying a new token on Ethereum.
Anti-Snipe Token Launches: Taxes, Blacklists and Trading Delays — Deep-dive guide covering anti sniper bot token launch: Launch taxes, first-block blacklists, max wallet, cooldowns and Uniswap v4 hooks: how anti-snipe token launches work and how sniper bots deal with each.
Ethereum Sniper Bot: Flashbots Same-Block Sniping on Uniswap — Deep-dive guide covering flashbots sniper bot: How a Flashbots sniper bot buys a new Uniswap token in the same block: v2/v3/v4 launch patterns, Block-0 vs Block-1, bribes, settings and the risks.
Crypto Sniping Group on Telegram: MEV DAO Premium Sniping Group — Deep-dive guide covering crypto sniping group telegram: How to judge a crypto sniping group on Telegram: free calls vs real sniping, pump-and-dumps, fake Safeguard bots, and a pre-trade checklist.
Banana Gun Alternatives for Ethereum: Flat-Fee Sniping vs 1% Per Trade — Deep-dive guide covering banana gun alternatives for ethereum flat fee sniping vs 1 per trade: Banana Gun alternatives on Ethereum compared: Maestro, Sigma, flat-fee and custom bots, by fees, key custody and how they land snipes.
Best ETH Sniper Bot in 2026: Fees, Speed & Key Custody — Deep-dive guide covering best eth sniper bot: Compare the best ETH sniper bot options in 2026 across fees, speed, and key custody: Banana Gun, Maestro, open-source scripts, and MEV DAO.
Banana Gun vs Maestro vs MEV DAO: ETH Sniping Compared — Deep-dive guide covering banana gun vs maestro: Banana Gun vs Maestro vs MEV DAO compared on Ethereum mainnet: 1% per-trade fees vs flat-fee sniping, block-0 bundle speed, router safety, and key custody.
Banana Gun Fees vs Telegram Sniper Bot Fees (2026) — Deep-dive guide covering banana gun fees: Banana Gun fees vs Maestro fees and other Telegram sniper bot fees compared: what 1% per trade really costs on Ethereum vs flat-fee Flashbots sniping.
Are Telegram Trading Bots Safe? Key Custody & Hacks — Deep-dive guide covering are telegram trading bots safe: Are Telegram trading bots safe in 2026? How key custody works in Banana Gun, Maestro, and Unibot, past router exploits, and how to snipe without losing keys.
Block 0 Sniper Explained: Same-Block Token Launch Buys — Deep-dive guide covering block 0 sniper: How a block 0 sniper works on Ethereum: bundling same-block buys behind addLiquidity or enableTrading via Flashbots, builder tips, and anti-snipe defenses.
Meme Coin Sniper Bot on Ethereum: Setup & Risks — Deep-dive guide covering meme coin sniper bot ethereum: How to configure a meme coin sniper bot on Ethereum in 2026: Flashbots block-0 settings, max-wallet limits, honeypot simulation, and avoiding rug pulls.
Is a Sniper Bot Worth It? Are Sniper Bots Profitable — Deep-dive guide covering is a sniper bot worth it: Is a sniper bot worth it on Ethereum in 2026? See on-chain profitability data, why 74% of blind snipes lose, and how winning searchers filter.
Ethereum Sniper Bot GitHub: Open-Source vs Paid Bots — Deep-dive guide covering ethereum sniper bot github: Reviewing Ethereum sniper bot GitHub repos vs paid bots in 2026: Uniswap V2/V3 sniper code, what free scripts miss, and how to spot malicious GitHub drainers.
Crypto Sniping Group Telegram: Legit vs Dump Groups — Deep-dive guide covering ethereum calls telegram group: Joining an Ethereum calls Telegram group or crypto sniping group? Spot exit-liquidity pump rooms vs verified contract audits and Flashbots snipes.
Mempool Sniper Bot: Pending-Tx Snipes vs Private Bundles — Deep-dive guide covering mempool sniper bot: How an Ethereum mempool sniper bot works in 2026: watching pending liquidity transactions vs. private Flashbots bundles, and how to win Block 0 launches.
ETH Copy Trading Bot: How Wallet-Tracking Snipes Work — Deep-dive guide covering eth copy trading bot: How an ETH copy trading bot works on Ethereum in 2026: mempool vs. confirmed-block wallet tracking, avoiding copy-trade bait traps, and Flashbots execution.
Uniswap V4 Sniper: Hooks & What Changes for Launch Bots — Deep-dive guide covering uniswap v4 sniper: How a Uniswap V4 sniper bot works on Ethereum in 2026: PoolManager singleton architecture, flash accounting, beforeSwap hooks, and dynamic launch-tax evasion.
Anti-Snipe Token Tax & Blacklist Detection for Snipers — Deep-dive guide covering anti snipe token: Run anti snipe token and token tax checker diagnostics in 60 seconds by inspecting Solidity modifiers, dynamic fee hooks, and blacklist mappings.
Sniper Bot Gas Settings: Priority Fees & Builder Tips — Deep-dive guide covering sniper bot gas settings: Master sniper bot gas settings and priority fee sniping on Ethereum: EIP-1559 maxPriorityFeePerGas, block.coinbase builder bribes, and bundles.
How to Use Banana Gun on Ethereum vs Flat-Fee Sniping — Deep-dive guide covering how to use banana gun: How to use Banana Gun on Ethereum in 2026: how it works, 1% auto-snipe fee math, builder bribes, and when flat-fee Flashbots sniping costs less.

Open-Source Reference Repositories

eip-7702-delegation-checker-revoker — CLI to inspect 0xef0100 delegation designators and clear malicious EIP-7702 delegates.
compromised-wallet-sweeper-rescue — Atomic eth_sendBundle sponsor + asset transfer rescue template.
flashbots-bundle-simulator-anvil — Reproducible Foundry Anvil harness for bundle debugging.
solidity-mev-bot-scam-detector — Static analyzer to detect obfuscated YouTube/Remix MEV bot drainer contracts.
ethereum-sniper-bot-flashbots — Same-block Uniswap V2/V3 bundle execution and pre-trade honeypot simulation reference.
mev-arbitrage-and-liquidation-reference — Atomic two-pool arbitrage & Aave V3 liquidationCall executor with builder coinbase bribe math.

For production Ethereum sniping, compromised-wallet rescues, or custom MEV engineering, visit MEV DAO or start a 3-day trial.

Ethereum Compromised Wallet & EIP-7702 Sweeper Rescue Handbook (2026 Reference)

MEV DAO — Sun, 25 Oct 2026 13:44:36 +0000

When an Ethereum private key or seed phrase leaks, automated sweeper bots monitor the address and drain any incoming ETH within milliseconds—long before you can broadcast a standard transfer or revoke transaction. Since the May 2025 Pectra upgrade (EIP-7702, transaction type 0x04), attackers also attach persistent 0xef0100 || delegate_address bytecode directly to externally owned accounts (EOAs), executing malicious receive() hooks inside the funding call itself.

This technical reference compiles the complete atomic Flashbots bundle (eth_sendBundle) rescue architecture, EIP-7702 delegation clearing workflow, and protocol-specific recovery runbooks maintained by MEV DAO.

Architecture & Execution Checklist

[Local Node / Mempool Stream] ---> [Foundry Anvil eth_call Simulation]
                                          |
                                          v
[X-Flashbots-Signature Auth]  ---> [eth_sendBundle -> Block Builders]

Key technical invariants to verify before broadcasting:

Simulate state transitions at block.number + 1 using eth_callBundle or a pinned Foundry anvil --fork-url environment before signing live bundles.
Compute effective bundle gas price (effectiveGasPrice) across all transactions in the bundle, including 0-gas sponsored victim transactions, and ensure it exceeds the target block's tail gas price.
Multi-builder fan-out: Submit time-sensitive bundles simultaneously to relay.flashbots.net, Titan Builder, Beaverbuild, and Rsync Builder so you don't miss slots built by non-Flashbots relays.

Complete Technical Guides & Deep-Dive Runbooks in This Series

Below is the complete index of technical deep-dives, runnable Solidity/TypeScript templates, and step-by-step troubleshooting guides in this cluster:

How to Rescue Tokens From a Compromised Wallet With a Sweeper Bot (Flashbots Guide) — Deep-dive guide covering rescue tokens compromised wallet: A sweeper bot steals every bit of ETH you send for gas. Here's how Flashbots bundles let you rescue tokens and NFTs from a compromised wallet anyway.
How to Check and Remove a Malicious EIP-7702 Delegation — Deep-dive guide covering remove eip-7702 delegation: EIP-7702 sweeper on your wallet? How to see the delegation with eth_getCode, clear it to address zero, and rescue funds before the attacker re-delegates.
How to Revoke Token Approvals and Permit2 Signatures — Deep-dive guide covering revoke token approvals: Unlimited approvals and signed Permit2 permits drain most wallets. How to find and revoke them, use Permit2 lockdown, and when revoking won't help.
Rescue Tokens From a Compromised Wallet: Sweeper Bot Rescue Service — Deep-dive guide covering rescue tokens from compromised wallet: Your options for a sweeper bot rescue: DIY Flashbots bundles, the Flashbots Whitehat Hotline, rescue tools, and how to spot fake recovery services.
How to Claim an Airdrop From a Compromised Wallet (Before the Sweeper Does) — Deep-dive guide covering how to claim an airdrop from a compromised wallet before the sweeper does: How to claim an airdrop from a compromised wallet with a Flashbots bundle: fund gas, claim and transfer in one block before the sweeper bot.
The YouTube MEV Bot Scam: How the "Remix Contract" Drains Your ETH — Deep-dive guide covering youtube mev bot scam: How the YouTube MEV bot scam works: how the fake Remix bot contract hides the attacker address, real on-chain losses, red flags, and recovery steps.
Wallet Drained? What to Do in the First Hour (Ethereum Checklist) — Deep-dive guide covering wallet drained: Wallet drained? A first-hour Ethereum checklist: stop the bleeding, tell a key leak from an approval drain, move to a new seed, rescue leftovers, report it.
Crypto Recovery Scams: How to Spot Fake "Wallet Recovery" Services — Deep-dive guide covering crypto recovery scam: Crypto recovery scams took $1.4B in 2025 per the FBI. How fake recovery services find drain victims, the red flags, and what can actually be recovered.
Unstake From a Compromised Wallet: Rescue Locked Tokens — Deep-dive guide covering unstake from compromised wallet: How to unstake from a compromised wallet on Ethereum: rescue staked ETH, Lido/EigenLayer positions, and vesting tokens before a sweeper bot steals them.
EIP 7702 Rescue vs Flashbots Bundles: Saving Tokens — Deep-dive guide covering eip 7702 rescue: EIP 7702 rescue vs classic Flashbots bundles on Ethereum: how sweep7702 atomic batching defeats aggressive sweeper bots and rescues compromised wallets.
Recover NFT From a Hacked Wallet: Sweeper Bot Guide — Deep-dive guide covering recover nft from hacked wallet: How to recover an NFT from a hacked wallet on Ethereum when a sweeper bot is watching: atomic Flashbots ERC-721 and ERC-1155 rescue bundles explained.
Private Key Leaked on Ethereum? Save What's Left — Deep-dive guide covering private key leaked ethereum: Private key leaked on Ethereum or GitHub? See how secret-scanner sweeper bots drain .env keys in seconds and how to rescue tokens via Flashbots.
Sweeper Bot on Trust Wallet, Ledger & Rabby: Rescue Steps — Deep-dive guide covering sweeper bot trust wallet: Dealing with a sweeper bot on Trust Wallet, Ledger, or Rabby? How wallet-specific seed derivation works and how to export your key to run a Flashbots rescue.
Compromised Wallet Checker: Is Your Ethereum Key Leaked? — Deep-dive guide covering compromised wallet checker: Use this 5-step Ethereum compromised wallet checker to tell whether your private key is leaked, you have an EIP-7702 sweeper, or a token approval drained you.
Rescue ENS & Vesting Contracts From a Compromised Wallet — Deep-dive guide covering rescue ens compromised wallet: How to rescue ENS names (.eth) and token vesting contracts (Sablier, Team Finance, Unicrypt, custom cliffs) from a compromised Ethereum wallet via Flashbots.
Wallet Drainer Approvals: Permit, SetApprovalForAll & 7702 — Deep-dive guide covering wallet drainer approvals: How wallet drainer approvals steal ERC-20s, NFTs, and ETH via EIP-2612 Permit, Permit2, SetApprovalForAll, and EIP-7702—and how to revoke them.
Sweeper Bot Rescue Service: Live Token Rescue Case Study — Deep-dive guide covering sweeper bot rescue service: Case study: how our sweeper bot rescue service used a private Flashbots rescue bundle to save $42,800 in tokens from an active Ethereum sweeper.

Open-Source Reference Repositories

eip-7702-delegation-checker-revoker — CLI to inspect 0xef0100 delegation designators and clear malicious EIP-7702 delegates.
compromised-wallet-sweeper-rescue — Atomic eth_sendBundle sponsor + asset transfer rescue template.
flashbots-bundle-simulator-anvil — Reproducible Foundry Anvil harness for bundle debugging.
solidity-mev-bot-scam-detector — Static analyzer to detect obfuscated YouTube/Remix MEV bot drainer contracts.
ethereum-sniper-bot-flashbots — Same-block Uniswap V2/V3 bundle execution and pre-trade honeypot simulation reference.
mev-arbitrage-and-liquidation-reference — Atomic two-pool arbitrage & Aave V3 liquidationCall executor with builder coinbase bribe math.

For production Ethereum sniping, compromised-wallet rescues, or custom MEV engineering, visit MEV DAO or start a 3-day trial.

How to Test an MEV Bot on a Mainnet Fork With Anvil

MEV DAO — Thu, 22 Oct 2026 21:42:37 +0000

The most expensive way to test an MEV bot is on mainnet with real money. A bug in the swap math, a wrong token decimal, an approval missing in the contract, and the "test" costs a few hundred dollars in gas or a lot more in bad trades.

The cheap way is a mainnet fork. You run a local copy of Ethereum that starts from the real chain state at a block you choose. Every pool, every token balance and every contract is there, but the ETH is fake and nothing you do touches the real chain. Foundry's Anvil makes this really easy.

This is the setup I'd recommend for testing any bot: arbitrage, liquidation, sniping, anything.

Install Foundry and start a fork

If you don't have Foundry yet, install it from getfoundry.sh. Then you need an archive-capable RPC URL. A free tier from a node provider works to start, or your own node if you have one.

Start the fork:

anvil --fork-url $ETH_RPC_URL --fork-block-number 21000000

That gives you a local node on http://127.0.0.1:8545 with mainnet state as of that block. Anvil fetches the state it needs from your RPC as you go and caches it, so the first calls are slower than the rest.

Always pin the block number. If you don't, you fork from the latest block, and every test run starts from a different state. Pinned blocks make your tests reproducible, and Anvil can reuse its cache. The forking docs cover the options.

Don't use the default accounts with real keys

Anvil starts with ten accounts, each with 10,000 fake ETH, from a well-known test mnemonic. Those keys are public. Everyone has them. If you ever use one of them on a real network by accident, whatever's in it gets taken immediately.

The Anvil docs warn about this. Use your own mnemonic for forks:

anvil --fork-url $ETH_RPC_URL --fork-block-number 21000000 \
  --mnemonic "your own test mnemonic that is never used on mainnet"

And keep your real bot keys out of the test environment completely.

The custom methods that make forks useful

Anvil has a set of custom RPC methods beyond normal Ethereum JSON-RPC. These are the ones I use most for bots.

Impersonate any address

You can send transactions as any address without its private key. That's how you get tokens for testing, by impersonating a whale, or how you replay a transaction from a real user.

cast rpc anvil_impersonateAccount $WHALE
cast send $USDC "transfer(address,uint256)" $MY_BOT 1000000000 \
  --from $WHALE --unlocked
cast rpc anvil_stopImpersonatingAccount $WHALE

Or start Anvil with --auto-impersonate to allow it for every address.

Set balances, code and storage directly

cast rpc anvil_setBalance $MY_BOT 0xDE0B6B3A7640000   # 1 ETH
cast rpc anvil_setCode $ADDRESS $BYTECODE
cast rpc anvil_setStorageAt $ADDRESS $SLOT $VALUE

anvil_setCode is great for swapping a contract for a modified version, for example a mock oracle you can move whenever you want. That's how you test a liquidation bot: change the price, see if your bot finds the position and closes it.

Control mining

This is the important one for MEV. By default, Anvil mines a block for every transaction instantly. That's useless if your bot needs to react to pending transactions. So turn it off:

anvil --fork-url $ETH_RPC_URL --fork-block-number 21000000 --no-mining

Now transactions sit in Anvil's pool until you mine. You can see them with txpool_content, the same way your bot would watch a mempool, and then mine when you're ready:

cast rpc txpool_content
cast rpc anvil_mine

This lets you simulate the real flow: a "victim" transaction arrives in the pool, your bot sees it, builds its response, and you mine one block to see the result. You can also use --block-time 12 for regular 12-second blocks.

Snapshots

cast rpc evm_snapshot     # returns an id
# ... run your test ...
cast rpc evm_revert $SNAPSHOT_ID   # back to the snapshot

Snapshot before each test case and revert afterwards. You can run the same scenario a hundred times without restarting Anvil or fetching state again.

Traces

Start Anvil with --print-traces and you'll see the full call trace for every transaction in the terminal. When your bot's transaction reverts with a useless error, this tells you which call failed and why.

Replay a real opportunity

This is where forks really help. Find a real MEV transaction on Etherscan, a liquidation or an arbitrage that another bot won. Note its block number, then:

Fork at the block before it: --fork-block-number <block - 1>.
Disable mining.
Send the transactions that came before it in that block (impersonating their senders), so the state is the same as when the opportunity appeared.
Run your bot and see if it finds the same opportunity, and how much it would have made.
Compare your gas usage to the winner's.

You can also inspect any historical transaction directly with cast run:

cast run $TX_HASH --rpc-url $ETH_RPC_URL

That replays the transaction locally and prints its trace, which is great for understanding what a competitor's contract actually does.

Do this for twenty historical opportunities and you'll learn more about your strategy than from a month of reading.

Forge tests for the contract

For the on-chain part of the bot, write Foundry tests that run against a fork:

function setUp() public {
    vm.createSelectFork(vm.envString("ETH_RPC_URL"), 21_000_000);
    deal(USDC, address(bot), 1_000e6);
}

function test_arbitrageIsProfitable() public {
    uint256 before = IERC20(WETH).balanceOf(address(bot));
    bot.execute(route);
    assertGt(IERC20(WETH).balanceOf(address(bot)), before);
}

deal from forge-std sets a token balance for you, so you don't need to find a whale. Add tests for the failure cases too: what happens if the price moved, if the pool is empty, if the token takes a fee. Those are the ones that lose real money.

What a fork can't tell you

A fork is great for checking that your logic and contracts work. It doesn't tell you whether you'll win on mainnet:

No competition. On your fork, you're the only bot. On mainnet, ten others see the same opportunity.
No builder auction. Your bundle doesn't compete for inclusion. To learn how that part works, read Flashbots bundles explained.
No latency. Real bots fail because they're 200ms too slow. A fork won't show that.
Your RPC is the bottleneck. Forks fetch state on demand, so heavy tests can hit rate limits on free RPC plans.

So use the fork to make sure the bot is correct, then go live with small size to find out if it's competitive.

My testing checklist before going live

[ ] Contract tests pass on a fork, including failure cases
[ ] Bot finds and handles at least ten replayed historical opportunities
[ ] Gas usage is close to (or lower than) the bots that won those opportunities
[ ] Profit calculation includes gas and the builder payment
[ ] No private key from the test setup is used anywhere real
[ ] Kill switch and max position size are tested

If you're building a liquidation bot, I wrote about the strategy side in how liquidation bots work on Aave. For arbitrage, start with how to build a profitable MEV arbitrage bot.

And if you want me to build or review a bot for you, message me on Telegram. The ready-made MEVDAO tools, the Sniper Bot, Sniping Group and Token Rescue Bot, are on the features page. Join the MEV Secrets email list right below for weekly tips.

Originally published on the MEV DAO blog.

Flashbots Bundles Explained: How to Send eth_sendBundle and Why Yours Isn't Landing

MEV DAO — Thu, 22 Oct 2026 21:42:27 +0000

Almost every MEV bot on Ethereum, whether it's an arbitrage bot, a sniper or a rescue script, ends up sending bundles. And almost every developer who sends their first bundle has the same experience: the request returns a bundle hash, everything looks fine, and nothing ever shows up on-chain.

This guide covers what a bundle is, how to send one properly, and a practical checklist for figuring out why yours isn't landing.

What a bundle is

A bundle is an ordered list of signed transactions that you send privately to a block builder instead of broadcasting them to the public mempool. The builder will include the whole bundle, in exactly that order, in one block, or it won't include any of it.

Flashbots popularized this. Their Quick Start describes the flow: searchers send bundles to builders, builders simulate them to make sure they don't revert, build full blocks, and deliver those blocks to validators through mev-boost relays. Validators running mev-boost pick the most valuable block offered to them.

Three properties make bundles so useful:

Atomic. All of the transactions land together or none do. That's what makes things like sponsored wallet rescues possible, where one transaction funds an account and the next ones spend that ETH in the same block. I covered that in how to rescue tokens from a compromised wallet with a sweeper bot.
Ordered. You control the sequence, which is how backruns and same-block snipes work.
Private and revert-protected. Bundles aren't visible in the public mempool before inclusion, and failed bundles don't land on-chain, so you don't pay gas for a trade that didn't work.

How to send a bundle

The endpoints

Flashbots has two main endpoints on mainnet, and mixing them up is a common first mistake. Per the Flashbots guide on sending transactions and bundles:

rpc.flashbots.net is Flashbots Protect, a drop-in wallet RPC for regular users. It takes normal eth_sendRawTransaction calls. It does not take bundles.
relay.flashbots.net is for searchers and bots. It accepts bundles and private transactions through Flashbots-specific methods. It does not support regular Ethereum RPC methods, so you still need a normal node for nonces, gas estimates and receipts.

For testing, there's also a Sepolia relay at relay-sepolia.flashbots.net.

The signing key

Every request to the relay is signed with an ECDSA key that identifies you as a searcher. The signature goes in the X-Flashbots-Signature header as address:signature, where the signature is over the JSON body. This key doesn't hold funds and shouldn't be your trading key. Flashbots uses it to build a reputation for you over time, and higher-reputation searchers get better access when the network is congested. So reuse the same identity key instead of generating a new one every run.

The eth_sendBundle request

The JSON-RPC docs describe the payload. The core fields are:

txs: an array of signed raw transactions, in order.
blockNumber: the hex block number this bundle is valid for.
Optional: minTimestamp and maxTimestamp, revertingTxHashes (transactions that are allowed to revert without killing the bundle), replacementUuid (to replace or cancel a bundle later) and builders (a list of other registered builders that should also receive the bundle).

The same docs list limits of 100 transactions and 300,000 bytes per bundle.

A minimal request body looks like this:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_sendBundle",
  "params": [
    {
      "txs": ["0x02f8...", "0x02f8..."],
      "blockNumber": "0x1499a2c"
    }
  ]
}

If you're in JavaScript, the official ethers-provider-flashbots-bundle library handles signing and gives you simulate() and sendBundle() helpers. Note that its README says it's designed for an existing ethers.js v5 installation.

Target the next block, and resubmit every block

A bundle is valid for one block. If you target block N+1 and it isn't included there, it's gone. The library README is explicit that if your bundle should be valid until it's mined, you need to resubmit for every block, and the target should always be a future block, never the current one.

Resubmitting each block is also your chance to re-check the opportunity, update fees to the new base fee, and re-sign with the correct nonce.

mev_sendBundle and MEV-Share

Flashbots also has mev_sendBundle, a newer format that supports MEV-Share, where you can backrun user transactions that are only partially revealed through hints. Their MEV-Share searcher writeup explains the strategies. If you're just starting, eth_sendBundle is the simple option and is what most examples use.

Always simulate first

Before you send anything, simulate it with eth_callBundle (the library's simulate() method). The simulation runs your signed transactions in order on top of a given block and returns gas used, fees paid and coinbase payments for each transaction.

This catches the majority of problems before they cost you an opportunity. The Flashbots troubleshooting guide recommends simulating, logging the results, and keeping a record of every bundle and its signed transactions, because a bundle that fails leaves no trace on Etherscan to debug from.

Why your bundle isn't being included: the checklist

The Flashbots troubleshooting guide lists five reasons a bundle doesn't land, in the order you should check them.

1. A transaction in the bundle reverts

If any transaction reverts (and isn't listed in revertingTxHashes), the whole bundle is dropped. Common causes: wrong nonce, insufficient balance, a stale price that makes your slippage check fail, a deadline that's already passed, or a token transfer that the token contract blocks.

Fix: simulate against the block you're targeting and read the per-transaction results.

2. You're not paying enough for the blockspace

Your transactions must pay at least the base fee, or the block would be invalid. Beyond that, the builder compares what your bundle pays with what it would earn from other transactions using the same gas. The docs give a simple example: if your bundle pays a 1 gwei priority fee but the cheapest transaction in the block pays 2 gwei, the builder is better off leaving your bundle out.

What matters is the effective priority fee: everything the bundle pays the builder (priority fees plus any direct ETH transfers to the block's coinbase), divided by the gas it uses.

Fix: pay more, or use less gas for the same result. Gas optimization is a bid in disguise.

3. A competitor bid more for the same opportunity

Builders roughly simulate each bundle at the top of the block, sort by effective priority fee, and then add bundles one by one as long as they still work. If another bundle that touches the same state goes first, yours may revert, collide on a nonce, or pay less than it did in isolation. Then it's dropped.

The auction is blind, so you can't see competing bids in advance. You can look afterward: the library's getConflictingBundle() helper re-simulates the target block to find which bundle conflicted with yours and how much it paid.

Fix: compare your effective priority fee with the winner's. If you're consistently outbid, the opportunity may be too competitive. In that case, a less crowded strategy beats a higher bid. My take on that is in how to build a profitable MEV arbitrage bot.

4. Your bundle arrived too late

Your bundle has to reach the builder, get simulated, go into a block, and get through a relay to the validator, all before the slot. The troubleshooting guide notes each of those steps can take around 1 to 2 seconds. There's also a window where your node still thinks the chain is at block X while the rest of the network has already seen X+1, so you're targeting a block that's already been built.

Fix: cut your own processing time, use low-latency, well-synced nodes, and send your bundle as early as you can in the slot.

5. The validator isn't running mev-boost

mev-boost is opt-in. If the validator for a slot doesn't run it, or isn't connected to a relay your builder submits to, no bundle will land in that block. Research on the builder market, such as this 2024 study, found that the large majority of blocks since the Merge come through mev-boost, but not all of them.

Fix: nothing to fix. Resubmit for the next block.

Send to more than one builder

Flashbots is one builder among several. The builder market is concentrated in a handful of players, and their share changes over time. You can see current relay and builder shares on relayscan.io and slot-level data on mevboost.pics.

If you only send to one builder, you only get into blocks that builder wins. You can use the builders field to have Flashbots share your bundle with other registered builders, and many builders run their own bundle endpoints. Check each builder's documentation for its exact API before relying on it.

Get refunds when you overpay

Eligible bundles that land in blocks built by BuilderNet (the block-building network Flashbots operates together with partners) can earn refunds of part of what they paid, based on how much they contributed to the block's value. The rules are in the BuilderNet refunds documentation. The Flashbots RPC docs include flashbots_getFeeRefundsByRecipient and related methods so you can see what you've earned, and flashbots_setFeeRefundRecipient to send refunds to a different address. It's worth checking, especially if you bid aggressively.

The short version

Use relay.flashbots.net for bundles, with a stable identity key.
Simulate with eth_callBundle every time.
Target the next block and resubmit every block.
Check the five failure reasons in order: reverts, fee too low, outbid, too late, no mev-boost.
Send to multiple builders.

If you'd rather not build all of this yourself, the MEVDAO Sniper Bot and Token Rescue Bot already handle bundle building, simulation and submission for sniping and wallet rescues. They're included in the MEVDAO subscription with a 3-day free trial.

For more guides like this, join the free MEV Secrets email list below. And if you want a custom MEV bot built, message me on Telegram.

Originally published on the MEV DAO blog.