> 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/pt-br/conceitos-principais/how-solana-and-evm-meet.md).

# Como Solana e a EVM se encontram na Rome

Como carteiras Solana chamam contratos Solidity, endereços EVM chamam programas Solana, e o Rome lida com identidade, tokens, taxas e limites de execução.

Esta página explica como as chamadas atravessam entre a Solana e a EVM na Rome. Ela cobre quem assina, onde os tokens ficam, quem paga e quais regras da Solana afetam contratos Solidity.

Salvo indicação em contrário, os números e transações desta página são do Hadrian (testnet) em 19 de outubro de 2026.

## O que é um endereço sintético?

Um endereço sintético é a identidade EVM de uma chave pública Solana. A Rome o calcula como os últimos 20 bytes de `keccak256` da chave pública: `keccak256(pubkey)[12..32]`. O mapeamento é fixo. Ele é chamado de sintético porque ninguém possui uma chave secp256k1 para ele: o MetaMask não pode assinar por ele, e apenas a chave Solana pode autorizar chamadas a partir dele.

Na chamada de contrato de nível superior, ambos `msg.sender` e `tx.origin` são o endereço sintético. A Rome armazena o nonce EVM sob esse endereço. O contrato não consegue distinguir essa identidade de um usuário MetaMask por meio desses campos.

## Como um usuário Solana chama um contrato Solidity?

A carteira autoriza uma chamada EIP-1559 sem assinatura por uma de duas rotas. A rota v1 é o caminho atual. A rota legada é o caminho mais antigo: a carteira assina e paga pela transação Solana que carrega `DoTxUnsigned`, e o programa EVM da Rome deriva o endereço sintético desse signatário Solana.

Na rota v1, a carteira assina uma mensagem legível contendo `Rome authorization`, uma nova linha e o hash da chamada como `0x` seguido por 64 caracteres hexadecimais minúsculos. A transação carrega essa assinatura em uma instrução de verificação Ed25519 no índice 0. O programa EVM da Rome deriva o endereço sintético da chave que autorizou a chamada.

A Rome Proxy compõe a transação v1. A carteira então assina e a envia para a Solana. Na rota de relay, a Rome Proxy submete a transação e paga SOL, e o endereço sintético paga gás a partir de seu saldo nativo no token de gás da cadeia (USDC no Hadrian e no Rubicon).

Quando a carteira paga diretamente, a rota v1 custa 15.000 lamports: uma taxa de assinatura de 5.000 lamports, 5.000 lamports pela assinatura de verificação Ed25519 e um pedágio da tesouraria de 5.000 lamports. A rota legada `DoTxUnsigned` não tem instrução Ed25519 e custa 10.000 lamports. Ambas as rotas também pagam rent para quaisquer contas criadas. Nenhuma das rotas diretas cobra gás EVM. Uma transação da rota legada no Hadrian custou à carteira 10.000 lamports e reportou `gasUsed = 0` e `effectiveGasPrice = 0`.

O `submitRomeTxV1` segue estas etapas:

1. Leia o nonce do endereço sintético com `eth_getTransactionCount`, estime o gás e construa a chamada sem assinatura.
2. Peça à carteira que assine a `Rome authorization` mensagem.
3. Solicite uma transação de `rome_composeUnsignedAtomicV1`.
4. Verifique o pagador retornado, os bytes da chamada, a autorização Ed25519, os programas permitidos e a ausência de uma taxa de prioridade.
5. Peça à carteira que assine a transação v1, envie-a para a Solana e faça polling da Rome Proxy pelo recibo EVM.
6. Se a chamada exigir execução iterativa, faça relay por meio de `rome_relayUnsignedV1` usando a mesma assinatura de autorização.

Use `fundSyntheticGas` para financiar o saldo nativo necessário para um relay ou `msg.value`. Ele deposita o token de gás da conta de token da carteira e credita o saldo nativo do endereço sintético. Saldos nativos usam 18 casas decimais.

