Across Does L2-to-L2 Transfers in 3 Seconds, deBridge Settled B with Zero TVL Risk, and ERC-7683 Standardizes Intent Execution - Why Intent-Based Bridges Are Eating the Market

[defi_diana]

The Bridge Model That Changes Everything

I have been deep in the cross-chain trenches for the past two years, and after watching $2.8 billion get stolen from bridge hacks in 2025 alone – representing roughly 40% of all Web3 exploits – I am finally ready to say it: the traditional lock-and-mint bridge model is fundamentally broken, and intent-based bridges are the architecture that replaces it.

Let me break down why this matters with real numbers.

How Intent Bridges Actually Work

Traditional bridges like Portal (formerly Wormhole, $1.9B TVL), Stargate ($370M TVL), and Axelar ($320M TVL) all follow the same basic pattern: lock assets on the source chain, mint synthetic representations on the destination chain. The problem is obvious – every dollar locked in a bridge contract is a dollar that can be stolen. The Wormhole hack ($320M), the Ronin bridge hack ($625M), and the Nomad hack ($190M) all exploited this exact custodial vulnerability.

Intent-based bridges flip this model entirely. When you use Across Protocol to bridge from Arbitrum to Optimism, you are not locking anything in a pool. Instead, you express an intent: “I want 1 ETH on Optimism, and I will pay from my Arbitrum balance.” Professional market makers called solvers or relayers see this intent and compete to fill it. The solver sends you 1 ETH on Optimism from their own capital, then gets repaid from your locked funds on the source chain after verification.

The Numbers Tell the Story

Across Protocol has achieved remarkable performance with this model. L2-to-L2 transfers complete in approximately 3 seconds for transactions under $10K. The protocol holds $98M in TVL – but critically, this is relayer capital, not user funds sitting in a vulnerable bridge contract. Monthly volume has reached $1.3B, and Uniswap integrated Across directly into their interface for in-app bridging, making it the default cross-chain experience for the largest DEX in existence.

deBridge has taken an even more aggressive approach to the zero-TVL thesis. They have settled over $10B in cumulative volume with effectively zero protocol-level TVL risk. Their median transfer time sits at 1.96 seconds. Instead of a monolithic validator set, deBridge uses a network of decentralized validators to verify cross-chain messages, but the key innovation is that user funds are never custodied by the protocol itself.

Why Zero-TVL Is Superior Risk Architecture

Here is the core insight that most people miss: in a traditional bridge, security scales with TVL – the more money locked, the bigger the honeypot, the more sophisticated the attacks become. In an intent-based bridge, there is no honeypot. If a solver gets compromised, only that solver’s capital is at risk, not every user’s funds.

This shifts the security model from protocol-level risk (one exploit drains everyone) to market-level risk (individual solver failures are contained). It is the difference between a single point of failure and a distributed market of independent actors.

ERC-7683: The Standard That Unifies It All

Perhaps the most significant development is ERC-7683, co-developed by Uniswap Labs and Across Protocol. This standard creates a unified framework for cross-chain intent execution. Any solver can fill any intent from any protocol that implements the standard. This means solvers are no longer siloed to individual bridge protocols – they can operate across the entire intent ecosystem, increasing competition and reducing costs for users.

The practical impact: more solvers competing means tighter spreads, faster fills, and better prices. It transforms cross-chain bridging from a fragmented market of isolated protocols into an interconnected solver network.

The Competitive Landscape

I should note that intent bridges are not the only innovation here. Circle’s CCTP V2 provides native mint/burn for USDC transfers, which eliminates bridge risk for stablecoin-specific use cases. And messaging-based bridges like LayerZero and Wormhole are adding intent layers on top of their existing infrastructure.

But the direction is clear. The $2.8B in bridge hack losses is an unsustainable tax on the ecosystem. Intent-based architectures are not just marginally better – they represent a fundamentally different risk model that eliminates the largest attack vector in cross-chain infrastructure.

The market is voting with volume, and intent bridges are winning.

[blockchain_brian]

Unpacking the Technical Architecture of Intent Resolution

Diana, excellent overview. Let me dig deeper into how intent resolution actually works at the protocol level, because the mechanics are more nuanced than “user posts intent, solver fills it.”

The Intent Lifecycle

When a user submits an intent on Across, the following sequence executes:

