> 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/13-build-on-solgate.md).

# 13. Desenvolva na Solgate

Desenvolva na Solgate, a ponte e rota de mensagens entre Solana, Ethereum e as chains do AggLayer, entendendo o que atravessa a ponte, como as mensagens fluem, quanto custam e como migrar de Hadrian para Rubicon.

Rome transforma EVM e Solana em um único mercado. Solgate é a ponte e a rota de mensagens entre elas. Ela leva tokens de Solana para Ethereum e para as chains AggLayer, e tokens EVM para Solana. Também transporta mensagens entre contratos, e o contrato Rome que recebe uma mensagem pode chamar um programa Solana na mesma transação. Esta lição mostra o que atravessa a ponte, como uma mensagem flui, o que verificar em um contrato receptor e como desenvolver na Hadrian agora e publicar na Rubicon. [Lição 10](https://docs.rome.builders/pt-br/rome-academy/10-from-other-chains.md) aborda a Rome Bridge, que traz USDC. Solgate é a rota para outros tokens e para mensagens.

## O que você vai aprender

* Quais tokens atravessam a ponte em cada direção e como um token que ainda não tem mint em Solana passa a poder ser transferido pela ponte.
* O que significam Verified e Unverified e como os usuários adicionam um token à carteira.
* Como uma mensagem vai de Ethereum para Rome e depois para um programa Solana — e volta.
* Os tempos e custos medidos na Hadrian e na Sepolia.
* As regras que um contrato receptor deve seguir e para quais casos as mensagens não são adequadas.
* Por que usar Solgate e em que você confia em cada direção.
* Como começar na Hadrian e o que muda na Rubicon.

## Antes de começar

* Conclua [10. Trazer usuários e fundos de outras chains](https://docs.rome.builders/pt-br/rome-academy/10-from-other-chains.md). Você precisa entender o conceito de uma solicitação de resgate de ponte.
* Leia [5. Chamar Solana a partir de 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). Um contrato receptor que chama Solana usa o precompile CPI, e um token Solana na Rome é o próprio mint.
* Tenha uma carteira Hadrian com fundos, uma carteira EVM com ETH da Sepolia e uma carteira Solana com SOL da devnet. A etapa 7 lista os faucets.

## A lição

### Etapa 1. Saiba o que atravessa a ponte

Solgate transporta uma forma de cada token por chain: aquela registrada on-chain. Primeiro, escolha a direção.

**De Solana para Ethereum e as chains AggLayer**

| Token                                                                                                                                      | Atravessa a ponte?                                                                                        |
| ------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------- |
| SOL                                                                                                                                        | Sim, como "Wrapped SOL (Rome)"                                                                            |
| Tokens SPL clássicos, inclusive memecoins                                                                                                  | Sim. Na testnet, selecione ou cole o mint; o primeiro envio o lista                                       |
| Token-2022 cuja única funcionalidade adicional é o congelamento                                                                            | Na testnet. Ainda não na mainnet                                                                          |
| Token-2022 com taxa de transferência                                                                                                       | Não é transportado                                                                                        |
| Outros Token-2022 (hooks de transferência, delegado permanente)                                                                            | Permanece em Solana e na Rome, onde a EVM da Rome continua usando-o                                       |
| Mints não transferíveis, NFTs                                                                                                              | Não                                                                                                       |
| Tokens que outra ponte trouxe para Solana, quando a AggLayer chega à chain de origem (por exemplo, ETH transferido por uma ponte Wormhole) | Não é transferido pela ponte uma segunda vez. Transfira pela ponte o original a partir da chain de origem |
| USDC                                                                                                                                       | É transferido pelo CCTP da Circle, não pela Solgate                                                       |

**De Ethereum e das chains AggLayer para Solana**

| Token                                                                                       | Atravessa a ponte?                                                                               |
| ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| ETH                                                                                         | Sim, como "Ether (Rome)", com 9 casas decimais em Solana                                         |
| ERC-20 padrão                                                                               | Sim, como "\<name> (Rome)", um mint SPL clássico. Na testnet, a configuração não exige permissão |
| ERC-20 com taxa de transferência                                                            | Sim. A ponte registra o que recebeu                                                              |
| Tokens cujo emissor mantém sua própria rota para Solana (CCTP da Circle e similares)        | Use a rota do emissor                                                                            |
| Tokens permissionados (ERC-3643 e similares)                                                | Somente a rota do próprio emissor                                                                |
| Tokens com rebase                                                                           | Não. Faça a ponte do token encapsulado sem rebase                                                |
| Cópias criadas por outra ponte, quando a AggLayer alcançar a cadeia de origem desses tokens | Não fazer a ponte duas vezes                                                                     |

Regras que se aplicam a todos os tokens:

* A Solgate mantém uma forma de cada token por cadeia. As formas criadas por outras pontes permanecem separadas e nunca são mescladas.
* Todo token criado pela Rome recebe o nome "\<origin name> (Rome)" e mantém o símbolo do token de origem.
* A Solana mantém o suprimento em 64 bits, então tokens com mais de 9 casas decimais têm 9 casas na Solana. Os valores são transferidos em unidades inteiras da Solana. As frações menores que uma unidade ficam com a ponte como garantia.
* A mint Solana criada pela Rome não tem autoridade de congelamento. Sua única autoridade de emissão é o contrato do token na Rome.
* Na Rome, um token da Solana é a própria mint. O saldo de uma carteira na Rome é sua própria conta de token da Solana, sem uma segunda cópia encapsulada.
* No momento, a Solgate não transporta tokens criados em uma cadeia da Rome.

Um token que ainda não tem uma mint na Solana pode se tornar compatível com a ponte em algumas etapas assinadas. Na testnet, qualquer pessoa pode fazer isso usando uma carteira EVM ou Solana. Na mainnet, a Rome lista os tokens.

1. **Token criado em uma rede EVM.** Primeiro, envie-o para a Hadrian. A primeira reivindicação lá cria sua cópia na Rome. Em seguida, abra **Adicionar um token** e cole qualquer identificador: uma palavra, o endereço na cadeia de origem, o endereço na Rome ou uma mint da Solana.
2. **Assine as etapas numeradas.** Elas são a configuração, um logotipo opcional e a finalização. Uma carteira Solana paga somente em SOL e não precisa de gas da Rome, pois o relayer da Rome envia a finalização por ela. O cartão mostra o custo total antes da assinatura. A taxa de configuração da Hadrian é de 1 USDC ou 0.06 SOL, além das taxas da rede.
3. **Token criado na Solana.** Selecione ou cole a mint na Bridge. O primeiro envio a adiciona à ponte e a lista, como etapas únicas.

O logotipo é opcional, gratuito e exige mais uma assinatura. O arquivo deve ter menos de 256 KB e estar no formato PNG, pois as carteiras Solana podem não exibir SVG. Você pode adicioná-lo mais tarde em My tokens.

### Etapa 2. Explique aos usuários o que é verificado e permita que adicionem o token

Os tokens verificados estão na lista de verificados da Rome. Qualquer outro token configurado pelo fluxo aberto aparece como **Não verificado**. A aba **Tokens** lista todos os tokens. Os usuários podem pesquisar por nome, símbolo ou qualquer endereço. Cada linha mostra o logotipo, a etiqueta e a rota, e pode ser expandida para exibir os endereços por cadeia, com opções para copiar e abrir no explorador, **Adicionar à carteira** e **Fazer ponte**. A opção "Somente verificados" fica ativada por padrão.

Critérios para ser verificado: um contrato legítimo na cadeia de origem, confirmado por uma listagem na CoinGecko ou na CoinMarketCap, ou pelo site do emissor; um logotipo; e nenhuma tentativa de se passar por um token verificado.

As carteiras e os exploradores fazem suas próprias verificações. Na mainnet da Solana, a ordem habitual é uma listagem na CoinGecko ou na CoinMarketCap, seguida pela atualização de reputação do Solscan e pela verificação da Jupiter. A Solflare define sua própria etiqueta automaticamente.

As carteiras EVM oferecem a opção de um clique **Adicionar à carteira** (EIP-747) nas linhas de Tokens, em My tokens e na tela de recebimento. As carteiras Solana leem o nome, o símbolo e o logotipo do token nos metadados on-chain.

### Etapa 3. Acompanhe uma mensagem

Qualquer contrato na Ethereum ou em uma cadeia da AggLayer pode enviar uma mensagem para um contrato na Rome, e vice-versa. O estado da Rome fica na Solana, então o contrato receptor na Rome pode chamar qualquer programa da Solana na mesma transação, assinada por seu próprio PDA — uma conta Solana que só aquele contrato pode assinar. Um programa da Solana pode enviar uma mensagem pela Rome da mesma forma.

Você precisa de mensagens quando o agente é um contrato (uma DAO, um executor de governança, um cofre, um escrow ou um Safe) ou quando a Solana precisa agir em uma cadeia EVM. Quem tem uma carteira EVM não precisa disso, pois o mesmo endereço funciona diretamente na Rome.

```
Cadeia Ethereum / AggLayer               Rome (EVM, estado na Solana)                  Solana
remetente ─ bridgeMessage(rome, rcvr, …, data) ─► o comitê da Rome publica a raiz de saída
                                          qualquer pessoa: claimMessage(proof, data)
                                          └► rcvr.onMessageReceived(origin, net, data)
                                               └► CPI opcional via 0xFF..08,
                                                  assinado pelo PDA do receptor ──────► qualquer programa

Programa da Solana ─ CPI no programa EVM da Rome, assinado pelo próprio PDA ─► bridgeMessage(dest, rcvr, data)
                                          O certificado de Rome é finalizado na Ethereum ─► qualquer pessoa pode reivindicar no destino
```

Na entrada, o remetente chama `bridgeMessage`. O comitê de Rome publica a raiz de saída da Ethereum em Rome. Em seguida, qualquer pessoa pode chamar `claimMessage` com a prova, e a bridge chama `onMessageReceived` no seu receptor. Na saída, um programa da Solana chama o programa EVM de Rome, que chama `bridgeMessage`. O certificado de Rome é finalizado na Ethereum, e qualquer pessoa reivindica no destino.

### Etapa 4. Leia os tempos medidos

Esses percursos foram executados em Hadrian e Sepolia.

| Percurso                                                                | Resultado                                                                                        | Tempo até ficar disponível para reivindicação | Custo em Hadrian                                                |
| ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | --------------------------------------------- | --------------------------------------------------------------- |
| Contrato da Sepolia → contrato de Rome                                  | Entregue                                                                                         | 133–158 s                                     | $0.096 para um novo receptor, $0.0007 depois                    |
| Sepolia → contrato de Rome → programa Memo da Solana, uma reivindicação | O Memo foi executado, e a PDA do receptor assinou                                                | 158 s                                         | $0.096 para um novo receptor                                    |
| Valor em ETH com uma mensagem para Rome                                 | Chega como um saldo comum de ETH encapsulado                                                     | 396 s (durante um pico de testes)             | $0.19                                                           |
| Token e mensagem em uma única transação na Sepolia                      | 5 de 5 entregues, token reivindicado primeiro                                                    | Não registrado                                | $0.175 + $0.119                                                 |
| O receptor recusa e depois aceita                                       | A simulação da API recusou a reivindicação, então nada foi enviado; ela foi concluída mais tarde | 412 s                                         | $0.0007 pela reivindicação aceita                               |
| Contrato de Rome → contrato da Sepolia                                  | Entregue e reivindicado                                                                          | 317 s                                         | $0.0007 para enviar; 446.636 de gas para reivindicar na Sepolia |
| Programa da Solana → Rome → saída                                       | Enviado em uma única transação da Solana; ainda não reivindicado na Sepolia                      | n/a                                           | 5.000 lamports + uma tarifa de Rome (não registrada)            |

Uma chamada bridgeMessage da Sepolia `bridgeMessage` com uma atualização forçada da raiz de saída consumiu de 395 mil a 400 mil gas. O gas da cadeia de origem é adicional aos custos de Hadrian acima.

Ainda não executados: mainnet, mensagens de L2 da AggLayer, uma carteira Solana como remetente, valor enviado para fora de Rome, valor com uma chamada da Solana, um receptor de governança realista e uma reivindicação iterativa.

### Etapa 5. Escreva um receptor seguro

* **Verifique o chamador e a origem.** `msg.sender` deve ser a bridge. `(originNetwork, originAddress)` deve ser o remetente em que você confia.
* **A execução exatamente uma vez é sua responsabilidade.** Uma reivindicação revertida continua disponível e pode ser tentada novamente, e a função de remoção de raízes de saída da bridge pode desfazer uma reivindicação. Mantenha seu próprio nonce.
* **Nenhuma reivindicação é feita automaticamente.** Seu app executa um claimer, ou o usuário faz a reivindicação. O claimer paga o gas do destinatário.
* **O valor que entra** chega como ETH encapsulado na Rome. **O valor que sai** é enviado apenas como ETH encapsulado (`bridgeMessageWETH`, em múltiplos de 1e9 wei), e esse caminho ainda não foi executado. O USDC usado para gas na Rome é transferido via CCTP, nunca pela AggLayer.
* **Um destinatário que chama a Solana recebe mensagens com valor zero.** Envie o valor como um token separado na mesma transação de origem e verifique no destinatário se ele chegou.
* **Meça seu consumo de computação.** Uma transação Solana permite cerca de 1,35 milhão de CU, e a estimativa de gas recusa valores acima de cerca de 1,25 milhão. A reivindicação com Memo-CPI usou 813.199 CU, deixando cerca de 0,44 a 0,54 milhão de CU para mais operações na Solana. Instruções maiores e quantidades maiores de contas ainda não foram medidas. Para operações mais pesadas, como uma troca em uma DEX ou um empréstimo, deixe a mensagem pendente e execute-a em uma segunda transação.
* **Mantenha as mensagens pequenas.** Uma reivindicação de uma mensagem de 16 bytes já gera cerca de 2,4 KB de dados de chamada.
* **Limite o que uma única mensagem da Rome pode liberar** no destino, com um limite ou um atraso. As mensagens de saída dependem exclusivamente dos signatários da Rome.

Mensagens não são adequadas para intents, liquidações rápidas, liquidações forçadas e feeds de preços. A transferência de Sepolia para Rome levou de 133 a 412 s, e uma rota L2 da AggLayer acrescenta o tempo de liquidação da própria cadeia. Também não são adequadas para operações pesadas na Solana dentro de uma única reivindicação nem para comprar tokens da Solana por meio de mensagens.

### Etapa 6. Entenda por que usar a Solgate e em que você está confiando

* **Ela é liquidada por meio da AggLayer da Polygon no Ethereum.** A Rome executa os contratos de bridge da AggLayer da Polygon sem modificações. Os certificados de saída da Rome são liquidados no Ethereum com a prova pessimista da AggLayer.
* **Ela não tem uma rede independente de validadores da bridge.** As partes envolvidas são o Ethereum, a AggLayer e as próprias chaves da Rome: um comitê 2 de 3 para entradas e os signatários da AggLayer da Rome para saídas.
* **É um único mercado.** Na Rome, um token da Solana é a mesma mint, não uma versão encapsulada dela. O saldo de uma carteira Solana na Rome fica em sua própria conta de token, e os contratos da Rome movimentam os mesmos tokens SPL.
* **É programável nos dois lados.** Uma mensagem EVM pode acionar um programa da Solana na transação em que é recebida. Um programa da Solana pode enviar uma mensagem para fora por meio da Rome.
* **Na testnet, a configuração não exige permissão, a partir de qualquer uma das carteiras.** Uma carteira Solana paga apenas SOL. Um token EVM se torna uma mint SPL clássica, sem autoridade de congelamento, cunhada apenas pelo contrato correspondente na Rome.
* **Há uma única representação por cadeia, sem encapsular uma versão já encapsulada.** A Rome identifica o que cria como "(Rome)", mantém os tokens com uma rota do emissor nessa rota e nunca faz uma nova bridge da cópia de outra bridge.
* **É uma única conexão com a AggLayer.** A mesma bridge unificada conecta ao Ethereum e a todas as cadeias da AggLayer listadas pelo app.
* **Compare os modelos de confiança.** Wormhole, LayerZero, CCIP e outros também conectam a Solana a cadeias EVM, cada um com seu próprio modelo de confiança. Compare a tabela abaixo com os modelos deles para decidir o que atende ao seu uso.

| Direção                                   | Em que você confia                                                                                                                                                                                                                         |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Ethereum → Rome                           | Ethereum, além de um comitê 2 de 3 que publica a raiz de saída do Ethereum na Rome. A Safe da Rome é proprietária dela, com um timelock                                                                                                    |
| Cadeia da AggLayer → Rome                 | O que foi descrito acima, além do certificado dessa cadeia liquidado no Ethereum                                                                                                                                                           |
| Rome → Ethereum ou uma cadeia da AggLayer | Os signatários da AggLayer da Rome. A prova pessimista limita cada token originado em outra cadeia ao valor que entrou. As mensagens e os tokens cuja origem na AggLayer é a Rome (SOL e outros tokens da Solana) dependem dos signatários |

### Etapa 7. Comece na Hadrian

O app é [solgate.testnet.romeprotocol.xyz](https://solgate.testnet.romeprotocol.xyz). Ele oferece Bridge, Add a token, Tokens, Claim, Activity e How it works. A lista atual de cadeias está em `GET /v1/chains`.

| Chain            | Rede AggLayer | ID da chain | Observações                                                                                                                    |
| ---------------- | ------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------ |
| Rome Hadrian     | 74            | 200010      | RPC `https://hadrian.testnet.romeprotocol.xyz/`, explorador `via-hadrian.testnet.romeprotocol.xyz`; estado na devnet da Solana |
| Ethereum Sepolia | 0             | 11155111    | Você solicita para si mesmo                                                                                                    |
| Katana Bokuto    | 37            | 737373      | Você solicita para si mesmo                                                                                                    |
| Billions Testnet | 32            | 6913        | Você solicita para si mesmo                                                                                                    |

Tokens de teste:

* **SOL da devnet da Solana.** faucet.solana.com. Uma carteira Solana não precisa de mais nada no Solgate.
* **Gas da Hadrian (USDC).** USDC de testnet do faucet da Circle (faucet.circle.com), transferido para seu endereço EVM como gas da Hadrian pela testnet da Rome Bridge (bridge-api.devnet.romeprotocol.xyz). Escolha uma testnet de origem listada pela Rome Bridge.
* **ETH da Sepolia.** Qualquer faucet público da Sepolia.
* **Tokens ERC-20 da Sepolia já verificados na Hadrian.** Tokens do faucet da Sepolia da Aave (DAI, USDT, WBTC, AAVE, EURS). Ou implante o seu próprio e configure-o.

Contratos e código para consultar:

* Bridge da Rome para a Hadrian: `0x5366e5864cb9dba587a706d8dd48cfdc40b961af` (rede 74). Bridge da Sepolia: `0x528e26b25a34a4A5d0dbDa1d57D318153d2ED582` (rede 0).
* Bridge da Polygon: `github.com/agglayer/agglayer-contracts`. Leia `AgglayerBridge.sol` e `AgglayerBridgeL2.sol` (`bridgeMessage`, `bridgeMessageWETH`, `claimMessage`) e a `IBridgeMessageReceiver` interface (`onMessageReceived`).
* Pré-compilações da Solana da Rome: `github.com/rome-protocol/rome-solidity`, `contracts/interface.sol`. A CPI para qualquer programa fica em `0xFF00…0008`, e a pré-compilação do token SPL fica em `0xff00…0005`.
* Endereços dos tokens por chain: `GET /v1/tokens`. Chains: `GET /v1/chains`. Chaves ativas: `GET /v1/switches`.

A API de mensagens está ativa no Hadrian.

| Chame                                        | Use                                                                                                                                                                                                      |
| -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `POST /v1/transfers` `{ networkId, txHash }` | Registre um envio que você minerou. `networkId` é a rede de onde ele saiu                                                                                                                                |
| `GET /v1/transfers?wallet=<address>`         | Seus registros                                                                                                                                                                                           |
| `GET /v1/transfers?tx=<hash>`                | Os registros de um envio, começando pelo token                                                                                                                                                           |
| `GET /v1/transfers/:id`                      | Um registro, com seu estágio: enviado → certificado → liquidado → pronto para resgate → resgatado → recebido                                                                                             |
| `GET /v1/transfers/:id/claim`                | A transação de resgate, simulada primeiro. Se o destinatário causaria uma reversão, a resposta será `message_would_fail`. A simulação não detecta um resgate que exceda o limite de computação da Solana |

### Etapa 8. Migre do Hadrian para o Rubicon

Rubicon é a blockchain de mainnet de Roma, com estado na mainnet da Solana e liquidação no AggLayer na mainnet do Ethereum. O Solgate está ativo no Rubicon em [solgate.romeprotocol.xyz](https://solgate.romeprotocol.xyz), com Ethereum, X Layer e Katana, e Roma lista os tokens disponíveis lá. O que você desenvolver no Hadrian pode ser migrado, com os IDs de rede e os endereços alterados. Meça novamente os tempos e custos na mainnet, pois os valores do Hadrian são de testnet. As instruções gerais de migração estão em [11. Publicar no Rubicon](https://docs.rome.builders/pt-br/rome-academy/11-ship-to-rubicon.md).

Na mainnet: envios nos dois sentidos e resgate na Solana para SOL, ETH, USDT, WBTC e OKB; resgate automático de depósitos de ETH do Ethereum para uma carteira EVM no Rubicon; as abas Tokens e Atividade, filtros de atividade e o cartão Chegou. O rastreamento de mensagens, a configuração de tokens sem permissão por qualquer uma das carteiras e um fluxo de listagem para tokens nativos da Solana estão disponíveis na testnet, mas ainda não na mainnet. Consulte [Usar o Solgate](https://docs.rome.builders/pt-br/apps-na-rome/solgate/using.md).

O que muda na mainnet:

* Gás real: USDC no Rubicon (traga-o pela Rome Bridge) e ETH no Ethereum.
* Os tempos de chegada acompanham a liquidação na mainnet: do Ethereum para a Solana, cerca de 120 segundos; da Solana para o Ethereum, cerca de 6 minutos; da Solana para a X Layer, cerca de 18 minutos; da Solana para a Katana, cerca de 4 minutos; e da Katana para a Solana, cerca de 65 minutos. [Usar o Solgate](https://docs.rome.builders/pt-br/apps-na-rome/solgate/using.md#times) os lista.
* Na mainnet, Phantom e Solflare acrescentam suas próprias instruções às transações.
* As carteiras e os exploradores fazem suas próprias verificações de tokens (etapa 2).
* O modelo de confiança é o mesmo, com o comitê e o conjunto de signatários da mainnet de Roma.

Desenvolva no Hadrian agora. Publique no Rubicon quando estiver pronto.

## Teste seus conhecimentos

Faça uma pequena operação de ida e volta no Hadrian.

1. Implante um ERC-20 de teste na Sepolia, transfira alguns tokens para o Hadrian e, em seguida, use **Adicionar um token** com uma carteira EVM. Leia o total do cartão antes de assinar.
2. Crie uma mint SPL na devnet da Solana, selecione-a na Bridge usando uma carteira Solana, envie-a para a Sepolia do Ethereum e faça o resgate lá.
3. Escreva um destinatário com as duas verificações e um nonce. Envie uma mensagem para ele a partir de um contrato na Sepolia e resgate-a com `GET /v1/transfers/:id/claim`.

Em seguida, responda:

* Quais são os dois valores que um destinatário verifica antes de confiar em uma mensagem?
* Um destinatário chama a Solana e também precisa receber valor. Como você o envia?
* Por que mensagens não são adequadas para uma liquidação?

<details>

<summary>Respostas</summary>

* `msg.sender`, que deve ser a ponte, e `(originNetwork, originAddress)`, que deve ser o remetente em que você confia.
* Envie a mensagem com valor zero. Envie o valor como um token separado na mesma transação de origem e verifique no destinatário se ele chegou.
* De Sepolia a Rome, o tempo foi de 133 a 412 s, e uma rota AggLayer L2 acrescenta o tempo de liquidação da própria cadeia. Uma liquidação não pode esperar tanto.

</details>

## Próximo

Ideias para desenvolver e onde cada uma começa estão em [Ideias para Solgate](https://docs.rome.builders/pt-br/apps-na-rome/solgate/ideas.md). As páginas de referência são [Desenvolvimento na Solgate](https://docs.rome.builders/pt-br/apps-na-rome/solgate/builders.md) para tokens e [Mensagens na Solgate](https://docs.rome.builders/pt-br/apps-na-rome/solgate/messaging.md) para mensagens.

[Voltar ao mapa do curso](https://docs.rome.builders/pt-br/rome-academy/academy.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/13-build-on-solgate.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.
