Como Crear Una Blockchain con Rust – Parte 1

Rust es uno de los lenguajes de programación más seguros en la actualidad.

Si lo integramos con el ecosistema de blockchain, podemos lograr que un proyecto sea muy seguro.

En este tutorial aprenderás a Como Crear Una Blockchain con Rust, vamos con ello.

Partes

• Parte 1
• Parte 2 (Final – Código Fuente GitHub)

Sigue los pasos tal como te indico, para que todo salga bien.

Creación de Nuevo Proyecto

Ejecuto el siguiente comando para crear el proyecto con Rust:

cargo new blockchain-rust
     Created binary (application) `blockchain-rust` package

Rust nos crea una estructura de directorios y archivos para el proyecto.

Creando la Blockchain con Rust

Abrimos el archivo main.rs que se encuentra en src > main.rs:

/blockchain-rust 
  ├── /src 
      ├── main.rs // Abrimos este Archivo 
  ├── .gitignore 
  ├── Cargo.toml

Primero importamos las siguientes dependencias:

use chrono::{Local, Utc}; // Paquete para usar la fecha y tiempo
use sha2::{Digest, Sha256}; // Paquete para dar soporte a SHA-2
use log::{info, warn}; // Paquete para implementar registros o logs
use std::io::Write; // Usamos el trait 'Write' de Rust

Puedes encontrar las dependencias en el repositorio de crates.io:

• Visitar la página del paquete chrono
• Visitar la página del paquete sha2
• Visitar la página del paquete log
• El trait std::io::Write es nativo del lenguaje de programación Rust.

Si no sabes instalar una dependencia en Rust, te recomiendo seguir el tutorial Como Instalar una Dependencia o Paquete en Rust.

Creamos nuestra variable DIFICULTAD:

// Definimos una variable DIFICULTAD con números 0 de tipo string
const DIFICULTAD: &str = "00000";

Definimos la estructura inicial de la blockchain:

// Estructura para la blockchain 
struct Blockchain {
   blocks: Vec<Block>,
}

Cada bloque de la blockchain, tendrá la siguiente estructura:

// Estructura para un bloque independiente de la blockchain 
struct Block {
   id: u64,
   hash: String,
   previous_hash: String,
   timestamp: i64,
   data: String,
   nonce: u64,
}

Creamos las tareas para la creación de cada bloque de la blockchain (he colocado comentarios para explicar que hacen las líneas de código más importantes):

// Implementamos las tareas para cada bloque de la blockchain 
impl Block {

   // Función para crear un nuevo bloque
   fn new(id: u64, previous_hash: String, data: String) -> Self {
      
      // Usamos el tiempo 
      let timestamp = Utc::now().timestamp();

      // Generamos un nuevo bloque, el cual hereda información del bloque anterior 
      let (hash, nonce) = Self::minar(id, previous_hash.clone(), timestamp, data.clone());

      // Organizamos los tipos de datos que usamos en nuestra función 'new()'
      Self {
         id,
         hash,
         previous_hash,
         timestamp,
         data,
         nonce,
      }
   }
   
   // Función para crear un nuevo hash para el nuevo bloque 
   fn hash(id: u64, previous_hash: String, timestamp: i64, data: String, nonce: u64) -> String {

      // Juntamos los datos de los bloques unificados 
      let datos_bloque_unificados = format!("{}{}{}{}{}", id, previous_hash, timestamp, data, nonce);

      // Creamos una variable mutable llamada 'hash' y actualizamos los datos del siguiente bloque
      let mut hash = Sha256::new();
      hash.update(datos_bloque_unificados);
      format!("{:x}", hash.finalize())

   }

   // Función para minar un bloque
   fn minar(id: u64, previous_hash: String, timestamp: i64, data: String) -> (String, u64) {
      
      // Creamos una variable mutable con valor 0 
      let mut nonce = 0;

      // Loop para minar un bloque 
      loop {

         // Minamos un bloque obteniendo datos del bloque anterior 
         let hash = Self::hash(id, previous_hash.clone(), timestamp, data.clone(), nonce);

         // Si el bloque fue minado correctamente, mostramos un mensaje 
         if hash.as_str().starts_with(DIFICULTAD) {
            info!("El bloque #{} fue minado exitosamente", id);
            return (hash, nonce);
         }

         // Cambiamos el valor del variable nonce 
         nonce += 1;
      }

   }

}

Hasta aquí hemos creado nuestro proyecto con Rust y hemos definido los paquetes que usaremos.

Asimismo hemos creado nuestra implementación Block que contiene nuestros métodos para crear los bloques de la blockchain.

Ten Paciencia, lo que quiero es que entiendas todo el proceso para Crear este Proyecto y no llenarte el capitulo de mucho contenido porque te puedes marear y no tendrás un óptimo aprendizaje.

Nota (s)

• Los Pasos y opciones mencionadas en este capitulo del tutorial pueden cambiar, esto no depende de nosotros, si no de las empresas que dan soporte a estas herramientas como Cargo y a las dependencias mencionadas en este tutorial, que suelen cambiar sus opciones de despliegue y configuración en futuras versiones.
• En el siguiente capitulo terminaremos de crear nuestra blockchain con Rust.

Síguenos en nuestras Redes Sociales para que no te pierdas nuestros próximos contenidos.