1. Intent Creation: The user deposits funds into an origin chain spoke pool contract and specifies destination chain, recipient, token, amount, and a relayer fee. This creates a cryptographic commitment – not a lock in the traditional sense, but a conditional deposit.

2. Solver Discovery and Competition: Relayers monitor the spoke pool contracts across all supported chains. When a new deposit event fires, multiple relayers evaluate whether they can profitably fill the order. This is where the market dynamics get interesting – relayers are essentially running MEV-style infrastructure, scanning mempools and computing optimal fill strategies.

3. Optimistic Fill: The winning relayer sends funds to the user on the destination chain from their own inventory. For sub-$10K L2-to-L2 transfers, this happens in roughly 3 seconds because the relayer is taking on the settlement risk, not waiting for finality.

4. Settlement via UMA Optimistic Oracle: Across uses UMA’s optimistic oracle for repayment verification. The relayer submits a proof that they filled the order correctly, and there is a challenge window. If nobody disputes, the relayer gets repaid from the origin chain spoke pool. This is the clever bit – the settlement layer is decoupled from the execution layer.

MEV Dynamics in Cross-Chain Intents

Here is where things get technically fascinating. Cross-chain intents create a new MEV surface that does not exist in single-chain transactions. Solvers are essentially competing in a cross-chain orderflow auction. The fastest solver with the best inventory management wins the fill, and their profit margin is the spread between the user’s fee and their cost of capital.

On Across specifically, there is a priority relayer system. Certain relayers get first-fill rights for a short window before the order opens to the general pool. This creates a hierarchical competition structure that balances speed (priority relayers fill instantly) with decentralization (anyone can fill after the window).

deBridge takes a different approach with its decentralized validator network. Instead of an optimistic oracle, deBridge validators independently verify cross-chain messages. The validators stake collateral, and slashing conditions enforce honest behavior. This gives deBridge slightly different trust assumptions – you are trusting a validator set rather than an optimistic game.

ERC-7683 as a Unified Standard

From an architecture perspective, ERC-7683 defines two core interfaces: CrossChainOrder and ISettlementContract. The CrossChainOrder struct standardizes how intents are expressed – origin chain, destination chain, deadline, nonce, and arbitrary implementation-specific data. The ISettlementContract interface standardizes how solvers interact with the settlement layer.

The practical consequence is that a solver built for Across can, with minimal modification, also fill intents from UniswapX or any other ERC-7683-compliant protocol. This creates a unified solver market where competition drives down fees across the entire ecosystem, not just within individual protocols.

What concerns me technically is liveness – if all solvers go offline or refuse to fill during a volatility event, users could face significant delays. The fallback mechanisms vary by protocol, and I think this is an area where more robust engineering is needed.

[bridge_builder_ben]

Intent-Based vs Messaging-Based vs ZK-Based: The Full Architecture Comparison

Great thread. As someone who has spent years building cross-chain infrastructure, I want to lay out the three dominant bridge architectures side by side, because intent-based is not universally superior – it depends on what you are optimizing for.

Architecture 1: Messaging-Based Bridges (LayerZero, Wormhole, Axelar)

These protocols transmit arbitrary messages between chains using validator networks or oracle systems. LayerZero supports 120+ chains with its Decentralized Verifier Networks (DVNs). Wormhole uses 19 Guardian validators. Axelar runs a PoS network with ~75 validators.

Strengths: Can transmit any data, not just token transfers. This means cross-chain governance votes, NFT transfers, contract calls – the full composability stack. LayerZero’s omnichain fungible tokens (OFTs) provide canonical representations across chains rather than wrapped versions.

Weaknesses: Speed is constrained by finality on source chains plus validator confirmation. Typical transfer times range from 1-15 minutes. TVL custody risk remains for token transfers – Portal holds $1.9B in locked assets. Validator set compromise is a systemic risk.

Architecture 2: Intent-Based Bridges (Across, deBridge, UniswapX)

As Diana described, these shift execution to professional solvers who front capital.

Strengths: Sub-5-second execution for typical transfers. Zero or minimal protocol-level TVL. Risk is distributed across individual solvers rather than concentrated in contract pools. ERC-7683 creates a standardized solver market.

Weaknesses: Capital-intensive for solvers – you need deep inventory across every supported chain and token pair. This creates centralization pressure, because only well-capitalized entities can serve as competitive solvers. For large transfers (over $100K), solver liquidity becomes a bottleneck, and execution may fall back to slower settlement paths. Intent bridges also cannot transmit arbitrary cross-chain messages – they are optimized for asset transfers specifically.

