Summary: Decision-makers are asking how to turn “intents” into fast, safe, and profitable execution on modern modular rollups. This guide shows exactly how to design, ship, and operate a production-grade solver: which intent rails to target first (CoW, UniswapX, ERC‑7683), how to integrate with OP‑Stack chains using Rollup‑Boost, shared sequencers, and modern DA layers, and how to harden privacy/MEV, simulation, and monitoring.

How to Build a Solver for Blockchain Intents: From Intents to Execution on Modular Rollups

The “intent → solver → execution” pattern is moving from whiteboards into production: UniswapX, CoW Protocol, and ERC‑7683 cross‑chain intents are live; OP‑Stack rollups ship fault proofs; and rollup ordering is evolving with verifiable priority, TEEs, and shared sequencers. Meanwhile, MEV pressure now gates scalability, so solvers that internalize MEV and minimize spam are becoming core infra, not “nice-to-have” features. (docs.uniswap.org)

Below is a concrete playbook for building a solver that earns fills today and is future-proofed for modular rollups tomorrow.

1) What you’re actually building: the intent-to-execution pipeline

At a high level, your solver does five jobs:

Intake: ingest intents from one or more “intent rails”:

CoW Protocol batch auctions (FCBA) for swaps on EVM L1/L2s. (docs.cow.fi)
UniswapX auctions (Dutch, limit, priority) across Ethereum and L2s. (docs.uniswap.org)
ERC‑7683 cross‑chain intents (Across + Uniswap standard) for settlement across chains. (erc7683.org)

Normalize: map each intent into an internal, constraint-and-preference model (price bounds, timeouts, chain/settlement target, slippage, privacy flags).
Plan: compute routes across AMMs and RFQ/MM quotes, cross‑chain settlement paths, and internalization opportunities (peer matches and backruns) under gas/MEV constraints.
Simulate and prove safety: pre-trade sim with bundle or batch constraints; prove post-conditions (amount out, recipients, timings).
Execute and settle: call the protocol’s settlement contracts or rollup-native paths, preferably over private or OFA-protected orderflow; reconcile refunds/rebates; and write observability.

Anoma’s “intent machine” vocabulary is useful here: solvers take unbalanced intents, find matchings, and return balanced transactions that satisfy constraints. Treat this as your abstract layer, even if you start on specific rails like CoW or UniswapX. (specs.anoma.net)

2) Pick your first rails (and what “production details” actually look like)

A. CoW Protocol: win batch auctions with FCBA

CoW aggregates user intents off-chain and runs frequent batch auctions. Solvers submit single-order or combinatorial bids; the protocol selects a fair combination that maximizes user surplus, with MEV protection via uniform clearing prices and “coincidence of wants.” Practically, this means your solver must be good at:

Mixed-integer/heuristic optimization across on-chain liquidity plus internal peer matches.
Strict solution validity and “fairness” checks enforced by the settlement contract. (docs.cow.fi)

Production specifics you can act on:

Auction cadence is every few seconds; your algorithm must converge under real deadlines. CoW publishes solver tutorials and keeps public dashboards of solver performance. (docs.cow.fi)
FCBA shipped with measurable throughput and reward uplifts; rewards are paid weekly per CIP schedule in COW, fostering an open solver market. Budget your ROI around real incentive parameters. (outposts.io)

Design tips:

Maintain two engines: a fast deterministic baseline that never underperforms, and a higher-variance metaheuristic that improves surplus under time caps (e.g., <1–2 s). Pre-commit to a stop rule that falls back to baseline when convergence stalls. (Academic work shows multi-objective GAs can meet sub-second medians under 2 s limits on CoW-style batches.) (arxiv.org)

B. UniswapX: fillers and quoters with strict latency and onchain hooks

UniswapX is an auction-based intents system where fillers compete to execute users’ orders at best prices. On Ethereum mainnet, a permissioned “quoter” role parameters orders via RFQ; on L2s, everyone competes as permissionless fillers. Architecture details you should design against:

