> 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/introducao/quickstart.md).

# Início rápido

Implante seu primeiro contrato Solidity na Rome em menos de 5 minutos.

Implante seu primeiro contrato Solidity na Rome em menos de 5 minutos. Este guia é voltado para [**Hadrian**](/pt-br/redes/hadrian.md), a cadeia pública de testnet. [Rubicon](/pt-br/redes/rubicon.md) é a cadeia da mainnet, onde o gás é USDC real; teste tudo primeiro em uma cadeia de teste.

## Pré-requisitos

* [Node.js](https://nodejs.org/) v22.13+
* [MetaMask](https://metamask.io/) extensão do navegador
* Uma carteira Solana configurada para **Devnet**, somente se você adicionar fundos a partir da Solana (etapa 2). Chamar contratos a partir de uma carteira Solana exige uma que assine transações Solana v1, o que é abordado em [Abra seu contrato para usuários da Solana](/pt-br/guias-do-desenvolvedor/open-to-solana-users.md).

## 1. Adicione Hadrian ao MetaMask

Adicione manualmente (Configurações → Redes → Adicionar rede):

| Campo                | Valor                                           |
| -------------------- | ----------------------------------------------- |
| Nome da rede         | Rome Hadrian                                    |
| URL do RPC           | `https://hadrian.testnet.romeprotocol.xyz/`     |
| ID da cadeia         | `200010`                                        |
| Símbolo da moeda     | `USDC`                                          |
| Explorador de blocos | `https://via-hadrian.testnet.romeprotocol.xyz/` |

## 2. Adicione fundos à sua carteira

O gás é pago no token de gás da cadeia, que no Hadrian é USDC. No Hadrian, ele é lastreado no USDC Devnet da Solana da Circle (mint `4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU`), então SOL de devnet não é gás. Não há faucet da Rome. Duas maneiras de obter USDC no Hadrian:

**Da Solana** — obtenha USDC Devnet da Solana na [faucet da Circle](https://faucet.circle.com/) (escolha Solana Devnet) e um pouco de SOL de devnet para as taxas da Solana na [faucet da Solana](https://faucet.solana.com/), com sua carteira Solana configurada para Devnet. Em seguida, use a [Rome Bridge](/pt-br/apps-na-rome/bridge-api.md) com o Hadrian como destino e a rota Solana, com o endereço da sua carteira EVM como destinatário; a bridge pede que essa carteira EVM assine uma transação de reivindicação no Hadrian, o que converte o USDC em gás.

**Fazendo a ponte a partir de uma cadeia EVM** — faça mint de USDC de teste na Ethereum Sepolia na [faucet da Circle](https://faucet.circle.com/), em seguida, traga-o para a Rome com a [Rome Bridge](/pt-br/apps-na-rome/bridge-api.md)  (CCTP). Você precisará de um pouco de ETH de Sepolia para a transação do lado de origem — veja [Torneiras](/pt-br/recursos/faucets.md) para cada faucet.

**Quanto?** Uma escrita na Rome custa mais do que a intuição sobre Ethereum sugere, porque a maior parte do gás paga pela criação de contas Solana: um destinatário que nunca foi usado, uma nova conta de token, um contrato implantado. Use `eth_estimateGas`, o que as ferramentas padrão fazem, e nunca codifique 21.000 fixamente. A estimativa inclui a criação da conta; a Rome cobra o gás que uma transação realmente usa (nas medições em Hadrian, isso nunca foi mais do que a estimativa), e o SDK `submitRomeTx` adiciona uma margem de 1,3x à estimativa, o que não custa nada porque apenas o gás usado é cobrado. Adicione pelo menos **0,5 USDC de gás**; 1 USDC deixa uma folga confortável. Os números em [Suporte a JSON-RPC](/pt-br/referencia/json-rpc.md) mostram quanto custam escritas individuais.

Se um depósito no lado da Solana falhar com um aviso de "insufficient SOL" apesar de a carteira estar financiada, coloque sua carteira Solana no modo Testnet / Devnet (veja o [FAQ](/pt-br/recursos/faq.md)).

## 3. Crie um projeto Hardhat

```bash
mkdir rome-hello && cd rome-hello
npx hardhat --init
```

Aceite os padrões quando solicitado — Hardhat 3, o diretório atual e o template TypeScript + Node Test Runner + viem — e deixe-o instalar as dependências. O template vem com um exemplo `Contador` de contrato com testes; eles não interferem neste guia.

## 4. Configure o Hardhat para a Rome

Edite o `hardhat.config.ts` e adicione as redes da Rome em `defineConfig({ ... })`:

```typescript
  networks: {
    hadrian: {
      type: "http",
      chainType: "l1",
      chainId: 200010,
      url: "https://hadrian.testnet.romeprotocol.xyz/",
      accounts: [configVariable("PRIVATE_KEY")],
    },
  },
```

`configVariable("PRIVATE_KEY")` é resolvido a partir do ambiente, então exporte sua chave privada do MetaMask:

```bash
export PRIVATE_KEY="0xYOUR_PRIVATE_KEY"
```

(Para qualquer coisa além de uma chave descartável, prefira o keystore criptografado que acompanha a caixa de ferramentas: `npx hardhat keystore set PRIVATE_KEY`.)

## 5. Escreva um contrato

Crie `contracts/HelloRome.sol`:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

contract HelloRome {
    string public greeting = "Olá da Solana!";
    uint256 public counter;

    event Greeted(address indexed sender, uint256 count);

    function greet() external returns (string memory) {
        counter++;
        emit Greeted(msg.sender, counter);
        return greeting;
    }

    function setGreeting(string calldata _greeting) external {
        greeting = _greeting;
    }
}
```

## 6. Faça o deploy

Crie `scripts/deploy.ts`:

```typescript
import hardhat from "hardhat";

async function main() {
  const { viem } = await hardhat.network.connect();
  const publicClient = await viem.getPublicClient();

  const hello = await viem.deployContract("HelloRome");
  console.log("HelloRome implantado em:", hello.address);

  const hash = await hello.write.greet();
  await publicClient.waitForTransactionReceipt({ hash });

  console.log("Contador:", (await hello.read.counter()).toString());
  console.log("Saudação:", await hello.read.greeting());
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

Faça o deploy no Hadrian:

```bash
npx hardhat run scripts/deploy.ts --network hadrian
```

Saída esperada (seu endereço será diferente):

```
HelloRome implantado em: 0x09c437e305eeb698e1776cff23ca16c1bb25aabd
Contador: 1
Saudação: Olá da Solana!
```

Abra o endereço implantado no [explorador](https://via-hadrian.testnet.romeprotocol.xyz/) para ver as instruções da Solana por trás da sua transação. Seu contrato Solidity agora está sendo executado na Solana.

## O que Vem a Seguir

* [Implante em Solidity](/pt-br/guias-do-desenvolvedor/deploy-solidity.md) — deploy com Hardhat e Foundry em profundidade
* [Chamar Solana a partir da EVM](/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md) — chame programas da Solana a partir de Solidity via CPI
* [Arquitetura](/pt-br/introducao/architecture.md) — como a Rome executa a EVM dentro da Solana

## Erros comuns

| Erro                    | Causa                                                                              | Correção                                                                                                    |
| ----------------------- | ---------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `fundos insuficientes`  | Não há token de gás suficiente para o limite de gás multiplicado pelo preço do gás | Adicione pelo menos 0,5 USDC de gás (veja a etapa 2) com a [Rome Bridge](/pt-br/apps-na-rome/bridge-api.md) |
| `nonce muito baixo`     | Divergência no nonce da transação                                                  | Redefina a conta (MetaMask → Configurações → Avançado → Limpar atividade)                                   |
| `execução revertida`    | Falha na execução do contrato                                                      | Verifique a lógica do contrato; use `eth_call` para depurar                                                 |
| Tempo limite de conexão | RPC inacessível                                                                    | Verifique a URL do RPC                                                                                      |


---

# 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/introducao/quickstart.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.