Architecture 3: ZK-Based Bridges (zkBridge, Succinct, Polymer)

These use zero-knowledge proofs to verify source chain state on the destination chain without trusting any external validator set. A ZK proof mathematically demonstrates that a transaction was included in a finalized block.

Strengths: Trust-minimized – you are trusting math, not validators. No external security assumptions beyond the source chain’s own consensus. Once ZK proof generation becomes fast enough, this is the theoretically optimal bridge design.

Weaknesses: Proof generation latency is still the bottleneck. Even with hardware acceleration and recursive proof composition, generating a ZK proof of Ethereum’s consensus state takes minutes to hours depending on the proving system. Cost is also non-trivial – proof generation for a single bridge transaction can cost $0.50-$5.00 in compute. These bridges cannot handle high-frequency, low-value transfers economically.

The Realistic Assessment

Intent-based bridges dominate the user-facing transfer market because speed and cost are what end users care about. But messaging bridges remain essential for cross-chain composability beyond simple transfers. And ZK bridges represent the long-term ideal for trust-minimized verification, particularly for high-value institutional transfers where settlement certainty matters more than speed.

The smart play is hybrid architectures. Across already uses UMA’s optimistic oracle as a fallback settlement layer. I expect we will see intent bridges adopt ZK proofs for settlement verification within 18 months, combining the speed of solver-fronted execution with the trust guarantees of mathematical proof. That convergence is the real endgame.

[crypto_chris]

The Trading and Market Perspective on Intent Bridges

Solid analysis across the board. Let me bring the market and trading lens to this, because the shift to intent-based bridges has direct implications for token economics, solver profitability, and arbitrage opportunities.

Bridge Token Economics Are Fundamentally Changing

Traditional bridge protocols derived their token value from TVL-based security models. Axelar’s AXL token secures a validator set that custodies assets. Stargate’s STG token governs liquidity pools. The token’s utility was directly tied to the amount of capital locked in the protocol. This created a reflexive dynamic: higher token price attracted more staking and liquidity, which theoretically improved security, which drove more usage.

Intent-based bridges break this model entirely. Across’s ACX token does not secure a pool of user assets – there is no pool to secure. Instead, ACX governance directs protocol parameters, fee structures, and relayer incentives. The $98M in TVL on Across is relayer capital earning yield on deposits, not a security budget.

deBridge’s DBR token is even more interesting. With $10B settled and effectively zero protocol TVL, the token’s value proposition shifts entirely to fee capture and governance rights over the protocol’s fee switch. When a bridge processes $10B in volume at even 5-10 basis points average fee, that is $5-10M in annual revenue flowing through the protocol.

Are Solver Margins Sustainable?

This is the critical question from a trading perspective. Across relayers currently earn their margin from the spread between user fees and their cost of capital. For a typical L2-to-L2 transfer under $10K, the user pays roughly 5-15 basis points. The relayer’s cost includes:

• Capital opportunity cost: Funds tied up in inventory across 10+ chains
• Gas costs: Transaction fees on both origin and destination chains
• Settlement risk: The window between filling an order and receiving repayment
• Inventory rebalancing: Moving capital back to chains where demand is highest

My estimate from on-chain data is that competitive relayers are earning 3-8 basis points net margin per fill. That sounds thin, but at $1.3B monthly volume, even 5 basis points translates to $650K monthly gross revenue for the entire relayer pool. The question is whether ERC-7683 standardization drives margins to near-zero as more solvers enter the market.

Arbitrage Opportunities in the Cross-Chain Intent Market

Here is what I find most interesting from a trading perspective. The intent model creates several exploitable inefficiencies:

1. Cross-protocol price discrepancies: When Across quotes 8 bps for an ETH bridge and deBridge quotes 12 bps for the same route, sophisticated traders can route through the cheaper option or even arbitrage between the two.

2. Inventory imbalance pricing: When solver inventory gets skewed (heavy demand on Arbitrum-to-Base, light demand on the reverse), relayer fees on the popular route increase. Traders monitoring these imbalances can time their bridges to capture cheaper rates.

3. Token bridge arbitrage: When the same token trades at slightly different prices across L2s, intent bridges create the fastest path to capture that spread. At 3-second L2-to-L2 execution, you can effectively arbitrage DEX prices across rollups in near real-time.

