> 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/core-concepts/how-solana-and-evm-meet.md).

# How Solana and the EVM meet on Rome

How Solana wallets call Solidity contracts, EVM addresses call Solana programs, and Rome handles identity, tokens, fees, and execution limits.

This page explains how calls cross between Solana and the EVM on Rome. It covers who signs, where tokens live, who pays, and which Solana rules affect Solidity contracts.

Unless stated otherwise, the numbers and transactions on this page are from Hadrian (testnet) as of 19 October 2026.

## What is a synthetic address?

A synthetic address is the EVM identity of a Solana public key. Rome computes it as the last 20 bytes of `keccak256` of the public key: `keccak256(pubkey)[12..32]`. The mapping is fixed. It is called synthetic because no one holds a secp256k1 key for it: MetaMask cannot sign for it, and only the Solana key can authorize calls from it.

At the top-level contract call, both `msg.sender` and `tx.origin` are the synthetic address. Rome stores the EVM nonce under that address. The contract cannot distinguish this identity from a MetaMask user through those fields.

## How does a Solana user call a Solidity contract?

The wallet authorizes an unsigned EIP-1559 call through one of two lanes. The v1 lane is the current path. The legacy lane is the older path: the wallet signs and pays for the Solana transaction carrying `DoTxUnsigned`, and the Rome EVM program derives the synthetic address from that Solana signer.

In the v1 lane, the wallet signs a readable message containing `Rome authorization`, a newline, and the call hash as `0x` followed by 64 lowercase hexadecimal characters. The transaction carries this signature in an Ed25519 verification instruction at index 0. The Rome EVM program derives the synthetic address from the key that authorized the call.

The Rome Proxy composes the v1 transaction. The wallet then signs it and sends it to Solana. On the relay route, the Rome Proxy submits the transaction and pays SOL, and the synthetic address pays gas from its native balance in the chain's gas token (USDC on Hadrian and Rubicon).

When the wallet pays directly, the v1 lane costs 15,000 lamports: a 5,000-lamport signature fee, 5,000 lamports for the Ed25519 verification signature, and a 5,000-lamport treasury toll. The older legacy `DoTxUnsigned` lane has no Ed25519 instruction and costs 10,000 lamports. Both routes also pay rent for any accounts created. Neither direct route charges EVM gas. A legacy-lane transaction on Hadrian cost the wallet 10,000 lamports and reported `gasUsed = 0` and `effectiveGasPrice = 0`.

The SDK's `submitRomeTxV1` follows these steps:

1. Read the synthetic address's nonce with `eth_getTransactionCount`, estimate gas, and build the unsigned call.
2. Ask the wallet to sign the readable `Rome authorization` message.
3. Request a transaction from `rome_composeUnsignedAtomicV1`.
4. Verify the returned payer, call bytes, Ed25519 authorization, permitted programs, and absence of a priority fee.
5. Ask the wallet to sign the v1 transaction, send it to Solana, and poll the Rome Proxy for the EVM receipt.
6. If the call requires iterative execution, relay it through `rome_relayUnsignedV1` using the same authorization signature.

Use `fundSyntheticGas` to fund the native balance needed for a relay or `msg.value`. It deposits the gas token from the wallet's token account and credits the synthetic address's native balance. Native balances use 18 decimals.

To use tokens in a contract, the SDK funds the synthetic address, calls the contract, and returns any remaining tokens. `buildFundLeg` uses `ActivateAta` to move tokens from the wallet into the synthetic address's token account. The Solidity call uses those tokens through a wrapper. `buildSweepLeg` uses `transfer_spl` to send the remaining tokens back to the wallet.

The wallet must support signing Solana v1 transactions. Solflare supports this on Solana devnet; Phantom does not yet. Every call checks and increments the EVM nonce under the synthetic address to prevent replay.

