SODAX

An intent SDK is a software development kit that lets developers request outcomes, such as "trade this token on one blockchain network for that token on another", and hands execution to a Solver that finds and runs the best route. The developer declares what the user wants. The infrastructure decides how it happens. This guide explains what an intent SDK is, how it works under the hood, how it differs from a cross chain sdk built on bridge aggregation, and how to evaluate the options available to DeFi builders in 2026.

A note on terminology. In mobile development, "Intent SDK" also refers to Android's Intent messaging system for launching app components. That is unrelated to this article. Here, intent SDK means the DeFi tooling category: SDKs that implement intent-based execution across blockchain networks.

Key Takeaways

An intent SDK abstracts execution. Developers declare outcomes, and a Solver fulfills them.
Intent-based execution removes manual route construction, token wrapping, and per-network integration work.
The SODAX SDK exposes intent execution across 21 blockchain networks, including non-EVM networks such as Solana, Sui, Stellar, and native Bitcoin.
ERC-7683 gives the industry a shared standard for expressing intents, which makes the category easier to evaluate in 2026.

What Is an Intent SDK?

An intent SDK is developer tooling for intent-based execution (often searched as cross chain intent tooling). An Intent is a signed declaration of a desired outcome: the input token, the output token, the source and destination blockchain networks, and the minimum acceptable result. A Solver is an independent party that decides and coordinates how that outcome gets executed. The SDK is the layer that lets an application create, submit, track, and cancel those intents without touching the underlying routing logic.

This is a different contract between application and infrastructure than traditional DeFi integrations. A conventional integration asks the developer to pick a route, handle wrapped assets, manage gas on two networks, and monitor delivery. An intent SDK asks the developer for the outcome and a signature. Everything else, including route selection, execution timing, and the fill, is the Solver's job, while SODAX settles the result across networks. SODAX calls this cross-network execution, meaning execution that spans any blockchain network as if there were no boundaries.

The pattern has been standardizing. ERC-7683 defines a shared format for intents so that order flow and Solver networks can interoperate. The pattern also has visible lineage: the ICON project published an early intent-sdk providing abstractions for intent smart contracts and a Solver, and SODAX carries that architecture forward as a production execution system in 2026.

How an Intent SDK Works: Quote, Intent, Fill

The lifecycle of an intent has three phases: quote, intent creation, and fill. First the application requests a quote so the user sees the expected output. Then the SDK creates the intent on the source network and deposits the input tokens. Finally a Solver fills the intent on the destination network and the user receives the output.

Here is what that looks like in practice with the SODAX SDK.

Note on code samples
These signatures reflect the SODAX SDK as of July 2026. The SDK evolves rapidly. Always verify against the official documentation at docs.sodax.com before integrating in production.

Requesting a quote requires the input amount scaled by the token's decimals:

import {
  ChainKeys,
  type SolverIntentQuoteRequest
} from "@sodax/sdk";

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 inputAmount = 100000000000000n; // 0.0001 ETH (18 decimals)

const quoteRequest = {
  token_src: arbEthToken,
  token_dst: polygonPolToken,
  token_src_blockchain_id: ChainKeys.ARBITRUM_MAINNET,
  token_dst_blockchain_id: ChainKeys.POLYGON_MAINNET,
  amount: inputAmount,
  quote_type: 'exact_input',
} satisfies SolverIntentQuoteRequest;

const quoteResult = await sodax.swaps.getQuote(quoteRequest);
if (!quoteResult.ok) {
  console.error('Failed to get quote:', quoteResult.error);
} else {
  const { quoted_amount } = quoteResult.value;
  console.log('Quoted output amount:', quoted_amount);
}

The quoting API supports exact_input, where the user specifies the amount to send, and exact_output, where the user specifies the amount to receive.

Execution is a single call. The SDK's swap() method is the recommended end-to-end path and orchestrates the full lifecycle internally: createIntent() runs the source network transaction, verifyTxHash() confirms it is on the network, relayTxAndWaitPacket() relays it to the Hub, and postExecution() notifies the Solver. The caller then polls getStatus() until the intent is solved. Builders who need custom signing flows can drop down to createIntent() directly, and createLimitOrder() produces an intent with no deadline for resting orders. The full method list is in the Swaps module documentation.

For frontend teams, the @sodax/dapp-kit package wraps the same lifecycle in React hooks such as useQuote(), which refreshes quotes automatically, useSwap(), and useStatus() for tracking execution.

Intent SDK vs Cross Chain SDK: What Is the Difference?

Most defi sdk tooling for moving value between blockchain networks falls into two categories, and the difference determines how much execution risk your application carries.

A traditional cross chain sdk is an aggregation layer. It queries multiple bridging and exchange venues, assembles a multi-step route, and returns it to your application for execution. The application, and by extension the user, owns that route: if a step fails midway, the funds sit in an intermediate state that your support team gets to untangle.

An intent SDK inverts the responsibility. The user's tokens are escrowed against a signed intent with a minimum output and a deadline. A Solver executes the route with its own capital and only gets paid when the outcome is delivered. If no Solver fills the intent by the deadline, the escrow unwinds. Execution risk moves from the application to the infrastructure.

The practical consequences for builders:

Failure handling is contractual, not operational. An unfilled intent expires and returns funds.
The integration surface is one SDK, not one integration per network or per venue.
Pricing is outcome-based. The quote reflects the net amount the user receives.

Choosing a LI.FI SDK Alternative: Intent SDKs and Aggregators Compared

Builders evaluating a lifi sdk alternative in 2026 are usually comparing three architectures: intent-based execution systems, bridge and exchange aggregators, and single-protocol transfer APIs. The honest comparison:

	SODAX SDK	LI.FI SDK	Across	deBridge DLN
Execution model	Intent-based, Solver-executed	Bridge and DEX aggregation	Intent-based (ERC-7683)	Intent-style fast transfers
Network coverage	21 networks: 12 EVM plus Solana, Sui, Stellar, ICON, Injective, NEAR, native Bitcoin, Stacks, Hedera	Broad EVM coverage plus Solana	EVM networks	EVM networks plus Solana
Built-in money market	Yes, lending and borrowing on 27 assets via the same SDK	No, exchange and transfer focused	No	No
Native Bitcoin support	Yes, shipped May 2026	Via wrapped representations	No	No
Monetization	Configurable partner fee deducted in-quote	Integrator fee options	Limited	Referral-based options
Where it is stronger	Non-EVM breadth, lending, tokenized stocks	Route aggregation depth and a large, mature integrator ecosystem	Fill speed on EVM routes and standards leadership as an ERC-7683 author	Latency on its supported routes

Each column reflects a real tradeoff. LI.FI remains the strongest pure aggregator if your product only needs EVM coverage and you want maximum route optionality. Across is a strong choice for speed-sensitive EVM transfers and helped author the ERC-7683 standard. The SODAX SDK is differentiated where coverage and product surface matter: it is the option among these that combines non-EVM networks, native Bitcoin without wrapping, a money market, and tokenized stocks (xStocks, live since June 2026) behind one intent SDK. As of July 2026, 25 protocols and applications have integrated SODAX infrastructure.

Why Intent Based DeFi Changes the Integration Model

Intent based defi changes what an integration is worth to the team that ships it.

First, one integration compounds. Because the Solver abstracts every underlying network, a wallet or application that integrates an intent SDK once inherits each new network the infrastructure adds, with no additional engineering. When SODAX added native Bitcoin in May 2026 and xStocks in June 2026, existing integrators got both without a code change to their routing logic.

Second, monetization is built into the execution path. The SODAX SDK lets integrators configure a partner fee that getQuote() deducts automatically before quoting, so the displayed amount is what the user receives and the fee accrues to the integrator on every filled intent. The monetization guide covers the configuration.

Third, the same intent architecture extends past trading. The SODAX SDK exposes lending and borrowing against cross-network collateral through the same interface, so a builder can offer supply, borrow, and trade flows across 21 blockchain networks from a single dependency rather than composing a separate defi sdk for each vertical.

Frequently Asked Questions

What is an intent SDK in DeFi?

An intent SDK is a software development kit that lets applications submit signed declarations of desired outcomes, called Intents, which a Solver network executes across blockchain networks. The developer specifies input, output, and minimum result. The Solver handles routing, capital, and settlement. Examples in 2026 include the SODAX SDK and Across, both intent-based, in contrast to aggregation SDKs such as LI.FI.

Is an intent SDK the same as a bridge aggregator SDK?

No. A bridge aggregator SDK returns a route that your application executes and owns, including mid-route failure states. An intent SDK escrows funds against a signed outcome and pays a Solver only on delivery, so unfilled intents expire and return funds automatically. The two models differ in who carries execution risk, not just in API shape.

What is ERC-7683 and does it matter for intent SDKs?

ERC-7683 is an Ethereum standard that defines a common format for expressing intents so that order flow and Solver networks can interoperate. It matters because it turns intent-based execution from a set of proprietary designs into an evaluable category. When comparing intent SDKs in 2026, standard alignment is a reasonable proxy for long-term interoperability.

Does the SODAX SDK support non-EVM networks?

Yes. As of July 2026, the SODAX SDK operates across 21 networks: Sonic, Ethereum, Arbitrum, Base, BNB Chain, Optimism, Polygon, Avalanche, Hyperliquid, LightLink, Redbelly, and Kaia on the EVM side, plus Solana, Sui, Stellar, ICON, Injective, NEAR, native Bitcoin, Stacks, and Hedera. Non-EVM coverage, including Bitcoin without wrapped representations, is one of the main reasons builders pick it over EVM-only alternatives.

How do developers monetize an intent SDK integration?

The SODAX SDK supports a configurable partner fee. The fee is deducted inside getQuote() before the quote is returned, so the user sees their net output and the integrator earns on every filled intent. This makes revenue proportional to executed volume rather than to page views or referral clicks.

Getting Started with an Intent SDK

The fastest way to evaluate an intent SDK is to run one quote. The SODAX SDK quote flow shown above works against live infrastructure, and the developer documentation walks through intent creation and status polling end to end. For a scoped integration plan, the SODAX SDK partner page outlines what the SDK exposes, and the partners page generates a tailored integration guide for your product type. Declare the outcome. Let the Solver do the rest.