Respond to Ethereum RFQs within 500 ms; slow responders are rejected. The RFQ server sits in AWS us‑east‑2—co-locate if necessary. Expected quoting RPS ≈ 1. (docs.uniswap.org)
L2s run direct auctions without RFQ. Fillers poll orders (start with 6 rps) or register webhooks; on Arbitrum’s 250 ms block cadence, V3 Dutch uses block numbers for decay rather than timestamps. (docs.uniswap.org)
Permit2 “permitWitnessTransferFrom” is used with the order as witness; your fill contract executes via reactorCallback, or you can “directFill” with address(1) for capital-on-hand fills. (docs.uniswap.org)

What to ship first:

A filler with: fast price/hedge quotes, cancel-aware sim, strict order freshness checks, and a latency SLO of p95 < 200 ms E2E. Implement a first-class “fade” manager; repeated RFQ fades will block you temporarily. (docs.uniswap.org)

C. ERC‑7683 cross‑chain intents: standardized settlement for multi-chain UX

Uniswap Labs and Across co-authored ERC‑7683 to unify cross-chain intents via a standard order struct and “CrossChainSettler” interfaces. This lowers the barrier to enter filler networks across apps and chains; Optimism has publicly aligned with the standard for Superchain UX. If you plan for multi-chain intents, design your solver’s settlement layer around 7683 now. (erc7683.org)

Action items:

Implement CrossChainOrder parsing and settlement callbacks; build a risk engine for timeout, on-destination verification, and escrow release rules (settler only releases user funds after proof of fulfillment).
Integrate OP‑Stack bridges and messaging as first-class targets in your planner.

3) Target execution venues: OP‑Stack rollups, shared sequencers, and DA choices

A. OP‑Stack chains with Rollup‑Boost: verifiable priority and 250 ms Flashblocks

OP‑Stack rollups now have production fault proofs, moving the ecosystem to Stage‑1 decentralization; the roadmap aims for Stage‑2 with multiple independent provers. For solvers, two things matter:

Trust guarantees for exits are stronger post–fault proofs.
Ordering and user guarantees can be upgraded via Rollup‑Boost extensions. (blog.oplabs.co)

Rollup‑Boost, co-designed by Flashbots with Uniswap Labs and OP Labs, provides:

Flashblocks: ~250 ms streaming confirmations with revert protection and higher gas throughput.
Verifiable priority ordering in TEEs, enabling credibly neutral ordering rules and user assurances. Unichain is the flagship deployment path. Cloud providers like Alchemy already expose Rollup‑Boost for dev rollups. (writings.flashbots.net)

Tactical advice:

When executing on OP‑Stack chains with Rollup‑Boost, treat revert protection as a lever for safe-once routes (e.g., multi-leg AMM routing with minimal revert cost). Include a policy: “no submission without revert protection” for large orders.

B. Shared sequencers and cross-rollup atomicity

Shared sequencers (e.g., Astria) let multiple rollups share ordering, enabling fast confirmations and atomic cross-rollup inclusion while using Celestia for DA. For integration, understand Astria’s components:

Composer (write), Conductor (read), Relayer, and namespaced DA via Celestia light nodes per rollup. Your solver can target multi-rollup atomics by coordinating inclusion windows at the shared sequencer. (astria.org)

If you’re rolling your own appchain or L3:

Astria’s RaaS and dev clusters make it one-click to stand up a Geth rollup bound to the shared sequencer; your solver just writes to Composer and monitors Conductor for firm/final confirmations. (astria.org)

C. Data availability: Celestia vs EigenDA vs Ethereum blobs

Your solver won’t choose DA, but your clients will—and it shapes fee models and latency:

Celestia + Blobstream gives DA via DAS and a ZK light client (SP1) on Ethereum/Arbitrum. Initial blobspace up to 8 MB per block can translate to roughly 9,000–30,000 ERC‑20 TPS depending on compression; Blobstream is live for builders. (blog.celestia.org)
EigenDA is being adopted by high‑throughput L2s; public statements cite ~15 MB/s live throughput with V2 testnets targeting ~50 MB/s—useful context when sizing fees/latency for flood‑fill solvers. (megaeth.com)

4) Orderflow, privacy, and MEV: build it in on day one

Key reality: MEV now imposes economic limits to scaling—bots can consume a majority of gas/throughput on popular rollups. Your solver must minimize public leakage, capture backrun value for users, and avoid contributing to spam. (writings.flashbots.net)

Concrete layers to implement:

