Como Crear Una Blockchain con Rust – Parte 2 (Final)

Github

En la parte anterior creamos un nuevo proyecto para nuestro blockchain con Rust.

Importamos las dependencias y creamos las funciones necesarias para que crear los bloques de la blockchain.

En esta segunda parte y última terminaremos de crear nuestro blockchain con Rust, vamos con ello.

Partes

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

Ahora crearemos las tareas para iniciar o crear el génesis de la blockchain.

El genesis crea el primer bloque y así sucesivamente se irán generando nuevos bloques.

También validamos los bloques que se van creando y realizamos otras tareas más (he colocado comentarios para explicar que hacen las líneas de código más importantes):

// Implementamos las tareas para la blockchain 
impl Blockchain {

   // Función para crear la blockchain 
   fn new() -> Self {
      Self { blocks: Vec::new() }
   }

   // Función para dar origen a la blockchain 
   fn crear_genesis(&mut self) {

      // Usamos el tiempo 
      let timestamp = Utc::now().timestamp();

      // Vinculamos valores de la implementación 'Block' 
      let (hash, nonce) = Block::minar(
         0,
         String::from("genesis"),
         timestamp,
         String::from("genesis"),
      );

      // Definimos los datos para la blockchain 
      let bloque_genesis = Block {
         id: 0,
         hash,
         previous_hash: String::from("genesis"),
         timestamp,
         data: String::from("genesis"),
         nonce,
      };

      // Creamos el bloque inicial de la blockchain 
      self.blocks.push(bloque_genesis);
      info!("El bloque Génesis se creó con éxito y se agregó a la blockchain.");

   }

   // Función para verificar si el bloque es válido 
   fn validacion_bloque(&self, block: &Block, bloque_anterior: &Block) -> bool {
      
      // Analizamos los datos del bloque 
      if (block.id == bloque_anterior.id + 1)
         && block.hash.starts_with(DIFICULTAD)
         && (block.previous_hash == bloque_anterior.hash)
         && (Block::hash(
            block.id,
            block.previous_hash.clone(),
            block.timestamp,
            block.data.clone(),
            block.nonce,
         ) == block.hash)
      {
         // Mostramos un mensaje para confirmar que el bloque es válido 
         info!("El bloque #{} es válido", block.id);
         return true;
      }

      // Si el bloque no es válido, mostramos un mensaje 
      warn!("El bloque #{} no es válido", block.id);
      false
   }

   // Verificamos si la blockchain es válida 
   fn validacion_cadena(&self) -> bool {

      // Si la blockchain no es válida, mostramos con un mensaje 
      for block_index in 1..self.blocks.len() {
         if !self.validacion_bloque(&self.blocks[block_index], &self.blocks[block_index - 1]) {
            warn!("La blockchain no es válida");
            return false;
         }
      }

      // Si la blockchain sí es válida, mostramos un mensaje 
      info!("La blockchain sí es valida");
      true
    }
   
   // Función para agregar un nuevo bloque a la blockchain 
   fn agregar_bloque(&mut self, block: Block) {

      // Si no hay un bloque para agregar, mostramos un mensaje 
      let bloque_anterior = self
         .blocks
         .last()
         .expect("Debe haber al menos un bloque en la blockchain");

      // Si el bloque es válido lo agregamos a la blockchain 
      // Y si el bloque no es válido, mostramos un mensaje 
      if self.validacion_bloque(&block, bloque_anterior) {
         self.blocks.push(block);
         info!("El bloque se agregó con éxito a la blockchain.");
      } else {
         warn!(
            "El bloque no es válido, no se puede enviar el bloque #{} a la blockchain",
            block.id
         );
      }
   }
}

Por último nuestra función principal de Rust que contiene todos los métodos y tareas creados anteriormente (he colocado comentarios para explicar que hacen las líneas de código más importantes):

// Función principal 
fn main() {

   // Mostramos los mensajes en la terminal 
   pretty_env_logger::formatted_timed_builder()
      .format(|buf, record| {
         writeln!(
            buf,
            "{} [{}] - {}",
            Local::now().format("%H:%M:%S"),
            record.level(),
            record.args()
         )
      })
      .filter(None, log::LevelFilter::Info)
      .init();
   
   // Creamos la blockchain 
   let mut blockchain = Blockchain::new();
   blockchain.crear_genesis();
    
   // Ejecutamos las funciones y tareas creadas anteriormente 
   // Mostramos un par de mensajes de rutina 
   loop {
      let bloque_anterior = blockchain
         .blocks
         .last()
         .expect("Debe haber al menos un bloque en la blockchain");
      let nuevo_bloque = Block::new(
         bloque_anterior.id + 1,
         bloque_anterior.hash.clone(),
         String::from("Creación de Una Blockchain con Rust"),
      );

      blockchain.agregar_bloque(nuevo_bloque);

      if blockchain.blocks.len() % 10 == 0 {
         blockchain.validacion_cadena();
     }
   }

}

Estoy usando Visual Studio Code.

Entonces compilo el proyecto en la terminal:

cargo build

   Compiling blockchain-rust v0.1.0 
    Finished dev [unoptimized + debuginfo] target(s) in 0.67s

Paso seguido ejecuto el proyecto luego de haberlo compilado:

Así puedes crear una blockchain o cadena de bloques con el lenguaje de programación Rust.

Al inicio de esta parte del tutorial he colocado un enlace a un repositorio de GitHub en donde puedes encontrar todo el código del proyecto.

Conclusión

En este tutorial has aprendido a Como Crear Una Blockchain con Rust.

Te servirá como base para crear proyectos de blockchain más avanzados con el lenguaje de programación Rust.

Tienes que practicar mucho y así serás un crack en la creación de blockchain con Rust.

Nota(s)

• No olvides que debemos usar la Tecnología para hacer cosas Buenas por el Mundo.

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