4. Solver competition dynamics: When a new ERC-7683-compliant protocol launches, there is typically a period of reduced solver competition, meaning wider spreads and more profit for early participants.

My Trading Thesis

I am currently long on the intent bridge narrative for three reasons. First, Uniswap’s integration of Across validates the model at the highest level of DeFi. Second, ERC-7683 creates a network effect where each new compliant protocol strengthens the entire solver market. Third, the $2.8B in bridge hack losses creates regulatory and institutional pressure to move away from custodial bridge models.

The risk is solver centralization. If three or four well-capitalized entities dominate the solver market, we have recreated the same central point of failure that intent bridges were supposed to eliminate – just at a different layer of the stack.

[ethereum_emma]

The Developer and User Experience Side of Intent Bridges

This thread has covered the economics, architecture, and trading angles really well. I want to share what it actually feels like to integrate these protocols from a developer perspective, because the DX gap between intent-based bridges and traditional bridges is significant.

Integrating Across vs Traditional Bridges

I recently integrated both Across and a traditional messaging bridge into a cross-chain DeFi frontend, and the difference was striking.

With the traditional messaging bridge, the integration required me to handle multiple states: pending deposit confirmation, waiting for message relay, waiting for destination chain execution, and handling various failure modes (message timeout, insufficient relayer gas, destination chain reorg). The user flow had a minimum of 3 separate status screens, and I needed to implement a polling system to track message progress across chains. The SDK documentation was extensive but assumed deep knowledge of the underlying protocol mechanics. Total integration time: about two weeks.

With the Across SDK, the integration was closer to a standard swap interface. The user approves a token spend, submits the bridge transaction, and within seconds the funds appear on the destination chain. From a frontend perspective, I only needed to handle two states: pending and complete. The SDK abstracts away the entire solver competition, optimistic oracle settlement, and repayment verification. The user does not need to know or care that a relayer fronted their funds. Total integration time: roughly three days.

UX Improvements for End Users

The UX difference from the user’s perspective is even more dramatic. I ran informal usability testing with 15 people – a mix of crypto-native and newcomer users. Key findings:

Speed perception: With the traditional bridge, users consistently asked “is it stuck?” after 30 seconds. With Across, L2-to-L2 transfers completed before users had time to worry. The 3-second execution time changes the mental model from “bridging is a risky waiting game” to “bridging just works.”

Error handling: Traditional bridges have multiple failure modes that surface confusing errors to users – destination chain gas estimation failures, relayer timeouts, message expiration. Intent bridges simplify this dramatically. Either a solver fills your order or it reverts, and you get your funds back on the source chain. There is no intermediate state where your funds are “in the bridge.”

Fee transparency: Across shows a single upfront fee. Traditional bridges often have hidden costs – origin chain gas, relay fees, destination chain gas – that are hard to predict before the transaction. One user in my testing described the traditional bridge fee structure as “a surprise bill at a restaurant.”

SDK Comparison

For developers considering which to integrate:

Across SDK: Clean TypeScript interfaces, good type safety, straightforward quote-then-execute flow. The @across-protocol/sdk package handles route discovery, fee estimation, and transaction construction. Weakness: documentation could be more thorough on edge cases, and the SDK does not yet fully support all ERC-7683 features.

deBridge SDK (dln-client): Also well-structured, with good support for multi-step transactions. Their API-first approach means you can integrate via REST endpoints without a heavy SDK dependency, which is nice for teams that prefer lighter integrations. The validator-based settlement means slightly different error handling patterns than Across’s optimistic oracle.

Traditional bridge SDKs (LayerZero, Wormhole): More mature ecosystems with broader chain support and extensive documentation. If you need arbitrary cross-chain messaging beyond token transfers – cross-chain governance, cross-chain NFT transfers, cross-chain contract calls – these are still your only option. The tradeoff is complexity and slower execution.

What Uniswap’s Integration Signals

Uniswap choosing Across for in-app bridging is the strongest validation signal the intent model has received. Uniswap has the most demanding UX standards in DeFi and the largest user base. The fact that they evaluated the entire bridge landscape and chose an intent-based solution tells you where the industry is heading. For developers building cross-chain experiences, I would strongly recommend starting with intent-based SDKs unless you specifically need arbitrary message passing.

The gap is closing fast, and ERC-7683 will only accelerate it.