• Saltar a la navegación principal
  • Saltar al contenido principal
  • Saltar a la barra lateral principal
  • Saltar al pie de página

Analytics Lane

Ciencia e ingeniería de datos aplicada

  • Ciencia de datos
  • Criptografía
  • Python
  • Matlab
  • R
  • Herramientas
  • Tienda

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

mayo 14, 2018 Por Daniel Rodríguez Deja un comentario

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:

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)

No te olvides valorar esta entrada

Sin votos
Por favor espera...

Archivado en: Criptografía Etiquetado como: Blockchain, Criptomonedas

Entrada anterior: « Valor de ciclo de vida de cliente
Siguiente entrada: Instalación de varias versiones de Python en Anaconda »

Interacciones del lector

Deja un comentario Cancelar la respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Suscríbete a nuestro boletín

Suscríbete al boletín semanal para estar al día de todas las publicaciones de Analytics Lane.

Contenido relacionado

Barra lateral primaria

Tiendas afiliadas

Realiza tus compras mediante los enlaces y colabora con la web, todo sin coste adicional para ti. También puedes ver nuestra tienda. ¡Gracias!
Aliexpress Amazon Banggood Gearbest

Seguir a Analytics Lane

  • twitter
  • pinterest
  • youtube
  • telegram
  • github
  • rss

Seguir en Feedly

follow us in feedly

Suscríbete a nuestro boletín

Suscríbete al boletín semanal para estar al día de todas las publicaciones de Analytics Lane.

Política de Privacidad

Lo mejor valorado

  1. Seleccionar filas y columnas en Pandas con iloc y loc
    Puntuación: 5.0/5. 5 votos.
  2. Unir y combinar dataframes con pandas en Python
    Puntuación: 5.0/5. 5 votos.
  3. Guardar y leer archivos Excel en Python
    Puntuación: 5.0/5. 5 votos.
  4. Eliminar registros duplicados en pandas
    Puntuación: 5.0/5. 5 votos.
  5. Archivos JSON con Python: lectura y escritura
    Puntuación: 4.8/5. 8 votos.

Entradas recientes

  • Truco: ¿cómo se eliminar la salida en una celda de un IPython Notebook? diciembre 13, 2019
  • Numpy básico: como invertir arrays de Numpy diciembre 11, 2019
  • ¿Bajar impuestos para crecer más o crecer más para bajar impuestos? diciembre 9, 2019
  • Copias de seguridad de SQL Server con Microsoft SQL Server Management Studio diciembre 6, 2019
  • Numpy básico: inicializar arrays de Numpy con un valor diciembre 4, 2019

Comentarios recientes

  • Daniel Rodríguez en Operaciones de filtrado de DataFrame con Pandas en base a los valores de las columnas
  • Axel Caballero en Operaciones de filtrado de DataFrame con Pandas en base a los valores de las columnas
  • Daniel Rodríguez en Reglas de asociación y market-basket analysis
  • eva en Reglas de asociación y market-basket analysis
  • Daniel Rodríguez en Proteger las funciones escritas en Matlab para su distribución

Etiquetas

Anaconda Analytics Lane App Designer Bases de datos Blockchain CLV Computación cuántica Criptomonedas Deep learning Elecciones Excel Git GUIDE Hash Java Jupyter Libros Machine learning Marketing node numpy pandas Precios RapidMiner scikit-learn seaborn series temporales Small Data Spark SQL Truco Unit testing VirtualBox

Footer

Secciones

  • Ciencia de datos
  • Criptografía
  • Herramientas
  • Noticias
  • Opinión

Programación

  • JavaScript
  • Julia
  • Matlab
  • Python
  • R

Analytics Lane

  • Acerca de Analytics Lane
  • Boletín de noticias
  • Contacto
  • Tienda

Afiliados

  • AliExpress
  • Amazon
  • BangGood
  • GearBest
  • GearVita
  • Geekbuying
  • JoyBuy

Sobre de Analytics Lane

En Analytics Lane tratamos de explicar los principales conceptos de la ciencia e ingeniería de datos con un enfoque práctico. Los principales temas tratados son ciencia de datos, ingeniería de datos, inteligencia artificial, machine learning, deep learning y criptografía. Además, también se habla de los principales lenguajes de programación y herramientas utilizadas por los científicos e ingenieros de datos.

2018-2019 Analytics Lane · Términos y condiciones · Política de Cookies · Política de Privacidad · Herramientas de privacidad · Contacto