DEV Community

Cover image for C贸mo crear tu propio smart contract con Solidity y Hardhat 馃敟馃殌
Josu茅 Andr茅s
Josu茅 Andr茅s

Posted on • Updated on

C贸mo crear tu propio smart contract con Solidity y Hardhat 馃敟馃殌

Introducci贸n

En esta oportunidad, vamos a explorar el potencial de los smart contracts de Ethereum mediante el uso de Solidity y Hardhat como nuestro entorno de desarrollo.
A trav茅s de la creaci贸n de una peque帽a aplicaci贸n, desplegaremos en las redes de prueba de Polygon, Avalanche para demostrar las capacidades que nos ofrece el ecosistema de blockchain. Al final del proceso, tendremos una mejor comprensi贸n del alcance y la versatilidad de los smart contracts y su aplicaci贸n pr谩ctica en el mundo real.

Instalaci贸n de dependencias

Para desarrollar nuestro contrato inteligente usaremos Harhat como IDE ya que nos permitir谩 probarlo dentro de un entorno local antes de llevarlo en una red pruebas o principal. Adem谩s de que nos proporciona herramientas de automatizaci贸n de tareas, como pruebas automatizadas, pruebas de cobertura de c贸digo y generaci贸n de documentaci贸n, lo que nos facilita mucho el desarrollo y depuraci贸n de contratos inteligentes.
Adem谩s de que se adapta muy f谩cilmente a proyectos de cualquier tama帽o y complejidad.

Para realizar la instalaci贸n de Hardhat primero necesitamos Node.js ya que este hace uso de este entorno de ejecuci贸n. Si ya cuentas con Node.js omite este paso, de lo contrario es necesario ir al sitio oficial, descargarlo e instalarlo para la plataforma que utilices.

Ahora a instalar Hardhat, para ello debemos seguir los pasos de instalaci贸n desde su sitio web.

Una vez instalado deber铆amos de ver el siguiente resultado al ejecutar el comando para la creaci贸n de un nuevo proyecto:

$ npx hardhat
888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

馃懛 Welcome to Hardhat v2.9.9 馃懛鈥

? What do you want to do? 鈥
鉂 Create a JavaScript project
  Create a TypeScript project
  Create an empty hardhat.config.js
  Quit
Enter fullscreen mode Exit fullscreen mode

en mi caso crear茅 uno basado en JavaScript, pero puedes crearlo basado en TypeScript o vaci贸 si es el caso. El proyecto lo llamar茅 notes_dapp.

Creaci贸n de smart contract

Dentro de la carpeta de contracts definiremos el smart contract correspondiente

// notes_dapp/contracts/TaskList.sol

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity ^0.8.18;

contract TaskList {
  struct Task {
    bytes32 description;
    bool completed;
  }

  mapping(uint => Task) public tasks;
  uint public taskCount;

  function addTask(bytes32 _description) public {
    taskCount++;
    tasks[taskCount] = Task(_description, false);
  }

  function completeTask(uint _taskId) public {
    require(tasks[_taskId].completed == false, "Task is already completed");
    tasks[_taskId].completed = true;
  }

  function deleteTask(uint _taskId) public {
    require(tasks[_taskId].completed == true, "Can only delete completed tasks");
    delete tasks[_taskId];
  }

  function getTask(uint _taskId) public view returns (bytes32, bool){
    return (tasks[_taskId].description, tasks[_taskId].completed);
  }

  function getTaskCount() public view returns (uint) {
    return taskCount;
  }
}
Enter fullscreen mode Exit fullscreen mode
  • Task: Estructura que nos permitir谩 la descripci贸n de la tarea y el status de la misma
  • tasks: Map que contendr谩 todas las tareas que vayamos definiendo a futuro
  • completeTask: Funci贸n que nos permitir谩 marcar como completada determinada tarea
  • deleteTask: Nos permitir谩 eliminar una tarea en especifico
  • getTask: Obtiene una tarea mediante un id proporcionado, podremos obtener los la descripci贸n y el status de la tarea
  • getTaskCount: Funci贸n que nos permite obtener el numero de tareas

Podremos compilar el smart contract mediante el siguiente comando:

鉂 npx hardhat compile
Compiled 2 Solidity files successfully
Enter fullscreen mode Exit fullscreen mode

