0Pricing
Blockchain Smart Contracts with Solidity · Lección

Interacción con contratos desplegados

Descubra cómo interactuar con sus smart contracts desplegados mediante pruebas de JavaScript y comandos de consola.

Interacción con contratos desplegados es una lección gratuita de Blockchain Smart Contracts with Solidity en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Blockchain Smart Contracts with Solidity, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Blockchain Smart Contracts with Solidity incluye 4 lecciones en total.

Why Interact with Contracts?

Después de desplegar tu contrato inteligente, comienza la verdadera diversión: ¡interactuar con él! Esto significa llamar a sus funciones, leer sus datos y enviar transacciones.

Interactuar es fundamental para:

  • Pruebas: Asegurarte de que tu contrato se comporte como se espera.
  • Interfaces de dApps: Permitir que los usuarios se conecten y utilicen tu contrato.
  • Automatización: Crear scripts que realicen acciones en la cadena de bloques (blockchain).

Your Interaction Toolkit

Al trabajar con Hardhat o Truffle, cuentas con herramientas poderosas para interactuar con contratos desplegados:

  • Hardhat Console / Truffle Console: Un entorno de línea de comandos interactivo para pruebas rápidas y depuración.
  • Pruebas en JavaScript: Scripts automatizados que despliegan (o se conectan a) contratos y verifican su comportamiento.
  • Scripts personalizados: Archivos JavaScript independientes para interacciones más complejas y repetibles.

Hoy nos centraremos en la consola y en las pruebas con JS.

Hardhat Console: The Sandbox

La consola de Hardhat proporciona una forma cómoda de interactuar con tus contratos y la cadena de bloques directamente desde tu terminal. Utiliza un entorno de ejecución de Hardhat (HRE) que ya tiene cargados ethers.js y los artefactos de tus contratos compilados.

Para iniciar la consola, abre tu terminal en el directorio de tu proyecto Hardhat y ejecuta:

npx hardhat console

Esto iniciará un entorno de JavaScript interactivo.

Connect to Your Contract

Antes de poder llamar a funciones, necesitas "conectarte" a tu contrato desplegado. Esto implica obtener su dirección y crear un objeto Contract de ethers.js que lo represente.

Así es como podrías hacerlo en un script de Hardhat (o directamente en la consola):

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

async function main() {
  // First, get the ContractFactory for your contract
  const Counter = await ethers.getContractFactory("Counter");

  // Replace with the actual address where your contract is deployed
  const deployedAddress = "0x5FbDB2315678afecb367f032d93F642f64180aa3";

  // Attach to the deployed contract using its address
  const counter = await Counter.attach(deployedAddress);

  console.log("Connected to Counter at:", counter.address);
}

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

Calling View Functions

Las funciones marcadas como view o pure no cambian el estado de la cadena de bloques. Su ejecución es gratuita y simplemente devuelven datos. Puedes llamarlas directamente desde la instancia de tu contrato.

Leamos el conteo actual de nuestro contrato Counter. Ten en cuenta que ethers.js devuelve objetos BigNumber para números grandes, por lo que a menudo usamos .toString() para mostrarlos.

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

async function main() {
  const Counter = await ethers.getContractFactory("Counter");
  const deployedAddress = "0x5FbDB2315678afecb367f032d93F642f64180aa3";
  const counter = await Counter.attach(deployedAddress);

  // Call the getCount view function
  const currentCount = await counter.getCount();
  console.log("Current count is:", currentCount.toString());
}

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

Sending Transactions

Para cambiar el estado de tu contrato (por ejemplo, actualizar una variable, transferir tokens), necesitas enviar una transacción. Estas llamadas consumen gas y requieren un firmante (tu cuenta).

Después de enviar una transacción, normalmente utilizas await para esperar su confirmación y asegurar que sea minada en la cadena de bloques. Incrementemos nuestro contador:

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

async function main() {
  const Counter = await ethers.getContractFactory("Counter");
  const deployedAddress = "0x5FbDB2315678afecb367f032d93F642f64180aa3";
  const counter = await Counter.attach(deployedAddress);

  console.log("Incrementing count...");
  const tx = await counter.increment();
  await tx.wait(); // Wait for the transaction to be mined

  const newCount = await counter.getCount();
  console.log("Count after increment:", newCount.toString());
}

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