Para usar tokens em um contrato, o SDK financia o endereço sintético, chama o contrato e devolve quaisquer tokens restantes. `buildFundLeg` usa `ActivateAta` para mover tokens da carteira para a conta de token do endereço sintético. A chamada Solidity usa esses tokens por meio de um wrapper. `buildSweepLeg` usa `transfer_spl` para enviar os tokens restantes de volta para a carteira.

A carteira precisa suportar assinatura de transações Solana v1. O Solflare suporta isso no devnet da Solana; o Phantom ainda não. Cada chamada verifica e incrementa o nonce EVM sob o endereço sintético para evitar replay.

Veja [Chamar EVM a partir da Solana](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-evm-from-solana.md), [Construir um app de duas vias](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/dual-lane-app.md), e [Rome SDK](https://docs.rome.builders/pt-br/produtos/rome-sdk.md).

## Como um usuário EVM, ou um contrato, chama um programa Solana?

Todo endereço EVM tem um endereço derivado de programa da Solana que possui suas contas de token e pode assinar chamadas para programas Solana. Esta é sua PDA de autoridade externa. O programa EVM da Rome a deriva a partir da seed `EXTERNAL_AUTHORITY` seguida pelo endereço EVM. As seeds não contêm chain ID, então cadeias hospedadas pelo mesmo programa EVM da Rome compartilham essa autoridade.

Um usuário ou contrato chama o pré-compilado CPI em `0xFF…08` com o ID do programa-alvo, a lista de contas e os bytes da instrução. CPI significa cross-program invocation. O pré-compilado invoca o programa Solana dentro da mesma transação Solana.

`invoke` assina em nome da PDA de autoridade externa do chamador quando a lista de contas a marca como signatária. `invoke_signed` também oferece suporte a PDAs derivadas com sal. Cada PDA com sal deve aparecer na lista de contas como signatária.

Os métodos `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, e `pdas_batch_derive` são auxiliares somente de leitura. Eles não invocam um programa Solana.

O pré-compilado recusa chamadas direcionadas ao próprio programa EVM da Rome. Ele também recusa uma lista de contas que contenha o ID do programa EVM da Rome. Uma CPI não pode nomear o fee payer da Solana, exceto dentro de uma instrução System simples. `Transfer` instrução.

Um swap do RomeDexRouter 2.0.0 no Hadrian seguiu estas etapas:

1. O roteador chamou `HelperProgram.create_ata` para garantir que a conta de token de saída do usuário existisse.
2. Ele derivou as contas de token de entrada e de saída do usuário e marcou sua própria PDA de autoridade externa como signatária.
3. Ele chamou `CPI.invoke` com o programa de swap da Solana, a lista de contas e os bytes da instrução de swap.
4. O SPL Token moveu os tokens da conta do usuário para o pool e devolveu os tokens de saída para a outra conta do usuário. A PDA do roteador assinou como delegada SPL do usuário. O roteador não reteve nenhum token.
5. O roteador verificou a quantidade recebida com `CPI.account_u64_at(dstAta, 64)`.
6. O recibo reportou 10.001 de gás: `5,000 + 5,000 + 1 = 10,001` lamports de custo da Solana. Esses custos foram a taxa de assinatura, o pedágio da tesouraria e a taxa de prioridade. A Rome Proxy pagou SOL, e o usuário pagou gás em USDC.

Veja [Chamar Solana a partir da EVM](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md), [Integrar um programa Solana](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/integrate-solana-program.md), e o [Referência de precompile](https://docs.rome.builders/pt-br/referencia/precompiles.md).

## Quem assina quando um contrato chama um programa Solana?

A Rome assina com a PDA de autoridade externa do chamador imediato do pré-compilado. Um contrato, portanto, assina como ele mesmo. Apenas uma chamada enviada diretamente ao pré-compilado pela própria EVM do usuário ou pelo endereço sintético assina com a PDA do usuário.

Para permitir que um roteador ou adaptador mova os tokens de um usuário, o usuário chama `approve_spl(spender, amount, mint)`. Isso define a PDA de autoridade externa do contrato como a delegada SPL da conta de token do usuário. É a versão da Rome para o ERC-20 `approve`.

Em `DELEGATECALL`, o pré-compilado recusa a PDA de autoridade externa nua como signatária. Autoridades com sal incluem o contrato em execução em sua derivação sob `DELEGATECALL`.

## Se todo endereço tem uma PDA, por que os wrappers não dividem a liquidez?

Para uma carteira, um wrapper é uma visão de seus tokens SPL. `balanceOf` lê a conta de token real da carteira na Solana. `totalSupply` lê o suprimento do mint.

Os três wrappers de wUSDC no Hadrian (testnet), 9.0.0 (`0xbce339ba…`), 8.0.0 (`0xae287c43…`), e maio de 2026 (`0x9fd4d58d…`), mostram o mesmo saldo para cada carteira. Todos os três retornam o suprimento do mint de `totalSupply`.

Um detentor nativo da Solana e um detentor EVM usam contas do mesmo mint. A carteira Solana possui sua conta de token diretamente. A PDA de autoridade externa do endereço EVM possui sua conta de token. `ActivateAta` e `transfer_spl` movem tokens entre essas contas. Ambos os detentores negociam contra as mesmas contas e reservas do pool Solana.

Saldos detidos por contratos precisam de tratamento diferente. Tokens enviados para um contrato ficam na conta de escrow do wrapper. O wrapper acompanha o saldo do contrato. Um par no estilo UniswapV2 no Hadrian tinha um saldo de 9.600.566 através do wrapper 9.0.0 e 0 através do wrapper 8.0.0. Use o wrapper canônico do registro para pools, vaults e mercados de empréstimo.

Cada conta de token tem um único slot de delegada SPL. Conceder permissão a um roteador ou bridge substitui a concessão do wrapper. Após uma rotação de wrapper, o usuário deve conceder permissão ao novo wrapper com `approve_spl`. Conceda permissão ao wrapper novamente se outra delegada o tiver substituído.

Cada fábrica permite um wrapper por mint. Wrappers de fábricas diferentes ainda podem ler as mesmas contas de token da carteira. Veja [Interoperação de Tokens](https://docs.rome.builders/pt-br/conceitos-principais/token-interop.md).

## Como a Rome contorna as diferentes semânticas da Solana e da EVM?

| Diferença                                            | O que a Rome faz                                                                                                                                                                                                                        |
| ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Contas declaradas antecipadamente vs acesso dinâmico | Emula a chamada primeiro e usa as contas tocadas como a lista de contas da instrução Solana.                                                                                                                                            |
| Limites de computação e tamanho de uma transação     | Usa execução atômica (VmAt) quando a chamada cabe. Contas holder carregam payloads maiores, e a execução iterativa (VmIt) divide o trabalho entre transações.                                                                           |
| Bloqueios de conta entre pernas                      | Renova os bloqueios em contas de saldo e de armazenamento a cada perna. Os bloqueios duram 3 segundos, ou 4 segundos quando a transação nomeia mais de 28 contas. Uma escrita atômica em uma conta bloqueada falha com `AccountLocked`. |
| Token de gás e taxas                                 | Conta os custos da Solana em lamports e os converte em cobranças no token de gás com o preço do gás da transação. Chamadas pagas pela carteira pagam SOL diretamente.                                                                   |
| Blocos e slots                                       | Usa o slot da Solana para `block.number` e o relógio da Solana para `block.timestamp`.                                                                                                                                                  |
| Finalidade                                           | Confirma na Solana `confirmado`. Hercules revalida blocos indexados em `finalizado`.                                                                                                                                                    |
| Assinaturas                                          | Verifica assinaturas EVM com `secp256k1_recover`. A autorização Solana usa Ed25519. Ambas produzem um remetente EVM de 20 bytes.                                                                                                        |
| Rent                                                 | Financia a criação e o crescimento de contas Solana por meio do fee payer. Cobra o remetente EVM via gás quando há um recipient de taxa.                                                                                                |
| Casas decimais e largura de inteiro                  | Usa 18 casas decimais para saldos nativos de gás. A conversão para unidades SPL deve ser exata e caber em `u64`. Wrappers usam as casas decimais do mint e rejeitam valores acima do `uint64` máximo.                                   |
| Reentrância e medição de gás                         | Não possui medidor de gás por opcode EVM. O estipêndio de 2.300 gás não restringe chamadas, então os contratos precisam de proteções explícitas contra reentrância.                                                                     |
| Profundidade de CPI                                  | Executa o programa EVM da Rome na profundidade 1 e um alvo CPI na profundidade 2. A Solana permite aninhamento até a profundidade 5.                                                                                                    |
| Atomicidade dos efeitos colaterais da Solana         | Executa CPIs legadas imediatamente e aborta a transação inteira se o frame delas reverter depois. Chamadas em cache são registradas durante a execução e enviadas no commit. Elas são descartadas quando seu frame reverte.             |
| `SELFDESTRUCT` e opcodes desconhecidos               | Desativa `SELFDESTRUCT`. Ele e outros opcodes não implementados abortam a transação inteira com `IncompatibleVersionEVM`.                                                                                                               |
| Nonces                                               | Armazena e verifica um nonce EVM por remetente em sua PDA de saldo. A estimativa de gás pula a verificação de nonce.                                                                                                                    |

### Contas

O emulador executa a chamada contra as contas da Solana antes do envio. Ele registra toda conta tocada e se ela precisa ser gravável. Esse conjunto se torna a lista de contas da instrução Solana. Uma conta necessária ausente da lista faz a chamada on-chain falhar.

Um ramo dependente do tempo pode mudar entre a emulação e a execução. Se essa mudança fizer a chamada exceder seu orçamento de computação, a Rome Proxy recompõe uma vez no próximo bloco.

### Tamanho e computação da transação

A execução atômica (VmAt) cabe em uma única transação Solana, com cerca de 1,4 milhão de unidades de computação e no máximo 64 contas. A chamada também precisa caber nos limites de heap e de traço de instruções.

Uma transação Solana v1 comporta no máximo 4.096 bytes. Para payloads de transação EVM maiores, a Rome Proxy escreve chunks de 3.600 bytes em uma `TxHolder` conta holder com tamanho máximo de 80.000 bytes. A taxa de assinatura de cada chunk é cobrada como gás.

A execução iterativa (VmIt) salva o estado da VM em uma `StateHolder` conta holder entre pernas. Uma sessão permite no máximo 160 iterações. O planejador produz no máximo 128 pernas, com um limite de opcode de pelo menos 500 por perna. CPIs legadas exigem execução atômica. Chamadas em cache suportam execução iterativa.

### Gás e rent

Uma unidade de gás da Rome representa um lamport de custo da Solana. Os custos incluem taxas de assinatura, o pedágio da tesouraria de 5.000 lamports, taxas de prioridade e rent líquido de reembolsos. `eth_gasPrice` reporta wei do token de gás por lamport. Quando há um recipient de taxa, a Rome cobra do remetente `lamports × tx.gasPrice` a partir do saldo nativo.

O fee payer da Solana financia rent quando a Rome cria ou aumenta contas de saldo e armazenamento. Esse custo é cobrado do remetente EVM como gás quando há um recipient de taxa. Portanto, a primeira transferência para um endereço nunca usado custa cerca de 1 milhão de gás. `eth_estimateGas` nunca retorna menos de 21.000.

### Blocos, tempo e finalização

`block.number` é o slot da Solana. `block.timestamp` é o timestamp Unix do relógio da Solana. A Rome captura ambos quando cria o estado da VM e os mantém ao longo das pernas iterativas.

`blockhash(n)` seja `keccak256(bytes32(n))` dentro dos últimos 256 slots e zero fora deles. Ele não tem entropia. `block.coinbase` é o recipient de taxa, ou zero quando não há nenhum.

O SDK aguarda `confirmado`. O Hercules revalida cada bloco indexado em `finalizado` e o recarrega se o blockhash tiver mudado.

### Reverts, reentrância e CPI

CPIs legadas executam imediatamente. Se um frame que fez uma CPI reverter depois, a Rome aborta a transação inteira. O try/catch do Solidity `try/catch` não pode absorver esse revert. Chamadas em cache são registradas durante a execução e enviadas no commit. Um frame revertido descarta as chamadas registradas. Depois que uma transação escreve por um caminho, escritas pelo outro caminho são recusadas. Após uma escrita em cache, os auxiliares de leitura legados também são recusados: as leituras de conta do CpiProgram e `pdas_batch_derive`e as do HelperProgram `user_balance`, `allowance_of` e `mint_info`.

A Rome não possui medidor de gás por opcode EVM. `gasleft()` retorna o limite de gás, ou `U256::MAX` quando não há recipient de taxa. O gás passado para `CALL` ou `CREATE` não é imposto. Use proteções explícitas contra reentrância em vez de confiar no estipêndio de 2.300 gás.

A profundidade da pilha de instruções da Solana é 5. O programa EVM da Rome roda na profundidade 1, então seu alvo roda na profundidade 2 e pode aninhar até a profundidade 5. O swap do Hadrian executou o programa de swap na profundidade 2 e o SPL Token na profundidade 3. Uma mudança pendente na Solana (SIMD-0268) elevaria a profundidade de 5 para 9. Ela não estava ativa no devnet nem na mainnet em 19 de outubro de 2026. Uma CPI de volta para o programa EVM da Rome é recusada.

Veja [Modelo de execução](https://docs.rome.builders/pt-br/conceitos-principais/execution-model.md), [Restrições](https://docs.rome.builders/pt-br/conceitos-principais/constraints.md), [Orçamento de Computação](https://docs.rome.builders/pt-br/conceitos-principais/compute-budget.md), e [Limitações conhecidas](https://docs.rome.builders/pt-br/seguranca/known-limitations.md).

## Perguntas comuns

### MetaMask e Phantom são a mesma conta na Rome?

Não. Uma chave MetaMask e uma chave Solana geram dois endereços EVM diferentes, e a Rome nunca os vincula. A chave MetaMask gera seu endereço Ethereum usual. A chave Solana gera seu [endereço sintético](#what-is-a-synthetic-address), `keccak256(pubkey)[12..32]`: `2PMoUv…` torna-se `0x45b64dae…`. Na chamada de nível superior, `msg.sender` e `tx.origin` são o endereço que assina, incluindo o endereço sintético na rota de relay.

Chaves diferentes explicam a separação: duas chaves MetaMask também são duas contas. As curvas apenas significam que nenhuma chave pode assinar pelo endereço da outra. Não existe recurso de vínculo. `ActivateAta` financia apenas o endereço sintético do próprio signatário. Uma `Depósito` instrução pode creditar qualquer endereço EVM com gás nativo, pago a partir da conta de token de gás do signatário. A proxy só constrói depósitos para o próprio endereço sintético do signatário. Nada disso torna duas chaves uma única conta. Um pool vê dois detentores, mas ambos negociam contra as mesmas reservas; veja [A liquidez é compartilhada](#is-liquidity-shared-between-solana-and-evm-users-or-split).

### Como as contas Solana e EVM se mapeiam?

A Rome mapeia cada chave Solana para um único [endereço EVM sintético](#what-is-a-synthetic-address). Todo endereço EVM tem uma PDA de saldo por cadeia para seu nonce, saldo nativo de gás e código. Sua PDA de autoridade externa possui suas contas de token e assina CPIs. Cadeias em um único programa Rome compartilham essa autoridade.

Estas contas foram lidas no Hadrian (testnet):

| Conta                              | Endereço MetaMask `0x35153297…a266`                                            | carteira Solana `2PMoUv…`, endereço sintético `0x45b64dae…127d`                                  |
| ---------------------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
| Contas Solana próprias da carteira | Nenhuma da chave MetaMask                                                      | Conta de sistema SOL `2PMoUv…`; própria conta wSOL `T8gKAAg9pz5eLcerH1Nh52Hn97m1nnGyhY9z4bwtyir` |
| PDA de saldo                       | `8zuWEakFcuRRJ5Gju44u6Ptyk22gbNUMbsD8VLEQVS4c`                                 | `EeRr14Feh3Ft7YuyacAVJQd3YSYsKAPTqdMEN43gtBSd`                                                   |
| PDA de autoridade externa          | `EZSTURZAg3GMqiWN3NBCvMLjEeLSxGH9PGooW6dAG8Kb`                                 | `FMSHMpgdA9rEhzGLSvFniAHT7BmGjJweQqxPiGJJntC1`                                                   |
| Conta de token que a Rome usa      | USDC `8wAzpmag4oL4c6ku6wqQBjxWXYLPoVsek6SyAvrYaxim`, pertencente a `EZSTURZA…` | wSOL `3pPjxR4ho3mVb5AMauVCjqTBUVS2Rif5JAnk9DFukPg2`, pertencente a `FMSHMpgd…`                   |

Os tokens de um usuário Solana ficam em dois lugares: nas próprias contas da carteira e nas contas da PDA do endereço sintético que os wrappers leem. O SDK move os tokens para dentro com `ActivateAta` e de volta com `transfer_spl`como descrito em [Como um usuário Solana chama um contrato Solidity?](#how-does-a-solana-user-call-a-solidity-contract). A varredura `0x95b2502d…` devolveu 0,016587 wSOL para a carteira. O mesmo endereço MetaMask tem contas de token diferentes no Hadrian (testnet) e no Rubicon (mainnet) porque eles rodam em programas Rome, mints e clusters Solana diferentes.

### Quem paga qual taxa quando um usuário EVM e um usuário Solana chamam o mesmo contrato? É um caminho de taxa ou dois?

A Rome usa um único modelo de custo com duas formas de liquidá-lo. Uma unidade de gás da Rome é um lamport de custo da Solana: taxas de assinatura, o pedágio da tesouraria de 5.000 lamports, qualquer taxa de prioridade e rent líquido de reembolsos.

Nas rotas Solana assinadas pela carteira, o fee payer da Solana paga esse custo em SOL sem cobrança de gás EVM. Em chamadas MetaMask e de relay, a Rome Proxy adianta SOL. O programa cobra do remetente EVM `lamports × o preço de gás da transação` a partir do saldo nativo para um recipient de taxa da proxy. O token de gás é USDC no Hadrian (testnet) e no Rubicon (mainnet).

Esses dois `chamadas de` supply (USDC da MetaMask, wSOL da chave Solana) usaram o AavePool 2.0.0 (`0x81e7e7e4…`) no Hadrian (testnet). Cada uma criou duas contas.

| Custo ou recipient                 | Chave EVM (MetaMask)                                                                                  | Chave Solana (assinada pela carteira v1)                                                                                        |
| ---------------------------------- | ----------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| tx EVM                             | `0xc7e6ee8d…`, de `0x35153297…`                                                                       | `0xb0712551…`, de `0x45b64dae…`                                                                                                 |
| Quem assinou e pagou SOL           | pagador proxy da Rome `GNX1fLhb…`                                                                     | A carteira do usuário `2PMoUv…`                                                                                                 |
| SOL gasto                          | 2.102.962 lamports = 5.000 de assinatura + 2 de prioridade + 5.000 de pedágio + 2 × 1.046.480 de rent | 2.107.960 lamports = 10.000 em taxas de assinatura (transação + verificação Ed25519) + 5.000 de pedágio + 2 × 1.046.480 de rent |
| Gás EVM cobrado                    | O remetente pagou 2.102.962 de gás × 13.004.742.450 wei = 0,0273485 USDC                              | `gasUsed` 0, `gasPrice` 0                                                                                                       |
| Gás pago para                      | recipient de taxa da proxy `0x179d6112…`                                                              | Ninguém; nenhum `gasRecipient`                                                                                                  |
| Recipient do pedágio da tesouraria | `7WDWCxvk…`, conta da tesouraria #31                                                                  | `3F9eKFpr…`, conta da tesouraria #6                                                                                             |

* **Rota legada (caminho mais antigo):** `0x350b8e36…` custou à carteira 1.056.480 lamports: 5.000 de taxa de assinatura + 5.000 de pedágio + 1.046.480 de rent, por uma conta criada. O gás EVM foi 0.
* **Relay:** Aave `empréstimo` transação `0x18d65e8c…` usou 16 pernas Solana. O endereço sintético pagou 2.177.992 de gás = 0,0226594 USDC, usando o mesmo caminho de taxas que um usuário MetaMask. A cobrança de gás cobre `16 × 5.002 + 5.000 de pedágio + 2 × 1.046.480 de rent = 2.177.992`. Cada perna de relay também carrega a assinatura de verificação Ed25519. A proxy paga esses 5.000 lamports por perna e não os repassa, então esta chamada custou à proxy 16 × 10.002 lamports em taxas.
* **Tesouraria compartilhada:** Toda rota paga seu pedágio de 5.000 lamports em uma das 64 contas de tesouraria da cadeia. As duas chamadas de supply acima pagaram seus pedágios nas contas #31 e #6 do mesmo conjunto.
* **Preço declarado:** A Rome cobra o preço declarado da transação, `maxFeePerGas` para EIP-1559. Não há taxa base nem reembolso da diferença. Transações em produção com chave EVM declararam de 1× a 2× a `eth_gasPrice` cotação de 10.403.793.960 wei por lamport, e cada uma pagou exatamente o que declarou. O gás é precificado por lamport de custo da Solana, não por opcode EVM.
* **Custos assinados pela carteira:** As rotas do SDK não definem taxa de prioridade, então os usuários não pagam cobrança de computação. Eles pagam taxas de assinatura, o pedágio e rent em SOL. A rota v1 paga por duas assinaturas: a assinatura da transação e a verificação Ed25519.

Veja o [fluxo de chamadas da Solana](#how-does-a-solana-user-call-a-solidity-contract) e [guia de duas rotas](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/dual-lane-app.md) para as rotas da carteira e de relay.

### A liquidez é compartilhada entre usuários Solana e EVM, ou é dividida?

Compartilhada. Ambas as rotas negociam contra as contas do mesmo mint. Na Aave no Hadrian (testnet), uma chave Solana e uma chave EVM da rota MetaMask ambas forneceram e tomaram empréstimo por meio da conta de escrow wSOL `3yY2FHSG…` (MetaMask: fornecer `0xaf460f52…`, tomar empréstimo `0x89dbf0b6…`; chave Solana: fornecer `0xb0712551…`, tomar empréstimo `0x18d65e8c…`). Este é o escrow do wrapper wSOL, que contém a reserva awSOL.

No rome-dex, uma carteira Solana depositou liquidez diretamente nos mesmos vaults usados pelo swap do roteador EVM `0xa7f77530…`. A transação de depósito Solana `2xFSzza7…` não contém nenhum programa Rome. Apenas saldos mantidos por contratos dependem do wrapper, então use o wrapper canônico do registro para pools e vaults (veja a [seção de PDA e wrapper](#every-address-has-a-pda-so-why-dont-the-wrappers-split-liquidity)). Não meça a liquidez de wSOL com `totalSupply`: ele lê 0 porque o mint nativo de SOL reporta suprimento 0.

### Como movo tokens e saldo de gás entre um endereço MetaMask e uma carteira Solana?

* **Carteira Solana para endereço MetaMask, tokens:** Crie a conta de token se ela estiver faltando (a criação idempotente do programa Associated Token, com a PDA de autoridade externa do endereço como proprietária) e então envie uma transferência SPL simples para ela. `HelperProgram.ata(address, mint)` retorna o endereço dele. `2tBhefMJ…` fez ambos e moveu 20 USDC.
* **Carteira Solana para endereço MetaMask, gás:** Financie seu próprio endereço sintético com `fundSyntheticGas`. Depois envie uma transferência de valor nativo do endereço sintético para o endereço MetaMask.
* **Endereço MetaMask para carteira Solana, tokens:** Chame `transfer_spl(bytes32,uint64,bytes32)` no pré-compilado Helper diretamente do endereço EVM, com a conta de token existente do destinatário. Alternativamente, chame `RomeBridgeWithdraw.bridgeOutToSolana`, que precisa de uma concessão e de uma conta de token do destinatário já existente.
* **Endereço MetaMask para carteira Solana, gás:** Chame a função payable do pré-compilado Withdraw `withdrawal(bytes32 to)` com o valor como `msg.value`. A carteira o recebe como USDC em sua conta de token USDC, que a Rome cria se necessário. `msg.value` deve ser múltiplo de 10^12 wei. O destinatário deve ser uma conta de carteira existente.

`transfer_spl_to_signer` chega à sua própria carteira somente na faixa Solana assinada pela carteira. No MetaMask ou pelo relé, o signatário é o pagador proxy da Rome, então a chamada falha ou os tokens vão para a Rome. Veja a [Referência de precompile](https://docs.rome.builders/pt-br/referencia/precompiles.md).

Uma identidade pode gastar os tokens da outra somente por meio de uma concessão explícita, `approve_spl` ou um ERC-20 `approve`, como com qualquer outro endereço. Cada conta de token tem um único slot de delegado. Veja [Interoperação de Tokens](https://docs.rome.builders/pt-br/conceitos-principais/token-interop.md#one-time-grant-per-wallet).

### Meu endereço é o mesmo em toda cadeia Rome?

O endereço EVM é o mesmo em todas as cadeias porque vem da chave. Seu nonce e saldo de gás são mantidos por cadeia. Suas contas de token são compartilhadas entre cadeias no mesmo programa Rome e diferem entre programas e clusters. Veja o [mapeamento de contas](#how-do-solana-and-evm-accounts-map).

### Qual carteira funciona na faixa Solana? Phantom funciona?

Ainda não na faixa Solana. A faixa Solana usa transações Solana v1, e a carteira precisa assiná-las. Na devnet, a Solflare funciona; a Phantom ainda não.

### O explorador mostra qual faixa uma transação usou?

Parcialmente. O [Via explorador](https://docs.rome.builders/pt-br/apps-na-rome/via.md) mostra se uma chave EVM ou uma chave Solana enviou uma chamada: `originação` seja `ecdsa` ou `solana_unsigned`, e chamadas com chave Solana carregam `solanaSigner`. Ele não distingue as rotas legada, v1 e relé; todas as três mostram `solana_unsigned`. Uma chamada via relé é a que tem valor diferente de zero `gasUsed` e um `gasRecipient`. Um reforço de gás feito com `fundSyntheticGas` aparece como `ecdsa` sem `solanaSigner`.

## Para onde ir em seguida

* [Arquitetura](https://docs.rome.builders/pt-br/primeiros-passos-1/architecture.md)
* [Modelo de execução](https://docs.rome.builders/pt-br/conceitos-principais/execution-model.md)
* [Interoperação de Tokens](https://docs.rome.builders/pt-br/conceitos-principais/token-interop.md)
* [Chamar Solana a partir da EVM](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md)
* [Chamar EVM a partir da Solana](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-evm-from-solana.md)
* [Construir um app de duas vias](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/dual-lane-app.md)
* [Integrar um programa Solana](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/integrate-solana-program.md)
* [Referência de precompile](https://docs.rome.builders/pt-br/referencia/precompiles.md)
* [referência JSON-RPC](https://docs.rome.builders/pt-br/referencia/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/pt-br/conceitos-principais/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.