Nos dice que se compilaron dos archivos, esto debido a que por default hardhat genera un smart contract de ejemplo llamado Lock.sol, esto solo para los proyectos que no son generados de forma vac铆a, el cual fue nuestro caso. Por lo que deber铆as de ver algo asi en tu carpeta contracts

contracts/
鈹溾攢鈹 Lock.sol
鈹斺攢鈹 TaskList.sol
Enter fullscreen mode Exit fullscreen mode

Tests

Otra parte fundamental para cualquier proyecto de desarrollo de software es el apartado de los tests, estos nos permitir谩n reducir posibles errores en desarrollos posteriores y como buenos programadores que debemos ser no omitiremos estos de nuestro proyecto.
Por lo que, dentro de la carpeta test agregare el archivo con los tests correspondientes:

// notes_dapp/test/TaskList.js

const { expect } = require("chai")
const { ethers } = require("hardhat")
const { loadFixture } = require("@nomicfoundation/hardhat-network-helpers")

describe("Task list contract contract", function () {
  async function deployContract() {
    const contract = await ethers.getContractFactory("TaskList")
    const deploy = await contract.deploy()

    return { deploy }
  }

  it("Contract Deploy", async function () {
    const { deploy } = await loadFixture(deployContract)

    const _description = "test description"

    const description = ethers.utils.formatBytes32String(_description)
    await deploy.addTask(description)

    const taskOne = await deploy.getTask(1)

    expect(taskOne[0], _description)
    expect(taskOne[1], false)
  })

  it("Test, when add two tasks", async function () {
    const { deploy } = await loadFixture(deployContract)
    const _description = "test description"
    const _description2 = "test description"

    const description = ethers.utils.formatBytes32String(_description)
    const description2 = ethers.utils.formatBytes32String(_description2)

    await deploy.addTask(description)
    await deploy.addTask(description2)

    const taskOne = await deploy.getTask(1)
    const taskTwo = await deploy.getTask(2)

    expect(taskOne[0], _description)
    expect(taskOne[1], false)

    expect(taskTwo[0], _description2)
    expect(taskTwo[1], false)
    expect(await deploy.getTaskCount()).to.equals(2)
  })

  it("Test, set complete task, successfully", async function () {
    const { deploy } = await loadFixture(deployContract)
    const _description = "test description"

    const description = ethers.utils.formatBytes32String(_description)
    await deploy.addTask(description)
    await deploy.completeTask(1)

    const taskOne = await deploy.getTask(1)

    expect(taskOne[1], true)
  })

  it("Test, Error trying to complete a completed task", async function () {
    const { deploy } = await loadFixture(deployContract)
    const _description = "test description"

    const description = ethers.utils.formatBytes32String(_description)
    await deploy.addTask(description)
    await deploy.completeTask(1)
    await expect(deploy.completeTask(1)).to.be.revertedWith(
      "Task is already completed"
    )
  })

  it("Test, Delete task", async function () {
    const { deploy } = await loadFixture(deployContract)
    const _description = "test description"

    const description = ethers.utils.formatBytes32String(_description)
    await deploy.addTask(description)
    await deploy.completeTask(1)

    const task = await deploy.getTask(1)
    expect(task[1]).to.equals(true)
    await deploy.deleteTask(1)
  })

  it("Test, Error deleting task", async function () {
    const { deploy } = await loadFixture(deployContract)
    const _description = "test description"

    const description = ethers.utils.formatBytes32String(_description)
    await deploy.addTask(description)

    const task = await deploy.getTask(1)
    expect(task[1]).to.equals(false)
    await expect(deploy.deleteTask(1)).to.be.revertedWith(
      "Can only delete completed tasks"
    )
  })
})
Enter fullscreen mode Exit fullscreen mode

Podemos correr los tests ejecutando:

鉂 npx hardhat test


  Lock
    Deployment
      鉁 Should set the right unlockTime (2831ms)
      鉁 Should set the right owner
      鉁 Should receive and store the funds to lock
      鉁 Should fail if the unlockTime is not in the future (89ms)
    Withdrawals
      Validations
        鉁 Should revert with the right error if called too soon (89ms)
        鉁 Should revert with the right error if called from another account (45ms)
        鉁 Shouldn't fail if the unlockTime has arrived and the owner calls it (45ms)
      Events
        鉁 Should emit an event on withdrawals (38ms)
      Transfers
        鉁 Should transfer the funds to the owner (89ms)

  Task list contract contract
    鉁 Contract Deploy (109ms)
    鉁 Test, when add two tasks (291ms)
    鉁 Test, set complete task, successfully (44ms)
    鉁 Test, Error trying to complete a completed task (62ms)
    鉁 Test, Delete task (60ms)
    鉁 Test, Error deleting task (70ms)


  15 passing (4s)