Private RPC + OFAs:
- Flashbots MEV‑Share is an orderflow auction spec that redistributes backrun value to users and wallets; it introduces privacy levels, validity conditions, and bundle APIs. Use it by default for sensitive legs. (docs.flashbots.net)
- MEV Blocker RPC offers endpoints for protected flow with optional revert protection; it sends to multiple builders and returns rebates. Integrate “/noreverts” for critical orders. Infra providers (Alchemy, GetBlock) also offer MEV-protected routes. (mevblocker.io)
TEE-backed ordering:
- On rollups with Rollup‑Boost, prioritize transactions that benefit from verifiable priority ordering and Flashblocks. This reduces information leakage windows for your strategies. (writings.flashbots.net)
Time-based ordering markets:
- Arbitrum’s Timeboost adds an “express lane” via sealed-bid second-price auctions. If you operate on Arbitrum, add bidding logic and expected value models; the system has generated material fees for the DAO and is configurable for Orbit chains. (docs.arbitrum.io)

5) Simulation and safety: how you avoid paying for reverts

Before submitting settlement transactions or fills:

Use bundled simulations to evaluate multi-leg routes under the same block and state—Tenderly exposes tenderly_simulateBundle via RPC and API. Build sim clusters per target chain with state overrides for robust gas/price testing. (docs.tenderly.co)
Maintain mempool telemetry for “what just changed” near auction close. Even as some public tools sunset, you can use remaining explorers and archives to study private/public ratios and latency windows. (docs.blocknative.com)
Enforce hard guards:
- Valid-until timestamps and block‑based decay windows (especially on L2s with <1 s blocks). (docs.uniswap.org)
- Dominance checks vs AMM reference routes (“never worse than EBBO”) for CoW-style batches. (docs.cow.fi)
- No send without revert protection for non-trivial sizes on Rollup‑Boost rollups or via MEV Blocker’s /noreverts. (writings.flashbots.net)

6) Account abstraction realities you can leverage

Post‑Pectra, EIP‑7702 lets EOAs delegate to smart wallet logic via a type‑0x04 “set code” transaction with an authorization list, giving you persistent smart‑account behavior until revoked. In practice, this improves solver UX for policy wallets, paymasters, and session keys across chains that support 7702-compatible semantics. Use with strict allowlists and auto‑revoke procedures. (eips.ethereum.org)

For intent systems that also accept ERC‑4337 UserOperations, keep your bundler integrations up to date; modern stacks combine protocol‑level 7702 with 4337 alt‑mempool flows depending on chain. (eips.ethereum.org)

7) An execution blueprint (90 days)

Phase 0–2 weeks: platform choices and safety rails

Choose initial rails: CoW (batch) + UniswapX (auction) + ERC‑7683 for cross‑chain.
Stand up MEV‑Share and MEV Blocker routes; define privacy tiers per flow.
Set SLOs: p95 quote latency < 200 ms; fill success > 98%; revert rate < 1%.

Phase 3–6 weeks: solver core and sims

Implement dual-engine routing: deterministic baseline + heuristic improver with 1–2 s wall-time.
Integrate Tenderly bundle sims for all target chains; build post‑condition validators and price/bounds proofs. (docs.tenderly.co)
Wire UniswapX filler: webhooks/polling, permit2 handling, directFill modes; pass the 500 ms RFQ constraint if pursuing mainnet quoter access. (docs.uniswap.org)

Phase 7–10 weeks: rollup integration and ordering

Deploy on OP‑Stack L2 (e.g., Base or Unichain) with Rollup‑Boost sidecar in staging; validate revert protection and Flashblocks latencies. (alchemy.com)
If targeting Arbitrum, add Timeboost bidding. Gate bids behind EV>0 with slippage-aware reprice. (docs.arbitrum.io)
Add ERC‑7683 settlement module and OP‑Stack bridge handling. (erc7683.org)

Phase 11–13 weeks: monitoring, incentives, and cutover

Emit per-order and per-batch metrics: surplus delta vs AMM fallback; rebates/MEV refunds; private vs public inclusion; revert causes.
Enroll in CoW solver rewards and UniswapX trusted channels where applicable. (docs.cow.fi)
Security review: signature domain checks, permit2 nonces, destination allowlists, onchain guards.

8) KPIs that actually matter to decision‑makers

