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

# Inicio rápido

Despliega tu primer contrato Solidity en Rome en menos de 5 minutos.

Despliega tu primer contrato Solidity en Rome en menos de 5 minutos. Esta guía está dirigida a [**Hadrian**](/es/redes/hadrian.md), la cadena de testnet pública. [Rubicon](/es/redes/rubicon.md) es la cadena de mainnet, donde el gas es USDC real; prueba todo primero en una cadena de pruebas.

## Requisitos previos

* [Node.js](https://nodejs.org/) v22.13+
* [MetaMask](https://metamask.io/) extensión del navegador
* Una billetera de Solana configurada en **Devnet**, solo si financias desde Solana (paso 2). Llamar contratos desde una billetera de Solana requiere una que firme transacciones Solana v1, lo cual se cubre en [Abre tu contrato a usuarios de Solana](/es/guias-para-desarrolladores/open-to-solana-users.md).

## 1. Añade Hadrian a MetaMask

Añádelo manualmente (Configuración → Redes → Añadir red):

| Campo                 | Valor                                           |
| --------------------- | ----------------------------------------------- |
| Nombre de la red      | Rome Hadrian                                    |
| URL de RPC            | `https://hadrian.testnet.romeprotocol.xyz/`     |
| ID de cadena          | `200010`                                        |
| Símbolo de la moneda  | `USDC`                                          |
| Explorador de bloques | `https://via-hadrian.testnet.romeprotocol.xyz/` |

## 2. Financia tu billetera

El gas se paga en el token de gas de la cadena, que en Hadrian es USDC. En Hadrian está respaldado por el USDC de Solana Devnet de Circle (mint `4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU`), así que el SOL de devnet no es gas. No hay faucet de Rome. Hay dos maneras de obtener USDC en Hadrian:

**Desde Solana** — obtén USDC de Solana Devnet desde el [faucet de Circle](https://faucet.circle.com/) (elige Solana Devnet) y un poco de SOL de devnet para las comisiones de Solana desde el [faucet de Solana](https://faucet.solana.com/), con tu billetera de Solana configurada en Devnet. Luego usa el [Rome Bridge](/es/apps-en-rome/bridge-api.md) con Hadrian como destino y su ruta de Solana, con la dirección de tu billetera EVM como destinatario; el puente le pide a esa billetera EVM que firme una transacción de reclamación en Hadrian, lo que convierte el USDC en gas.

**Mediante un puente desde una cadena EVM** — acuña USDC de prueba en Ethereum Sepolia desde el [faucet de Circle](https://faucet.circle.com/), luego tráelo a Rome con el [Rome Bridge](/es/apps-en-rome/bridge-api.md) (CCTP). Necesitarás un poco de ETH de Sepolia para la transacción del lado de origen — mira [Faucets](/es/recursos/faucets.md) para cada faucet.

**¿Cuánto?** Una escritura en Rome cuesta más de lo que sugiere la intuición de Ethereum, porque la mayor parte de su gas paga por crear cuentas de Solana: un destinatario que nunca se ha usado, una nueva cuenta de token, un contrato desplegado. Usa `eth_estimateGas`, que es lo que hacen las herramientas estándar, y nunca codifiques 21,000. La estimación incluye la creación de la cuenta, Rome cobra el gas que una transacción realmente usa (en mediciones en Hadrian eso nunca fue más que la estimación), y el `submitRomeTx` del SDK aumenta la estimación en 1.3x como margen, lo cual no cuesta nada porque solo se cobra el gas usado. Financia al menos **0.5 USDC de gas**; 1 USDC deja un margen cómodo. Los números en [Soporte de JSON-RPC](/es/referencia/json-rpc.md) muestran cuánto cuestan escrituras individuales.

Si un depósito del lado de Solana falla con una advertencia de "SOL insuficiente" a pesar de tener la billetera financiada, configura tu billetera de Solana en modo Testnet / Devnet (ver el [FAQ](/es/recursos/faq.md)).

## 3. Crea un proyecto Hardhat

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

Acepta los valores predeterminados cuando se te pida — Hardhat 3, el directorio actual y la plantilla TypeScript + Node Test Runner + viem — y deja que instale las dependencias. La plantilla incluye un ejemplo `Counter` contrato con pruebas; no interfieren con esta guía.

## 4. Configura Hardhat para Rome

Edita el `hardhat.config.ts` generado y añade las redes de Rome dentro de `defineConfig({ ... })`:

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

`configVariable("PRIVATE_KEY")` se resuelve desde el entorno, así que exporta tu clave privada de MetaMask:

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

(Para cualquier cosa más allá de una clave desechable, prefiere el almacén de claves cifrado que incluye la toolbox: `npx hardhat keystore set PRIVATE_KEY`.)

## 5. Escribe un contrato

Crea `contracts/HelloRome.sol`:

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

contract HelloRome {
    string public greeting = "¡Hola desde 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. Despliega

Crea `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 desplegado en:", hello.address);

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

  console.log("Contador:", (await hello.read.counter()).toString());
  console.log("Saludo:", await hello.read.greeting());
}

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

Despliega en Hadrian:

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

Salida esperada (tu dirección será diferente):

```
HelloRome desplegado en: 0x09c437e305eeb698e1776cff23ca16c1bb25aabd
Contador: 1
Saludo: ¡Hola desde Solana!
```

Abre la dirección desplegada en el [explorador](https://via-hadrian.testnet.romeprotocol.xyz/) para ver las instrucciones de Solana detrás de tu transacción. Tu contrato Solidity ahora se está ejecutando en Solana.

## Qué sigue

* [Desplegar Solidity](/es/guias-para-desarrolladores/deploy-solidity.md) — implementación de Hardhat y Foundry en profundidad
* [Llamar a Solana desde EVM](/es/guias-para-desarrolladores/call-solana-from-evm.md) — llama programas de Solana desde Solidity vía CPI
* [Arquitectura](/es/introduccion/architecture.md) — cómo Rome ejecuta EVM dentro de Solana

## Errores comunes

| Error                        | Causa                                                                                   | Solución                                                                                               |
| ---------------------------- | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `fondos insuficientes`       | No hay suficiente token de gas para el límite de gas multiplicado por el precio del gas | Financia al menos 0.5 USDC de gas (ver el paso 2) con el [Rome Bridge](/es/apps-en-rome/bridge-api.md) |
| `nonce demasiado bajo`       | Desajuste del nonce de la transacción                                                   | Restablece la cuenta (MetaMask → Configuración → Avanzado → Borrar actividad)                          |
| `la ejecución se revirtió`   | La ejecución del contrato falló                                                         | Revisa la lógica del contrato; usa `eth_call` para depurar                                             |
| Tiempo de espera de conexión | RPC inaccesible                                                                         | Verifica la URL del 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/es/introduccion/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.