DEV Community: Josué Andrés

Cómo crear tu propio smart contract con Solidity y Hardhat 🔥🚀

Josué Andrés — Fri, 12 May 2023 00:26:40 +0000

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

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;
  }
}

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

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

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"
    )
  })
})

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)

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
})

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",
}

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

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:

Nombre de la red: Mumbai TestNet
Dirección RPC: https://rpc-mumbai.maticvigil.com
Identificador de cadena: 80001
Símbolo de moneda: MATIC
Dirección de explorador de bloques:https://mumbai.polygonscan.com

Debería de verse algo similar:

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.

se abrirá una ventana donde confirmaremos la transacción

después de un par de minutos podremos ver 0.2 Matic en nuestra dirección

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]
+    }
+  }

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

$ yarn add dotenv

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

La clave la obtienes de la siguiente forma:

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

$ npx hardhat run scripts/TaskListDeploy.js --network mumbai

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}

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

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

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;
});

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

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

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

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

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;
});

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

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],
+    }
  }
};

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

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

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}

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

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;
});

por último solo probaremos la creación y actualización a completado de nuestra tarea

npx hardhat run scripts/TaskList.js
Task number: 0

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

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

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

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…

View on GitHub

gRPC Hola mundo con golang

Josué Andrés — Sat, 22 May 2021 02:19:24 +0000

Hola, en está ocasión hablaremos de gRPC una de las tecnologías que esta provocando disrupción en la forma en que comunicamos nuestros microservicios, el día de hoy crearemos un hola mundo haciendo uso de esta tecnología

Introducción

gRPC(gRPC Remote Procedure Calls) o llamada de procedimiento remoto (RPC) es un framework de código abierto desarrollado inicialmente por Google, el cual incluye extensiones para balanceo de carga, rastreo, salud de nuestros servicios, comprobación y autenticación. Hace uso de Protocol Buffers para definir la estructura de nuestra aplicación. Es aplicable a aplicaciones móviles, navegadores web y servicios backend.

gRPC al día de hoy es una tecnología que se encuentra en proceso de adopción y lo que nos deja entre ver es el gran futuro que tiene esta tecnología, no es un sustituto a REST pero si una gran alternativa al momento de crear servicios que sean escalables, resilientes y de alta disponibilidad que es lo que justamente nos ofrece gRPC.

Van a ser diferentes los casos y los problemas que tengamos que resolver y tendremos que decidir qué tipo de solución podemos dar al momento de diseñar servicios ya sea usando una tecnología u otra gRPC vs APIs REST.

Algunas de las compañías que utilizan gRPC son:

Dropbox
OpenBMC
Netflix
CoreOS
Cisco
entre otros..

Nuestra app...

Para nuestro ejemplo necesitamos instalar la herramienta de protocol buffer que nos permitirá construir nuestro servicio.
En mi caso estoy utilizando Mac OS, para este sistema basta con ejecutar

brew install protobuf

para el caso de versiones Linux:

