Il post Guida passo passo per costruire una blockchain con Go (Golang) è apparso per la prima volta su Coinpedia Fintech News
Introduzione
La blockchain ha trasformato radicalmente il modo in cui consideriamo i dati e la sicurezza. In sostanza, la blockchain è un registro distribuito che registra le transazioni su più nodi, rendendo quasi impossibile modificare questi record una volta confermati. Questa innovazione rivoluzionaria ha rivoluzionato il settore finanziario, dando origine al mercato delle criptovalute.
Ma l’influenza della blockchain non si ferma qui: sta rimodellando settori come l’assistenza sanitaria, la gestione della supply chain e oltre.
Go (Golang): la soluzione perfetta per lo sviluppo blockchain
Go, noto anche come Golang, è un linguaggio di programmazione sviluppato da Google, celebrato per la sua efficienza e scalabilità nello sviluppo software. Come linguaggio compilato e tipizzato staticamente, Go traduce il codice direttamente in linguaggio macchina, con conseguente esecuzione più rapida, qualcosa di cui le reti blockchain hanno un bisogno critico.
I sistemi blockchain richiedono velocità e produttività elevate, ed è in questi ambiti che Go eccelle.
Una delle caratteristiche più importanti di Go è la sua capacità di supportare la concorrenza. Ciò significa che Go può gestire più operazioni contemporaneamente, massimizzando l'utilizzo del sistema. Nella blockchain, dove più blocchi e transazioni avvengono contemporaneamente, il modello di concorrenza di Go gestisce queste attività in modo efficiente senza complicare la gestione multi-thread.
Libreria per le esigenze di Blockchain
Go è dotato di una libreria standard completa che fornisce pacchetti essenziali per networking, crittografia e gestione dei dati, funzionalità chiave per qualsiasi sistema blockchain. Inoltre, la semplicità e la leggibilità di Go riducono la curva di apprendimento, rendendo più facile per gli sviluppatori comprendere rapidamente il linguaggio e la sua sintassi.
Forte supporto della comunità
Con una grande e attiva comunità e un crescente supporto del settore, risolvere qualsiasi problema che si presenti durante lo sviluppo della blockchain diventa più facile. Go offre una solida base per gli sviluppatori che desiderano creare soluzioni blockchain scalabili e ad alte prestazioni.
Una guida pratica per lo sviluppo di blockchain con Go
Questo articolo è pensato per i principianti che si immergono nel mondo di Go e blockchain. Imparerai tutto, dall'impostazione del tuo ambiente alla configurazione dei prerequisiti, alla compilazione e al test delle tue applicazioni blockchain. Quindi, sei pronto a esplorare la blockchain con Go? Cominciamo!
Comprendere i concetti di Blockchain con Go
Prima di immergerci nella sintassi e nelle funzioni, è essenziale comprendere i concetti fondamentali della blockchain. Comprendere questi fondamenti renderà più facile seguire i passaggi tecnici successivi.
Nozioni di base sulla blockchain in Go
La blockchain è composta da tre componenti: blocchi, transazioni e catene.
Blocchi: un blocco è un'unità primitiva della blockchain, memorizza in modo permanente i dati delle transazioni. Ogni blocco ha i suoi metadati, come l'indice, il timestamp, l'hash e le informazioni effettive sulla transazione. Questi blocchi sono concatenati insieme, formando un registro sequenziale e immutabile.
Transazione: le transazioni sono la forza trainante del sistema. Rappresentano tutte le informazioni necessarie riguardanti lo scambio di valuta, il trasferimento di informazioni, ecc. sulla rete. Ogni blocco contiene una serie di transazioni che vengono elaborate e verificate dalla rete blockchain.
Catena: ogni blocco ha un puntatore al blocco precedente che funge da riferimento e questo collegamento continuo di blocchi tra loro è chiamato catena di blocchi, da cui il nome Blockchain.
Principi fondamentali della blockchain
Decentralizzazione: a differenza dei database tradizionali gestiti da un'autorità centrale, la blockchain distribuisce il controllo su più nodi. Ogni nodo mantiene una copia della blockchain, garantendo trasparenza e riducendo il rischio di corruzione o fallimento centralizzati.
Immutabilità: una volta che i dati sono registrati sulla blockchain, non possono essere alterati. Ciò si ottiene collegando ogni blocco al precedente tramite un hash crittografico. Ogni tentativo di manomettere un blocco ne altera l'hash, interrompendo la catena e allertando la rete.
Meccanismo di consenso: i meccanismi di consenso sono protocolli che tutti i partecipanti utilizzano per convalidare le transazioni e lo stato del registro. I meccanismi comuni includono Proof of Work (PoW), Proof of Stake (PoS) e Practical Byzantine Fault Tolerance (PBFT).
Pronti a creare Blockchain con Go?
A questo punto, dovresti avere una solida conoscenza dei fondamenti della blockchain. Ora arriva la parte emozionante! Nelle sezioni seguenti, ti guideremo passo dopo passo nella creazione delle tue applicazioni blockchain usando Go.
Preparati a metterti all'opera! Immergiamoci nel lato pratico dello sviluppo blockchain con Go.
Capitolo 1: Impostazione dell'ambiente di sviluppo
Prima di iniziare a scrivere codice e contratti, è necessario il giusto ambiente di sviluppo. Ciò comporta un paio di passaggi. Di seguito è riportata una guida dettagliata per iniziare. Pronti, via!!
Installazione di Go
Scarica e installa l'ultima versione di Go dal sito Web ufficiale
Assicurati di scaricare la versione specifica del sistema (Windows, Mac Os, Linux)
Imposta le variabili d'ambiente:
Windows: il programma di installazione di Go aggiunge automaticamente Go al PATH del tuo sistema, ma puoi aggiungerlo manualmente tramite Proprietà del sistema > Variabili di ambiente se necessario
MacOS/Linux: export PATH=$PATH:/usr/local/go/bin (in bash o zshrc)
Verificare l'installazione utilizzando il comando: go version
Questo ti darà un output per esempio: go versione go1.19.0 linux/amd64
Scelta di un IDE
Un Integrated Development Environment è l'elemento più necessario per qualsiasi tipo di programmazione. In altre parole, è un altro editor di codice. Quando si va a scegliere ci sono un sacco di opzioni, ma le due scelte più popolari sono VSCode e GoLand.
Visual Studio Code: VSCode – sviluppato da Microsoft è una piattaforma open source, versatile e leggera, utilizzata per vari linguaggi di programmazione. Offre potenti funzionalità come il completamento del codice, il debug e il controllo delle versioni.
Scarica VSCode dal sito ufficiale
Seguire le istruzioni sullo schermo e completare l'installazione in base al proprio sistema.
Imposta VSCode dal pannello estensioni (Ctrl + Maiusc + X) e scarica tutto ciò che è necessario come: estensione Go, condivisione live, Gitlens, ecc.
GoLand: GoLand, sviluppato da JetBrains, è un IDE pensato appositamente per lo sviluppo Go. Include potenti strumenti di debug, testing e refactoring, oltre al supporto integrato per database, rendendolo una scelta solida per progetti più grandi.
Scarica GoLand dal sito ufficiale di JetBrains
Imposta e installa GoLAnd e quindi imposta correttamente le variabili del percorso File →Impostazioni →Vai →GOROOT
Ecco fatto, sei pronto per creare progetti blockchain Go!!
Installazione delle librerie richieste
Utilizzare go get per installare le librerie essenziali.
Capitolo 2: Costruire una semplice blockchain con Go
I blocchi sono le unità di base della Blockchain. Il blocco contiene tutte le informazioni sulle transazioni, gli identificatori univoci e i link ai blocchi precedenti. In questo capitolo, esploreremo più in dettaglio la struttura del blocco in Golang.
1. Creazione della struttura del blocco
Il blocco è rappresentato sotto forma di un tipo di dati chiamato struct, può essere un tipo di dati definito dall'utente. La struct del blocco contiene attributi come:
Indice: l'indice è utile per indicare la posizione di qualsiasi blocco nella blockchain.
Timestamp: è l'ora in cui è stato creato il blocco
Dati: contengono qualsiasi tipo di informazione relativa alla transazione o allo stato del blocco.
Hash precedente: è l'hash del blocco precedente collegato a quello corrente.
Hash: Identificatore univoco della chiave di ogni blocco deciso tramite metodi crittografici
Nel seguente frammento di codice abbiamo implementato la struttura del blocco.
tipo Blocco struct { Indice int Timestamp stringa Dati stringa PrecedenteHash stringa Hash stringa}
Implementare metodi per calcolare l'hash del blocco utilizzando la sintassi Go:
import ( “crypto/sha256” “fmt”)func (b *Block) calculateHash() string { data := fmt.Sprintf(“%d%s%s%s”, b.Index, b.Timestamp, b.Data, b.PreviousHash) hash := sha256.Sum256([]byte(data)) return fmt.Sprintf(“%x”, hash)}
La funzione calculateHash() viene utilizzata per calcolare l'hashing del blocco corrente
2. Creazione della struttura Blockchain
Dopo aver definito la blockclass e i suoi attributi, puoi procedere ulteriormente e creare il blocco genesi. Il blocco genesi è il primo blocco nella blockchain che deve essere inizializzato e ha un indice pari a zero. Dopo aver definito il blocco genesi, puoi procedere ulteriormente e aggiungere nuovi blocchi alla tua blockchain utilizzando il metodo addblock(). Dopo aver aggiunto il nuovo blocco, calcola anche l'hash di quel blocco. Ecco il codice:
func createGenesisBlock() Blocco { return Blocco{Indice: 0, Timestamp: “2024-09-16”, Dati: “Blocco Genesis”, Hash Precedente: “0”}}func createGenesisBlock() Blocco { return Blocco{Indice: 0, Timestamp: “2024-09-16”, Dati: “Blocco Genesis”, Hash Precedente: “0”}}func (bc *Blockchain) addBlock(stringa dati) { prevBlock := bc.getLatestBlock() newBlock := Blocco{ Indice: prevBlock.Indice + 1, Timestamp: "2024-09-16", Dati: dati, PreviousHash: prevBlock.Hash, } newBlock.Hash = newBlock.calculateHash() bc.Blocks = append(bc.Blocks, newBlock)}
Capitolo 3: Implementazione dei meccanismi di consenso in Go
Prova di lavoro
Abbiamo già avuto una panoramica dei meccanismi di consenso in questo articolo, ora esploriamoli più approfonditamente in questo capitolo. I meccanismi di consenso sono fondamentali per proteggere e convalidare le transazioni e lo stato del database.
Il meccanismo di consenso più utilizzato è la Proof of Work. In PoW i minatori competono tra loro in una situazione limitata nel tempo per risolvere il difficile puzzle crittografico. Quindi, solo quando trovi il nonce più appropriato e lo fai verificare, il nuovo blocco verrà aggiunto. Questo sforzo aggravato assicura che nessuno possa controllare o introdurre i blocchi senza spendere quegli sforzi computazionali.
Nel primo passaggio dobbiamo aggiungere un attributo proof alla struttura:
}tipo Blocco struct { Indice int Timestamp stringa Transazioni []Transazione Prova int PrecedenteHash stringa}
Nel secondo passaggio implementare il metodo di dimostrazione del lavoro per generare la dimostrazione che soddisfa il livello di difficoltà.
tipo Blocco struct { Indice int Timestamp stringa Transazioni []Transazione Prova int PrecedenteHash stringa}func (b *Block) proofOfWork(lastProof int) int { prova := 0 per !isValidProof(lastProof, proof) { prova++ } ritorna prova }func isValidProof(lastProof, proof int) bool { indovina := strconv.Itoa(lastProof) + strconv.Itoa(proof) guessHash := sha256.New() guessHash.Write([]byte(guess)) guessHashString := fmt.Sprintf(“%x”, guessHash.Sum(nil)) return guessHashString[:4] == “0000” }
Aggiorna la struttura della Blockchain per convalidare la prova prima di aggiungere nuovi blocchi. Questo passaggio assicura che solo blocchi validi vengano aggiunti alla blockchain.
tipo Blockchain struct { Catena []Blocco Transazioni Correnti []Transazione }func (bc *Blockchain) addBlock(prova int, previousHash stringa) { blocco := Blocco{ Indice: len(bc.Catena) + 1, Timestamp: time.Now().String(), Transazioni: bc.Transazioni Correnti, Prova: prova, PreviousHash: previousHash, } bc.Chain = append(bc.Chain, block) bc.CurrentTransactions = nil }func (bc *Blockchain) validProof(lastProof, proof int) bool { indovina := strconv.Itoa(lastProof) + strconv.Itoa(proof) indovinaHash := sha256.New() indovinaHash.Write([]byte(indovina)) indovinaHashString := fmt.Sprintf(“%x”, indovinaHash.Sum(nil)) ritorna guessHashString[:4] == “0000”}
Capitolo 4: Creazione di una semplice API Blockchain con Go
L'interfaccia di programmazione dell'applicazione, nota anche come API, è il cuore e l'anima di qualsiasi applicazione. L'API aiuta diversi software/piattaforme a interagire tra loro. Ciò introduce la natura coesiva e l'integrazione senza soluzione di continuità di reti e sistemi esterni alla blockchain. Le API differenziano la parte front-end e quella back-end e semplificano ulteriormente l'interazione. Le API facilitano la facile integrazione delle funzionalità della blockchain nei sistemi esistenti
Impostazione dell'ambiente API
Poiché Go è già installato e configurato nel tuo sistema, puoi procedere e impostare l'ambiente API. Go ha una libreria standard che è più che sufficiente per le API, ma puoi comunque usare Gin e Swagger per creare e documentare la tua API.
Installa e configura gli strumenti necessari per creare API con Go.
vai a prendere -u github.com/gin-gonic/gin //Gingo prendi -u github.com/swaggo/swag/cmd/swag //Swagger per la documentazione
Creazione dell'API
La creazione di API fornisce un approccio modulare, consentendo l'integrazione scalabile e gestibile delle funzionalità della blockchain in vari sistemi.
Crea un'API per definire gli endpoint per l'aggiunta di blocchi e la visualizzazione della blockchain utilizzando Go.
//Impostazione del serverpackage mainimport ( “github.com/gin-gonic/gin” “net/http”)func main() { r := gin.Default() r.POST(“/mine”, mineBlock) r.GET(“/chain”, getChain) r.Run(“:8080”) } //aggiungi un gestore di blocchifunc addBlockHandler(w http.ResponseWriter, r *http.Request) { var newBlock Blocco json.NewDecoder(r.Body).Decode(&newBlock) blockchain.addBlock(newBlock.Data) json.NewEncoder(w).Encode(newBlock) }func getBlockchainHandler(w http.ResponseWriter, r *http.Request) { json.NewEncoder(w).Encode(blockchain) }//Definisci gli endpoint API func mineBlock(c *gin.Context) { // Logica per estrarre un nuovo blocco c.JSON(http.StatusOK, gin.H{“message”: “Blocco estratto con successo”}) }func getChain(c *gin.Context) { // Logica per restituire il blockchain c.JSON(http.StatusOK, gin.H{“catena”: blockchain}) }
Nel frammento di codice sopra, gli API Block Handler sono funzioni che elaborano richieste relative alle operazioni blockchain, come l'aggiunta di nuovi blocchi o il recupero di dati di blocco. Gli API Endpoint sono URL o percorsi specifici in un'API che corrispondono a diverse operazioni o risorse.
Capitolo 5: Esecuzione e test dell'applicazione
Il passaggio finale di qualsiasi processo di sviluppo è il test dell'applicazione. Questo ci dice molto sulle funzionalità dell'app che abbiamo creato. Esistono diversi metodi di test: test unitari, test integrati e test di garanzia della qualità. È importante testare l'applicazione prima di distribuirla e che sia completamente funzionale.
Esecuzione dell'applicazione
Compila ed esegui l'applicazione blockchain Go.
vai a correre main.go
Questo comando compila ed esegue il tuo codice. Di conseguenza, avrai richieste in arrivo sulla porta 8080 come specificato.
Test con Postman
Testare gli endpoint API utilizzando Postman o curl.
curl -X POST -d ‘{“Dati”:”Nuovo blocco”}’ http://localhost:8080/block
Fai clic su Invia per inviare la richiesta. Dovresti ricevere una risposta che indica se il blocco è stato aggiunto correttamente.
Capitolo 6: Esempio dal vivo di creazione di un'applicazione blockchain con Go
Trionfo! Hai raggiunto la fine del percorso di sviluppo. Prima di concludere, combiniamo tutto ciò che abbiamo studiato finora e implementiamolo in un singolo codice passo dopo passo.
Esecuzione passo dopo passo
Passaggio 1: creare la struttura del blocco con gli attributi necessari utilizzando la sintassi Go.
Passaggio 2: implementare il metodo calculate_hash.
Passaggio 3: definire e inizializzare la struttura Blockchain con un blocco genesi.
Passaggio 4: implementare metodi per aggiungere nuovi blocchi e recuperare il blocco più recente utilizzando Go.
Passaggio 5: aggiungere la funzionalità Proof of Work alla struttura Block e aggiornare la struttura Blockchain.
Passaggio 6: configurare l'ambiente API per gestire le richieste tramite Go.
Fase 7: testare l'applicazione estraendo un nuovo blocco e verificando la blockchain utilizzando Postman o curl.
package mainimport ( “crypto/sha256” “encoding/hex” “encoding/json” “fmt” “log” “net/http” “strconv” “strings” “time” “github.com/gorilla/mux”)// Il blocco rappresenta ogni "elemento" nel tipo di blockchain Blocco struct { Indice int // Posizione del blocco nella catena Timestamp string // Timestamp di creazione del blocco Dati string // Dati memorizzati nel blocco PreviousHash string // Hash del blocco precedente Hash string // Hash del blocco corrente Proof int // Proof of Work}// Blockchain rappresenta l'intera catena di blocchi tipo Blockchain struct { Blocks []Block }// Crea il blocco genesi (il primo blocco nella catena)func createGenesisBlock() Block { return Block{ Indice: 0, Timestamp: time.Now().String(), Dati: “Blocco Genesis”, PreviousHash: “0”, Prova: 0, Hash: calculateHash(0, time.Now().String(), “Blocco Genesis”, “0”, 0), }}// Calcola l'hash del bloccofunc calculateHash(index int, timestamp, data, previousHash string, proof int) string { record := strconv.Itoa(index) + timestamp + data + previousHash + strconv.Itoa(proof) hash := sha256.New() hash.Write([]byte(record)) hashed := hash.Sum(nil) return hex.EncodeToString(hashed) }// Algoritmo Proof of Work: una semplice implementazione PoW in cui troviamo un hash con un certo numero di zeri inizialifunc (b *Block) proofOfWork(difficulty int) { for { b.Hash = calculateHash(b.Index, b.Timestamp, b.Data, b.PreviousHash, b.Proof) if strings.HasPrefix(b.Hash, strings.Repeat(“0”, difficoltà)) { break } b.Proof++ }}// Aggiungi un nuovo blocco alla blockchainfunc (bc *Blockchain) addBlock(data string, difficoltà int) { prevBlock := bc.getLatestBlock() newBlock := Block{ Indice: prevBlock.Index + 1, Timestamp: time.Now().String(), Dati: dati, PreviousHash: prevBlock.Hash, Prova: 0, } newBlock.proofOfWork(difficulty) bc.Blocks = append(bc.Blocks, newBlock) }// Ottieni l'ultimo blocco nella catenafunc (bc *Blockchain) getLatestBlock() Block { return bc.Blocks[len(bc.Blocks)-1] }// Inizializza la blockchain con il blocco genesifunc initializeBlockchain() *Blockchain { genesisBlock := createGenesisBlock() return &Blockchain{[]Block{genesisBlock}}}// Gestori API// Ottieni l'intera blockchainfunc getBlockchainHandler(w http.ResponseWriter, r *http.Request) { json.NewEncoder(w).Encode(blockchain.Blocks)}// Aggiungi un nuovo blocco alla blockchainfunc addBlockHandler(w http.ResponseWriter, r *http.Request) { var newBlockData struct { Stringa dati `json:”data”` } _ = json.NewDecoder(r.Body).Decode(&newBlockData) blockchain.addBlock(newBlockData.Data, trouble) json.NewEncoder(w).Encode(blockchain.getLatestBlock()) }// Inizializza la blockchain e il livello di difficoltà per Proof of Workvar blockchain = initializeBlockchain()var trouble = 3 // Livello di difficoltà di Proof of Work// Imposta l'API serverfunc main() { router := mux.NewRouter() router.HandleFunc(“/blockchain”, getBlockchainHandler).Methods(“GET”) router.HandleFunc(“/block”, addBlockHandler).Methods(“POST”) log.Println(“In ascolto sulla porta 8080…”) log.Fatal(http.ListenAndServe(“:8080”, router))}
Conclusione e direzioni future
Congratulazioni! Hai creato con successo un'applicazione blockchain funzionale usando Go! Grazie a questa guida, hai acquisito competenze fondamentali, tra cui la creazione di una blockchain da zero, l'implementazione di Proof of Work e la configurazione di una REST API per interagire con la tua blockchain. I principali insegnamenti tratti da questo viaggio includono:
Definizione e strutturazione dei blocchi
Implementazione di meccanismi di consenso
Integrazione di API per l'interazione blockchain
Ma questo è solo l'inizio. Mentre continui il tuo viaggio nello sviluppo blockchain con Go, ci sono aree entusiasmanti da esplorare e migliorare.
Il futuro di Go nello sviluppo di applicazioni decentralizzate (dApp) ha un potenziale immenso. Ecco alcuni argomenti avanzati che vale la pena approfondire:
Esplorazione di meccanismi di consenso avanzati
Miglioramenti della scalabilità
Interoperabilità
Applicazioni nel mondo reale
Mentre procedi, non esitare a sperimentare, perfezionare e innovare. Il mondo della blockchain si sta evolvendo rapidamente e le tue competenze con Go ti consentiranno di rimanere all'avanguardia.
Grazie per aver seguito questa guida e buon divertimento nel tuo percorso di sviluppo blockchain!
Guarda anche: Come costruire la tua prima blockchain con Plutus: un tutorial passo dopo passo