Imagine: a user wants to swap ETH for USDC, but every trade on Uniswap moves the price and instantly attracts MEV bots. Front-running and sandwich attacks eat up to 2% of the amount. A batch execution system in the style of CoW Protocol solves this drastically — all orders over a fixed period (e.g., 30 seconds) execute simultaneously at a uniform clearing price. No attacker can insert themselves into the trade flow because there are no real-time transactions. This approach is detailed in the CoW Protocol documentation.
We specialize in batch auction development for DeFi projects. Our services cover the entire system: from the settlement contract to the off-chain orderbook and competitive solver. We have over 5 years of experience implementing auction batches, and we guarantee zero MEV vulnerabilities. Estimated gas savings: ~$200 per batch (50 orders) vs. naive approach.
Batch Auction Development: Why It Beats AMMs
The system processes orders in batches with a single clearing price. All orders submitted during the batch period execute at the same price. This is fundamentally different from an AMM, where each trade changes the price and allows MEV bots to intervene. Users get: zero slippage within the batch, protection against manipulation, and no LP fees.
Uniform settlement price
Every N seconds (typically ~30), the batch closes. The settlement price is determined as the price that maximizes trading volume: all buy and sell orders that intersect at that price are executed. If the price is better than the user’s limit, the surplus is returned — a unique feature of the CoW style.
How does a batch system protect against MEV?
The main protection is the uniform clearing price: an attacker cannot insert their transaction before or after a specific order because all orders execute in the same batch. Additionally, we use an off-chain orderbook: users sign orders via EIP-712 signatures without spending gas on submission. Solvers (competitive algorithms) propose solutions, and the contract verifies correctness.
Solver design
Finding the optimal solution is an NP-hard problem. We use an external solver plus on-chain settlement. The solver computes the clearing price and routing off-chain, then submits the solution to the contract. The contract checks: each order executes at least as well as its limit, total balances are preserved, and all signatures are valid. This approach is 10–20 times faster than on-chain and can handle hundreds of orders per batch.
Solver Architecture Comparison
| Parameter | On-chain solver | Off-chain solver + settlement |
|---|---|---|
| Performance | Gas-limited (up to 50 orders) | 500+ orders per batch |
| Algorithm complexity | Simple (linear search) | Advanced optimization (ILP, graphs) |
| Gas cost (settlement) | ~200k gas | ~120k gas (flash accounting) |
Settlement contract implementation
Flash accounting
Instead of sequential ERC-20 transfers (naive approach), we use flash accounting: the contract maintains an internal ledger of net token movements. After processing all orders, only non-zero transfers are executed. This reduces gas by a factor of 2–3 — especially noticeable when handling 100+ orders. Total gas savings for a typical batch of 50 orders is about 40%.
struct Order { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; // minimum buy amount (limit) uint32 validTo; // deadline bytes32 appData; // metadata uint256 feeAmount; // gas compensation for solver bytes32 kind; // SELL or BUY order bool partiallyFillable; bytes32 sellTokenBalance; // erc20 / internal / external bytes32 buyTokenBalance; } Signatures via EIP-712 standard and EIP-1271 for contract wallets. The settlement contract verifies isValidSignature when executing the batch.
On-chain solution verification
The contract receives an array of executions and transfers from the solver. Checks:
- For each order:
executedSellAmount * buyPrice >= order.buyAmount. - Conservation law:
sum(sellAmounts) >= sum(buyAmounts). - All order signatures are valid.
-
validTonot expired.
Batch Auction Development Process
| Stage | Duration | Result |
|---|---|---|
| Design | 3-5 days | Order structure, solver architecture, fee model |
| Settlement contract | 2-3 weeks | Order verification, flash accounting, Uniswap fallback |
| Off-chain components | 1-2 weeks | Orderbook API, basic solver, signature relay |
| Testing | 1 week | Fuzz tests, integration with Uniswap v3 |
What is included in the work (deliverables)
- Documentation: architecture, API, deployment guide.
- Access to private repository with contracts and solver.
- Team training: workshop on maintaining the system.
- Support: 1 month after launch (bug fixes, consultations).
We guarantee quality: all contracts undergo formal verification and auditing with Slither and Mythril. Our engineers have 5+ years of DeFi development experience and have implemented 10+ auction batches for partners. Pricing starts at $15,000 for a basic system.
Timelines
Simplified version with on-chain solver (up to 50 orders) — 2-3 weeks. Full system with external solver and competition — 4-6 weeks. The cost is determined individually — contact us for a project evaluation. Order a turnkey batch auction implementation and get a consultation.