> 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/rome-academy/08-open-your-solana-program-to-evm-users.md).

# 8. Abra seu programa Solana para usuários do EVM

Permita que usuários do MetaMask chamem um programa que você já executa na Solana, por meio de um contrato fino em Solidity e do precompile CPI, sem porta e sem uma segunda cópia do seu estado.

Você tem um programa Solana que funciona. Os usuários dele têm carteiras Solana. Rome permite que um segundo público o acesse: pessoas que possuem uma carteira EVM, como a MetaMask, sem que você precise reescrever o programa em Solidity.

## O que você vai aprender

* Por que você abriria um programa Solana para usuários EVM, e o que você mantém.
* Como uma chamada EVM alcança seu programa: um contrato Solidity fino e o precompile de CPI.
* O que seu programa vê como signer e as contas.
* Como os tokens de um usuário EVM chegam ao seu programa e voltam.
* Os limites com os quais você precisa projetar: uma trilha, uma transação atômica, o limite de contas.

## O caso de uso

Esta lição serve a um caso de uso de [O que você pode construir](https://docs.rome.builders/pt-br/rome-academy/02-what-you-can-build.md): um aplicativo Solana existente que quer mais usuários. Um mercado de lending, um AMM, um cofre, um mercado de previsão ou um programa de privacidade se encaixam.

O público EVM é grande e já tem carteiras, ferramentas e hábitos. Se você portar seu programa para Solidity, você mantém duas bases de código e divide seu estado. No Rome, você mantém um programa e um estado. Usuários EVM o acessam por meio de um pequeno contrato Solidity, e usuários Solana continuam chamando-o nativamente. Ambos negociam contra as mesmas contas e a mesma liquidez. [Escolha seu núcleo](https://docs.rome.builders/pt-br/conceitos-principais/choose-your-core.md) chama essa forma de (b), um núcleo Solana nativo com um roteador CPI fino.

[rome-dex](https://github.com/rome-protocol/rome-dex) é a referência: um pool Solana nativo, com um roteador EVM na frente dele.

## Antes de começar

* Concluir [7. Abra seu app EVM para carteiras Solana](https://docs.rome.builders/pt-br/rome-academy/07-open-to-solana-wallets.md), a mesma ideia do outro lado.
* Saiba [5. Chame a Solana a partir do Solidity](https://docs.rome.builders/pt-br/rome-academy/05-call-solana-from-solidity.md) e [6. Tokens nos dois lados](https://docs.rome.builders/pt-br/rome-academy/06-tokens-on-both-sides.md). Esta lição os reúne.
* Tenha seu programa implantado na devnet da Solana. O Hadrian faz a liquidação lá, então o programa precisa existir nesse cluster. Veja [Hadrian](https://docs.rome.builders/pt-br/redes/hadrian.md).

## O caminho em resumo

### Passo 1: coloque um contrato fino na frente do seu programa

O contrato é um adaptador. Ele não contém lógica de negócios. Ele verifica o chamador, monta sua instrução e chama o precompile de CPI com `invoke_signed`. Todo o resto permanece no seu programa Solana. A mecânica da chamada está em [Chamar Solana a partir da EVM](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md#calling-custom-solana-programs), e a interface está `contracts/interface.sol` no público [rome-solidity](https://github.com/rome-protocol/rome-solidity) repositório.

Seu adaptador tem três maneiras de manter a posição de um usuário. O guia as compara em [Três maneiras de manter a posição de um usuário](https://docs.rome.builders/pages/710652f2600ba20ebe907343732b80a7d5c1c611#id-2.-three-ways-to-hold-a-users-position):

| Formato                    | O que é                                                      | Se encaixa em                                          |
| -------------------------- | ------------------------------------------------------------ | ------------------------------------------------------ |
| Contrato adaptador         | Puxa os tokens do usuário, chama seu programa como ele mesmo | Uma frente reutilizável para um programa com depósitos |
| Usuário chama o precompile | A própria autoridade do usuário assina, sem contrato         | Concessões únicas e programas simples                  |
| Roteador sem custódia      | Nunca segura tokens, gasta a delegação do usuário            | Swaps e outras ações únicas                            |

Escolha o adaptador para um cofre ou programa de lending, e o roteador para um swap.

### Passo 2: saiba quem seu programa vê

Cada endereço EVM tem uma identidade Solana, seu PDA de autoridade externa, derivado sob o programa Rome. Quando um contrato chama o precompile, o Rome assina com a autoridade desse contrato. Seu programa vê uma chave pública de 32 bytes marcada como signer. Ele nunca vê um endereço EVM de 20 bytes e nunca vê o usuário.

Então o usuário não é o signer. Para distinguir os usuários, o adaptador passa um valor por usuário nos dados da instrução, ou pede ao Rome que também assine com um sub-PDA salgado derivado do endereço do usuário. Seu programa então mantém uma posição por sub-PDA. As regras de signer estão em [Todo endereço EVM tem uma identidade Solana](https://docs.rome.builders/pages/710652f2600ba20ebe907343732b80a7d5c1c611#id-1.-every-evm-address-has-one-solana-identity).

Escreva seu programa para agir com base em qualquer autoridade que assine. Assim, ele atende tanto uma carteira Solana quanto um adaptador.

### Passo 3: mova os tokens do usuário

No Rome, o USDC de um usuário é um único token SPL visto de dois lados, como a lição 6 mostrou. O saldo do usuário fica em uma conta de token de propriedade da sua autoridade. Para permitir que um adaptador o gaste, o usuário concede uma delegação SPL ao adaptador antes do depósito. O adaptador puxa os tokens para uma conta de token de sua propriedade e então chama seu programa. Na saída, seu programa paga para a própria conta de token do usuário, e o usuário o vê imediatamente como um saldo ERC-20.

Dois armadilhas importam aqui:

* Um ERC-20 `transferFrom` para um contrato só credita o livro-razão de custódia do wrapper. O contrato não recebe uma conta de token da qual possa gastar. Use a delegação, não o wrapper.
* Uma conta de token tem apenas um delegado. Sua concessão substitui a concessão do wrapper, e as transferências normais de token do usuário param até que ele conceda novamente ao wrapper. Verifique `isEnabled` depois do seu fluxo.

A sequência completa está em [Tokens entrando, tokens saindo](https://docs.rome.builders/pages/710652f2600ba20ebe907343732b80a7d5c1c611#id-3.-tokens-in-tokens-out).

### Passo 4: fique dentro dos limites

* **Uma trilha.** Uma chamada de programa customizado é um CPI da trilha legacy. Uma transação não pode misturá-la com chamadas da trilha cached, então mantenha o wrapper cached fora dessa transação.
* **Apenas atômico.** Um CPI da trilha legacy não pode ser executado em uma transação iterativa. A chamada inteira precisa caber em uma transação Solana, cerca de 1,4M de unidades de computação, 64 endereços e 4 KB. Seu programa compartilha esse orçamento de computação com o programa Rome.
* **Contas antecipadas.** O Rome emula a chamada e coloca na transação Solana toda conta que ela toca. Cada conta deve ser derivável a partir de entradas que o adaptador tenha. Uma conta nova ainda é nomeada.
* **Profundidade rasa.** Seu programa roda um nível abaixo do Rome. Cada programa que ele chama usa outro nível.
* **O aluguel é do usuário.** As contas que sua instrução cria são pagas por meio do gas do usuário.

Mantenha cada ação em um movimento de token e um CPI para o seu programa. Divida qualquer coisa maior em duas transações do usuário. Os limites estão em uma tabela em [Restrições](https://docs.rome.builders/pt-br/conceitos-principais/constraints.md).

## Um exemplo prático

Suponha que seu programa seja um cofre. Um usuário Solana deposita USDC e depois o retira. Você quer que usuários da MetaMask façam o mesmo.

1. Você implanta um adaptador que conhece o ID do seu programa e o mint do USDC. No construtor, ele cria sua própria identidade Solana e uma conta de token para ela.
2. Um usuário da MetaMask envia uma transação que concede ao adaptador uma delegação SPL sobre o seu USDC.
3. O usuário chama `depósito`. O adaptador puxa o USDC para sua própria conta de token e então chama seu programa com sua própria autoridade e um sub-PDA salgado para esse usuário como signers.
4. Seu programa move o USDC para o cofre e registra a posição sob o sub-PDA.
5. A concessão do adaptador substituiu a do wrapper, então seu app lê `isEnabled` no wrapper para o usuário. Ele retorna `false`, e o usuário envia `approve_spl` para o wrapper novamente. O próximo depósito precisa de uma nova concessão para o adaptador.
6. O usuário chama `withdraw`. O adaptador faz seu programa pagar diretamente do cofre para a conta de token do usuário. O saldo aparece na MetaMask como o token ERC-20.

Seus usuários Solana nunca tocaram no adaptador. Eles chamam o cofre diretamente e veem os mesmos totais. O esboço equivalente em Solidity está em [Um depósito e um saque, em Solidity](https://docs.rome.builders/pages/710652f2600ba20ebe907343732b80a7d5c1c611#id-7.-a-deposit-and-a-withdraw-in-solidity).

Teste no Hadrian primeiro. `eth_call` e `eth_estimateGas` executa a mesma emulação que o proxy usa para enviar, então um CPI que falha ali falha na cadeia pelo mesmo motivo, e o revert carrega o erro do seu programa. Depois de um envio, leia a parte Solana da transação com `rome_solanaTxForEvmTx`. Veja [Testando](https://docs.rome.builders/pages/710652f2600ba20ebe907343732b80a7d5c1c611#id-8.-testing).

## Teste seus conhecimentos

Pegue um pequeno programa seu, ou o que está em rome-dex, e anote, sem código:

1. O signer que seu programa vê quando um adaptador o chama.
2. As contas que um depósito nomeia.
3. O número de movimentos de token e CPIs nesse depósito.

Depois, implante seu adaptador no Hadrian, financie a conta de token do usuário, envie a concessão SPL para o adaptador e execute o depósito por meio de `eth_estimateGas` com o endereço do usuário como `a partir de`. A estimativa deve funcionar. Se falhar, os dados do revert nomeiam o erro Solana.

<details>

<summary>1. Um usuário da MetaMask faz um depósito por meio do seu adaptador. Quem assina para o seu programa?</summary>

O PDA de autoridade externa do adaptador, mais qualquer sub-PDA salgado que o adaptador listar. Não o usuário. Os direitos do usuário vêm da delegação SPL que ele concedeu.

</details>

<details>

<summary>2. Por que não puxar o USDC do usuário com o <code>transferFrom</code>?</summary>

do wrapper?

</details>

<details>

<summary>Os tokens cairiam na conta de custódia do wrapper e seriam registrados no seu livro-razão. O adaptador não teria uma conta de token própria para passar ao seu programa.</summary>

Falha. Um CPI da trilha legacy é recusado em uma transação iterativa. Reduza a ação para um movimento de token e um CPI, ou divida-a em duas transações.

</details>

## Próximo

[9. Construa um app de dupla via](https://docs.rome.builders/pt-br/rome-academy/09-build-a-dual-lane-app.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/rome-academy/08-open-your-solana-program-to-evm-users.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.