Price improvement vs baseline (AMM/EBBO) by size bucket, net of gas. (docs.cow.fi)
Fill rate, cancel/fade rate, and p95/p99 latencies (quote to onchain inclusion).
Revert rate (gross and net of revert protection), average sim error.
MEV refunds captured for users/wallets (MEV‑Share/MEV Blocker) as a % of flow. (docs.flashbots.net)
Cross‑chain fill time and failure rate for ERC‑7683 orders. (erc7683.org)
Operational cost per 1,000 fills by chain (RPC, sim, infra).

9) Example: cross‑chain treasury swap with execution guarantees

Scenario: a treasury wants to swap 1,000,000 USDC on Base to stETH on an OP‑Stack L2 with revert protection and best net price.

Plan:

Express as ERC‑7683 order: settle funds in a standard CrossChainSettler contract; deadline 7 minutes; slippage 20 bps; privacy: private relay required. (erc7683.org)
Solver route: (a) capture best price on Base via protected flow; (b) hedge/bridge using intents filler network; (c) settle on destination rollup with Rollup‑Boost revert protection; (d) return surplus and rebates to the treasury via OFA rebate rules. (writings.flashbots.net)
Safety: bundle‑simulate both legs; require attestable ordering on destination; block submission if revert‑protection not available or if sim confidence < threshold. (docs.tenderly.co)

10) Emerging best practices we see winning in 2026

Start private, prove public: default to OFAs/private RPC for sensitive flow; publish post‑trade receipts and proofs for auditability. (docs.flashbots.net)
Build for verifiable ordering: where available, target TEE‑attested ordering (Rollup‑Boost) or sealed-bid lanes (Timeboost) with clear EV policies instead of latency races. (writings.flashbots.net)
Compose with standards: use ERC‑7683 for cross‑chain intents; plug into OP‑Stack interop as it matures; avoid bespoke bridges where possible. (erc7683.org)
Keep DA assumptions explicit: if clients pick Celestia (Blobstream) or EigenDA, adjust your fee and timing models accordingly; document how DA outages affect SLAs. (blog.celestia.org)
Treat MEV as a cost center: measure “spam externalities” and reward internalization that improves net user surplus; align with Builder/Sequencer ecosystems that redistribute value (MEV‑Share, Rollup‑Boost). (docs.flashbots.net)

11) Implementation notes you’ll thank yourself for later

UniswapX details to hard‑code into runbooks:
- RFQ response < 500 ms; quote server region us‑east‑2; small-order filters; “fade” penalties; use the OrderQuoter sim to verify fillability before gas. (docs.uniswap.org)
- V3 Dutch uses block numbers for decay—important on Arbitrum with 250 ms blocks. (docs.uniswap.org)
- Permit2 witness semantics and directFill(address(1)) path for using own inventory. (docs.uniswap.org)
CoW Protocol specifics:
- FCBA fairness constraints and auction selection; ship combinatorial bids only when they dominate single‑order bids to avoid “unfair” filtering; enroll for weekly COW rewards. (docs.cow.fi)
OP‑Stack realities:
- Fault proofs are live; Stage‑2 is the north star (multi‑proof, security council limited to break‑glass). Budget for upgrades and shared governance cadence. (blog.oplabs.co)
Shared sequencers:
- If you target Astria, implement Composer/Conductor clients and understand namespace filtering; expect Celestia light nodes per rollup for DAS guarantees. (astria.org)
Simulation and observability:
- Use bundled sims; maintain rolling model of revert-protected vs non-protected submission costs by chain; archive param studies on slippage vs latency by venue. (docs.tenderly.co)

Close

Intents won’t replace transactions; they rewire who competes to fulfill them and how value is shared. Your competitive edge as a solver comes from three things: (1) protocol-native correctness and safety that never regresses, (2) decisive latency and privacy engineering, and (3) modular rollup awareness—leveraging verifiable ordering, shared sequencers, and efficient DA. Build against the rails that exist today (CoW, UniswapX, ERC‑7683), ship with private/MEV-aware execution from day one, and meet rollups where they’re going: faster confirmations, stronger withdrawal guarantees, and programmable ordering. (docs.cow.fi)

If you want a blueprint tailored to your stack—assets, chains, latency/SLO targets—we can help you ship a pilot in 90 days and a competitive solver in a quarter.