Prueba de esfuerzo: creación de una criptomoneda (2º Parte)

En la entrada anterior de esta serie se explico la tecnología de cadenas de bloques y se comenzó a crear una criptomoneda. La cadena de bloques es una base de datos donde los registros, llamados bloques, están enlazados entre sí evitando que puedan ser modificados uno de ellos una vez insertados.

En la implementación que se realizó en la entrada anterior cualquier usuario puede agregar fácilmente nuevos bloques, con lo que podría reescribir la cadena completamente. Para evitar esto se introduce la prueba de esfuerzo. Una prueba de esfuerzo es un problema que no resulta fácil de resolver, pero si que es fácil de verificar una vez obtenida la solución al mismo. Resolver este problema es lo que como “minado”.

Prueba de esfuerzo

La introducción de una prueba de esfuerzo permite también gestionar el intervalo de tiempo promedio que transcurre entre que se agregan bloques. En caso de que el tiempo actual sea menor se puede aumentar la complejidad de la prueba, mientras que si es mayor se puede reducir la complejidad.

Definición del problema

La forma de introducir una prueba de esfuerzo es exigiendo que el hash de cada uno de los bloques verifique unas condiciones especificas para considerarlo valido. Este requisito puede ser que este comience por un número especifico de ceros. Por ejemplo, el hash SHA-256 de la cadena “Hello” expresado en binario se puede calcular utilizando el siguiente código:

En Analytics Lane

Truco: Usar separadores de miles en Python para números grandes

from hashlib import sha256

hash = sha256('Hello'.encode('utf-8')).hexdigest()
bin(int(hash, 16))[2:].zfill(len(hash) * 4)

Con lo que se obtienen el siguiente resultado:

0001100001011111…

En este caso se observa que el hash comienza por tres ceros seguido de dos unos. En una supuesta cadena de bloques se puede pedir que el hash comience por ocho ceros para que el bloque sea valido. La única forma de modificar el hash de un conjunto de datos es modificar estos. Por lo cual se ha de buscar datos que agregados a los originales generen un hash con las características deseadas, lo que se conoce como proceso de minado. En el ejemplo, esto se puede conseguir agregando el entero 419 a la cadena de texto:

hash = sha256(repr(['Hello', 429]).encode('utf-8')).hexdigest()
bin(int(hash, 16))[2:].zfill(len(hash) * 4)

por lo que el nuevo hash verifica las condiciones impuestas

0000000001011110…

La única forma de realizar el proceso de minado es calculada el hash con diferentes conjuntos de datos hasta que se llega a uno que cumpla las condiciones deseadas. Para el ejemplo esto se puede hacer con el siguiente código

def mining(difficulty):
    initial = datetime.now()
    proof = 0
    
    while (True):
        hex_hash = sha256(repr(['Hello', proof]).encode('utf-8')).hexdigest()
        binary_hash = bin(int(hex_hash, 16))[2:].zfill(len(hex_hash) * 4)
        
        if binary_hash[:difficulty] == "0" * difficulty:
            final = datetime.now()
            elapsed = final - initial
            return difficulty, proof, elapsed.total_seconds()
        
        proof += 1

En este caso se utiliza una variable proof a la que se incrementa un numero hasta que se llega al valor para el cual el hash cumple la condición. En el código se ha añadido el calculo de tiempo transcurrido en el proceso de minado, en la siguiente gráfica se puede ver como aumenta este con la dificultad requerida. En la que se puede observar que el crecimiento con el tiempo es exponencial.

Actualización de la cadena de bloques

En la cadena de bloques que se había implementado en la entrada anterior se ha de modificar para incluir la prueba de esfuerzo. Lo primero que se ha de añadir son dos propiedades difficulty y proof en el objeto Block. El primero es un valor entero con el número de ceros necesarios para validar el bloque y el segundo es los datos que se agregan para conseguir el objetico. Una vez añadidos los valores se ha de modificar la función calculate_hash para incluir estos dos valores en el calculo del hash.

Además de las propiedades se han de añadir tres nuevos métodos:

• hash_satisfies_difficulty, en la que se comprobará si el hash satisfice el requisito de dificultad.
• is_valid, en el que se comprobará si el bloque es valido
• mining, con el que realizar el proceso de minado para que el bloque sea valido

Estos tres métodos se muestran en el siguiente código.

def hash_satisfies_difficulty(self):
    binary_hash = bin(int(self.hash, 16))[2:].zfill(len(self.hash) * 4)

    return binary_hash[:self.difficulty] == "0" * self.difficulty
    
def is_valid(self):
    return self.hash_satisfies_difficulty() and self.hash == self.calculate_hash()
    
def mining(self, init=None, maximum_iter=1000):
    if init is not None:
        self.proof = init

    number_iter = 0

    while not self.is_valid() and number_iter < maximum_iter:
        self.proof += 1
        self.hash = self.calculate_hash()
            
        number_iter += 1
            
    return self.is_valid

En el objeto BlockChain simplemente se ha de modificar el método is_valid para compruebe la validez del bloque con lo método definidos anteriormente.

Evaluación del impacto de la dificultad

Para ver el impacto de la dificultad a la hora de minar la cadena de bloques se puede repetir el ejercicio realizado en la entrada anterior en el que se creaba una cadena de bloques con diferentes frutas modificado la exigencia para que un bloque sea valido. Esto se puede conseguir con el siguiente código

data = ["Avocado", "Apple", "Cherry", "Orange", "Strawberry"]

for difficulty in range(4, 21, 4):
    initial = datetime.now()
    
    blockchain = BlockChain(Block(0, data[0], None, None, difficulty=difficulty))

    while not blockchain.chain[0].is_valid():
        blockchain.chain[0].mining()

    for i in range(1, len(data)):
        blockchain.add_block(Block(i, data[i], blockchain.chain[i-1].hash, None))

        while not blockchain.chain[i].is_valid():
            blockchain.chain[i].mining()

    final = datetime.now()
    elapsed = final - initial
    
    print('Elapsed time for difficulty %d is: %f' % (difficulty, elapsed.total_seconds()))

A partir del mismo se puede crear una gráfica en la que puede ver el tiempo necesario para crear el bloque en función de la dificultad. Observándose, como en el caso anterior, un crecimiento exponencial.

Una vez explicado el concepto de prueba de esfuerzo, en la siguiente entrada de la serie se explicará cómo se puede utilizar para mantener el tiempo entre paquetes constantes modificando la dificultad de minando.

Imágenes: Pixabay (mmi9)