Crypto Basics

News

Governance

Guides

Product Info


## TL;DR

-   TWAP (Time-Weighted Average Price) orders split a large trade into equal parts, executed at regular intervals, to reduce the price impact of your own trade - not to guarantee a better price or protect you from every mistake.
    
-   The five mistakes below: assuming any TWAP shields you from MEV, mismatching duration/part count to your order size, skipping price protection, over-slicing your order, and under-approving your token allowance.
    
-   CoW Protocol's TWAP orders settle through the same solver-run batch auctions as every other order on CoW Swap, which changes the MEV picture compared with manually firing off repeat swaps on a public AMM.
    
-   None of this is "set and forget." A few minutes of setup is the difference between a TWAP that does its job quietly and one that limps along half-filled.
    

## Why TWAP mistakes are easy to make

[TWAP](https://swap.cow.fi/#/1/advanced/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) has a reputation as the sensible, grown-up order type - the one you reach for when a trade is too big to just fire off in one transaction without moving the market against yourself. That reputation is earned. Splitting a large order into smaller, evenly-timed pieces is one of the oldest tricks in institutional execution, crypto included.

But "time-weighted average price" is doing a lot of quiet work in that name, and it's easy to assume it does more than it actually does. [TWAP](https://swap.cow.fi/#/1/advanced/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) smooths out the impact of your own trade. It doesn't forecast the market, guarantee a favourable price, or forgive a sloppy setup. Here are five mistakes that trip people up, and how to sidestep them - with notes on how CoW Protocol's version of TWAP handles each one.

### Mistake #1: Assuming any TWAP protects you from MEV

A "[TWAP](https://swap.cow.fi/#/1/advanced/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48)" isn't one thing - it's a pattern (split the order, spread it over time), and how that pattern gets executed matters enormously. Manually fire off ten swaps through a wallet on a public AMM at regular intervals, and you haven't built yourself a shield - you've built a schedule. Each slice is its own transaction sitting in the public mempool, predictable and evenly spaced. An MEV searcher can watch for slice two, front-run it, let it fill at a worse price, back-run it, then repeat for slice three, four, and five. Ten slices, ten small sandwiches, instead of one big one.

CoW Protocol's [TWAP orders](https://swap.cow.fi/#/1/advanced/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) work differently: every part settles through the same solver-run batch auction as every other CoW Swap order, rather than landing in the public mempool as an isolated, predictable transaction. That's a structurally different setup from a DIY mempool TWAP, and it removes that specific attack surface - though, as with any onchain system, no venue can promise immunity from every possible form of adverse trading.

How to avoid it: Don't treat "spread it over time" as protection on its own. Check whether the venue's TWAP settles through a design that accounts for MEV, or whether you're just handing a bot a schedule.

### Mistake #2: Picking a duration or part count that doesn't fit the trade

Too short a window, and you haven't spread the order out enough to get the benefit - you're paying the setup cost of a [TWAP](https://swap.cow.fi/#/1/advanced/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) for the impact profile of a single swap. Too long, and you've swapped one risk for another: your average price is now exposed to wherever the broader market wanders during that window. TWAP smooths your own footprint; it does nothing to stop the market trending against you while you wait.

Rough rule of thumb: the bigger your order relative to the asset's normal trading activity, the more parts and the longer the duration you want, so each individual slice is small relative to available liquidity. A trade that's a small fraction of daily volume for a major pair rarely needs hours; one that's a meaningful chunk of it might.

How to avoid it: Set duration and number of parts together, with your order size and the asset's typical liquidity in mind - not a default you left untouched.

### Mistake #3: Skipping price protection (or setting it too tight)

CoW Protocol's [TWAP orders](https://swap.cow.fi/#/1/advanced/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) include a price protection setting - a minimum acceptable price per part. Leave it unset, and a part can execute at whatever price is available the moment it triggers, including during a sudden bad move. Set it too tight against a moving market, and parts simply won't execute at all - your order stalls, unfilled, while you wait for a price that may not come back in time.

How to avoid it: Set price protection with some real headroom for normal volatility - not zero, and not so strict it defeats the order's purpose.

### Mistake #4: Slicing the order thinner than it needs to be

More parts isn't automatically better. Every part is its own onchain execution, and each one needs to be worth doing. Split a modest order into far more parts than it needs, and you can end up with pieces so small the costs eat into any benefit, without meaningfully improving your average execution price versus a handful of well-sized parts. CoW Protocol enforces a minimum size per part for exactly this reason - the figure varies by network, so check the current numbers on the TWAP order screen or [docs.cow.fi](http://docs.cow.fi) before you set your part count.

How to avoid it: More parts should buy you something - less impact, better averaging. If it's just buying you more transactions, dial it back.

### Mistake #5: Approving only enough for the first slice

A [TWAP](https://swap.cow.fi/#/1/advanced/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) order isn't one transaction - it's a series of parts triggering over your chosen duration, and your token approval needs to cover the whole thing: every part, not just the first. With exact/partial allowances now available for TWAP orders on CoW Swap (rather than defaulting to an unlimited approval), this is an easy trap: you approve an exact amount, but base it on one part instead of the full order. The first slice or two go through fine, then the order quietly stalls once the approval runs dry.

How to avoid it: Base your approval on the total sell amount - part size × number of parts - not the per-part figure. Exact allowances are a good habit; just make sure "exact" means exact for the whole order.

## Bringing it together

[TWAP](https://swap.cow.fi/#/1/advanced/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) remains one of the better tools for executing size without broadcasting your intentions to the entire market - but "better tool" still means a tool that rewards a bit of setup. Match duration and part count to the trade, set price protection with room to breathe, don't over-slice, and approve for the full order rather than the opening move.

Ready to put it into practice? Head to CoW Swap, choose TWAP from the order type menu, and give it a proper go.

## Recommended reading

-   [Getting to Grips with Time-Weighted Average Price (TWAP) Orders](https://cow.fi/learn/getting-to-grips-with-time-weighted-average-price-twap-orders)
    
-   [Why TWAP? The Perks of Time-Weighted Average Price](https://cow.fi/learn/why-twap)
    
-   [TWAP vs. Limit Orders: Which Should You Use and When?](https://cow.fi/learn/twap-vs-limit-orders-which-should-you-use-and-when)
    
-   [How to Use CoW Swap's TWAP Orders via Safe Wallet](https://cow.fi/learn/how-to-use-cow-swap-twap-orders-via-safe-wallet)
    
-   [When to Swap and When to TWAP](https://cow.fi/learn/when-to-swap-when-to-twap)
    
-   [TWAP Orders - Technical Docs](https://docs.cow.fi/cow-protocol/concepts/order-types/twap-orders)

large_5 Common TWAP Order Mistakes.png

medium_5 Common TWAP Order Mistakes.png

small_5 Common TWAP Order Mistakes.png

thumbnail_5 Common TWAP Order Mistakes.png

5 Common TWAP Order Mistakes.png

TWAP orders can cut the price impact of a large trade, but only if they're set up right. 5 common TWAP mistakes on CoW Protocol, from MEV myths to under-sized parts and under-approved allowances, plus how to avoid each one.

5 Common TWAP Order Mistakes (and How to Avoid Them)

A token approval is a standing, on-chain permission that lets a smart contract move a specific token out of your wallet, and it stays active until you explicitly revoke it. That means an approval you granted years ago can still be live today, including for contracts that have since been upgraded, abandoned, or compromised. This article explains why unlimited approvals are a standing risk, how to audit and revoke the ones you no longer need, and how signed intents keep new approvals from piling up in the first place.

**TL;DR**
* A token approval is a standing on-chain permission that survives indefinitely.
* [60% of approval transactions](https://dl.acm.org/doi/fullHtml/10.1145/3545948.3545963) are unlimited, leaving 22% of users at high risk.
* Approvals don't expire when you disconnect your wallet or stop using a protocol.
* Auditing and revoking old approvals is sound hygiene, but it treats the symptom.
* Scoped, expiring EIP-2612 signatures keep your approval count from growing with each trade.

## What a token approval actually grants

When you approve a token for a protocol, you're calling the ERC-20 approve() function. That function registers a specific address (the spender) as permitted to transfer tokens out of your wallet. Per the [Ethereum ERC-20 standard](https://ethereum.org/developers/docs/standards/tokens/erc-20/), the approve function "allows spender to withdraw from your account multiple times, up to the value amount."

"Multiple times" is the operative phrase. You're not authorizing a single transaction. You're delegating a capability the spender can exercise at any point in the future, without asking again.

The permission sits on-chain until you explicitly revoke it. The spender needs no further action from you.

## Why unlimited approvals are the risk hiding in your wallet

You control the approval amount, but most protocols don't give you that choice. They request the maximum possible value, known as an unlimited approval. This avoids a new approval transaction every time you interact. The convenience saves gas. The trade-off is that the protocol can pull your entire balance of that token at any time.

Unlimited approvals account for 60% of all analyzed transactions (15.2 million out of 25.4 million), and the same dataset found 22% of users carry a high risk of token theft from excessive allowances.

Exploiting an unlimited approval is relatively straightforward once the permission is granted. [Fireblocks' 2025 report](https://www.fireblocks.com/report/protect-your-business-from-defi-signing-attacks) documents the consequence: "the attacker no longer requires any further interaction with you in order to drain these funds." The contract can pull your tokens weeks or months later. Nothing you do triggers it.

## Approvals don't expire: the permissions you forgot you gave

Closing your browser or disconnecting a wallet doesn't kill an approval. Because the permission lives on-chain, not in your active session, it survives even if you never visit the dApp again.

That gap matters because users rarely revisit their approval list. Just 17.6% of DeFi scam victims regularly checked their token approvals after being exploited, [according to a 2025 Georgia Tech study](https://news.research.gatech.edu/2025/05/08/decentralized-finance-booming-so-are-security-risks). Twenty-six percent took no action at all.

A wallet active for two or three years likely carries dozens of standing approvals. Many point to contracts that have been upgraded or abandoned. Per the [CoW Protocol SDK](https://cowprotocol-cow-sdk.mintlify.app/guides/token-approvals), a compromised approved contract puts all your tokens at risk. The protocol doesn't need to be running for the approval to remain exploitable.

## How to audit and revoke approvals you no longer need

Auditing approvals shrinks your attack surface. It won't stop new permissions from accumulating, but it closes the doors you've already left open:
* Connect your wallet to [Revoke.cash](https://revoke.cash) or Etherscan's token approval checker. Both scan your address and show every spender contract with a standing allowance, the approved amount, and the last activity date.
* Assess which approvals are still doing work. If you rely on an approval for a recurring position or active limit order, leave it. If you haven't touched the protocol in months, treat that entry as a liability.
* Revoke everything else. Each revocation sets the approved amount to zero via an on-chain transaction. On Ethereum mainnet the gas cost can be meaningful; on L2s it drops substantially.

[Auditing and revoking approvals](https://cow.fi/learn/getting-started-with-de-fi-your-comprehensive-guide-to-decentralized-finance) is a sound habit and part of any solid [DeFi security routine](https://cow.fi/learn/how-to-dyor-2026). But it's maintenance, not prevention. Revoke today, and the list starts rebuilding the moment you interact with a new protocol.

## Approve once, then trade with signed intents instead of per-trade permissions

### The structural problem with legacy approvals

Every time you interact with a new protocol using the legacy approve() model, you add another entry to your approval ledger. After a year of active DeFi use, that ledger holds approvals to contracts that may have changed hands or been patched. Some have accumulated years of unreviewed code changes. Revocation clears entries; it doesn't stop new ones from forming.

### How EIP-2612 changes the model

By using EIP-2612, you grant one on-chain approval to a shared contract. After that, every individual trade is authorized through a gasless off-chain signature. Each signature is scoped to a token, an amount, and an expiry. The EIP-2612 contract validates the signature and executes the transfer.

The result: your on-chain approval count stops growing with each new protocol interaction. EIP-2612 is now the default approval layer for most major DEX and wallet flows, per a [2026 industry guide](https://eco.com/support/en/articles/12005545-what-is-permit2-a-2026-guide-to-token-approvals). It cuts both gas costs and the risk of deceptive signature requests for ERC-20 spends.

### CoW Swap's implementation

CoW Swap builds on this model through its [gasless approvals](https://cow.fi/learn/announcing-gasless-approvals-on-cow-swap) feature. For over 150 tokens, the approval and swap run in a single flow. EIP-2612 removes the separate on-chain approval transaction. You sign once, and the intent goes to competing solvers who settle the trade. The scoped permission expires after the trade rather than sitting open indefinitely.

### The honest trade-off

Signature-based flows reduce the number of on-chain approvals, but they introduce a different risk. An off-chain EIP-2612 signature that looks like a routine wallet pop-up can grant a scoped but real permission if you sign something malicious. Off-chain messages are also harder for most wallets to display in readable form, which means the social engineering risk shifts rather than disappears. EIP-2612 creates a smaller attack surface than unlimited on-chain approvals, but reading what you sign remains non-negotiable.

## Why gasless, off-chain orders reduce your total on-chain permissions

Because trades route through signed intents, your on-chain approval count stays flat. It doesn't climb with each new protocol you touch. You aren't granting a new spender contract access to your tokens every time you try a new pool or protocol.

CoW Hooks extend this further. Pre-hooks let you bundle a scoped approval directly with your swap intent, so the approval and trade happen atomically in one operation. Per [CoW Hooks documentation](https://cow.fi/learn/cow-hooks-you-are-in-control), pre-hooks sign approvals before a trade and post-hooks handle bridging or staking afterward. All of it runs within a single intent. Nothing lingers.

There's also a monitoring benefit. Because [every DeFi action, including approvals, appears on-chain](https://cow.fi/learn/defi-security-best-practices), a shorter approval list is a more legible one. A suspicious contract call is easier to catch when you're reviewing 4 active approvals than when you're scanning through 40.

## Trade with fewer on-chain permissions on CoW Swap

### For individual traders

CoW Swap applies this intent-based model to [over 150 tokens](https://cow.fi/learn/announcing-gasless-approvals-on-cow-swap) through EIP-2612. The first time you trade a supported token, you sign an off-chain message instead of submitting an on-chain approval transaction. That permission is scoped to the trade and expires once it settles. No standing unlimited allowance accumulates on the protocol's contract.

For tokens not yet covered by gasless approvals, CoW Protocol routes to the vault relayer contract. That's a single shared endpoint, not a new spender contract per protocol. Your approval list stays shorter over time either way.

### For DAOs and treasury holders

As a DAO or treasury holder, you face the same approval risks as retail traders, but at a scale where a single misstep affects much more. CoW's Milkman contract - a Yearn-built contract funded through the CoW DAO Grants program - addresses a risk unique to your organization. A governance vote to sell $20 million in treasury tokens is public before it executes, which invites front-running.

Milkman uses delayed execution: the trade is approved once, then executes only when price conditions are met, preventing bots from acting on a known intent. Aave and ENS have together moved over $20M through Milkman", [per CoW Protocol's documentation](https://cow.fi/learn/what-is-milkman-cow-swaps-solution-for-delayed-execution-trading).

ENS executed a [$15 million treasury swap via CoW Swap](https://daostar.org/research/delegating_decentralization.pdf). The selection criteria included minimal slippage and MEV protection, both properties of the intent-based, solver-competition model. No expanded on-chain approval footprint was required to execute at that scale.

## Why a shorter approval list is safer by default

Only 0.2% of users approve exact amounts and revoke promptly after every trade, so the more useful target is a trading workflow that makes the problem smaller by default. Every time you use scoped, expiring signatures instead of standing on-chain allowances, your approval list stays flat instead of accumulating open permissions. That is the structural fix: a workflow that rarely needs revocation in the first place.

## FAQs about defi token approvals

### Does disconnecting my wallet revoke token approvals?

No, disconnecting your wallet only terminates the active session between your interface and the dApp. Because token approvals are recorded on-chain in the smart contract's state, the permission remains active and exploitable until you submit a specific revocation transaction to the blockchain.

### What happens to my limit orders if I revoke an approval?

Revoking an approval for a specific token will cause any active limit orders or recurring positions relying on that token to fail. The protocol’s smart contract will no longer have the required permission to pull funds from your wallet when your price target is hit, effectively canceling the trade's ability to execute.

### How do I tell if a EIP-2612 signature request is malicious?

Legitimate EIP-2612 requests use the [EIP-712 standard](https://eco.com/support/en/articles/12005545-what-is-permit2-a-2026-guide-to-token-approvals) to show human-readable details, including the specific token, exact amount, and an expiration timestamp. If a wallet prompt shows a raw, unreadable hex string or requests an unlimited duration for a single trade, it is likely a phishing attempt designed to drain your assets.

### Which tokens does CoW Swap support for gasless approvals?

CoW Swap supports [over 150 tokens](https://cow.fi/learn/announcing-gasless-approvals-on-cow-swap) for gasless approvals, including major assets like DAI, GNO, and various liquid staking tokens. For tokens that do not support the EIP-2612 permit standard, the protocol routes through a vault relayer to minimize the number of unique spender contracts you must approve.

### Is it worth the gas cost to revoke an approval for a small balance?

If the gas cost to revoke exceeds the value of the tokens at risk, it may not make economic sense to revoke immediately. However, since unlimited approvals cover your entire future balance of that token, you should revoke any permission to a compromised or unverified contract regardless of your current holdings to protect future deposits.


Token approvals don't expire. Learn why unlimited approvals are a standing risk, how to audit them, and how signed intents reduce your exposure to exploits.

Understanding Token Approvals in DeFi

DeFi liquidity comes from five distinct sources — and which one your trade routes through shapes the price you get more than almost anything else. Most interfaces route to a single pool by default and leave the other four untouched: order books, private market makers, peer-to-peer matches, and solver-routed liquidity. Each one prices a trade differently, based on its own formula, current depth, and recent activity. This article maps all five sources and explains why reaching every one of them at once produces a better price.

**TL;DR**
* DeFi liquidity has five sources, and the source determines your price.
* The five: AMM pools, order books, private market makers, peer-to-peer matches, and solver routes.
* AMM stale pricing costs LPs [5 to 7 percent of capital](https://arxiv.org/pdf/2307.02074) annually via Loss-Versus-Rebalancing.
* Most interfaces access only one source, so better prices elsewhere go uncaptured.
* [OECD data](https://www.oecd.org/content/dam/oecd/en/publications/reports/2024/04/concentration-of-defi-s-liquidity_5df1e8f9/4ed08440-en.pdf): most pools are 98 to 100 percent held by one provider.
* Solver competition queries every venue at once, so the best path wins automatically.

## Liquidity 101: what it means for a trade to fill

Liquidity, in execution terms, is the ability to buy or sell without moving the price against yourself. The deeper the liquidity at your trade size, the smaller the slippage. A token pair with $10,000 of available depth at a given price is technically liquid. Try to trade $50,000 through it and the price moves against you.

DeFi's ecosystem is now large enough to support distinct liquidity venues, with specialized options for different trade types, sizes, and participants. Which venue your trade hits determines the price you capture, and accepting the default leaves that choice to the interface.

## AMMs and bonding curves: the pools most swaps touch

[Automated Market Makers](https://cow.fi/learn/understanding-automated-market-makers-a-beginner-s-guide-to-de-fi-liquidity) (AMMs) are the most common liquidity source in DeFi. An AMM holds a pair of tokens in a smart contract and prices trades algorithmically. The ratio between the two tokens determines the price. Buy token A, and the pool now holds less of it, so A's price rises. Sell A, and the ratio shifts the other way. No counterparty is needed. The formula and the reserves do the work.

[Liquidity providers](https://cow.fi/learn/what-is-a-liquidity-provider) deposit both tokens into the pool and earn fees on every trade. AMM prices update only when a trade occurs. Between trades, the pool's price can lag the true market price. Arbitrageurs close that gap by trading against the pool at the LP's expense. Research [published on arXiv](https://arxiv.org/pdf/2307.02074) estimates this [Loss-Versus-Rebalancing (LVR)](https://cow.fi/learn/the-risks-of-providing-liquidity-unmasking-lvr-in-de-fi) costs LPs 5 to 7 percent of capital annually. Fee income rarely covers it.

A pool with a large total value locked can look like deep liquidity. TVL tells you how much is deposited, not how much you can trade without price impact. A concentrated position covering only a narrow price band may deliver worse execution on a large trade than a shallower pool with full-range coverage. Depth at the current price is what drives slippage, not the headline TVL figure.

## Order books and the limits of on-chain depth

On-chain order books work the way traditional exchange order books do: traders post bids and asks at specific prices. A trade fills when a posted order matches the incoming price. The depth of the book at any given price determines how much you can trade there without gaps.

Gas costs constrain on-chain order books: posting a bid, updating it when the market moves, or canceling it when conditions change all incur transaction fees. That overhead deters the continuous quoting activity that keeps a traditional order book tight. A market maker on a centralized exchange might update quotes thousands of times per minute, a pace that would be economically ruinous on-chain. The result is order books that tend to be thin outside the highest-volume token pairs. Spreads widen. Gaps appear in the book at larger trade sizes, and traders absorb more price impact than they would on a tighter venue.

## Private market makers: the inventory aggregators often miss

Professional market makers hold token inventory and quote prices directly to fill trades. These providers use real-time market data; a bonding curve formula plays no role in their quotes. For large trades or common token pairs, their quotes can beat AMM prices. Market maker quotes reflect current conditions, not the lagging state of a pool last touched several blocks ago.

Most swap interfaces never access these quotes. Aggregators that route exclusively through on-chain liquidity leave private market maker pricing entirely off the table.

The lack of access to private quotes matters more as institutional capital enters the ecosystem. As tokenized real-world assets and Treasuries grow, professional capital increasingly operates through professional quoting infrastructure, and most interfaces can't reach it.

## Peer-to-peer matching: when two traders are each other's liquidity

The simplest form of liquidity is two traders who want opposite sides of the same trade at the same time, with no pool, no formula, and no LP fee involved. If another trader in the same batch wants the reverse of what you want, you fill each other directly.

CoW Protocol calls this a Coincidence of Wants (CoW). It can produce a better price than a pool-based route because neither trader pays a spread to an intermediary.

CoW Protocol runs this check on every batch before touching any external venue. When two orders match directly, the protocol [settles them peer-to-peer](https://cow.fi/learn/how-cow-protocol-actually-works). No pool fees, no bonding curve slippage, and no exposure to predatory Maximal Extractable Value (MEV). The match doesn't require any configuration from the trader. It happens automatically whenever opposing orders share the same batch.

## Why tapping one source can limit price discovery

AMMs price by formula regardless of what private market makers are currently quoting. A pool might offer 1.5 percent slippage on a trade that a professional market maker would fill at 0.3 percent. The interface routing exclusively to that pool will never surface the difference.

On-chain order books may have no liquidity at the price and size you need. Wide spreads and thin depth mean even a moderately sized trade can move materially through available orders.

### Off-chain and peer-to-peer sources

Private market maker quotes don't appear in interfaces that scan only on-chain liquidity. A better price exists; the trader simply can't see it.

Peer-to-peer matches don't happen if no one looks for them. An interface routing to a single pool won't detect that another order in the system would have filled yours directly.

The concentration problem compounds all of this. [OECD research](https://www.oecd.org/content/dam/oecd/en/publications/reports/2024/04/concentration-of-defi-s-liquidity_5df1e8f9/4ed08440-en.pdf) found that on average, 98 to 100 percent of a given pool's assets are held by a single provider. A single-provider pool can reprice sharply on a large trade, or gap entirely if that provider withdraws. When exploring [liquidity in DeFi](https://cow.fi/learn/understanding-how-liquidity-works-in-de-fi-what-it-is-and-why-it-matters-to-you), this concentration means headline depth numbers mislead more often than they inform.

## How solvers source from every venue at once

Solvers change what the routing problem looks like. A trader submits an intent: what they want to trade, at what minimum acceptable price. Solvers (independent third parties competing for the right to settle the trade) then search across all available sources simultaneously.

A solver checks every available source: AMM pools, on-chain order books, private market maker quotes, and peer-to-peer matches within the same batch. It constructs the fill path that returns the best price. The solver that finds the best execution wins the settlement. Solver competition forces a genuine search across venues. It avoids the default route to whichever pool the interface has hardcoded.

The Aave DAO's treasury management provides a concrete measure of what that search produces. Aave executed a $1.94 million DAI-to-USDC swap through CoW Protocol's solver competition. The result was a [$9,699.15 surplus](https://cow.fi/learn/aave-trade-breakdown) above the target price. The trade had been announced publicly in a governance proposal before execution, the kind of advance notice that typically invites automated arbitrage. Solver competition found a better price than the DAO could have sourced manually. Competition created value where a manual route would have left it behind. [Aave Labs cited CoW Protocol](https://www.theblock.co/amp/post/381336/aave-cow-mev-protected-swaps-intent-based-flash-loans) for its intent-based architecture and onchain transparency as reasons for the ongoing partnership.

## Solving the sourcing problem

CoW Protocol runs solver competition on every trade by default. Peer-to-peer matches, private market maker quotes, and on-chain liquidity are all checked before any order settles. The trader doesn't configure this. It happens on every swap.

[Limit orders on CoW Swap](https://cow.fi/learn/defi-limit-orders) are gasless unless the trade executes. Solvers take on the transaction risk. Any price improvement above your limit price returns to you as surplus, not to the protocol.

For liquidity providers, [CoW AMM](https://cow.fi/cow-amm) routes price discovery through a competitive solver auction. Arbitrage surplus that would otherwise exit the pool as LVR flows back to LPs instead.

The single-pool default this article opened with is not really an interface problem; it is a sourcing problem. When a trade can reach every venue at once, the best price stops depending on which default a developer hardcoded and starts depending on which solver competed hardest to fill it.

## FAQs about defi liquidity

### What happens if no peer-to-peer match is found for a trade?

If a batch auction does not contain a Coincidence of Wants (CoW) to match your order peer-to-peer, the trade does not fail. Instead, solvers automatically fall back to the most efficient route across external sources, including AMM pools, on-chain order books, and private market makers, to ensure the trade fills at the best available market price.

### How do impermanent loss and LVR differ for liquidity providers?

Impermanent loss occurs when the price of deposited assets diverges in any direction, whereas Loss-Versus-Rebalancing (LVR) specifically measures the value leaked to arbitrageurs because of stale pool prices. While impermanent loss can reverse if prices return to their original ratio, [LVR is a permanent cost](https://cow.fi/learn/the-risks-of-providing-liquidity-unmasking-lvr-in-de-fi) that typically totals 5 to 7 percent of capital annually.

### Do private market makers provide liquidity for every token pair?

Private market makers typically focus on high-volume pairs and liquid assets where they can manage inventory risk effectively. For niche or long-tail tokens, liquidity usually defaults to AMM bonding curves. However, as tokenized real-world assets reached [$25 billion in 2026](https://www.sec.gov/files/ctf-written-craig-m-lewis-economic-analysis-defi-04-07-2026.pdf), professional market makers have increasingly expanded their quoting activity into institutional-grade assets.

### Does concentrated liquidity count as deep liquidity for large trades?

Concentrated liquidity only provides depth within a specific, narrow price range. If a large trade exceeds that range, it may experience significant slippage or fail to fill entirely, even if the pool has a high total value locked. For large executions, solver-based routing is necessary to aggregate depth from multiple price bands and venues simultaneously.

### How is a solver different from a standard DEX aggregator?

A standard aggregator splits a trade across multiple on-chain pools based on a static snapshot of the market. A solver is an independent participant in a competitive auction that searches for the best execution path in real-time, including off-chain liquidity and peer-to-peer matches. In CoW Swap, solvers also take on the transaction risk, so users [pay no gas](https://cow.fi/learn/defi-limit-orders) for failed trades.


DeFi liquidity comes from five distinct sources. Learn how each one prices your trade, and why routing to all of them at once gets you the best price.

Where Does Liquidity Come From in DeFi?

You set your price. You closed the tab. You came back three days later expecting a filled order and a small dopamine hit - and instead you're staring at the same open order, patiently waiting, like a text message left on read.

Before you assume something's broken: it probably isn't. [CoW Swap limit orders](https://swap.cow.fi/#/1/limit/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) don't work quite like the limit orders you're used to on a centralized exchange, and that difference is usually  _why_  it hasn't filled. Here's what's actually going on, and what you can do about it.

## A quick refresher on how CoW Swap limit orders work

When you place a limit order on [CoW Swap](https://swap.cow.fi/#/1/limit/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48), you're not sending a transaction - you're signing an intent: "I want to sell X for at least Y." That intent goes into a batch with everyone else's orders, and independent solvers compete to find the best way to execute the whole batch. The solver that generates the most value for the batch wins, and it settles everyone's orders on-chain in one go.

This is why placing and cancelling limit orders on [CoW Swap](https://swap.cow.fi/#/1/limit/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) costs no gas - you're not touching the chain until a solver actually executes your order. It's also why your order isn't guaranteed to fire the instant the market touches your number. Execution depends on a solver finding a valid, worthwhile settlement for it in that particular auction round. So if it hasn't filled, it's usually one of five things.

### **1. The price genuinely hasn't reached your limit.**  
The most boring explanation is usually the right one. Check the market price against the price you set. This is worth stating because [CoW Swap](https://swap.cow.fi/#/1/limit/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48)'s limit orders are actually stricter in your favour than most: if the market moves past your limit price, you get that better price, not just your stated limit. So it's never firing early - it fires at your price or better.

### **2. The price has reached your limit - but not by enough to cover network fees.**  
This one trips people up because it's specific to how CoW Protocol prices limit orders. There's no upfront fee for placing a limit order. Instead, the protocol waits until the market price clears  _both_  your limit price  _and_  the network cost of settling the trade, then takes the fee out of that margin. So you can watch the spot price tick past your limit and still see nothing happen - because there isn't yet enough room above your limit to also cover gas.

The open orders panel actually shows you this directly: check the "Executes At" column next to your order. That's the real price your order needs to hit, fees included, and the little traffic-light indicator gives you a rough sense of how close you are.

### **3. It's partially filled - and the rest is dust.**  
By default, CoW Swap limit orders are partially fillable, which means they can fill gradually as liquidity shows up rather than needing to fill all at once. That's usually a good thing: partial fills tend to complete faster and at better prices than all-or-nothing orders. 

But it means you might look at your order and see it's 94% filled with a small remainder sitting there - and if that remainder is small relative to the network fee needed to settle it, a solver may not bother executing it. The result is a tiny leftover balance in your wallet instead of a fully closed order. If you'd rather avoid this entirely, you can switch to fill-or-kill in the swap panel settings - you'll trade some fill speed and price for an all-or-nothing outcome.

### **4. It expired.**  
Every limit order has an expiration date you set when you placed it. If the market never reached your price (with enough margin for fees) before that deadline, the order simply expires unfilled - no drama, no gas spent, nothing lost. Worth a glance at your open orders to check it hasn't quietly timed out.

### **5. No solver found a viable settlement for it in that auction.**  
Less common, but worth knowing: solvers only execute orders they can settle profitably within a batch. For very illiquid pairs or unusual amounts, there may be auctions where no solver puts together a solution that includes your order - even if your price is technically reachable on paper. This tends to resolve itself as liquidity conditions shift, but it's more likely to bite on thinly traded tokens.

## What to do about it

-   **Check "Executes At."**  This is the single most useful number on the page - it tells you the real price your order needs, fees and all.
-   **Widen your limit price slightly**, if your strategy allows it, so there's more room to clear the fee threshold.
-   **Extend the order duration**  if it's close to expiring and the market's trending your way.
-   **Switch fill settings**  - toggle off partial fills if you want all-or-nothing, or leave them on if you're optimizing for speed and price.
-   **For illiquid pairs, be patient or resize.**  A smaller order or a more liquid route can make it easier for solvers to find a settlement.
-   **Cancel and re-quote if your thesis has changed.**  Cancellation is free and off-chain, so there's no cost to resetting.

None of this means the order is stuck or the protocol has failed you - it means [CoW Swap](https://swap.cow.fi/#/1/limit/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) is doing exactly what it's designed to do: refusing to execute your trade for anything worse than what you asked for, fees included. That patience is the trade-off for the protection.

[Try it for yourself!](https://swap.cow.fi/#/1/limit/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48)

large_Why Your CoW Swap Limit Order Hasn't Filled Yet (and What to Do).png

medium_Why Your CoW Swap Limit Order Hasn't Filled Yet (and What to Do).png

small_Why Your CoW Swap Limit Order Hasn't Filled Yet (and What to Do).png

thumbnail_Why Your CoW Swap Limit Order Hasn't Filled Yet (and What to Do).png

Why Your CoW Swap Limit Order Hasn't Filled Yet (and What to Do).png

CoW Swap limit order not filling? Here's exactly why: price, fees, partial fills, or expiry, and what to check first.

Why Your CoW Swap Limit Order Hasn't Filled Yet (and What to Do)

Most months, CoW DAO’s story is what we’ve built. But this month, the story is about where CoW Protocol showed up. MetaMask's new agent wallet, Jumper's advanced trading mode, RHEA's cross-chain DEX — CoW Protocol is increasingly becoming the execution layer other teams reach for, rather than a destination on its own. Meanwhile, governance spent the month working through one of its more technically demanding proposals in public.

Here's everything.

#### August by the Numbers

Monthly Volume: $2.88B  

Monthly Trades: 353,601 

Active Wallets: 70,552 (44,187 new · 26,365 returning)

Cumulative All-Time Volume: $211.6B

DEX aggregator market share: 15.1%, 3rd across all supported chains


**Chain breakdown - top 5 (August):**

- Ethereum led at $2.6b

- Base ($120.3m)

- Arbitrum ($80.4m)

- BNB ($79.1m)

- Gnosis ($10.2m)

### Integrations

#### Agents Can Trade Now Too: MetaMask Agent Wallet
CoW Protocol is part of the execution stack behind [MetaMask's new Agent Wallet](https://x.com/CoWSwap/status/2085378517798178903), live for everyone as of August 6. As autonomous agents start holding and moving funds on people's behalf, the execution layer underneath them matters as much as it does for human traders — MEV protection and best execution don't stop being relevant just because a human isn't the one clicking "swap."

#### Jumper Advanced
CoW Protocol now powers limit orders inside Jumper's new [Advanced trading mode](https://x.com/CoWSwap/status/2085120387310829897), alongside simulated swaps, smart slippage, and large-order splitting. It's a sign of where CoW Protocol keeps landing: not as the front door, but as the execution engine behind serious trading tools built by other teams.

#### RHEA Finance
CoW Protocol is also powering order routing and slippage protection for [RHEA Finance's cross-chain DEX](https://x.com/CoWSwap/status/2085007452643156435), supporting institutional-size trades — $50K to $500K — on stablecoins including USDC, USDT, and EURe, from any EVM asset to any token whitelisted by NEAR Intents. Same story as MetaMask and Jumper: CoW Protocol's execution shows up wherever serious trades needs them.

#### Lido NEST: Automated Treasury Execution
Lido now uses CoW Protocol to power [NEST's automated LDO buybacks](https://x.com/CoWSwap/status/2088288651054571779) on mainnet — rule-based, DAO-controlled, MEV-protected, running daily in the background. It's a different kind of integration than a trading front-end: this is CoW Protocol as the execution layer for another DAO's own treasury operations, not just its users' trades.

#### Affiliate Program: $200M+ Referred
The Moo & Earn Affiliate Program crossed $200 million in total referred volume this month, with over 1,000 affiliates now participating. Crossing four figures in affiliate count alongside the volume milestone is arguably the more interesting number — it says the program isn't just being driven by a handful of large referrers, but by a genuinely growing base of people with a reason to share a link.

### Governance
[CIP-87: Penalty Cap Redesign](https://forum.cow.fi/t/cip-87-penalty-cap-redesign/3520) proposed switching solver settlement penalties from a flat, chain-specific amount to a small percentage of trade size. It drew real technical debate on the forum, moved to a Snapshot vote on August 19, and passed on August 25.

### Grants
The [UI Translation Program](https://forum.cow.fi/t/rfp-cow-swap-ui-translation-localization/3481) finished external translation work on August 21 and is now in internal review phase through September 11, ahead of deployment.

### Treasury
The [CoW DAO Treasury — July 2026 Monthly Report](https://forum.cow.fi/t/cow-dao-treasury-july-2026-monthly-report/3532) is out.

### See You in September
August was a month of showing up — inside agent wallets, advanced trading tools, and institutional cross-chain flows — while governance did the less visible work of getting a technical proposal right in public.
See you in September.

CoW DAO 🐮

large_08.png

medium_08.png

small_08.png

thumbnail_08.png

08.png

All the lates goings on from CoW DAO in August

CoW DAO Monthly Recap: August 2026

For most of its history, CoW Protocol has meant better execution within the EVM world. But this month, that’s all changed. CoW Protocol now settles cross-chain swaps into Bitcoin — taking the protocol's solver competition and MEV protection outside the EVM for the first time. But it wasn't the only thing that happened this month.

Here's everything.

### July by the Numbers

- Monthly volume: $2.5B  

- Monthly Trades: 691,978  

- Active Wallets: 111.5k (86.1k new · 25.4k returning · 77% new-wallet ratio)

- Cumulative All-time Volume: $208.5B  

- 14.5% DEX aggregator market share — 3rd across all supported chains  

**Chain breakdown - top 5 (July):** 

- Ethereum led at $2.2b 

- BNB ($134.3m) 

- Base ($84.4m) 

- Arbitrum ($79.5m) 

- Avalanche ($16.1m)

#### Cross-Chain Swaps to Bitcoin

CoW Swap now supports cross-chain swaps directly into and out of Bitcoin. The same mechanics that protect every CoW Protocol trade — solver competition, MEV protection, best execution — now extend to BTC.

This matters beyond the feature itself. CoW Protocol was built for EVM chains; Bitcoin isn't one. Getting there means the protocol's execution guarantees are no longer bounded by EVM compatibility — which says as much about where the infrastructure is headed as it does about this specific launch.

#### Affiliate Program: $170M+ Referred

The Moo & Earn Affiliate Program has now driven over $170 million in total referred volume. The program pays out both the affiliate and the referred trader once volume hits milestones — no gatekeeping, no approval committee, just a link and a reason to share it. Crossing $170M is the clearest signal yet that permissionless referral mechanics can move real volume without compromising the protocol's user-first design.

### Product Updates


#### [Safe{Mobile} + WalletConnect](https://x.com/CoWSwap/status/2079607096706822185)

Safe users can now connect directly to CoW Swap via WalletConnect inside Safe{Mobile}. Multisig security doesn't take days off — and now it doesn't need a desktop either.

#### Lido Fast Swaps return 

[Integrated Fast Swaps](https://x.com/CoWSwap/status/2078100694234493211) are back in the Lido staking widget. Users can skip the withdrawal queue entirely and unstake into ETH, USDC, WBTC, and other assets for instant liquidity, powered by CoW Protocol. Liquidity shouldn't be a waiting game — this is what that looks like in practice.

#### CoW Swap on PQ1 

CoW Swap is now [integrated into PQ1](https://x.com/CoWSwap/status/2082150167516520834), ethphone's new hardware wallet — built to be the first post-quantum secure hardware wallet on the market. Every CoW Swap trade is clear-signed directly on the device, and PQ1's known-address database now includes CoW Swap's deployments. That means an approval no longer shows up as an opaque hex string. Small detail, real difference for anyone trying to verify what they're actually signing.

### Transparency

#### Token Transparency Filing with Blockworks

CoW Protocol's [Token Transparency disclosure report](https://blockworks.com/token-transparency/filing/cow-protocol) is now live, published with Blockworks. A press release says trust us; a filing says check for yourself. Read the filing here.

#### Ownership Token Framework

COW has also been added to Aragon's [Ownership Token Framework dashboard](https://otf.aragon.org/tokens/cow), which independently maps governance tokens across onchain control, value accrual, verifiability, and token distribution. COW scores 10 of 15 — full marks on verifiability and token distribution, with the framework noting CoW's offchain Snapshot-based governance and Safe-held treasury as the main gap to a fully onchain-bound score. Worth reading in full for anyone doing diligence on COW's governance structure.

### Ecosystem & Advocacy

#### Encrypt the Mempool Coalition

CoW DAO has joined the [Encrypt the Mempool Coalition](https://x.com/CoWSwap/status/2075535205809414169), working alongside other industry leaders to push for an EIP that would encrypt Ethereum's mempool as part of the network's next hardfork. The goal: stop toxic MEV and real-time censorship at the protocol level, in a decentralized and credibly neutral way.

This is a different kind of contribution than a product launch — it's CoW DAO putting weight behind infrastructure-level change that benefits the entire ecosystem, not just its own users. MEV protection has always been core to CoW DAO's pitch; this is that same mission playing out at the base layer instead of the application layer.

### Community

CoW DAO co-founder and CTO Felix (@fleupold_) joined NEAR Protocol and The Rollup for Virtual NEAR Day on July 16, discussing the infrastructure behind intent-based execution and where chain abstraction goes from here. Intents aren't a CoW-only conversation anymore — they're becoming the shared vocabulary for how execution infrastructure gets built across ecosystems. [Watch here](https://x.com/i/broadcasts/1DGleeraoArJL).

### Team

We're hiring:
Partnerships Manager

If you want to help build the infrastructure protecting DeFi users at scale, apply now.

### Treasury

The [CoW DAO Treasury — June 2026 Monthly Report](https://forum.cow.fi/t/cow-dao-treasury-june-2026-monthly-report/3494) was published this month. It covers June rather than July, but the throughline holds: capital preservation, liquidity, and selective stablecoin yield, with additional USDC deployed into the KPK USDC Prime vault and a swap of USDC into GHO.

### Grants and Governance

A CIP-Draft proposing to simplify CoW DAO's bonding pool operations continues to move through the forum. Separately, the [Bring Your Own Solver (BYOS) grant](https://forum.cow.fi/t/rfp-bring-your-own-solver-byos/3469/10) — which would let a bonded solver source solutions from a permissionless set of external sub-solvers — has a grant application in progress from the bleu team.

The [UI translation program](https://forum.cow.fi/t/rfp-cow-swap-ui-translation-localization/3481/19) has moved from applications to execution: candidates have been selected, and the translation window is officially open. Thank you to everyone who applied — this is community-driven localization, built by the people who'll actually use it.

### See You in August

July was the month CoW Swap stopped being bounded by the EVM. Bitcoin cross-chain swaps, $170M+ in referred volume, a seat at the table on mempool encryption, and the infrastructure conversation showing up on stages beyond our own. Not a quiet month at all.

See you in August.

CoW DAO 🐮

large_07.png

medium_07.png

small_07.png

thumbnail_07.png

07.png

All the lates goings on from CoW DAO in July

CoW DAO Monthly Recap: July 2026


#### TL;DR

-   **Limit orders**  let you name your price and wait. They execute only at your limit price or better, whenever the market gets there (or they expire).
-   **TWAP orders**  split one large trade into smaller equal parts, executed on a schedule, to avoid moving the market with a single big trade.
-   The twist: a TWAP order is basically a string of mini limit orders on a timer. Same DNA, different job.
-   Use a  **limit order**  when you care about  _price_  and are fine waiting an unknown amount of time.
-   Use  **TWAP**  when you care about  _price impact_  - usually because your trade is big enough to move the market if you dumped it in all at once.
-   Both run through CoW Protocol's batch auctions, so both come with MEV protection, gasless order management, and surplus capture - you're not trading away any of that by picking one over the other.

If you've spent any time in the [CoW Swap](https://swap.cow.fi/#/1/swap/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) "Advanced" tab, you've probably had this exact moment of hesitation: Limit or TWAP? They both sound like "smarter" ways to trade than a plain swap, but they solve different problems. Let's break down what each one is actually doing under the hood, and when to reach for which.

## Quick refresher: what's a limit order?

A limit order is an instruction to buy or sell at a specific price or better, up until it expires. You're not saying "trade now" - you're saying "trade  _when the price is right_, however long that takes."

On CoW Swap, limit orders come with a few mechanics worth knowing:

-   **Partially fillable by default.**  Your order can fill in chunks as liquidity becomes available at your price, rather than requiring the entire order to fill in one shot. This usually means faster completion than an all-or-nothing order.
-   **No separate fee.**  CoW Protocol covers network fees by waiting for a price slightly better than your limit price - which is also why your order might not fill the  _instant_  the spot price technically crosses your line.
-   **Gasless management.**  Placing, editing, and cancelling limit orders off-chain is free. (On-chain cancellation is available too, but costs gas - useful if you want a guaranteed, immediate cancel.)

We've covered the mechanics in full in  [Limit Orders Explained](https://cow.fi/learn/limit-orders-explained)  and the walkthrough in  [How to Use Limit Orders on CoW Swap](https://cow.fi/learn/how-to-use-limit-orders-on-cow-swap), so we won't re-tread that ground here - just the parts that matter for this comparison.

## Quick refresher: what's a TWAP order?

TWAP stands for Time-Weighted Average Price. Instead of placing one order, you split a large trade into equal parts and space them out over a set duration - say, six parts over three hours instead of one lump-sum trade. The goal is to land close to the  _average_  market price over that window, rather than whatever the price happens to be the second you hit "swap."

The parts you set:

-   **Number of parts**  - how many pieces your order is split into
-   **Total duration**  - how long the whole thing takes to execute
-   **Price Protection**  - an optional guardrail that pauses execution if the market moves against you by more than a percentage you set

One requirement to flag up front: TWAP orders currently need a Safe wallet with an upgraded fallback handler, since they run on CoW Protocol's Composable order framework. Regular swaps and limit orders don't have that requirement. We go deep on setup in  [Why TWAP? The Perks of Time-Weighted Average Price](https://cow.fi/learn/why-twap)  and  [How to use CoW Swap's TWAP orders via Safe Wallet](https://cow.fi/learn/how-to-use-cow-swap-twap-orders-via-safe-wallet).

### The side-by-side

![twap-vs-limit-orders-comparison.png](https://celebrated-gift-f83e5c9419.media.strapiapp.com/twap_vs_limit_orders_comparison_9ef654b1be.png)

### The connection most people miss

Another way to think of the difference between limit and TWAP orders: a TWAP order isn't a separate species from a limit order - it's a_sequence_  of them. Each part of a TWAP trade executes as its own small limit order at fixed intervals. TWAP is really "limit order strategy, automated and scheduled."

That reframes the decision nicely. You're not choosing between two unrelated tools. You're choosing between:

-   **One limit order**  - I want this price, I'll wait for it.
-   **Many small limit orders on autopilot**  - I want to trade a large amount without my own order size becoming the thing that moves the price against me.

### When to reach for a limit order

-   You have a specific entry or exit price in mind (buying a dip, taking profit at a target) and you're comfortable waiting.
-   Your trade size is small-to-moderate relative to the pool's liquidity - a single fill won't meaningfully move the market.
-   You want to "set and forget" a price target without babysitting the market.
-   You don't have a Safe wallet set up and don't want to make one just to place this trade.

### When to reach for TWAP

-   You're moving a large amount and a single trade would create real price impact.
-   You're implementing a DCA-style strategy - buying or selling gradually rather than all at once. (More on that in [Understanding Dollar Cost Averaging in Crypto](https://cow.fi/learn/understanding-dollar-cost-averaging-in-crypto).)
-   You want to avoid signaling a big trade to the market - a large single order is a lot easier to spot (and front-run) than several smaller ones spread over time.
-   You'd rather smooth out short-term volatility than bet on hitting one specific price.

### What they have in common

Wherever you land, you're not giving anything up by choosing one order type over the other - both run through the same CoW Protocol machinery:

-   **MEV protection**, via delegated trade execution, Coincidence of Wants matching, and uniform clearing prices within batch auctions (see  [How CoW Swap solves the MEV problem](https://cow.fi/learn/how-cow-swap-solves-the-mev-problem))
-   **Surplus capture**  - if solvers find you a better price than quoted, that improvement comes back to you, not the protocol
-   **Gasless order placement and cancellation**  (off-chain), so testing the waters costs nothing
-   **No fees for failed transactions**

### The cheat sheet

If you only remember one thing:  limit orders optimize for price, TWAP orders optimize for size.  Small trade, specific price target, willing to wait → limit order. Large trade, worried about moving the market yourself → TWAP. And if you're not sure your trade even qualifies as "large" in the first place, that's worth a gut check before reaching for TWAP's extra setup steps.

----------

**Further reading**

-   [When to Swap and when to TWAP](https://cow.fi/learn/when-to-swap-when-to-twap)  - the companion comparison, for when you're deciding between a plain swap and TWAP instead
-   [Limit Orders Explained](https://cow.fi/learn/limit-orders-explained)
-   [How to Use Limit Orders on CoW Swap](https://cow.fi/learn/how-to-use-limit-orders-on-cow-swap)
-   [CoW Swap Improves the Limit Order Experience with Partially Fillable Limit Orders](https://cow.fi/learn/cow-swap-improves-the-limit-order-experience-with-partially-fillable-limit-orders)
-   [Why TWAP? The Perks of Time-Weighted Average Price](https://cow.fi/learn/why-twap)
-   [Getting to Grips with Time-Weighted Average Price (TWAP) orders](https://cow.fi/learn/getting-to-grips-with-time-weighted-average-price-twap-orders)
-   [Understanding Dollar Cost Averaging in Crypto](https://cow.fi/learn/understanding-dollar-cost-averaging-in-crypto)
-   [Introducing the Programmatic Order Framework, from CoW Protocol](https://cow.fi/learn/introducing-the-programmatic-order-framework-from-cow-protocol)

large_TWAP vs. Limit Orders- Which Should You Use and When.png

medium_TWAP vs. Limit Orders- Which Should You Use and When.png

small_TWAP vs. Limit Orders- Which Should You Use and When.png

thumbnail_TWAP vs. Limit Orders- Which Should You Use and When.png

TWAP vs. Limit Orders- Which Should You Use and When.png

Limit orders lock in your price and wait for the market to meet it. TWAP orders split large trades into smaller pieces over time to avoid moving the market. See how each works on CoW Swap, the key differences, and which one fits your trade.

TWAP vs. Limit Orders: Which Should You Use and When?

You want to move 5,000 USDC from Arbitrum to Base. Simple, right? You open a bridge, type in the amount, hit confirm. Twenty minutes later you're staring at a wallet balance that's a bit smaller than you expected, and no single line item explains why.  

That gap between "what the bridge quoted" and "what actually landed" is rarely one big fee. It's usually five or six small ones stacking on top of each other - and each one is checkable  _before_  you send, not something you have to accept after the fact. Here's what to look for when bridging stablecoins.

### 1. Work out your real cost equation, not just "the bridge fee"

Most people look at the number a bridge shows them - say, 6 basis points - and stop there. But that's one slice of a longer chain, which typically looks something like this:

`Origin swap fee (if any) + origin gas + bridge/protocol fee + relayer or LP fee + destination gas + destination swap fee (if any)`

Let's look at that in action. On a $10,000 transfer, a 0.05% swap fee on the way in is $5 before you've touched the bridge. Gas on a congested L1 can be another $5-50 depending on timing. None of these show up in the headline "bridge fee" - they show up in your final balance. Checking the  _total_, not the advertised toll, is step one.

### 2. Ask whether you need to swap to a stablecoin at all before bridging

There's a long-standing habit in DeFi of converting to USDC "to make the bridge cheaper," on the logic that stablecoins have the deepest liquidity. Often true - but that conversion is itself a transaction with its own fee and price impact, paid_before_  the bridge even starts. If the swap costs more than the bridge fee it was supposed to save, the shortcut has failed. Worth running the numbers both ways to ensure that assumption is true.

### 3. Know which rail actually applies to your stablecoin

![stablecoin_bridging_mechanisms.png](https://celebrated-gift-f83e5c9419.media.strapiapp.com/stablecoin_bridging_mechanisms_b47ebe5008.png)

#### Varies by integration

USDC-specific rails like CCTP don't help you if you're moving USDT - that's a different mechanism with different fee and timing characteristics. Confirm which rail you're actually on before comparing costs, since comparing a burn-and-mint quote to a liquidity-pool quote is comparing two different things.

### 4. Check gas on  _both_  ends - not just the chain you're leaving

This is the one that catches people out after the fact rather than before: you land on the destination chain holding stablecoins and nothing else, and there's no native gas token to do anything with them. You can't even swap your way out of it, because that swap itself needs gas. Before bridging, confirm you'll have enough of the destination chain's native token to actually use what arrives - or that your route handles this for you (some intent-based routes deduct gas needs from the transferred asset itself, so you land ready to use it).

### 5. Watch for native vs. bridged versions of the same ticker

USDC on Arbitrum isn't automatically the same asset as USDC on Ethereum. Circle-issued "native" USDC and legacy "bridged" versions like USDC.e can both show up in a wallet labeled similarly, but they aren't interchangeable everywhere - some protocols and some CEX deposit flows only accept the native version. Landing with the wrong variant means a second swap, a second fee, and in some cases funds that are difficult to recover if sent to the wrong contract. Worth a 30-second check against Circle's own contract address list before you assume a "USDC" balance is fungible with the USDC you started with.

### 6. Decide what you're actually optimizing for: cost, speed, or exposure

These trade off against each other, and the "right" answer depends on the transfer, not a universal rule:

-   **Cost-sensitive, not time-sensitive**  - a burn-and-mint transfer with standard (non-expedited) finality typically avoids liquidity-pool fees entirely, at the cost of waiting longer for confirmation.
-   **Time-sensitive**  - intent-based and liquidity-pool routes settle faster because solvers or LPs front the capital, but that speed is priced in.
-   **Security-conscious, large transfer**  - this is where it's worth remembering that bridges, as a category, have been the single largest attack surface in DeFi. Academic analysis of 49 cross-chain bridge incidents between mid-2021 and September 2024 puts cumulative losses at roughly $4.3 billion  [(Wu et al., ACM Web Conference 2025)](https://arxiv.org/html/2410.14493), and a separate 2025 review of 34 incidents found funds were typically moved within about two hours of the exploit - often before it was even publicly disclosed  [(Global Ledger, 2025)](https://app.globalledger.io/hubfs/Press%20Materials/All%20Bridge%20Hacks%2c%20$2.9B%20Lost.pdf). For large or repeated transfers, checking a bridge's audit history and validator model matters at least as much as its fee.

### Where this leaves you

None of these checks are particularly groundbreaking - they're closer to reading the label before you buy something than to advanced DeFi strategy. The reason they matter is that "the bridge fee" is only ever one line of a longer receipt, and most of the other lines are visible in advance if you look.

If manually checking all six feels like a lot of tab-juggling for a routine transfer, that's the exact problem solver competition and intent-based routing are designed to absorb: on [CoW Swap](https://swap.cow.fi/#/1/swap/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48), a cross-chain trade is expressed as a single intent - what you're sending, what you want to receive, where - and the underlying CoW Protocol solver auction handles route selection, while the same MEV-protection mechanism that covers single-chain trades extends to the cross-chain flow. You can still check the route it picked; you just don't have to build the checklist yourself every time.

### Further Reading

-   [Gas Tokens, Native Tokens, and Why You're Getting Stuck at the Bridge](https://cow.fi/learn/gas-tokens-native-tokens-and-why-you-re-getting-stuck-at-the-bridge) 
-   [Wrapped Tokens vs. Native Bridging: What's the Difference, and Which Is Safer?](https://cow.fi/learn/wrapped-tokens-versue-native-bridging-explained)
-   [Cross-Chain MEV: How Bots Extract Value When You Move Between Chains](https://cow.fi/learn/cross-chain-mev-how-bots-extract-value-when-you-move-between-chains) 
-   [How Long Should a Bridge Transfer Take?](https://cow.fi/learn/bridge-transfer-times-explained)
-   [The Difference Between a DEX Aggregator and a Bridge Aggregator (And Why You Need Both)](https://cow.fi/learn/the-difference-between-a-dex-aggregator-and-a-bridge-aggregator-and-why-you-need-both)

large_The Stablecoin Bridging Checklist.png

medium_The Stablecoin Bridging Checklist.png

small_The Stablecoin Bridging Checklist.png

thumbnail_The Stablecoin Bridging Checklist.png

The Stablecoin Bridging Checklist.png

What actually drives the cost of bridging stablecoins? A step-by-step checklist covering gas, rails, and bridge security before you send USDC or USDT.

The Stablecoin Bridging Checklist: Six Things to Check Before You Move a Dollar Across Chains


### TL;DR

-   A DEX aggregator solves one problem: finding the best price for a trade within a single blockchain.
    
-   A bridge aggregator solves a different problem: finding the best route to move an asset between blockchains.
    
-   They look alike - both compare options and hide complexity - but they run on different infrastructure, with different risks and different failure modes.
    
-   Using only one leaves a gap. A great DEX aggregator can't get your tokens to another chain. A great bridge aggregator can't guarantee you a good price once they land.
    
-   CoW Swap runs both jobs in one flow - DEX aggregation via solver competition, bridge aggregation via Across, Bungee, and NEAR Intents - bundled into a single signed intent.
    

"Aggregator" is one of those DeFi words that gets said constantly and defined rarely. Ask someone what a DEX aggregator does and what a bridge aggregator does, and there's a decent chance you'll get the same answer twice - something like "it finds you the best deal." True. But it’s not the whole story.

A DEX aggregator and a bridge aggregator aren't two flavors of the same tool. They're two different tools, solving two different problems, built on two entirely different pieces of infrastructure. One lives entirely within a single blockchain. The other exists specifically to get you off it.

Mix them up, and you end up shopping for the wrong solution to whatever's actually annoying you. Understand the difference, and it becomes obvious why serious cross-chain trading needs both, working together - not as a nice-to-have, but as the actual minimum bar. This article explains them both, and how you can benefit from both.

## What a DEX aggregator does

Think of a DEX aggregator as a price-comparison tool for a single blockchain. Liquidity for any given token pair - ETH/USDC, say - isn't sitting in one place. It's fragmented across dozens of decentralized exchanges: Uniswap pools, Curve pools, Balancer pools, private market makers, all on the same chain, all with their own AMM math ticking away independently. Checking each one by hand, working out which offers the least price impact for your trade size, takes a human longer than the market takes to move.

A DEX aggregator automates that search. It scans the available liquidity sources, compares quotes, and - in more advanced systems like [CoW Protocol's batch auctions](https://cow.fi/learn/understanding-batch-auctions) - lets professional solvers compete off-chain to fill your order, including private liquidity a simple router might never see. The trade still happens on the chain you started on. Nothing crosses a network boundary. The job is entirely: find the best price, here, now.

(For the full mechanics - smart order routing, solver competition, the shift from routers to intents - see [What is a DEX aggregator?](https://cow.fi/learn/what-is-a-dex-aggregator) and [What is a DeFi aggregator?](https://cow.fi/learn/what-is-a-defi-aggregator))

## What a bridge aggregator does

A bridge aggregator solves a completely different problem, starting from a completely different premise: your tokens are on the wrong chain, and no DEX, however smart, can fix that. Uniswap doesn't have an opinion on your assets sitting on Arbitrum when you need them on Base. That's not what it does.

Getting assets across chains means using a bridge - infrastructure that locks, burns, or messages a token's value from one network to another. And just like DEX liquidity, bridge infrastructure is fragmented: dozens of protocols exist, each with different fees, speeds, security models, and chain coverage.

A bridge aggregator does for bridges what a DEX aggregator does for exchanges: scans the available routes, compares them on cost, speed, and reliability, and executes the best one - sometimes splitting large transfers across multiple bridges, sometimes finding multi-hop paths when no direct route exists. We've gone deep on the mechanics in [What is a bridge aggregator?](https://cow.fi/learn/what-is-a-bridge-aggregator)

## Where they look alike - and where that stops

On the surface, the two jobs sound like the same job with a find-and-replace: swap "exchange" for "bridge" and you're done. That's why the terms get used interchangeably so often. The resemblance is skin-deep, though. Underneath, they're solving structurally different problems.
![Screenshot 2026-08-13 at 09.32.16.png](https://celebrated-gift-f83e5c9419.media.strapiapp.com/Screenshot_2026_08_13_at_09_32_16_82bb4b3b48.png)


That risk-and-failure-mode row is the one that matters most. A bad DEX route costs you basis points. A bad bridge route can strand your funds between two chains for hours, or expose them to a hack in a bridge contract you never chose to trust directly. Cross-chain bridges carry a genuinely different category of risk to "I got a slightly worse swap price" - worth reading up on in [what to check before you use one](https://cow.fi/learn/what-are-the-current-best-practices-for-using-cross-chain-bridges).

## Why you need both

Here's where it gets concrete. Say you're holding USDC on Arbitrum, and you've spotted an opportunity that needs ETH on Base.

With only a DEX aggregator, you're stuck. It'll get you a great price for USDC → ETH - on Arbitrum. Your ETH still isn't on Base. You'd need to bridge it yourself, manually, in a separate step, on a separate app, hoping you picked a bridge that wasn't this week's headline exploit.

With only a bridge aggregator, you can get your USDC moved over to Base efficiently - but you land holding USDC, not ETH. You still need a separate swap, at whatever price happens to be available in that moment, with nothing competing on your behalf to improve it.

Either way, you're back to the three-steps, three-gas-fees, three-chances-to-mess-it-up experience that makes cross-chain trading feel like a part-time job: open one app to bridge, wait, pay gas, open another app to swap, wait again, pay more gas - hoping prices haven't moved against you in between. We've broken that specific friction down before in[Understanding cross-chain swaps](https://cow.fi/learn/understanding-cross-chain-swaps).

A DEX aggregator alone gets you a good deal on the wrong chain. A bridge aggregator alone gets you to the right chain holding the wrong asset. You need both jobs done - and ideally, done together, in one motion, rather than stitched together by hand.

## How CoW Swap does both, in one flow

CoW Swap evolved from a DEX aggregator into a DEX and bridge aggregator, rather than staying in its lane.

When you make a cross-chain swap on CoW Swap, both jobs run inside a single intent:

1.  The DEX aggregation leg - CoW Protocol solvers compete to fill your swap, the same mechanism that's always powered CoW Swap on a single chain.
    
2.  The bridge aggregation leg - CoW Swap compares routes across integrated bridge providers, currently [Across, Bungee, and NEAR Intents](https://docs.cow.fi/cow-protocol/tutorials/cow-swap/swap-and-bridge), to find a path to your destination chain.
    
3.  One signature, bundled together - both legs sit inside a single transaction. If either leg fails, the whole thing reverts, rather than leaving you holding half a trade on the wrong chain.
    

You still get the benefit of solver competition on the swap side and route comparison on the bridge side - you just aren't the one manually stitching the two together, tab by tab, gas fee by gas fee. The full mechanics of that one-flow model are covered in [From DEX Aggregator to Bridge Aggregator: CoW Swap's One-Flow Revolution](https://cow.fi/learn/from-dex-aggregator-to-bridge-aggregator-co-w-swap-s-one-flow-revolution).

## The bottom line

A DEX aggregator and a bridge aggregator aren't competing products, and they're not the same product wearing a different hat. They're two layers of the same multi-chain stack, solving two different problems with two different risk profiles. Used alone, either one leaves you finishing the job by hand. Used together, they cover the whole trip - from the price you get, to the chain you land on.

👉 [Try a cross-chain swap on CoW Swap](https://swap.cow.fi/)

##  Further reading

-   [What is a DEX aggregator?](https://cow.fi/learn/what-is-a-dex-aggregator)
    
-   [What is a bridge aggregator?](https://cow.fi/learn/what-is-a-bridge-aggregator)
    
-   [What is a DeFi aggregator?](https://cow.fi/learn/what-is-a-defi-aggregator)
    
-   [Understanding cross-chain swaps](https://cow.fi/learn/understanding-cross-chain-swaps)
    
-   [From DEX Aggregator to Bridge Aggregator: CoW Swap's One-Flow Revolution](https://cow.fi/learn/from-dex-aggregator-to-bridge-aggregator-co-w-swap-s-one-flow-revolution)
    
-   [What are the current best practices for using cross-chain bridges](https://cow.fi/learn/what-are-the-current-best-practices-for-using-cross-chain-bridges)

large_The Difference Between a DEX Aggregator and a Bridge Aggregator.png

medium_The Difference Between a DEX Aggregator and a Bridge Aggregator.png

small_The Difference Between a DEX Aggregator and a Bridge Aggregator.png

thumbnail_The Difference Between a DEX Aggregator and a Bridge Aggregator.png

The Difference Between a DEX Aggregator and a Bridge Aggregator.png

A DEX aggregator gets you the best price. A bridge aggregator gets you to the right chain. Cross-chain trading needs both.

The Difference Between a DEX Aggregator and a Bridge Aggregator (And Why You Need Both)

You've done everything right. You bridged your USDC to a shiny new chain, watched the confirmation come through, and opened your wallet to admire your new multi-chain life.

And now you're stuck. Not "the bridge is down" stuck. Stuck in the quieter, dumber way: you have money, and you cannot spend a cent of it, because you don't have the one token the network will actually accept as payment for doing anything at all.

Welcome to the gas token problem. It's not a bug, and it's not really even a bridge issue - it's a side effect of how blockchains charge rent. Once you see how the pieces fit together, the "stuck at the bridge" moment stops being a mystery and starts being something you can see coming from a mile away.

## First, what is a native token?

Every blockchain has one currency it insists on for its own upkeep. Ethereum wants ETH. Gnosis Chain wants xDAI. Solana wants SOL. This is the network's  native token  - the asset that pays for block space, and the only thing validators or sequencers will accept as a fee, no matter what else you're holding.

Layer 2s inherit this logic even when it seems like it shouldn't apply to them. Arbitrum, Optimism, and Base all use ETH as their native token too - but it's  _their_  ETH, sitting in  _their_  ledger, not a shared pool with Ethereum mainnet. Having ETH on Ethereum doesn't give you a drop of it on Base. They just happen to share a ticker.

## Native, gas, and wrapped: three words doing the same job (mostly)

This is where most of the confusion actually lives, so it's worth being precise:

-   **Native token**  - the asset baked into the chain's core protocol as the fee currency. This is a design choice made at genesis.
-   **Gas token**  - informal shorthand for "whatever token you're using to pay a given transaction's fee." Ninety-nine times out of a hundred, that's the native token. It's the same thing wearing a more casual name.
-   **Wrapped token**  - an ERC-20-flavoured stand-in for a native token, created purely so the native asset can play nicely with smart contracts. WETH is wrapped ETH. wxDAI is wrapped xDAI. Wrapping is a one-way-and-back conversion at a flat 1:1 rate - you're not gaining or losing anything, just changing the token's shape so contracts can move it.

That third one trips people up because it's easy to confuse with a fourth, unrelated thing: a  _bridged_  representation of an asset from another chain entirely - like USDC.e on a chain that isn't USDC's home turf. That's not a wrapped native token. It's an IOU for an asset that lives somewhere else. Different problem, different risk profile, same instinct to squint at your wallet and ask "wait, which one of these is real?"

## Most chains agree on their toll-taker. Not all of them.

Here's the part that makes this genuinely tricky rather than just mildly annoying: there's no universal rule for which token a chain will accept. You have to know each one individually.

![gas-tokens-by-chain-table.png](https://celebrated-gift-f83e5c9419.media.strapiapp.com/gas_tokens_by_chain_table_0321ea2078.png)

And then there are the exceptions that prove the rule is optional. Some OP Stack chains use a "custom gas token" feature to swap ETH out entirely - Fraxtal, for instance, runs on FRAX instead. If you're not paying attention when you bridge somewhere new, you can end up holding exactly the wrong assumption about what that network wants from you.

## The moment you actually get stuck

Picture bridging 2,000 USDC from Arbitrum to a newer L2 you've never used before, to catch a yield opportunity you read about an hour ago. The bridge does its job: the USDC shows up, right on schedule.

Now try to do literally anything with it - swap it, approve it, send it - and your wallet stalls out asking for a fee in the chain's native token. Which you don't have. Because the bridge moved the asset you  _wanted_, not the asset you'd  _need_  to use it. Your funds aren't lost. They're just sitting behind a toll booth, and you're the one person in line without correct change, on a road where nobody accepts anything else.

This is why "gas tokens" and "getting stuck at the bridge" are really the same conversation. The bridge did exactly what it promised. The gap is that arriving with value and arriving with the  _ability to spend_  that value are two separate events, and nothing about a standard bridge transfer guarantees both happen together.

## The workarounds people reach for (and why they're patches, not fixes)

None of this is news to anyone who's spent real time bridging around, which is why a small folk wisdom has built up:

-   **Withdraw straight from an exchange**  to the destination chain in its native token, so you land with gas already in hand. Works, if you planned ahead and don't mind an extra hop through a centralized platform.
-   **Keep a standing float of gas on every chain you touch.**  Reasonable in theory, mildly ridiculous in practice once you're active on six or seven networks. It's asset management, but for the privilege of  _starting_  your asset management.
-   **Testnet-style faucets.**  Real on testnets, essentially non-existent for mainnet value - nobody's handing out free ETH on Base.
-   **"Gas drop" add-ons some bridges bundle in**, quietly including a small amount of native gas alongside your transfer. Helpful, but it's a feature of  _that specific bridge_, not something you can count on everywhere.

Every one of these is a way of remembering to solve the problem yourself, in advance, correctly, every single time. Which is a lot to ask of anyone who just wants to chase a yield opportunity before it disappears.

## The actual fix: stop making gas your problem

The more durable answer isn't a better checklist - it's removing the step entirely. This is what "gas abstraction" means in practice, and it's shown up in a couple of forms:

**Account abstraction (ERC-4337)**  introduced the paymaster: a contract that can front your gas fee, either sponsoring it outright or accepting payment in an ERC-20 token - including the very token you're trying to move - while quietly settling the actual fee in native currency behind the scenes. You never touch the native token at all.

**Intent-based execution**  solves the same problem from a different angle. Instead of you constructing and paying for a transaction, you sign an intent - "I have this, I want that" - and a solver competes to fill it, fronting whatever gas is required along the way. [CoW Protocol](https://cow.fi/cow-protocol) works this way: solvers execute trades on users' behalf and are compensated for settling batches, and fees are taken from the sell token itself rather than requiring you to hold the network's native currency up front. 

When [CoW Swap](https://cow.fi/cow-swap) handles a cross-chain trade, that same logic extends across the bridge leg too - the solver network sources the route and fronts execution, so you're not left holding an asset on a new chain with no way to move it.

None of this is a workaround stacked on a workaround. It's a structural fix to the actual problem: gas tokens exist because someone has to pay the chain's toll, and there's no rule saying that someone has to be you, scrambling, after the fact, on a chain you've never used before.

## The short version

-   **Native token** = the chain's required fee currency, decided at genesis.
-   **Gas token** = casual name for whatever's paying the fee right now - usually the native token.
-   **Wrapped token** = an ERC-20 costume for a native token, not a different asset, not a bridge IOU.
-   Bridges move the asset you asked for. They don't automatically hand you the toll money for the road you just landed on.
-   The fix that actually holds up is one where you stop needing destination-chain gas in the first place.

large_native-gas--wrapped-bridged-tokens-explained.png

medium_native-gas--wrapped-bridged-tokens-explained.png

small_native-gas--wrapped-bridged-tokens-explained.png

thumbnail_native-gas--wrapped-bridged-tokens-explained.png

native-gas--wrapped-bridged-tokens-explained.png

Native, gas, and wrapped tokens get conflated constantly — and that mix-up is exactly why bridging can leave you holding funds you cannot spend. A chain-by-chain breakdown of the confusion, and how gas abstraction fixes the problem for good.

Gas Tokens, Native Tokens, and Why You're Getting Stuck at the Bridge


In December 2021, someone spotted a strange gap in the market: Uniswap V2 on Ethereum would let you swap 238,172 MATIC for 116.97 WETH. Bridge that WETH over to Polygon, swap it back into WMATIC, and you'd walk away with 288,033 WMATIC - a profit of roughly $111,688, for doing nothing more than moving the same trade across a bridge. [Researchers at Flashbots documented it](https://arxiv.org/abs/2112.01472) as one of the first clean examples of value that only exists because a transaction crosses chains.

That gap wasn't a fluke. It was the opening move in what's now a well-studied, well-funded, and increasingly automated corner of DeFi: cross-chain MEV. If you've read our [primer on what cross-chain MEV is](https://cow.fi/learn/understanding-cross-chain-mev), you already know the shape of the problem. This piece goes one level deeper - into the actual mechanics bots use to extract value the moment your assets leave one chain and haven't yet landed on another, using data from the research groups who've spent the last two years measuring it.

## The core problem: your trade takes time, and time is inventory for bots

A same-chain swap settles in one block. A cross-chain swap doesn't - it involves a source-chain transaction, a bridging or messaging step, and a destination-chain transaction, and none of those three steps are guaranteed to happen in the same moment, or even the same minute. [Flashbots researcher Alex Obadia and co-authors formalized this in 2021](https://arxiv.org/abs/2112.01472): they defined "cross-domain MEV" as extractable value that depends on the joint ordering of actions across two or more chains, not just one. Every chain is its own "domain" with its own sequencer or validator set, and the seams between domains - bridges, messaging layers, deposit queues - are where the value leaks.
![inline primary - 3 -.png](https://celebrated-gift-f83e5c9419.media.strapiapp.com/inline_primary_3_f14306b84b.png)

That gap between "signed on Chain A" and "settled on Chain B" is exactly what bots are built to live inside.

## The bot's playbook: 3 distinct techniques

### 1. Inventory arbitrage - skip the bridge entirely

The single biggest finding from the most comprehensive study of executed cross-chain arbitrage to date might surprise you: [most bots don't actually bridge anything](https://arxiv.org/abs/2501.17335). Researchers tracking nine blockchains over a full year identified 242,535 executed cross-chain arbitrages worth $868.64 million in volume - and 66.96% of them used pre-positioned inventory sitting on both chains already, rather than moving assets through a bridge in real time.

That's worth pausing on, because it reframes what cross-chain MEV mechanically is. The intuitive picture - a bot watching your bridge transaction and racing to beat it to the other side - describes a minority of activity. The dominant strategy doesn't touch a bridge at all. Here's what it actually looks like: a bot keeps a working balance of, say, USDC on Arbitrum and USDC on Base at the same time, and watches the price of the same token pair on a DEX on each chain in real time.

The moment that pair is priced meaningfully differently between the two - enough to clear gas and fees - the bot sells on the expensive side and buys on the cheap side, in the same few seconds, using capital it already has sitting in both places. No bridge required to capture the spread; if any bridging happens, it's a separate, unhurried step later on to rebalance the two balances back to where the bot wants them. It's the same instinct as an arbitrage bot watching the same asset across two DEXs on one chain - just applied across two chains instead, which means the bot needs a balance sheet split across both to even play.

The logic for why bots prefer this is simple: bridging is slow, and slow kills arbitrage. Trades using pre-funded inventory on both ends settled in a 9-second median. Trades that had to route an asset through a bridge - because the bot didn't have capital already in place and had to physically move it to seize the opportunity - took a 242-second median, roughly 27 times longer. For a bot competing against dozens of others for the same few seconds of price divergence, that gap is the whole game.

And that need for pre-funded capital on every chain is exactly what concentrates this market into a small number of hands. This is not a level playing field of independent bots: the same study found the five largest addresses executed more than half of all detected trades, and one address alone captured close to 40% of daily volume in the months after Ethereum's Dencun upgrade cut rollup costs in March 2024.

Keeping idle working capital ready across nine-plus chains at once is expensive - only a handful of well-capitalized operators can afford to do it at the scale needed to compete, which is why cross-chain arbitrage is dominated by a few key players rather than spread across a long tail of smaller bots. That concentration isn't a side note; it's the same dynamic behind the vertical-integration risk covered further down.

### 2. Cross-layer sandwich attacks - no mempool required

Sandwich attacks are old news on Ethereum's public mempool. What's newer is that they've been shown to work against rollups that don't even have a public mempool - by attacking the bridge deposit step instead of the trade itself.

[Researchers from ETH Zurich and Northeastern University](https://arxiv.org/abs/2405.00138) demonstrated three working strategies against Arbitrum and Optimism, all exploiting the same quirk: when you deposit funds from Ethereum into a rollup, that deposit transaction is visible in Ethereum's public mempool before it's processed on the rollup - even though the rollup's own mempool is private.

-   **Classical sandwiching** - the bot watches Ethereum's mempool for L1-to-L2 deposit transactions that will trigger a swap, then sandwiches the deposit itself, so the price manipulation lands on the L2 side once the deposit clears.
    
-   **Hybrid sandwiching** - the bot places its front-running leg on L1, then races straight to the L2 sequencer for the back-running leg, exploiting the fact that sequencers place incoming L1 deposits at the top of the next L2 batch - a deterministic slot the bot can plan around.
    
-   **Speculative sandwiching** - the bot skips L1 entirely, waiting instead for the rollup's timeout window (the delay before a sequencer pulls a pending L1 deposit into an L2 batch) and sandwiching it purely on L2, which is cheaper to execute.
    
    
![inline primary - 2 - house - ad.png](https://celebrated-gift-f83e5c9419.media.strapiapp.com/inline_primary_2_house_ad_a3e9da7c4f.png)

The researchers estimated attackers had already extracted close to $2 million this way, almost entirely from users bridging through the Hop Protocol. The takeaway isn't that any one bridge is uniquely at fault - it's that "the rollup has no public mempool" is not the same thing as "the rollup is invisible to bots." The visibility just moves up a layer, to wherever your deposit transaction first gets broadcast.

### 3. Multi-hop arbitrage - rare, slow, and often not even worth it

It's tempting to imagine bots chaining arbitrage across three or four chains at once, extracting value at every hop. In practice, the data says this barely happens. A 2026 systematization of MEV research scanned 12 blockchain networks, 45 bridges, and over 2.4 billion transactions looking for genuine multi-hop (three-chain-plus) arbitrage - and [found only ten instances](https://doi.org/10.48550/arxiv.2603.07716): eight three-hop trades and two four-hop trades, no five- or six-hop trades at all.

The ones that did happen weren't pretty: three-hop arbitrage took an average of 7.2 minutes to execute, four-hop took 11.6 minutes, and only 60% of attempts were actually profitable once execution risk and fees were accounted for. Every additional hop adds latency, adds a chance something reverts partway through, and adds a chain's worth of gas costs - which is precisely why the profitable, high-volume end of cross-chain MEV concentrates on simple two-domain trades with pre-positioned capital, not elaborate multi-chain chains.

## Why this behaves differently from single-chain MEV

Three structural facts explain why cross-chain MEV rewards a different kind of operator than single-chain MEV does:

-   **No atomicity**. On one chain, a searcher can bundle a front-run, the victim's trade, and a back-run into a single atomic block - it either all happens or none of it does. Across chains, that guarantee disappears. A bot can execute perfectly on Chain A and still get stuck holding an asset it can't offload if Chain B's price moves before the second leg lands.
    
-   **Capital beats cleverness**. Because bridging is slow, the fastest strategy is to not bridge at all - which means having capital parked and ready on every chain you want to trade on. That's a balance-sheet requirement, not just a technical one, and it structurally favors well-funded operations over solo searchers.
    
-   **It rewards vertical integration.** The same research groups tracking this space flag a genuine systemic concern: sophisticated searchers have an incentive to pair up with - or become - the infrastructure operators who sequence transactions (rollup sequencers, large validator operators). When the entity ordering transactions is also the entity extracting MEV from them, you get [censorship, liveness, and finality risks](https://arxiv.org/abs/2501.17335) that compound across every chain that operator touches.
    

## What this looks like from where you're sitting

Say you're swapping USDC on Arbitrum for ETH on Base. Somewhere in that flow, one or more of the following is a live possibility, depending on how the route is built:

1.  Your deposit or bridge transaction sits in a public mempool for some window of time before it's finalized - exactly the window cross-layer sandwich bots are built to watch.
    
2.  The price on the destination chain can move between when you signed and when your funds actually arrive, and a bot with pre-positioned inventory on both chains can beat you to the resulting arbitrage.
    
3.  If your route depends on a relayer or a third-party liquidity provider to complete the second leg, that party has some discretion over timing - and timing, as we've seen, is the entire resource being fought over.
    

None of this requires a hack or a bug. It's the predictable output of a multi-step, non-atomic process being watched by well-resourced, automated participants. That's also why it's worth being precise about the distinction between cross-chain [MEV](https://cow.fi/learn/a-guide-to-mev-on-ethereum-explained-cow-dao) and cross-chain [bridge hacks](https://cow.fi/learn/bridge-hacks-explained-why-cross-chain-is-exploited) - they're related but different threats. MEV extraction skims value from the ordering and timing of legitimate transactions; a bridge hack is a direct exploit of the bridge's smart contracts or validator set. Both matter, but they call for different defenses - [we've covered bridge security separately](https://cow.fi/learn/what-are-the-current-best-practices-for-using-cross-chain-bridges-in-de-fi) if you want the full picture, including why bridge hacks alone accounted for [roughly $2.3 billion in losses in 2025](https://symbiosis.finance/blog/best-crypto-bridges-2025-top-cross-chain-bridge-solutions-for-defi).

## How the ecosystem is responding

A few mitigations are gaining real traction, each attacking a different part of the problem:

-   Private transaction relays (Flashbots Protect, MEV Blocker, and similar RPC endpoints) keep your transaction out of the public mempool entirely, closing off the visibility that classical and hybrid cross-layer sandwiching both depend on.
    
-   Batch auctions and uniform clearing prices settle a group of orders together at one price, discovered off-chain through solver competition, rather than executing trades one at a time in a sequence a bot can insert itself into. This is the mechanism [CoW Protocol](https://cow.fi/learn/understanding-batch-auctions) is built around, and it's also the reasoning behind extending solver competition to the bridging leg of a trade - [CoW Swap sources cross-chain routes from multiple bridge partners, including Across and Bungee](https://cow.fi/learn/cow-dao-unveils-seamless-cross-chain-swaps), bundling the swap and the bridge into a single signed intent instead of leaving each leg separately exposed.
    
-   Decentralizing block and batch building is the structural fix researchers point to most consistently - the more concentrated sequencing power gets, the more cross-chain MEV rewards vertical integration between searchers and infrastructure operators. Spreading that power back out is a direct countermeasure to the concentration data above.
    
-   SUAVE and similar shared-sequencing designs aim to let searchers compete for cross-domain execution rights through an auction layer that isn't controlled by any single chain's sequencer - still early, but aimed squarely at the collusion incentive Obadia's original paper flagged back in 2021.
    

## The practical takeaway

Cross-chain MEV isn't going away - it's a direct consequence of DeFi being multi-chain, and the research suggests it's growing (cross-chain arbitrage volume grew 5.5x over the year researchers studied). But it's also more concentrated, more capital-intensive, and more mechanically specific than it might sound. It isn't some bot randomly front-running you mid-bridge; it's inventory-rich operators racing a 9-second clock, and mempool-watchers exploiting the exact moment your deposit becomes visible before your rollup processes it.

The practical version of "protect yourself" looks like this:

-   Prefer routes that avoid unnecessary time in a public mempool.
    
-   Understand that a cross-chain swap is not one transaction - it's a sequence, and every seam in that sequence is a place value can leak.
    
-   Where possible, use aggregated or intent-based routing that bundles the swap and bridge legs, rather than manually sequencing them yourself across multiple tabs and multiple minutes.

large_Cross-Chain MEV- How Bots Extract Value When You Move Between Chains.png

medium_Cross-Chain MEV- How Bots Extract Value When You Move Between Chains.png

small_Cross-Chain MEV- How Bots Extract Value When You Move Between Chains.png

thumbnail_Cross-Chain MEV- How Bots Extract Value When You Move Between Chains.png

Cross-Chain MEV- How Bots Extract Value When You Move Between Chains.png

Most cross-chain MEV bots skip bridges entirely, using pre-positioned inventory to exploit price gaps in seconds. A research-backed look at how bots really extract value across chains, from arbitrage to cross-layer sandwich attacks.

Cross-Chain MEV: How Bots Extract Value When You Move Between Chains


Most cross-chain transfers complete in 1 to 20 minutes. Some canonical bridges take longer - up to a few hours - and optimistic-rollup withdrawals can take up to 7 days by design. The time your transfer takes has almost nothing to do with "network traffic" in the way people usually mean it. It comes down to three things:

-   How long the source chain takes to finalize your transaction
    
-   Which security model the bridge uses
    
-   How fast the destination chain can process the incoming deposit
    

If you're staring at a spinner right now wondering whether something's wrong, skip to what to do when it doesn't arrive. If you want to understand why the estimate you were quoted is the estimate you got, keep reading.

## Why Transfer Time Varies

A bridge transfer isn't one action - it's a relay race with three legs, and your total time is the sum of all three. Let’s take a closer look at each part of the race.

### 1. Source-chain finality

Before a bridge will act on your transaction, the source chain needs to consider it irreversible. This is the single biggest lever on total time, and it varies enormously by chain:

![source_chain_finality_table.png](https://celebrated-gift-f83e5c9419.media.strapiapp.com/source_chain_finality_table_2c735ca521.png)

Notice that L2s are fast for L2-to-L2 movement but slow for withdrawals back to L1 - that's not a bug, it's the security tradeoff optimistic rollups make. More on that below.

### 2. The bridge's security model

Broadly, there are two families:

-   Canonical / lock-and-mint bridges wait for full source-chain finality before minting on the destination. Slower, but you're relying on the underlying chains' security rather than a third party's judgment. [We've covered how lock-and-mint actually works here.](https://cow.fi/learn/what-are-the-current-best-practices-for-using-cross-chain-bridges-in-de-fi)
    
-   Intent / liquidity-network bridges skip the wait by having a relayer front you the destination funds immediately, then reconcile with the source chain in the background. Faster - often under a minute - but you're now trusting the relayer's solvency and the reconciliation process.
    

Neither is "better" in the abstract. It's a speed-versus-trust-assumption tradeoff, and it's worth knowing which one your transfer is using, because it explains the number you were quoted.

### 3. Destination-chain processing

Even a bridge that fills instantly still has to land in the next available block on the destination chain, and a congested destination chain adds real delay here - this is the one piece that does fluctuate with "network traffic."

## The Realistic Time Bands

Rather than ranking specific bridges against each other (speed benchmarks shift constantly and a table of named providers goes stale in a quarter), here's a rough breakdown by category:

-   Intent-based / same-ecosystem transfers: seconds to a couple of minutes
    
-   L2-to-L2 canonical bridging: roughly 10-20 minutes
    
-   Ethereum-origin canonical bridging: roughly 15-30 minutes
    
-   Optimistic rollup withdrawals (L2 → L1): up to 7 days - this is the one that catches people off guard, because it's not a malfunction, it's the challenge window that makes the withdrawal trust-minimized in the first place
    

If you were quoted something in the first three bands and it's taking noticeably longer, that's worth investigating. If you're doing an L2 withdrawal and it says "7 days," that's the system working as intended, not stuck.

## What to Do When a Transfer Is Stuck

If you bridged using [CoW Swap's cross-chain swaps feature](https://docs.cow.fi/cow-protocol/tutorials/cow-swap/swap-and-bridge), here's what's actually happening under the hood, and what to check at each stage.

First, check the order status in [CoW Explorer.](https://explorer.cow.fi/) Every cross-chain swap has two tabs - Swap and Bridge - so you can see exactly which leg you're waiting on. If it says "Bridging in progress," the swap already completed and you're waiting on the bridge provider. If you don't see a bridge status at all yet, the swap itself hasn't executed - nothing has been sent anywhere, and your funds are still in your wallet.

Know that the bridge only starts after the swap succeeds. These aren't parallel processes. If your order expired, got canceled, or failed at the swap stage, bridging never began - there's nothing to track because nothing left your wallet. This trips people up more than actual bridge delays do.

The estimated bridging time you saw at quote time came from the bridge provider, not from CoW Swap. It's a live pass-through number, not a fixed promise, so some drift is normal - particularly during the source-chain finality window described above.

If the bridge deposit fails or expires, your funds don't vanish - they route back to your Account Proxy (also called CoW Shed), a personal contract that acts as a safety net for exactly this scenario. Expiration windows are set by the bridge provider, not CoW Swap or CoW Protocol. 

A quick example: Across typically refunds after around 3 hours if a deposit hasn't completed. Once a refund lands in your Account Proxy, you can recover it from the Account Proxy page in your CoW Swap account by selecting the relevant proxy version and withdrawing the token to your wallet.

**One thing you can't do:** once the swap has executed and the bridge deposit has been submitted, the transfer can't be manually canceled from your side. At that point it will either complete on the destination chain or refund per the provider's policy - there's no in-between action to take except wait or check the explorer.

**When to actually be concerned:** if you're well past the quoted estimate and past the provider's stated refund/expiry window and CoW Explorer shows no status change, that's the point to reach out for support with your order ID in hand.

## Quick Answers

#### Why is my bridge transfer taking longer than expected? 
Usually one of three reasons: the source chain hasn't reached finality yet, the bridge you're using is a canonical (not intent-based) bridge that waits for that finality by design, or the destination chain is congested. None of these mean the transfer failed.

####  Is a slow transfer a sign something's gone wrong? 
Not by itself. Check whether you're within the bridge provider's stated time range and refund window before assuming a problem. A transfer that's merely slow behaves very differently from one that's actually failed - the latter typically resolves via an automatic refund, not silence.

#### What's the longest a bridge transfer should normally take? 
For standard deposits, a few hours at the outside. The major exception is optimistic rollup withdrawals back to L1, which have a built-in challenge period that can run up to 7 days - that's a deliberate security feature, not a delay.

large_how long should a bridge transfer take.png

medium_how long should a bridge transfer take.png

small_how long should a bridge transfer take.png

thumbnail_how long should a bridge transfer take.png

how long should a bridge transfer take.png

Most bridge transfers take 1–20 minutes. Learn why times vary by chain and bridge type — and exactly what to do if yours seems stuck.

How Long Should a Bridge Transfer Take?


You want to move your ETH from Ethereum to Arbitrum. Or your USDC from Base to Optimism. Simple enough, right? Except your ETH can't actually leave Ethereum. No blockchain asset can. What crosses the chain is never the original token - it's a promise, a proof, or a freshly minted copy. The difference between  _wrapped tokens_  and  _native bridging_  comes down to how that promise is made, and who you're trusting to keep it.

That question - "who's holding the bag on the other end?" - is the single most important thing to understand before you bridge anything of value. 

In this piece, we'll break down how each model actually works, walk through what happens when they fail (using real hacks, not hypotheticals), and land on a straight answer for which one is safer - and when the "safer" option isn't available to you anyway.

## First: no asset actually "crosses" a chain

Blockchains are sealed systems. Ethereum has no idea Arbitrum exists, and vice versa. A bridge is the piece of infrastructure that mimics cross-chain movement by doing one of two things on the source chain -  locking the asset, or burning it - and then producing a corresponding asset on the destination chain.

Everything else is a variation on those two ideas.

## Wrapped tokens: lock-and-mint

This is the original bridging pattern, and it's how WBTC (Wrapped Bitcoin) got onto Ethereum in the first place.

1.  You send 1 BTC to a custodial address or smart contract.
2.  The bridge operator confirms the deposit and mints 1 wBTC on Ethereum.
3.  Your wBTC is now a claim check - a token that represents Bitcoin, without being Bitcoin.
4.  To get your original BTC back, you burn the wBTC and the bridge releases the locked Bitcoin.

The catch is right there in step 1:  something has to hold the original asset. That might be a single custodian, a multisig of a handful of signers, or a decentralized validator set. Whatever it is, your wrapped token is only ever as good as its ability to keep that lock secure - forever, with no downtime, against every attacker on earth. 

That's a permanent, non-negotiable dependency. Every day your funds sit as a wrapped asset is another day you're exposed to whoever is minding the vault.

## Native bridging: burn-and-mint

The newer, cleaner pattern skips the wrapped-asset step entirely.

1.  The asset is burned - destroyed, not locked - on the source chain.
2.  The issuer (not a bridge operator) verifies the burn and mints the  _real_, native asset directly on the destination chain.

Circle's  [CCTP (Cross-Chain Transfer Protocol)](https://www.circle.com/cross-chain-transfer-protocol)  is the clearest example: bridge USDC from Ethereum to Arbitrum via CCTP, and the Ethereum USDC is burned while native Arbitrum USDC - the same USDC everyone else on that chain already uses - is minted in its place. No synthetic "USDC.e" floating around. No custodian sitting on a pile of locked tokens. Just one canonical representation of the asset, always.

Canonical L2 bridges (Arbitrum's official bridge, Optimism's, Base's) work on a related principle: they're built directly into the rollup's protocol and inherit their security from Ethereum's own consensus, rather than from a separate validator set the bridge operator introduces. 

The tradeoff is speed - withdrawals back to Ethereum from an optimistic rollup can mean a seven-day challenge window - but there's no additional trust assumption layered on top.

## Which is actually safer?

Wrapped tokens don't  _automatically_  mean unsafe, and native bridging doesn't  _automatically_  mean safe - but the two models fail in structurally different ways, and it's worth knowing what those failures actually look like.

Wrapped-token bridges tend to fail through custody compromise. Let's take a look at some famous examples:

-   **[Ronin Bridge](https://www.bankless.com/analyzing-the-ronin-bridge-hack)  (March 2022, ~$625M)**  - Sky Mavis operated 5 of Ronin's 9 validator nodes. A prior, never-revoked signing delegation let attackers get the fifth signature they needed through a gas-free RPC node. No smart contract was broken. The bridge did exactly what it was built to do when handed five valid signatures - it just shouldn't have had five valid signatures to hand.
-   **[Wormhole](https://www.certik.com/blog/wormhole-bridge-exploit-incident-analysis)  (February 2022, ~$326M)**  - the opposite failure mode. The Guardian validator network was never compromised at all; the exploit was a smart-contract bug that let an attacker skip signature verification entirely and mint 120,000 wETH on Solana with nothing backing it.
-   **[Multichain](https://chain.link/education-hub/cross-chain-bridge-vulnerabilities)  (July 2023, ~$125M)**  - all the compromised private keys traced back to a single point of control: the CEO.

Different root causes - social engineering, code bugs, key centralization - but the same shape: a wrapped asset is a promise backed by  _someone_, and that someone is a single point of failure that plain ownership of the native asset doesn't have.

Native, canonical bridges remove that specific failure mode  - there's no custodian to compromise and no synthetic asset to become unbacked. That doesn't make them risk-free (a bug in the issuer's own burn/mint logic is still a bug), but it does mean one whole category of historical bridge hacks - the multisig-compromise, custodian-goes-bad category - simply doesn't apply.

So, is there a safer option for bridging? The honest, unglamorous answer: native bridging structurally removes custodian risk; wrapped tokens don't, by design. 

For a canonical asset like USDC, that makes burn-and-mint routes the clear default. For long-tail tokens without a native cross-chain standard, a well-audited, long-running, decentralized wrapped-token bridge may still be the only option - in which case validator decentralization and audit history become the things actually worth diligence on.

## Where CoW Swap fits in

This is exactly the decision  [CoW Swap's cross-chain swaps feature](https://docs.cow.fi/cow-protocol/tutorials/cow-swap/swap-and-bridge)  is built to take off your plate. When you  [swap and bridge in one flow](https://cow.fi/learn/from-dex-aggregator-to-bridge-aggregator-co-w-swap-s-one-flow-revolution), CoW Swap's solvers compete to find you the best swap route, while the routing layer compares bridge providers like Bungee and Near Intents to find the fastest, most reliable path - and shows you exactly which bridge is being used, with the option to override and choose manually if you'd rather. One intent, one signature, and you're not the one having to audit a validator set at 11pm before you bridge.

## The takeaway

Every bridge, wrapped or native, is answering the same question:  _what do I trust to make this asset real on the other side?_  Wrapped tokens answer it with a custodian. Native bridging answers it with the issuer, or with the chain's own consensus. Knowing which answer you're getting - and for how long your funds are sitting exposed to it - is the whole game.

large_Wrapped Tokens vs. Native Bridging- What's the Difference, and Which Is Safer.png

medium_Wrapped Tokens vs. Native Bridging- What's the Difference, and Which Is Safer.png

small_Wrapped Tokens vs. Native Bridging- What's the Difference, and Which Is Safer.png

thumbnail_Wrapped Tokens vs. Native Bridging- What's the Difference, and Which Is Safer.png

Wrapped Tokens vs. Native Bridging- What's the Difference, and Which Is Safer.png

Bridging crypto across chains? Learn the real difference between wrapped tokens and native bridging - and which one actually protects your funds better.

Wrapped Tokens vs. Native Bridging: What's the Difference, and Which Is Safer?

June picked up where May left off.

New integrations kept shipping. But the defining work of June happened at the solver layer: an upgraded competition metric, an open RFP that rethinks who can participate in the protocol's auctions, and a governance conversation about how bonded solvers operate over the long term. And when the month closed, the numbers told a story worth reading carefully.

Let's get into it.

#### June by the Numbers

-   Monthly Volume: $3.4B
    
-   Monthly Trades: 449,820
    
-   Active Wallets: 96.1k (75.8k new · 20.3k returning · 79% new wallet ratio)
    
-   Cumulative All-Time Volume: $205.3B
    

Chain breakdown:

-   Ethereum led at $3B
    
-   Base $130.3M
    
-   BNB $100M
    
-   Arbitrum $79.7M
    
-   Polygon $15.6M
    
-   Gnosis $5.8M
    

Volume up 48% and trades have nearly doubled. BNB drove a significant share of that shift, with 122,000 trades executed across 39,000 wallets. Of which 88% of those were first time users. That has helped nudge the proportion for new wallets versus returning ones up to 78%.

### Integrations

#### [Summer.fi: No More Swapping Before You Deposit](https://x.com/CoWSwap/status/2061486892009271678)

Summer.fi's earn vaults now let users deposit with any token and withdraw to any asset — powered by CoW Protocol. The price is visible upfront, the conversion happens automatically, and the position is filled. Seamless in, seamless out.

#### [MetaMask Swaps](https://x.com/CoWSwap/status/2064773052722770416)

Four new providers joined MetaMask Swaps in June — PancakeSwap, CoW Swap, Uniswap, and Titan Exchange — adding more competition across quotes for MetaMask users. More competition means better rates. CoW Protocol's solver network is built to win that competition.

### Solver Infrastructure

#### [Consistency Metric v2](https://forum.cow.fi/t/consistency-metric-v2/3474)

The solver consistency metric has been upgraded from raw order count to a combined score. It now factors both relative surplus and settlement success rate. The idea? Solvers who bid credibly and settle reliably score well. Solvers submitting near-zero bids to inflate their count don't.

The result? Better incentives, better competition, and better outcomes for users.

#### [RFP: Bring Your Own Solver (BYOS)](https://forum.cow.fi/t/rfp-bring-your-own-solver-byos/3469/6)

BYOS (Bring Your Own Solver) is a new RFP from CoW Grants aimed at lowering the barrier to competing on CoW Protocol orders. Right now, bidding requires becoming a fully bonded solver — legal, operational, and communication overhead that only well-resourced teams can clear. BYOS changes that: one bonded solver handles the trust layer, while anyone else — market makers, UIs, liquidity sources — can submit signed routing proposals on individual orders without bonding themselves.

### Governance

#### [CIP-Draft: Simplifying the CoW DAO Bonding Pool](https://forum.cow.fi/t/cip-draft-simplifying-the-operations-of-the-cow-dao-bonding-pool/3455/8)

This CIP-Draft simplifies CoW DAO bonding pool rules: a flat 10% service fee from day one, plus a "Solver Bond Safe" that auto-receives 20% of weekly rewards until it matches a reduced bonding pool ($200k in stables/ETH, or $100k + 0.5M COW) — at which point the solver can run its own driver independently. It replaces a patchwork of overlapping requirements that had become hard to track and enforce, aiming to cut core-team overhead and make self-operation more accessible to more solvers.

### One last thing.

CoW Swap is now on [LinkedIn!](https://pt.linkedin.com/company/cowdao)

Find us there for ecosystem updates, team news, and more.

CoW DAO 🐮

large_cow dao monthly june.png

medium_cow dao monthly june.png

small_cow dao monthly june.png

thumbnail_cow dao monthly june.png

cow dao monthly june.png

All the lates goings on from CoW DAO in June

CoW DAO Monthly Recap: June 2026


## TL;DR

-   DeFi limit orders let you set a target price and walk away — the trade executes automatically if the market reaches it, and nothing happens if it doesn't.
-   Automated market makers can't natively hold a pending order: they price trades instantly off pool ratios, so limit orders on AMMs are usually bolted on through separate monitoring bots or contracts.
-   [CoW Swap](https://swap.cow.fi/#/1/swap/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) settles limit orders as signed intents through CoW Protocol's solver network and batch auctions, rather than as public on-chain transactions waiting to be triggered.
-   Placing and cancelling a limit order on CoW Swap costs nothing if the trade doesn't execute — you only pay when a solver fills it.

## What are DeFi limit orders?

A limit order lets you specify the precise price at which you want to buy or sell an asset. The trade remains pending until the market reaches your target price. If the asset fails to reach that level, the trade simply expires unexecuted.

In traditional finance, centralized exchanges manage limit orders through a central order book. Every buy connects directly to a corresponding sell. Decentralized finance operates under distinct mechanics. Most decentralized exchanges run on automated market maker (AMM) models. An AMM relies on user-funded liquidity pools to execute swaps instantly at current market prices. This AMM design makes native limit orders difficult to implement natively on-chain.

## The problem with limit orders on AMMs

Early decentralized exchanges struggled to support proper limit orders. Because an AMM prices assets based on the ratio of tokens in a pool, the system cannot hold a pending order waiting for a future price point.

To solve this limitation, many protocols introduced workaround solutions. They created smart contracts that monitor AMM prices and execute user trades when the target price hits. While functional, these automated scripts introduce major inefficiencies into the trading process.

Transaction fees present the biggest challenge for AMM-triggered limit orders. Creating the smart contract requires a network gas fee. Cancelling the order requires another network fee. If the market approaches your target price, fluctuates briefly, and moves away, the transaction might fail during processing — and a failed transaction still costs gas, bleeding funds from the trader.

[Maximal Extractable Value (MEV)](https://cow.fi/learn/a-guide-to-mev-on-ethereum-explained-cow-dao) creates an additional risk, though not quite the one it first appears to be. When your bot triggers, it broadcasts a normal swap transaction with your limit price set as the minimum amount you'll accept. That transaction sits in the public mempool before it confirms — and that's the window searcher bots watch for. 

They can push the pool price against you right before your trade lands. Because your limit price is the floor, they usually can't force a worse fill than you set — the transaction just fails outright, and you've paid gas for nothing. If the bot instead builds in some slippage tolerance above your limit to avoid constant failures, that tolerance is exactly the room a sandwich attack needs — and a worse fill is possible. Either way, you lose something: gas on the reverts, or price on the fills that go through.

None of this makes AMMs themselves the problem — they're still where most on-chain liquidity lives, including liquidity CoW Swap's own solvers tap into. The issue is how a pending order gets triggered and settled on top of that liquidity, not the liquidity itself.

## How intent-based settlement solves it

The latest generation of decentralized exchanges takes a different approach. Intent-based exchanges remove direct on-chain execution from the user's side.

[CoW Swap](https://swap.cow.fi/#/1/swap/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48), processes limit orders as "intents." When you place an order, you sign a cryptographic message stating your desired outcome. You might sign a message that essentially says you want to swap 1 WETH for at least 3,000 USDC by next Friday.

This signed intent enters an off-chain order book. Independent third parties, called solvers, monitor the open intents and compete to find the most profitable execution path for your trade — including through the same AMMs discussed above, plus DEX aggregators and private liquidity sources.

## Why CoW Swap's limit orders avoid these problems

Intent-based trading provides structural advantages for users placing limit orders. CoW Swap applies this model to address the specific problems found in on-chain, bot-triggered limit orders.

### Free cancellation and failed trades

Signing an intent on [CoW Swap](https://swap.cow.fi/#/1/swap/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) requires no gas fees. You are simply signing an off-chain message. Cancelling is also free as long as the order has not been picked up by a solver. If your limit order expires or fails to execute, you pay nothing. The solver takes on the transaction risk. They pay the gas fee to execute the trade on-chain, and they only collect their fee if the swap succeeds.

### MEV protection by default

Because solvers execute the trade on your behalf, your signed intent isn't a transaction sitting exposed in the public mempool — there's nothing there for a searcher bot to see or reorder. CoW Protocol groups intents into batches and settles every trade in a batch at the same uniform clearing price. 

That structure removes the reordering advantage MEV searchers rely on. It's why a [CoW Swap](https://swap.cow.fi/#/1/swap/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) limit order can't be pushed into a worse fill than your stated price the way an on-chain, bot-triggered order can — the trade either clears at your price or better, or it simply doesn't clear in that batch. No reverts, no gas wasted chasing a price that keeps moving away.

### Better pricing through coincidence of wants

Batching trades creates opportunities for direct peer-to-peer settlement. If Alice wants to buy ETH with USDC, and Bob wants to buy USDC with ETH, a solver can match their orders directly within the batch. This peer-to-peer matching reduces reliance on liquidity pools. Avoiding pools means you bypass the typical swap fees and price impact associated with automated market makers.

### Access to deep liquidity

Solvers have access to liquidity across the entire decentralized finance ecosystem. If a direct peer-to-peer match is unavailable, solvers search multiple liquidity sources to fill your limit order. They check Uniswap, Balancer, Curve, and specialized market makers. This broad search capability ensures your order executes the moment enough liquidity exists at your target price.

## Setting up a limit order on CoW Swap

Placing a limit order takes just a few steps - and unlike most exchanges, none of them cost gas to set up.

First, connect your wallet to the [CoW Swap](https://swap.cow.fi/#/1/swap/WETH/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) interface and select the network you want to trade on, such as Ethereum Mainnet or Gnosis Chain. Then open the limit order view - click "Limit" next to "Swap" in the center module, or use the "Trade" dropdown in the top-left.

Next, choose the token you want to sell and the token you want to receive, and enter the amount you want to sell. The interface calculates the rest as you go.

Then set your limit price - the price (or better) at which the order should fill - and an expiry time. Orders can stay valid anywhere from a few minutes up to a year; the expiry simply sets how long solvers keep watching for a price that fills your order.

Before the order goes live, you may be prompted to approve your sell token. For tokens that support it this is a one-time gasless signature; for others it's a one-time on-chain approval. Either way, you never pay gas to place, edit, or cancel the order itself - and cancellations are free.

Finally, review the summary. By default the order is partially fillable, so it can fill gradually as liquidity appears. Click "Place limit order" and sign the message in your wallet - that signature isn't a transaction and costs nothing. Your order is now live and waiting for solvers.

## Smart management of pending limit orders

While intent-based systems simplify the technical execution, you still need to manage your pending trades logically.

Traders set limit orders based on expected price fluctuations. If market conditions change drastically, a previously sensible target price might become a liability. Revisit your open orders periodically. If the asset experiences structural changes, such as a major protocol upgrade or a security incident, cancel your old orders and assess the new reality.

Liquidity plays an important role in limit order execution. Highly liquid pairs like ETH and USDC fill quickly once the price target hits. Smaller, niche tokens might struggle to execute immediately even if the chart shows your price was briefly reached. Solvers need sufficient liquidity to route the trade without taking on excessive slippage. Setting realistic expectations for low-cap tokens helps you plan trades effectively.

## The future of automated trade execution

Decentralized exchanges continue to build better execution environments. The shift from pure on-chain AMM routing to off-chain solver networks represents a massive leap in user experience.

Limit orders no longer require complex smart contract monitoring or expensive gas fees for simple cancellations. Intent architecture aligns the incentives logically. Solvers only get paid when they successfully execute your trade at the price you demanded. As decentralized finance matures, this specialized, competitive execution model will likely become the standard for all automated trading.

## Frequently asked questions

**Do I need Ethereum to place a limit order on CoW Swap?**

You do not need ETH for gas to place the order itself after the initial token approval. You simply sign a free message. The solver who eventually executes the trade will extract a small fee from your sell token to cover the network gas costs.

**Will my limit order definitely execute?**

No. The market price must reach your specified target for a solver to pick it up. Also, enough liquidity must exist at that price point to fulfill your requested amount.

**Can I place a stop-loss order in DeFi?**

Standard limit orders execute at your target price or better. A stop-loss order requires a trigger price that initiates a market sell to prevent further losses. While similar, they require different logic. Some protocols offer dedicated stop-loss functionality, but mechanics vary between exchanges.

Learn how DeFi limit orders work, why traditional AMMs struggle with pending trades, and how intent-based trading protects your orders from MEV and slippage.

Best limit orders in DeFi

You ran 18 months of backtest data. Sharpe above 2. Drawdown looked manageable. On paper, you had a strategy worth funding. Then you deployed real capital and the P&L went negative in week one.

Here's the thing about that backtest: it never measured how your strategy performs. It measured how it performs in a frictionless fantasy. It priced every fill at the mid, ignored gas, and assumed every transaction landed - as if no other bot could see your orders before they settled. None of that is true on a live DEX, which is why those clean Sharpe numbers belong in a pitch deck, not a P&L.

This piece breaks down exactly where the backtest-to-live gap comes from - slippage, price impact, gas, MEV, and failed transactions - and how intent-based execution closes it. If your simulated edge disappears in production, this is where to look first.

**TL;DR**

* Backtests price fills at the mid. Live DEX trades pay slippage, gas, and MEV.
* Price impact scales with your order size and reads as zero in every backtest.
* MEV extractors took [180,000 ETH](https://arxiv.org/html/2411.03327v2) from Ethereum traders in under a year.
* Intent-based execution settles trades in batch auctions, off the public mempool — so there's nothing to front-run.
* If your backtest is profitable but production isn't, audit the execution layer before you touch the strategy.

## What a backtest assumes vs. what a live trade pays

A backtest models a market that doesn't exist. Orders fill at the mid price, which no DEX ever quotes. Gas is zero, even though every on-chain transaction costs something. Fill rates are 100%, even though transactions revert. The order book sits still, even though liquidity moves the instant a large order lands.

Timing makes it worse. Opportunity windows last [100 to 500 milliseconds](https://www.cobo.com/post/ai-trading-bot-crypto-security-mpc-wallet), and even a fast bot needs 50 to 200ms to act. That pressure never shows up in a simulation.

Most quants patch this with a fixed haircut per trade: a slippage estimate, a flat gas fee. But a static haircut is an average, and live slippage is dynamic. It tracks your order size, the pool depth at the moment you trade, and volatility — and volatility peaks exactly when your strategy says "execute." The haircut is never conservative enough at the tails. The tails are where the money goes.

## The costs backtests leave out: slippage, price impact, and gas

**Slippage** is the gap between the price you expected and the price you got. On a DEX it grows with thin liquidity and high volatility. A bot that fires aggressively into a price move is trading into the worst possible spread — the one the backtest priced at the mid.

**Price impact** is different. It's the market's reaction to your own order size. On an AMM, a large buy moves the price against you in proportion to your size versus pool depth. A $50,000 order in a shallow pool can move your execution price by several percent. In a backtest, that order fills at the pre-trade price. In production, your order *is* the thing that moves the price.

**Gas** isn't a fixed line item. It rises with congestion, and congestion peaks with volatility — because the event that triggers your strategy triggers everyone else's too. Your static gas estimate is competing against systems that reprice their fee bids every block. A 0.5% theoretical edge can go negative on gas alone during a single congestion spike.

## MEV bots front-run and sandwich your fills

### How front-running works on a live DEX

Every transaction you broadcast to a public mempool is visible before it settles. [Front-running](https://cow.fi/learn/what-is-frontrunning) works because bots watch that mempool nonstop. When one spots a large pending swap, it submits its own trade with a higher gas fee so validators process it first. By the time your transaction runs, the price has already moved against you.

This isn't an exploit in the usual sense. As [Chainlink's research](https://chain.link/article/front-running-defi) notes, the bot is using public data and the gas-fee mechanism exactly as the protocol defines them. Your trade still lands — just at a worse price, with the extractor keeping the difference.

### Sandwich attacks

A sandwich adds a second leg. The attacker buys right before your transaction and sells right after, bracketing your fill. You push the price up on entry; they exit into the liquidity you just created. The entire round-trip cost comes out of your fill.

The scale is real. Before Ethereum moved to proof-of-stake in September 2022, [440,000 ETH](https://arxiv.org/html/2411.03327v2) was extracted via MEV. In the months after, extractors took another 180,000 ETH through May 2023 alone. That value transfers straight from regular traders — including unprotected bots — to extractors. And the infrastructure doing it is organized: researchers have mapped [7 main bot categories and 24 subcategories](https://arxiv.org/html/2403.19530v2) on Ethereum.

Your backtest modeled none of it.

### Why mempool exposure is the hidden tax

A bot trading on an AMM runs inside a parallel economy of extractors whose revenue depends on your fills being worse than they should be. MEV doesn't appear as a line item. It shows up as steady underperformance against the backtest, with no obvious cause in the strategy logic. That's what makes it so easy to misdiagnose as bad alpha.

## How failed transactions affect your net returns

On-chain, transactions revert — and a revert doesn't refund your gas. The computation ran, so you pay for it. During high-contention periods, when every automated system fires at once, revert rates and gas prices climb together.

The hot-wallet setup most bots run on adds another risk. Fast execution needs accessible funds, which means private keys live in connected systems. Hot-wallet compromises cost the industry over $4 billion across 2023 and 2024 ([Cobo](https://www.cobo.com/post/ai-trading-bot-crypto-security-mpc-wallet)). A single credential leak can wipe out everything the strategy earned.

A bot with a 10% failure rate in production is carrying a cost structure the backtest treated as zero.

## How intent-based execution closes the backtest-to-live gap

### It takes your trades off the mempool

[Intent-based trading](https://cow.fi/learn/understanding-crypto-intents-the-future-of-your-de-fi-trades-2026) changes where execution happens. You sign an intent that states the outcome you want — the token pair and the minimum price you'll accept. Solvers (bonded third parties competing to fill your order) find the best route off-chain. Your trade never sits in the public mempool waiting to be sandwiched.

CoW Swap's batch auctions resist MEV by design, [confirmed by EigenPhi's research](https://docs.cow.fi/cow-protocol/concepts/benefits/mev-protection). Trades match off-chain before they touch on-chain liquidity, so a sandwich has nothing to bracket. The gas-bidding race that front-runners exploit never starts, because there's no race to enter. The mempool costs from the sections above simply don't apply to a trade that never enters the mempool.

### One clearing price, and the surplus comes back to you

Batch auctions group trades into short time windows. Every trade in a batch for the same token pair settles at a single uniform clearing price, so no bot can outbid you within the batch. And any surplus a solver finds above your signed minimum goes back to you, not the protocol.

Gasless placement and cancellation remove the failed-transaction cost. You sign an intent once. If conditions aren't met, nothing is consumed — which covers both the gas-on-revert problem and the polling loops that quietly burn fees on traditional keeper bots.

## Build on solvers that can't fill below the price you signed

The [Programmatic Order Framework](https://cow.fi/learn/introducing-the-programmatic-order-framework-from-cow-protocol) lets smart contracts place orders that execute perpetually based on on-chain conditions. You sign once; solvers fill when conditions are met. No backend polls the chain, and nothing needs manual intervention per trigger.

The **Milkman** contract, built with Yearn Finance, solves a problem governance strategies hit constantly: delayed execution. A DAO vote can take days to clear, and a price set when the proposal opened is stale by settlement. Milkman checks an on-chain oracle at the moment of execution, so the trade fills at the price that exists when it lands.

**CoW Hooks** bundle pre- and post-swap actions into a single atomic transaction — claim rewards to fund a trade, bridge tokens after a swap, or unwrap WETH as part of the fill. Steps that normally need separate transactions, and carry separate failure points, collapse into one unit.

For building, the [Trading SDK](https://docs.cow.fi/cow-protocol/integrate/api) (TypeScript, with Viem and Ethers v5/v6 support) handles quote fetching, order signing, and order management. Solvers are bonded and compete to fill your order, and they cannot fill below the price you signed. That guarantee is exactly what your backtest assumed about execution quality. Most DEXs don't provide it.

## Why CoW Protocol execution matches what your model assumed

You don't close the backtest-to-live gap by refining strategy logic. You close it by changing the execution environment - from one built for raw speed to one built for outcome integrity.

CoW Protocol attacks the gap line item by line item. Your orders are intents, settled in batch auctions by solvers competing to fill them - so you're not racing other bots through the mempool. On MEV, orders in a batch settle at a uniform clearing price, which removes the profitable spot to sandwich or frontrun you; the "as if no one could see my orders" assumption your backtest quietly made gets a lot closer to true.

On failed transactions, you sign an intent and solvers handle execution, so you don't pay gas on orders that don't land - the reverts that silently drained a P&L your backtest never modeled stop hitting you. On slippage and price impact, solvers compete to route your order across available liquidity and match it against opposing flow when they can, so the fill is decided by who finds you the best outcome rather than by who's first.

It won't turn a frictionless fantasy into reality - price impact on size is still physics. But it stops charging you for the costs a naive backtest forgot to include.

The [developer quickstart](https://learn.cow.fi/) and [programmatic orders docs](https://docs.cow.fi/cow-protocol/concepts/order-types/programmatic-orders) are the concrete starting points.

So if your strategy prints in the backtest but bleeds in production, the alpha is probably fine - audit the execution layer. The costs you're paying - slippage, price impact, gas spikes, MEV, failed transactions - were in every live run. The backtest just never charged you for them.

## FAQs about running trading bots in DeFi

### How do I model slippage and price impact in a backtest?

Static haircuts rarely match reality, because price impact depends on your specific order size and pool depth. Model the constant-product formula (x \* y \= k) for the actual pools you target, so you can calculate how your own trade moves the market. [Research](https://arxiv.org/html/2411.03327v2) points to ignoring these dynamic costs as a primary reason strategies with a thin edge fail in production.

### Does MEV or gas cost more for high-frequency strategies?

MEV usually costs more, because it scales with your trade volume rather than network congestion. Gas is a visible fee; MEV is an invisible tax that pulled [180,000 ETH](https://arxiv.org/html/2411.03327v2) from Ethereum traders in under a year. High-frequency bots without MEV protection often lose more to sandwich attacks than they pay in priority fees.

### What happens if a solver can't fill my order?

If the market moves so that no solver can meet your signed minimum, the order simply doesn't execute. Unlike traditional bots that burn gas on reverted transactions, intent-based orders are gasless until they settle. Your order stays open until the price returns to your limit or the order expires.

### How does Milkman handle delayed DAO treasury swaps?

Milkman checks an on-chain oracle at the moment of execution, so a price set when a vote opened can't go stale during a three-day governance delay. The trade fills at the [fair market price](https://cow.fi/learn/introducing-the-programmatic-order-framework-from-cow-protocol) when the transaction actually lands, which protects large treasury rebalances from being front-run.

### How do I deploy a bot with the CoW Protocol Trading SDK?

Integrate the [Trading SDK](https://docs.cow.fi/cow-protocol/integrate/api) with TypeScript libraries like Viem or Ethers. Your bot can fetch quotes, sign intents, and manage orders without maintaining a backend for mempool monitoring. Because execution is delegated to solvers, you skip the overhead of running high-performance nodes or private RPC connections.

If your DeFi bot looked great in backtests but bleeds in live markets, the cause is usually execution, not strategy. Here's how slippage, MEV, and gas eat your edge — and how to close the gap.

Running Trading Bots in DeFi: Why Backtests Lie

You want to build a position in a token. The price is moving. Buy it all now and you might be buying the local top. Wait for a dip and you might watch it run without you. Either way, you're betting that you can time the market - and almost nobody can, consistently.

Dollar-cost averaging (DCA) is the way out of that bet. Instead of trying to nail the perfect entry, you buy a fixed amount on a schedule and let the average price take care of itself. It's the strategy that lets you start now and stay in, without needing to be right about timing.

This guide makes the case for DCA, then shows you how to actually run it on-chain - because there's a catch most DCA guides skip. On a public blockchain, a predictable buying schedule is easy to spot and easy to exploit. TWAP orders on CoW Swap fix that, and we'll walk through exactly how.

**TL;DR**

* DCA removes the pressure of timing the market - you buy on a schedule and average out volatility.
* It's the strategy most likely to keep you invested through the scary moments, which is where returns are made or lost.
* TWAP automates DCA by splitting your buy into timed parts that each move the market less.
* On-chain, predictable buys leak value to MEV bots and price impact - the part most guides ignore.
* On CoW Swap, TWAP orders are MEV-protected, capture surplus, and settle straight from your own Safe.

## What DCA actually does for you

DCA is simple: pick an amount, pick a schedule, and buy on that schedule no matter what the price is doing. $200 every week. Whatever you choose. When the price is high, your fixed amount buys a little less. When it's low, it buys a little more. Over time, you end up with an average entry price instead of a single all-or-nothing bet.

That does three things for you.

**It takes timing off the table.** You don't have to predict the bottom, because you're buying across many points instead of one. The pressure to "get it right" disappears.

**It smooths out volatility.** Crypto swings hard. Spreading your buys means one bad day doesn't define your whole position - you're averaging through the chop, not getting caught by it.

**It keeps you in the game.** This is the big one. The hardest part of investing isn't picking the asset - it's holding through the drops. DCA turns a scary lump-sum decision into a series of small, routine ones, which makes it far more likely you actually stick with your plan.

That last point matters more than the math, and it's worth being honest about why.

## "But isn't lump-sum investing better?"

Fair question. And on paper, often yes: [Vanguard's research](https://corporate.vanguard.com/content/dam/corp/research/pdf/cost_averaging_invest_now_or_temporarily_hold_your_cash.pdf) found that investing all at once beats DCA roughly two-thirds of the time, because markets tend to rise and money sitting on the sidelines isn't growing.

But that statistic describes a robot - an investor who drops their whole stack in one go and feels nothing when it falls 30% the next week. Real people aren't robots. They buy the top, panic at the bottom, and sell at a loss. A higher expected return you abandon halfway down is worth less than a slightly lower one you actually hold.

That's the real job of DCA. [Investopedia](https://www.investopedia.com/terms/d/dollarcostaveraging.asp) puts it plainly: it's a risk-management tool, not a returns-maximizer. You're trading a sliver of theoretical upside for a much higher chance of staying invested through the moments that make most people quit. For a volatile asset you plan to hold for years, that's a good trade.

So the choice isn't really "DCA vs. lump-sum." It's "a plan you'll stick to vs. a plan you'll bail on." DCA is built for the first one.

## TWAP: DCA on autopilot

Once you've decided to DCA, the next question is how to run it without setting a weekly calendar reminder and manually clicking buy every time. That's what TWAP is for.

TWAP (Time-Weighted Average Price) splits one big order into equal parts and runs them at set intervals automatically. You decide the total amount, how many parts to break it into, and how far apart to space them. Then it runs on its own.

It's the same logic institutions have used for decades to buy large positions without moving the market against themselves. Each part is small enough to create little price impact, and across the whole schedule you get an average price instead of a single moment's depth.

The quiet benefit: it removes the override temptation. Manual DCA has a failure point - the week the market's been red for three days and you decide to "wait for it to stabilize." That's usually the exact buy you were supposed to make. TWAP just runs. No second-guessing, no babysitting charts.

## The catch nobody mentions: MEV and price impact

Here's the part most DCA guides leave out. On a public blockchain, every scheduled buy is a transaction anyone can see coming.

A weekly buy - same token, same rough size, same time - is about as predictable as a trade gets. MEV bots watch the mempool for exactly this. They spot your order waiting to settle, jump in front of it, nudge the price up, and sell right after you buy. You still get your tokens, just at a slightly worse price. Every. Single. Time.

There's a second, quieter cost too: price impact. Every on-chain buy pushes against the liquidity in a pool. One small buy barely moves it. But run 52 of them over a year and those fractions of a percent add up to a real drag on your average cost - one that never shows up on any single receipt.

So the strategy is sound. The standard on-chain execution is the problem.

## How CoW Swap protects every buy

CoW Swap closes both gaps, and even turns the tables.

**Your buys hide from front-runners.** CoW Protocol routes each TWAP part through off-chain [solver competition](https://cow.fi/learn/how-cow-protocol-actually-works) instead of the public mempool. Solvers compete to fill your order - including by matching it peer-to-peer with someone trading the other way, a [Coincidence of Wants](https://cow.fi/learn/what-are-cows-on-cow-swap). Because the trade never sits exposed waiting to settle, the front-running window simply isn't there. The bots stay hungry.

**Better prices come back to you as surplus.** On most DEXs, slippage only ever moves against you. On CoW Swap, if a solver finds a better price than you asked for, that improvement is yours - 100% of it, paid straight back. CoW's own testing found that selling 1,000 ETH in four parts of 250 ETH [returned a price 3.5% better](https://blog.cow.fi/why-twap-25d9a0f690f4) than dumping it all at once. Across a long DCA schedule, that edge compounds in your favor.

**A built-in floor for bad days.** Before your order runs, you can set a price-protection limit. If the market moves against you past that threshold, the order pauses instead of mechanically buying into a crash. It picks back up when prices return to range, or waits for you to take a look.

## Setting up a TWAP order: parts, intervals, and minimums

Placing one is straightforward. Three settings do most of the work.

**Total amount** is the full position you want to build.

**Number of parts** is how many slices you split it into. More parts means smaller buys and less market impact each time - just keep each part above the network minimum.

**Interval** is the time between buys. Tighter intervals average price more finely; wider ones stretch the schedule out.

You'll also set that **price-protection threshold** as a percentage, so the order knows when to pause.

A couple of practical notes:

CoW Swap TWAP runs from a [Safe wallet](https://docs.cow.fi/cow-protocol/tutorials/cow-swap/twap). You set the order once, and a service called the Watch Tower submits each part on schedule. Your funds stay in your own Safe the whole time - nothing gets parked in a third-party contract.

Minimums depend on gas costs per network. On Ethereum mainnet, each part needs to be at least around $1,000 to be worth a solver's time. On L2s like Arbitrum, Base, and Gnosis Chain, that drops to about $5 per part - so small, frequent buys that wouldn't make sense on mainnet work fine there. (These thresholds can change, so check current values when you set up.)

Once you submit, the Watch Tower takes over. Solvers bid on each part, any surplus settles back to your Safe, and if price protection trips mid-schedule, you simply keep the parts that already filled and decide whether to resume.

## Start dollar-cost averaging on CoW Swap

DCA was never really in question. It's one of the most reliable ways to build a position without betting everything on your timing - and, more importantly, without betting on your own nerves holding up during a crash.

The only thing standing between the strategy and your results is execution. Run it on a standard DEX and a little of every buy quietly goes to bots and slippage. Run it as a TWAP order on CoW Swap and your buys are protected, any price improvement comes back to you, and your assets never leave your Safe.

The [DCA and TWAP setup guide](https://docs.cow.fi/cow-protocol/tutorials/cow-swap/twap) walks through the full configuration. Set your total, pick a part size above the network minimum, choose an interval, and add a price-protection threshold. Then let it run.

Happy averaging. 🐮

## FAQs about TWAP and DCA

### Is DCA actually a good strategy, or should I just buy all at once?

Both work, but they solve different problems. Lump-sum investing tends to win on paper because markets usually rise, but it only pays off if you can hold through the drops without panic-selling. DCA spreads your buys over time, which lowers the emotional pressure and makes it far more likely you'll stick with your plan. For most people building a long-term position in a volatile asset, the strategy you'll actually follow beats the one that looks best in a spreadsheet.

### Does TWAP work for selling, not just buying?

Yes - it's just as useful on the way out. Splitting a large sell into parts keeps you from crashing the price with one big order. CoW's testing found that selling 1,000 ETH in four parts [returned a 3.5% better price](https://blog.cow.fi/why-twap-25d9a0f690f4) than a single sale, because you're not signaling your full size to the market at once.

### How many parts and what interval should I use?

It's a trade-off between smoothness and cost. More parts and tighter intervals give you a finer average price, but each part has to clear the network minimum (around $1,000 on Ethereum mainnet, roughly $5 on L2s like Arbitrum). For volatile tokens, shorter intervals capture more of the swings; for slow, long-term accumulation, wider intervals are fine.

### What happens if the price drops sharply mid-schedule?

If you've set a price-protection threshold and the market moves past it, the order pauses instead of buying into the fall. The parts that already filled stay in your wallet, and you can resume the schedule when things settle or close out the rest.

### How is this protected from MEV when a normal swap isn't?

A normal DEX swap sits in the public mempool, where bots can see it and sandwich it. CoW Protocol routes each TWAP part through off-chain solver competition instead, so your trade never sits exposed. That removes the front-running window and means any price improvement comes back to [you as surplus](https://cow.fi/learn/why-twap), not the bot's.

DCA is one of the smartest ways to build a position without timing the market. Here's why it works, and how TWAP orders on CoW Swap let you run it without leaking value to MEV bots.

Why You Should Use TWAP and DCA

### TL;DR

-   Bridges keep getting hacked because every bridge has to solve a difficult problem: proving something happened on one chain to a contract that can't see that chain.
    
-   Every solution to that problem - locking funds, trusting validators, passing messages - creates a new concentration of trust, and a new target.
    
-   Three separate bridge exploits hit in the space of about two weeks in June 2026, via three completely different attack vectors.
    
-   The industry is getting better at detection and disclosure, even as the hacks keep coming.
    
-   CoW Swap's cross-chain routing is built so the swap leg of your trade never touches a bridge contract at all.
    

Open a crypto news feed on more or less any given week in 2026 and there's a decent chance you'll find a bridge exploit in it. In the space of about ten days this June alone: [Secret Network's bridge to Axelar was drained of $4.67 million](https://thedefiant.io/news/hacks/secret-network-axelar-bridge-drained-4-67m-infinite-mint-flaw) after an attacker forged cross-chain messages. A leaked signing key broke the trust model behind [Taiko's Ethereum L2 bridge](https://finance.yahoo.com/markets/crypto/articles/ethereum-layer-2-taiko-warns-153103509.html), forcing the entire network to halt and every user to withdraw their funds. And a separate exploit pulled roughly [$2 million out of Aztec's bridge to Ethereum](https://rekt.news/aztec-bridge-rekt).

Three hacks, three completely different root causes, ten days. By some counts, [bridges have produced over $340 million in losses across more than a dozen exploits in 2026 alone.](https://askfuzz.ai/discover/news/cryptocurrencies/crypto-bridge-hacks-drain-340-7m-in-may-14-protocols-hit)

If you've ever wondered why this particular corner of DeFi seems to get hit so much harder than everything else, here's the uncomfortable answer: it's not bad luck, and it's mostly not sloppy engineering either. It's structural. Bridges are solving a problem that doesn't have a clean solution - and every way of solving it creates a new place for things to go wrong.

This piece walks through why that is, what the actual failure categories look like, and what's changing about how the industry handles it.

## The problem bridges are trying to solve

Blockchains don't talk to each other. Ethereum has no idea what's happening on Arbitrum. Arbitrum has no idea what's happening on Base. Each chain is its own self-contained ledger, validated by its own set of nodes, with no native way to look across the fence at another chain's state.

A bridge's entire job is to manufacture a way around that. When you bridge a token from Chain A to Chain B, something - a smart contract, a validator set, an oracle network - has to vouch for the fact that you really did lock, burn, or deposit that token on Chain A, so that Chain B is willing to release or mint the equivalent on the other side.

That "something that vouches" is the whole problem. Whatever you choose to do that vouching - a contract holding the asset, a set of validators signing off, a relayer passing messages between chains - becomes a single point that concentrates enormous value and has to be trusted completely. Get it right and the bridge works invisibly. Get it wrong, even slightly, and there's often nothing standing between an attacker and everything the bridge is holding.

## The three ways it breaks

Pull apart a few years of bridge hacks and they tend to cluster into three categories - not three different kinds of bad luck, but three different places where the "vouching" can fail.

### 1. Validation logic flaws

This is what happens when the code responsible for checking "did this deposit actually happen?" has a hole in it - and the contract on the other side mints or releases funds based on a deposit that was never real.

The Wormhole hack in 2022 ($320 million) is the canonical example: an attacker found a way to spoof the signature verification that was supposed to confirm a deposit on Solana, and minted wrapped ETH on the other side without ever depositing anything.

The Secret Network/Axelar exploit from this June is a more recent, smaller-scale version of the same idea. The bridge's contract was supposed to check that incoming cross-chain messages came from a legitimate, allow-listed channel. That check had been disabled. The attacker spun up their own minimal blockchain, opened a channel to the bridge contract, and self-relayed forged deposit messages that the contract accepted as genuine - minting real, redeemable wrapped tokens against deposits that never happened.

Different chains, different code, same underlying failure: the contract trusted a message it shouldn't have.

### 2. Validator and key compromise

Some bridges don't rely purely on contract logic - they rely on a defined set of validators or operators who sign-off on cross-chain messages. If you can compromise enough of those signers, or steal the right key, you don't need to find a bug in the code at all. You just become the trusted party.

Ronin Bridge ($624 million, 2022) is the largest example of this in DeFi history: attackers compromised five of the nine validator keys securing the bridge, which was enough to forge withdrawals and walk away with the funds.

Taiko's incident this June is a newer twist on the same theme. The exploit had nothing to do with a contract bug - a cryptographic signing key for Taiko's hardware-based prover system had been accidentally committed to a public GitHub repository. Whoever found it could generate proofs the bridge would treat as legitimate. The team halted block production and told every user on the network to withdraw funds from every bridge built on Taiko, because the entire trust model the bridges relied on could no longer be guaranteed.

### 3. Trusted-root and messaging failures

The third category covers bridges that rely on a "trusted root" - some reference point the contract checks new messages against to confirm they're legitimate. If that reference point is ever misconfigured, even briefly, the contract can end up accepting messages it should reject outright.

Nomad's collapse in 2022 ($190 million) is the textbook case. A routine upgrade set the trusted root to a default, unverified value. Once that was live, any message - forged or not - passed validation. What followed wasn't even a single sophisticated attacker; it was a free-for-all, with bystanders watching it happen in real time and racing to copy the exploit before anyone fixed it.

## Why this keeps happening

None of this is really an engineering failure in the sense of "they should have just tried harder." Lock-and-mint bridges, validator-based bridges, and message-passing bridges are three different architectures for the same underlying compromise: to make two chains that can't see each other behave as if they can, you have to put your trust somewhere. A contract. A validator set. A root hash. Wherever that trust lives, it accumulates value - and accumulated value is, by definition, an attractive target.

Bridges aren't unusually badly built. They're unusually exposed, because the thing they do is inherently exposed.

## What's actually getting better

It's worth saying plainly: this isn't a story of an industry standing still. Zero-knowledge light clients are replacing "trust a validator set" with "verify a cryptographic proof," which removes an entire category of attack. Decentralized validation and multi-party signing are replacing small, compromise-able validator sets. Rate limiting and circuit breakers - caps on how much value can move through a bridge in a given window - are increasingly standard, turning what used to be a total drain into a contained, partial one.

The response speed to this June's incidents is itself a data point worth noting. Axelar and Secret jointly disclosed their exploit within 48 hours, isolated the affected contract, and were transparent about which integrations were and weren't impacted. Taiko halted the entire network within hours of detecting irregular activity and gave users a clear, immediate instruction. Neither outcome is good news exactly - but a few years ago, disclosure timelines like that would have been unusual. The bar for incident response has moved, even while the underlying attack surface hasn't gone away.

## How cross-chain swaps happen on CoW Swap

When you make a cross-chain swap on CoW Swap, the trade is split into two distinct legs. The swap leg - converting one token into another - settles through CoW Protocol's solver competition: a [combinatorial batch auction](https://docs.cow.fi/cow-protocol/concepts/introduction/fair-combinatorial-auction) where independent, bonded solvers compete to fill your order. That leg never touches a bridge contract, because there's nothing to bridge yet; it's a same-chain settlement.

The bridging leg, where your assets move from one chain to another, is handled by routing across an aggregated set of vetted bridge providers chosen by route quality rather than defaulted to a single option.

It’s important to state that no aggregator can fully insulate a user from the underlying risk profile of whichever bridge a route sends them through, and that risk doesn't disappear just because it's one step in a bundled flow.

What the split design does mean is that you're not single-sourced to one bridge's contract, validator set, or trust assumptions for your entire trade, and the swap side of the transaction doesn't inherit bridge-specific risk it never needed to carry in the first place.

👉 [Try a cross-chain swap on CoW Swap](https://swap.cow.fi/)

## So what do you actually do with this?

Knowing why bridges break doesn't make any single bridge bulletproof - and it shouldn't stop you from using them, because cross-chain DeFi isn't optional anymore. What it should change is how you evaluate a bridge before you trust it with size: has its validation logic been audited, and by whom? Is it relying on a small validator set or a more decentralized model? Has it had an incident before, and how did it respond when it did?

For the practical side of that - checklist-style, before-you-bridge guidance - see our [best practices guide for using cross-chain bridges](https://cow.fi/learn/what-are-the-current-best-practices-for-using-cross-chain-bridges-in-de-fi).

## Further reading

-   [Understanding Cross-Chain Swaps](https://cow.fi/learn/understanding-cross-chain-swaps)
    
-   [What are the current best practices for using cross-chain bridges in DeFi?](https://cow.fi/learn/what-are-the-current-best-practices-for-using-cross-chain-bridges-in-de-fi)
    
-   [From DEX Aggregator to Bridge Aggregator: CoW Swap's One-Flow Revolution](https://cow.fi/learn/from-dex-aggregator-to-bridge-aggregator-co-w-swap-s-one-flow-revolution)
    
-   [What is a bridge aggregator?](https://cow.fi/learn/what-is-a-bridge-aggregator)

large_CoW DAO - Bridge Hacks - Explained.png

medium_CoW DAO - Bridge Hacks - Explained.png

small_CoW DAO - Bridge Hacks - Explained.png

thumbnail_CoW DAO - Bridge Hacks - Explained.png

CoW DAO - Bridge Hacks - Explained.png

Explore the most common bridge hacks, how they worked and how people are solving the bridge-hack problem. 

Bridge Hacks Explained: Why Cross-Chain Bridges Keep Getting Exploited


You found a token you like. It lives on Arbitrum. Your funds are on Ethereum. Simple, right?

Forty minutes later, you've opened four tabs, googled "is USDC.e the same as USDC" (it isn't), topped up a gas token you'd never heard of, second-guessed a bridge address, and paid three separate fees to do what should have been one click. Welcome to multi-chain DeFi - where the hard part isn't deciding what to do. It's surviving how to do it.

Chain abstraction is the idea that you shouldn't have to survive any of that. In fact, you shouldn't even have to know it's happening.

Let's unpack what that actually means - and why it might be the most important shift in DeFi user experience since the wallet.

## What chain abstraction actually is

Think about the last time you sent a text. You didn't choose which cell tower to route it through, or check whether your carrier and your friend's carrier were "compatible." You typed a message, hit send, and the messy infrastructure underneath sorted itself out. Chain abstraction wants crypto to feel the same way.

In plain English: chain abstraction hides the complexity of multiple blockchains behind a single, simple experience. Instead of "bridge to Base, swap on Base, remember to keep some ETH for gas," you just say what you want - turn this into that - and a layer underneath figures out which chains, which routes, and which steps make it happen. The chain becomes a detail, not a decision.

That's the whole pitch: you state the goal, the system handles the geography.

## Chain abstraction vs. account abstraction vs. bridges (the part everyone mixes up)

Before we go further, let's clear up three terms that get thrown around as if they're the same thing. They're not - they're layers that stack.

-   A bridge moves a specific asset from one chain to another. It's a single tool, and an important one, but on its own it still leaves you doing the driving.
    
-   Account abstraction upgrades your wallet so it can do smarter things - batch actions, cover your gas, sign in friendlier ways. It makes your account more capable.
    
-   Chain abstraction is the big umbrella. It uses bridges, account abstraction, and a few other tricks together so that the chains themselves fade into the background.
    

The easy way to remember it: account abstraction makes your wallet smarter; chain abstraction makes the chains invisible.

## How DeFi got so fragmented in the first place

None of this complexity was designed to annoy you. It's a side effect of success. A few years ago, "DeFi" mostly meant Ethereum. Then came the scaling boom: Layer 2s like Arbitrum and Base, alternative Layer 1s, app-specific chains, the works. Suddenly there was room for everyone - cheaper fees, faster transactions, more experimentation.

The catch is that each new chain is its own island. Its own liquidity. Its own gas token. Its own wallet quirks and bridge routes. Great for builders; exhausting for the person just trying to make a trade. We solved the scaling problem and accidentally created a navigation problem.

(If you want a deeper tour of how protocols differ across this landscape, our guide to [choosing a DeFi protocol](https://cow.fi/learn/choosing-a-de-fi-protocol) is a good companion read.)

## The hidden tax of not having chain abstraction

Here's what fragmentation actually costs you, in practice:

-   You pay more than once. Bridge fee, swap fee, gas on both sides. A single cross-chain move can mean [paying triple](https://cow.fi/learn/from-dex-aggregator-to-bridge-aggregator-co-w-swap-s-one-flow-revolution) for one outcome.
    
-   You make expensive mistakes. Wrong chain, wrong token version (the infamous USDC vs USDC.e), wrong bridge - and there's rarely an "undo."
    
-   You take on real risk. Bridges are some of the most-targeted infrastructure in all of crypto. We'll be honest about that later.
    
-   You burn time and nerves. The tab-juggling, the route anxiety, the quiet dread while a transaction sits "pending."
    

It's a tax you pay in money, attention, and stress - and most people don't even realize they're paying it, because they assume that's just how crypto works.

It doesn't have to be.

## How chain abstraction works under the hood

So how do you make chains disappear? Not with one magic product - with a stack of pieces working together. Here are the main ones.

Intents: say what you want, not how to do it. This is the engine. Traditionally, you micromanage every step: pick the pool, set the slippage, route the trade, manage gas. An intent flips that. As we explain in [how CoW Protocol actually works](https://cow.fi/learn/how-cow-protocol-actually-works), an intent is you saying: here's what I want and my conditions - now go find me the best way to do it. You state the outcome; you delegate the execution.

Solvers: the pros who do the driving. Once you've expressed an intent, specialized parties called solvers compete to fulfil it as well as they can. They're the ones working out the route across chains and liquidity sources - so you don't have to. Competition is the whole point: they win your business by finding you a better outcome.

Composability: stacking steps invisibly. Because your intent is signed rather than executed step-by-step, it can be combined with other actions behind the scenes. As the [CoW Hooks](https://cow.fi/learn/cow-hooks-you-are-in-control) piece puts it, signing instead of self-executing is exactly what lets the system compose your order with other steps - which is how a "swap here, bridge there, arrive on the other chain" sequence collapses into one smooth motion.

Account abstraction and bridges, tucked underneath. Smarter accounts handle gas and batching; bridges still move the assets. The difference is that you're no longer operating them by hand - they've become plumbing. (And yes, the bridges are still there. We'll be honest about what that means in a moment.)

Put it all together and "ten steps across three tabs" becomes "one signature."

## Why it matters for DeFi users

Strip away the jargon and the benefits are refreshingly human:

-   Less to know, less to break. You don't need a mental map of every chain to take part. Fewer decisions means fewer costly mistakes.
    
-   One flow instead of five. Cross-chain moves become a single action rather than a weekend project.
    
-   Access to everything, from anywhere. Liquidity and opportunities spread across chains stop being walled off behind a setup process.
    
-   A safer default. A guided single flow has fewer places to slip up than a manual relay race between apps.
    

In short: chain abstraction lets you spend your attention on strategy instead of logistics.

## Where CoW Swap fits in

This is more than theory for us - CoW Protocol's intent-based model is chain abstraction in action for trading.

When you trade cross-chain on CoW Swap, you don't bridge-then-swap-then-pray across multiple apps. You sign one intent, and solvers find the best swap route and the best bridge route in a single, gasless, MEV-protected flow - [no tab-juggling](https://cow.fi/learn/cow-swap-lands-on-ink-gasless-mev-shielded-cross-chain-ready). Under the hood there's a lot happening; on your screen, it's one move.

A couple of details worth knowing:

-   Your funds stay protected by an Account Proxy (also called CoW Shed). If something goes wrong mid-execution, your assets land safely there - and you can withdraw them to your wallet whenever you like.
    
-   [Cross-chain swaps](https://cow.fi/learn/cow-dao-unveils-seamless-cross-chain-swaps) currently span networks including Ethereum, Gnosis Chain, Arbitrum, Base, Polygon, and Avalanche, with more than one bridge provider working behind the scenes to find your route.
    

It's the same philosophy you'll find across CoW Protocol, just pointed at the multi-chain problem: state your intent, let professionals compete to serve it, and skip the complexity tax.

## A reality check: abstraction isn't magic

Here's the part the hype articles skip. Chain abstraction is wonderful when it works - and it can get awkward when it leaks.

The underlying chains are still real. Different networks finalise at different speeds, and the assets still travel through bridges - which remain [one of DeFi's biggest security risks](https://cow.fi/learn/what-are-the-current-best-practices-for-using-cross-chain-bridges-in-de-fi). A good abstraction layer hides this most of the time, but edge cases - slow finality, mismatched token versions, a misbehaving chain - can still poke through the smooth surface.

So our honest advice: enjoy the simplicity, but don't let it make you incurious. Knowing roughly what's happening under the hood, and following [bridge best practices](https://cow.fi/learn/what-are-the-current-best-practices-for-using-cross-chain-bridges-in-de-fi) when you're moving real size, is still the smart move. Abstraction should remove the busywork - not your judgement.

## The bigger picture

The internet got good when we stopped thinking about it. Nobody checks which servers route their email or which cables carry their video call - it just works, and that invisibility is exactly what let billions of people on.

Crypto is heading the same way. Chain abstraction is the bet that the winning products won't be the ones that make you understand blockchains - they'll be the ones that let you forget there's more than one. You'll state what you want, and the rails will sort themselves out.

And the less you have to think about chains, the more DeFi starts to feel like it was built for you - not for the machines underneath.

large_CoW Protocol - what is chain abstraction.png

medium_CoW Protocol - what is chain abstraction.png

small_CoW Protocol - what is chain abstraction.png

thumbnail_CoW Protocol - what is chain abstraction.png

CoW Protocol - what is chain abstraction.png

Chain abstraction lets you trade across blockchains without juggling tabs, gas tokens, or risky bridges. Learn what it is, how intents and solvers make chains disappear, why it matters for DeFi users, and how CoW Swap puts it into practice.

What Is Chain Abstraction - and Why It Matters for DeFi Users


May was a month for shipping. New infrastructure, a major tokenomics conversation opened, the herd crossed $201B in cumulative volume — and a chapter of accountability was quietly, properly closed.

Let's get into it.

#### May by the Numbers


- Monthly Volume - $2.2B

- Cumulative All-Time Volume - $202.14B

- Monthly Trades - 241,368

- Active Wallets - 40.9k

- New Wallets - 26.3k

- Returning Wallets - 14.6k

- DEX Aggregator Market Share - 16.8% (2nd place)

All-time milestones: 
- $202.1B volume 
- 12.3M trades 
- 708.1K wallets 
- $42M DAO revenue 
- $1.21B surplus returned to users

**On market share:** CoW Protocol sits at 16.8% of DEX aggregator volume across all supported chains in May — behind 0x API (18.7%) and ahead of KyberSwap (16.6%) and 1inch Fusion (14.2%). In a competitive, incentive-driven landscape, holding that position on execution quality alone is worth noting.

#### Intents Get an Upgrade: Atomic Bundles

On May 1, CoW Protocol launched Atomic Bundles — a reusable smart contract template that lets developers bundle multiple complex DeFi actions into a single atomic intent. Looping strategies. Repay-with-collateral. Flashloan-powered operations. All executed in one go, all protected.

This expands what an "intent" can do on CoW Protocol. Atomic Bundles turn intents into composable building blocks that allow for more sophisticated on-chain strategies — submitted as a single signed order, executed atomically by solvers competing for the best outcome.

For developers building the next wave of DeFi products, this is the kind of primitive that opens new design space. Watch what gets built on top of it.

#### CoW Protocol Comes to Euler

Euler has integrated CoW Protocol as the swap execution layer for cross-asset position actions on Ethereum mainnet. Multiply positions, swap collateral, repay debt from collateral — all with MEV-protected execution built directly into the flow, powered by Atomic Bundles. Sign one intent. Solvers compete for execution. Position updates automatically.

#### Affiliate Program: $100M in Referred Volume

The CoW Swap Affiliate Program — approved via CIP-84 in March, launched in April — has crossed $100M in total referred volume. Rewards are flowing to affiliates and traders alike. The program is live, it's working, and it's scaling.

Permissionless. Volume-based. Built to last.

### The Tokenomics Conversation

On May 15, the Core Team published CoW DAO's Path to Value Distribution, developed with Aragon under the Value Distribution Mechanism RFP. The context matters: since April 2024, buybacks have totalled 78.6M $COW against 66.6M in solver emissions - net emissions of -12M $COW, negative every quarter. The protocol is already deflationary. But the Core Team is clear that protocol growth alone doesn't create structural token demand. Mechanism design is needed.

Three proposals are on the table: formalising solver bond requirements (20% of weekly rewards into dedicated Solver Bond Safes); a 1:1 burn trial through December 2026, estimated to permanently remove 60-85M COW; and a flexible buyback mandate giving the Core Team authority to scale purchases up to 100% of weekly revenue based on market conditions. A feedback-driven CIP is the intended next step.

### Simplifying the Bonding Pool

A companion CIP-Draft proposes streamlining bonding pool operations: a flat 10% service fee for all solvers from day one, formalised Solver Bond Safes, and a cleaner path to independent operation. Less overhead, more transparency.

### CIP-86: DNS Hijack Victims Made Whole

In April, cow.fi was hijacked via social engineering at the domain registrar. Around 1.2M USDC in user funds were drained during the roughly 4.5 hours the phishing site was live. The protocol itself was never compromised - but CoW DAO chose to act anyway. CIP-86, the discretionary grants program for affected users, passed on May 8 and closed May 31. Every verified claim has been paid in full. CoW DAO wasn't legally obligated to. It paid because trust is infrastructure too.

See you in June. 🐮

large_cow-dao-monthly-may-2026.png

medium_cow-dao-monthly-may-2026.png

small_cow-dao-monthly-may-2026.png

thumbnail_cow-dao-monthly-may-2026.png

cow-dao-monthly-may-2026.png

All the latest goings on from CoW DAO in May. 

CoW DAO Monthly Recap: May 2026 

Every time you swap tokens on a standard automated market maker, you broadcast your specific route to a public mempool where bots systematically steal value through front-running. An intent based dex stops this leak by letting you declare a final desired outcome and outsourcing the underlying routing to competitive third-party solvers. Fixing the public mempool hazard demands changing the fundamental architecture of a trade from manual mapping to automated settlement. You will learn how this declarative system operates behind the scenes, the math behind the savings, and the hidden risks that private solver networks still carry.

**TL;DR**

* An intent based dex is a trading platform where you state your minimum desired final token balance and third-party solvers find the best way to fulfill that request.  
* Specialized network actors take over your order and compete across all available decentralized markets to fulfill the trade automatically.  
* While this architecture protects trades from public front-running to deliver massive price surplus and save millions for large decentralized organizations, it introduces new centralization risks by relying on private solver oligopolies.

## What is an intent based dex?

An intent based dex is a trading platform that shifts processing from imperative commands to a declarative request. You no longer dictate the specific path your tokens take. Under the traditional imperative model, you trade through liquidity pools directly by manually selecting routers and specifying the precise smart contract calls. This direct connection forces you to determine slippage limits and pathing efficiency, which places the burden of successful execution squarely on the user. If you select a bad pool, you take the financial hit.

DeFi researchers describe this system as a structural shift from manual routing to an automated model where you simply state the minimum acceptable outcome. Breaking away from prescriptive pathing removes you from the technical mechanics. You hand the responsibility over to specialized network actors who figure out how to settle your high-level request on-chain. When you sign a [crypto intent](https://cow.fi/learn/what-is-a-crypto-intent), these third-party actors assume the settlement risk to deliver the desired tokens.

## How an intent based dex works

Relying on third-party actors to bear the settlement risk fundamentally alters the financial outcome for the trader. Specialized operators called solvers now compete in a private marketplace to fulfill your explicit request by sourcing liquidity from any available venue. However, [intent DEX architectures are not uniform](https://developers.uniswap.org/docs/liquidity/uniswapx/overview). Platforms like UniswapX use per-order Dutch auctions where single orders dictate flow, whereas systems like CoW Swap use batch auctions. Regardless of the underlying engine, your signature acts as a binding contract that secures payment if a solver meets your terms.

Here is how the process unfolds in practice:

1. Alex submits an intent requesting to trade 10 ETH for a minimum of 30,000 USDC.  
2. Solvers check for peer-to-peer coincidences of wants, matching opposing trade intents directly to bypass standard pool fees and reduce on-chain gas consumption.  
3. For the remaining volume, solvers scan automated market makers, [DEX aggregators](https://cow.fi/learn/what-is-a-dex-aggregator), and private inventory to build the best routing path.  
4. The solvers submit their proposed fulfillment paths in a competitive bidding process, and a smart contract processes the requested swap outcome.

The request sequence abstracts blockchain complexity away from the user, leaving solvers to assume all the risk of a failed route. If gas prices spike or liquidity vanishes before the block finalizes, the solver absorbs the loss. Standardizing these systems makes the private marketplace even more efficient. The [Ethereum Foundation highlighted the Open Intents Framework](https://blog.ethereum.org/2025/08/29/protocol-update-003) as a production-ready system in 2025 designed for modular order origination, processing, fulfillment, and settlement. Alongside this framework, the [ERC-7683 standard](https://eips.ethereum.org/EIPS/eip-7683) provides a formalized interface for cross-chain trade fulfillment, which pulls more liquidity into the solver ecosystem and drives prices down for the end user.

## Why an intent based dex matters

Driving down prices through solver competition stops the massive financial bleeding caused by public mempool extraction. The default broadcast method comes with severe costs, as bots constantly scan the network to exploit your slippage tolerance. A 2024 study tracking standard platforms identified 55,000 high-confidence token thefts resulting in [over $3.88 million in measurable losses](https://arxiv.org/abs/2401.11547). Declarative systems bypass this hazard directly by taking the order off the public broadcast layer. The bots cannot sandwich a trade they cannot see.

The design shift generates hard-dollar price improvements for traders beyond theoretical efficiency. When the [ENS DAO secured a trading surplus](https://cow.fi/learn/ens-trade-breakdown) by swapping 10,000 ETH to USDC, the protocol realized a price improvement of $80,992.87 with actual slippage settling at just 0.5 percent against a 2 percent tolerance. Similarly, the Aave DAO generated a [$9,699.15 price surplus](https://cow.fi/learn/aave-trade-breakdown) on a 1.9 million DAI to USDC swap using solver-based settlement. Real money flows back into your wallet because solvers constantly under-bid each other to win the order.

Despite these measurable savings, many protocol developers falsely claim that private routing networks are immune to manipulation. The data shows otherwise, as a recent analysis of closed solver networks confirmed [2,932 private sandwich attacks](https://arxiv.org/abs/2512.17602) still occurring against victim transactions. The financial barrier to building a competitive solver limits market participants, which means the ecosystem naturally [consolidates into a limited oligopoly](https://arxiv.org/abs/2403.02525) with lingering censorship risks. Trusting private relays is dangerous without additional protocol safeguards.

## How modern DEXs clear intent orders

Managing the financial upside of declarative trading while avoiding the centralization traps of private solvers demands an engine that forces competition. CoW Protocol strikes this balance by pooling intents into [batch auctions](https://cow.fi/learn/understanding-batch-auctions) handled by a decentralized solver network. By applying uniform clearing prices, the protocol structurally prevents solvers from pocketing the spread and returns the excess value to the trader as surplus. Try CoW Swap to route your next trade through a protected solver network and protect your assets from public mempool extraction.

## FAQs about intent based dex

### How is an intent based dex different from a DEX aggregator?

Aggregators act like search engines for liquidity, finding a route that you still have to process yourself. If the price moves while your transaction is pending in the public mempool, your trade fails or suffers slippage. Intent platforms hand the order to solvers who create and process dynamic routes behind the scenes in real time.

### Do I still pay gas fees on intent trades?

Most intent platforms use gasless signatures to approve a swap. The winning solver pays the actual network gas fee directly and factors that cost into the final quoted price they offer you. Fee abstraction removes complex gas mechanics from the trader, meaning you rarely need native network tokens sitting in your wallet just to cover transaction overhead.

### What happens if no solver wants to fill my order?

The request simply expires unfilled if your parameters are too strict or market conditions shift rapidly. Because you signed a message to approve the trade, a failed order costs you zero gas. You retain full control of your assets, avoiding the frustrating experience of stuck or pending transactions that plague traditional platforms.

### Can solvers steal my tokens?

Smart contracts strictly enforce the parameters you sign upon submission. A solver cannot touch your funds unless their transaction automatically delivers the specific asset amount you requested in the same block. If their proposed path fails to meet your stated minimums, the transaction reverts automatically.

### What is the ERC-7683 standard?

It is a formalized framework that standardizes cross-chain intent orders across the Ethereum ecosystem. By establishing a universal language for these transactions, developers can plug into existing decentralized networks. The framework allows different wallets and applications to share the same unified solver networks.


Learn how an intent based dex protects trades from public MEV by outsourcing routing to private solvers, and why it saves you money over standard automated market makers.

What is an intent-based DEX?

* The intent setup lets users declare an end goal while solvers figure out the best way to achieve it.  
* The model protects traders from miner extractable value (MEV) attacks and bad execution prices.  
* CoW Protocol uses intent architectures to find the best available liquidity across decentralized exchanges.  
* Delegating execution logic reduces the technical burden on everyday retail users.

Intent based trading reverses the traditional model of executing transactions on a blockchain. Users define a desired outcome. Solvers then compete to find the best execution path to reach that outcome.

In a standard transaction, a trader creates a specific set of instructions. The trader selects a decentralized exchange, accepts a certain amount of slippage, signs the transaction, and pays for the gas. The blockchain executes those specific steps. Intent based trading removes the step-by-step instructions. A user simply signs a message stating they want to trade 1 ETH for at least 3,000 USDC. Third-party agents locate the required liquidity and execute the transaction.

## How intent based trading works

Traditional decentralized finance requires users to act as their own brokers. You identify the trading pair, calculate the gas fees, and broadcast the transaction to the public mempool. Broadcasting the order publicly exposes your trade to searchers and miners who can front-run or sandwich your order.

An intent model changes the fundamental workflow. The process relies on a network of third-party actors often called solvers or fillers.

* A user signs an off-chain message declaring their intent to trade asset A for asset B under specific parameters.  
* The signed message goes to an off-chain order book or mempool.  
* Solvers monitor pending signed messages and search for the best way to execute the trade.  
* The winning solver submits the transaction on-chain and pays the required gas fees on behalf of the user.

The user maintains full control over the final outcome. The smart contract cryptographically enforces the conditions set in the signed message. A trade cannot settle unless the rigid conditions of the intent are met.

## Benefits for decentralized finance traders

Trading with intents solves several major problems present in standard automated market maker designs.

### Protection against miner extractable value

Public mempools give malicious actors time to observe pending trades. These actors construct their own transactions to extract profit from unsuspecting users. Intent based trading keeps the order details off-chain until a solver secures execution. Solvers internalize the risk of execution, meaning the user receives the price they requested or better. Solvers effectively absorb the slippage risk that would normally fall heavily on the retail trader.

### Better pricing through batch auctions

CoW Protocol groups multiple intents into a single batch. Solvers match overlapping orders directly against one another. The matching process operates as a coincidence of wants. Matching buyers and sellers directly removes the need to route trades through external automated market makers. Users avoid paying liquidity provider fees and experience lower price impact.

If direct matching is not possible, solvers search across all liquid exchanges to find the best current price. They aggregate liquidity from various decentralized exchanges to fulfill the order.

### Improved user experience

Executing a token swap on a decentralized exchange frequently requires holding a native network token to pay for gas. A user on Ethereum needs ETH to trade an ERC-20 token. Intents let solvers pay the gas fee upfront. The protocol then deducts the gas cost from the final trade amount. You can trade USDC for DAI without keeping a separate ETH balance just to cover network fees.

## The role of solvers in execution

Solvers operate as the processing engine for intent based architectures. These independent entities compete against one another to provide traders with the best settlement prices. The competition forces solvers to search every available liquidity source across the network.

A solver might route part of a trade through Uniswap, route another fraction through Curve, and match the remainder directly with another user in the batch. The winning solver earns a small reward for providing the best path. The intense competition ensures users receive highly favorable rates.

Solvers face financial penalties for bad behavior. If a solver submits an invalid route or fails to execute an order properly, the protocol slashes their bonded stake. The constant threat of financial loss ensures solvers operate efficiently.

## Differences from traditional routing

Standard liquidity aggregators check prices across multiple decentralized exchanges at the specific moment a user requests a quote. The aggregator builds a transaction path and gives it to the user to execute. The market often moves between the time the quote is generated and the block confirmation. The user absorbs the resulting price impact.

Submitting an intent shifts the responsibility of execution. The solver handles the routing logic at the precise moment of settlement. The user takes no risk regarding gas price spikes or sudden changes in automated market maker reserves. The trade either fills at the requested price or fails without costing the user anything.

Intent based systems also separate the concept of expression from execution. Expression covers what the user wants to happen. Execution covers how the network makes it happen. Traditional routing forces the user to handle both parts. Intent models limit the user's responsibility to expression only.

## Intent creation and off-chain limits

Generating an intent requires no on-chain transaction. The user only provides a cryptographic signature. The cryptographic signature acts as a binding agreement that the user will accept a specific trade outcome.

Because intents start off-chain, users gain immense flexibility. You can set up a trade intent to buy a token only if the price drops below a specific threshold. These limit orders sit securely off-chain. They cost zero gas until the market conditions align and a solver executes the trade.

Traders can cancel intents before they are filled without paying gas fees. Traditional limit orders executed fully on-chain require a user to pay a fee to create the order and another fee to cancel it.

## Use cases for CoW Protocol

CoW Swap, built on top of CoW Protocol, implements intent based trading as its primary mechanic. Traders rely on the platform to execute large volume swaps without drastically moving the market price.

Everyday decentralized finance participants use CoW Swap to avoid MEV sandwich attacks. High-volume traders rely on it to access fragmented liquidity pools without manually checking quotes across a dozen different protocols.

Decentralized autonomous organizations execute treasury management swaps by submitting intents. The batch auction system secures favorable execution rates for these massive volume operations. Large trades are split among multiple liquidity sources automatically by the winning solver.

## The future of decentralized trading

The separation of user intent from technical execution points toward a more accessible decentralized finance ecosystem. As more protocols adopt intent-centric architectures, the barrier to entry for new users drops significantly.

Future iterations of intent models may support cross-chain swaps. A user could sign a single intent to trade Ethereum on mainnet for a token on an optimistic rollup. Solvers would handle the complex bridging mechanics in the background.

## Frequently asked questions

### Does intent based trading cost more than a standard swap?

Transaction costs are generally lower or equal to traditional decentralized exchanges. The protocol bundles multiple intents together, spreading the base gas cost across several users. Batching overlapping trades eliminates liquidity provider fees for those specific matching orders.

### What happens if my intent is not filled?

Your intent expires if a solver cannot find liquidity that matches your minimum requirements. You do not pay any gas fees or penalty charges for expired intents because the order never successfully goes on-chain.

### Can anyone become a solver?

Becoming a solver requires massive technical infrastructure and financial bonding. Network participants deposit capital as collateral. The protocol slashes the deposited stake if the solver acts maliciously or fails to execute trades properly.

### Is intent based trading safe?

The architecture offers exceptionally high security guarantees. Smart contracts cryptographically enforce the minimum price requirement. A solver cannot settle a trade for less than the user requested. The protocol verifies you receive either your minimum requested amount or nothing at all.


Learn how intent based trading allows users to specify desired outcomes directly. This model reduces slippage and protects traders against miner extractable value attacks.

What is intent based trading?

**TL;DR**

* Intent based architecture allows crypto users to define their desired outcome while outsourcing the execution details to specialized third parties.  
* Solvers compete to find the best execution path, which often results in better pricing and reduced gas fees for the user.  
* Systems building on intents protect users from maximum extractable value (MEV) attacks and transaction slippage.

## The mechanical shift in decentralized applications

Standard blockchain transactions rely on an imperative model. You specify the specific steps the blockchain takes to execute a trade. You approve the token, sign the transaction, pay the gas fee, and submit the order to a routing contract. The smart contract acts mechanically on your instructions. If market prices shift while your transaction waits in the mempool, your trade might fail or suffer from bad execution.

Intent based architecture flips the focus. You declare what you want to achieve directly. A user might sign a message stating they are willing to trade 1,000 USDC for at least 0.5 ETH. Once you sign the message, you hand the problem over to a network of sophisticated actors. These off-chain operators figure out how to best execute the trade. The underlying protocol enforces your minimum requirements and rejects any execution that fails to meet them.

This structural shift heavily reduces the burden on everyday traders. You no longer need to calculate precise routing paths across multiple unlinked liquidity pools. The system absorbs the heavy lifting, allowing end users to experience decentralized finance exactly as they intend.

## Core components of intent based architecture

Intents require a specialized infrastructure to function securely. The system separates the desired state from the technical execution, dividing responsibilities among users, solvers, and settlement contracts. This operational division creates a highly efficient ecosystem for digital asset exchange.

### Users declare their final goals

The process begins with an off-chain signature. You create an order specifying a starting asset, a desired asset, and a time limit. Your signature acts as a binding cryptographic condition that sets strict boundaries on what the network can do with your funds. You do not pay gas at this stage. You simply broadcast a cryptographic wish to the network.

By keeping the initial request off-chain, the network saves block space and avoids committing useless data to the blockchain. Users can cancel their orders freely before execution without paying network fees.

### Solvers compete for execution rights

Once an intent enters the system, third-party actors called solvers take over operations. Solvers run complex algorithms to search centralized exchanges, decentralized exchanges, private liquidity pools, and active market makers. The solvers compete in an auction to offer you the highest possible value. They look for direct matches between different users, route trades through automated market makers, or apply their own inventory to fill the order.

The competitive nature of this auction forces solvers to provide maximum value to the user. The solver network handles the execution logic, actively fighting each other to present the most efficient transaction path. If a specific solver finds a cheaper route, they win the right to process your trade and collect a small operational reward.

### Settlement contracts enforce the rules

The winning solver groups the intents into a batch and submits them to an on-chain settlement contract. The settlement contract verifies that the execution path meets the specific conditions signed by each user. If a solver attempts to extract value or deliver a price lower than the user's limit, the smart contract immediately rejects the transaction. The solver pays the gas fees for the on-chain execution, and users pay a small fee taken directly from their trade proceeds only if the trade succeeds.

## Solving structural problems in decentralized finance

Moving from step-by-step execution to outcome-focused design addresses many systemic flaws in decentralized finance. The updated design protects ordinary users against predatory network actors and frequent usability hurdles.

### Shielding users from toxic order flow

Public mempools expose standard transactions to searchers and miners who constantly exploit unconfirmed trades. These network attackers use front-running and sandwich attacks to extract wealth from regular users. Intent based architecture keeps user orders off-chain until a solver can fulfill the execution at a specific price. The settlement contract acts as a shield, preventing attackers from manipulating the execution sequence to harm the user. The solver takes on the execution risk, absorbing any mempool hostility.

### Aggregating better pricing algorithms

Standard decentralized exchanges rely heavily on isolated automated market makers. Intent systems aggregate liquidity from the entire crypto ecosystem. Solvers can match trades directly between users in a mechanism known as a coincidence of wants. If one person wants to sell ETH for USDC and another wants to buy ETH with USDC, the solver overlaps their trades directly. The direct match removes automated market maker fees and slippage, granting both traders a massive price advantage.

### Removing friction from the user experience

Standard web3 interactions often demand high technical knowledge. Traders typically need to acquire the native network token to pay for gas, calculate slippage tolerance, and handle failed transactions. Intents abstract these complexities away. You sign a message, and the network actively handles the execution, trade routing, gas payments, and final settlement. The experience heavily mirrors traditional financial applications while retaining the security of self-custody.

## Risks within intent ecosystems

Delegating execution to third parties introduces new challenges to blockchain operations. A dominant solver can monopolize an intent network if competition remains low. High centralization reduces the quality of prices for end users and creates a single point of failure in the routing network.

Censorship resistance also requires intense technical attention. Solvers function as off-chain entities with the power to ignore specific requests. A rogue solver might choose to ignore intents from particular addresses. Network designers mitigate censorship by building diverse, open solver ecosystems where any skilled participant can join the auction. As long as one honest solver remains active in the network, user intents will successfully execute.

Developers must also secure the settlement contracts. Because smart contracts hold the final authority over user funds and intent validation, any flaw in the code could allow a malicious solver to steal assets. Routine auditing and bug bounty programs help secure the settlement layer against these threats.

## Intent based architecture in CoW Protocol

CoW Protocol operates as a leading implementation of intent based architecture for digital asset trading. When you trade on CoW Swap, the meta-DEX aggregator built on top of CoW Protocol, you sign an intent to trade at a specific limit price. The protocol then uses batch auctions to group multiple trades together for the most efficient execution.

The batch auction model creates a highly efficient clearing mechanism for traders. Solvers compete to find a uniform clearing price for all assets across the batch. The protocol actively seeks out coincidences of wants, matching user orders directly against each other before routing the remaining volume to on-chain automated market makers. This direct matching saves traders millions of dollars in fees and potential price impact.

CoW Protocol enforces all user intents through a rigorous settlement contract. Solvers have to provide the clearing price they promised, or the contract rejects the batch. The solver pays the gas, meaning users avoid failed transaction fees. The architecture creates a safe, highly liquid environment for decentralized trading that directly benefits the end consumer.

## The future of intent mechanisms

The implementation of intents spans beyond simple token swaps. Developers actively apply intent based architecture to cross-chain bridging, lending protocols, and complex yield strategies. A user might soon sign an intent requesting a specific yield on their stablecoins. The solver network would then handle the bridging, fund staking, auto-compounding processes, and risk management across multiple blockchains.

As technology matures, solvers will access deeper liquidity pools and deploy faster routing algorithms. The barrier to entry for crypto markets will drop as intent mechanisms hide the technical operations from everyday users. By focusing on final outcomes, blockchain interactions will eventually feel identical to standard internet applications.

## Frequently asked questions

### What differentiates an intent from a traditional transaction?

A traditional transaction dictates the specific computational steps the blockchain takes to finalize a trade. An intent only specifies the final state the user requires. Highly specialized network actors then determine the best computational steps.

### Do users pay gas fees for intents?

Users typically avoid direct gas fees from their wallets when signing an intent. Solvers pay the blockchain gas fees and deduct a small, transparent execution cost from the user's final desired asset.

### Are intent networks centralized?

The creation and settlement of intents happen in a decentralized manner via smart contracts. The execution layer relies on specialized solvers operating off-chain. Healthy intent networks encourage fierce competition among decentralized solvers to prevent monopolies.

### Can an intent expire if no solver picks it up?

Yes. Users set time limits on their signed intents. If market conditions prevent any solver from meeting the minimum requirements before the time limit hits, the intent simply expires at no cost to the user.

### Is intent based architecture safe?

Intent protocols offer high security by enforcing outcomes cryptographically. The smart contract blocks malicious solvers from extracting value. The protocol depends heavily on the security of its settlement contract, making thorough smart contract audits necessary for ultimate user protection.


Learn how intent based architecture changes cryptocurrency transactions by focusing on desired outcomes, avoiding complex manual steps, improving market pricing, and adding security.

What is intent based architecture?

**TL;DR**

* A cross chain swap exchanges tokens originating on one blockchain for a different set of tokens living on another blockchain.  
* Manual methods force traders to interact with bridges, maintain native gas tokens for multiple networks, and execute multiple sequential trades.  
* Intents-based architectures outsource the technical execution to specialized third-party entities called solvers.  
* Solvers compete to find the most efficient execution paths across bridges and decentralized exchanges to return the requested token.

## Understanding the basics of cross chain swaps

As decentralized finance grows, liquidity and applications spread across multiple blockchain ecosystems. You will often find distinct decentralized exchanges, lending platforms, derivatives markets, and non-fungible token marketplaces operating on separate networks. Users frequently need to move value from a base network like Ethereum to a Layer 2 network like Arbitrum or a parallel Layer 1 like Avalanche.

Executing a cross chain swap allows users to trade an asset held on their source network for a different asset on their chosen destination network. If an investor holds ETH on the Ethereum mainnet and wants GMX tokens on Arbitrum, they execute a cross chain swap to complete the transaction. The underlying protocol takes the original ETH, transfers the equivalent value across the network divide, and deposits the final GMX into the user's wallet.

Blockchain networks operate in isolated environments. They cannot directly read each other's state or natively exchange digital assets. This isolation causes liquidity fragmentation, where capital stays locked within specific network borders. Cross chain swaps solve this fragmentation by connecting isolated liquidity pools and allowing capital to flow efficiently to applications on other chains.

## The mechanics behind moving tokens across networks

Moving assets across independent blockchains requires specialized bridging protocols relying on smart contracts deployed on both the source and target chains. Several core technical mechanisms make these transfers possible.

The most common method involves lock-and-mint architecture. A user sends their tokens to a smart contract on the source chain, which locks the assets in a secure vault. The protocol then relays a message across the networks. After verifying the deposit, the smart contract on the target chain mints an equivalent number of synthetic or wrapped tokens and delivers them to the user.

Some protocols skip the wrapping process entirely to maintain large reserves of native assets on multiple chains. A user deposits tokens into the source chain pool. The protocol sends a message to the destination chain pool to release the equivalent value of the desired token to the user.

These relay systems depend on decentralized consensus networks or trusted validators to pass messages securely. The validators confirm that the funds are actually locked or deposited on the source chain before authorizing any release of funds on the target chain.

## Trading versus bridging assets

A standard bridge moves an identical asset from one network to another. Bridging USD Coin from Ethereum to Polygon results in you holding USD Coin on the Polygon network. The asset type remains consistent throughout the transfer.

A cross chain swap takes the process further by integrating decentralized exchange functions into the bridging sequence. The transaction starts with one asset type and ends with a drastically different token on the destination chain.

Executing this multi-step process manually introduces significant friction. Users typically bridge the initial asset to the new network. They then switch their wallet interface to the new network. Because the destination decentralized exchange requires native gas tokens to process a trade, the user needs to hold enough of that native token to pay the transaction fee. Finally, they execute a swap on a local decentralized exchange to acquire the final token.

Cross chain swap protocols attempt to bundle these fragmented steps. They execute the bridging and the subsequent token trades in a continuous automated sequence, removing the need for manual wallet switching.

## Security considerations and risks

Moving liquidity between isolated networks introduces specific security variables. Bridge smart contracts inherently hold massive reserves of locked assets, making them highly attractive targets for malicious actors.

Interoperability protocols rely on validators or external oracles to confirm cross-network messages. If an attacker compromises a validator network, they can forge a deposit message on the source chain and trick the destination contract into releasing funds. This vulnerability has led to significant capital losses across the decentralized finance sector.

Slippage creates substantial financial risk during cross-network trades. Blockchains process blocks at different speeds. Cross chain transactions take significantly longer to confirm than single-chain transactions. The price of the target asset may change while the initial bridge transfer is processing. The user might receive fewer tokens than expected by the time the final swap executes on the destination chain.

Maximum extractable value bots also target these delayed transactions. Bots identify large cross chain swap orders pending on destination networks and execute front-running trades to extract value from the price impact.

## The shift toward intents-based trading

The traditional transaction model requires users to dictate the explicit technical path of their trade. They manually authorize token approvals, select specific bridges, pay network gas fees, and broadcast the final swap to the memory pool.

Intents-based trading fundamentally changes this technical user experience. A user simply signs a digital message stating the asset they currently hold and the final token they want to receive. They express a distinct trading intent.

Specialized algorithmic actors take over the actual execution process. These actors compete against each other to find the most efficient route to fulfill the user's request. Because the algorithmic actors handle the complex bridging mechanics and routing logistics, the user does not need to maintain balances of gas tokens for multiple chains.

Intents-based routing transfers the execution risk from the individual trader to the institutional solvers. If a bridge transaction fails or delays, the solver absorbs the financial penalty. The user only completes the trade if the solver fulfills their defined intent at the specified price.

## Executing transactions with CoW Protocol

CoW Protocol uses an intents-based architecture to make cross chain execution highly efficient. Users specify their desired final output, and independent solvers search for the optimal path across various blockchain networks.

They also analyze decentralized exchanges and bridges simultaneously, and then mathematically bundle the individual transaction steps out of sight from the user. The solver covers all intermediate network fees and bridging costs, simply deducting the equivalent operating value from the final output amount.

Relying on these solvers protects traders against network failures and routing errors. CoW Swap ensures the trader receives the output they cryptographically signed. If the network conditions prevent solvers from executing the trade at the specified price, the transaction simply fails to execute, and the user retains their original assets securely in their wallet.

By abstracting the technical requirements of standard bridging, CoW Swap makes interacting with multiple networks feel identical to executing a standard token trade on a single chain.

## Frequently asked questions

### How long does a cross chain transaction take?

Confirmation times depend on the specific bridging protocols applied and the current congestion of the networks involved. Certain transfers confirm in a matter of minutes. Protocols relying on optimistic rollups might require up to a week for standard withdrawals to process mechanically. Intents-based systems often fulfill orders faster by fronting liquidity directly on the destination chain.

### Do I need gas tokens for both networks?

Applying manual bridging methods requires traders to hold native gas tokens for every network they interact with. Using an intents-based protocol like CoW Protocol eliminates this requirement. The solvers pay the necessary gas fees to network validators and deduct the equivalent value directly from the traded assets.

### Can I swap assets between non-Ethereum Virtual Machine chains?

Yes. Specific interoperability systems successfully connect structurally different networks, such as Ethereum and Solana. The specific routes available depend on the protocol you choose and the liquidity bridges supporting those independent ecosystems.

### What happens if my transaction fails midway?

Manual bridging occasionally results in mid-point failures, leaving traders with assets locked on a bridge contract or trapped as the wrong token on the destination chain. Using intents protects against this outcome. The structural design ensures atomicity. You either receive the specific token you requested, or the transaction fails to proceed and your initial assets remain safely in your original wallet.


Learn how a cross chain swap works, the difference between swapping and bridging, and how intents-based trading simplifies cross-network transactions.

What is a cross chain swap?

CoW DAO develops the most user-protective products in Ethereum - so you can do more with less worry.

All articles