tutoriales.com

Desplegando tu Primer Contrato Inteligente en Ethereum con Hardhat y Solidity 🚀

Este tutorial te guiará a través del emocionante proceso de desplegar tu primer contrato inteligente en la red de pruebas de Ethereum. Aprenderás a configurar tu entorno de desarrollo con Hardhat, escribir un contrato simple en Solidity y publicarlo en la blockchain, sentando las bases para tus futuros proyectos Web3.

Intermedio20 min de lectura39 views7 de marzo de 2026Reportar error

¡Bienvenido al fascinante mundo del desarrollo de contratos inteligentes! Si estás listo para llevar tus habilidades de programación al siguiente nivel y construir aplicaciones descentralizadas (dApps), este es tu punto de partida. En esta guía completa, te enseñaré cómo desplegar tu primer contrato inteligente en una red de pruebas de Ethereum, utilizando las poderosas herramientas Hardhat y Solidity.

El despliegue de un contrato inteligente es un hito crucial para cualquier desarrollador blockchain. Es el momento en que tu código cobra vida en la cadena de bloques, volviéndose inmutable y accesible para todos. ¡Prepárate para la acción! 🔥

🎯 ¿Qué Aprenderás en Este Tutorial?

Al finalizar este tutorial, serás capaz de:

  • Configurar un entorno de desarrollo Hardhat desde cero.
  • Escribir un contrato inteligente básico en Solidity.
  • Compilar y probar tu contrato localmente.
  • Desplegar tu contrato inteligente en una red de pruebas de Ethereum (por ejemplo, Sepolia).
  • Interactuar con tu contrato desplegado.
🔥 Importante: Este tutorial asume que tienes conocimientos básicos de JavaScript y la línea de comandos. No te preocupes si eres nuevo en Solidity, ¡iremos paso a paso!

🛠️ Herramientas Necesarias

Antes de sumergirnos en el código, asegúrate de tener instaladas las siguientes herramientas en tu sistema:

  • Node.js y npm/yarn: Para la gestión de paquetes JavaScript. Puedes descargarlos desde nodejs.org.
  • Un editor de código: Visual Studio Code es altamente recomendado, con la extensión de Solidity.
  • Una cuenta en Alchemy o Infura: Necesitarás un nodo RPC para conectarte a la red de pruebas. Ambos ofrecen planes gratuitos.
  • Metamask: Para gestionar tu billetera y obtener Ether de prueba.

Verificación de Instalación

Para verificar si Node.js y npm están instalados, abre tu terminal y ejecuta:

node -v
npm -v

Deberías ver las versiones instaladas.

📖 Paso 1: Configuración del Entorno de Desarrollo con Hardhat

Hardhat es un entorno de desarrollo para Ethereum que facilita la compilación, despliegue, prueba y depuración de contratos inteligentes. ¡Es una herramienta esencial!

1.1 Crear un Nuevo Proyecto

Primero, crea un nuevo directorio para tu proyecto y navega hacia él:

npm init -y
mkdir mi-primer-contrato
cd mi-primer-contrato
npm init -y

1.2 Instalar Hardhat

Ahora, instala Hardhat en tu proyecto:

npm install --save-dev hardhat

1.3 Inicializar un Proyecto Hardhat

Una vez instalado, inicializa un proyecto Hardhat. Te preguntará qué tipo de proyecto quieres crear. Selecciona la opción para crear un proyecto básico de JavaScript:

npx hardhat

Selecciona las siguientes opciones:

  • Create a basic sample project (Crear un proyecto de ejemplo básico)
  • Presiona Enter para aceptar la ruta predeterminada.
  • Yes (Sí) para instalar las dependencias (hardhat-waffle, ethereum-waffle, chai, @nomicfoundation/hardhat-ethers).

Esto creará la estructura de directorios básica de Hardhat, incluyendo contracts/, scripts/, test/ y hardhat.config.js.

📌 Nota: Si no tienes `npx` instalado, puedes instalarlo con `npm install -g npx`. Sin embargo, generalmente viene incluido con Node.js.

Estructura del Proyecto Hardhat

mi-primer-contrato/
├── contracts/          # Aquí irán tus contratos Solidity
│   └── Lock.sol        # Contrato de ejemplo de Hardhat
├── scripts/            # Scripts para desplegar y automatizar tareas
│   └── deploy.js       # Script de despliegue de ejemplo
├── test/               # Archivos de prueba para tus contratos
│   └── Lock.js         # Pruebas de ejemplo
├── hardhat.config.js   # Archivo de configuración de Hardhat
├── package.json
├── package-lock.json
└── README.md

