> 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/11-ship-to-rubicon.md).

# 11. Ship to Rubicon

Take your dual-lane app from Hadrian to the Rubicon mainnet, with the launch checklist, the limits to design around and how to report a problem.

Everything so far ran on Hadrian, where the USDC is test money. Rubicon is the mainnet. The contract and the app are the same. The network values change, the money is real, and a few tools do not know Rubicon yet. This lesson takes you through the move.

## What you'll learn

* What changes between Hadrian and Rubicon, and what does not.
* Where to read Rubicon's network values, and which tools cannot target it yet.
* The launch checklist for an app with both lanes.
* The execution limits to design around before real users arrive.
* How to report a security problem.

## Before you start

* Finish [10. Bring users and funds from other chains](https://docs.rome.builders/rome-academy/10-from-other-chains.md). Your dual-lane app should pass its full round trip on Hadrian.
* Have a deployer wallet with real USDC on Rubicon. Bring it in with the mainnet bridge from lesson 10. There is no faucet.
* Have a Solana mainnet RPC from a provider you have an account with. The SDK sends the signed Solana transaction to the RPC you give it.
* Have a Solana mainnet wallet that signs v1 transactions, with a little SOL for fees and a small amount of USDC, for the Solana-lane round trip.

## The lesson

### Step 1. Know what changes

The EVM is the same, so the same compiled artifacts deploy. Three things change:

* The chain ID, RPC, Rome program ID, Solana USDC mint and wrapper addresses. Take them from [Rubicon](https://docs.rome.builders/networks/rubicon.md) and [Contract Addresses](https://docs.rome.builders/reference/contract-addresses.md), which stay current.
* The gas price. It is real USDC and it is higher than on Hadrian. It varies, so read `eth_gasPrice` instead of assuming a number.
* The Solana side. Your Solana-lane app now talks to Solana mainnet, not devnet.

Rubicon is in the public registry from v0.3.0, so your app can read its chain values and wrapper addresses there, as it does for Hadrian. The Rome CLI (v0.12.0) and `create-rome-app` still pin registry v0.2.0, which has no Rubicon entry, so they cannot target it. That includes `rome verify`. For the Solana `connection`, use your own mainnet RPC, not the public one the registry lists. The SDK's `deps` map is in [Open your Solidity contract to Solana users](https://docs.rome.builders/pages/QQmOT5sDIQcUnRUM4fU6#id-3.-let-a-solana-wallet-call-it).

### Step 2. Check the design against the limits

These limits are the ones that most often change a design. They are listed once here and in full on [Known Limitations](https://docs.rome.builders/security/known-limitations.md).

* `SELFDESTRUCT` is not supported, and any opcode Rome does not implement aborts the whole transaction.
* The gas value passed to `CALL` is not enforced and there is no 2300-gas stipend. Stipend-based reentrancy protection does not work. Use reentrancy guards and checks-effects-interactions.
* One atomic transaction has about 1.4M compute units, 64 accounts and 4 KB. Legacy-track CPIs cannot run in an iterative transaction.
* CPI depth is 4.
* `debug_traceTransaction` is not available. Debug with `eth_call` and the explorer.
* Each chain has a single operator. Iterative execution locks the accounts it touches for a few seconds, so a heavily shared account becomes a bottleneck.

Run the vault through this list. If your own contract makes Solana calls, lesson 5 and [Constraints](https://docs.rome.builders/core-concepts/constraints.md) are the check.

### Step 3. Walk the launch checklist

The checklist in the guide has seven items. They are in the order you do them:

1. Deployed on Hadrian, and the EVM path works from MetaMask.
2. Every value-moving entry point is ERC-20 based and uses the canonical wrapper.
3. A Solana wallet completes the full round trip on Hadrian, through the SDK lane, or through the relay when a call is iterative.
4. Each Solana-lane call sits under the atomic budget, or is routed through the relay.
5. The wrapper grant is in the first-deposit flow of both lanes.
6. Source verified on the explorer.
7. Redeployed on Rubicon with the mainnet wrappers, and one real round trip run.

The checklist with its notes is at the end of [Open your Solidity contract to Solana users](https://docs.rome.builders/pages/QQmOT5sDIQcUnRUM4fU6#id-5.-launch-checklist). Lessons 3 to 9 covered items 1 to 6. Item 7 is this lesson.

### Step 4. Deploy and verify on Rubicon

Deploy with the same tools as lesson 3, with the Rubicon network values. Estimate every write with `eth_estimateGas` and never hardcode 21,000, because most of a write's cost is creating Solana accounts. Fund the deployer with a few USDC before the first deploy. Then verify the source with the mainnet verifier, whose endpoint is on the Rubicon page. Process: [Verify Contracts](https://docs.rome.builders/developer-guides/verify-contracts.md).

### Step 5. Prove both lanes with real money

Run one round trip from each lane with a small amount.

* EVM lane: wrap, grant, approve, deposit, withdraw.
* Solana lane: provision, fund leg, grant, approve, deposit, withdraw, sweep leg.

Use a Solana wallet you have checked signs v1 transactions on mainnet. The guides document wallet support for Hadrian only, so this run is also your test. Read `computeUnitsConsumed` for every Solana-lane step and compare it to your Hadrian numbers.

### Step 6. Publish funding instructions and support contacts

Point users at the mainnet bridge from lesson 10 so they can fund themselves. Watch your contract on the Rubicon explorer.

If you find a security vulnerability in Rome, report it privately. Email the address on [Responsible Disclosure](https://docs.rome.builders/security/responsible-disclosure.md) or open a ticket in the Rome Discord. Do not disclose it publicly before a fix is deployed, and do not exploit it beyond what shows the problem. For general questions, use the channels on [Community](https://docs.rome.builders/resources/community.md).

## Check yourself

Your outcome: a verified contract on Rubicon and two transactions to show for it.

1. Your contract's source shows as verified on the Rubicon explorer.
2. One deposit from a MetaMask address and one from a Solana wallet appear on the explorer, and each vault balance matches its deposit. After you withdraw both, the balances are zero and the tokens are back with their owners.
3. For the Solana-lane deposit, you have the compute units from its Solana receipt.

Then answer:

* Why can `rome verify` not run against Rubicon today?
* Why does a contract that relies on `transfer()` for reentrancy safety need a change?

<details>

<summary>Answers</summary>

* The Rome CLI (v0.12.0) reads its chain values from registry v0.2.0, which has no Rubicon entry. Rubicon arrived in registry v0.3.0.
* Rome does not enforce the gas value passed to a call and has no 2300-gas stipend, so that protection does not apply. Add a reentrancy guard and update state before external calls.

</details>

## Next

Link your Rubicon contract to your app in [Arena](https://arena.mainnet.romeprotocol.xyz). The app moves to Live.

[12. Launch your own chain](https://docs.rome.builders/rome-academy/12-launch-your-own-chain.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/11-ship-to-rubicon.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.
