> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/rome-academy/10-from-other-chains.md).

# 10. Bring users and funds from other chains

Bring users and their funds to your Rome app from other chains and from Solana, with the bridge, its API and the CLI, and keep your app's screen live.

Your app works for both wallet types. Now people need a way to arrive. Most of them hold USDC on another chain or on Solana, and they should not have to learn Rome first. This lesson uses the Rome Bridge API to bring USDC in from a supported chain, track the transfer, and let users take funds back out, while your app stays current. [2. What you can build](https://docs.rome.builders/rome-academy/02-what-you-can-build.md) shows where this fits.

## What you'll learn

* How a user on another chain reaches your Rome app without leaving home.
* How a user's USDC reaches Rome from an EVM chain and from Solana.
* Why a transfer lands as gas or as wUSDC, and how to choose.
* The four steps of an inbound transfer.
* Why leaving Rome has more steps than arriving.
* How to show live state in your app and check a transfer in the explorer.

## Before you start

* Finish [9. Build a dual-lane app](https://docs.rome.builders/rome-academy/09-build-a-dual-lane-app.md). You need the vault, or any app you want users to reach.
* Have the Rome CLI installed ([Rome CLI + MCP](https://docs.rome.builders/products/rome-cli.md)).
* Have test USDC on a source chain and the source chain's native token for its fee, from [Faucets](https://docs.rome.builders/resources/faucets.md).

## The lesson

### Step 1. Understand the two ways in

With the Rome Bridge, your users come from one of two places. An EVM chain sends USDC over Circle's CCTP. A Solana wallet sends SOL or USDC over plain SPL transfers. Either way, the bridge is on-chain and settles under the user's own signature. The off-chain Bridge API quotes the route, checks the source transaction and sponsors the settle fee. It holds no funds and no keys, so it can only trigger what the user already signed.

The supported chains and assets differ between the testnet and the mainnet, so read the lists instead of assuming. They are on [Rome Bridge](https://docs.rome.builders/apps-on-rome/bridge-api.md), and the live list is the API's `/v1/routes`. The pattern of reaching your app from a user's home chain is in [From home](https://docs.rome.builders/developer-guides/from-home.md).

### Step 2. Decide gas or wUSDC

USDC that arrives through the bridge lands as gas by default. Gas is what a MetaMask user pays fees with. The token your vault takes is wUSDC. Those are two forms of the same USDC, and the user can convert one into the other.

Set the intent in the quote. An app that takes wUSDC, like your vault, wants users to arrive as wUSDC. A user who arrives as gas wraps some of it first, as in lesson 9. A user who plans to leave again needs wUSDC, because bridging out burns wUSDC, not gas. They can arrive as wUSDC or wrap some gas later with `withdraw_to_ata`.

### Step 3. Run an inbound transfer

An inbound transfer takes four steps. The SDK's `/bridge` subpath wraps the API calls as `requestQuote`, `registerTransfer`, `getTransfer` and `reportStep`. Its `registerTransfer` (v0.4.0) still posts the whole quote, which the live API refuses, so register with the `quoteId` yourself, as the Rome CLI does.

1. Quote the route. Send the source chain, asset, amount, sender and recipient. Chains go in as CAIP-2 ids, and amounts are base-unit integers in strings.
2. The user signs the transactions of the first step, in order, exactly as returned. For a CCTP transfer that is the USDC approval and the burn. On the gas route the user also signs one EIP-712 settle authorization, after you fill in the burn hash.
3. Register the transfer. Send the quote's `quoteId` and the burn hash as `step1TxHash` to `POST /v1/transfers` within 15 minutes of the quote. On the gas route, add the settle signature as `userSettleSig`. The API checks that the transaction matches the stored quote and returns a transfer id.
4. Poll the transfer until `outcome` is `complete`, and handle `failed` and `expired`. A complete transfer can carry a `degradation` note, so check it before you tell the user the gas or wUSDC arrived.

Solana arrivals follow the same shape with different steps. The user sends an SPL transfer to their Rome account. With the gas intent, USDC on a chain whose gas token is USDC needs one more transaction from the user to turn the wrapper into gas. The quote lists every signature a route needs. Request and response shapes: [From home](https://docs.rome.builders/developer-guides/from-home.md#bring-assets-in).

### Step 4. Run it from the CLI first

Before you write any bridge code, run the flow with the CLI. `rome fund` brings USDC in as gas, `rome bridge` takes an intent of gas or wrapper, and `rome verify --path from-home` proves a full round trip: bridge in, act on Rome, bridge out. This gives you a working reference to compare your integration against. Commands and flags: [Rome CLI + MCP](https://docs.rome.builders/products/rome-cli.md).

### Step 5. Handle the way out

Bridging out is not the inbound flow in reverse. For USDC over CCTP, the user signs two steps. Step 1 is two Rome transactions: a grant that lets the bridge contract move the exact amount of this burn, then the burn. Register the transfer with the burn hash. Step 2 is the claim. When the transfer's step 2 reads `ready`, it carries the message and attestation, and the user calls `receiveMessage` with them on the destination chain. Nothing in the claim is sponsored, so the user needs gas there. Report the claim hash to the API (`reportStep` in the SDK). Calls and shapes: [Take assets back out](https://docs.rome.builders/developer-guides/from-home.md#take-assets-back-out).

Withdrawing to a Solana address has no claim step. For USDC it is one Rome transaction that withdraws to the user's Solana account.

The grant matters to your app. A token account has one delegate, so the bridge grant replaces the wrapper's grant until the user grants the wrapper again. Check `isEnabled` before the next deposit, as lesson 9 taught.

### Step 6. Keep your app live

Rome endpoints support `eth_subscribe` for `newHeads` and `logs`, on the same host as the HTTPS RPC. With ethers, `provider.on("block")` and `contract.on(event)` work as they do anywhere. With viem, the `webSocket` transport drops Rome's numeric subscription ids, so pass `poll: true` to `watchBlocks` and `watchEvent`, or use ethers for push updates. `newPendingTransactions` never emits, because Rome has no public mempool. Code: [WebSocket Subscriptions](https://docs.rome.builders/developer-guides/websocket-subscriptions.md).

When you read history, bound every `eth_getLogs` call by block range. Rome's RPC rejects a range wider than about 12,000 blocks. For a transaction that touches Solana, Via's "Settled in" row links the Solana transaction that settled it, and the Solana explorer shows its instructions and compute units. That is how you answer a user who asks where their transfer is. See [Via](https://docs.rome.builders/apps-on-rome/via.md) and [JSON-RPC Support](https://docs.rome.builders/reference/json-rpc.md).

## Solgate: Solana assets and AggLayer EVM chains

[Solgate](https://docs.rome.builders/apps-on-rome/solgate.md) connects Solana assets to AggLayer EVM chains in both directions, on mainnet and testnet. USDC uses CCTP. The steps above use the Rome Bridge API.

To move other tokens or send messages, read [13. Build on Solgate](https://docs.rome.builders/rome-academy/13-build-on-solgate.md).

## Check yourself

Bring one real transfer through and observe it.

1. Fund a fresh Hadrian wallet with some gas USDC, then bring more USDC in with `rome bridge` and the wrapper intent. Keep enough gas for approvals, vault calls and the outbound burn.
2. Read the wallet's wUSDC balance on Hadrian, for example with `rome call` on the wrapper's `balanceOf`. With the wrapper intent, the arrival is the bridge's Solana transaction (Circle's receive message), not a Rome transaction, so do not expect an arrival transaction in the Hadrian explorer.
3. Repeat the transfer through the API: quote, sign, register, then poll `GET /v1/transfers/{id}` until `outcome` reads `complete`.
4. Run `rome verify hadrian --path from-home` with `--from` (your source chain) and `--amount` (a small amount, such as 0.2), then read the result. It takes about 20 minutes.

Then answer:

* Which balance does an outbound USDC burn spend, and how can a user get it?
* Who pays for the claim on the destination chain?

<details>

<summary>Answers</summary>

* wUSDC. USDC that arrived as gas is a different balance. A user gets wUSDC through the wrapper intent, or by wrapping some gas with `withdraw_to_ata`.
* The user. The claim is a transaction on the destination chain, so the user needs gas there.

</details>

## Next

[11. Ship to Rubicon](https://docs.rome.builders/rome-academy/11-ship-to-rubicon.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.rome.builders/rome-academy/10-from-other-chains.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
