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

¿Qué es Blockchain?

En 2008, el documento Bitcoin fue publicado por un individuo o grupo desconocido llamado Satoshi Nakamoto. Bitcoin surgió como una versión peer-to-peer de dinero 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 paper, Satoshi definió una forma distribuida de almacenar información, hoy conocida como Blockchain.

Blockchain technology
Tecnología Blockchain

En pocas palabras, Blockchain es un libro de contabilidad digital compartido e inmutable que almacena las transacciones a través de una red descentralizada de ordenadores.

Podemos dividir Blockchain en dos términos sencillos:

  • Bloque: Espacio donde se almacenan las transacciones
  • Cadena: Un conjunto de registros vinculados

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

Cada bloque se construye sobre otro, 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 cualquiera con los permisos correctos puede revisar la integridad.

Blockchain introduce un interesante conjunto de características:

  • Inmutabilidad del historial
  • Persistencia de la información
  • Ausencia de errores en los datos almacenados

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

Cabe mencionar que una Blockchain de Python no tiene por qué ser un programa complejo con miles de líneas de código. En su esencia, sería una lista de transacciones vinculadas entre sí.

Por supuesto, esta ha sido una breve explicación, pero si desea una guía completa, hemos elaborado un tutorial completo sobre Blockchain para principiantes. Asegúrese de echarle un vistazo.

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

Construir una Blockchain con Python

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

  • Construir un sistema Blockchain simple escrito en Python
  • Utilizar nuestra Blockchain con transacciones preestablecidas representadas como cadenas
  • Probar la inmutabilidad de nuestra Blockchain

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

Lo que necesitará para seguir este tutorial

  • Comprensión de clases y métodos en Python
  • Uso básico de la línea de comandos

Creación de 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, importe hashlib, un módulo que nos permite crear mensajes cifrados unidireccionales. Las técnicas criptográficas como el hashing hacen que Blockchain cree transacciones seguras.

Una función hash es un algoritmo que toma algunos datos (normalmente una cadena codificada) y devuelve un identificador único, a menudo llamado «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, limítese a importar el módulo incorporado hashlib:

# archivo main.py
"""
Una simple Blockchain en Python
"""

importar hashlib

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

Ahora, entremos en GeekCoinBlock, nuestro nombre de blockchain totalmente original.

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

        self.previous_block_hash = previous_block_hash
        self.lista_transacciones = lista_transacciones

        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 una pieza torpe de código. Desglosemos cada parte en la siguiente sección.

Explicación de GeekCoinBlock

En primer lugar, creamos una clase llamada GeekCoinBlock, una envoltura para objetos que tendrán ciertas características (atributos) y comportamientos (métodos).

Después 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 las transacciones realizadas en el bloque actual).

Almacenamos el hash anterior y la lista de transacciones y creamos una variable de instancia block_data como cadena. Esto no ocurre 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.

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

Esta función recibe cadenas codificadas (o bytes) como parámetros. Por eso usamos el método block_data.encode(). Después, llamamos a hexdigest () para que nos devuelva los datos codificados en formato hexadecimal.

Sé que todo esto puede resultar abrumador, así que juguemos con hashlib en un intérprete de comandos Python.

En [1]: import hashlib

En [2]: message = "Python es genial"

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

En [4]: h1
Out[4]: <objeto sha256="" @="" 0x7efcd55bfbf0="">

En [5]: h1.hexdigest()
Salida[5]: 'a40cf9cca ... 42ab97'

En [6]: h2 = hashlib.sha256(b "Python no es genial")

En [7]: h2
Out[7]: <objeto sha256="" @="" 0x7efcd55bfc90="">

En [8]: h2.hexdigest()
Salida[8]: 'fefe510a6a ... 97e010c0ea34'</objeto></objeto>

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 blockchain, su hash cambiará drásticamente. Esta es la razón por la que el dicho «No se puede corromper una Blockchain» es cierto.

Utilización de nuestra clase Block

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

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

clase GeekCoinBlock:
    ...

t1 = "Noah envía 5 GC a Mark"
t2 = "Mark envía 2,3 GC a James"
t3 = "James envía 4.2 GC a Alisson"
t4 = "Alisson envía 1.1 GC a 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 previous_hash del bloque génesis (primer bloque que precede a otros bloques) siempre será alguna cadena o hash arbitrario, en este caso, «firstblock»

bloque1 = GeekCoinBlock('primerbloque', [t1, t2])

print(f "Datos del bloque 1: {datos_del_bloque1}")
print(f "Bloque 1 hash: {bloque1.block_hash}")

A continuación, hacemos lo mismo con el segundo bloque, pero pasándole el hash del primer bloque como argumento previous_hash .

bloque2 = GeekCoinBlock(bloque1.hash_bloque, [t3, t4])

