Creando un Blockchain para entenderlo mejor
En un artículo anterior: ¿Qué es el Blockchain? Una breve introducción a la Cadena de Bloques. Hablamos un poco sobre lo que nosotros entendemos es el Blockchain, su relación con el Bitcoin y también su independencia del mismo, dado que es una tecnología que puede ser utilizada en otros ámbitos diferentes al de las criptomonedas.
Pero, para ser francos, hablar es fácil, llevarlo a la práctica es todo otro asunto. Así que, ni lerdos ni perezosos, vamos a tratar de implementar una muy muy muy básica Cadena de Bloques en Java.
Desde ya te advertimos lo siguiente: lo que vas a ver acá es muy básico. Solo lo hacemos para afianzar un poco más nuestros conocimientos sobre como funciona el Blockchain.
Tabla de contenidos
Una definición estrictamente técnica sobre el Blockchain
Preparando el artículo en donde hablamos sobre el Blockchain, me encontré con una definición un poco particular, con un enfoque estrictamente técnico y minimalista, a diferencia de la mayoría de las definiciones en donde, en ocasiones, hay mucho de "azúcar para los ojos".
Está definición es de Brian Benchoff, el Satoshi Nakamoto de Hackaday. Brian define la Cadena de Bloques de la siguiente manera:
"Una cadena de bloques es una lista enlazada en la que cada elemento de la lista contiene datos y un hash del elemento anterior de la lista. Para añadir datos a la lista se requiere el acuerdo de la mayoría de los usuarios."
La definición es sencilla y esta exenta de toda lógica de negocio. Esta técnica se podría emplear para cualquier cosa, desde generar un traza de pólizas de seguro, hasta un mecanismo de identificación de propiedad de un asset digital (¿Te suena NFT?).
Creando el Blockchain más básico posible
Vamos a crear un Blockchain en su mínima expresión para ir entendiendo los conceptos fundacionales del mismo. Así que tendremos que codificar un poco (uff, creo que estoy un poco oxidado).
El proyecto está construido en Java, sin mucha magia rara.
Empecemos creando el bloque. El mismo es una sencilla clase que contiene los siguientes datos:
- La huella digital (de acá en más la llamaremos por su nombre: hash).
- El hash del bloque anterior (fundamental en todo eso para implementar trazabilidad y consistencia).
- Datos. El dato que contendrá el bloque. A efectos prácticos simplemente guardaremos un
String. - Fecha de creación del bloque.
El constructor de nuestra clase Block, va a recibir los datos y el hash del bloque anterior. En ese momento, al instanciar el bloque, vamos a persistir el tiempo (timestamp).
Un aspecto muy importante en todo esto del Blockchain, es la generación del hash del bloque actual utilizando el hash del bloque anterior. Para generar el hash utilizamos el método HashCodeBuilder de la librería Apache Commons, pero eso simplemente por comodidad, y a efectos de avanzar rápidamente, dado que la forma correcta sería utilizar SHA-256.
Retomando lo mencionado anteriormente, el bloque actual tiene el hash del bloque anterior y su propio hash, que es generado utilizando el hash del bloque anterior. Esto que quedó como un trabalenguas, es fundamental, ya que si se modifican los datos del bloque anterior, el hash del mismo también será modificado, dado que para generarlo también usamos los datos del bloque. Es decir, si un hash cambia, afecta a todos los bloques anteriores. De ahí el termino cadena, ligados por los hases de los bloques.
Calculamos el hash del bloque con aquellas propiedades que queremos hacer inmutables, es decir, evitar que sean modificadas sin alterar el hash. En nuestro caso vamos a utilizar las siguiente propiedades:
- El hash del bloque anterior.
- La fecha (timestamp).
- Los datos del bloque.
Si uno de estos datos son modificados el hash también se modificara, y nosotros vamos a poder identificar esa alteración.
Quitando la verbosidad de Java (chau! geters y seters), nos queda algo como lo siguiente:
public class Block {
private int hash;
private int previousHash;
private long timeStamp;
private String data;
public Block(String data, int previousHash) {
this.data = data;
this.previousHash = previousHash;
this.timeStamp = new Date().getTime();
this.hash = this.hashCode();
}
public int hashCode() {
return new HashCodeBuilder(17, 23).append(data.hashCode())
.append(previousHash)
.append(timeStamp)
.toHashCode();
}
}Bien, ahora vamos a crear una clase con un método en el cual vamos a construir nuestro Blockchain, es decir, una lista de bloques.
public class Blockchain {
public static ArrayList<Block> chain = new ArrayList<Block>();
public static void main(String[] args) {
String msg = "--> Huella digital (hash) del bloque ";
Block firstBlock = new Block("Génesis", 0);
chain.add(firstBlock);
// Le pasamos el hash del primer bloque
Block secondBlock = new Block("Segundo", firstBlock.getHash());
chain.add(secondBlock);
// Le pasamos el hash del segundo bloque
Block thirdBlock = new Block("Tercero", secondBlock.getHash());
chain.add(thirdBlock);
// Validamos que la cadena de bloque no se encuentre corrupta.
validate();
Block newBlock = new Block("Sustituimos bloque", firstBlock.getHash());
int index = chain.indexOf(firstBlock);
chain.remove(index);
chain.add(index, newBlock);
// La cadena tiene que estar corrupta
validate();
}
}Ahora vamos a construir el método que nos permite validar la integridad de nuestra cadena de bloques.
Para eso simplemente tenemos que iterar por nuestra lista de bloques comparando lo siguiente:
- Que el hash del bloque que está siendo procesado (bloque actual), sea igual a un hash generado con los mismos valores de las propiedades utilizadas inicialmente para generar el hash. Este mecanismo nos avisa si algún valor de la instancia de un bloque a sido alterada.
- Que el hash del bloque anterior sea el mismo que el que se encuentra en el bloque que está siendo procesado (bloque actual).
El método de validación quedaría algo así:
public static Boolean validate() {
Block actual;
Block previous;
for (int i = 1; i < chain.size(); i++) {
actual = chain.get(i);
previous = chain.get(i - 1);
if (Integer.compare(actual.getHash(), actual.hashCode()) != 0) {
System.out.println("--> Error: La huella digital (hash) del bloque actual " + actual.getHash()+ " no coincide con la esperada: " + actual.hashCode());
return false;
}
if (Integer.compare(previous.getHash(), actual.getPreviousHash()) != 0) {
System.out.println("--> Error: La huella digital (hash) del bloque actual " + actual.getHash() + " no coincide con la del bloque previo en la cadena: " + previous.hashCode());
return false;
}
}
System.out.println("--> OK: Cadena de bloques valida");
return true;
}Si ejecutamos la clase Blockchain, la consola nos mostrara lo siguiente:
--> Huella digital (hash) del bloque génesis: 1594171198
--> Huella digital (hash) del bloque dos: -2094399895
--> Huella digital (hash) del bloque tres: 695525592
--> OK: Cadena de bloques valida
--> Error: La huella digital (hash) del bloque actual -2094399895 no coincide con la del bloque previo en la cadena: 1343423454A modo de resumen
Esto es, sin lugar a duda, un ejemplo muy básico al cual el faltan integrar cantidad de conceptos esenciales, como ser: la prueba de trabajo, usar SHA-256 para generar el hash, implementación de árboles merkle, y ni que hablar del soporte para la distribución de los bloques entre nodos.
Si queres profundizar más en el tema te dejamos algunos de los tutoriales que nosotros consideramos tienen el equilibrio justo entre profundidad y claridad:
- Crea tu propia blockchain en Java
- Implementing a Simple Blockchain in Java
- Creating Your First Blockchain with Java
También aprovechamos la ocasión para dejarte un serie de videos con, a mi entender, la mejor explicación gráfica sobre el funcionamiento del Blockchain, realizada por Anders Brownworth.
Parte 1
✋ ¿Te gusta copiar y pegar artículos cómo si fueran tuyos? No te culpamos. Así que te la vamos a hacer fácil mira: nuestros artículos tienen una licencia WTFPL acrónimo de Do What the Fuck You Want to Public License. De nada.
— Foto de portada de Terry