How Cross Chain Swaps Work Without Bridging in 2026
A cross chain swap exchanges tokens across networks in one action. How intent-based execution works in 2026, and how it compares to bridging.
A cross chain swap is a single operation that exchanges a token on one blockchain network for a different token on another, without the user manually bridging assets first. In 2026, the cleanest way to ship this is intent-based execution: the user signs the outcome they want, and independent solvers source liquidity and fill the trade, and SODAX settles it across networks. This guide is for builders deciding how to add a cross chain swap to a wallet, a DEX, or an app, and what the integration actually looks like in code.
Key takeaways
- A cross chain swap moves value and changes the asset in one user action. It replaces the old bridge-then-trade sequence.
- Intent-based execution shifts routing complexity off your frontend and onto a Solver. You integrate an outcome rather than a path.
- SODAX exposes cross-network exchange, lending, and settlement through one SDK and API across 21 networks as of 2026.
- The same integration that powers a swap also unlocks a cross chain money market and cross chain collateral, so the surface you build against scales beyond trading.
- SODAX delivers output as a native asset or a sodaVariant, and now reaches native Bitcoin and tokenized stocks (xStocks), not only EVM tokens.
What is a cross chain swap
A cross chain swap is the exchange of an asset on a source blockchain network for a different asset delivered on a destination blockchain network, settled as one logical operation. The user starts with, for example, ETH on Arbitrum and ends with POL on Polygon. They never touch a bridge UI. They never hold a wrapped intermediary. They never sign a second transaction on the far side.
This is distinct from two operations builders often conflate. A token bridge moves the same asset from one network to another, frequently by minting a wrapped representation on the destination. A same-network swap exchanges two assets on a single network through an AMM. A cross chain swap does both jobs at once. It changes the asset and crosses the network boundary in a single Intent.
SODAX treats this as cross-network execution, meaning execution that spans any blockchain network as if the boundaries were not there. The distinction matters for builders because it changes where the complexity lives. With a bridge-and-swap design, your application orchestrates the steps, holds intermediate state, and handles partial failures. With cross-network execution, you submit the desired outcome and the system coordinates the rest.
For broader context on why moving assets between networks has historically been the riskiest part of DeFi, the Ethereum Foundation's bridge documentation is a useful primer. Bridge exploits have caused some of the largest losses in DeFi history, which is precisely why the execution model you choose is an architectural decision, not just a UX one.
How a cross chain swap works with intent-based execution
In an intent-based model, the user expresses a desired result: a minimum amount of output token X on destination network Y, in exchange for input token Z on source network W. That expression is an Intent. The user signs it. They do not specify the route.
A Solver then competes to fulfill the Intent. The Solver is not a passive relayer. It evaluates available liquidity, constructs the execution path, and fills the trade, delivering at least the minimum output the user accepted. If it cannot meet the terms, the Intent is not filled and the user keeps their funds.
This design has three consequences builders care about:
- Routing is externalized. Your frontend does not need to discover pools, compute multi-hop paths, or manage slippage across networks. You request a quote and submit an Intent.
- Settlement is outcome-guaranteed at the protocol level. The minimum output amount is enforced, so the user cannot be filled below the price they signed.
- Asset coverage extends through sodaVariants, the mechanism SODAX uses to represent assets on networks where they do not exist natively, so liquidity is not stranded by where a token was originally issued.
The underlying Intent structure carries the input and output tokens, the minimum acceptable output, the source and destination networks, and an optional deadline. Builders rarely construct this by hand. The SDK assembles it from a quote.
Cross chain swap vs bridge-and-swap
Most teams start with the bridge-and-swap pattern because it composes familiar tools. It works, but the cost shows up in the parts that are hard to see in a demo and expensive in production.
| Dimension | Bridge then swap | Cross chain swap (intent-based) |
|---|---|---|
| User actions | Two or more signatures, often on two networks | One signed Intent |
| Failure surface | App holds intermediate state, must handle stuck bridges | Intent either fills at terms or does not fill |
| Routing logic | Your code discovers paths and pools | Externalized to the Solver |
| Asset on destination | Often a wrapped intermediary | Native or sodaVariant output token |
| Integration footprint | Multiple SDKs and contracts | One cross chain SDK and API |
The headline fee of a bridge is easy to model. The implicit costs, failed transfers, wrapped-asset liquidity gaps, and the engineering time to handle edge cases, are where the bridge-and-swap pattern gets expensive. An intent model collapses that surface into a single fulfillment guarantee.
SODAX vs other cross chain swap options
The conceptual table above contrasts patterns. The table below names alternatives so you can place SODAX against tools you may already be evaluating. Each is strong at what it was built for.
| Option | Core model | Strongest for | Where it is stronger than SODAX |
|---|---|---|---|
| SODAX | Intent-based exchange with a Solver, native or sodaVariant output, EVM and non-EVM including Bitcoin | One integration for swaps plus lending and collateral across both network families | n/a |
| LI.FI | Aggregation API across many bridges and DEXs | Best-route discovery across the widest venue set | Wider raw bridge and DEX coverage for pure transfers |
| Stargate | Unified liquidity pools on LayerZero | Deep stablecoin transfers with instant guaranteed finality | More mature unified stablecoin pools on EVM |
| Squid | Cross-chain swaps routed through Axelar GMP | EVM-to-Cosmos reach via the Axelar network | Stronger native Cosmos ecosystem coverage |
SODAX is differentiated, not alone. If you only need best-route token movement, an aggregator may cover it. If you only need stablecoin transfers, a pool-based protocol may be simpler. SODAX is strongest when one integration needs to serve swaps, lending, and collateral across EVM and non-EVM, including native Bitcoin.
How to build a cross chain swap with the cross chain SDK
The integration starts with a quote. The cross chain SDK reads token addresses and decimals off the Sodax instance configuration, so you do not hardcode them. The quote tells you the expected output, which you use to set the minimum output on the Intent.
Note on code samples
These signatures reflect the SODAX SDK as of June 2026. The SDK evolves rapidly. Always verify against the official documentation at docs.sodax.com before integrating in production.
import { Sodax, ChainKeys } from '@sodax/sdk';
import type { SolverIntentQuoteRequest } from '@sodax/sdk';
const sodax = new Sodax();
const arbEthToken = sodax.config.spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].nativeToken; // ETH on Arbitrum
const polygonPolToken = sodax.config.spokeChainConfig[ChainKeys.POLYGON_MAINNET].nativeToken; // POL on Polygon
const quoteRequest = {
token_src: arbEthToken,
token_dst: polygonPolToken,
token_src_blockchain_id: ChainKeys.ARBITRUM_MAINNET,
token_dst_blockchain_id: ChainKeys.POLYGON_MAINNET,
amount: 100000000000000n, // 0.0001 ETH (18 decimals)
quote_type: 'exact_input',
} satisfies SolverIntentQuoteRequest;
const quoteResult = await sodax.swaps.getQuote(quoteRequest);
if (!quoteResult.ok) {
console.error('Quote failed:', quoteResult.error);
} else {
const { quoted_amount } = quoteResult.value;
console.log('Quoted output amount:', quoted_amount);
// Use quoted_amount to set minOutputAmount on the Intent
}Two things to internalize from this. First, amounts are always in the token's smallest unit, so 0.0001 ETH is expressed scaled by 18 decimals. Second, getQuote automatically deducts any configured partner fee from the amount before forwarding to the Solver, so the returned quoted_amount is the net output the user actually receives. That makes partner monetization a configuration concern rather than a payload concern.
If you are building a React frontend rather than a backend service, the same flow is available as hooks through the dapp kit: useQuote auto-refreshes a live quote, useSwap submits the Intent, and useStatus tracks execution to completion. The choice between the cross chain SDK and the cross chain API is a deployment decision, not a capability one. Both route to the same independent solvers and the same liquidity. This guide stays on the swap model itself. The full SDK build, the quote, Intent, and status lifecycle plus the method reference, lives in the companion Intent SDK developer walkthrough and the SODAX developer docs.
Beyond swaps: cross chain money market and cross chain collateral
The reason to evaluate execution infrastructure rather than a single-purpose bridge is that the same integration surface unlocks more than trading. A cross chain money market lets a user supply an asset on one network and borrow against it on another, because the collateral accounting is unified at the execution layer rather than siloed per network. SODAX exposes 27 money market assets for lending and borrowing across networks.
Cross chain collateral is the primitive underneath that. When collateral is recognized across networks, a user is not forced to move assets to where the lending market lives. They post collateral where it already sits and draw liquidity where they need it. For a builder, this means a wallet or app can offer borrowing without first solving the bridging problem, because the execution layer already did. With native Bitcoin support live since 2026-05-26, that collateral set now includes BTC itself.
This is the practical argument for treating swaps, lending, and settlement as one system. You integrate the cross-network execution layer once. The cross chain swap is the entry point most teams ship first, but the SODAX money market runs on the same foundation, and 25 protocols have already integrated SODAX infrastructure across these surfaces.
Frequently asked questions
What is the difference between a cross chain swap and a bridge?
A bridge moves the same asset from one blockchain network to another, often as a wrapped token. A cross chain swap changes the asset and crosses the network boundary in one operation, so the user ends with a different token on the destination network. SODAX delivers the output as a native asset or a sodaVariant rather than a wrapped intermediary.
How many networks does a SODAX cross chain swap support?
SODAX operates across 21 networks as of 2026 (often searched as cross chain coverage), spanning EVM networks such as Ethereum, Arbitrum, Base, BNB Chain, Optimism, Polygon, Avalanche, and Sonic, alongside non-EVM networks including Solana, Sui, Stellar, Injective, ICON, NEAR, native Bitcoin, and Stacks. Naming the networks your users actually hold assets on is more useful than the count alone.
Do I need a separate cross chain SDK and cross chain API?
No. The cross chain SDK and the cross chain API route to the same independent solvers and liquidity. Use the SDK for application or backend integration, or the dapp kit hooks for a React frontend. The choice is about where your code runs, not what it can do.
How are fees handled on a cross chain swap?
The SDK's getQuote deducts any configured partner fee from the input amount before forwarding to the Solver, so the quoted output already reflects what the user receives. Partner monetization is set in configuration, not added to the request payload.
What happens if a cross chain swap cannot be filled at my price?
The Intent carries a minimum output amount. A Solver fills it only if it can meet at least that amount. If no Solver can satisfy the terms, the Intent does not execute and the user retains their funds, so there is no silent fill below the signed price.
Building with cross-network execution
A cross chain swap is the most direct way to give users a single-action trade across networks, and intent-based execution is what makes it reliable to ship. You integrate an outcome, the Solver handles the path, and the same surface extends to a cross chain money market and cross chain collateral when you are ready. If you want to see the execution model in action before integrating, try the live SODAX exchange, then build against the SDK documented at docs.sodax.com.