> 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/guias-do-desenvolvedor/call-evm-from-solana.md).

# Chamar EVM a partir da Solana

Permita que uma carteira Solana controle contratos EVM na Rome — sem chave Ethereum. A carteira assina, e sua transação vai para a Solana.

O inverso de [Chamar Solana a partir da EVM](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md): uma carteira Solana (por exemplo, Solflare) chama qualquer contrato EVM na Rome diretamente, com **nenhuma chave Ethereum**. É assim que [Aerarium](https://docs.rome.builders/pt-br/apps-na-rome/apps.md) permite que usuários nativos de Solana compartilhem os mesmos contratos que usuários de EVM.

A forma de uma única chamada é a do SDK `submitRomeTxV1`, que faz o proxy compor uma transação Solana v1 para a chamada; esta página explica os mecanismos.

## Endereços sintéticos

A identidade EVM de uma carteira Solana é o seu **endereço sintético** — os últimos 20 bytes do `keccak256` da sua chave pública Solana de 32 bytes:

```
synthetic_evm_address = keccak256(solana_pubkey)[12:]
```

Este é o `msg.sender` endereço usado quando a carteira chama um contrato, e a identidade estável sob a qual seu nonce e seu armazenamento vivem. A derivação é fixada no protocolo, então uma carteira sempre mapeia para o mesmo endereço.

```javascript
import { syntheticAddress } from "@rome-protocol/sdk";
const from = syntheticAddress(solanaPubkey); // 0x… 20 bytes
```

## O sintético é um pass-through — ele não mantém tokens em repouso

O saldo gasto de um usuário nativo de Solana fica em sua **carteira Solana** (como tokens SPL), exposto 1:1 no lado EVM como o **wrapper ERC20SPL** (por exemplo, `wUSDC`). O sintético não mantém nada em repouso, então o valor flui *por* ele — cada etapa assinada pela carteira Solana:

1. **Provisionamento (uma vez).** A PDA de autenticação externa de um novo sintético não existe até que `create_pda` execute — e as transferências abaixo são assinadas por essa PDA. `submitRomeTxSolanaLane` faz o provisionamento automaticamente no primeiro uso (ou chame `provisionSynthetic` para uma etapa explícita "Ativar"; verifique com `isSyntheticProvisioned`). Com `submitRomeTxV1`, verifique `isSyntheticProvisioned` e envie `buildCreatePdaCall` por ela uma vez.
2. **Etapa de financiamento (carteira → sintético).** Mova o token da ATA da carteira para a do sintético — a `ActivateAta` etapa, construída por `buildFundLeg`. Agora `wrapper.balanceOf(synthetic)` lê esse saldo, então o sintético o gasta como um ERC-20 comum (`transfer` / `transferFrom`) — **não** como nativo `msg.value`, que ele não mantém.
3. **A(s) chamada(s) (`DoTxUnsigned`).** O sintético executa a(s) transação(ões) EVM — por exemplo `approve` depois um vault `depósito` que puxa via `transferFrom`.
4. **Etapa de varredura (sintético → carteira).** Depois que um saque / empréstimo / claim deposita tokens no sintético, `buildSweepLeg` os devolve para a ATA da própria carteira do usuário (`HelperProgram.transfer_spl`), então o sintético termina com saldo zero.

A próxima seção descreve o que o `submitRomeTxSolanaLane` constrói no lado do cliente. `submitRomeTxV1` faz o proxy compor uma transação v1 em vez disso, sem descoberta de contas, ComputeBudget ou carteira de tesouraria no seu código; veja [os endpoints externos V1](#the-external-v1-endpoints) abaixo.

## Como a chamada é construída

`submitRomeTxSolanaLane` faz tudo isso. Os mecanismos:

1. **Construa uma transação EIP-1559 sem assinatura** com `a partir de` = o endereço sintético — sem assinatura secp256k1.
2. **Descobrir contas** — chame [`rome_emulateCallAccounts`](https://docs.rome.builders/pt-br/referencia/json-rpc.md) com os `a partir de`, `a`, `dados`, **e `valor`** (quando a chamada é pagável). Passar `valor` importa: o proxy emula a *real* chamada, então qualquer escrita de armazenamento dependente de valor — por exemplo, um novo slot de mapeamento — é alocada e sua conta Solana é retornada. Omiti-lo e essa conta fica ausente, e a transação falha com *"instruction modified data of a read-only account."*
3. **Monte a transação Solana:** duas **ComputeBudget** instruções (a EVM da Rome precisa de um limite de CU maior ≈1,35M e de uma heap frame grande ≈250 KB — os padrões da Solana falham) + a **`DoTxUnsigned`** instrução (o RLP sem assinatura + as contas descobertas) + a **carteira de tesouraria** (a execução paga a ela uma pequena taxa; a descoberta a omite, então o SDK a acrescenta).
4. **A carteira assina e envia.** O **A carteira Solana assina a transação Solana (Ed25519) e a envia para o RPC da Solana — não para o proxy.** O runtime da Solana verifica a assinatura; na cadeia, o programa deriva `msg.sender` a partir desse signatário. A autoridade é a assinatura Solana, não uma Ethereum. (O proxy é usado apenas para a emulação/descoberta na etapa 2.)

O PDA do usuário (`["EXTERNAL_AUTHORITY", synthetic_address]`) é dono das contas de token dele e assina CPI de SPL em seu nome — então um usuário Solana pode fornecer, tomar emprestado, trocar e prover liquidez inteiramente a partir de sua carteira Solana.

## Os endpoints externos V1

`submitRomeTxV1` é a forma de uma única chamada: ele pede ao proxy uma transação v1 composta, a verifica, faz com que a carteira a assine e a envia para o RPC da Solana, fazendo relay pelo proxy quando a chamada não cabe. O proxy expõe a mesma rota como métodos RPC, então qualquer cliente pode usá-la sem o SDK (lista completa em [Suporte a JSON-RPC](https://docs.rome.builders/pt-br/referencia/json-rpc.md)):

* `rome_composeUnsignedAtomicV1(rlp, pubkey, signature)` — uma transação Solana v1; a carteira a assina e o app a transmite ao RPC da Solana. Recusada quando a chamada não cabe em uma única transação atômica.
* `rome_composeUnsignedIterativeV1(rlp, pubkey, signature)` — cada etapa da execução (atômica se couber, caso contrário as etapas iterativas); a carteira assina cada uma, `rome_submitSignedV1Plan` as transmite. Os limites em um plano longo estão em [Chamadas retransmitidas e chamadas longas](#relayed-calls-and-long-calls).
* `rome_relayUnsignedV1(rlp, pubkey, signature)` — uma assinatura da carteira, o pagador do proxy conduz as etapas e retorna o hash da tx EVM; o sintético paga o gas da Rome, então financie-o uma vez com `rome_composeExternalDepositV1`.

**A assinatura de autorização.** `rlp` é o corpo bruto EIP-1559 não assinado de 9 campos. A carteira assina, com sua chave Ed25519, seja o bruto de 32 bytes `keccak256(0x02 ‖ rlp)` ou a mensagem legível

```
Rome authorization\n0x<64 lowercase hex chars of that hash>
```

Ambos são aceitos; a forma legível é o que uma carteira renderiza de forma legível em seu prompt `signMessage` . O programa recalcula o hash a partir do corpo que executa e exige que a mensagem assinada seja exatamente uma das duas formas, então uma assinatura sobre um corpo nunca pode autorizar outro, e o nonce do corpo impede replay.

## Chamadas retransmitidas e chamadas longas

Algumas chamadas não cabem em uma única transação Solana. Esta seção cobre o que acontece então, e quais limites se aplicam.

### Quando o compositor atômico recusa

`rome_composeUnsignedAtomicV1` recusa uma chamada que não cabe em uma única transação atômica. `submitRomeTxV1` então faz relay da chamada pelo proxy com a **mesma** assinatura de autorização, então a carteira não é solicitada uma segunda vez. O resultado tem `route: "relay"` e nenhuma `assinatura Solana`. Passe `relayOnRefusal: false` para obter a recusa como erro em vez disso, ou chame `relayV1` você mesmo para fazer relay de propósito.

Três coisas para saber sobre uma chamada com relay:

* **O sintético paga o gas.** Na rota de relay, o proxy envia e paga pelas transações Solana, e a chamada é paga no token nativo de gas da cadeia a partir do saldo do sintético. O saldo deve ser pelo menos `gasLimit × maxFeePerGas`. `fundSyntheticGas(deps, amountWei)` recarrega isso a partir da própria conta de token da carteira para o token de gas da cadeia (USDC em Hadrian e Rubicon); a carteira assina uma única transação v1 simples, e precisa de um pouco de SOL para a taxa Solana. `amountWei` está em wei de 18 decimais da cadeia e deve ser um múltiplo de 10^12, ou o proxy o recusa. Sem o SDK, `rome_composeExternalDepositV1` constrói a mesma transação.
* **Um revert não lança erro.** Uma chamada com relay que reverte no lado EVM é resolvida normalmente, com `receipt.status === "0x0"`. Verifique `receipt?.status === "0x1"` antes de tratar a chamada como concluída. `receipt` seja `null` se o recibo não aparecer a tempo.
* **`relayOnRefusal: false` é uma escolha feita no SDK, não um bloqueio.** O proxy já mantém a assinatura de autorização para esse payload e pode executá-lo por qualquer uma das rotas, até `gasLimit × maxFeePerGas`.

```javascript
const res = await submitRomeTxV1(deps, { to, data, value });
if (res.route === "relay" && res.receipt?.status !== "0x1") {
  // uma chamada com relay que reverte é resolvida; ela não lança erro
}
```

### Chamadas longas

Uma chamada que precisa de mais de uma transação é executada como uma sessão iterativa: o programa executa quantos passos EVM couberem em cada transação Solana e salva seu estado entre elas. Duas formas de conduzi-la a partir de uma carteira Solana:

* **Faça relay.** `rome_relayUnsignedV1` recebe uma assinatura da carteira e o pagador do proxy envia cada etapa. O sintético paga o gas, como acima.
* **Assine as etapas você mesmo.** `rome_composeUnsignedIterativeV1` retorna cada etapa com um slot de assinatura vazio, a carteira assina cada uma, e `rome_submitSignedV1Plan` as transmite em ordem. Cada etapa é uma transação Solana separada para a carteira assinar, então uma carteira que assina uma transação por vez solicita uma vez por etapa, além da assinatura de autorização. A carteira paga a taxa Solana em cada etapa.

Os limites:

| Limite                                              | Valor              | De onde vem                                                                                                               |
| --------------------------------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------- |
| Transações em uma `rome_submitSignedV1Plan` chamada | 64                 | O proxy recusa um plano mais longo                                                                                        |
| Etapas que o compositor iterativo vai planejar      | 128                | O limite no compositor iterativo do SDK Rome em Rust, que também limita o plano `rome_composeUnsignedIterativeV1` retorna |
| Iterações em uma sessão                             | 160                | O programa EVM da Rome; além disso a sessão para de retomar, libera seus bloqueios de conta e termina                     |
| Tamanho da transação Solana e contas                | 4 KB, 64 endereços | Cada etapa é uma transação Solana v1                                                                                      |

A maioria das chamadas reais se resolve em muito menos etapas do que esses limites. O limite de 64 transações em um plano assinado pela carteira é o primeiro que você encontrará. Uma chamada que precise de mais etapas do que isso não pode ser transmitida por `rome_submitSignedV1Plan`.

Uma chamada longa não pode fazer CPIs do trilho legado. Chamadas que mutam nos precompiles legados (`0xff…08`, `0xff…09` e `0x42…16`) são recusadas em uma sessão iterativa com `CpiProhibitedInIterativeTx`. Leituras do estado da Solana e dos precompiles do trilho em cache (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`) funcionam. Uma chamada que faz CPIs do trilho legado precisa caber em uma única transação atômica, seja qual for a rota que a envie. Veja [Restrições](https://docs.rome.builders/pt-br/conceitos-principais/constraints.md) e [Orçamento de Computação](https://docs.rome.builders/pt-br/conceitos-principais/compute-budget.md).

## Implementações de referência

* **Aerarium** — conduz Compound v3 (fornecer / tomar emprestado) a partir de uma carteira Solana via `DoTxUnsigned`. É a referência para o antigo trilho de transação legada descrito acima, não para `submitRomeTxV1`.
* **Rome DEX** não é um exemplo desta página: seu lado Solana é um programa nativo da Solana para o qual a carteira assina diretamente, e seu lado EVM compartilha o mesmo pool.

Aerarium não precisa de uma segunda carteira — o endereço sintético torna uma chave Solana um conta EVM de primeira classe. Para o padrão v1, siga [Construir um app de duas vias](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/dual-lane-app.md).

## O que vem a seguir

* [Chamar Solana a partir da EVM](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md) — a outra direção, via CPI
* [Interoperação de Tokens](https://docs.rome.builders/pt-br/conceitos-principais/token-interop.md) — como os saldos são compartilhados entre EVM e Solana


---

# 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/guias-do-desenvolvedor/call-evm-from-solana.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.