print(f "Datos del bloque 2: {datos_del_bloque2}")
print(f "Bloque 2 hash: {bloque2.block_hash}")

Vamos a ejecutar y analizar la salida que obtenemos de este trozo de código. Una vez más, escriba en su terminal

❯ python main.py
Datos del bloque 1: Noah envía 5 GC a Mark - Mark envía 2,3 GC a James - firstblock
Hash del bloque 1 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Datos del bloque 2: James envía 4,2 GC a Alisson - Alisson envía 1,1 GC a Noah - 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Hash del bloque 2: 448c4306caf7f6937b0307f92f27fbea3bb73b3470363dee5026a1209dadcfa8

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

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

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

t2 = "Mark envía 2,3 GC a James" -> t2 = "Mark envía 3,2 GC a James"

Vemos un cambio drástico en el hash de los bloques.

Datos del bloque 1: Noah envía 5 GC a Mark - Mark envía 3,2 GC a James - primerbloque
Hash del bloque 1: 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Datos del bloque 2: James envía 4,2 GC a Alisson - Alisson envía 1,1 GC a Noah - 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Hash del bloque 2: 569b977306ce88b53e001dca7ba00c03a51c60d6df4650e7657dcd136f2da0ac

Puede ver el proyecto actual en este repositorio de GitHub.

Codificación de una cadena de bloques

No es muy inteligente basar la integridad de nuestro sistema en variables codificadas a mano, así que necesitamos otro enfoque.

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

Empecemos borrando nuestras transacciones anteriores y los objetos bloque, y luego utilicemos el código siguiente.

# main.py

clase Blockchain:
    def __init__(self):
        self.chain = []
        self.generar_bloque_genesis()

    def generar_bloque_genesis(self):
        self.chain.append(GeekCoinBlock("0", ['Bloque Génesis']))
    
    def crear_bloque_desde_transacción(self, lista_transacciones):
        bloque_anterior_hash = self.ultimo_bloque.block_hash
        self.chain.append(GeekCoinBlock(previous_block_hash, transaction_list))

    def mostrar_cadena(self):
        for i in range(len(self.chain)):
            print(f "Datos {i 1}: {self.cadena[i].datos_bloque}")
            print(f "Hash {i 1}: {self.cadena[i].block_hash}\n")

    @propiedad
    def ultimo_bloque(self):
        return self.cadena[-1]

Esto es de nuevo un enorme trozo de código. Desglosemos cada parte:

  • self. chain – La lista donde se registran todos los bloques. Podemos acceder a cada bloque mediante índices de lista.
  • generate_genesis_block – Añade el genesis o 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 – Nos permite añadir bloques a la cadena con sólo una lista de transacciones. Sería muy molesto crear un bloque manualmente cada vez que queremos 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. La utilizamos en el método create_block_from_transaction.

Pongamos a prueba esta Blockchain.

# main.py

importar hashlib

clase GeekCoinBlock
    ...


class Blockchain:
    ...

t1 = "Jorge envía 3,1 GC a Joe"
t2 = "Joe envía 2,5 GC a Adam"
t3 = "Adán envía 1,2 CG a Bob"
t4 = "Bob envía 0,5 CG a Charlie"
t5 = "Charlie envía 0,2 CG a David"
t6 = "David envía 0,1 CG a Eric"

miblockchain = Blockchain()

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

mi_cadena_de_bloques.mostrar_cadena()

Ahora, ejecute el archivo main.py .

Datos 1: Bloque Génesis - 0
Hash 1: 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e

Dato 2: George envía 3,1 GC a Joe - Joe envía 2,5 GC a Adam - 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e
Hash 2: 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5

Datos 3: Adam envía 1,2 GC a Bob - Bob envía 0,5 GC a Charlie - 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5
Hash 3: 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589

Datos 4: Charlie envía 0,2 GC a David - David envía 0,1 GC a Eric - 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589
Hash 4: 869df2f03c9860767d35b30a46233fbeea89a3000ae5019d1491e3829d1ab929

¡Felicidades! 🙌 Acaba de crear una Blockchain Python sencilla desde cero.

Ahora puede reforzar la inmutabilidad de la Blockchain utilizando getters y setters e implementar otras características como proof-of-work, minería o cualquier otro concepto que explicamos en el artículo Fundamentos de la minería de Bitcoin.

Conclusión

Blockchain es la tecnología detrás de Bitcoin, Ethereum y cualquier otra criptodivisa que exista. En este artículo, aprendió a crear una Blockchain con Python utilizando algoritmos hash como sha256, clases y objetos.

Su reto es crear un sistema de minería, y ¿por qué no implementarlo con una API REST utilizando frameworks como Django o Flask?

Mucha gente está haciendo fortunas con las criptodivisas. Imagínese lo que podría hacer si creara una usted mismo. 🤑

¡Siga codificando! 👨‍💻