Ebben a cikkben a Go blokklánc fejlesztésére fogunk összpontosítani a semmiből. Mielőtt azonban elkezdenénk, győződjön meg arról, hogy ismeri a Golang alapfogalmait. Ha nem, akkor bölcs dolog, ha végigmész az előzetes koncepciókon, majd visszatérsz a blokklánchoz.
Tehát térjünk közvetlenül a témára.
Kezdve egy új könyvtárral
Kezdésként egy új könyvtárat építünk. Tegyük fel, hogy ennek a könyvtárnak a neve „blockchain”. A kódot beírjuk a parancssorba (vagy ha macOS-t vagy Linuxot használ, akkor a terminált kell használnia). Így beírjuk:
cd go-workspace
mkdir blokklánc
cd blokklánc
kód .
Amint megnyílik a VS-kód, létrehozunk egy Go modult a parancssorban. Hogyan csináljuk? Nos, beírjuk:
go mod init github.com/golang-company/blockchain
Kódolás a main.go-ban
Ezután létrehozunk egy „main.go” nevű Go forrásfájlt, és beírjuk a kódot. De először értsük meg, mi az a blokklánc. A blockchain decentralizált és több társ között elosztott nyilvános adatbázisként határozható meg. A blokklánc lehetővé teszi az adatbázis számára az önkorrekciót, még akkor is, ha egy csomópont pontatlan adatokat állít elő.
Általában egy blokklánc blokkja az adatbázisban megosztott adatokból, egy hash-ből és az előző blokk kriptográfiai hashéből áll.
Szóval, készen állsz Irány a blokklánc fejlesztés? Nagy! Kezdjük el.
Programozási rész
Ebben a részben megvizsgáljuk a main.go fájlt.
csomag fő
import(
"bájt"
"crypto/sha256"
"fmt"
)
type Cryptoblock struct {
Hash [] bájt
Adat [] bájt
PrevHash [] bájt
}
- Mint látható, egy struktúra csak létrejött.
func (c *Cryptoblock) BuildHash() {
részletek := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{})
hash := sha256.Sum256(részletek)
c.Hash = hash[ : ]
}
- Most felállítunk egy metódust, amely lehetővé teszi számunkra, hogy az adatoktól és az előző hash-től függően hash-t generáljunk. Importáljuk a „bytes” könyvtárat, mert azt használni fogjuk.
- A következő lépés a részletek nevű változó létrehozása, és az adattípus byte használata. A Join()-t használjuk a bájtszeletek összekapcsolásához.
részletek := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{})
Itt veszünk egy 2D bájtszeletet, továbbítjuk a c.Data-t és az előző hash-t. Ezután egyesítjük az üres bájtszeletet.
- Ezt követően elkészítjük a tényleges hash-t a sum256 hash függvény segítségével a részleteken. Ezt használhatjuk az sha256 könyvtár importálásához.
- Ezután a létrehozott hash-t benyomjuk a blokk Hash mezőjébe.
func BuildBlock (adatkarakterlánc, prevHash [] bájt) *Cryptoblock {
blokk := &Cryptoblock{[]byte{}, []byte(data), prevHash}
block.BuildHash()
visszatérő blokk
}
- Most létrehozunk egy függvényt, amely lehetővé teszi a blokk létrehozását. A függvény adatsort fogad be bemenetként, prevHash-t az előző blokkból bemenetként, majd egy hivatkozást ad ki a Cryptoblock-ra. A blokkot a blokkkonstruktor segítségével építjük meg.
- A &kriptoblokk a blokkra való hivatkozásként működik. A Hash mezőben egy üres bájtszeletet építünk be. Az Adat mezőben az adatkarakterláncot vesszük, és bájtok szeletévé alakítjuk. És beépítjük a prevHash-t a PrevHash mezőbe.
- Végül meghívjuk a BuildHash()-t a blokkon, és visszaadjuk a blokkot.
type BlockChain struct {
blokkok []*Cryptoblock
}
- Olyan típusra van szükség, amely segít a blokklánc kifejezésében. És ennek megvalósítására megvalósítottunk egy struktúrát. A BlockChain típusú struktúra a Cryptoblockra mutató mutatók tömbjéből áll.
func (chain *BlockChain) AddBlock(adatkarakterlánc) {
prevBlock := chain.blocks[len(chain.blocks)-1]
new := BuildBlock(data, prevBlock.Hash)
chain.blocks = append(chain.blocks, new)
}
- Itt egy olyan módszert hozunk létre, amely lehetővé teszi, hogy egy blokkot csatlakoztassunk a lánchoz. A módszer lekéri a blokklánc mutatót. Ezt követően adatkarakterláncot fogad el.
- A chain.blocks meghívásával a blokkláncban az előző blokkhoz jutunk. Ezután átadtuk a blokklánc hosszát [len(chain.blocks)-1].
- Az új változóban a BuildBlock függvényt hívjuk meg, és adatkarakterláncot és prevBlock.Hash-t adunk át.
- Az append funkciót felhasználva, hozzáadva ezt a chain.blocks-hoz, az új blokkot a blokklánchoz csatoljuk.
func Inception() *Cryptoblock {
return BuildBlock("Kezdet", []byte{})
}
- A következő lépés az Inception nevű függvény létrehozása, amely leírja a blokklánc első blokkját. És a függvényben egy új BuildBlock-ot adunk vissza, az első blokkban lévő adatokkal együtt. Itt. Beépítettem az „Inception”-t és egy bájtszeletet, amely egy üres előző hash-t jelent.
func InitBlockChain() *BlockChain {
return &BlockChain{[]*Cryptoblock{Kezdet()}}
}
- Az első blokklánc létrehozásához bevezettem az InitBlockChain funkciót. Itt csak a BlockChain konkrét utalását adom vissza. Ezután felépítjük a Cryptoblock tömbjét, ahol meghívjuk az Inception függvényt.
func main () {
lánc := InitBlockChain()
chain.AddBlock ("Első blokk a kezdet után")
chain.AddBlock ("Második blokk a kezdet után")
chain.AddBlock ("Harmadik blokk a kezdet után")
for _, block := range chain.blocks {
fmt.Printf(“Előző hash: %x\n”, block.PrevHash)
fmt.Printf(“Adatok a blokkban: %s\n”, block.Data)
fmt.Printf("Hash: %x\n", block.Hash)
}
}
- Végül elérkeztünk a fő funkcióhoz. Amint láthatja, meghívtuk az InitBlockChain()-t, és hozzárendeltük a láncváltozóhoz.
- Ezután a chain.AddBlock segítségével blokkokat adunk a lánchoz, és átadjuk a szükséges adatokat.
- Ezt követően egy for ciklust futtatunk, hogy ellenőrizzük a blokkláncot. Ezután mindegyik blokkot különválasztjuk, és minden blokkon belül kinyomtatjuk a mezőket. Csak beírjuk:
fmt.Printf(“Előző hash: %x\n”, block.PrevHash)
fmt.Printf(“Adatok a blokkban: %s\n”, block.Data)
fmt.Printf("Hash: %x\n", block.Hash)
output:
Tehát elmondhatjuk, hogy a program sikeres volt. Remélem, sikerült megértened a blokklánc koncepciójának megvalósítását Golangban. Csak folytasd a gyakorlást, és képes leszel bonyolult projekteket kezelni.
A kriptokódja megérdemli a legjobb biztonságot. Kap egy Ledger hardver pénztárca mindössze 79 dollárért!
Forrás: https://coinfomania.com/build-a-blockchain-in-golang/