La cadena de bloques puede ser pública o privada. Por eso, primero hay que revisar cómo interactúan estas dos cadenas. Después de ver esa interacción, se compararán las cadenas de bloques públicas y privadas, mostrando los métodos y funciones que sirven para ambas.

Blockchain públicos y privados

Las cadenas de bloques privadas se determinan por los permisos, la escalabilidad, la vulnerabilidad y el cumplimiento normativo.

Cadenas de bloques privadas vs. cadenas de bloques públicas

Las cadenas de bloques públicas no piden permisos. Cualquiera puede unirse y participar, como pasa en una red de pruebas pública o en Bitcoin.

  • Las cadenas de bloques privadas tienen restricciones. Una organización o un grupo autorizado controla quién puede participar.
  • Las cadenas de bloques públicas funcionan bien en sistemas abiertos y democráticos, pero suelen ser más lentas y su escalabilidad es más compleja.
  • Las cadenas de bloques privadas a menudo escalan mejor y pueden ser más fáciles de administrar para usos empresariales.
  • La diferencia radica en la tensión entre la apertura y el control. Las cadenas públicas buscan mayor descentralización, mientras que las privadas dan mayor peso a la gobernanza, el rendimiento y el cumplimiento de las normas.

En resumen, las cadenas de bloques públicas resultan útiles cuando se requiere participación abierta. En cambio, las cadenas de bloques privadas funcionan mejor cuando es necesario controlar el acceso y cumplir con las normas empresariales.

Interacción entre blockchains públicas y privadas

Las cadenas de bloques públicas y privadas se conectan cuando guardan referencias entre sí. Así, la interacción entre ambas se basa en esas referencias.

Para agregar datos de una cadena pública a una privada, un servicio puede monitorear la cadena pública para detectar nuevos bloques y registrar las transacciones relevantes en la cadena privada.

En el ejemplo, las transacciones de Bitcoin se registran en una cadena privada. Luego, el hash de la transacción conecta las dos cadenas.

Para poner datos de una cadena privada en una cadena pública, normalmente no se guardan todos los datos privados, sino un hash que los identifica.

Puedes volver a hacer las pruebas en Bitcoin Core. OP_RETURN se usa para almacenar ese hash en la cadena de bloques de Bitcoin.

Como los hashes son bastante pequeños, caben en el espacio de almacenamiento que permite OP_RETURN.

Conclusión clave: las cadenas de bloques públicas y privadas suelen conectarse mediante anclaje o referencia de datos mediante hashes. Por eso, no se copian los registros privados completos en una cadena pública.

Construye una Blockchain sencilla y privada

Para construir esta cadena de bloques privada simple, seguiremos 6 etapas. Así, al terminar, entenderás los conceptos básicos para crear una cadena de bloques privada.

  1. El modelo de datos del bloque.
  2. Crear nuevos bloques.
  3. Almacenar los bloques.
  4. Enlazar los bloques.
  5. Altura del bloque y sello de tiempo
  6. LevelDB para persistir los datos

Recuerde que un bloque tiene dos partes principales: el encabezado y el cuerpo. El encabezado almacena los metadatos básicos del bloque. El cuerpo guarda los datos.

A diferencia de las plataformas de cadena de bloques rígidas, con tu propia cadena de bloques sencilla puedes definir el modelo de datos directamente en el cuerpo del bloque. De este modo, el diseño del bloque se adapta a lo que necesitas.

La regla principal que permite su funcionamiento como cadena de bloques es que los bloques se vinculan entre sí mediante hashes.

En resumen, vas a crear una cadena de bloques a medida, en la que decides qué datos contienen los bloques y usas hashes para mantener la integridad de la cadena. Así, la lógica del bloque y la de la cadena quedan unidas.

El modelo de datos que vamos a utilizar para un bloque es el siguiente:

// Block data model
{
    "hash": "000000000000e198e04b0759cfecd59a95604cc551db9ad3b12a290375a95419",
    "height": 1325438,
    "body": [
    ],
    "time":,
    "previousblockhash": ""
}

Para crear un bloque nuevo, primero crea un archivo simpleChain.js y escribe una clase Block reutilizable en JavaScript, como se muestra a continuación.

/* ===== Block Class ===================================
|    Class with a constructor for block data model      |
|    ====================================================*/

class Block {
    constructor(data){
        this.height = '';
        this.timeStamp = '';
        this.data = data;
        this.previousHash = '0x';
        this.hash = '';
    }
}

El constructor establece los campos principales del bloque: altura, marca de tiempo, datos, hash anterior y hash.

