> 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/open-to-solana-users.md).

# Abra seu contrato para usuários da Solana

Implante um contrato Solidity na Rome (testnet Hadrian, mainnet Rubicon) e abra-o para carteiras Solana — o que o contrato precisa, como um usuário de carteira Solana o chama, endereços por rede e um lançame ch

Um único deploy, dois tipos de usuários. Um contrato em Rome é acessado por usuários do MetaMask com sua chave EVM e por usuários de carteira Solana (Solflare, por exemplo) com sua chave Solana — mesmo endereço, mesmo estado. Esta página é o caminho de ponta a ponta: fazer deploy, tornar o contrato pronto para Solana, conectar a faixa Solana no seu app e publicar na mainnet.

## 1. Faça deploy na rede que você quiser

As chains Rome são alvos EVM padrão: Hardhat, Foundry, viem e ethers funcionam sem mudanças (tutorial completo em [Implantar contratos Solidity](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/deploy-solidity.md)).

| Rede                                                                       | ID da cadeia | RPC                                         | Explorador                                                                            | Token de gás  | Como obter gas                                                                                                                                                                                                                      |
| -------------------------------------------------------------------------- | ------------ | ------------------------------------------- | ------------------------------------------------------------------------------------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [**Rubicon**](https://docs.rome.builders/pt-br/redes/rubicon.md) (mainnet) | `7531`       | `https://rubicon.mainnet.romeprotocol.xyz/` | [via-rubicon.mainnet.romeprotocol.xyz](https://via-rubicon.mainnet.romeprotocol.xyz/) | USDC          | Faça bridge de USDC a partir de Ethereum, Base, Arbitrum, Polygon, Avalanche, Monad ou OP (CCTP) ou a partir de Solana com o [Rome Bridge](https://bridge-api.mainnet.romeprotocol.xyz/); ele chega como gas                        |
| **Hadrian** (testnet)                                                      | `200010`     | `https://hadrian.testnet.romeprotocol.xyz/` | [via-hadrian.testnet.romeprotocol.xyz](https://via-hadrian.testnet.romeprotocol.xyz/) | USDC de teste | Faça bridge de USDC de teste a partir de uma testnet ([Faucets](https://docs.rome.builders/pt-br/recursos/faucets.md)) ou faça wrap a partir de uma carteira da devnet da Solana no [Rome App](https://app.devnet.romeprotocol.xyz) |

Gas é USDC com 18 decimais no lado EVM; não existe faucet de Rome em Rubicon ou Hadrian. As escritas custam mais gas do que a intuição sobre Ethereum sugere, porque a maior parte do custo é criar contas Solana: um destinatário nunca usado, uma nova conta de token, um contrato implantado. Use `eth_estimateGas`e, o que a ferramenta padrão faz, e nunca codifique 21.000. Medido em Hadrian, implantar um contrato de 10 bytes estimou e usou 1.147.921 gas, e uma transferência nativa para um endereço nunca usado, 1.086.961, contra 21.000 para uma transferência para um endereço existente. Rome cobra o gas realmente usado, que nessas medições nunca foi maior do que a estimativa. Financie alguns USDC antes do primeiro deploy. Depois verifique a origem no explorador ([Verificar contratos](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/verify-contracts.md); o verificador da mainnet é `https://verify.mainnet.romeprotocol.xyz`).

Desenvolva em Hadrian e depois faça redeploy dos mesmos artefatos em Rubicon com o chain id e os endereços dos wrappers da mainnet trocados; nada no contrato muda entre as redes. Rubicon está no registro público a partir da v0.3.0, mas `create-rome-app` e `rome-cli` ainda fixam o registro v0.2.0, que não tem entrada para Rubicon, então não conseguem apontar para ela; para essas ferramentas, preencha os valores manualmente a partir de [Rubicon](https://docs.rome.builders/pt-br/redes/rubicon.md). O gas em Rubicon é USDC real, cerca de dez vezes o preço de gas de Hadrian, então fazer deploy lá custa dinheiro de verdade.

## 2. O que torna um contrato pronto para Solana

A identidade EVM de um usuário da Solana é o **endereço sintético**, `keccak256(solana_pubkey)[12:]`: um endereço comum `msg.sender`, com um nonce comum. A maioria dos contratos não precisa de nenhuma mudança. As três coisas que importam:

* **Receba valor como ERC-20, não `msg.value`.** Os fundos de um usuário da Solana são tokens SPL na carteira, vistos no lado EVM como o wrapper do token (`wUSDC`, `wETH`, `wSOL`). O sintético não mantém nada parado e os ativos do usuário chegam como o wrapper, então puxe com `transferFrom` após um `approve` e devolva com `transfer`. Cada usuário concede ao wrapper seu direito de delegado SPL uma vez antes do primeiro pull ([Conceda uma vez: o wrapper](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/dual-lane-app.md#one-time-grant-the-wrapper)). Um `payable` ponto de entrada só funciona depois que o sintético recebe gas nativo (o da rota de relay `rome_composeExternalDepositV1`), o que o modelo de fund-and-sweep não faz. Um vault ERC-20, AMM ou mercado de empréstimo já existente já tem o formato certo.
* **Use os wrappers canônicos.** Cada chain tem um wrapper por mint; os endereços estão em [Contract Addresses](https://docs.rome.builders/pt-br/referencia/contract-addresses.md) (o de Hadrian também está no registro público [é o wrapper em cache que esta seção descreve.](https://github.com/rome-protocol/rome-registry)). Aponte os construtores para esses endereços; não faça deploy do seu próprio.
* **Encaixe o orçamento atômico onde uma carteira assina.** Uma carteira Solana assina uma transação Solana, então uma chamada na rota Solana precisa caber nisso: cerca de 1,4M compute units, 64 contas, 4 KB ([Restrições](https://docs.rome.builders/pt-br/conceitos-principais/constraints.md)). Medido em Hadrian: uma transferência, um approve e um supply da Aave cabem; um swap do Uniswap V3 cabe com pouca folga (cerca de 1,24M CU); um borrow da Aave não cabe e segue pela rota de relay na próxima seção. Meça com o `computeUnitsConsumed`, solicitando a transação com `maxSupportedTransactionVersion: 1` (as pernas Rome são transações v1; sem isso o RPC recusa a solicitação).

O que você não precisa: um programa Solana, uma bridge, um segundo deploy ou qualquer Solidity específico de Rome. Se o contrato também chamar programas Solana pelos precompiles, veja [Chamar Solana a partir da EVM](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md).

## 3. Deixe uma carteira Solana chamá-lo

O caminho EVM do seu app permanece inalterado (MetaMask + `submitRomeTx`, ou viem/ethers puro). Para a rota Solana há dois formatos.

**A faixa do SDK — uma transação Solana v1 por chamada.** [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) (`submitRomeTxV1`) faz o proxy compor uma transação Solana v1 para sua chamada EVM (até 64 contas e 4 KB, sem address lookup table; não há instrução ComputeBudget, carteira tesouro ou descoberta de contas no seu código). A carteira assina duas vezes com a mesma chave: primeiro uma mensagem de autorização legível (`Rome authorization` em uma linha, `0x` e o hash da transação EVM na linha seguinte), que a chain verifica por meio do programa Ed25519, e depois a transação. O app envia a transação assinada para o RPC da Solana; a chamada retorna o hash da transação EVM e seu recibo. Antes de a carteira assinar a transação, o SDK a verifica: o pagador é o único assinante, apenas o programa Rome e o verificador Ed25519 são executados, a instrução Rome carrega exatamente a chamada que o usuário autorizou e não há taxa de prioridade. Qualquer outra coisa é recusada.

Se uma chamada não couber em uma transação, o composer a recusa e o SDK a entrega ao proxy para encaminhar, com a mesma assinatura de autorização, então o usuário ainda vê um único prompt de autorização. O resultado então tem `route: "relay"`. As regras para chamadas encaminhadas e chamadas longas estão em [Chamadas retransmitidas e chamadas longas](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-evm-from-solana.md#relayed-calls-and-long-calls). Uma chamada encaminhada é paga no gas nativo da chain, então o sintético precisa de um saldo de gas: `fundSyntheticGas(deps, amountWei)` move o token de gas da chain (USDC em Hadrian e Rubicon) da conta de token da carteira para ele, em uma única transação v1 assinada pela carteira.

A perna de funding (`buildFundLeg`) e a criação da conta de token da carteira antes de um sweep são instruções Solana comuns; `submitSolanaInstructionsV1` envia-as também como transações v1, assinadas pelo mesmo signatário da carteira, sem envolver proxy. A própria chamada do sweep (`buildSweepLeg`, `HelperProgram.transfer_spl`) passa por `submitRomeTxV1` como qualquer outra, e o proxy encontra as contas de token. `submitRomeTxV1` não cria por conta própria a conta de um novo sintético: antes da primeira chamada que move valor, verifique `isSyntheticProvisioned(...)` e, se for falso, envie `buildCreatePdaCall(synthetic)` por `submitRomeTxV1` uma vez. Um passo a passo completo de depósito e retirada com código está em [Construir um app de duas vias](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/dual-lane-app.md); a mecânica está em [Chamar EVM a partir da Solana](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-evm-from-solana.md). O anterior `submitRomeTxSolanaLane`, que monta uma transação Solana legada no cliente, ainda está no SDK como a rota mais antiga.

**De onde cada `deps` valor vem.** O `deps` objeto do SDK tem cinco campos obrigatórios (o restante, como `fetchImpl` e os timeouts, é opcional). Quatro vêm da chain e um da carteira:

| `deps` campo | De onde vem                                                                                                                    | Obtenção no registro (`@rome-protocol/registry` v0.2.0)                                                  |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
| `proxyUrl`   | a URL de RPC da chain                                                                                                          | `getChain(chainId).rpcUrl`                                                                               |
| `chainId`    | o ID da chain                                                                                                                  | `getChain(chainId).chainId`                                                                              |
| `programId`  | o ID do programa Rome em que a chain roda                                                                                      | `getChain(chainId).romeEvmProgramId`                                                                     |
| `conexão`    | um RPC da Solana para o cluster da chain, para onde a transação assinada é enviada (devnet para Hadrian, mainnet para Rubicon) | `getChain(chainId).solana.rpc` (uma URL pública de devnet para Hadrian); para mainnet use um RPC próprio |
| `signer`     | da carteira `LaneSigner`, ou um `Keypair` em scripts                                                                           | nenhum                                                                                                   |

Os construtores de perna recebem valores que não estão em `deps`. O seu `mint` (chamado `usdcMint` no passo a passo) é o mint Solana do token de gas, vindo de `getTokens(chainId)` (a entrada com `kind: "gas"`, campo `mintId`). O endereço do wrapper wUSDC não é uma entrada do construtor de perna; você o usa para as chamadas ERC-20, e ele é a entrada com `kind: "spl_wrapper"` e símbolo `wUSDC` (campo `address`). O registro cobre Hadrian e, a partir da v0.3.0, Rubicon. Para preencher os valores de Rubicon manualmente, em vez disso: `proxyUrl` `https://rubicon.mainnet.romeprotocol.xyz/`, `chainId` `7531`, `programId` `RomePq9X3iAoTr813HR7uRarafFDUJty6GdiEceYpzX`, `mint` `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`, o wrapper da tabela na próxima seção e um RPC da mainnet Solana para `conexão`. [Rubicon](https://docs.rome.builders/pt-br/redes/rubicon.md) tem a lista completa.

**Os endpoints externos V1 do proxy — a mesma rota sem o SDK.** O SDK encapsula o compose atômico, o relay e o depósito de gas (`fundSyntheticGas`). Os métodos RPC brutos continuam disponíveis para clientes que não usam o SDK, e incluem o compose iterativo, que o SDK não encapsula. A carteira assina uma mensagem Ed25519 sobre a chamada (a forma legível `Rome authorization\n0x<hash>` ou o hash bruto), e o proxy ou compõe a(s) transação(ões) Solana para a carteira assinar (`rome_composeUnsignedAtomicV1`, `rome_composeUnsignedIterativeV1` + `rome_submitSignedV1Plan`) ou executa todo o fluxo por conta própria com uma única assinatura da carteira (`rome_relayUnsignedV1`, depois de um `rome_composeExternalDepositV1` (o SDK's `fundSyntheticGas`) que abastece o saldo de gas do sintético; chamadas encaminhadas consomem dele, então recarregue quando estiver baixo). Formatos dos métodos em [Suporte a JSON-RPC](https://docs.rome.builders/pt-br/referencia/json-rpc.md); as regras de autorização em [Chamar EVM a partir da Solana](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-evm-from-solana.md#the-external-v1-endpoints). Use o relay para qualquer coisa iterativa e a rota do SDK para tudo que couber.

De qualquer forma, o contrato vê uma transação normal vinda do endereço sintético e o usuário nunca possui uma chave EVM.

## 4. Endereços de wrapper por rede

| Rede             | `wUSDC` wrapper                              | Outros wrappers                                                                                          |
| ---------------- | -------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| Rubicon (7531)   | `0x0952d233b0c254cd375f3bfb3e5869c1a906f9b3` | `wETH` `0x01e8b3573da1d4b7b4b1ce0932cf07c8af0c92e9`, `wSOL` `0xc4e29e0f726a906e93277cbbc37bf27a9848a113` |
| Hadrian (200010) | `0xbce339ba4c3a8de3bb8af1c5539e6ac11da3112d` | `wETH` `0x02aeace038269f9961c93d04dcacd6fb3adfa55f`, `wSOL` `0x39f36444fcb79b3e691544aee2a832ebef54ca9f` |

O token de gas nativo aparece como `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee` nas listas de tokens; ele não é um contrato ERC-20. Os wrappers carregam os decimais do mint SPL, não 18: wUSDC 6, wETH 8, wSOL 9.

## 5. Checklist de lançamento

1. Implantado em Hadrian; o caminho EVM funciona a partir do MetaMask.
2. Todo ponto de entrada que move valor é baseado em ERC-20 e aponta para o wrapper canônico da chain.
3. Uma carteira Solana que assina transações v1 (o Solflare faz isso na devnet hoje; o Phantom ainda não) conclui o round trip completo em Hadrian: provisione o sintético (`create_pda`, uma vez) → perna de funding → concessão → approve → chamada → perna de sweep, usando a rota do SDK; ou a rota de relay se a chamada for iterativa.
4. O `computeUnitsConsumed` é lido do recibo da Solana e fica dentro do orçamento atômico, ou a chamada é roteada pelo relay.
5. A concessão do wrapper está no fluxo de primeiro depósito do seu app para ambas as rotas: `isEnabled(user)` é verificado e `approve_spl` é enviado uma vez quando for falso ([Conceda uma vez: o wrapper](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/dual-lane-app.md#one-time-grant-the-wrapper)).
6. Código-fonte verificado no explorador.
7. Reimplantado em Rubicon com os endereços dos wrappers da mainnet. Seus `deps` valores vêm do registro (v0.3.0 ou posterior) ou manualmente de [Rubicon](https://docs.rome.builders/pt-br/redes/rubicon.md). O mesmo round trip é executado uma vez com fundos reais, usando uma carteira que você verificou que assina transações v1 na mainnet.

## O que vem a seguir

* [Construir um app de duas vias](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/dual-lane-app.md) — o exemplo do vault, passo a passo, ambas as carteiras
* [Chamar EVM a partir da Solana](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-evm-from-solana.md) — endereços sintéticos, descoberta de contas, os endpoints externos V1
* [Implantar contratos Solidity](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/deploy-solidity.md) · [Verificar contratos](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/verify-contracts.md) · [Contract Addresses](https://docs.rome.builders/pt-br/referencia/contract-addresses.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/guias-do-desenvolvedor/open-to-solana-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.
