> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sodax.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> SODAX is mainnet-only (no testnet chains or RPC endpoints exist) with a hub-and-spoke architecture; Sonic is the hub. SODAX is non-custodial protocol/software: it routes and settles; independent solvers on the marketplace fill — never say 'our solver', 'the SODAX solver', that SODAX trades, takes custody, or fills orders. For frontend/React integrations, prefer @sodax/dapp-kit hooks over calling @sodax/sdk directly. SDK operations — the methods that build, submit or await a transaction, and the API/quote calls — return Result<T, E> ({ ok: true, value } or { ok: false, error }): check result.ok, never wrap them in try/catch or branch on error.message; discriminate on the narrow error.code union instead. Synchronous config getters (getPartnerFee, getSupportedSwapTokens, getVault, ...) return their value directly, not a Result.

# Swaps on Robinhood Chain

> Intent-based cross-network swaps from a Robinhood Chain perspective: one signed EVM transaction, solver-filled, settled across networks.

SODAX swaps are intents, not bridges. Your user signs one transaction on Robinhood Chain that locks the input and declares what they want on the destination network. Solvers fill it; the SODAX relayer carries proof between Robinhood Chain, the hub (Sonic), and the destination. If nothing fills, the intent can be cancelled and funds recovered.

From your side it is one SDK call. From your user's side it is one wallet prompt, plus an approval the first time they swap an ERC-20 token.

## What this looks like on Robinhood Chain

* **Source**: the intent transaction is an EVM transaction on Robinhood Chain (chain ID 4663). `ChainKeys.ROBINHOOD_MAINNET` (`'robinhood'`) identifies the network everywhere in the SDK.
* **Reach**: any solver-compatible asset on any SODAX network is a valid destination, <span data-sodax-config="count" data-metric="swap-tokens">166</span> assets today. The [on-Robinhood Chain asset list](/robinhood-chain/networks-and-assets) only bounds what users hold on Robinhood Chain itself, not what they can swap into.
* **Tokens**: ETH is the native gas token and uses the zero address in the SDK config. Every other asset, Stock Tokens included, is an ERC-20 token. Read addresses and decimals from the SDK config; never hard-code them.
* **Settlement**: output lands on the destination network at `dstAddress`. Swaps into Robinhood Chain settle as ordinary token balances at the recipient's address.

<h2 id="approvals">
  Approvals
</h2>

`swap()` does not approve the input token for you. ETH is the native token and needs no approval. Every ERC-20 token does: the allowance is checked against SODAX's asset manager on Robinhood Chain, so check it first and approve when it falls short.

```typescript theme={null}
const allowance = await sodax.swaps.isAllowanceValid({ params, walletProvider });
if (!allowance.ok) throw allowance.error;

if (!allowance.value) {
  const approval = await sodax.swaps.approve({ params, walletProvider });
  if (!approval.ok) throw approval.error;
  // wait for the approval to be mined before calling swap()
}
```

`params` is the same intent params object you pass to `swap()`.

## Quoting

The solver API quotes both directions:

```typescript theme={null}
const quoteResult = await sodax.swaps.getQuote({
  token_src: usdg.address,            // token on Robinhood Chain
  token_dst: usdc.address,            // token on the destination network
  token_src_blockchain_id: ChainKeys.ROBINHOOD_MAINNET,
  token_dst_blockchain_id: ChainKeys.ARBITRUM_MAINNET,
  amount: 100n * 10n ** BigInt(usdg.decimals), // 100 USDG
  quote_type: 'exact_input',          // the only supported quote type
});
```

`getQuote` deducts any configured partner fee before quoting, so `quoted_amount` is the net output the user actually receives.

<h2 id="stock-tokens">
  Stock Tokens
</h2>

The live config lists Robinhood Stock Tokens on Robinhood Chain for swaps, and marks each with `isRwa: true`. They are swap-only: none of them is in the money market list.

* **SDK support**: `@sodax/sdk` 2.1.0 does not include them. Its config does not list them, so `getQuote` and `swap` reject a Stock Token address on 2.1.0. They are on `main` for the next release; until then, quote and swap the base assets on Robinhood Chain.
* **Token standard**: Stock Tokens are standard ERC-20s with 18 decimals, issued by Robinhood Assets (Jersey) Limited, so they follow the same approval flow as any ERC-20.
* **Amounts are raw token amounts**: Robinhood applies dividends and splits through an on-chain multiplier (`uiMultiplier()`, ERC-8056) that changes how many shares one token represents without changing balances. SODAX amounts are token amounts; apply the multiplier only when you display share counts.
* **Offer restrictions**: Robinhood's [Stock Tokens documentation](https://docs.robinhood.com/chain/stock-tokens) states that Stock Tokens may not be offered, sold, or delivered in the United States or to U.S. persons, and that offers and sales are restricted in other jurisdictions. Check those terms before you surface Stock Tokens in your product.

The Sonic vaults behind each Stock Token are listed under [Robinhood Tokenized Equities](/developers/deployments/mainnet#robinhood-tokenized-equities).

## Fees

Using SODAX is free to integrate. Two fees can apply to a trade:

* **Base fee**: a fixed 0.1% of the input, taken by the protocol. Not configurable; compute it ahead of time with `getSolverFee(inputAmount)`.
* **Your fee**: optional platform fee on top, set by you and paid to you. It is the only fee you control. Configure it at SDK setup and check it with `getPartnerFee(inputAmount)`. See [Monetize SDK](/developers/how-to/monetize_sdk).

The user also pays Robinhood Chain's network fee for the intent transaction, in ETH. It includes an L1 data fee for posting the transaction to Ethereum, which standard gas estimation already accounts for.

## Executing

Prefer `swap()`. It creates the intent on Robinhood Chain, verifies it landed, submits it to the relay, waits for the packet on the hub, and notifies the solver. The [Quickstart](/robinhood-chain/quickstart#4-quote-and-swap) has the complete call. Track progress with `getStatus(request)`, and cancel unfilled intents with `cancelIntent`. Limit orders (intents without deadlines) work from Robinhood Chain too, via `createLimitOrder`.

Orchestrating manually with `createIntent` and `submitIntent` works the same as on any EVM network: Robinhood Chain intents need no relay extra data.

## Error handling

Operations return `Result<T>` instead of throwing. The core methods (`swap`, `createIntent`, `postExecution`) return a typed `SodaxError` union you can `switch` on by `error.code`.

***

Full reference, including raw mode, limit orders, cancellation, and the complete error-code table: [Swaps](/developers/packages/foundation/sdk/functional-modules/swaps).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.