✨ Paso 2: Creando Nuestro Primer Contrato Inteligente (Solidity)

Vamos a crear un contrato simple llamado HolaMundo.sol que almacena un mensaje y permite cambiarlo. Este es el equivalente blockchain del famoso "Hello World".

2.1 Crear el Archivo del Contrato

Dentro de la carpeta contracts/, crea un nuevo archivo llamado HolaMundo.sol.

touch contracts/HolaMundo.sol

2.2 Escribir el Código Solidity

Ahora, abre contracts/HolaMundo.sol y pega el siguiente código:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract HolaMundo {
    string public mensaje;

    constructor(string memory _mensajeInicial) {
        mensaje = _mensajeInicial;
    }

    function obtenerMensaje() public view returns (string memory) {
        return mensaje;
    }

    function establecerMensaje(string memory _nuevoMensaje) public {
        mensaje = _nuevoMensaje;
    }
}

Explicación del Contrato HolaMundo.sol

  • // SPDX-License-Identifier: MIT: Indica la licencia del código.
  • pragma solidity ^0.8.0;: Especifica la versión del compilador Solidity a usar.
  • contract HolaMundo { ... }: Define nuestro contrato inteligente.
  • string public mensaje;: Declara una variable de estado pública llamada mensaje de tipo string. public crea automáticamente una función getter.
  • constructor(string memory _mensajeInicial): Esta es una función especial que se ejecuta una sola vez cuando el contrato es desplegado. Inicializa la variable mensaje.
  • function obtenerMensaje() public view returns (string memory): Una función view que devuelve el valor actual de mensaje sin modificar el estado de la blockchain (y por lo tanto, no cuesta gas).
  • function establecerMensaje(string memory _nuevoMensaje) public: Una función que permite modificar el valor de mensaje. Esta función sí modifica el estado de la blockchain y, por lo tanto, cuesta gas ejecutarla.

⚙️ Paso 3: Compilar el Contrato

Antes de desplegar, debemos compilar el contrato para convertir el código Solidity en bytecode, que es lo que entiende la Ethereum Virtual Machine (EVM).

npx hardhat compile

Si todo va bien, verás una salida similar a esta:

Compiled 2 Solidity files successfully (evm version default).

Esto creará una nueva carpeta artifacts/ que contiene los archivos JSON compilados (.json y .dbg.json) para cada contrato. Estos archivos son cruciales porque contienen el bytecode y la ABI (Application Binary Interface) del contrato.

💡 Consejo: Es una buena práctica compilar tus contratos con frecuencia para detectar errores de sintaxis a tiempo.

🧪 Paso 4: Escribiendo Pruebas (Opcional, pero Recomendado)

Probar tus contratos es fundamental para asegurar su correcto funcionamiento y seguridad. Hardhat facilita esto.

4.1 Crear el Archivo de Prueba

Dentro de la carpeta test/, crea un nuevo archivo llamado HolaMundo.js.

touch test/HolaMundo.js

4.2 Escribir el Código de Prueba

Abre test/HolaMundo.js y pega el siguiente código:

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("HolaMundo", function () {
  let HolaMundo;
  let holaMundo;
  let owner;
  let addr1;

  beforeEach(async function () {
    // Obtiene una factory para el contrato HolaMundo
    HolaMundo = await ethers.getContractFactory("HolaMundo");
    // Obtiene las cuentas de prueba disponibles
    [owner, addr1] = await ethers.getSigners();
    // Despliega el contrato con un mensaje inicial
    holaMundo = await HolaMundo.deploy("¡Hola, Hardhat!");
    // Espera a que la transacción de despliegue se confirme
    await holaMundo.waitForDeployment();
  });

  it("Debería devolver el mensaje inicial", async function () {
    expect(await holaMundo.obtenerMensaje()).to.equal("¡Hola, Hardhat!");
  });

  it("Debería permitir cambiar el mensaje", async function () {
    const nuevoMensaje = "¡Hola, Blockchain!";
    await holaMundo.establecerMensaje(nuevoMensaje);
    expect(await holaMundo.obtenerMensaje()).to.equal(nuevoMensaje);
  });
});

4.3 Ejecutar las Pruebas

Desde la raíz de tu proyecto, ejecuta:

npx hardhat test

