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

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

¿Qué es Blockchain?

En 2008, el artículo de 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 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 en día conocida como Blockchain.

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

Podemos dividir Blockchain en dos términos simples:

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

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

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

Blockchain presenta un interesante conjunto de características:

• Inmutabilidad de la historia
• Persistencia de la información
• Sin errores con los datos almacenados

Actualmente, muchos sistemas dependen de Blockchain, como las criptomonedas, la transferencia de activos (NFT) y, posiblemente, en un futuro cercano, la votación.

Vale la pena mencionar que Python Blockchain no tiene por qué 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 un 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
• Utilice nuestra Blockchain con transacciones preestablecidas representadas como cadenas
• Prueba la inmutabilidad de nuestra Blockchain

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

Qué necesitarás para seguir este tutorial:

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

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, importe hashlib, un módulo que nos permite crear mensajes cifrados unidireccionales. Las técnicas de criptografía como el hash 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 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, solo importe 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 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 un fragmento de código torpe. Analicemos cada parte en la siguiente sección.

Explicación de GeekCoinBlock

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 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 prediseñado para hacer bloques inmutables.

Esta función recibe cadenas codificadas (o bytes) como parámetros. Es por eso que usamos 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 que el dicho "No se puede corromper una Blockchain" es cierto.

Usando nuestra clase de bloque

Construiremos una clase Blockchain completa más tarde, 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 usando 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á 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 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}")

Ejecutemos y analicemos el resultado que obtenemos de este fragmento de código. Una vez más, escribe 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 retoma prácticamente el mecanismo de Blockchain.

Empiezas 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

Puede ver el proyecto actual en este repositorio de GitHub.

Codificar 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 crear una clase que los una en una Blockchain.

Comencemos por eliminar nuestras transacciones anteriores y bloquear 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]

Este es nuevamente un gran fragmento de código. Analicemos cada parte:

• self.chain : la lista donde se registran todos los bloques. Podemos acceder a cada bloque a través de índices de lista.
• generate_genesis_block : agrega la génesis o el primer bloque a la cadena. El hash anterior del bloque es "0" y la lista de transacciones es simplemente "Genesis Block".
• 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 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. Lo usamos en el método create_block_from_transaction .

Probemos este 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! Acaba de crear una cadena de bloques de Python simple desde cero.

Ahora puede fortalecer la inmutabilidad de Blockchain mediante el uso de captadores y definidores e implementar otras características como prueba de trabajo, minería o cualquier otro concepto que explicamos en el artículo Fundamentos de minería de Bitcoin.

Conclusión

Blockchain es la tecnología detrás de Bitcoin, Etherium y todas las demás criptomonedas que existen. En este artículo, aprendió cómo crear una cadena de bloques con Python mediante el uso de algoritmos hash como sha256 , clases y objetos.

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

Mucha gente está haciendo fortunas con las criptomonedas. Imagínese lo que podría hacer si creara uno por sí mismo.

¡Sigue codificando!