> 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/guias-para-desarrolladores/deploy-solidity.md).

# Deploy Solidity Contracts

Despliega contratos inteligentes Solidity en Solana con Hardhat o Foundry: configuración de la red Rome, cuentas financiadas y despliegue paso a paso.

Esta guía cubre el despliegue de contratos inteligentes de Solidity en Rome EVM usando Hardhat y Foundry.

## Requisitos previos

* Node.js v22.13+ (Hardhat) o Foundry instalados
* Una dirección de Rome EVM con fondos (ver [Inicio rápido](https://docs.rome.builders/es/primeros-pasos-1/quickstart.md))
* Tu clave privada exportada como variable de entorno

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

## Configuración de red

| Red                   | URL de RPC                                  | ID de cadena | Explorador                             |
| --------------------- | ------------------------------------------- | ------------ | -------------------------------------- |
| Hadrian (testnet)     | `https://hadrian.testnet.romeprotocol.xyz/` | `200010`     | `via-hadrian.testnet.romeprotocol.xyz` |
| **Rubicon (mainnet)** | `https://rubicon.mainnet.romeprotocol.xyz/` | `7531`       | `via-rubicon.mainnet.romeprotocol.xyz` |

El gas es USDC en todas las redes. En Hadrian lo obtienes puenteando USDC de prueba o envolviéndolo desde una wallet de Solana devnet ([Faucets](https://docs.rome.builders/es/recursos/faucets.md)); en Rubicon, puenteando USDC desde Ethereum, Base, Arbitrum, Polygon, Avalanche, Monad u OP, o desde una wallet de Solana, con el [Rome Bridge](https://bridge-api.mainnet.romeprotocol.xyz/). Despliega en Rubicon con los mismos artefactos que probaste en Hadrian — solo cambian el chain id y las direcciones del wrapper.

## Hardhat

### Configuración

```bash
mkdir my-rome-project && cd my-rome-project
npx hardhat --init
```

Acepta los valores predeterminados (Hardhat 3, directorio actual, plantilla TypeScript + viem); las dependencias se instalan automáticamente.

### hardhat.config.ts

```typescript
import hardhatToolboxViemPlugin from "@nomicfoundation/hardhat-toolbox-viem";
import { configVariable, defineConfig } from "hardhat/config";

export default defineConfig({
  plugins: [hardhatToolboxViemPlugin],
  solidity: {
    profiles: {
      default: { version: "0.8.28" },
      production: {
        version: "0.8.28",
        settings: { optimizer: { enabled: true, runs: 200 } },
      },
    },
  },
  networks: {
    hadrian: {
      type: "http",
      chainType: "l1",
      chainId: 200010,
      url: "https://hadrian.testnet.romeprotocol.xyz/",
      accounts: [configVariable("PRIVATE_KEY")],
    },
    rubicon: {
      type: "http",
      chainType: "l1",
      chainId: 7531,
      url: "https://rubicon.mainnet.romeprotocol.xyz/",
      accounts: [configVariable("PRIVATE_KEY")],
    },
  },
});
```

`configVariable("PRIVATE_KEY")` se resuelve desde el entorno (o desde el almacén de claves cifrado — `npx hardhat keystore set PRIVATE_KEY`).

### Desplegar

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

### Verificar en el explorador de bloques

```bash
npx hardhat verify --network hadrian 0xCONTRACT_ADDRESS
```

Necesita la configuración del verificador de Sourcify de [Verificar contratos](https://docs.rome.builders/es/guias-para-desarrolladores/verify-contracts.md) en tu `hardhat.config.ts`.

## Foundry

### Configuración

```bash
forge init my-rome-project
cd my-rome-project
```

### Desplegar

```bash
# Red de pruebas
forge create --rpc-url https://hadrian.testnet.romeprotocol.xyz/ \
  --private-key $PRIVATE_KEY \
  src/Counter.sol:Counter
```

### Llamar al contrato desplegado

```bash
# Leer
cast call 0xCONTRACT_ADDRESS "number()" \
  --rpc-url https://hadrian.testnet.romeprotocol.xyz/

# Escribir
cast send 0xCONTRACT_ADDRESS "increment()" \
  --rpc-url https://hadrian.testnet.romeprotocol.xyz/ \
  --private-key $PRIVATE_KEY
```

## Usando el SDK de Solidity de Rome

Para contratos que interactúan con programas de Solana, usa las interfaces del [`rome-solidity`](https://github.com/rome-protocol/rome-solidity) repositorio público. Se instala desde GitHub, no desde npm:

```bash
# Hardhat / npm
npm install github:rome-protocol/rome-solidity

# Foundry
forge install rome-protocol/rome-solidity
# luego en foundry.toml, bajo [profile.default]:
# remappings = ["@rome-protocol/rome-solidity/=lib/rome-solidity/"]
```

Los contratos más allá de `interface.sol` y las interfaces de oráculo (por ejemplo, los wrappers ERC-20 y la factory) importan OpenZeppelin. Con npm viene incluido como dependencia. Con Foundry, ejecuta también `forge install OpenZeppelin/openzeppelin-contracts` y añade el remapping `@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/`.

Con npm, el paquete se instala como `@rome-protocol/rome-solidity`, así que la importación de abajo se resuelve desde `node_modules`. Con Foundry, el remapping hace que la misma importación se resuelva desde `lib/rome-solidity`.

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

import {ICrossProgramInvocation, IHelperProgram}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";

contract MyRomeContract {
    IHelperProgram constant Helper =
        IHelperProgram(0xFF00000000000000000000000000000000000009);
    ICrossProgramInvocation constant Cpi =
        ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);

    // Transfiere un token SPL desde el PDA del llamador
    function moveSpl(address to, uint64 tokens, bytes32 mint) external {
        Helper.transfer_spl(to, tokens, mint);
    }

    // Invoca cualquier programa de Solana mediante CPI
    function callSolanaProgram(
        bytes32 programId,
        ICrossProgramInvocation.AccountMeta[] calldata accounts,
        bytes calldata data
    ) external {
        Cpi.invoke(programId, accounts, data);
    }
}
```

## Trae un protocolo existente

Cualquier contrato de Solidity se despliega en Rome sin modificaciones — un contrato de cumplimiento normativo, un protocolo DeFi o una aplicación endurecida existente. Lo único que no está en tu contrato es la **autorización única del wrapper**: un usuario que mueve tokens envoltorio SPL (wUSDC y similares) a través de tu contrato tiene que concederle al wrapper de ese token el derecho de mover sus tokens una vez, antes del primer `transferFrom`. Sin eso, la transferencia revierte con el error SPL `0x4`. Comprueba `isEnabled(user)` en el wrapper y ver [Concesión única por billetera](https://docs.rome.builders/es/conceptos-basicos/token-interop.md#one-time-grant-per-wallet); tu frontend envía el permiso, tu contrato no cambia. Dos ejemplos en producción que puedes hacer fork y desplegar con el mismo flujo de Hardhat / Foundry de arriba:

* [**compound-on-rome-comet**](https://github.com/rome-protocol/compound-on-rome-comet) — Compound v3 canónico (Comet), Foundry estándar.
* [**rome-aave-v3**](https://github.com/rome-protocol/rome-aave-v3) — Aave v3 canónico.

Ambos obtienen ejecución de Solana y composabilidad CPI sin cambios en el contrato; sus usuarios hacen la autorización única del wrapper descrita arriba antes del primer depósito.

## Gas

Deja que tus herramientas estimen el gas (`eth_estimateGas`; Hardhat, `forge create` y `cast` todos lo hacen) y nunca codifiques de forma rígida `21000`. En Rome, la mayor parte del costo de una escritura es crear cuentas de Solana, como un contrato desplegado, una nueva cuenta de token o un destinatario que nunca se ha usado, y la estimación las incluye. Para una llamada que realiza CPIs de Solana, la estimación puede salir baja, así que deja un margen. Rome cobra el gas realmente usado. Medido en Hadrian, desplegar un contrato de 10 bytes estimó y consumió 1.147.921 gas, y una transferencia nativa a una dirección existente estimó 21.000 y consumió 10.001. Un contrato real cuesta más, así que estima tu propio despliegue. La [página JSON-RPC](https://docs.rome.builders/es/referencia/json-rpc.md#gas-is-solana-derived-estimate-dont-hardcode) tiene la tabla medida.

## Restricciones de despliegue

| Restricción                        | Límite              | Notas                                                                         |
| ---------------------------------- | ------------------- | ----------------------------------------------------------------------------- |
| Tamaño máximo del contrato         | 24 KB               | Igual que Ethereum (EIP-170, 24,576 bytes)                                    |
| Límite de tamaño de la transacción | 80 KB por holder    | Los despliegues grandes se dividen entre cuentas holder de forma transparente |
| Presupuesto de cómputo             | \~1.4M CU (atómico) | Usa el modo iterativo para contratos pesados                                  |
| Versión de Solidity                | 0.8.28 recomendado  | Las versiones anteriores funcionan, pero 0.8.28 coincide con el SDK           |

## Errores comunes

| Error                                                                | Causa                                                                                                           | Solución                                                                                                                                                                                                                                                                                                               |
| -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fondos insuficientes para gas`                                      | La dirección EVM no tiene token de gas                                                                          | Hadrian: puentea USDC de prueba con el [Rome Bridge](https://docs.rome.builders/es/apps-en-rome/bridge-api.md) (véase [Inicio rápido](https://docs.rome.builders/es/primeros-pasos-1/quickstart.md), paso 2); Rubicon: puentea USDC real con el [Rome Bridge en mainnet](https://bridge-api.mainnet.romeprotocol.xyz/) |
| `nonce demasiado bajo`                                               | Nonce obsoleto en la wallet                                                                                     | Restablece la cuenta de MetaMask o especifica el nonce manualmente                                                                                                                                                                                                                                                     |
| `ejecución revertida`                                                | La lógica del contrato falló                                                                                    | Depura con `eth_call` ni `forge test --fork-url`                                                                                                                                                                                                                                                                       |
| `ejecución revertida` con el error SPL `0x4` al mover tokens wrapper | El usuario no ha hecho la autorización única del wrapper                                                        | Comprueba `isEnabled(user)` en el wrapper y envía `approve_spl` una vez ([detalles](https://docs.rome.builders/es/conceptos-basicos/token-interop.md#one-time-grant-per-wallet))                                                                                                                                       |
| `transacción con precio demasiado bajo`                              | Precio del gas por debajo del mínimo                                                                            | Aumenta el precio del gas en la transacción                                                                                                                                                                                                                                                                            |
| Una transferencia o despliegue falla con un límite de gas fijo       | Un límite codificado de forma rígida, como `21000` está por debajo de lo que cuesta crear las cuentas de Solana | Elíminalo y usa `eth_estimateGas`                                                                                                                                                                                                                                                                                      |

## Qué sigue

* [Abre tu contrato a usuarios de Solana](https://docs.rome.builders/es/guias-para-desarrolladores/open-to-solana-users.md) — deja que los usuarios de wallets de Solana llamen a lo que acabas de desplegar
* [Llamar a Solana desde EVM](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md) — usa precompilaciones CPI para interactuar con programas de Solana
* [Verificar contratos](https://docs.rome.builders/es/guias-para-desarrolladores/verify-contracts.md) — publica tu código fuente en el explorador de bloques


---

# 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/guias-para-desarrolladores/deploy-solidity.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.
