¿Cómo crear una cadena de bloques con Python?

por

¿Sabías que Bitcoin está construido sobre Blockchain? Hoy vamos a construir una Blockchain con Python desde cero.

¿Qué es la cadena de bloques?

En 2008 el papel bitcoin fue publicado por un individuo o grupo desconocido llamado Satoshi Nakamoto. Bitcoin surgió como una versión peer-to-peer de efectivo electrónico que permitía realizar transacciones sin pasar por instituciones centralizadas (bancos). La mayoría de la gente no sabe que en ese mismo documento, Satoshi definió una forma distribuida de almacenar información, hoy conocida como Blockchain.

tecnología de cadena de bloques

En pocas palabras, Blockchain es un libro de contabilidad digital compartido e inmutable que almacena transacciones en una red descentralizada de computadoras.

Podemos dividir Blockchain en dos términos simples:

  • Block: Un espacio donde almacenamos transacciones
  • Cadena: un conjunto de registros vinculados

Esto define a Blockchain como una cadena de bloques enlazados, donde cada bloque almacena una transacción realizada con parámetros específicos.

Cada bloque se construye encima de otro bloque, creando una cadena irreversible de bloques. En otras palabras, cada bloque depende de otro. Esto se convierte en un sistema robusto e inmutable en el que cualquier persona con los permisos correctos puede revisar la integridad.

Blockchain presenta un conjunto interesante de características:

  • Inmutabilidad de la historia
  • persistencia de la información
  • No hay errores con los datos almacenados

Muchos sistemas actualmente se basan en Blockchain, como las criptomonedas, la transferencia de activos (NFT) y, posiblemente, en un futuro próximo, la votación.

Vale la pena mencionar que Python Blockchain no tiene que ser un programa complejo con miles de líneas de código. En esencia, sería una lista de transacciones vinculadas entre sí.

Por supuesto, esta fue una breve explicación, pero si desea una guía completa, hemos producido un tutorial completo sobre Blockchain para principiantes. Asegúrese de comprobarlo.

Sin más demora, construyamos una Blockchain simple con Python.

Construyendo una cadena de bloques con Python

Antes de comenzar, definamos lo que vamos a hacer en este tutorial:

  • Cree un sistema Blockchain simple escrito en Python
  • Usa nuestra Blockchain con transacciones preestablecidas representadas como cadenas
  • Prueba la inmutabilidad de nuestra Blockchain

No vamos a usar JSON sino listas de Python. Esto nos permitirá simplificar el proceso y centrarnos en aplicar los conceptos clave de Blockchain.

Lo que necesitarás para seguir este tutorial:

Creando la clase Block

Abra su editor de código favorito y cree un archivo main.py. Este será el archivo con el que trabajaremos.

Ahora, importa hashlib, un módulo que nos permite crear mensajes encriptados unidireccionales. Las técnicas de criptografía como el hashing hacen que Blockchain cree transacciones seguras.

Una función hash es un algoritmo que toma algunos datos (generalmente una cadena codificada) y devuelve un identificador único, a menudo denominado «resumen» o «firma». Esta última parte es vital; con una función hash, una ligera diferencia en la entrada produce un identificador radicalmente diferente como salida. Veremos esto en acción más adelante.

Por ahora, solo importa el módulo integrado hashlib:

# main.py file
"""
A simple Blockchain in Python
"""

import hashlib

Este módulo incluye la mayoría de los algoritmos hash que necesitará. Solo tenga en cuenta que usaremos la función hashlib.sha256().

Ahora, entremos en GeekCoinBlock, nuestro nombre de cadena de bloques totalmente original.

class GeekCoinBlock:
    
    def __init__(self, previous_block_hash, transaction_list):

        self.previous_block_hash = previous_block_hash
        self.transaction_list = transaction_list

        self.block_data = f"{' - '.join(transaction_list)} - {previous_block_hash}"
        self.block_hash = hashlib.sha256(self.block_data.encode()).hexdigest()

Sé que esto puede resultar en un código torpe. Analicemos cada parte en la siguiente sección.

GeekCoinBlock Explicación

Primero, creamos una clase llamada GeekCoinBlock, un contenedor para objetos que tendrán ciertas características (atributos) y comportamientos (métodos).

Luego definimos el método __init__ (también llamado constructor), que se invoca cada vez que se crea un objeto GeekCoinBlock.