Automated Interaction Tests

Aunque la consola es excelente para verificaciones rápidas, las pruebas automatizadas de JavaScript son esenciales para un desarrollo sólido. Te permiten:

  • Definir comportamientos esperados.
  • Ejecutar pruebas de forma rápida y repetida.
  • Detectar regresiones al realizar cambios.

Hardhat se integra a la perfección con marcos de prueba como Mocha y Chai, utilizando ethers.js para la interacción con contratos.

Writing an Interaction Test

Un archivo de prueba típico de Hardhat utiliza describe para los conjuntos de pruebas e it para las pruebas individuales. Dentro de un bloque it, te conectarás a tu contrato y luego llamarás a sus funciones, verificando los resultados.

Recuerda reemplazar deployedAddress con la dirección real de tu contrato en tu red de prueba.

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

describe("Counter Contract Interaction", function () {
  let counter;
  const deployedAddress = "0x5FbDB2315678afecb367f032d93F642f64180aa3"; // Your contract address

  before(async function () {
    const CounterFactory = await ethers.getContractFactory("Counter");
    counter = await CounterFactory.attach(deployedAddress);
  });

  it("should read the initial count correctly", async function () {
    const initialCount = await counter.getCount();
    expect(initialCount.toString()).to.equal("0");
  });

  it("should increment the count via transaction", async function () {
    const initialCount = await counter.getCount();
    await counter.increment();
    const finalCount = await counter.getCount();
    expect(finalCount.toString()).to.equal(initialCount.add(1).toString());
  });
});

Smart Interaction Tips

Ten en cuenta estos consejos para una interacción efectiva con contratos:

  • Verifica siempre las direcciones: Comprueba dos veces la dirección del contrato con la que estás interactuando.
  • Entiende el gas: Las transacciones que cambian el estado consumen gas. Estima los costos para despliegues en la red principal (mainnet).
  • Maneja los errores: Usa bloques try-catch para las transacciones, ya que pueden revertirse.
  • Usa eventos: Escucha los eventos del contrato para obtener datos estructurados sobre las transacciones.
  • Prueba exhaustivamente: Escribe pruebas integrales para todas las funciones críticas y casos extremos.

Quick Check: Interaction Types

Has aprendido sobre dos formas principales de interactuar con las funciones de los contratos inteligentes: leer el estado (funciones view/pure) y cambiar el estado (funciones de transacción).

¿Cuál de las siguientes afirmaciones sobre estas interacciones es VERDADERA?

Recap: Interacting with Contracts

¡Has aprendido con éxito cómo interactuar con tus contratos inteligentes desplegados!

  • Exploramos el uso de la consola de Hardhat para pruebas inmediatas e interactivas.
  • Viste cómo conectarte a una instancia de contrato desplegada.
  • Diferenciamos entre llamar a funciones `view` (gratuitas, de solo lectura) y enviar transacciones (cuestan gas, cambian el estado).
  • Finalmente, cubrimos la importancia de las pruebas automatizadas en JavaScript para una interacción confiable con los contratos.

¡A continuación, estás listo para explorar la gestión de estado y los patrones de almacenamiento en Solidity!

Preguntas frecuentes

¿La lección «Interacción con contratos desplegados» es gratis?

Sí — el texto completo de «Interacción con contratos desplegados» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Blockchain Smart Contracts with Solidity, actualiza a CoddyKit PRO. El curso de Blockchain Smart Contracts with Solidity incluye 4 lecciones en total.

¿Qué aprenderé en «Interacción con contratos desplegados»?

Descubra cómo interactuar con sus smart contracts desplegados mediante pruebas de JavaScript y comandos de consola. Practicas Blockchain Smart Contracts with Solidity con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Blockchain Smart Contracts with Solidity?

No se requiere experiencia previa. Blockchain Smart Contracts with Solidity en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Interacción con contratos desplegados»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Blockchain Smart Contracts with Solidity?

Sí. Cada lección de Blockchain Smart Contracts with Solidity incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Configuración de Hardhat o Truffle
  2. Compilación y despliegue de contratos
  3. Interacción con contratos desplegados
  4. Escritura y ejecución de pruebas de contratos
← Volver a Blockchain Smart Contracts with Solidity