# Make sure you grab the latest version
curl -OL https://github.com/google/protobuf/releases/download/v3.5.1/protoc-3.5.1-linux-x86_64.zip
# Unzip
unzip protoc-3.5.1-linux-x86_64.zip -d protoc3
# Move protoc to /usr/local/bin/
sudo mv protoc3/bin/* /usr/local/bin/
# Move protoc3/include to /usr/local/include/
sudo mv protoc3/include/* /usr/local/include/
# Optional: change owner
sudo chown [user] /usr/local/bin/protoc
sudo chown -R [user] /usr/local/include/google

Crearemos una carpeta que llamaremos grpc-hello-world y dentro de ella inicializaremos nuestro proyecto mediante go mod init tendremos algo como esto:

$ go mod init
go: creating new go.mod: module github.com/Josh2604/grpc-hello-world

Dentro de la carpeta ejecutaremos go get -u google.golang.org/grpc tendremos dos archivos como los siguientes:

.
├── go.mod
└── go.sum

0 directories, 2 files

Crearemos la siguiente estructura de carpetas y archivos

.
├── go.mod
├── go.sum
└── hello
    ├── client.go
    ├── hello.proto
    └── server.go

1 directory, 5 files

Dentro de hello.proto definiremos la estructura del request, response y la función que resolverá nuestra petición.

syntax="proto3";

message User {
  string name=1;
  string age=2;
}

message HelloRequest {
  User user=1;
}
message HelloResponse {
  string message=1;
}
service HelloService {
  // Unary
  rpc Hello(HelloRequest) returns (HelloResponse){};
}

El ciclo de vida de RPC diferentes tipos de implementaciones en esta ocasión estaremos implementando el tipo Unary RPC, en otros posts crearemos ejemplos de las diferentes implementaciones de RPC.

Dentro de la ruta principal de nuestro proyecto crearemos el siguiente script:

#!bin/bash
protoc hello/hello.proto --go_out=plugins=grpc:.

daremos permisos de ejecución mediante chmod u+x generate.sh y lo ejecutamos ./generate.sh esto nos generara un nuevo archivo llamado hello.pb.goque contiene lo necesario para implementar nuestro servidor y cliente con gRPC. Restructuraremos un poco el proyecto el cual quedará de la siguiente manera:

.
├── generate.sh
├── go.mod
├── go.sum
└── hello
    ├── client
    │   └── client.go
    ├── hello.pb.go
    ├── hello.proto
    └── server
        └── server.go

3 directories, 7 files

Instalar dependencias en caso de que se requieran, después de la generación del archivo hello.pb.go, no tendremos que modificar nada de este archivo, contiene la implementación necesaria para nuestro ejemplo.

Ahora dentro de nuestro archivo client/client.go agregaremos lo siguiente:

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/Josh2604/grpc-hello-world/hello"
    "google.golang.org/grpc"
)

func main() {
    fmt.Println("Client running!")
    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("could not connect: %v", err)
    }
    defer conn.Close()
    c := hello.NewHelloServiceClient(conn)
    doHello(c)
}

func doHello(c hello.HelloServiceClient) {
    fmt.Println("Starting rpc")
    req := &hello.HelloRequest{
        User: &hello.User{
            Name: "test",
            Age:  "25",
        },
    }
    res, err := c.Hello(context.Background(), req)
    if err != nil {
        log.Fatalf("Error calling rpc method: %v", err)
    }

    log.Printf("Response from GreatService: %v", res.Message)
}

Y para nuestro archivo server/server.go agregamos el siguiente código:

package main

import (
    "context"
    "fmt"
    "log"
    "net"

    "github.com/Josh2604/grpc-hello-world/hello"
    "google.golang.org/grpc"
)

type server struct{}

func (s *server) Hello(ctx context.Context, req *hello.HelloRequest) (*hello.HelloResponse, error) {
    fmt.Println("Hello Called")
    name := req.GetUser().GetName()
    age := req.GetUser().GetAge()
    result := "Hello " + name + " I'm " + age + " years old"
    res := &hello.HelloResponse{
        Message: result,
    }
    return res, nil
}

func main() {
    fmt.Println("Server running!")

    list, err := net.Listen("tcp", "0.0.0.0:50051")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }

    // Server Creation
    s := grpc.NewServer()
    hello.RegisterHelloServiceServer(s, &server{})

    if err := s.Serve(list); err != nil {
        log.Fatalf("faile to serve: %v", err)
    }
}

Estamos listos para poder probar lo que hemos hecho hasta ahora.

Abrimos nuestra terminal y dentro de la carpeta del proyecto ejecutamos los siguientes comandos

Servidor gor hello/server/server.go
Cliente gor hello/client/client.go

Y Listo !! tienes tu primer hola mundo con golang y grpc. Dejo el link del repositorio, si te fue de utilidad compártelo con los demás y hagamos que la comunidad siga creciendo!!

Puedes ver mas publicaciones visitando mi sitio web literalcoder.com :)

Josh2604 / grpc-hello-world

Hello world - grpc -golang

Scroll infinito con React.js y Go

Josué Andrés — Sun, 21 Mar 2021 22:17:32 +0000

Bienvenidos nuevos lectores, espero que les sea de utilidad el contenido del siguiente post...

React se ha convertido en una de las librerías mas populares en cuanto a creación de interfaces de usuario se refiere, y en esta ocasión haremos uso de esta para la creación de un hook que nos permitirá gestionar la funcionalidad de un infinite scroll.

Backend

Iniciaremos creando el API para nuestra implementación la cual de desarrollaremos en uno de los lenguajes que hasta el momento ha ido ganando mucha popularidad entre la comunidad de desarrolladores(incluyéndome), sí, me refiero a go.

Como requisitos debemos de contar con la instalación y configuración del lenguaje. Para asegurarnos de que contamos con go en nuestro sistema ejecutamos:

$ go version

como resultado debemos de tener similar, dependiendo del sistema operativo que se utilice:

$ go version go1.16 darwin/amd64

Una vez que contamos con go en nuestro sistema comenzaremos con la creación de la estructura del proyecto, haremos uso de las denominadas arquitecturas limpias como la hexagonal teniendo como resultado la siguiente estructura de directorios:

Separaremos la lógica de nuestro servidor y la configuración de rutas para poder incluir mas adelante nuevos endpoint a nuestro servicio.

package server

import (
    "net/http"

    "github.com/Josh2604/go-infinite-scroll/api/dependencies"
    "github.com/gin-gonic/gin"
)

func routes(router *gin.Engine, handlers *dependencies.Handlers) {
    postRoutes(router, handlers)
}

func postRoutes(router *gin.Engine, handlers *dependencies.Handlers) {
    router.GET("/", func(c *gin.Context) {
        c.JSON(http.StatusOK, "Running")
    })
    router.POST("/posts", handlers.GetPosts.Handle)
}

package server

import (
    "github.com/Josh2604/go-infinite-scroll/api/dependencies"
    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
)

const port = ":8080"

func Start() {
    router := gin.New()

    handlers := dependencies.Exec()

    router.Use(cors.Default())
    routes(router, handlers)

    if err := router.Run(port); err != nil {
        panic(err)
    }
}

Definiremos nuestra carpeta de dependencias y realizaremos su inyección al momento del arranque de nuestro servicio.

package dependencies

import (
    "github.com/Josh2604/go-infinite-scroll/api/entrypoints"
    "github.com/Josh2604/go-infinite-scroll/api/usecases/getfeeds"
)

type Handlers struct {
    GetPosts entrypoints.Handler
}

func Exec() *Handlers {
    // UseCases
    postsUseCases := &getfeeds.Implementation{}

    // Handlers
    handlers := Handlers{}

    handlers.GetPosts = &entrypoints.GetPosts{
        GetPostsUseCase: postsUseCases,
    }

    return &handlers
}

Definimos los puntos de entrada de nuestra app dentro de la carpeta entrypoints estos se encargaran de ser los handlers de nuestras rutas.

package entrypoints

import (
    "net/http"

    "github.com/Josh2604/go-infinite-scroll/api/core/contracts/getposts"
    apiErrors "github.com/Josh2604/go-infinite-scroll/api/errors"
    "github.com/Josh2604/go-infinite-scroll/api/usecases/getfeeds"
    "github.com/gin-gonic/gin"
)

type GetPosts struct {
    GetPostsUseCase getfeeds.UseCase
}

func (useCase *GetPosts) Handle(c *gin.Context) {
    err := useCase.handle(c)
    if err != nil {
        c.JSON(err.Status, err)
    }
}

func (useCase *GetPosts) handle(c *gin.Context) *apiErrors.Error {
    var request getposts.Paginator
    errq := c.BindJSON(&request)
    if errq != nil {
        return apiErrors.NewBadRequest("Invalid Request Parameters", errq.Error())
    }

    response, err := useCase.GetPostsUseCase.GetPosts(c, &request)
    if err != nil {
        c.JSON(http.StatusInternalServerError, "Error!")
        return nil
    }

    c.JSON(http.StatusOK, &response)
    return nil
}

Por último crearemos el caso de uso para nuestro servicio de scroll infinito, no utilizaremos una base de datos, se hará uso de un archivo json estático que contiene una lista de 100 posts de prueba. Se puede hacer la implementación de una base de datos más adelante debido a la separación de las capas del servicio (Las bondades que nos permite el uso de arquitecturas limpias).

package getfeeds

import (
    "context"
    "encoding/json"
    "io/ioutil"
    "math"
    "os"

    "github.com/Josh2604/go-infinite-scroll/api/core/contracts/getposts"
    "github.com/Josh2604/go-infinite-scroll/api/core/entities"
)

type UseCase interface {
    GetPosts(ctx context.Context, paginator *getposts.Paginator) (*getposts.Response, error)
}

type Implementation struct {
}

// GetFeeds -
func (useCase *Implementation) GetPosts(ctx context.Context, paginator *getposts.Paginator) (*getposts.Response, error) {
    var pageNumber, items = paginator.PageNo, paginator.Limit
    posts := getPosts()
    total := len(posts)

    start := (pageNumber - 1) * items
    end := pageNumber * items

    div := float64(total) / float64(items)
    totalPages := math.Trunc(div)

    HASMORE := true

    if (pageNumber + 1) > int(totalPages) {
        HASMORE = false
    }

    if (paginator.PageNo * paginator.Limit) > total {
        start = 0
        end = 0
    }

    response := getposts.Response{
        Total:       total,
        CurrentPage: pageNumber,
        PagesNo:     int(totalPages),
        HasMore:     HASMORE,
        Items:       posts[start:end],
    }
    return &response, nil
}

func getPosts() []entities.Post {
    posts := make([]entities.Post, 100)

    raw, err := ioutil.ReadFile("feeds.json")
    if err != nil {
        os.Exit(1)
    }
    errJ := json.Unmarshal(raw, &posts)
    if errJ != nil {
        os.Exit(1)
    }
    return posts
}

Ejecutamos el comando:

$ go run api/main.go

y podremos ver nuestra app corriendo en el puerto :8080

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /                         --> github.com/Josh2604/go-infinite-scroll/api/server.postRoutes.func1 (2 handlers)
[GIN-debug] POST   /posts                    --> github.com/Josh2604/go-infinite-scroll/api/entrypoints.Handler.Handle-fm (2 handlers)
[GIN-debug] Listening and serving HTTP on :8080

El principal beneficio que nos provee el uso de arquitecturas limpias es el desacople de las capas de nuestra aplicación y mediante la inyección de dependencias poder agregar o quitar funcionalidades a la misma, logrando que los cambios afecten lo menos posible a la estructura de nuestra proyecto.

Frontend

Para comenzar con el frontend crearemos un nuevo proyecto ejecutando npx create-react-app react-infinite-scroll (tener instalado node.js), dentro de la carpeta src de nuestro proyecto crearemos la siguiente estructura de carpetas.

Lo primero que haremos es crear un hook donde encapsularemos la funcionalidad de nuestra API.

src/app/hooks/useScroll.js

import axios from 'axios';
import { useCallback, useEffect, useState } from 'react';

export default function useScroll({ pageNo, limit, apiPath }) {
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(false);
  const [data, setData] = useState([]);
  const [hasMore, setHasMore] = useState(true);
  const [details, setDetails] = useState({
    "total": 0,
    "pages": 0
  });

  const GetData = useCallback(async () => {
    try {
      let cancel;
      let config = {
        method: 'POST',
        url: apiPath,
        data: {
          page_no: pageNo,
          limit: limit ? limit : 10
        },
        cancelToken: new axios.CancelToken(c => cancel = c)
      }

      const response = await axios(config);

      const data = response.data;

      setData(prevData => {
        return [...new Set(prevData), ...data.items]
      });
      setDetails({
        total: data.total,
        pages: data.pages_no
      });
      setHasMore(data.has_more);

      setLoading(false);
      return () => cancel();
    } catch (error) {
      setError(true);
      setLoading(false);
      if (axios.isCancel(error)) {
        return
      }
    }
  }, [pageNo, apiPath, limit]);

  useEffect(() => {
    GetData();
  }, [GetData]);

  return { loading, error, data, hasMore, details };
};

Lo siguiente es crear el componente de react e importar nuestro hook creado anteriormente, la funcion HandlerScroll de nuestro componente la utilizaremos para calcular el ancho de nuestro contenedor una vez que sobrepasemos el ancho al hacer scroll sobre el contenedor incrementaremos en uno el valor actual de la variable pageNumber esto provocara que nuestro hook se ejecute y nos devuelva los nuevos resultados.

src/app/components/InfineScroll/index.js

import React, { useState } from 'react';
import useScroll from './../../hooks/useScroll';
import './styles.css';

function ScrollImplementation() {
  const [pageNumber, setPageNumber] = useState(1)
  const { loading, error, data, hasMore, details } = useScroll({ pageNo: pageNumber, limit: 10, apiPath: 'http://service-name/posts' });

  function HandlerScroll(evt) {
    const { scrollTop, clientHeight, scrollHeight } = evt.currentTarget;
    if (scrollHeight - scrollTop === clientHeight && loading === false && hasMore === true) {
      setPageNumber(prevPageNumber => prevPageNumber + 1);
    }
  }
  return (
    <div className="container">
      <h1 className="display-6">Posts</h1>
      <span class="badge rounded-pill bg-primary"> No. paginas: {details.pages}</span>
      <span class="badge rounded-pill bg-info text-dark">Items: {details.total}</span>
      <div className="container-fluid posts-container"
        onScroll={HandlerScroll}
      >
        {
          data.map((element, key) => {
            return (
              <div key={key} className="card card-container">
                <div className="card-body">
                  <h5 className="card-title">{element.title}</h5>
                  <p className="card-text">{element.body}</p>
                </div>
              </div>
            )
          })
        }
        <div>{error && 'Error...'}</div>
      </div>
    </div>
  )
}
export default ScrollImplementation;

Por último agregaremos algunos estilos a nuestro componente:

.posts-container{
  max-height: 44em;
  overflow-y: scroll;
  overflow-x: hidden;
}
.card-container{
  margin: 1em 0em 1em 0em;
}

Si te fue de ayuda, comparte este contenido con quien creas que le sera util ;)

Puedes ver mas publicaciones visitando mi sitio web literalcoder.com :)

Repositorio de GitHub (Frontend):

Josh2604 / react-infinite-scroll

Implementación de scroll infinito en Recact.js

Implementación de scroll infinito con React.js

Backend

Implementación en Go

View on GitHub

Repositorio de GitHub (Backend):

Josh2604 / go-infinite-scroll

Go infinite scroll backend.

Posts API

Frontend

Implementación con React

Features

Implementación de scroll infinito

GET /

POST /posts

Paginación de posts

request:

{
    "page_no": 1,
    "limit":10
}

response:

{
    "total": 100
    "current_page": 2,
    "pages_no": 20,
    "has_more": true,
    "items": [
        {
            "user_id": 0,
            "id": 6,
            "title": "dolorem eum magni eos aperiam quia",
            "body": "ut aspernatur corporis harum nihil quis provident sequi\nmollitia nobis aliquid molestiae\nperspiciatis et ea nemo ab reprehenderit accusantium quas\nvoluptate dolores velit et doloremque molestiae"
        },
        {
            "user_id": 0,
            "id": 7,
            "title": "magnam facilis autem",
            "body": "dolore placeat quibusdam ea quo vitae\nmagni quis enim qui quis quo nemo aut saepe\nquidem repellat excepturi ut quia\nsunt ut sequi eos

…

View on GitHub

DEV Community: Josué Andrés

Cómo crear tu propio smart contract con Solidity y Hardhat 🔥🚀

Introducción

Instalación de dependencias

Creación de smart contract

Tests

Deploy

Polygon

Avalanche

Conclusiones

Repositorio

Josh2604 / notes-dapp-sample

Notes dApp sample, created with hardhat.

Dapp de Notas

Funcionalidades

Tecnologías utilizadas

gRPC Hola mundo con golang

Introducción

Nuestra app...

Josh2604 / grpc-hello-world

Hello world - grpc -golang

Scroll infinito con React.js y Go

Backend

Frontend

Repositorio de GitHub (Frontend): Josh2604 / react-infinite-scroll Implementación de scroll infinito en Recact.js Implementación de scroll infinito con React.js Backend Implementación en Go View on GitHub

Josh2604 / react-infinite-scroll

Implementación de scroll infinito en Recact.js

Implementación de scroll infinito con React.js

Backend

Josh2604 / go-infinite-scroll

Go infinite scroll backend.

Posts API

Frontend

Features

GET /

POST /posts

Repositorio de GitHub (Frontend):

Josh2604 / react-infinite-scroll

Implementación de scroll infinito en Recact.js

Implementación de scroll infinito con React.js

Backend

Implementación en Go

View on GitHub