> 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/from-home.md).

# Da chain de origem: acesse Rome a partir de outra chain

Permita que usuários de outra chain alcancem seu app Rome sem sair de casa — traga ativos para dentro, aja e depois os retire novamente.

Seus usuários não precisam mudar para Roma. A partir da sua cadeia de origem — uma L2 como Arbitrum ou Monad, ou Solana — eles trazem ativos, usam seu app Rome e retiram os ativos de volta. A ponte é on-chain e autorizada pela própria assinatura do usuário; você conecta seu app a ela por meio de uma única API.

## Como funciona

* **Entrada (origem → Rome):** na rota do USDC com token de gas sobre o CCTP, a `settle_inbound_bridge_v2` instrução do programa Rome credita o usuário, sob uma **EIP-712** `SettleAuthorization`, portanto não há um liquidante privilegiado. As outras rotas de entrada não usam essa instrução nem assinatura. O USDC embrulhado, ETH via Wormhole e SOL entram diretamente como o token embrulhado na conta do usuário. O USDC da Solana em uma cadeia cujo token de gas é USDC precisa de mais uma transação, assinada pelo usuário, para transformar o token embrulhado em gas. A cotação informa quais assinaturas uma rota precisa.
* **Saída (Rome → origem):** `RomeBridgeWithdraw` (em [`rome-solidity`](https://github.com/rome-protocol/rome-solidity)) queima o ativo em Rome. Depois, o usuário o reivindica na cadeia de origem com sua própria transação.
* **Transporte:** Circle **CCTP** para USDC e a **Wormhole** ponte de tokens para ETH. As cadeias de origem da Solana usam transferências SPL simples na entrada e uma retirada Rome na saída. Wormhole é a via de entrada apenas para ETH. Existe uma rota genérica via Wormhole apenas para a saída, e cada ativo nela precisa ser habilitado pelos operadores da Rome primeiro.
* **Orquestração:** o [`rome-bridge-api`](https://github.com/rome-protocol/rome-bridge-api) fora da cadeia cotará uma rota, verificará a transação da cadeia de origem e patrocinará a taxa de liquidação. Ele não mantém fundos nem chaves. Só pode disparar o que o usuário já assinou.

## Conecte isso

A API é pública na devnet em `https://bridge-api.devnet.romeprotocol.xyz`. `GET /v1/routes` lista todas as rotas ativas (ativo, via, direção, cadeia de origem, cadeia Rome, velocidades). As chamadas abaixo são as mesmas quatro que o SDK encapsula em `@rome-protocol/sdk/bridge` (`requestQuote`, `registerTransfer`, `getTransfer`, `reportStep`). A CLI executa todo o fluxo para você: `rome fund` e `rome bridge` para as transferências e `rome verify --path from-home` para uma ida e volta, como descrito na página [Rome CLI](https://docs.rome.builders/pt-br/produtos/rome-cli.md) .

### Traga ativos para dentro

1. **Cote a rota.** Envie a cadeia de origem do usuário, o ativo, o valor e os endereços. As cadeias entram como ids CAIP-2, como `eip155:84532`; `romeChainId` é a sua cadeia Rome. Os nomes antigos `ethereum` e `solana` ainda são aceitos, mas estão obsoletos, e a API marca essas respostas com um cabeçalho `Sunset` . Os formatos completos da requisição e da resposta estão na [referência da API](https://github.com/rome-protocol/rome-bridge-api/blob/main/docs/API.md).

   ```bash
   curl -X POST https://bridge-api.devnet.romeprotocol.xyz/v1/quote \\

     -H 'Content-Type: application/json' \\

     -d '{
       "asset": "USDC",
       "direction": "to-rome",
       "sourceChain": "eip155:84532",
       "romeChainId": "200010",
       "amount": "1000000",
       "sender": { "ethereum": "0xUSER" },
       "recipient": "0xUSER"
     }'
   ```

   Os valores são inteiros em unidade base como strings (`"1000000"` é 1 USDC). Os valores de ETH estão em wei e, na saída, precisam ser múltiplos de 10.000.000.000 wei (o wrapper tem 8 casas decimais); a API rejeita qualquer valor mais fino. A resposta lista as `etapas`. O usuário assina as transações de cada etapa marcada como `userSigns: true`, em ordem de etapas: transações EVM estão em `unsignedTxs`, instruções Solana em `unsignedTx`. Assine exatamente como retornado. As etapas sem nada para assinar são concluídas pelo patrocinador assim que Circle ou Wormhole atestarem a transferência. A reivindicação de saída é a exceção, descrita abaixo: o usuário a constrói.
2. **Peça ao usuário que assine.** Para uma cotação CCTP, isso é a aprovação de USDC e a queima na cadeia de origem. Se a cotação tiver uma entrada em `signatureRequests`, o usuário também assina essa `SettleAuthorization` EIP-712 `userSettleSig` assim que o hash da queima for conhecido; preencha o hash da queima e passe o resultado como
3. **Registre a transferência.** `POST /v1/transfers` com o `quoteId` e `step1TxHash`, o hash da última transação na primeira etapa (a queima), em até 15 minutos da cotação. Na rota de gas, adicione a assinatura de liquidação como `userSettleSig`. A API recusa um objeto de cotação completo. Ela verifica se a transação na cadeia de origem corresponde à cotação armazenada e retorna um transfer `id`.
4. **Faça polling** `GET /v1/transfers/{id}` a cada poucos segundos até `resultado` seja `concluído`, e trate `falhou` e `expirado`. O usuário então é financiado em Rome e pode usar seu app. Uma transferência concluída pode carregar uma nota de `degradação` com um `degradationReason`, então verifique-os antes de informar ao usuário que o saldo de gas ou de wrapper chegou.

As cadeias de origem da Solana seguem a mesma estrutura, com etapas diferentes. O usuário envia uma transferência SPL para a conta de token da sua conta Rome. SOL chega como SOL embrulhado após essa única transferência. Em uma cadeia cujo token de gas é USDC, como Hadrian, o USDC precisa de uma segunda etapa: uma transação Rome que o usuário assina e que transforma o wrapper que chegou em gas nativo. Qualquer outro token SPL passa pela rota `spl-solana-to-rome` que recebe a mint em `splAsset`.

### Retire os ativos

Fazer bridge para fora não é o fluxo de entrada executado ao contrário. Ele tem mais de uma assinatura, e o usuário o conclui na cadeia de origem. Cotar com `direction` definido como `from-rome`. `sourceChain` nomeia o lado não-Rome como um id CAIP-2, e a queima vai para essa cadeia. `destinationChainId` é opcional e deve concordar com ele quando você o enviar. O nome antigo `ethereum` ainda significa Ethereum Sepolia:

```bash
curl -X POST https://bridge-api.devnet.romeprotocol.xyz/v1/quote \\

  -H 'Content-Type: application/json' \\

  -d '{
    "asset": "USDC",
    "direction": "from-rome",
    "sourceChain": "eip155:84532",
    "destinationChainId": 84532,
    "romeChainId": "200010",
    "amount": "1000000",
    "sender": { "rome": "0xUSER" },
    "recipient": "0xUSER"
  }'
```

Para USDC via CCTP, a cotação retorna duas etapas, e o usuário assina ambas:

1. **Em Rome, duas transações em ordem.** A primeira concede `RomeBridgeWithdraw` direitos de delegado sobre o wUSDC do usuário na Solana (`approve_spl`). A concessão cobre exatamente o valor dessa queima, então a cotação a inclui sempre e o usuário a assina antes de cada queima. A segunda queima o wUSDC por meio de `RomeBridgeWithdraw`, o que inicia a transferência CCTP. Registre a transferência com o hash da queima. A queima gasta wUSDC, o token que a cotação nomeia como `burnToken`, e não o USDC nativo de gas. Os fundos que entraram como gas não são o que é queimado, então, para uma ida e volta, traga USDC com `intent: "wrapper"`.
2. **Na cadeia de destino, a reivindicação.** Faça polling `GET /v1/transfers/{id}` até a etapa 2 estar `pronta`. Ela então carrega a `mensagem` e `atestado`. O usuário chama `receiveMessage(message, attestation)` no transmissor de mensagens da Circle na cadeia de destino (a cotação informa o transmissor e o domínio CCTP). Nada é patrocinado aqui, então o usuário precisa de gas nessa cadeia. Informe o hash da reivindicação com `POST /v1/transfers/{id}/steps/2`.

ETH saindo de Rome via Wormhole não é oferecido hoje em Hadrian ou Rubicon. Hadrian lista ETH via Wormhole apenas em direção a Rome. Rubicon não lista nenhuma rota de ETH.

Fazer a retirada para um endereço Solana não tem etapa de reivindicação. USDC é uma única transação Rome que faz a retirada para a conta Solana do usuário. SOL é uma etapa Rome com três transações: a mesma concessão de delegado sobre wSOL, a criação opcional da conta de token wSOL do destinatário na Solana (pulada quando ela já existe) e a retirada por meio de `RomeBridgeWithdraw`.

**As transferências de saída não precisam de etapa de ativação.** Uma queima CCTP cria uma conta de mensagem na Solana, e essa conta precisa de aluguel. A própria conta Solana do contrato da ponte paga esse aluguel. Logo antes da chamada CPI, o contrato chama `swap_gas_to_lamports`: o pagador de taxas Solana da transação adianta os lamports, e o usuário é cobrado por eles em gas na mesma transação de queima. Uma carteira nova pode fazer sua primeira transferência de saída sem nenhuma configuração anterior. `RomeBridgeWithdraw` está na versão 13.0.0 em Hadrian e em Rubicon hoje. As cotações de saída não trazem etapa de ativação nem de recarga, então seu app não precisa verificar a conta do usuário antes da primeira cotação. As transferências de entrada também não precisam de ativação. A `rome` CLI (0.11.0) ainda tem sua própria verificação. `rome bridge --to` (sem `--dry-run`) lê os lamports da conta de autoridade externa do usuário na Solana. Se ela tiver menos de 15.000.000, o comando para e informa para executar `rome activate <chain>`, que paga 2 USDC em Hadrian por meio do contrato `SimpleActivator` . `rome verify --path from-home` faz a mesma verificação antes de começar. O contrato não precisa dessa ativação.

## Leia o código

* [appia](https://github.com/rome-protocol/appia) — um app from-home: os usuários trazem USDC da cadeia de origem e usam DeFi do lado Rome sem sair dela.
* [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api) — o orquestrador (cotar → verificar → patrocinar).

## O que vem a seguir

* [Obtendo financiamento](https://docs.rome.builders/pt-br/recursos/faucets.md) — o mesmo caminho de bridge financia uma carteira dev recém-criada.
* [Implante Solidity](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/deploy-solidity.md) — coloque seu app em Rome.


---

# 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/from-home.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.
