We Lost $1,800 on a Transfer That Worked Fine

December. Had to move a large USDC position from Ethereum to Solana. Not the first time. Opened Wormhole, connected wallet, pasted address, confirmed. Four minutes, done. Everything worked. Didn't think about it again.

About a week later we needed to test something on deBridge — completely unrelated — and while we were there, just out of curiosity, we plugged in the same numbers from that transfer. Same token, same amount, same direction. Roughly same time of day.

deBridge would have been $1,800 cheaper.

Not because Wormhole ripped us off. Not because anything went wrong. Just... liquidity conditions at that specific moment happened to favor deBridge. And we didn't check. Why would we? Wormhole has always worked fine.

Going Down the Rabbit Hole

That $1,800 was annoying enough to spend an evening on. We went back through the last month of transfers — maybe a dozen total — and re-quoted each one across every bridge we could find. Wormhole, deBridge, LayerZero, Allbridge. Matched the amounts, found the closest timestamps.

This was tedious. Each bridge has a different UI, different fee display format, different way of showing slippage estimates. Some show total cost upfront, some bury it. Allbridge shows pool-based fees that scale differently from Wormhole's flat guardian fees. LayerZero's costs depend on which DVN config is active. Comparing them side by side meant a spreadsheet and a lot of tab-switching.

The result was worse than we expected. Not "a few were suboptimal." All of them. Every single transfer had a cheaper option that we didn't take.

Here's a sample from the spreadsheet:

1Transfer #4 — $85K USDC, ETH → SOL, Dec 11 14:32 UTC
2  Wormhole (used):  net $84,620  (fees $142, slippage ~$238)
3  deBridge:         net $84,890  (fees $98, slippage ~$12)    ← $270 better
4  LayerZero:        net $84,780  (fees $118, slippage ~$102)
5  Allbridge:        net $84,710  (fees $132, slippage ~$158)
6
7Transfer #7 — $142K USDC, ETH → SOL, Dec 18 09:15 UTC
8  Wormhole (used):  net $141,180  (fees $210, slippage ~$610)
9  deBridge:         net $141,520  (fees $155, slippage ~$325)
10  Allbridge:        net $141,940  (fees $180, slippage ~$(-120))  ← $760 better
11  LayerZero:        net $141,410  (fees $175, slippage ~$415)
12
13Transfer #11 — $210K USDC, SOL → ETH, Dec 22 16:48 UTC
14  Wormhole (used):  net $208,840  (fees $315, slippage ~$845)
15  deBridge:         net $212,240  (fees $248, slippage ~$(-488))  ← $3,400 better
16  LayerZero:        net $209,680  (fees $285, slippage ~$35)
17  Allbridge:        net $209,120  (fees $298, slippage ~$582)

Transfer #11 still bothers us. $3,400. On a single transfer. deBridge's DLN happened to have excellent fill conditions at that moment — intent-based, so no pool slippage — and we were sitting on Wormhole watching guardian consensus for five minutes while the better option was right there.

Smallest gap across the whole month was around $200. Average was about $900. We'd been telling ourselves we were being responsible by sticking with the "reliable" bridge. Turns out we were just being lazy.

Why Nobody Checks

It's not stupidity. Comparing bridges manually is genuinely painful. Open four tabs. Connect wallet four times. Wait for quotes. Try to mentally compare fee structures that are all calculated differently. Factor in slippage estimates that you're not sure you trust. Think about speed. Think about reliability.

We timed ourselves doing a full manual comparison once. Four bridges, one transfer. It took 47 seconds from start to having all four quotes open. And that's us, knowing exactly where to go and what to look for. For someone less familiar it's a multi-minute process.

And here's the kicker: by the time you've compared all four, the first quote is already stale. Bridge conditions move. Gas changes. A large trade hits a pool and shifts the balance. The comparison you just did is already partially wrong.

So you just use the bridge you used last time. Everyone does this. It's rational behavior given the friction. The irrational part is that bridge conditions change constantly and your habit doesn't track any of it.

The Night We Wrote the First Script

Couldn't sleep after looking at that spreadsheet. The numbers were too annoying. Wrote something quick. It was genuinely terrible:

1// the entire "engine" on night one. don't judge.
2const quotes = await Promise.all([
3  wormhole.getQuote(params),
4  debridge.getQuote(params),
5  layerzero.getQuote(params),
6  allbridge.getQuote(params),
7]);
8
9// just... sorted by output. that's it. that's the algorithm.
10const best = quotes.sort((a, b) => b.outputAmount - a.outputAmount)[0];
11console.log(`use ${best.bridge}, saves ${best.outputAmount - quotes[3].outputAmount}`);

Hardcoded addresses. No error handling. Crashed if any API took more than 5 seconds. The Allbridge adapter was wrong for about three days because we misread their fee docs. But the core idea — hit all four APIs, compare outputs — worked.

We ran it before the next real transfer. It said deBridge. We would have picked Wormhole again. The difference was about $400 on that one. Not life-changing, but free money we would have left on the table.

Started using it for every transfer after that. Just running the script before hitting confirm on any bridge. Over the next two weeks, it picked a different bridge from our "default" about 70% of the time. Sometimes the savings were $50. Sometimes $800. Never once did it pick wrong when we spot-checked.

Where It Got Interesting

The script just sorted by cheapest output. That's what every aggregator does. Fine. But after a few weeks of using it, we noticed something weird.

One transfer — the script picked a bridge with the lowest fees but the pool turned out to be thin. We were watching the transaction in the explorer and the actual output was significantly worse than quoted. Slippage came in way higher than the estimate. Another bridge had quoted $80 more in fees but had a deep pool. If we'd used that one, slippage would have been negligible. Net-net we would have saved over a thousand dollars.

Then it happened again on a different transfer. And again. The pattern was clear: the cheapest quote and the best actual outcome were not the same thing. Especially on larger transfers where pool depth actually matters.

1Jan 8 — $95K USDC ETH → SOL
2  script picked: LayerZero (cheapest quote, $94,820)
3  actual outcome: $94,340 (slippage was 3x quoted)
4
5  should have picked: deBridge (quote $94,740, but deep DLN fill)
6  likely outcome: ~$94,700 (intent fill, minimal slippage)
7
8  difference: ~$360 lost by following the "cheapest" quote

The quote is a best-case number. What actually happens depends on pool depth, congestion, timing, MEV, fill availability. The bridge that looks cheapest on paper can cost you the most in practice.

That's when the question changed. Not "which bridge has the best quote" but "which bridge gives the best outcome when things don't go perfectly." That second question turned out to be much harder. And much more interesting.

That's what we started building on January 20.