Este método tiene tres parámetros:

  • self (la instancia de cada objeto)
  • previous_block_hash (una referencia al bloque anterior)
  • transaction_list (una lista de transacciones realizadas en el bloque actual).

Almacenamos el hash anterior y la lista de transacciones y creamos una variable de instancia block_data como una cadena. Esto no sucede con las criptomonedas reales, en las que almacenamos ese tipo de datos como otro hash, pero para simplificar, almacenaremos cada bloque de datos como una cadena.

Finalmente, creamos el block_hash, que otros bloques usarán para continuar la cadena. Aquí es donde hashlib resulta útil; en lugar de crear una función hash personalizada, podemos usar el sha256 preconstruido para hacer bloques inmutables.

Esta función recibe cadenas codificadas (o bytes) como parámetros. Es por eso que estamos usando el método block_data.encode(). Después de eso, llamamos a hexdigest() para devolver los datos codificados en formato hexadecimal.

Sé que todo esto puede ser abrumador, así que juguemos con hashlib en un shell de Python.

In [1]: import hashlib

In [2]: message = "Python is great"

In [3]: h1 = hashlib.sha256(message.encode())

In [4]: h1
Out[4]: <sha256 ... object @ 0x7efcd55bfbf0>

In [5]: h1.hexdigest()
Out[5]: 'a40cf9cca ... 42ab97'

In [6]: h2 = hashlib.sha256(b"Python is not great")

In [7]: h2
Out[7]: <sha256 ... object @ 0x7efcd55bfc90>

In [8]: h2.hexdigest()
Out[8]: 'fefe510a6a ... 97e010c0ea34'

Como puede ver, un ligero cambio en la entrada como «Python es genial» a «Python no es genial» puede producir un hash totalmente diferente. Todo esto tiene que ver con la integridad de Blockchain. Si introduce algún pequeño cambio en una cadena de bloques, su hash cambiará drásticamente. Esta es la razón por la cual el dicho «No se puede corromper una Blockchain» es cierto.

Usando nuestra clase de bloque

Construiremos una clase completa de Blockchain más adelante, pero por ahora, usemos nuestra clase Block para crear una cadena de bloques (Blockchain).

En el mismo archivo, cree un par de transacciones compuestas por cadenas simples almacenadas en variables, por ejemplo:

class GeekCoinBlock:
    ...

t1 = "Noah sends 5 GC to Mark"
t2 = "Mark sends 2.3 GC to James"
t3 = "James sends 4.2 GC to Alisson"
t4 = "Alisson sends 1.1 GC to Noah"

Por supuesto, GC se refiere a GeekCoin

Ahora, construya el primer bloque de nuestra Blockchain utilizando la clase GeekCoinBlock e imprima sus atributos. Tenga en cuenta que el parámetro anterior_hash del bloque génesis (primer bloque que precede a otros bloques) siempre será una cadena arbitraria o hash, en este caso, «primer bloque».

block1 = GeekCoinBlock('firstblock', [t1, t2])

print(f"Block 1 data: {block1.block_data}")
print(f"Block 1 hash: {block1.block_hash}")

Luego, hacemos lo mismo con el segundo bloque, pero pasando el hash del primer bloque como argumento anterior_hash.

block2 = GeekCoinBlock(block1.block_hash, [t3, t4])

print(f"Block 2 data: {block2.block_data}")
print(f"Block 2 hash: {block2.block_hash}")

Ejecutemos y analicemos el resultado que obtenemos de este fragmento de código. Una vez más, escribe en tu terminal:

❯ python main.py
Block 1 data: Noah sends 5 GC to Mark - Mark sends 2.3 GC to James - firstblock
Block 1 hash: 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Block 2 data: James sends 4.2 GC to Alisson - Alisson sends 1.1 GC to Noah - 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Block 2 hash: 448c4306caf7f6937b0307f92f27fbea3bb73b3470363dee5026a1209dadcfa8

Por ahora, solo ve texto y algunos hashes de 64 caracteres, pero esto resume más o menos el mecanismo de una Blockchain.

Comienzas con un bloque de génesis, la base de todos los demás bloques.

Cualquiera puede validar la integridad de la cadena, y es por eso que Blockchain es un sistema tan seguro. Por ejemplo, si modificamos ligeramente el contenido de una transacción, digamos:

t2 = "Mark sends 2.3 GC to James" -> t2 = "Mark sends 3.2 GC to James"

Vemos un cambio dramático en el hash de los bloques.

