Intent-based bridge architecture doesn’t remove bridge trust assumptions, it moves them to solvers and fillers. This guide explains how ERC-7683 and the Open Intents Framework standardize orders, where resolver and filler risk sits, how Across, Eco, UniswapX, and LI.FI differ in trust models, and what to check before routing funds through an intents protocol.

Intent-based bridge architecture doesn’t remove bridge trust assumptions, it moves them to solvers and fillers. This guide explains how ERC-7683 and the Open Intents Framework standardize orders, where resolver and filler risk sits, how Across, Eco, UniswapX, and LI.FI differ in trust models, and what to check before routing funds through an intents protocol.
Intent-based bridge architecture lets a user sign what they want (tokens on chain B) instead of how to get it, and leaves the routing to a solver. ERC-7683 and the Open Intents Framework standardize that handoff, but they do not remove bridge trust assumptions, they relocate them to solvers and fillers who now choose between competing settlement-rail models before any funds move. This post breaks down how the standard works, where it pushes risk, and what to check before routing funds through an intents protocol.
Intent-based bridge architecture is a system where a user signs a declaration of desired outcome, such as "100 USDC on Base from my 100 USDC on Arbitrum," and a third-party solver (also called a filler or relayer) competes to deliver that outcome, fronting liquidity on the destination chain and getting reimbursed later from the user's locked origin-chain funds. It differs from classic lock-and-mint bridges, where a custodian or validator set locks the origin asset and a smart contract mints a wrapped representation on the destination chain, and the user waits on the bridge's own verification path instead of a competitive solver market.
The practical difference shows up in settlement speed and in where the trust sits. Lock-and-mint bridges put trust in the custodian, multisig, or light-client proof that unlocks the wrapped asset. Intent-based bridges put trust in whichever solver filled the order and in the mechanism that eventually reimburses that solver.
Here's the catch: reimbursement doesn't have to be atomic across both chains. The destination-side fill and the origin-side settlement typically happen in separate, non-atomic steps, and the gap between them is covered by the solver's own capital and the dispute window of whatever settlement rail it uses. QuillAudits' overview of blockchain bridge architecture covers the trusted, trustless, and hybrid taxonomy that intent-based designs sit alongside rather than replace.
ERC-7683 defines two order types, GaslessCrossChainOrder and OnchainCrossChainOrder, that any solver can fill across any supported chain pair, so individual protocols don't need to invent their own order format, per Archetype's writeup of the standard. Any filler that supports those two order types can compete for an intent regardless of which app or chain pair originated it.
Across, Eco, and UniswapX aren't just early adopters, they're co-authors and production implementers of the standard. UniswapX shipped a cross-chain version in late 2024 that uses ERC-7683 as its message format, with Across supplying the underlying settlement rail, per Eco's comparison of cross-chain intent protocols. The Open Intents Framework extends this further by giving solvers a shared set of interfaces, so the same filler infrastructure can serve multiple intents protocols instead of integrating each one from scratch.
What standardization doesn't do is converge the protocols on a single settlement mechanism. The same source notes that Across runs UMA's optimistic oracle for dispute resolution, Eco Routes abstracts across multiple messaging rails (CCTP, Hyperlane, LayerZero), and UniswapX delegates settlement entirely to Across. ERC-7683 standardizes the order format solvers read; it leaves the question of how a fill actually gets verified and finalized to each settlement rail. That gap is where solver-specific risk lives, and it's why a shared order format doesn't mean a shared trust model.
The clearest evidence for where ERC-7683 relocates trust is in the standard's own design discussion. In the "ERC-7683 Redux: Programmable Fillers" thread on Ethereum Magicians, a contributor described the resolver as the point of trust in the system.
"The resolver is the point of trust: filler operators whitelist resolvers, and once vetted, the instructions they produce are trusted."
That's not an incidental aside, it's the design's load-bearing assumption. Filler operators don't independently re-verify every instruction a resolver produces; they vet the resolver once and then trust its output, per the Ethereum Magicians discussion thread.
The same thread surfaces a second, narrower but equally important gap: assumptions emitted in an ERC-7683 order are advisory, not onchain-enforced. Contributor Frangio clarified that an assumption field exists in the order format specifically because the resolver wasn't able to check that condition onchain, which means the burden of actually verifying it shifts to the filler before it commits capital. Stateful or privacy-preserving intents make this harder still, since proving that origin-side funds genuinely exist before a destination-side fill can require preconditions a filler has no independent way to confirm on its own, per the same Ethereum Magicians thread. ERC-7683 standardizes the message. It doesn't standardize, or guarantee, how that message's claims get checked.
Three attack surfaces recur across solver-based intent systems, and none of them are unique to any one protocol.
Is intent-based bridging safer than a traditional lock-and-mint bridge? Not inherently. It trades custodian or validator-set risk for solver and settlement-rail risk, and whether that's actually safer depends entirely on the specific economic penalties backing the rail you're routing through.
Across is the clearest public case study of a penalty mechanism built to address that risk. It runs a 1-of-N trust assumption in which only a single honest actor needs to dispute an invalid relayer or bundle proposal to keep the system secure, and a disputed proposer loses their posted bond, per Across's security documentation. Disputing a root bundle requires posting a bond of roughly 0.45 ABT, with the bond size configurable through the HubPool contract's bondAmount() function, according to the same documentation.
As of April 2026, no fraudulent relayer fill had been successfully disputed in Across production, which the protocol attributes to that bond-slashing economic penalty deterring invalid claims before they're even attempted, per Eco's deep dive on Across's solver architecture. That's a meaningful data point, but it describes one rail's track record under its own incentive design, not a property of intent-based bridging in general. It's also the kind of number a due-diligence checklist should ask for by name: not "does a dispute mechanism exist" but "how many disputes has it actually resolved, and in whose favor." QuillAudits' piece on cross-chain messaging security covers a parallel gap: how a destination chain can be tricked into accepting an unverified message, which is the same fill-verification problem in a different wrapper.
Do you need to pick a solver, or does the protocol pick one for you? It depends on which layer of the stack you're interacting with, and the four names that come up most in ERC-7683 discussions sit at different layers.
| Protocol | Role in the stack | Settlement-rail trust model |
|---|---|---|
| Across | Settlement rail and solver network | UMA optimistic oracle with bonded dispute mechanism; 1-of-N honest-actor assumption |
| Eco (Routes) | Solver network, rail-agnostic | Abstracts across CCTP, Hyperlane, and LayerZero rather than running one native rail |
| UniswapX | Order-flow and auction layer | Delegates settlement execution to Across rather than running its own rail |
| LI.FI | Aggregator across bridges and DEXs | Routes through underlying bridge and intent protocols; not itself an intent-settlement rail |
Is LI.FI an intent-based protocol? Not in the ERC-7683 sense. LI.FI is an aggregation layer that routes a swap or bridge request across whichever underlying bridges, DEXs, and intent protocols (including ERC-7683 implementations) offer the best path, rather than running its own solver network or settlement rail. That matters for due diligence: if you're integrating through an aggregator, the solver trust model you actually inherit is whichever underlying rail the aggregator routes you to at execution time, which can change fill by fill.
For a protocol like Across or Eco, the solver trust model is fixed by the rail's own design and worth vetting once. For an aggregator like LI.FI, the trust model is a moving target, and the more relevant question is what rails it is permitted to route through and whether each of those has been independently reviewed.
Before routing meaningful volume through any ERC-7683 implementation, confirm the following:
These same questions apply to intent-based designs outside of bridging. QuillAudits' analysis of intent-based lending security risks covers solver vulnerabilities, intent-layer MEV, and signature or nonce flaws that recur across intent architectures regardless of the asset class, and RWA settlement designs are increasingly built on the same primitives; QuillAudits' piece on cross-chain RWA architecture already treats deBridge and Across as intent-based and optimistic settlement models for tokenized assets.
ERC-7683 and the Open Intents Framework solve a real fragmentation problem: before the standard, every intents protocol invented its own order format and filler interface, and solvers had to integrate each one separately. What the standard doesn't do is collapse the number of trust decisions a user or integrator has to make. It just moves those decisions from "which bridge custodian do I trust" to "which solver network, resolver whitelist, and settlement rail do I trust," and the standard's own contributors say plainly that the resolver is the point of trust and that unverifiable assumptions get pushed onto fillers rather than enforced onchain. Not all settlement rails are created equal, and the due-diligence checklist above is the minimum bar for telling them apart before funds move.
A comprehensive Blockchain Audit can help verify whether a solver's resolver whitelist, dispute bonding, and fill-verification logic hold up under adversarial conditions before they hold real liquidity. For deeper technical coverage of bridge and cross-chain exploits, visit QuillAudits' research.
Contents

From day-zero risk mapping to exchange-ready audits, QuillAudits helps projects grow with confidence. Smart contracts, dApps, infrastructure, compliance: secured end to end.