Si tus pruebas pasan, verás una salida similar a:

  HolaMundo
    ✔ Debería devolver el mensaje inicial (52ms)
    ✔ Debería permitir cambiar el mensaje (37ms)

  2 passing (294ms)

Esto confirma que tu contrato funciona como esperas localmente antes de desplegarlo en una red real.

⚠️ Advertencia: Las pruebas son esenciales. Nunca despliegues un contrato en una red pública sin antes haberlo probado exhaustivamente.

🌐 Paso 5: Preparando el Despliegue en la Red de Pruebas

Para desplegar en una red de pruebas, necesitamos varias cosas:

  1. Una URL de RPC: Proporcionada por servicios como Alchemy o Infura.
  2. Una clave privada: De una billetera con Ether de prueba (obtenido de un faucet).
  3. Configurar hardhat.config.js: Para que Hardhat sepa cómo conectarse a la red.

5.1 Obtener una URL de RPC (Alchemy/Infura)

  • Alchemy: Ve a alchemy.com, crea una cuenta gratuita y crea una nueva aplicación. Selecciona Ethereum como cadena y Sepolia como red. Copia la URL de HTTPS.
  • Infura: Similarmente, en infura.io, crea un proyecto Ethereum y selecciona la red Sepolia. Copia la URL de tu endpoint.

Guarda esta URL, la usaremos pronto.

5.2 Obtener Ether de Prueba y Clave Privada (MetaMask)

  1. Instala MetaMask: Si aún no lo tienes, instálalo como extensión de navegador.
  2. Cambia a la red Sepolia: En MetaMask, selecciona Red Sepolia.
  3. Obtén Ether de prueba: Ve a un faucet de Sepolia (por ejemplo, sepoliafaucet.com o busca "Sepolia Faucet"), pega la dirección de tu billetera MetaMask y solicita Ether. Necesitarás una pequeña cantidad para pagar las tarifas de gas del despliegue.
  4. Exporta tu Clave Privada: En MetaMask, haz clic en los tres puntos junto a tu cuenta, selecciona Detalles de la cuenta -> Exportar clave privada. Introduce tu contraseña y copia la clave. ¡Guárdala de forma segura! Nunca la compartas.

5.3 Configurar hardhat.config.js

Para evitar exponer nuestra clave privada directamente en el código, usaremos el paquete dotenv. Instálalo:

npm install --save-dev dotenv

Ahora, abre hardhat.config.js y modifícalo. Tu archivo debería verse similar a este:

require("@nomicfoundation/hardhat-ethers");
require("dotenv").config(); // Cargar variables de entorno

const SEPOLIA_RPC_URL = process.env.SEPOLIA_RPC_URL;
const PRIVATE_KEY = process.env.PRIVATE_KEY;

module.exports = {
  solidity: "0.8.19", // Asegúrate de que coincida con tu pragma
  networks: {
    sepolia: {
      url: SEPOLIA_RPC_URL || "",
      accounts: PRIVATE_KEY ? [PRIVATE_KEY] : [],
      chainId: 11155111, // ID de la red Sepolia
    },
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY, // Opcional, para verificar contratos
  },
};

5.4 Crear el Archivo .env

En la raíz de tu proyecto, crea un archivo llamado .env y añade tus variables de entorno. ¡Este archivo NO debe subirse a control de versiones (Git)! Añade .env a tu .gitignore.

touch .env

Contenido de .env:

SEPOLIA_RPC_URL="TU_URL_ALCHEMY_O_INFURA_AQUI"
PRIVATE_KEY="TU_CLAVE_PRIVADA_METAMASK_AQUI"
ETHERSCAN_API_KEY="TU_API_KEY_ETHERSCAN_AQUI" # Opcional
⚠️ Advertencia: Nunca uses claves privadas de cuentas con fondos reales en entornos de desarrollo o prueba. Siempre usa cuentas dedicadas con fondos de prueba.

🚀 Paso 6: Escribiendo el Script de Despliegue

Ahora vamos a modificar el script de despliegue por defecto de Hardhat para desplegar nuestro contrato HolaMundo.sol.

6.1 Modificar scripts/deploy.js

Abre scripts/deploy.js y reemplaza su contenido con el siguiente código:

const { ethers } = require("hardhat");

