es
Volver a la lista

Construya una cadena de bloques en Golang desde cero

source-logo  es.bitcoinethereumnews.com 29 Septiembre 2022 11:03, UTC

En este artículo, nos centraremos en el desarrollo de Go blockchain desde cero. Sin embargo, antes de comenzar, debe asegurarse de estar familiarizado con los conceptos básicos de Golang. De lo contrario, es aconsejable que revise los conceptos preliminares y luego regrese a blockchain. 

Entonces, vayamos directo al tema. 

Comenzando con un nuevo directorio 

Construiremos un nuevo directorio para empezar. Supongamos que este directorio tiene el nombre "blockchain". Escribiremos el código en el Símbolo del sistema (o si está usando macOS o Linux, debe usar la Terminal). Así, tecleamos:

cd go-espacio de trabajo 

cadena de bloques mkdir 

cadena de bloques de cd 

código

Cuando se abra VS Code, crearemos un módulo Go en el símbolo del sistema. ¿Cómo lo hacemos? Bueno, tecleamos:

ir mod init github.com/golang-company/blockchain

Codificación en main.go 

A continuación, crearemos un archivo fuente de Go llamado 'main.go' y escribiremos el código en él. Pero primero entendamos qué es blockchain. A blockchain puede definirse como una base de datos pública que está descentralizada y distribuida entre varios pares. Blockchain permite que la base de datos se autocorrija, incluso si un nodo produce datos inexactos. 

Por lo general, un bloque en una cadena de bloques consta de datos que compartimos en la base de datos, un hash y el hash criptográfico del bloque anterior. 

Entonces, ¿estás listo para Ir al desarrollo de blockchain? ¡Excelente! Empecemos. 

Parte de programación 

En esta sección, examinaremos el archivo main.go. 

paquete principal

importar

"bytes"

“cripto/sha256” 

"Fmt" 

)

escriba estructura de bloque criptográfico {

Hash [] byte 

Datos [] byte 

PrevHash [] byte 

}

  • Como puede ver, solo se ha creado una estructura. 

func (c *Criptobloque) BuildHash() {

detalles := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{}) 

hash := sha256.Sum256(detalles)

c.Hash = hash[ : ]

}

  • Ahora construiremos un método que nos permitirá generar un hash en función de los datos y el hash anterior. Importaremos la biblioteca de "bytes" porque la usaremos.
  • El siguiente paso es crear una variable llamada detalles y usar el tipo de datos bytes. Usaremos Join() para conectar las porciones de bytes.

detalles := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{}) 

Aquí, estamos tomando una porción 2D de bytes, transmitimos el c.Data y el hash anterior. Luego combinaremos la porción vacía de bytes. 

  • Después de esto, estamos creando el hash real tomando la ayuda de la función hash sum256 en los detalles. Podemos usar esto ya que importaremos la biblioteca sha256. 
  • A continuación, insertamos el hash creado en el campo Hash del bloque. 

func BuildBlock (cadena de datos, prevHash [] byte) *Cryptoblock {

bloque := &Cryptoblock{[]byte{}, []byte(datos), prevHash}

bloque.BuildHash()

bloque de retorno

  • Ahora construiremos una función que permita la creación de Block. La función acepta una cadena de datos como entrada, prevHash del bloque anterior como entrada y luego genera una referencia a Cryptoblock. Construiremos el bloque usando el constructor de bloques. 
  • El &Cryptoblock actúa como referencia al bloque. Para el campo Hash, incorporamos una porción vacía de bytes. Para el campo de datos, tomamos la cadena de datos y la convertimos en una porción de bytes. E incorporamos prevHash en el campo PrevHash. 
  • Por último, llamamos a BuildHash() en el bloque y devolvemos el bloque. 

escriba la estructura BlockChain {

bloques []*Criptobloque

}

  • Se requiere un tipo que ayude a expresar la cadena de bloques. E implementamos una estructura para lograr esto. La estructura de tipo BlockChain se compone de una matriz de punteros a Cryptoblock.

func (cadena *BlockChain) AddBlock(cadena de datos) {

prevBlock := cadena.bloques[len(cadena.bloques)-1]

nuevo := BuildBlock(datos, prevBlock.Hash)

cadena.bloques = agregar(cadena.bloques, nuevo)

}

  • Aquí, estamos creando un método que nos permite unir un bloque a la cadena. El método recupera el puntero de la cadena de bloques. Después de esto, acepta una cadena de datos. 
  • Al llamar a chain.blocks, llegamos al bloque anterior en la cadena de bloques. A continuación, pasamos la longitud de la cadena de bloques [len(chain.blocks)-1].
  • En la nueva variable, estamos llamando a la función BuildBlock y estamos pasando la cadena de datos y prevBlock.Hash.
  • Al utilizar la función de agregar, agregando esto a chain.blocks, luego adjuntamos el nuevo bloque a la cadena de bloques.

func Inicio() *Criptobloque {

devuelve BuildBlock(“Inicio”, []byte{})

}

  • El siguiente paso es crear una función llamada Inicio que describa el primer bloque de la cadena de bloques. Y devolveremos un nuevo BuildBlock en la función, junto con los datos del primer bloque. Aquí. He incorporado "Inicio" y una porción de bytes que representa un hash anterior vacío. 

func InitBlockChain() *BlockChain {

volver &BlockChain{[]*Criptobloque{Inicio()}}

}

  • Para crear la primera cadena de bloques, introduje la función InitBlockChain. Aquí, solo estoy devolviendo la referencia particular a BlockChain. A continuación, construimos una matriz de Cryptoblock, donde hacemos una llamada a la función Inception. 

func main () {

cadena := InitBlockChain()

chain.AddBlock ("Primer bloque después del inicio")

chain.AddBlock ("Segundo bloque después del inicio")

chain.AddBlock ("Tercer bloque después del inicio")

para _, bloque := rango cadena.bloques {

fmt.Printf(“Hash anterior: %x\n”, bloque.HashAnterior)

fmt.Printf(“Datos en bloque: %s\n”, bloque.Datos)

fmt.Printf(“Hash: %x\n”, bloque.Hash)

}

}

  • Finalmente, hemos llegado a la función principal. Como puede ver, hemos llamado a InitBlockChain() y lo hemos asignado a la variable de cadena. 
  • A continuación, agregamos bloques a la cadena a través de chain.AddBlock y pasamos los datos necesarios. 
  • Después de esto, ejecutamos un ciclo for para verificar la cadena de bloques. Luego seleccionamos cada bloque e imprimimos los campos dentro de cada bloque. Simplemente tecleamos:

fmt.Printf(“Hash anterior: %x\n”, bloque.HashAnterior)

fmt.Printf(“Datos en bloque: %s\n”, bloque.Datos)

fmt.Printf(“Hash: %x\n”, bloque.Hash)

Salida: 

Entonces, podemos decir que el programa es exitoso. Espero que haya podido comprender la implementación del concepto de blockchain en Golang. Sigue practicando y podrás manejar proyectos complejos. 

es.bitcoinethereumnews.com