Block 1 data: Noah sends 5 GC to Mark - Mark sends 3.2 GC to James - firstblock
Block 1 hash: 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Block 2 data: James sends 4.2 GC to Alisson - Alisson sends 1.1 GC to Noah - 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Block 2 hash: 569b977306ce88b53e001dca7ba00c03a51c60d6df4650e7657dcd136f2da0ac

Puedes ver el proyecto actual en este repositorio de GitHub.

Codificando una cadena de bloques

No es tan inteligente basar la integridad de nuestro sistema en variables codificadas a mano, por lo que necesitamos otro enfoque.

Tenemos los bloques. Es hora de construir una clase que los una en una Blockchain.

Comencemos eliminando nuestras transacciones anteriores y bloqueemos objetos, luego usemos el código a continuación.

# main.py

class Blockchain:
    def __init__(self):
        self.chain = []
        self.generate_genesis_block()

    def generate_genesis_block(self):
        self.chain.append(GeekCoinBlock("0", ['Genesis Block']))
    
    def create_block_from_transaction(self, transaction_list):
        previous_block_hash = self.last_block.block_hash
        self.chain.append(GeekCoinBlock(previous_block_hash, transaction_list))

    def display_chain(self):
        for i in range(len(self.chain)):
            print(f"Data {i + 1}: {self.chain[i].block_data}")
            print(f"Hash {i + 1}: {self.chain[i].block_hash}n")

    @property
    def last_block(self):
        return self.chain[-1]

Esto es nuevamente una gran pieza de código. Desglosemos cada parte:

  • self.chain — La lista donde se registran todos los bloques. Podemos acceder a cada bloque a través de índices de lista.
  • generar_genesis_block — Agrega el génesis o el primer bloque a la cadena. El hash anterior del bloque es «0», y la lista de transacciones es simplemente «Bloque Génesis».
  • create_block_from_transaction — Esto nos permite agregar bloques a la cadena con solo una lista de transacciones. Sería muy molesto crear un bloque manualmente cada vez que queramos registrar una transacción
  • display_chain — Imprime la cadena de bloques con un bucle for
  • last_block — Una propiedad que nos permite acceder al último elemento de la cadena. Lo usamos en el método create_block_from_transaction.

Probemos esta Blockchain.

# main.py

import hashlib

class GeekCoinBlock:
    ...


class Blockchain:
    ...

t1 = "George sends 3.1 GC to Joe"
t2 = "Joe sends 2.5 GC to Adam"
t3 = "Adam sends 1.2 GC to Bob"
t4 = "Bob sends 0.5 GC to Charlie"
t5 = "Charlie sends 0.2 GC to David"
t6 = "David sends 0.1 GC to Eric"

myblockchain = Blockchain()

myblockchain.create_block_from_transaction([t1, t2])
myblockchain.create_block_from_transaction([t3, t4])
myblockchain.create_block_from_transaction([t5, t6])

myblockchain.display_chain()

Ahora, ejecute el archivo main.py.

Data 1: Genesis Block - 0
Hash 1: 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e

Data 2: George sends 3.1 GC to Joe - Joe sends 2.5 GC to Adam - 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e
Hash 2: 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5

Data 3: Adam sends 1.2 GC to Bob - Bob sends 0.5 GC to Charlie - 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5
Hash 3: 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589

Data 4: Charlie sends 0.2 GC to David - David sends 0.1 GC to Eric - 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589
Hash 4: 869df2f03c9860767d35b30a46233fbeea89a3000ae5019d1491e3829d1ab929

¡Felicidades! 🙌 Acabas de crear una Blockchain de Python simple desde cero.

Ahora puede fortalecer la inmutabilidad de Blockchain mediante el uso de getters y setters e implementar otras características como prueba de trabajo, minería o cualquier otro concepto que explicamos en el artículo sobre los fundamentos de Bitcoin Mining.

Conclusión

Blockchain es la tecnología detrás de Bitcoin, Etherium y todas las demás criptomonedas que existen. En este artículo, aprendiste a crear una Blockchain con Python usando algoritmos hash como sha256, clases y objetos.

Tu desafío es crear un sistema de minería y, por qué no, implementarlo con una API REST usando frameworks como Django o Flask.

Muchas personas están haciendo fortunas con las criptomonedas. Solo imagina lo que podrías hacer si creas uno tú mismo. 🤑

¡Sigue codificando! 👨‍💻

No related posts.