> 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/primeiros-passos-1/quickstart.md).

# Início rápido

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

Implante seu primeiro contrato Solidity no Rome em menos de 5 minutos. Este guia é voltado para [**Hadrian**](https://docs.rome.builders/pt-br/redes/hadrian.md), a chain da testnet pública. [Rubicon](https://docs.rome.builders/pt-br/redes/rubicon.md) é a chain da mainnet, onde o gas é USDC real; tente tudo primeiro em uma chain 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**, apenas se você financiar a partir da Solana (etapa 2). Chamar contratos de uma carteira Solana precisa de uma que assine transações Solana v1, o que é abordado em [Abra seu contrato para usuários Solana](https://docs.rome.builders/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 de 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. Financie sua carteira

O gas é pago no token de gas da chain, que é USDC no Hadrian. No Hadrian, ele é lastreado pelo USDC da Solana Devnet da Circle (mint `4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU`), então o SOL da devnet não é gas. Não existe faucet do Rome. Duas maneiras de obter USDC no Hadrian:

**Da Solana** — obtenha USDC da Solana Devnet no [faucet da Circle](https://faucet.circle.com/) (escolha Solana Devnet) e um pouco de SOL da devnet para taxas da Solana no [faucet da Solana](https://faucet.solana.com/), com sua carteira Solana configurada para Devnet. Em seguida, use o [Rome Bridge](https://docs.rome.builders/pt-br/apps-na-rome/bridge-api.md) com Hadrian como destino e sua 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 claim no Hadrian, que transforma o USDC em gas.

**Ao fazer bridge de uma chain EVM** — faça mint de USDC de teste no Ethereum Sepolia no [faucet da Circle](https://faucet.circle.com/), depois traga-o para Rome com o [Rome Bridge](https://docs.rome.builders/pt-br/apps-na-rome/bridge-api.md) (CCTP). Você vai precisar de um pouco de ETH de Sepolia para a transação do lado de origem — veja [Faucets](https://docs.rome.builders/pt-br/recursos/faucets.md) para cada faucet.

**Quanto?** Uma write no Rome custa mais do que a intuição sobre Ethereum sugere, porque a maior parte do gas 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. A estimativa inclui a criação de conta, o Rome cobra o gas que uma transação realmente usa (em medições no Hadrian isso nunca foi mais do que a estimativa), e o SDK's `submitRomeTx` aumenta a estimativa em 1,3x como margem, o que não custa nada porque apenas o gas usado é cobrado. Financie pelo menos **0,5 USDC de gas**; 1 USDC deixa uma folga confortável. Os números em [Suporte a JSON-RPC](https://docs.rome.builders/pt-br/referencia/json-rpc.md) mostram quanto custam escritas individuais.

Se um depósito do lado da Solana falhar com um aviso de "insufficient SOL" apesar de a carteira estar financiada, coloque sua carteira Solana em Testnet Mode / Devnet (veja o [FAQ](https://docs.rome.builders/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 que ele instale as dependências. O template vem com um exemplo `Counter` contrato com testes; eles não interferem neste guia.

## 4. Configure o Hardhat para Rome

Edite o `hardhat.config.ts` gerado e adicione as redes Rome dentro de `defineConfig({ ... })`:

```typescript
  redes: {
    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="0xSUA_CHAVE_PRIVADA"
```

(Para qualquer coisa além de uma chave descartável, prefira o keystore criptografado que vem com a toolbox: `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 para o 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 [explorer](https://via-hadrian.testnet.romeprotocol.xyz/) para ver sua transação e siga o link "Settled in" para a transação na Solana que a liquidou. Seu contrato Solidity agora está sendo executado na Solana.

## O que vem a seguir

* [Implante Solidity](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/deploy-solidity.md) — implantação em profundidade com Hardhat e Foundry
* [Chamar Solana a partir da EVM](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md) — chame programas Solana a partir de Solidity via CPI
* [Arquitetura](https://docs.rome.builders/pt-br/primeiros-passos-1/architecture.md) — como o Rome executa a EVM dentro da Solana

## Erros comuns

| Erro                    | Causa                                                                      | Correção                                                                                                                              |
| ----------------------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| `fundos insuficientes`  | Gas token insuficiente para o limite de gas multiplicado pelo preço do gas | Financie pelo menos 0,5 USDC de gas (veja a etapa 2) com o [Rome Bridge](https://docs.rome.builders/pt-br/apps-na-rome/bridge-api.md) |
| `nonce muito baixo`     | Incompatibilidade do 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/primeiros-passos-1/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.
