Como Crear Una Blockchain con Rust – Parte 1

Nube Colectiva

hace 8 meses

Como Crear Una Blockchain con Rust - Parte 1

En esta página:

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)

Una blockchain es escalable y acumula bloques conforme crece

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

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

/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

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

// Estructura para la blockchain

struct Blockchain {

blocks: Vec<Block>,

}

Sabías que Discord usa el lenguaje de programación Rust para tareas en su Back-end.

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

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

   }

}

// 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.

Conoce estos 7 Proyectos Que Han Sido Creados con el Lenguaje de Programación Rust.

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.