El objetivo es llevar el modelo de datos del bloque que vimos antes a código real que puedas usar en tu propia cadena de bloques privada. Primero, define la estructura del bloque; después, úsala para crear nuevos bloques. Así, el modelo pasa de la idea a la implementación.

Aún no construyes toda la cadena. Primero haces el plano o el modelo del bloque; luego, con eso, creas los bloques siguientes.

Una vez definido el bloque, crea el contenedor de bloques con una clase llamada Blockchain. El constructor de esta clase inicializa un arreglo llamado chain, en el que se almacenan los bloques. También incluye el método addBlock(), que permite crear un nuevo bloque en el arreglo chain. El siguiente código muestra esto:

/*
|   Class with a constructor for blockchain data model  |
|   with functions to support:                          |
|           - createGenesisBlock()                      |
|           - getLatestBlock()                          |
|           - addBlock()                                |
|           - getBlock()                                |
|           - validateBlock()                          |
|           - validateChain()                          |
|   ====================================================*/

class Blockchain{
    constructor(){
        // new chain array
        this.chain = [];
    }

    // addBlock method
    addBlock(newBlock){
        this.chain.push(newBlock);
    }
}

Ahora transforma una simple colección de bloques en una cadena de bloques real mediante funciones hash y referencias entre bloques. Para ello, usa la biblioteca crypto-js para generar hashes SHA-256 que protejan los datos de cada bloque. Además, actualiza el constructor de la cadena de bloques para que comience con un bloque génesis. También cambia el método addBlock() para que cada bloque nuevo guarde el hash del bloque anterior antes de calcular su propio hash a partir de su contenido.

Así, cada bloque se vincula al anterior mediante criptografía. De ese modo, la cadena gana integridad y resulta más fácil detectar si alguien la ha manipulado. Por eso, los bloques se pueden encadenar.

class Blockchain {
    constructor(){
        // new chain array
        this.chain = [];
        // add first genesis block
        this.addBlock(this.createGenesisBlock());
    }

    createGenesisBlock(){
        return new Block("First block in the chain - Genesis block");
    }

    // addBlock method
    addBlock(newBlock){
        if (this.chain.length>0) {
            // previous block hash
            newBlock.previousHash = this.chain[this.chain.length-1].hash;
        }
        // SHA256 requires a string of data
        newBlock.hash = SHA256(JSON.stringify(newBlock)).toString();
        // add block to chain
        this.chain.push(newBlock);
    }
}

Ahora agrega dos metadatos clave a cada bloque en una cadena de bloques privada simple: su altura y su marca de tiempo. En la función addBlock(), la altura del bloque depende de la longitud actual de la cadena, lo que indica la posición de cada bloque en la secuencia. Para crear una marca de tiempo en UTC, crea un nuevo objeto Date, convierte la hora actual a texto y elimina los tres últimos dígitos. Así, el valor queda en segundos, no en milisegundos. Esto ayuda a identificar y verificar cada bloque, y a preparar los datos de la cadena de bloques para compararlos con fuentes externas si es necesario. Los cambios están en el siguiente bloque de código:

const SHA256 = require('crypto-js/sha256');

class Blockchain{
    constructor(){
        // new chain array
        this.chain = [];
        // add first genesis block
        this.addBlock(this.createGenesisBlock());
    }

    createGenesisBlock(){
        return new Block("First block in the chain - Genesis block");
    }

    // getLatest block method
    getLatestBlock(){
        return this.chain[this.chain.length -1];
    }

    // addBlock method
    addBlock(newBlock){
        // block height
        newBlock.height = this.chain.length;
        // UTC timestamp
        newBlock.timeStamp = new Date().getTime().toString().slice(0,-3);
        if (this.chain.length>0) {
            // previous block hash
            newBlock.previousHash = this.getLatestBlock().hash;
        }
        // SHA256 requires a string of data
        newBlock.hash = SHA256(JSON.stringify(newBlock)).toString();
        console.log(JSON.stringify(newBlock));
        // add block to chain
        this.chain.push(newBlock);
    }
}

Esta publicación concluye con un repaso de lo realizado: se creó una cadena de bloques privada sencilla. Los bloques están enlazados y forman un conjunto de datos. Como la versión presentada es simple a propósito, no incluye un mecanismo de consenso entre pares. Agregar este mecanismo sería una mejora si se buscara una cadena de bloques más avanzada. Además, el resumen vuelve a la comparación entre cadenas de bloques públicas y privadas y menciona que es posible conectar diferentes cadenas de bloques mediante hashes. En conjunto, la lección sirve como primer paso para crear una cadena de bloques privada antes de pasar a funciones más complejas.