¿Cómo crear una Blockchain con Python?

¿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 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

En pocas palabras, Blockchain es un libro de contabilidad digital compartido e inmutable que almacena transacciones en 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 con 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

“

""

import has

hlib
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

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 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 <x>[4]</x>: h1
Out<x>[4]</x>: <objeto sha256 ... @ 0x7efcd55bfbf0>

En <x>[5]</x>: h1.hexdigest()
Out<x>[5]</x>: 'a40cf9cca ... 42ab97'

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

En <x>[7]</x>: h2
Salida<x>[7]</x>: <sha256 ... objeto @ 0x7efcd55bfc90>

En <x>[8]</x>: h2.hexdigest()
Salida<x>[8]</x>: '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 blockchain, su hash cambiará drásticamente. Esta es la razón por la que el dicho “No se puede corromper una Blockchain” es cierto

Utilizando 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

class 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 arbitraria o hash, en este caso, “firstblock”

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

print(f "Datos del bloque 1: {block1.block_data}")
print(f "Hash del bloque 1: {block1.block_hash}")

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

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

print(f "Block 2 data: {block2.block_data}")
print(f "Block 2 hash: {block2.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
Bloque 1 hash: 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Bloque 2 datos: 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 - firstblock
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 y objetos de bloque anteriores, y luego utilicemos el código siguiente

# main.py

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

 def generate_genesis_block(self):
 self.chain.append(GeekCoinBlock("0", ['Bloque Génesis']))
    
 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 "Datos {i 1}: {self.chain<x>[i]</x>.block_data}")
 print(f "Hash {i 1}: {self.chain<x>[i]</x>.block_hash}\n")

 @property
 def last_block(self):
 return self.chain[-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

import hashlib

class GeekCoinBlock:
...


class Blockchain:
...

t1 = "George envía 3.1 GC a Joe"
t2 = "Joe envía 2.5 GC a Adam"
t3 = "Adam envía 1.2 GC a Bob"
t4 = "Bob envía 0.5 GC a Charlie"
t5 = "Charlie envía 0.

2 GC a David”

t6 = "David envía 0,1 GC a 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

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

Datos 2: George envía 3,1 GC a Joe - Joe envía 2.5 CG a Adán - 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e
Hash 2: 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5

Dato 3: Adán envía 1,2 CG 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, Etherium, y cualquier otra criptodivisa que exista. En este artículo, ha aprendido 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. Imagina lo que podrías hacer si creas una por ti mismo. 🤑

¡Siga codificando! 👨‍💻