Enter fullscreen mode Exit fullscreen mode

Puedes eliminar el archivo de test para el smart contract generado por hardhat al iniciar el proyecto, en mi caso no lo hice pero son archivos que no necesitaremos.

Deploy

Una vez generados nuestros tests para los casos de nuestro smart contract crearemos el script de deploy el cual nos servir谩 para realizar el deploy en las diferentes redes de prueba donde funcionara nuestro contrato.
Dentro de la carpeta scripts/ agregaremos el archivo TaskListDeploy.js con el siguiente contenido

const hre = require("hardhat")

async function main() {
  const Notes = await hre.ethers.getContractFactory("TaskList")
  const note = await Notes.deploy()

  await note.deployed()

  console.log(`Note dApp deployed on ${note.address}`)
}

main().catch(error => {
  console.log(error)
  process.exitCode = 1
})
Enter fullscreen mode Exit fullscreen mode

Por el momento nos aseguraremos de que nuestro contrato sea desplegado en nuestra red de pruebas ya proporcionada por hardhat. Para esto iremos al archivo:
hardhat.config.js y agregaremos la red por default.

Hardhat al ser una herramienta completa para el desarrollo blockchain ya nos proporciona una red de pruebas local sin la necesidad de ejecutar alguna otra aplicaci贸n que simule ser un nodo.
Tambi茅n nos da la posibilidad de ejecutar el nodo mediante el comando npx hardhat node (HardHat node).

En este caso no es necesario ejecutar el nodo.

require("@nomicfoundation/hardhat-toolbox")

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.18",
  defaultNetwork: "hardhat",
}
Enter fullscreen mode Exit fullscreen mode

Ahora probaremos que nuestro contrato se despliegue correctamente en la red por defecto que hemos seleccionado:

鉂 npx hardhat run scripts/TaskListDeploy.js
Note dApp deployed on 0x5FbDB2315678afecb367f032d93F642f64180aa3
Enter fullscreen mode Exit fullscreen mode

si todo salio bien podremos ver la direcci贸n de despliegue del contrato que en este caso pertenece a una direcci贸n de nuestro nodo de pruebas. Ya que verificamos que funciona el despliegue y que el comportamiento es el que esperamos podremos desplegar nuestro contrato den las diferentes redes que se mencionaron en la introducci贸n.

Polygon

Para poder desplegar nuestro contrato en la red de Polygon necesitamos contar con una billetera de criptomonedas, en mi caso hare uso de Metamask, pero servir铆a cualquiera que nos permita conectarnos las redes principales y de pruebas de las redes que usaremos.(Gu铆a inicial de Metamask)

Posteriormente necesitaremos agregar la red pruebas de Polygon en nuestra billetera, para ello necesitamos lo siguiente:

Deber铆a de verse algo similar:

tesnet-connection

