How Flash Loan Arbitrage Works: Atomic Trades Without Risk
We often encounter situations where the price gap for WETH between Uniswap v3 and SushiSwap is 0.3%. On $500k borrowed via an Aave flash loan, that's $1,500 before fees. After paying the 0.09% flash loan fee ($450) and gas ($20–50 on Ethereum mainnet), net profit is around $1,000 per atomic transaction that either completes fully or reverts without capital loss. This atomicity is what makes smart contract arbitrage fundamentally different from classic arbitrage, where you can lose assets.
Development cost for a basic bot starts at $3,000 and can yield monthly savings of over $500 in gas fees, with typical ROI within 2 months. Our team has over five years of experience developing such systems. We have delivered more than 15 projects across various networks and DEXes, ensuring reliability and performance for every solution. Flash loan
Contact us to evaluate your project — we will prepare a proposal tailored to your strategy. Get a consultation and learn how we can accelerate your time-to-market.
Why Classic Arbitrage Doesn't Work for Flash Loans
Gas Auction and MEV Competition — Flash Loan Development
On the public Ethereum mempool, you are not the only one seeing the price gap. MEV bots scan the mempool and frontrun profitable transactions — they set a higher gas price, their transaction lands in the block first, the gap closes, your transaction reverts, and gas is lost.
Solution: send via Flashbots eth_sendBundle. The transaction goes directly to the validator, bypassing the public mempool. No frontrunning, no gas auction with bots. Flashbots take a percentage of the profit (miner tip), but it is predictable. This method provides superior MEV protection compared to public mempool submission, which is 100 times more likely to be frontrun.
Another option is MEV Blocker or BuilderNet for broader coverage. On L2s (Arbitrum, Base), the centralized sequencer reduces MEV risks but does not eliminate them entirely — private mempools also exist there.
Sandwich Protection in the Executor Contract
The contract receives a flash loan, buys WETH on DEX A, and must sell on DEX B. Between these two swaps there is a window — in theory, a sandwich bot could intervene if the transaction is multi-step. In practice, for flash loan arbitrage, everything executes in a single transaction, so external sandwich is impossible. However, amountOutMinimum on each swap is mandatory — otherwise a sandwich within the same block via other transactions could shift the price slot of the pool.
Revert and Gas Loss
A flash loan reverts if the debt plus fee is not repaid in the same transaction. If the arbitrage logic fails, all gas is burned. On Ethereum mainnet, a failed transaction costs $10–50. With high attempt frequency, this accumulates. Gas savings using Flashbots can reach 20% due to the bundle mechanism. Our pre-simulation approach reduces failed transaction costs by 80% compared to naive submission, thanks to gas optimization techniques.
Optimization: pre-simulation before sending. eth_call with full calldata — the contract is simulated for free, and we see revert/success before spending real gas. In a production bot, this is a mandatory step: simulate → if success → send bundle.
How a Flash Loan Arbitrage Bot Processes Price Gaps
Components
Price scanner — an off-chain service in TypeScript/viem, subscribed to Swap events of all tracked pools via WebSocket. On each event, it recalculates the spot price and compares it with the pair matrix. When a gap exceeds the threshold (considering all fees), it signals for arbitrage.
Profit calculator — precise PnL calculation including: flash loan fee (Aave v3: 0.09%, Balancer: 0%), current block gas (via eth_gasPrice + EIP-1559 base fee), slippage for both swaps (via Quoter), and multi-sign tip for Flashbots. If the result is negative, we do not send.
Executor contract — Solidity contract implementing IFlashLoanSimpleReceiver (Aave) or IFlashLoanRecipient (Balancer). Inside executeOperation / receiveFlashLoan — logic of two swaps and debt repayment.
| Flash loan provider | Fee | Limit | Notes |
|---|---|---|---|
| Aave v3 | 0.09% | Pool liquidity | ERC-3156 compatible |
| Balancer v2 | 0% | Vault liquidity | No fee until transaction end |
| Uniswap v3 | 0.05–1% | Pool liquidity | Flash swap, token returned to pool |
| dYdX | 0% | Limited assets | Solo Margin, harder to integrate |
Executor: What's Inside
function executeOperation(
address asset,
uint256 amount,
uint256 premium,
address initiator,
bytes calldata params
) external returns (bool) {
require(msg.sender == address(POOL), "Caller not Aave Pool");
require(initiator == address(this), "Initiator mismatch");
(address dexA, address dexB, uint256 amountOutMin) =
abi.decode(params, (address, address, uint256));
// swap on DEX A
uint256 received = _swapExact(dexA, asset, targetToken, amount, 0);
// swap back on DEX B
uint256 finalAmount = _swapExact(dexB, targetToken, asset, received, amountOutMin);
uint256 totalDebt = amount + premium;
require(finalAmount >= totalDebt, "Unprofitable");
IERC20(asset).approve(address(POOL), totalDebt);
return true;
}
Checks on msg.sender and initiator are mandatory. Without them, anyone could call executeOperation directly with arbitrary params and drain tokens that the contract holds in approve.
Monitoring and Maintenance
An arbitrage bot is not a set-and-forget system. Gaps narrow as competition grows. A dashboard is needed: attempts per hour, success rate, average profit, gas cost. If the success rate drops below 5%, it's time to reconsider thresholds or add new pairs. This automated arbitrage monitoring ensures consistent profitability.
| Submission method | Success probability | Gas burn risk |
|---|---|---|
| Public mempool | Low (often frontrun) | High |
| Flashbots bundle | High (95%+) | Low |
How to Protect the Bot from MEV Attacks
Using a private mempool is the main defense. On Ethereum we use Flashbots bundles that go directly to the validator. This significantly reduces frontrunning risk. On L2s we use private RPCs from the sequencer. Additionally, we implement checks in the contract to prevent replay (nonce) and minimize execution time.
Comparison: Flashbots bundle outperforms public submission by approximately 100 times in the chance of successful block inclusion, providing robust MEV protection for your crypto bot.
Process of Work
- Analytics (2–3 days). Define target pairs, chains, DEXes. Analyze historical gap data via The Graph or Dune Analytics — estimate realistic profitability.
- Development (1–2 weeks). Executor contract + off-chain scanner + Flashbots integration. Fork tests on historical blocks with real gaps.
- Testing. Run on testnet (Sepolia) with test flash loans. Then mainnet in simulation-only mode (only
eth_call, no submission) — one week of data collection and threshold calibration. - Production deployment. Executor via Gnosis Safe (owner functions protected). Monitoring scripts and auto-restart via PM2.
What's Included in the Result
Example: basic bot configuration
For a single WETH-USDC pair on Ethereum using Aave v3 and Uniswap v3/SushiSwap. The bot includes a scanner for 2 pools, an executor with `amountOutMin` check, Flashbots bundle, and a Grafana dashboard. Development time is 10 days.- Executable smart contract in Solidity with full verification (Solidity bot).
- Off-chain price scanner configured for your pairs.
- Monitoring dashboard configuration (attempts, profit, gas).
- Deployment and operation documentation.
- Team training (1 hour online).
- Support guarantee for the first 3 months of operation.
Time Estimates
A basic bot for one chain and two DEXes takes 1–2 weeks. A multi-chain system with a custom price graph and Flashbots integration takes 3–4 weeks. This multi-chain DeFi arbitrage system can handle AMM trading pairs across different networks.
Pricing is determined after analyzing the technical specifications. Contact us to evaluate your project. Get a consultation — we will answer all your questions and prepare a proposal.