async function main() {
  const HolaMundo = await ethers.getContractFactory("HolaMundo");
  console.log("Desplegando HolaMundo...");

  // Aquí pasamos el argumento al constructor de nuestro contrato
  const holaMundo = await HolaMundo.deploy("¡Hola desde Sepolia!");

  // Espera a que el contrato esté completamente desplegado y la transacción confirmada
  await holaMundo.waitForDeployment();

  console.log(`Contrato HolaMundo desplegado en: ${await holaMundo.getAddress()}`);

  // Opcional: Verificar el contrato en Etherscan (si tienes API_KEY configurada)
  if (process.env.ETHERSCAN_API_KEY) {
    console.log("Verificando contrato en Etherscan...");
    try {
      await run("verify:verify", {
        address: await holaMundo.getAddress(),
        constructorArguments: ["¡Hola desde Sepolia!"],
      });
      console.log("Contrato verificado exitosamente en Etherscan.");
    } catch (error) {
      if (error.message.toLowerCase().includes("already verified")) {
        console.log("Contrato ya verificado.");
      } else {
        console.error("Error al verificar el contrato:", error);
      }
    }
  }
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

Explicación del Script de Despliegue

  • const HolaMundo = await ethers.getContractFactory("HolaMundo");: Obtiene una "factoría" para el contrato HolaMundo. Esta factoría es una abstracción que se utiliza para desplegar nuevas instancias del contrato.
  • const holaMundo = await HolaMundo.deploy("¡Hola desde Sepolia!");: Ejecuta el despliegue del contrato. Aquí es donde pasamos el argumento "¡Hola desde Sepolia!" al constructor de nuestro contrato HolaMundo.
  • await holaMundo.waitForDeployment();: Espera a que la transacción de despliegue sea minada y confirmada en la blockchain.
  • console.log(...): Imprime la dirección donde se desplegó el contrato. ¡Esta dirección es crucial!
  • run("verify:verify", {...}): Esta parte es opcional pero muy útil. Permite verificar tu contrato en Etherscan (o el explorador de bloques equivalente). Esto hace que el código fuente de tu contrato sea público y legible por cualquier persona, lo que aumenta la transparencia y la confianza.
💡 Consejo: Asegúrate de que el argumento pasado a `HolaMundo.deploy()` coincida con el tipo y orden de los parámetros del constructor de tu contrato Solidity.

✅ Paso 7: Desplegando el Contrato

¡Llegó el momento de la verdad! Ejecutaremos nuestro script de despliegue y veremos nuestro contrato cobrar vida en la red de pruebas de Sepolia.

npx hardhat run scripts/deploy.js --network sepolia

Si todo está configurado correctamente, verás una salida similar a esta:

Desplegando HolaMundo...
Contrato HolaMundo desplegado en: 0xAbc123... (Tu dirección real aquí)
Verificando contrato en Etherscan...
... (mensajes de Etherscan si la verificación es exitosa)

¡Felicidades! 🎉 Has desplegado tu primer contrato inteligente en la red de pruebas de Ethereum. Copia la dirección del contrato que se muestra en la terminal. La necesitarás para interactuar con él.

Importante: Verificación en Etherscan

La verificación del contrato en Etherscan es una buena práctica. Si la verificación automática no funciona, puedes hacerla manualmente en sepolia.etherscan.io/verifyContract usando el código fuente de tu contrato y los argumentos del constructor.

🤝 Paso 8: Interactuando con tu Contrato Desplegado

Ahora que tu contrato está en la blockchain, puedes interactuar con él. Vamos a usar un script simple para llamar a sus funciones.

8.1 Crear un Script de Interacción

En la carpeta scripts/, crea un nuevo archivo llamado interact.js.

touch scripts/interact.js

8.2 Escribir el Código de Interacción

Abre scripts/interact.js y pega el siguiente código. Asegúrate de reemplazar "TU_DIRECCION_DE_CONTRATO_AQUI" con la dirección real de tu contrato desplegado.

const { ethers } = require("hardhat");

async function main() {
  const contractAddress = "TU_DIRECCION_DE_CONTRATO_AQUI"; // ¡REEMPLAZA CON LA DIRECCIÓN DE TU CONTRATO!

  // Obtén la factoría del contrato (necesario para la ABI)
  const HolaMundo = await ethers.getContractFactory("HolaMundo");
  // Conéctate al contrato desplegado usando su dirección y la ABI
  const holaMundo = HolaMundo.attach(contractAddress);

  console.log("Interactuando con el contrato HolaMundo en:", await holaMundo.getAddress());

  // Obtener el mensaje actual
  let mensajeActual = await holaMundo.obtenerMensaje();
  console.log("Mensaje actual:", mensajeActual);

  // Establecer un nuevo mensaje
  const nuevoMensaje = "¡Hola desde la Interacción!";
  console.log("Estableciendo nuevo mensaje a:", nuevoMensaje);
  const tx = await holaMundo.establecerMensaje(nuevoMensaje);
  await tx.wait(); // Espera a que la transacción se mine
  console.log("Transacción de establecerMensaje confirmada.");

  // Obtener el mensaje actualizado
  let mensajeActualizado = await holaMundo.obtenerMensaje();
  console.log("Mensaje actualizado:", mensajeActualizado);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

8.3 Ejecutar el Script de Interacción

Ahora, ejecuta este script para interactuar con tu contrato desplegado:

npx hardhat run scripts/interact.js --network sepolia

Verás cómo el script obtiene el mensaje inicial, envía una transacción para cambiarlo y luego obtiene el nuevo mensaje. ¡Es tu código Solidity funcionando en la blockchain!

📌 Nota: Cada vez que ejecutas `establecerMensaje()`, se envía una transacción a la red Sepolia y se consume Ether de prueba como tarifa de gas.

📈 Resumen del Flujo de Despliegue

Este SVG ilustra el proceso completo de despliegue y prueba:

Entorno Hardhat Código Solidity Compilador Bytecode / ABI Scripts de Prueba Blockchain Local Script de Despliegue Red de Pruebas (Sepolia) Contrato Desplegado Interacción Cliente

Este diagrama muestra la progresión desde el desarrollo inicial hasta la interacción con el contrato desplegado en la blockchain.

💡 Siguientes Pasos y Mejores Prácticas

Has dado un gran paso al desplegar tu primer contrato. Pero el viaje apenas comienza. Aquí hay algunas cosas a considerar:

  • Seguridad: Los contratos inteligentes gestionan activos de valor. La seguridad es primordial. Aprende sobre vulnerabilidades comunes (reentrancy, integer overflow, etc.) y cómo prevenirlas.
  • Pruebas Avanzadas: Explora frameworks de prueba más robustos y técnicas como fuzzing.
  • Optimización de Gas: Escribir código eficiente en Solidity es crucial para minimizar los costos de transacción para los usuarios.
  • Integración Frontend: Aprende a conectar tu contrato inteligente con una interfaz de usuario web usando bibliotecas como Ethers.js o Web3.js.
  • Redes Principales (Mainnet): Una vez que te sientas seguro con tu contrato y pruebas, considera desplegar en la red principal de Ethereum. ¡Esto implica dinero real, así que extrema precauciones!
  • Estándares de Contratos: Investiga los estándares ERC (como ERC-20 para tokens, ERC-721 para NFTs) para construir contratos interoperables.
¿Qué pasa si mi contrato tiene errores?Si tu contrato tiene errores lógicos o de seguridad, una vez desplegado en la blockchain, es inmutable. Esto significa que **no se puede modificar**. La única forma de corregir errores es desplegar una nueva versión del contrato y, si es necesario, migrar los datos o los usuarios al nuevo contrato. De ahí la importancia de las pruebas exhaustivas antes del despliegue.
¿Por qué usamos una red de pruebas?Las redes de pruebas (como Sepolia, Goerli, Arbitrum Sepolia) son copias de la red principal de Ethereum que utilizan Ether de prueba sin valor real. Esto permite a los desarrolladores experimentar, probar y desplegar contratos inteligentes sin incurrir en costos reales ni arriesgar fondos. Una vez que el contrato es estable y seguro, se considera el despliegue en la red principal.
💡 Consejo: Mantente al día con las últimas novedades de Solidity y el ecosistema Ethereum. La tecnología blockchain evoluciona rápidamente.

Conclusión ✨

¡Has llegado al final de este tutorial! Has configurado tu entorno Hardhat, escrito un contrato Solidity, lo has probado y, lo más importante, ¡lo has desplegado en la red de pruebas de Ethereum! Esta es una habilidad fundamental para cualquier desarrollador Web3 y te abre la puerta a un mundo de posibilidades en la creación de dApps, NFTs, DeFi y mucho más.

Recuerda, la práctica hace al maestro. No dudes en experimentar con tu contrato HolaMundo, modificarlo, agregar nuevas funciones y desplegarlo una y otra vez. ¡Cada despliegue te acercará más a dominar el arte del desarrollo de contratos inteligentes!

¡Feliz codificación! 🚀

Comentarios (0)

Aún no hay comentarios. ¡Sé el primero!