> 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/apps-na-rome/bloom/lanes.md).

# As duas vias

Uma implantação de token, dois mundos de carteira. Ambos os fluxos executam o **os mesmos contratos** com o **mesmo gate de conformidade** — eles diferem apenas em quem assina e em como a transação chega à cadeia.

## Fluxo EVM

Ferramentas padrão do Ethereum, sem alterações: a carteira assina uma transação EVM, o endpoint JSON-RPC da cadeia a aceita, e o contrato do token impõe a lista de permissões. Nada específico do Bloom para integrar.

O gas em Rome é denominado em USDC, e uma escrita custa mais do que o equivalente em Ethereum sempre que precisa criar contas Solana (um detentor de primeira vez, uma nova conta de token). Use `eth_estimateGas`, como as ferramentas padrão fazem, e nunca fixe 21.000; a estimativa inclui a criação da conta, e Rome cobra o gas efetivamente usado. Uma transferência com gate também paga pela verificação da lista de permissões, então custa mais do que uma transferência simples do mesmo tamanho.

## caminho Solana

Uma carteira Solana opera os mesmos contratos EVM **nativamente — não existe nenhuma chave EVM**. Cada chamada é uma transação Solana v1 que o proxy da cadeia compõe para a carteira assinar. Não há tabelas de consulta de endereços nem instruções de orçamento de computação para montar: o proxy define o orçamento de computação e heap por conta própria.

1. **Identidade.** O endereço do usuário no lado EVM é *sintética*: derivado deterministicamente como `keccak256(solana_pubkey)[12..32]`. O programa EVM de Rome o deriva on-chain a partir do signatário real da transação — ele não pode ser falsificado, e não existe nenhuma chave privada secp256k1 para ele, então **a assinatura Solana é a única coisa que pode acionar esse endereço**.
2. **Autorizar.** O app monta a chamada como um payload EIP-1559 não assinado, usando o nonce, o preço do gas e a estimativa de gas que lê da cadeia. A carteira assina uma mensagem legível — ela aparece como *Rome authorization* seguida por um hash da chamada — o que prova que a chave Solana autoriza exatamente este payload EVM. Este é o primeiro prompt, e o proxy não comporá a chamada sem ele.
3. **Compor.** O app envia o payload e essa assinatura ao proxy. O proxy verifica a assinatura, emula a chamada para descobrir quais contas Solana ela toca e quais são graváveis, e retorna uma única transação Solana v1. O app verifica a mensagem retornada antes de pedir à carteira que a assine.
4. **Assinar e enviar.** A carteira assina a própria transação: o segundo prompt, uma assinatura diferente sobre uma string de bytes diferente. O app envia a transação assinada diretamente para um RPC Solana; o usuário paga a taxa Solana em SOL com sua própria carteira.
5. **Confirmar.** A transação é confirmada na Solana; a visão EVM acompanha um instante depois, então o app espera o nonce do endereço sintético avançar antes de enviar a próxima chamada.

**A carteira precisa assinar transações Solana v1.** O fluxo falha de forma fechada sem isso: uma carteira que não consegue assinar uma transação v1 interrompe a chamada com um erro, e o app nunca faz fallback para um formato de transação mais antigo. A Solflare assina v1 na devnet hoje; a Phantom ainda não.

### Antes da chamada: caixa e a concessão única

Duas coisas podem vir antes de uma chamada no fluxo Solana, e cada uma aparece como sua própria etapa com seus próprios prompts:

