Cross-Chain Execution Quality Index: The True Cost of Moving Crypto Between Blockchains
What Matters
The cheapest bridge quote can leave the most expensive completed workflow. Compare the exact destination outcome, separate cash fees from the assumed value of waiting, and identify what remains committed after a partial result. DN supplies a documented cost framework and two local instruments. This edition contains no live route measurements, provider rankings or verified failure probabilities.
Decentralised News · Editorial by Heath Muchena · Evidence reviewed 11–12 November 2026 · DN-CEQI v1.1 with recovery-method update
DN Evidence Block
Documented: primary provider fee and recovery rules, classic IBC and LayerZero V2 architecture, and original cross-chain coordination research. Original DN analysis: usable-value accounting, a route-cost scenario model and a commitment-evidence map. Not measured: live route costs, fills, latency distributions, refunds, capacity or a universal multi-chain atomicity limit. Numerical examples are constructed unless expressly attributed to provider documentation.
Affiliate disclosure: Decentralised News may receive compensation when eligible readers use partner links. Commercial relationships do not determine the framework, source selection or conclusions.
The claim versus the evidence
A low advertised bridge fee does not establish a low end-to-end cost. The proposed DN comparison includes source gas, bridge and solver charges, conversion losses, additional destination gas, application fees, quote movement and recovery effort. The local calculator also models a user-chosen value for waiting.
Failure-adjusted modeled economic cost = direct execution cost + modeled latency cost + probability-weighted additional recovery burden.
This is a framework awaiting an independently collected route dataset. The four standard sizes—$1,000, $10,000, $100,000 and $1 million—are separate proposed test sizes. The calculator’s size table is a sensitivity exercise, not evidence that any route supports those amounts at the same rates.
Key findings
- Bridge fee is one component. A small protocol charge can coexist with larger conversion, gas or completion costs.
- Trade size changes the arithmetic. A $5 fixed cost is 50 basis points on $1,000 and 0.05 basis points on $1 million.
- Compare the same intended outcome. A same-token transfer and a cross-chain swap into another asset have different dependencies.
- Speed and recovery need separate evidence. A quick ordinary fill does not establish a quick refund. [5]
- Destination usability matters. A fallback asset can preserve value while leaving the requested workflow incomplete. [9]
- Recovery is not universal rollback. A completed bridge leg can remain committed after a later operation fails. [8]
- Quotes are dated observations. Current market conditions and route details matter; fresh quotes must precede any actual comparison. [4]
The Wrong Question Is: “Which Crypto Bridge Has the Lowest Fee?”
Consider a constructed example, not observed quotes, for moving $100,000.
Route A
Advertised bridge fee:
$8
Final economic cost after gas, swaps and price deterioration:
$103
Route B
Advertised bridge fee:
$22
Final economic cost:
$61
Which was cheaper?
Route B.
Yet a conventional fee-comparison article could easily rank Route A first.
That is the problem the DN Cross-Chain Execution Quality Index is designed to solve.
Instead of asking:
Which bridge advertises the lowest fee?
DN asks:
How much economically usable value arrives on the destination blockchain, how long does it take, and what happens when the route does not complete normally?
What is cross-chain execution quality?
Cross-chain execution quality concerns the difference between the asset and value committed on the origin chain and the intended usable outcome on the destination chain. A route can involve wallet approval, an origin swap, value transfer or an intent fill, destination settlement, a final swap or contract call, and enough gas to use the result.
Each dependency can add cost or delay. Record the exact intended asset, network and final action before comparing routes. A route that delivers an intermediate token has not necessarily completed the same task as one that finishes the requested vault deposit.
The DN Definition of “Usable Destination Value”
This article introduces a deliberately stricter concept:
Usable Destination Value
The fair USD value of the asset the user can actually deploy, transfer or trade after the complete intended cross-chain route has finished.
This distinction is important.
Suppose a user wants:
ETH on Arbitrum → SOL on Solana
The bridge delivers USDC to Solana, but the final SOL swap fails.
The user’s funds may be safe.
The bridge may technically have succeeded.
But the intended transaction has not produced the requested usable destination asset.
LI.FI’s current documentation explicitly recognises these outcomes through statuses such as DONE / PARTIAL, where value reaches the destination but the exact intended token may not.[9]
DN therefore refuses to treat:
funds not lost
as synonymous with:
execution completed exactly as requested.
The DN Cross-Chain Cost Stack
The framework separates cash friction, price effects, waiting and recovery. Quote movement must be kept separate only where it is not already captured in a conversion-loss input.
Cost Component | What to record |
Source Gas | Approval and origin-chain execution |
Bridge / Solver Cost | Protocol, LP, relayer, solver and messaging economics |
Origin Slippage | Loss during any pre-bridge conversion |
Destination Slippage | Loss during any post-bridge conversion |
Destination Gas | Gas paid or economically deducted for destination execution |
Integrator / App Fee | Additional routing or application fee |
Latency Cost | Economic value of capital being unavailable during settlement |
Recovery Cost | Expected economic burden of failed, partial or refunded routes |
Record non-overlapping components before combining them. An entered assumption is not an observed fee.
The DN All-In Cross-Chain Cost
For component-level analysis:
Direct Cross-Chain Cost
DCC = SG + BF + OS + DS + DG + AF + QD
Where:
SG = source gas
BF = bridge / solver / relayer fees
OS = origin swap loss
DS = destination swap loss
DG = destination gas not already embedded
AF = application / integrator fees
QD = adverse quote deterioration
Then:
Latency Cost
LC = Capital × Opportunity Cost (bps per hour) ÷ 10,000 × Base Settlement Hours
And:
Expected Recovery Cost
ERC = P(Extra Recovery) × (Additional Recovery Spend + Additional Recovery Delay Cost)
Finally:
DN Failure-Adjusted All-In Cost
FAIC = DCC + LC + ERC
Expressed in basis points:
FAIC bps = FAIC ÷ Transfer Value × 10,000
This is a modeled metric in DN-CEQI. Base fees and base delay are counted once; recovery spend and recovery delay are incremental. The model does not deduct refunded fees, build a full conditional outcome tree, simulate retries or price irreversible principal loss. Its opportunity-cost component is not a cash debit.
A Second Method Prevents Double Counting
Cross-chain APIs frequently embed several costs inside the quoted output.
Adding every displayed fee again can therefore exaggerate the real cost.
A future measured benchmark should also reconcile the component model against delivered value. Use a consistent market-price basis, and distinguish execution friction from ordinary asset-price movement.
DN Delivered Value Method
All-In Economic Loss = Origin Fair Value + Externally Paid Costs − Destination Usable Fair Value
Suppose:
Origin value:
$100,000
Destination usable value:
$99,940
Gas paid outside the quoted amount:
$7
Then:
Total economic loss = $67
or:
6.7 basis points
This method captures what actually matters to the user.
The component model explains why the $67 disappeared.
A reconciled delivered-value record shows the economic difference under the declared valuation basis; it does not independently attribute every dollar to the bridge.
Using both can expose double-counting or missing costs. Do not add fees again when they are already embedded in the received amount. The $67 and 6.7 bps above are constructed arithmetic, not a measured route.
Why $1K, $10K, $100K and $1M Must Be Tested Separately
A bridge ranking that tests only one transfer size can be nearly meaningless.
Consider a fixed $2 cost.
Transfer | $2 Fixed Cost in Basis Points |
$1,000 | 20.00 bps |
$10,000 | 2.00 bps |
$100,000 | 0.20 bps |
$1,000,000 | 0.02 bps |
Now consider a variable 10 basis-point execution cost.
Transfer | 10 bps Economic Cost |
$1,000 | $1 |
$10,000 | $10 |
$100,000 | $100 |
$1,000,000 | $1,000 |
The winner can therefore change as order size increases.
For a small transaction, avoiding Ethereum gas might matter most.
For a $1 million transaction, saving three basis points of route deterioration represents:
$300
The marginal importance of a $2 transaction fee becomes almost irrelevant.
DN Size Elasticity
A future measured dataset can also describe size sensitivity.
Cross-Chain Cost Elasticity
Compare how a route’s total basis-point cost changes across separately executable sizes. The current calculator does not measure a liquidity curve.
A route dominated by fixed fees should become dramatically cheaper in basis-point terms as size increases.
A route dominated by:
- liquidity impact,
- solver margin,
- percentage protocol fees,
- DEX slippage,
may not.
This creates a useful classification.
Fixed-Cost Dominated
Fixed charges dilute as transfer value rises, if other economics remain unchanged.
Variable-Cost Dominated
Economic cost scales approximately with transfer value.
Liquidity-Curve Dominated
Costs may accelerate sharply once order size becomes large relative to available liquidity.
This last category is particularly important for the $100,000 and $1 million benchmarks.
Same-Asset Bridge vs Cross-Chain Swap
A future DN-CEQI dataset should use separate cohorts.
Cohort A: Same-Asset Transfer
Example:
USDC on Arbitrum → USDC on Base
This primarily tests:
- bridge fee
- gas
- settlement speed
- liquidity
- failure recovery
Cohort B: Cross-Asset Transfer
Example:
ETH on Ethereum → SOL on Solana
Now execution may require:
- source swap
- bridging
- destination swap
- multiple liquidity venues
- additional slippage
Cohort C: Bridge + Contract Action
Example:
USDC on Arbitrum → deposit into a lending vault on Base
Now execution quality includes whether the final contract call succeeds.
Cohort D: Canonical Bridge
Canonical withdrawal mechanisms can involve intentionally long settlement periods and should not be ranked directly against intent-based fast bridges without accounting for their fundamentally different security and settlement models.
DN Cross-Chain Benchmark Architecture
Every live test should record:
- Origin blockchain
- Destination blockchain
- Input asset
- Requested destination asset
- USD reference value
- Quote timestamp
- Source transaction timestamp
- Destination delivery timestamp
- Time to usable balance
- Expected output
- Minimum output
- Actual output
- Source gas
- Destination gas
- Protocol fee
- Solver / relayer fee
- Integrator fee
- Origin swap impact
- Destination swap impact
- Route path
- Underlying bridge
- Underlying DEX
- Quote-to-execution deviation
- Completion state
- Refund state
- Manual recovery requirement
- Recovery cost
- Recovery time
- Final usable destination value
The same methodology should then be repeated at:
$1K
$10K
$100K
$1M
where the route can realistically support the requested size.
A route that cannot return an executable $1 million quote should be recorded as:
NO EXECUTABLE ROUTE
rather than silently omitted.
That itself is valuable execution-quality information.
The Most Important Timing Metric: Time to Usable Funds
Cross-chain marketing often focuses on transaction speed.
The proposed benchmark uses a stricter endpoint:
Time to Usable Destination Balance
Predeclare the start event. Record both submission and inclusion; never silently mix those timing definitions within one latency comparison.
It stops only once the intended destination asset can actually be used.
Why?
Because these are not equivalent:
USDC has arrived
and
the requested destination swap has finished successfully.
Likewise:
destination transaction exists
is not necessarily the same thing as:
funds are economically available to the user.
Median Speed Is Not Enough
DN should eventually report:
Median completion time
P75 completion time
P95 completion time
Maximum observed completion time
Why P95?
Because a route that usually finishes in three seconds but occasionally takes two hours creates a very different operational risk from one consistently completing in 15 seconds.
Average speed can hide the tail.
DN Recovery Burden
Most bridge rankings virtually ignore what happens when something goes wrong.
DN treats recovery as part of execution quality.
A transfer may result in:
Outcome 1: Completed
Exact intended asset arrives.
Outcome 2: Delayed
Correct asset arrives, but significantly later than expected.
Outcome 3: Partial
Value arrives, but in an intermediate or fallback asset.
Outcome 4: Automatic Refund
Funds return without user intervention.
Outcome 5: Manual Recovery
User must submit another transaction, claim funds or intervene on another chain.
Outcome 6: Support-Assisted Recovery
The route requires assistance from the bridge or aggregator.
Outcome 7: Irrecoverable
Funds cannot reasonably be recovered.
These are economically different outcomes.
These are DN research categories, not universal provider status names. LI.FI documents DONE with PARTIAL for relevant fallback outcomes. Record the provider’s raw status and actual asset state alongside any normalized research label.[9]
Refund Reliability Requires a State History, Not a Rollback Label
A recovery claim should identify the state transition it promises. “Request accepted,” “eligible for refund” and “funds spendable by the intended beneficiary” are different events. In particular, the fact that an order expired does not establish that the refund transaction has executed.
| Observed state | Evidence to retain | Do not infer |
|---|---|---|
| Requested | Operation identity, accepted request and requested outcome. | That funds moved, the request was valid for execution, or a deadline began at the UI click. |
| Source committed | Receipt, token and amount; chain-specific finality assumption. | That the destination call completed or the source action can still be cancelled. |
| Recovery eligible | Unfilled or failed condition, deadline, authority and required proof. | That an API label alone establishes an immediately executable claim. |
| Recovery submitted | Correct chain, permitted actor, gas and transaction reference. | That submission is inclusion or finality. |
| Recovered | Actual beneficiary, asset, amount and time it becomes usable. | That prior fees, exposure or third-party effects were reversed. |
The reviewed deBridge cancellation flow requires the specified destination authority to initiate cancellation on the destination chain, followed by a message unlocking source funds. Its documented refund includes applicable protocol and affiliate fees, but the cancellation still requires gas and messaging resources. Across describes an expired, unfilled deposit as eligible for its later bundle and refund process. These are different recovery paths, not two examples of a universal instant reversal. [3] [5]
Use two denominators and keep pending cases
For a future observed cohort, report normal completion across all eligible initiated requests separately from recovery completion across requests that actually became eligible for the chosen recovery process. Do not divide recovered requests by every successful ordinary transfer and call the result refund reliability. Publish the inclusion rule, the number of requests in each group and the observation cutoff.
Constructed example: ten requests become recovery-eligible, seven have returned usable funds by the cutoff and three are still pending. The observed completed-by-cutoff fraction is 7/10. It is neither a 70% eventual recovery probability nor proof that the three remaining requests have permanently failed. Report their elapsed waiting times and unknown outcomes. A latency statistic based only on the seven completed recoveries excludes the longest unresolved waits; label it as a completed-case statistic or use a justified time-to-event method.
For partial destination execution, record what remains: the intermediate token, an open position, permission changes or an application obligation. LI.FI’s documented partial outcome illustrates why a completed bridge leg need not reverse after a later call fails. A subsequent swap or compensation is another action with its own cost and permissions. [8]
The existing commitment map below already contains recovery-actor, residual-state and failure-test fields. Add these event references there rather than inventing an overall rollback score. The cost calculator remains a scenario model: it does not estimate the recovery fraction from this narrative or deduct fee refunds automatically.
The DN Expected Recovery Cost
For a constructed recovery scenario, assume:
Transfer value:
$100,000
Assumed probability of additional recovery:
1%
Additional cash cost conditional on recovery:
$12
Additional delay conditional on recovery:
four hours
If the user’s capital opportunity cost is:
2 bps per hour
then conditional delay cost is:
8 bps × $100,000 = $80
Total recovery burden conditional on failure:
$92
Expected recovery cost:
1% × $92 = $0.92
That is:
0.092 basis points
It may appear small.
But if the failure probability rises, recovery requires days rather than hours, or the transaction involves an active arbitrage opportunity, the economics can change rapidly.
The calculator below allows readers to model their own assumptions rather than having DN pretend every user’s opportunity cost is identical.
deBridge DLN: solver-based cross-chain execution
deBridge documents a solver model in which destination liquidity is supplied on demand. Its fee overview separates a native-token flat charge, a protocol fee, solver margin and gas that may be included in the quoted rate. The DLN fee page documents a 4 bps protocol component and says to query current contract values rather than hard-code charges. These are component descriptions, not a DN quote or an all-in 4 bps price. [1] [2]
For a documented unfilled-order cancellation, the destination authority initiates the relevant action and cross-chain messaging unlocks source funds. The described refund includes applicable protocol and affiliate fees, while gas and messaging resources can still be required. The right to recover and the cost of doing so are separate questions. [3]
DN comparison question: how much output does the current quote deliver after all embedded economics, and what actor, chain and resources would an unfilled order require? The calculator’s additive recovery model does not automatically account for refunded protocol fees.
Across: intent-based relayer execution
Across describes fees through the difference between input and output, with LP and relayer components. Relayer economics include gas, capital opportunity cost and risk; LP pricing responds to utilization. Optional application fees are distinct. The current documentation labels /suggested-fees legacy and directs new integrations to the Swap API response. A reproducible sample must retain the API version and actual response, not copy a historical field list. [4]
Across reports that most deposits fill in roughly two seconds. That is a provider claim, not a DN-observed distribution. Its refund documentation describes eligibility after an unfilled deadline and subsequent bundle settlement, challenge and canonical-bridge processing. Refunds can take hours; the ordinary fill claim does not establish tail recovery latency. [5]
DN comparison question: separate fill time from refund time, preserve route limits and valuation units, and retrieve fresh fee data. No independent Across fill or refund sample was collected for this edition.
Stargate V2: the execution mode is part of the quote
Stargate V2’s user documentation distinguishes Fast/Taxi, an immediate one-to-one transfer mode, from Economy/Bus, which batches messaging costs and can add waiting. Destination-gas behavior also depends on the selected mode. These are documented design choices; they are not measured savings or completion times. [6]
A fair record therefore includes the mode, asset pair, chains, transfer size, quote time and destination requirements. “Stargate costs X” omits information needed to reproduce the result. The relevant trade-off is the complete quoted cost and usable-funds delay for the same requested task.
LI.FI: an aggregator needs a separate comparison
An underlying-bridge comparison asks how one execution mechanism performs. An aggregator comparison asks whether a routing system selects a better complete path after its own charges. LI.FI’s documentation describes a default integration fee of 25 bps, with commercial arrangements that can differ. That is a documented default, not proof that every LI.FI-powered interface or route charges the same amount. [7]
Record the actual application, fee configuration and underlying bridge/DEX path. A good route-selection decision can improve execution, while an additional charge can offset some benefit. Only the net, like-for-like destination outcome resolves that comparison.
Partial execution creates a completion task
LI.FI documents relevant routes in which a completed bridge step cannot be undone when a later destination action fails. Its intermediate-token guidance explains DONE/PARTIAL: value has arrived, but the user may hold a fallback asset instead of the requested token. [8] [9]
If a hypothetical request for SOL produces USDC on Solana, another swap and destination gas may be needed. Record that residual asset and remaining task before estimating costs. The commitment map below examines this state boundary; the cost model can then price explicitly chosen completion assumptions.
Relay: use the current fee categories
Relay documents a solver-capital execution flow with settlement steps that depend on the route. Its current fee guide groups costs into execution, swap, platform and application fees. The guide also distinguishes origin gas paid separately by a non-gasless user from costs included in the route’s execution breakdown. [10] [11]
The current fee response uses data.fees.execution, swap, platform and app. Older relayer-fee fields are deprecated. Save the response version and count each cost once; a renamed API field is not evidence that the corresponding economic charge disappeared. This edition makes no independent Relay speed claim. [10]
OKX DEX Bridge: evaluate the selected route
OKX Web3’s DEX guide, updated 19 October 2026, describes bridge aggregation as part of its routing interface. The correct comparison records the selected underlying route and the final costs presented for the exact request. The number of integrated chains or venues does not establish better execution for a particular transfer. [12]
The research question is whether the routing layer improves the same usable destination outcome after all charges. A brand-level comparison against one bridge can be misleading when the aggregator itself selects that bridge. The current guide provides product documentation, not an independently tested DN performance result.
Architecture Comparison Before Live DN Measurements
Platform | DN Classification | Primary Execution Model | What Makes It Interesting |
deBridge DLN | Direct protocol | Solver / intent, 0-TVL | Transparent component costs and solver economics |
Across | Direct protocol | Relayer / intent | Fast-fill architecture and explicit relayer economics |
Stargate | Direct protocol | Omnichain liquidity / messaging | Explicit fast vs batched cost trade-off |
Relay | Direct protocol | Solver / intent | Cross-chain execution and detailed fee decomposition |
LI.FI | Aggregator | Multi-bridge + DEX routing | Route selection across many underlying venues |
OKX DEX Bridge | Aggregator | Multi-bridge routing | Consumer-facing bridge aggregation across many networks |
This is an architecture comparison, not an empirical ranking.
DN will not fabricate performance numbers where observations have not yet been collected.
What Happens at $1 Million?
Large cross-chain orders deserve separate treatment.
For $1 million:
1 basis point = $100
5 basis points = $500
10 basis points = $1,000
50 basis points = $5,000
That means a route offering:
$3 lower gas
is irrelevant if it introduces:
8 bps additional execution loss
because the latter represents:
$800
at $1 million.
Large-order testing should therefore prioritize:
- executable capacity,
- delivered value,
- price impact,
- solver economics,
- completion certainty,
before obsessing over fixed gas.
The $1 Million Liquidity Trap
An important DN rule will be:
Never scale a $1,000 quote linearly to estimate a $1 million route.
Cross-chain liquidity can be nonlinear.
At higher sizes:
- solver inventories can become constrained,
- LP utilization can change,
- different bridges may become optimal,
- DEX price impact can accelerate,
- maximum route limits may be reached,
- route splitting may appear,
- quote availability may disappear entirely.
Across, for example, exposes min/max route limits and notes that fees respond to pool utilization.[4]
A consumer-interface maximum does not guarantee liquidity for every pair or size. Record the exact executable quote, limits, expiry and route at the time of the request.
DN Executable Capacity
The eventual Index should therefore include:
Maximum Executable Quote
Largest size at which a route returns an economically valid executable quote.
Large-Order Cost Slope
Change in cost bps as size increases.
Route Mutation Rate
How frequently the underlying bridge or liquidity path changes as size grows.
Large-Order Completion Rate
Observed success at professional and institutional sizes.
These measurements can reveal a platform that looks ordinary at $1,000 but becomes highly competitive at $500,000.
Or the reverse.
Latency Has a Price
For a hypothetical latency trade-off, consider two routes.
Route A
Cost:
8 bps
Settlement:
5 seconds
Route B
Cost:
5 bps
Settlement:
20 minutes
Which is better?
For someone moving stablecoins into long-term storage:
Route B has the lower stated fee, assuming other outcomes and risks are equivalent.
For an arbitrageur trying to capture a rapidly closing price discrepancy:
Route A may be preferable if the shorter delay is worth more than its extra stated cost; that requires an explicit assumption.
Therefore latency cannot be assigned one universal dollar value.
The DN calculator lets the reader specify an:
opportunity cost in basis points per hour
and converts the route delay into an economic cost.
DN Latency-Adjusted Cost
Suppose:
Capital:
$100,000
Delay:
30 minutes
Opportunity cost:
4 bps per hour
Latency cost:
$100,000 × 4/10,000 × 0.5
= $20
A supposedly cheaper route may therefore become economically inferior for time-sensitive capital.
For passive transfers, readers can simply set opportunity cost to zero.
Quote freshness matters here too
A cross-chain path can combine an origin conversion, a bridge quote, a destination conversion, gas estimates and solver pricing. Across explicitly says not to cache fee responses because fees respond to market conditions; deBridge likewise describes market-dependent quotes. [4] [1]
Record quote request, quote response, submission and usable-funds times. Compare quoted and delivered value using the stated price basis. Do not treat a stale quote as an executable promise or apply one universal refresh interval to every API.
The DN Cross-Chain Route Test
Every benchmark run should use identical controls wherever technically possible.
Route Parameters
Same:
- origin chain
- destination chain
- input token
- output token
- USD size
- wallet architecture
- slippage tolerance
- gas policy
- sampling window
Timing
Capture:
T0: quote request
T1: quote returned
T2: transaction submitted
T3: origin confirmation
T4: destination transaction
T5: intended output economically usable
Pricing
Record reference-market prices at:
T0
and
T5
so ordinary asset-price movement is not automatically attributed to the bridge.
Test Across Different Market Conditions
One quiet Tuesday afternoon is not enough.
Eventually DN should divide observations into:
Normal Liquidity
Routine conditions.
High Volatility
Sharp market movement.
Congested Networks
Gas or block-space stress.
Weekend Liquidity
Separate calendar windows; test rather than assume differences in liquidity.
Long-Tail Assets
Thin liquidity.
Stablecoins
Record price deviations and depeg conditions rather than assuming a constant dollar value.
A sufficiently sampled future dataset could then examine:
Which route is cheapest?
but:
Which route remains economical when conditions deteriorate?
DN Cross-Chain Execution Dataset
The long-term data object should expose fields such as:
observation_id
timestamp_utc
origin_chain
destination_chain
input_asset
output_asset
input_value_usd
provider
underlying_bridge
route_type
quoted_output
minimum_output
actual_output
source_gas_usd
destination_gas_usd
protocol_fee_usd
solver_fee_usd
app_fee_usd
origin_slippage_bps
destination_slippage_bps
quote_decay_bps
quote_latency_ms
usable_funds_latency_sec
completion_status
recovery_required
recovery_cost_usd
recovery_latency_sec
all_in_cost_usd
all_in_cost_bps
methodology_version
evidence_class
Once populated with actual measurements, this becomes a much more valuable web resource than another subjective list of “top bridges.”
DN evidence classification
| Label | Meaning in this article |
|---|---|
| Documented / provider-reported | A dated primary source describes a rule, architecture or claim; it is not independently measured here. |
| Observed | Would require an actual DN record with method, timing and provenance. No live route observation is included in this edition. |
| Calculated | Arithmetic derived from specified inputs. An illustrative input remains illustrative after calculation. |
| Modeled / illustrative | A constructed scenario with explicit assumptions, not a provider price, probability or result. |
| Self-reported | An input or evidence reference entered by a reader. The local instruments do not verify it. |
The two JSON exports preserve the input basis and their limits. Neither creates an observed record merely because it includes a calculation or a timestamp.
What a future measured comparison still needs
Live benchmark status: not measured. This edition contains no route leaderboard, P95 estimate, completion rate or measured recovery-cost distribution. Those outputs require executable requests, actual outcomes, a declared sampling design and an adequate sample for the question being asked.
A future table should show missing routes and failed requests rather than silently excluding them. It should expose cohort, size, observation window, raw outcome and uncertainty. A visually complete ranking would add no evidence if its cells were invented.
Which Cross-Chain Route Is Cheapest?
There is no universal winner.
The economically best route can depend on:
- transfer size,
- origin chain,
- destination chain,
- asset pair,
- network congestion,
- available solver inventory,
- DEX liquidity,
- desired settlement speed,
- recovery tolerance,
- whether the user needs the same asset or another asset.
For a $1,000 stablecoin transfer, fixed fees can determine the outcome.
For a $1 million volatile-asset transfer, a few basis points of liquidity deterioration can dwarf almost every fixed fee in the transaction.
The correct answer therefore requires a route-level calculation.
The tools below help specify and model that comparison. They do not fetch the live data needed to choose a current route.
Map the guarantee before pricing the failure
The outcome categories above separate completed, partial, refunded and manually recovered routes. A commitment map adds an engineering question before the economic calculation: which state transitions remain possible after each leg has finalized?
Consider a hypothetical route that swaps an asset on chain A, transfers value to chain B and deposits it into a vault. If the deposit fails after the transfer succeeds, the user may hold an intermediate asset on B. A recovery transaction can make that position usable. It does not erase the finalized swap on A, its fees or the interval of exposure.
LI.FI explicitly documents routes that cannot roll back a completed bridge step after a later failure. Its intermediate-token guidance explains that DONE/PARTIAL can mean receiving the bridged asset rather than the requested final token. These are documented semantics for relevant routes, not a claim that every interoperability protocol behaves identically. [8] [9]
Atomicity needs an exact invariant
“Everything succeeds or nothing happens” is too vague for a multi-ledger review. Specify the participants, transfers, permitted intermediate states and failure assumptions. Is the claim about one destination transaction, exchange safety between parties, eventual delivery or the full business workflow? An atomic call on one chain does not by itself answer the broader question.
Herlihy’s atomic-swap research gives protocol-specific guarantees for asset exchanges under a defined graph and participant model. Research on cross-chain deals separately examines safety and liveness among autonomous, mutually distrusting ledgers. These results are useful because they make assumptions explicit; neither paper establishes a universal maximum of five simultaneously composable chains. [13] [14]
DN’s inference is practical: counting supported chains is an inventory measure, not an atomicity test. A route touching two ledgers can have a poorly specified recovery path; a larger protocol can offer a carefully defined guarantee under restrictive assumptions. The actual architecture and claimed invariant determine what must be examined.
Message delivery is one part of application completion
LayerZero V2 separates verification and execution roles. A message’s verification state therefore needs to be distinguished from the success of the receiving application’s intended action. A review should identify which actor can execute or retry the operation, what resources it needs and what the application does after failure. [16]
IBC’s classic ICS-04 specifies packet acknowledgements and timeout handling, including proofs concerning the receiving chain. An absent response at the user interface is not equivalent to an authenticated timeout condition. Application callbacks and asset behavior still need to be examined for the actual deployed version. This reference concerns classic ICS-04; it is not a claim that all IBC generations share identical semantics. [15]
A recovery plan must account for evidence availability. The required deadline may have passed while the party still lacks the proof, chain access or gas needed to recover. This is why safety, eventual progress and operational recovery burden should remain separate entries rather than one “reliable” label.
Record each commitment and its residual state
| Review boundary | Evidence to record | Decision it supports |
|---|---|---|
| Source action | Contract/version, finality assumption and precise committed state. | What can still be cancelled after inclusion or finality? |
| Transport and proof | Message identity, verification conditions, acknowledgement or timeout evidence. | What establishes delivery, non-delivery or a recovery right? |
| Destination action | Required call, dependencies and failure behavior. | What happens if the intended final action does not execute? |
| Recovery | Responsible actor, permissions, gas, deadlines and resulting assets. | What work and exposure remain after a partial result? |
| Global claim | Invariant, proof/audit scope and matching deployment details. | Does the evidence cover the claim actually being made? |
Use the map to write failure tests before sending funds. A scoped test plan can examine a failed final call, delayed relay, paused application, unavailable proof and repeated recovery request. Retain the exact versions and expected terminal states. This article has not run those tests, and the tool does not execute them.
The DN Cross-Chain Commitment Map
The local record asks for the route, ordered legs, claimed all-or-nothing outcome and architecture. Eight evidence areas cover commitment points, the global guarantee, delivery versus execution, timeout proofs, recovery actors, residual state, replay handling and failure tests.
Its output counts evidence references, gaps and issues. A user choosing “atomicity claim” does not receive an atomicity certificate: the result explicitly says the claim needs deployment-specific proof and assumptions. The ordered-leg field is a human-authored map; this tool is not a protocol interpreter or a formal verifier.
DN Cross-Chain Commitment Map
This is a documentation map, not a formal proof, transaction simulator or authorization to execute. An entered atomicity claim is not validated.
Use non-sensitive aliases and reference labels. Inputs remain in this page’s temporary memory; downloading creates a local JSON file. Nothing is submitted to DN.
No record has been built. Missing evidence will remain visible.
After the state map is understood, use the existing route-cost calculator to model documented fees, delay and recovery effort. The two records answer connected questions. One explains what can happen; the other prices explicitly chosen outcomes and assumptions. A refund should not be assigned the economics of a complete rollback without examining its actual assets, costs and timing.
The calculator preserves the original DN cost arithmetic while exposing its assumptions. Its outputs separate fees and modeled delivered-value losses, expected recovery cash, modeled opportunity cost and total modeled economic cost. The cash/value subtotal includes conversion losses; these are not all separately debited fees. It has no empirically calibrated grade. Load the example only to inspect arithmetic; it is not a deBridge, Across, Stargate, Relay, LI.FI or OKX quote.
DN Cross-Chain Route Cost Calculator
Local scenario model, not a live bridge benchmark. The example uses invented assumptions and names no provider. Blank fields do not mean zero. Enter zero explicitly when a cost is absent, and use the same valuation basis for every amount.
Base costs and base delay apply once. Recovery probability weights only the additional recovery cash and delay. Opportunity cost is reported separately from fees and modeled losses in delivered value. The cash/value subtotal includes conversion and quote-movement losses, not only separately debited fees. This additive model does not deduct fee refunds or simulate repeated attempts or lost principal.
Enter assumptions or load the illustrative example. No result exists until you calculate.
Scenario result
- Route label
- Intended usable outcome
- Input basis
- Direct fees and modeled delivered-value losses
- Expected cash/value cost, including recovery cash
- Modeled opportunity cost — not a cash debit
- Failure-adjusted modeled economic cost
- Modeled economic cost relative to transfer value
- Elapsed-time scenario
- Probability-weighted extra recovery burden
Standard-size sensitivity
Only transfer value changes in these rows. Constant fees, rates, failure probability and delays are assumptions. The rows do not establish available liquidity, route limits or executable quotes. Do not scale a small live quote into a large trade using this table.
| Transfer value | Expected cash/value cost | Modeled opportunity | Modeled economic total | Total bps |
|---|
Cash amounts display to two decimals and bps to six. Individual rounded components may not sum to the rounded total; the exported record retains raw calculations. No score or provider recommendation is produced.
Method, limitations and privacy
- All values are entered assumptions or self-reported inputs. DN has not measured or verified this route.
- The cash/value cost fields include modeled conversion and quote-movement losses as well as fees. They are not all separately debited cash payments.
- Base fees and base latency are counted once in every outcome. Recovery cash and time are incremental, probability-weighted additions.
- Fees, slippage and quote movement must be non-overlapping. Do not add charges already embedded elsewhere in the same quote.
- The model does not represent fee refunds, a full outcome tree, repeated attempts, correlated failures, irreversible principal loss, asset-price changes or protocol security.
- Opportunity cost is a chosen linear rate applied to the full transfer value. It is not a cash debit, yield forecast or measured foregone return.
- The four standard-size rows hold rates, fixed charges, recovery probability and delays constant. They are sensitivity scenarios, not executable quotes or liquidity estimates.
- No wallet, transaction, external API or persistent browser storage is accessed.
Schema: dn.cross-chain-route-cost.v1, version 1.1.0. Documentation reviewed 11 November 2026. Creation time identifies this local record, not a transaction or measurement. Editing any input invalidates the previous result and disables its download. Inputs remain in page memory; reset or reload clears the tool’s record. Downloading deliberately saves the JSON to your device. Do not enter keys, credentials, wallet addresses or personal information.
How to read the calculator
The input fields begin blank. The example button loads the original illustrative numbers: a $10,000 transfer, $2 source gas, $0.50 fixed charge, 4 bps bridge/solver cost, 1 bp on each conversion, one minute of base delay, a 0.5% assumed chance of $5 extra recovery cash and two extra hours, with zero chosen opportunity cost. This yields $8.50 in direct fees and modeled conversion losses plus $0.025 expected recovery cash: $8.525, or 8.525 bps, before display rounding.
Enter zero only when justified. If destination gas is already included in the solver quote, do not add it again. If a route has no origin swap, its additional origin-conversion input can be zero. If a quote already reflects price impact or deterioration, avoid counting that same loss in another field.
Recovery probability is entered, not estimated by the tool. A 100% value models the extra recovery burden in every scenario; zero omits it. Neither setting represents observed reliability. A route with refunds, multiple retry branches or irrecoverable capital needs a richer outcome model. The commitment map can reveal those branches without pretending this additive calculator simulates them.
Cross-Chain Timing, Liquidity and the Risk a Solver Actually Takes
Decision extension · 13 November 2026. Compare the entire path from approved source expenditure to accepted destination value. A fast fill, a large liquidity pool and an intent interface describe different properties. None alone establishes that an agent’s payment will arrive in the right asset, within its deadline and with an acceptable recovery path.
Use an event ledger instead of one latency number
DN proposes recording quote time, source authorization, source submission, the required source finality, destination fill, recipient acceptance and final reimbursement or settlement where relevant. Define the exact event used by a provider’s latency claim. Keep failed, expired and cancelled attempts in the sample rather than reporting only successful routes.
Across documents initiation, destination fill and later settlement as separate phases. Its relayers front destination capital and subsequently receive reimbursement through its settlement architecture. These facts explain why the user can receive funds before the relayer has recovered its own capital; they do not establish a universal guarantee for every route or size. Across lifecycle · Architecture.
For an L2 source, specify which confirmation stage the next participant accepts. Optimism’s documentation distinguishes sequencer inclusion, Ethereum-published data and finality, separately from Standard Bridge withdrawal timing. A display marked “confirmed” therefore needs a protocol-specific meaning before it becomes evidence for a cross-chain release. OP Stack finality.
Measure the period of economic exposure
A moving price during a transfer is not by itself proof of front-running. Separate ordinary market movement, an unhedged position, quote expiry, sequencing effects and a documented adversarial action. Attribution to an AI agent needs evidence of the controller or workflow, not merely fast transactions.
Fictional exposure record: 50,000 units are committed at source and remain unavailable for the intended destination use for 12 minutes. The simple exposure-time measure is 600,000 unit-minutes. It records size multiplied by duration, not expected loss. A 1% adverse move on an unhedged 50,000-unit price exposure would be 500 units under a linear assumption; the twelve-minute interval does not establish that such a move is probable.
The same ledger can show partial fills or staged releases. Break the exposure into intervals with the amount actually at risk rather than multiplying the full amount by every stage and double-counting overlapping time. Funding and hedge costs require their own assumptions; the existing execution-cost tool does not secretly infer them.
Test executable route capacity, not headline TVL
For one proposed payment, request the specific asset contracts, direction, amount, minimum received, validity window and available fill or refund conditions. A network’s aggregate liquidity can sit in another asset, chain or strategy and may not be available to this order. Quote failure alone does not prove a liquidity shortage: permissions, unsupported routes, price limits, an API outage or expired state can also cause it.
DN’s proposed route test uses a predeclared series of sizes within authorized limits. Save each quote and reason for refusal without submitting a funded trade unless separately authorized. A read-only quote test establishes quoted availability, not realized fill quality. Actual fill evidence needs the accepted quote, source and destination receipts, charges and reconciliation.
Illustrative capacity check: if 80,000 units of genuinely available destination inventory were the only relevant capacity and an order required 100,000, the hypothetical gap is 20,000. It is not a finding about a live bridge. Solvers may rebalance or source more inventory, so the recorded conditions and quote validity matter.
Specify what the solver guarantees and what it does not
An intent expresses a desired outcome under defined conditions. Inspect who commits to that outcome, which contract checks fulfillment, what happens on non-fulfillment and who holds the source value in the meantime. Distinguish a solver using its capital from an indemnity promising to reimburse every bridge, contract, issuer or wallet loss.
Across’s fee documentation separates liquidity-provider, relayer and optional integrator fees. That helps explain price formation; it is not evidence that the relayer fee purchases unlimited insurance. Check the actual route and product terms instead of assuming all systems called intents allocate risk identically. Across fee components.
A coherent responsibility record names the loss-bearing party at each stage: before deposit, after deposit but before fill, after destination delivery and during solver reimbursement. Unknown legal recourse stays unknown. A successful destination transfer is evidence of that transfer, not a guarantee that every related contract or counterparty is risk-free.
Compare aggregation against the alternatives
For the same accepted destination amount and deadline, compare a direct route, an aggregator and pre-positioned destination funds. Include setup, all explicit fees, executable spread, slippage, replenishment and the cost of idle inventory under a disclosed assumption. Do not treat a more complex route as necessarily centralized or a unified interface as proof of unified liquidity.
Use the existing execution-cost calculator for the costs it actually models and attach the event ledger and responsibility matrix below. A defensible decision can reject a cheap route because its refund or recipient-acceptance condition is unresolved. No additive cost score should override an unmet mandatory condition.
| Record | Evidence | Failure to preserve |
|---|---|---|
| Same task | Exact source and destination assets, amount and deadline | Unlike routes presented as price competitors |
| Timing | Named milestones, timestamps and finality policy | A fast intermediate event called completed payment |
| Capacity | Dated executable quote or explicitly unexecuted quote test | TVL treated as immediately available route inventory |
| Responsibility | Custody, fulfillment, refund and recourse by stage | A capital advance mistaken for comprehensive insurance |
| Acceptance | Recipient can use the required asset under the agreed conditions | A transaction hash substituted for the business outcome |
Method and limits: documentation review and DN’s original evidence protocol, with hypothetical arithmetic. No live route-capacity sweep, paid transfer, liquidity-shortage incident sample or solver guarantee test was performed. Preserve this limit in any reuse of the examples.
Frequently Asked Questions
What is the cheapest way to bridge crypto between chains?
There is no universally cheapest bridge. The result depends on the source and destination networks, asset, trade size, liquidity, gas, route architecture and timing. Comparing the final usable destination value is more reliable than comparing advertised bridge fees alone.
How much does it cost to bridge $1,000 of crypto?
The answer is highly route-dependent. Fixed gas is disproportionately important at $1,000. A $5 cost alone represents 50 basis points, or 0.5%.
How much does it cost to bridge $100,000?
At $100,000, fixed gas becomes less important. One basis point equals $10, so liquidity, solver fees and slippage increasingly determine total cost.
What about a $1 million cross-chain transfer?
At $1 million, one basis point equals $100. Large transfers should be evaluated for executable capacity, price impact, solver liquidity and route limits rather than extrapolating from small-transfer quotes.
Is bridge fee the same as total cross-chain cost?
No. Total cost can include source gas, bridge or solver fees, DEX price impact, origin and destination slippage, destination gas, application fees, quote deterioration, latency and failure recovery.
What is destination gas?
Some routes require gas on the destination chain for a swap or contract call. Other architectures embed that cost in the route or provide gas automatically. It should only be counted separately when it is genuinely an additional user cost.
What happens if a cross-chain swap fails after bridging?
It depends on the route architecture. Some systems refund automatically. Some return an intermediate asset. Others can require manual recovery or another transaction. This is why the framework records recovery burden separately from headline fees.
Are cross-chain swaps atomic?
Not necessarily. A guarantee must identify the exact invariant, protocol and failure assumptions. A single destination transaction can be atomic while the full multi-chain workflow is not. LI.FI documents relevant routes with a completed bridge leg and a later partial outcome. [8]
Is the fastest bridge always best?
No. The optimal balance between cost and speed depends on what the user is doing with the capital. Stargate, for example, explicitly offers execution modes that trade speed against gas efficiency.
Are bridge aggregators better than individual bridges?
Not inherently. Aggregators can compare multiple routes, but they may also introduce their own application economics. A measured comparison should examine both underlying route economics and the final aggregator-inclusive outcome.
What is the DN Failure-Adjusted All-In Cost?
It is direct modeled fees and delivered-value losses plus a chosen opportunity cost of baseline waiting and probability-weighted incremental recovery cash and delay. It is not a measured fee quote, complete loss model or cash-only total.
Is a refund the same as atomic rollback?
No. A refund or compensating transaction may recover value while earlier finalized effects, costs and exposure remain.
Does supporting five chains prove composability across five chains?
No. A supported-network count does not establish one shared execution guarantee across the workflow. Inspect the exact invariant and deployment assumptions.
Does a passed deadline prove recovery can execute immediately?
No. A protocol can require authenticated state, a particular actor, chain access and resources. A deadline alone is not evidence that all recovery conditions are satisfied.
Do the tools verify a quote or an atomicity claim?
No. The cost tool calculates entered assumptions. The commitment map records self-reported evidence references and gaps. Neither calls a provider, submits a transaction, authenticates a reference or proves atomicity.
A proposed first empirical sample
The strongest first empirical dataset would not attempt to test every imaginable route.
A defensible initial protocol would use controlled requests; this sample has not been performed:
Routes
Arbitrum → Base
Base → Arbitrum
Ethereum → Base
Base → Ethereum
Ethereum → Solana
Solana → Ethereum
Assets
USDC → USDC
then:
ETH → USDC
then:
ETH → SOL
Sizes
$1,000
$10,000
$100,000
$1,000,000 where executable
Platforms
deBridge
Across
Stargate where eligible
Relay
LI.FI / Jumper
OKX DEX Bridge
The same route should be requested from every qualifying provider within the shortest practical synchronized sampling window.
The purpose would be:
a controlled cross-chain execution experiment rather than a list of marketing claims.
Reproducible records before a leaderboard
A future empirical programme could publish raw route observations, size curves, latency distributions, recovery histories and machine-readable records. The necessary order is evidence, then analysis, then a ranking whose scope matches its sample.
This edition already offers two narrower, honest exports: dn.cross-chain-route-cost.v1 (version 1.1.0) for modeled economics and dn.cross-chain-commitment-map.v1 (version 1.0.0) for entered evidence references. Their documentation review date and record creation time have different meanings. Neither export is a live route dataset or an automatically refreshed price feed.
The decision this framework supports
Start by defining the desired destination asset and final action. Use the commitment map to identify what remains committed after each failure, who can recover and which proof or permission is required. Then use current, non-overlapping cost inputs to compare the cash and waiting assumptions for that outcome.
Small transfers can be dominated by fixed charges. Large transfers need their own executable capacity and liquidity evidence. Time-sensitive strategies need a justified value for waiting. None of those decisions can be settled by an advertised bridge fee, an unsupported speed claim or a universal letter grade.
Methodology, limitations and change log
12 November 2026 recovery update: added recovery event states, distinct completion denominators and treatment of pending cases. No new route or refund observations were collected. Both existing instruments and their versioned schemas remain unchanged.
DN-CEQI v1.1 — evidence reviewed 11 November 2026. This revision preserves the original usable-value framework, size arithmetic, cohort design, recovery categories and worked examples. It adds the commitment map and replaces the old initializer-based calculator with local scoped controls, explicit validation, separate cash/opportunity results and schema-versioned JSON. The original numerical defaults remain illustrative.
Provider documentation is evidence of what the provider says, not independent proof of actual costs, uptime, supported route availability or successful execution. Research proofs have a defined model; they do not certify arbitrary deployments. The instruments do not verify sources, estimate live probabilities or authorize transactions.
Corrections: send the exact route, protocol/API version, date and supporting public evidence to press@decentralised.news. Do not send keys, credentials or private customer data. Refresh this review when a cited fee API, refund rule or commitment guarantee materially changes, or when reproducible observations become available.
18+ educational content. Cross-chain transactions involve smart-contract, liquidity, execution, bridge, validator, oracle and blockchain risks. Fees and routes can change rapidly. Verify the destination network, token, address, transaction details and current availability before transferring assets.
Primary sources and review record
Reviewed 11 November 2026. Links support the documented rules and architectures discussed above; they do not supply the calculator’s illustrative defaults.
- deBridge: Fees & Pricing — Flat, protocol, solver-margin and gas components; quotes depend on market conditions.
- deBridge: DLN fee structure — Source-chain native flat fee and documented 4 bps protocol fee; current values should be queried.
- deBridge: Cancelling an order — Unfilled-order cancellation conditions, destination authority and messaging/gas costs.
- Across: Fees in the System — LP/relayer fee economics, utilization, fresh quotes and legacy suggested-fees migration notice.
- Across: Refunds — Unfilled deadline, settlement process and non-instant refunds; typical fill claim is provider-reported.
- Stargate V2: Transfer — Economy/Bus batches transactions; Fast/Taxi prioritizes immediate one-to-one transfer.
- LI.FI: DApp fee structure — Documented default integration fee of 25 bps; alternative commercial arrangements can differ.
- LI.FI: Are cross-chain swaps atomic? — Relevant multi-step routes cannot roll back a completed bridge leg after a later destination failure.
- LI.FI: Intermediate tokens — DONE/PARTIAL can indicate a fallback asset rather than the intended output token.
- Relay: Fee components — Current execution, swap, platform and app fee categories; legacy relayer fee fields are deprecated.
- Relay: How Relay works — Solver-capital fill and settlement flow; API and protocol versions are separate concepts.
- OKX Web3: DEX user guide — Bridge aggregation and routing context; guide updated 19 October 2026.
- Herlihy: Atomic Cross-Chain Swaps — Protocol-specific swap guarantees depend on participant and graph assumptions.
- Herlihy, Liskov and Shrira: Cross-chain Deals and Adversarial Commerce — Safety and liveness for independent, mutually distrusting ledgers.
- Classic IBC ICS-04 channel and packet semantics — Acknowledgements and timeout proofs have protocol-specific semantics; this reference is not IBC v2.
- LayerZero V2 Deep Dive — Verification and execution are distinct roles in the V2 architecture.