Paso siguiente es a帽adir fondos a nuestra billetera, para ello necesitamos ir al siguiente sitio (https://faucet.polygon.technology/), nos aseguramos de que se encuentre seleccionada la red Mumbai y que el token sea MATIC, colocamos la direcci贸n de nuestra billetera y damos click en submit.

polygon_faucet

se abrir谩 una ventana donde confirmaremos la transacci贸n

funding_confirmation

despu茅s de un par de minutos podremos ver 0.2 Matic en nuestra direcci贸n

funded_wallet

Ahora agregaremos la red de MATIC a la configuraci贸n de hardhat as铆 como las variables de entorno correspondientes:

require("@nomicfoundation/hardhat-toolbox")
+ require("dotenv").config()

const MUMBAI_URL= process.env.MUMBAI_URL;
const MUMBAI_PRIVATE_KEY = process.env.MUMBAI_PRIVATE_KEY;

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.18",
  defaultNetwork: "hardhat",
+  networks: {
+    mumbai: {
+     url: MUMBAI_URL,
+      accounts: [MUMBAI_PRIVATE_KEY]
+    }
+  }
Enter fullscreen mode Exit fullscreen mode

Instalar el paquete dotenv mediante el gestor de maquetes de tu preferencia, en mi caso en yarn

$ yarn add dotenv
Enter fullscreen mode Exit fullscreen mode

Se crea el archivo .env en la ra铆z del proyecto con el siguiente contenido:

MUMBAI_URL=https://rpc-mumbai.maticvigil.com
MUMBAI_PRIVATE_KEY=TU_CLAVE_PRIVADA
Enter fullscreen mode Exit fullscreen mode

La clave la obtienes de la siguiente forma:

private_key
private_key_2

Ya que esta configurada la red estamos listos para desplegar el contrato mediante el comando:

$ npx hardhat run scripts/TaskListDeploy.js --network mumbai
Enter fullscreen mode Exit fullscreen mode

despu茅s de ejecutar el comando deber铆amos de tener lo siguiente:

$ npx hardhat run scripts/TaskListDeploy.js --network mumbai
Notes dApp deployed on {tu direcci贸n de contrato}
Enter fullscreen mode Exit fullscreen mode

Para visualizarlo vamos al explorador de mumbai y colocamos la direcci贸n del contrato, se deber铆a de poder visualizar la transacci贸n

deployed_contract

Continuaremos con la creaci贸n de un script en la carpeta de scripts que nos permitir谩 leer la informaci贸n del contrato una vez desplegado en la red de pruebas, agregaremos a nuestro archivo de variables .env la direcci贸n del contrato

MUMBAI_URL=https://rpc-mumbai.maticvigil.com
MUMBAI_PRIVATE_KEY=TU_CLAVE_PRIVADA
+CONTRACT_ADDRESS=TU_DIRECCI脫N_DE_CONTRATO
Enter fullscreen mode Exit fullscreen mode

posteriormente crearemos el siguiente archivo donde agregaremos lo siguiente

// scripts/TaskList.js
const hre = require("hardhat");
const abi = require("../artifacts/contracts/TaskList.sol/TaskList.json");

const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS;
const MUMBAI_URL = process.env.MUMBAI_URL;
const PRIVATE_KEY = process.env.MUMBAI_PRIVATE_KEY;

async function main(){
  const contractAddress = CONTRACT_ADDRESS;
  const contractABI = abi.abi;

  const provider = new hre.ethers.providers.JsonRpcProvider(MUMBAI_URL);

  const signer = new hre.ethers.Wallet(PRIVATE_KEY, provider);

  const taskList = new hre.ethers.Contract(contractAddress, contractABI, signer);

  // Nos permite agregar nuevas tareas
  // const description = hre.ethers.utils.formatBytes32String("Deploy de contrato en tesnet");
  // await taskList.addTask(description);

  const tasks = await taskList.getTaskCount();
  console.log(`Task number: ${tasks}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
Enter fullscreen mode Exit fullscreen mode

mediante el script anterior podremos interactuar con nuestro contrato sin necesidad de crear una interfaz web, pero claro el objetivo es que este se comunique con un frontend ;), ahora si ejecutamos el script deber铆amos de ver 0 tareas cargadas.

$ npx hardhat run scripts/TaskList.js
Task number: 0
Enter fullscreen mode Exit fullscreen mode

Si se descomenta el c贸digo y lo ejecutamos de nuevo estar铆amos creando la tarea que especifiquemos, ejecutamos nuevamente el comando anterior

npx hardhat run scripts/TaskList.js
Task number: 0
Enter fullscreen mode Exit fullscreen mode

este nos arrojara que son 0 tareas creadas, pero si ejecutamos nuevamente pero antes comentando el c贸digo de creaci贸n este nos devolver谩 ahora el total de una tarea

npx hardhat run scripts/TaskList.js
Task number: 1
Enter fullscreen mode Exit fullscreen mode

y podremos ver la transacci贸n en el explorador de bloques

first_transaction

Podemos agregar la funci贸n de marcar como terminada la tarea

// scripts/TaskList.js
const hre = require("hardhat");
const abi = require("../artifacts/contracts/TaskList.sol/TaskList.json");

const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS;
const MUMBAI_URL = process.env.MUMBAI_URL;
const PRIVATE_KEY = process.env.MUMBAI_PRIVATE_KEY;

async function main(){
  const contractAddress = CONTRACT_ADDRESS;
  const contractABI = abi.abi;

  const provider = new hre.ethers.providers.JsonRpcProvider(MUMBAI_URL);

  const signer = new hre.ethers.Wallet(PRIVATE_KEY, provider);

  const taskList = new hre.ethers.Contract(contractAddress, contractABI, signer);

  // Nos permite agregar nuevas tareas
  // const description = hre.ethers.utils.formatBytes32String("Deploy de contrato en tesnet");
  // await taskList.addTask(description);

+  // Permite marcar como terminada una tarea
+  await taskList.completeTask(1);

+  // Elimina una tarea
+  // await taskList.deleteTask(1);


  const tasks = await taskList.getTaskCount();
  console.log(`Task number: ${tasks}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
Enter fullscreen mode Exit fullscreen mode

si ejecutamos de nuevo tendremos como resultado un numero de tareas de 1 sin embargo podremos ver en el explorador la transacci贸n que marca como completada la tarea

npx hardhat run scripts/TaskList.js
Task number: 1
Enter fullscreen mode Exit fullscreen mode

mark_complete

De la misma forma podemos probar todas las funciones de nuestro contrato, y asi es como finalizamos con el despliegue de contratos inteligentes en Polygon, ahora aprender谩s a hacerlo en la red de Avalanche.

Avalanche

Para el despliegue del contrato en la red de Avalanche necesitamos configurar la informaci贸n de la red en el archivo de configuraci贸n de hardhat hardhat.config.js

require("@nomicfoundation/hardhat-toolbox")
require("dotenv").config()

const MUMBAI_URL= process.env.MUMBAI_URL;
const MUMBAI_PRIVATE_KEY = process.env.MUMBAI_PRIVATE_KEY;

+ const FUJI_URL = process.env.FUJI_URL;
+ const FUJI_PRIVATE_KEY = process.env.FUJI_PRIVATE_KEY;

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.18",
  defaultNetwork: "hardhat",
  networks: {
    mumbai: {
      url: MUMBAI_URL,
      accounts: [MUMBAI_PRIVATE_KEY]
+    },
+    fuji: {
+      url: FUJI_URL,
+      accounts: [FUJI_PRIVATE_KEY],
+    }
  }
};
Enter fullscreen mode Exit fullscreen mode

y dentro del archivo .env agregamos las variables correspondientes

MUMBAI_URL=https://rpc-mumbai.maticvigil.com
MUMBAI_PRIVATE_KEY=TU_CLAVE_PRIVADA
CONTRACT_ADDRESS=TU_DIRECCI脫N_DE_CONTRATO

+FUJI_URL=https://api.avax-test.network/ext/bc/C/rpc
+FUJI_PRIVATE_KEY=TU_CLAVE_PRIVADA
Enter fullscreen mode Exit fullscreen mode

Ahora necesitamos agregar fondos a nuestra billetera para poder pagar las tarifas de gas al momento de desplegar el contrato, para ello vamos al siguiente sitio https://faucet.avax.network/, colocaremos la direcci贸n de billetera y pediremos monedas de la red de pruebas de Avalanche

request_avax

Una vez que los fondos se encuentren en nuestra billetera podremos desplegar el contrato

$ npx hardhat run scripts/TaskListDeploy.js --network fuji
Notes dApp deployed on {tu direcci贸n de contrato}
Enter fullscreen mode Exit fullscreen mode

para poder visualizar el contrato desplegado vamos a snowtrace colocamos en el buscador la direcci贸n del contrato y podremos visualizarlo ya desplegado en la blockchain de pruebas de Avalanche

snowtrace_contract

Para probar el contrato comentaremos las credenciales que pertenec铆an a la red de Polygon y colocaremos las correspondientes a la red de Avalanche

const hre = require("hardhat");
const abi = require("../artifacts/contracts/TaskList.sol/TaskList.json");

const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS;
const MUMBAI_URL = process.env.MUMBAI_URL;
-const PRIVATE_KEY = process.env.MUMBAI_PRIVATE_KEY;
+const MUMBAI_PRIVATE_KEY = process.env.MUMBAI_PRIVATE_KEY;

+const FUJI_URL = process.env.FUJI_URL;
+const FUJI_PRIVATE_KEY = process.env.FUJI_PRIVATE_KEY;

async function main(){
  const contractAddress = CONTRACT_ADDRESS;
  const contractABI = abi.abi;

  // const provider = new hre.ethers.providers.EtherscanProvider("maticmum", process.env.MATIC_PRIVATE_KEY);
- const provider = new hre.ethers.providers.JsonRpcProvider(MUMBAI_URL);
+ const provider = new hre.ethers.providers.JsonRpcProvider(FUJI_URL);

-  const signer = new hre.ethers.Wallet(PRIVATE_KEY, provider);
+  const signer = new hre.ethers.Wallet(FUJI_PRIVATE_KEY, provider);

  const taskList = new hre.ethers.Contract(contractAddress, contractABI, signer);

  // Nos permite agregar nuevas tareas
  const description = hre.ethers.utils.formatBytes32String("Deploy de contrato en tesnet");
  await taskList.addTask(description);

  // Permite marcar como terminada una tarea
  // await taskList.completeTask(1);

  // Elimina una tarea
  //await taskList.deleteTask(1);


  const tasks = await taskList.getTaskCount();
  console.log(`Task number: ${tasks}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
Enter fullscreen mode Exit fullscreen mode

por 煤ltimo solo probaremos la creaci贸n y actualizaci贸n a completado de nuestra tarea

npx hardhat run scripts/TaskList.js
Task number: 0
Enter fullscreen mode Exit fullscreen mode

nos dir谩 que nuestro total de tareas son 0, pero si vamos al explorador de bloques veremos la transacci贸n, por 煤ltimo probaremos la actualizaci贸n de la tarea comentando el c贸digo de creaci贸n y se descomenta la funci贸n completeTask, ejecutaremos de nuevo

npx hardhat run scripts/TaskList.js
Task number: 1
Enter fullscreen mode Exit fullscreen mode

veremos que el n煤mero de tareas es 1, y en el explorador de bloques podremos visualizar la transacci贸n

complete_task

de esta forma ya contamos con un smart contract funcional que podr铆amos llevar a las redes principales de las cadenas de bloques, para ello solo basta con agregar las direcciones correspondientes a su respectiva mainnet y se configuran en el file hardhat.config.js as铆 como en el archivo .env colocar las URL rpc correspondientes.

Conclusiones

Como se podemos observar el uso de hardhat como entorno de desarrollo es sumamente potente, ya que nos permite realizar pruebas y testing de forma local con todas las herramientas necesarias ya integradas, ahorrandonos mucho tiempo en instalar software extra.
Por otro lado las redes de Polygon y Avalanche son muy econ贸micas para el despliegue de contratos inteligentes dentro de su mainnet y en cuanto a pruebas estas te proporcionan todo un entorno muy completo para que puedas validar tus desarrollos, en lo personal estas dos redes son las que m谩s me han agradado hasta el momento.

Si llegaste hasta aqu铆 espero que el tutorial te haya servido tanto si eres nuevo en el mundo de la blockchain o si ya tienes experiencia, y que esta tecnolog铆a te parezca tan interesante como a mi, seguir茅 agregando posts relacionados a blockchain y sobre otro temas relacionados, as铆 que no te pierdas de novedades.

Puedes encontrar m谩s posts como este en mi sitio web: LiteralCoder

Repositorio

GitHub logo Josh2604 / notes-dapp-sample

Notes dApp sample, created with hardhat.

Dapp de Notas

Esta es una Dapp (aplicaci贸n descentralizada) de notas construida con Hardhat y Ethereum. Esta aplicaci贸n permite a los usuarios crear, leer, actualizar y eliminar notas. La Dapp est谩 conectada a dos redes blockchain diferentes: Polygon y Avalanche.

Funcionalidades

La Dapp de Notas tiene las siguientes funcionalidades:

Crear notas: los usuarios pueden crear nuevas notas ingresando un contenido Numero de notas: los usuarios pueden ver el numero de notas creadas Actualizar notas: los usuarios marcar como completada una nota en especifico Eliminar notas: los usuarios pueden eliminar una nota existente.

Tecnolog铆as utilizadas

Hardhat: una herramienta de desarrollo de Ethereum que permite compilar, probar y desplegar contratos inteligentes React: una biblioteca de JavaScript para construir interfaces de usuario ethers.js: una biblioteca de JavaScript que permite interactuar con contratos inteligentes de Ethereum. Polygon: una red blockchain que permite transacciones r谩pidas y baratas. Avalanche: una red blockchain escalable y de alta鈥

Top comments (0)