* **Movendo caixa para dentro.** Uma chamada que gasta wUSDC o puxa do endereço sintético, que não mantém saldo em repouso. Se o sintético tiver menos do que a chamada precisa, o app primeiro transfere a diferença da própria conta de token USDC da carteira para a do sintético. Esta é uma única transação Solana assinada com um prompt, não uma chamada EVM: uma criação idempotente da conta de token do sintético, seguida pela instrução activate-token-account do programa Rome, que move os tokens sem executar a EVM. Ela é pulada quando o sintético já tem o suficiente.
* **A concessão única do wrapper.** wUSDC é o wrapper de um token SPL, e um wrapper move os tokens de um usuário como o delegado SPL desse usuário. Na primeira vez que o endereço sintético de uma carteira gasta wUSDC, a concessão ainda não está em vigor, e o app coloca um **Permitir transferências de wUSDC** passo à frente do restante. É uma chamada como qualquer outra (dois prompts), uma vez por carteira. Veja [Concessão única por carteira](https://docs.rome.builders/pt-br/conceitos-principais/token-interop.md#one-time-grant-per-wallet).

Uma compra a partir de uma carteira Solana recém-criada é, portanto, uma sequência curta: mover caixa para dentro, permitir transferências de wUSDC, aprovar a vitrine, comprar.

### Chamadas grandes demais para uma única transação

Uma transação atômica na Solana tem limites fixos: cerca de 1,4 milhão de unidades de computação, 64 contas e 4 KB na rede (veja [Restrições](https://docs.rome.builders/pt-br/conceitos-principais/constraints.md)). O Bloom sempre tenta primeiro a transação direta, assinada pela carteira. Só quando o proxy recusa a chamada porque ela não cabe em uma única transação é que o app a entrega ao proxy para **encaminhar**, e nunca antes:

* **Um prompt para essa chamada.** O relay reaproveita a mensagem de autorização que a carteira já assinou para a tentativa recusada, então não há segundo prompt idêntico nem transação para assinar. O proxy compõe a chamada, a submete à Solana (em quantas transações forem necessárias) e paga as taxas da Solana por conta própria.
* **O gas de Rome vem do saldo do sintético.** Uma chamada encaminhada é paga no gas nativo da cadeia, em wei, a partir do endereço sintético. Se esse saldo não for suficiente para o custo da chamada, o app primeiro o completa com fundos da carteira, em unidades inteiras de 10^12 wei: mais um prompt, normalmente uma vez por carteira, como a concessão.
* **O hash é um hash de transação Rome.** O resultado de uma chamada encaminhada é o hash da transação EVM do proxy, não uma assinatura Solana, então ele não abrirá em um explorador Solana; procure-o no explorador próprio da cadeia.

O relay se aplica a qualquer chamada que o proxy reporte como grande demais para uma única transação, o que em Credit pode incluir as ações de mercado maiores. A maioria das chamadas, incluindo uma transferência simples e uma aprovação, cabe em uma única transação e nunca segue esse caminho. A mecânica das chamadas encaminhadas e seus limites está 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).

### Prompts por etapa

| Etapa                                                                      | Prompts da carteira                                            |
| -------------------------------------------------------------------------- | -------------------------------------------------------------- |
| Mover caixa para dentro (apenas se houver falta)                           | 1                                                              |
| Permitir transferências de wUSDC (uma vez por carteira)                    | 2                                                              |
| Uma chamada que cabe em uma única transação (aprovar, comprar, transferir) | 2: a mensagem de autorização, depois a transação               |
| Uma chamada que precisa ser encaminhada                                    | 1, mais 1 para a recarga única de gas se o saldo estiver baixo |

Na página do ativo Invest, uma carteira Solana passa por caixa para dentro, concessão, aprovação e compra em uma única execução após pressionar Buy, e o botão informa "dois prompts da carteira" enquanto cada etapa assina. As etapas nomeadas ("Transferindo seu caixa") e as contagens de prompts iniciais são mostradas em Trade e Credit. Uma carteira EVM também recebe um passo único *Permitir transferências de wUSDC* no painel de compra.

### Computação medida, do fluxo anterior

Antes da migração para transações v1, o fluxo montava sua própria transação e mediu estes números na devnet de Rome, faixas observadas em duas cadeias. Eles não foram medidos novamente na transação v1 que o proxy compõe agora, então leia-os como ordem de grandeza, não como orçamento:

| Fluxo da faixa Solana                                                               | CU         |
| ----------------------------------------------------------------------------------- | ---------- |
| Transferência de RWA com gate                                                       | \~339–381K |
| Aprovação de wUSDC                                                                  | \~189–191K |
| Compra na vitrine (aprovar + comprar, duas transações)                              | \~730–796K |
| Varredura da perna de caixa para a própria conta de token da carteira               | \~42–54K   |
| Transferência simples de valor                                                      | \~47K      |
| `TestApprover.approve` — admissão à lista de permissões, **assinada pela carteira** | 220,794    |

O limite de computação por transação da Solana é 1,4M CU. Meça sua própria chamada a partir do `meta.computeUnitsConsumed` (`getTransaction` da transação Solana em um RPC Solana; o recibo EVM da cadeia não tem esse campo) em vez de assumir um destes.

## Custódia: por que o RWA permanece no sintético

A questão de design que todo ativo permissionado precisa responder: *o token pode vazar para fora do perímetro de conformidade?* No fluxo Solana a resposta é estrutural, não de política:

* **O RWA reside no estado EVM.** Seus saldos são armazenamento dentro das contas do programa EVM de Rome. Não há **nenhum mint SPL** dele, nenhuma representação de conta de token, nada nativo da Solana para mover. (Isso é intencional — uma versão embrulhada/espelhada seria a porta de escape.)
* **A infraestrutura do lado Solana não consegue tocá-lo.** As pernas de movimentação de ativos do fluxo (`create_ata`, transferências SPL, varreduras) operam sobre contas de token SPL; os saldos de armazenamento EVM não têm tal conta. Não há instrução que mova um saldo EVM para uma conta de token Solana.
* **Apenas a assinatura Solana do proprietário aciona o sintético**, e cada movimento que ele pode expressar é uma chamada ao contrato do token — que executa o gate da lista de permissões — então uma transferência para um endereço não incluído na lista de permissões reverte de forma idêntica, seja assinada por uma chave EVM ou por uma chave Solana.
* **A perna de caixa é a exceção deliberada.** wUSDC (rendimento, proventos de venda) é lastreado em SPL e *deve* fazer ida e volta: a perna de saída (`transfer_spl`) o move do sintético para a conta de token associada própria da carteira, verificado de ponta a ponta. O ativo permanece no perímetro; o caixa flui livremente.

Duas consequências práticas, ditas de forma clara: uma interface de carteira Solana não exibirá a posse de RWA (não há token SPL para listar) — o app Bloom é a superfície de posições; e uma chave Solana perdida é recuperada pelo processo do emissor ([COMPLIANCE.md](https://docs.rome.builders/pt-br/apps-na-rome/bloom/compliance.md#issuer-powers-transfer-agent-shaped)), não movendo o ativo fora da banda — que é exatamente a propriedade que um ativo permissionado quer.


---

# 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/apps-na-rome/bloom/lanes.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.