See [Call EVM from Solana](https://docs.rome.builders/developer-guides/call-evm-from-solana.md), [Build a dual-lane app](https://docs.rome.builders/developer-guides/dual-lane-app.md), and [Rome SDK](https://docs.rome.builders/products/rome-sdk.md).

## How does an EVM user, or a contract, call a Solana program?

Every EVM address has a Solana program-derived address that owns its token accounts and can sign calls to Solana programs. This is its external-authority PDA. The Rome EVM program derives it from the seed `EXTERNAL_AUTHORITY` followed by the EVM address. The seeds contain no chain ID, so chains hosted by the same Rome EVM program share this authority.

A user or contract calls the CPI precompile at `0xFF…08` with the target program ID, account list, and instruction bytes. CPI means cross-program invocation. The precompile invokes the Solana program within the same Solana transaction.

`invoke` signs for the caller's external-authority PDA when the account list marks it as a signer. `invoke_signed` also supports PDAs derived with salts. Each salted PDA must appear in the account list as a signer.

The methods `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, and `pdas_batch_derive` are read-only helpers. They do not invoke a Solana program.

The precompile refuses calls targeting the Rome EVM program itself. It also refuses an account list containing the Rome EVM program ID. A CPI may not name the Solana fee payer, except inside a plain System `Transfer` instruction.

A RomeDexRouter 2.0.0 swap on Hadrian followed these steps:

1. The router called `HelperProgram.create_ata` to ensure the user's output token account existed.
2. It derived the user's input and output token accounts and marked its own external-authority PDA as the signer.
3. It called `CPI.invoke` with the Solana swap program, the account list, and the swap instruction bytes.
4. SPL Token moved tokens from the user's account into the pool and returned output tokens to the user's other account. The router's PDA signed as the user's SPL delegate. The router held no tokens.
5. The router checked the received amount with `CPI.account_u64_at(dstAta, 64)`.
6. The receipt reported 10,001 gas: `5,000 + 5,000 + 1 = 10,001` lamports of Solana cost. Those costs were the signature fee, treasury toll, and priority fee. The Rome Proxy paid SOL, and the user paid gas in USDC.

See [Call Solana from EVM](https://docs.rome.builders/developer-guides/call-solana-from-evm.md), [Integrate a Solana program](https://docs.rome.builders/developer-guides/integrate-solana-program.md), and the [Precompile reference](https://docs.rome.builders/reference/precompiles.md).

## Who signs when a contract calls a Solana program?

Rome signs with the external-authority PDA of the immediate caller of the precompile. A contract therefore signs as itself. Only a call sent directly to the precompile by the user's own EVM or synthetic address signs with the user's PDA.

To let a router or adapter move a user's tokens, the user calls `approve_spl(spender, amount, mint)`. This sets the contract's external-authority PDA as the SPL delegate of the user's token account. It is Rome's version of ERC-20 `approve`.

Under `DELEGATECALL`, the precompile refuses the bare external-authority PDA as a signer. Salted authorities include the running contract in their derivation under `DELEGATECALL`.

## Every address has a PDA, so why don't the wrappers split liquidity?

For a wallet, a wrapper is a view of its SPL tokens. `balanceOf` reads the wallet's real token account on Solana. `totalSupply` reads the mint's supply.

The three wUSDC wrappers on Hadrian (testnet), 9.0.0 (`0xbce339ba…`), 8.0.0 (`0xae287c43…`), and May 2026 (`0x9fd4d58d…`), show the same balance for each wallet. All three return the mint's supply from `totalSupply`.

A Solana-native holder and an EVM holder use accounts of the same mint. The Solana wallet owns its token account directly. The EVM address's external-authority PDA owns its token account. `ActivateAta` and `transfer_spl` move tokens between these accounts. Both holders trade against the same Solana pool accounts and reserves.

Contract-held balances need different treatment. Tokens sent to a contract sit in the wrapper's escrow account. The wrapper tracks the contract's balance. A UniswapV2-style pair on Hadrian had a balance of 9,600,566 through wrapper 9.0.0 and 0 through wrapper 8.0.0. Use the canonical wrapper from the registry for pools, vaults, and lending markets.

Each token account has one SPL delegate slot. Granting permission to a router or bridge replaces the wrapper's grant. After a wrapper rotation, the user must grant the new wrapper permission with `approve_spl`. Grant the wrapper again if another delegate has replaced it.

Each factory permits one wrapper per mint. Wrappers from different factories can still read the same wallet token accounts. See [Token Interop](https://docs.rome.builders/core-concepts/token-interop.md).

## How does Rome get around the different semantics of Solana and the EVM?

| Difference                                   | What Rome does                                                                                                                                                                                               |
| -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Accounts declared up front vs dynamic access | Emulates the call first and uses the touched accounts as the Solana instruction's account list.                                                                                                              |
| One transaction's compute and size limits    | Uses atomic (VmAt) execution when the call fits. Holder accounts carry larger payloads, and iterative (VmIt) execution splits work across transactions.                                                      |
| Account locks across legs                    | Renews locks on balance and storage accounts every leg. Locks last 3 seconds, or 4 seconds when the transaction names more than 28 accounts. An atomic write to a locked account fails with `AccountLocked`. |
| Gas token and fees                           | Counts Solana costs in lamports and converts them to gas-token charges with the transaction's gas price. Wallet-paid calls pay SOL directly.                                                                 |
| Blocks and slots                             | Uses the Solana slot for `block.number` and the Solana clock for `block.timestamp`.                                                                                                                          |
| Finality                                     | Confirms at Solana `confirmed`. Hercules re-checks indexed blocks at `finalized`.                                                                                                                            |
| Signatures                                   | Verifies EVM signatures with `secp256k1_recover`. Solana authorization uses Ed25519. Both produce a 20-byte EVM sender.                                                                                      |
| Rent                                         | Funds Solana account creation and growth through the fee payer. Charges the EVM sender through gas when a fee recipient is present.                                                                          |
| Decimals and integer width                   | Uses 18 decimals for native gas balances. Conversion to SPL units must be exact and fit `u64`. Wrappers use the mint's decimals and reject amounts above `uint64` maximum.                                   |
| Reentrancy and gas metering                  | Has no EVM opcode gas meter. The 2,300-gas stipend does not restrict calls, so contracts need explicit reentrancy guards.                                                                                    |
| CPI depth                                    | Runs the Rome EVM program at depth 1 and a CPI target at depth 2. Solana permits nesting through depth 5.                                                                                                    |
| Atomicity of Solana side effects             | Executes legacy CPIs immediately and aborts the whole transaction if their frame later reverts. Cached calls are recorded during execution and sent at commit. They are discarded when their frame reverts.  |
| `SELFDESTRUCT` and unknown opcodes           | Disables `SELFDESTRUCT`. It and other unimplemented opcodes abort the whole transaction with `IncompatibleVersionEVM`.                                                                                       |
| Nonces                                       | Stores and checks an EVM nonce per sender in its balance PDA. Gas estimation skips the nonce check.                                                                                                          |

### Accounts

The emulator runs the call against Solana accounts before submission. It records every account touched and whether it must be writable. That set becomes the Solana instruction's account list. A required account missing from the list fails the on-chain call.

A time-dependent branch can change between emulation and execution. If that change causes the call to exceed its compute budget, the Rome Proxy recomposes once at the next block.

### Transaction size and compute

Atomic (VmAt) execution fits within one Solana transaction, with about 1.4 million compute units and at most 64 accounts. The call must also fit the heap and instruction-trace limits.

A Solana v1 transaction holds at most 4,096 bytes. For larger EVM transaction payloads, the Rome Proxy writes 3,600-byte chunks into a `TxHolder` holder account with a maximum size of 80,000 bytes. Each chunk's signature fee is charged as gas.

Iterative (VmIt) execution saves the VM state in a `StateHolder` holder account between legs. A session permits at most 160 iterations. The planner produces at most 128 legs, with an opcode limit of at least 500 per leg. Legacy CPIs require atomic execution. Cached calls support iterative execution.

### Gas and rent

One Rome gas unit represents one lamport of Solana cost. Costs include signature fees, the 5,000-lamport treasury toll, priority fees, and rent net of refunds. `eth_gasPrice` reports gas-token wei per lamport. When a fee recipient is present, Rome charges the sender `lamports × tx.gasPrice` from the native balance.

The Solana fee payer funds rent when Rome creates or grows balance and storage accounts. That cost is billed to the EVM sender as gas when a fee recipient is present. A first transfer to a never-used address therefore costs about 1 million gas. `eth_estimateGas` never returns less than 21,000.

### Blocks, time and finality

`block.number` is the Solana slot. `block.timestamp` is the Solana clock's Unix timestamp. Rome captures both when it creates the VM state and keeps them across iterative legs.

`blockhash(n)` is `keccak256(bytes32(n))` within the last 256 slots and zero outside them. It has no entropy. `block.coinbase` is the fee recipient, or zero when there is none.

The SDK waits for `confirmed`. Hercules re-checks each indexed block at `finalized` and reloads it if the blockhash changed.

### Reverts, reentrancy and CPI

Legacy CPIs execute immediately. If a frame that made a CPI later reverts, Rome aborts the whole transaction. Solidity `try/catch` cannot absorb that revert. Cached calls are recorded during execution and sent at commit. A reverted frame discards its recorded calls. Once a transaction has written through one track, writes through the other track are refused. After a cached write, the legacy read helpers are refused too: CpiProgram's account reads and `pdas_batch_derive`, and HelperProgram's `user_balance`, `allowance_of` and `mint_info`.

Rome has no EVM opcode gas meter. `gasleft()` returns the gas limit, or `U256::MAX` when there is no fee recipient. The gas passed to `CALL` or `CREATE` is not enforced. Use explicit reentrancy guards instead of relying on the 2,300-gas stipend.

Solana's instruction stack depth is 5. The Rome EVM program runs at depth 1, so its target runs at depth 2 and can nest through depth 5. The Hadrian swap ran the swap program at depth 2 and SPL Token at depth 3. A pending Solana change (SIMD-0268) would raise the depth from 5 to 9. It was not active on devnet or mainnet as of 19 October 2026. A CPI back into the Rome EVM program is refused.

See [Execution Model](https://docs.rome.builders/core-concepts/execution-model.md), [Constraints](https://docs.rome.builders/core-concepts/constraints.md), [Compute Budget](https://docs.rome.builders/core-concepts/compute-budget.md), and [Known Limitations](https://docs.rome.builders/security/known-limitations.md).

## Common questions

### Are MetaMask and Phantom the same account on Rome?

No. A MetaMask key and a Solana key give two different EVM addresses, and Rome never links them. The MetaMask key gives its usual Ethereum address. The Solana key gives its [synthetic address](#what-is-a-synthetic-address), `keccak256(pubkey)[12..32]`: `2PMoUv…` becomes `0x45b64dae…`. At the top-level call, `msg.sender` and `tx.origin` are the signing address, including the synthetic address on the relay route.

Different keys cause the separation: two MetaMask keys are also two accounts. The curves only mean neither key can sign for the other's address. There is no linking feature. `ActivateAta` funds only the signer's own synthetic address. A `Deposit` instruction can credit any EVM address with native gas, paid from the signer's gas-token account. The proxy only builds deposits to the signer's own synthetic address. None of these makes two keys one account. A pool sees two holders, but both trade against the same reserves; see [Is liquidity shared](#is-liquidity-shared-between-solana-and-evm-users-or-split).

### How do Solana and EVM accounts map?

Rome maps each Solana key to one fixed [synthetic EVM address](#what-is-a-synthetic-address). Every EVM address has a balance PDA per chain for its nonce, native gas balance, and code. Its external-authority PDA owns its token accounts and signs CPIs. Chains on one Rome program share that authority.

These accounts were read on Hadrian (testnet):

| Account                      | MetaMask address `0x35153297…a266`                                        | Solana wallet `2PMoUv…`, synthetic address `0x45b64dae…127d`                                 |
| ---------------------------- | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| Wallet's own Solana accounts | None from the MetaMask key                                                | SOL system account `2PMoUv…`; own wSOL account `T8gKAAg9pz5eLcerH1Nh52Hn97m1nnGyhY9z4bwtyir` |
| Balance PDA                  | `8zuWEakFcuRRJ5Gju44u6Ptyk22gbNUMbsD8VLEQVS4c`                            | `EeRr14Feh3Ft7YuyacAVJQd3YSYsKAPTqdMEN43gtBSd`                                               |
| External-authority PDA       | `EZSTURZAg3GMqiWN3NBCvMLjEeLSxGH9PGooW6dAG8Kb`                            | `FMSHMpgdA9rEhzGLSvFniAHT7BmGjJweQqxPiGJJntC1`                                               |
| Token account Rome uses      | USDC `8wAzpmag4oL4c6ku6wqQBjxWXYLPoVsek6SyAvrYaxim`, owned by `EZSTURZA…` | wSOL `3pPjxR4ho3mVb5AMauVCjqTBUVS2Rif5JAnk9DFukPg2`, owned by `FMSHMpgd…`                    |

A Solana user's tokens sit in two places: the wallet's own accounts and the synthetic address's PDA-owned accounts that wrappers read. The SDK moves tokens in with `ActivateAta` and back with `transfer_spl`, as described in [How does a Solana user call a Solidity contract?](#how-does-a-solana-user-call-a-solidity-contract). The sweep `0x95b2502d…` returned 0.016587 wSOL to the wallet. The same MetaMask address has different token accounts on Hadrian (testnet) and Rubicon (mainnet) because they run on different Rome programs, mints and Solana clusters.

### Who pays which fee when an EVM user and a Solana user call the same contract? Is it one fee path or two?

Rome uses one cost model with two ways to settle it. A Rome gas unit is one lamport of Solana cost: signature fees, the 5,000-lamport treasury toll, any priority fee, and rent net of refunds.

On wallet-signed Solana lanes, the Solana fee payer pays that cost in SOL with no EVM gas charge. On MetaMask and relay calls, the Rome Proxy fronts SOL. The program charges the EVM sender `lamports × the transaction's gas price` from its native balance to a proxy fee recipient. The gas token is USDC on Hadrian (testnet) and Rubicon (mainnet).

These two `supply` calls (USDC from MetaMask, wSOL from the Solana key) used AavePool 2.0.0 (`0x81e7e7e4…`) on Hadrian (testnet). Each created two accounts.

| Cost or recipient       | EVM key (MetaMask)                                                                  | Solana key (v1 wallet-signed)                                                                                        |
| ----------------------- | ----------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| EVM tx                  | `0xc7e6ee8d…`, from `0x35153297…`                                                   | `0xb0712551…`, from `0x45b64dae…`                                                                                    |
| Who signed and paid SOL | Rome's proxy payer `GNX1fLhb…`                                                      | The user's wallet `2PMoUv…`                                                                                          |
| SOL spent               | 2,102,962 lamports = 5,000 signature + 2 priority + 5,000 toll + 2 × 1,046,480 rent | 2,107,960 lamports = 10,000 in signature fees (transaction + Ed25519 verification) + 5,000 toll + 2 × 1,046,480 rent |
| EVM gas charged         | Sender paid 2,102,962 gas × 13,004,742,450 wei = 0.0273485 USDC                     | `gasUsed` 0, `gasPrice` 0                                                                                            |
| Gas paid to             | Proxy fee recipient `0x179d6112…`                                                   | Nobody; no `gasRecipient`                                                                                            |
| Treasury toll recipient | `7WDWCxvk…`, treasury account #31                                                   | `3F9eKFpr…`, treasury account #6                                                                                     |

* **Legacy lane (older path):** `0x350b8e36…` cost the wallet 1,056,480 lamports: 5,000 signature fee + 5,000 toll + 1,046,480 rent, for one created account. EVM gas was 0.
* **Relay:** Aave `borrow` transaction `0x18d65e8c…` used 16 Solana legs. The synthetic address paid 2,177,992 gas = 0.0226594 USDC, using the same fee path as a MetaMask user. The gas charge covers `16 × 5,002 + 5,000 toll + 2 × 1,046,480 rent = 2,177,992`. Each relay leg also carries the Ed25519 verification signature. The proxy pays that 5,000 lamports per leg and does not bill it, so this call cost the proxy 16 × 10,002 lamports in fees.
* **Shared treasury:** Every route pays its 5,000-lamport toll into one of the chain's 64 treasury accounts. The two supply calls above paid their tolls into accounts #31 and #6 of the same set.
* **Declared price:** Rome charges the transaction's declared price, `maxFeePerGas` for EIP-1559. There is no base fee or refund of the difference. Live EVM-key transactions declared from 1× to 2× the `eth_gasPrice` quote of 10,403,793,960 wei per lamport, and each paid exactly what it declared. Gas is priced per lamport of Solana cost, not per EVM opcode.
* **Wallet-signed costs:** The SDK lanes set no priority fee, so users pay no compute charge. They pay signature fees, the toll, and rent in SOL. The v1 lane pays for two signatures: the transaction signature and Ed25519 verification.

See the [Solana call flow](#how-does-a-solana-user-call-a-solidity-contract) and [dual-lane guide](https://docs.rome.builders/developer-guides/dual-lane-app.md) for the wallet and relay routes.

### Is liquidity shared between Solana and EVM users, or split?

Shared. Both lanes trade against the same mint's accounts. On Aave on Hadrian (testnet), a Solana key and a MetaMask-lane EVM key both supplied and borrowed through wSOL escrow account `3yY2FHSG…` (MetaMask: supply `0xaf460f52…`, borrow `0x89dbf0b6…`; Solana key: supply `0xb0712551…`, borrow `0x18d65e8c…`). This is the wSOL wrapper's escrow, which holds the awSOL reserve.

On rome-dex, a Solana wallet deposited liquidity directly into the same vaults used by EVM router swap `0xa7f77530…`. The Solana deposit transaction `2xFSzza7…` contains no Rome program. Only balances held by contracts depend on the wrapper, so use the registry's canonical wrapper for pools and vaults (see the [PDA and wrapper section](#every-address-has-a-pda-so-why-dont-the-wrappers-split-liquidity)). Don't measure wSOL liquidity with `totalSupply`: it reads 0 because the native SOL mint reports a supply of 0.

### How do I move tokens and gas balance between a MetaMask address and a Solana wallet?

* **Solana wallet to MetaMask address, tokens:** Create the token account if it is missing (the Associated Token program's idempotent create, with the address's external-authority PDA as owner), then send a plain SPL transfer to it. `HelperProgram.ata(address, mint)` returns its address. Transaction `2tBhefMJ…` did both and moved 20 USDC.
* **Solana wallet to MetaMask address, gas:** Fund your own synthetic address with `fundSyntheticGas`. Then send a native value transfer from the synthetic address to the MetaMask address.
* **MetaMask address to Solana wallet, tokens:** Call `transfer_spl(bytes32,uint64,bytes32)` on the Helper precompile directly from the EVM address, with the recipient's existing token account. Alternatively, call `RomeBridgeWithdraw.bridgeOutToSolana`, which needs a grant and an existing recipient token account.
* **MetaMask address to Solana wallet, gas:** Call the Withdraw precompile's payable `withdrawal(bytes32 to)` with the amount as `msg.value`. The wallet receives it as USDC in its USDC token account, which Rome creates if needed. `msg.value` must be a multiple of 10^12 wei. The recipient must be an existing wallet account.

`transfer_spl_to_signer` reaches your own wallet only on the wallet-signed Solana lane. From MetaMask or through the relay, the signer is Rome's proxy payer, so the call fails or the tokens go to Rome. See the [Precompile reference](https://docs.rome.builders/reference/precompiles.md).

One identity can spend the other's tokens only through an explicit grant, `approve_spl` or an ERC-20 `approve`, as with any other address. Each token account has one delegate slot. See [Token Interop](https://docs.rome.builders/core-concepts/token-interop.md#one-time-grant-per-wallet).

### Is my address the same on every Rome chain?

The EVM address is the same on every chain because it comes from the key. Its nonce and gas balance are kept per chain. Its token accounts are shared by chains on the same Rome program and differ between programs and clusters. See the [account mapping](#how-do-solana-and-evm-accounts-map).

### Which wallet works on the Solana lane? Does Phantom work?

Not yet on the Solana lane. The Solana lane uses Solana v1 transactions, and the wallet has to sign them. On devnet, Solflare does; Phantom does not yet.

### Does the explorer show which lane a transaction used?

Partly. The [Via explorer](https://docs.rome.builders/apps-on-rome/via.md) shows whether an EVM key or a Solana key sent a call: `origination` is `ecdsa` or `solana_unsigned`, and Solana-key calls carry `solanaSigner`. It does not tell the legacy, v1 and relay routes apart; all three show `solana_unsigned`. A relay call is the one with non-zero `gasUsed` and a `gasRecipient`. A gas top-up made with `fundSyntheticGas` shows as `ecdsa` with no `solanaSigner`.

## Where to go next

* [Architecture](https://docs.rome.builders/getting-started-1/architecture.md)
* [Execution Model](https://docs.rome.builders/core-concepts/execution-model.md)
* [Token Interop](https://docs.rome.builders/core-concepts/token-interop.md)
* [Call Solana from EVM](https://docs.rome.builders/developer-guides/call-solana-from-evm.md)
* [Call EVM from Solana](https://docs.rome.builders/developer-guides/call-evm-from-solana.md)
* [Build a dual-lane app](https://docs.rome.builders/developer-guides/dual-lane-app.md)
* [Integrate a Solana program](https://docs.rome.builders/developer-guides/integrate-solana-program.md)
* [Precompile reference](https://docs.rome.builders/reference/precompiles.md)
* [JSON-RPC reference](https://docs.rome.builders/reference/json-rpc.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/core-concepts/how-solana-and-evm-meet.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.
