Execution-Improvement Auctions

Execution-improvement auctions go beyond simple MEV extraction. They run a multi-objective optimization across competing solver bids to find the best overall execution for the user -- maximizing output, minimizing slippage, rewarding speed, and factoring in solver reputation.

Scoring Factors

Each solver bid is evaluated across four dimensions:

Factor	Weight	Description
Output	40%	Net output tokens delivered to the user relative to the baseline.
Slippage	25%	Reduction in price impact compared to naive execution.
Speed	20%	Estimated time to inclusion (fewer blocks = higher score).
Reputation	15%	Solver's historical success rate and reliability score.

Scoring Formula

The composite score for a solver bid is computed as:

score = (0.40 * output_normalized)
      + (0.25 * slippage_normalized)
      + (0.20 * speed_normalized)
      + (0.15 * reputation_normalized)

Each factor is normalized to the range [0, 1] relative to the other bids in the same auction round. The bid with the highest composite score wins.

Configuration

Auction parameters are configured in the engine's YAML config:

auction:
  type: execution_improvement
  scoring:
    output_weight: 0.40
    slippage_weight: 0.25
    speed_weight: 0.20
    reputation_weight: 0.15
  deadline_blocks: 2
  min_improvement_bps: 10
  max_solvers: 20
  timeout_ms: 500

Field	Type	Description
`output_weight`	float	Weight for the output factor.
`slippage_weight`	float	Weight for the slippage factor.
`speed_weight`	float	Weight for the speed factor.
`reputation_weight`	float	Weight for the reputation factor.
`deadline_blocks`	int	Maximum blocks a solver has to fulfill the order.
`min_improvement_bps`	int	Minimum improvement in basis points over baseline.
`max_solvers`	int	Maximum concurrent solver bids per auction.
`timeout_ms`	int	Auction round timeout in milliseconds.

Solver Bid Fields

Solvers submit bids with the following structure:

{
  "solver_id": "solver_abc123",
  "auction_id": "auc_xyz789",
  "output_amount": "1025000000",
  "output_token": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
  "slippage_bps": 5,
  "estimated_blocks": 1,
  "bundle": ["0xf86c..."],
  "signature": "0x3045..."
}

Field	Type	Description
`solver_id`	string	Unique identifier for the solver.
`auction_id`	string	The auction this bid targets.
`output_amount`	string	Amount of output token the solver commits to deliver.
`output_token`	string	Address of the output token.
`slippage_bps`	int	Estimated slippage in basis points.
`estimated_blocks`	int	Expected blocks until inclusion.
`bundle`	[]string	Signed transactions that execute the solver's strategy.
`signature`	string	ECDSA signature over the bid payload.

Backward Compatibility

Execution-improvement auctions are backward compatible with standard bundle auctions. If no solvers bid on an order, the engine falls back to the standard MEV backrun auction pipeline. Searchers that only submit traditional bundles continue to work without modification.

Intent Marketplace Integration

Execution-improvement auctions integrate with the intent marketplace. When a user submits an intent (e.g., "swap 1 ETH for maximum USDC"), the intent is broadcast to registered solvers who compete in an execution-improvement auction. The winning solver's bundle is submitted atomically, and the user receives the best available execution across all competing strategies.