ააშენეთ ბლოკჩეინი გოლანგში ნულიდან

ამ სტატიაში ჩვენ ყურადღებას გავამახვილებთ Go blockchain-ის განვითარებაზე ნულიდან. თუმცა, სანამ დავიწყებთ, დარწმუნებული უნდა იყოთ, რომ იცნობთ Golang-ის ძირითად ცნებებს. თუ არა, მაშინ გონივრული იქნება, თუ გაივლით წინასწარ ცნებებს და შემდეგ დაუბრუნდებით ბლოკჩეინს. 

ასე რომ, პირდაპირ თემას გადავიდეთ. 

იწყება ახალი დირექტორია 

დასაწყისისთვის ჩვენ ავაშენებთ ახალ დირექტორიას. დავუშვათ, რომ ამ დირექტორიას აქვს სახელი "ბლოკჩეინი". ჩვენ ჩავწერთ კოდს Command Prompt-ში (ან თუ იყენებთ macOS-ს ან Linux-ს, უნდა გამოიყენოთ ტერმინალი). ამრიგად, ჩვენ ვწერთ:

cd go-workspace 

mkdir ბლოკჩეინი 

CD ბლოკჩეინი 

კოდი .

როგორც VS კოდი იხსნება, ჩვენ შევქმნით Go მოდულს Command Prompt-ში. როგორ მოვიქცეთ ასე? კარგად, ჩვენ ვწერთ:

გადადით mod init github.com/golang-company/blockchain

კოდირება main.go-ში 

შემდეგი, ჩვენ შევქმნით Go-ს წყაროს ფაილს სახელად 'main.go' და ჩავწერთ მასში კოდს. მაგრამ ჯერ გავიგოთ რა არის ბლოკჩეინი. ა blockchain შეიძლება განისაზღვროს, როგორც საჯარო მონაცემთა ბაზა, რომელიც დეცენტრალიზებულია და ნაწილდება რამდენიმე თანატოლს შორის. ბლოკჩეინი საშუალებას აძლევს მონაცემთა ბაზას თვითგამოსწორება, მაშინაც კი, თუ კვანძი აწარმოებს არაზუსტ მონაცემებს. 

ჩვეულებრივ, ბლოკჩეინზე ბლოკი შედგება მონაცემთა ბაზაში, ჰეშისა და წინა ბლოკის კრიპტოგრაფიული ჰეშისგან. 

 ასე რომ, მზად ხართ ამისთვის გადადით ბლოკჩეინის განვითარებაზე? დიდი! Დავიწყოთ. 

პროგრამირების ნაწილი 

ამ განყოფილებაში ჩვენ განვიხილავთ main.go ფაილს. 

ძირითადი პაკეტი

იმპორტი (

"ბაიტები"

"კრიპტო/sha256" 

"Fmt" 

)

აკრიფეთ Cryptoblock struct {

ჰეშ [] ბაიტი 

მონაცემები [] ბაიტი 

PrevHash [] ბაიტი 

}

• როგორც ხედავთ, სტრუქტურა მხოლოდ შეიქმნა. 

func (c *Cryptoblock) BuildHash() {

დეტალები := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{}) 

ჰეში := sha256.Sum256(დეტალები)

გ.ჰაშ = ჰაში[ : ]

}

• ჩვენ ახლა ავაშენებთ მეთოდს, რომელიც მოგვცემს საშუალებას, გამოვიმუშაოთ ჰეში, მონაცემებისა და წინა ჰეშის მიხედვით. ჩვენ შემოვიტანთ „ბაიტების“ ბიბლიოთეკას, რადგან მას გამოვიყენებთ.
• შემდეგი ნაბიჯი არის ცვლადის შექმნა სახელწოდებით დეტალები და მონაცემთა ტიპის ბაიტების გამოყენება. ჩვენ გამოვიყენებთ Join() ბაიტების ნაჭრების დასაკავშირებლად.

დეტალები := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{}) 

აქ ჩვენ ვიღებთ ბაიტების 2D ნაჭერს, გადავცემთ c.Data-ს და წინა ჰეშს. შემდეგ ჩვენ გავაერთიანებთ ბაიტების ცარიელ ნაჭერს. 

• ამის შემდეგ, ჩვენ ვქმნით დეტალებზე sum256 ჰეშირების ფუნქციის ფაქტობრივ ჰეშს. ჩვენ შეგვიძლია გამოვიყენოთ ეს, რადგან შევაქვთ sha256 ბიბლიოთეკა. 
• შემდეგი, ჩვენ ვაყენებთ შექმნილ ჰეშს ბლოკისთვის Hash ველში. 

func BuildBlock (მონაცემთა სტრიქონი, prevHash [] ბაიტი) *Cryptoblock {

დაბლოკვა := &კრიპტობლოკი{[]ბაიტი{}, []ბაიტი(მონაცემები), prevHash}

block.BuildHash()

დაბრუნების ბლოკი

} 

• ჩვენ ახლა ავაშენებთ ფუნქციას, რომელიც ბლოკის შექმნის საშუალებას იძლევა. ფუნქცია იღებს მონაცემების სტრიქონს, როგორც შეყვანას, prevHash-ს წინა ბლოკიდან, როგორც შესატანად, შემდეგ კი გამოსცემს მითითებას Cryptoblock-ზე. ჩვენ ავაშენებთ ბლოკს ბლოკის კონსტრუქტორის გამოყენებით. 
• &Cryptoblock მოქმედებს როგორც ბლოკის მითითება. Hash ველისთვის ჩვენ ვაერთიანებთ ბაიტების ცარიელ ნაჭერს. მონაცემთა ველისთვის ჩვენ ვიღებთ მონაცემთა სტრიქონს და ვაქცევთ მას ბაიტების ნაჭერად. და ჩვენ ვაერთიანებთ prevHash-ს PrevHash ველში. 
• და ბოლოს, ჩვენ მოვუწოდებთ BuildHash() ბლოკზე და ვაბრუნებთ ბლოკს. 

აკრიფეთ BlockChain struct {

ბლოკავს []*კრიპტობლოკს

}

• საჭიროა ტიპი, რომელიც დაეხმარება ბლოკჩეინის გამოხატვას. და ჩვენ განვახორციელეთ სტრუქტურა ამის მისაღწევად. ტიპის BlockChain სტრუქტურა შედგება Cryptoblock-ის მაჩვენებლების მასივისაგან.

func (ჯაჭვი *BlockChain) AddBlock(მონაცემთა სტრიქონი) {

prevBlock := chain.blocks[len(chain.blocks)-1]

ახალი := BuildBlock (მონაცემები, prevBlock.Hash)

chain.blocks = დამატება (chain.blocks, ახალი)

}

• აქ ჩვენ ვქმნით მეთოდს, რომელიც საშუალებას მოგვცემს შევუერთოთ ბლოკი ჯაჭვს. მეთოდი იღებს ბლოკჩეინის მაჩვენებელს. ამის შემდეგ ის იღებს მონაცემთა სტრიქონს. 
• chain.blocks-ის გამოძახებით, მივდივართ ბლოკჩეინის წინა ბლოკამდე. შემდეგ გავიარეთ ბლოკჩეინის სიგრძე [len(chain.blocks)-1].
• ახალ ცვლადში ჩვენ ვუწოდებთ BuildBlock ფუნქციას და გადავცემთ მონაცემთა სტრიქონს და prevBlock.Hash-ს.
• დამატების ფუნქციის გამოყენებით, ამის დამატება chain.blocks-ში, შემდეგ ჩვენ ვამაგრებთ ახალ ბლოკს ბლოკჩეინზე.

func Inception() *Cryptoblock {

დააბრუნეთ BuildBlock ("Inception", []byte{})

}

• შემდეგი ნაბიჯი არის ფუნქციის შექმნა სახელწოდებით Inception, რომელიც აღწერს ბლოკჩეინის პირველ ბლოკს. და ჩვენ დავაბრუნებთ ახალ BuildBlock-ს ფუნქციაში, პირველ ბლოკში არსებულ მონაცემებთან ერთად. Აქ. მე ჩართული მაქვს "Inception" და ბაიტების ნაჭერი, რომელიც წარმოადგენს ცარიელ წინა ჰეშს. 

func InitBlockChain() *BlockChain {

დაბრუნება &BlockChain{[]*Cryptoblock{Inception()}}

}

• პირველი ბლოკჩეინის შესაქმნელად, მე შემოვიყვანე InitBlockChain ფუნქცია. აქ, მე უბრალოდ ვუბრუნებ კონკრეტულ მინიშნებას BlockChain-ზე. შემდეგი, ჩვენ ვაშენებთ Cryptoblock-ის მასივს, სადაც ვუწოდებთ Inception ფუნქციას. 

func main() {

ჯაჭვი := InitBlockChain()

chain.AddBlock („პირველი ბლოკი დაწყების შემდეგ“)

chain.AddBlock ("მეორე ბლოკი დაწყების შემდეგ")

chain.AddBlock ("მესამე ბლოკი დაწყების შემდეგ")

for _, block := range chain.blocks {

fmt.Printf(„წინა ჰეში: %x\n“, ბლოკი.PrevHash)

fmt.Printf(„მონაცემები ბლოკში: %s\n“, ბლოკი.მონაცემები)

fmt.Printf(„ჰაში: %x\n“, ბლოკი.ჰაში)

}

}

• საბოლოოდ, ჩვენ მივედით მთავარ ფუნქციამდე. როგორც ხედავთ, ჩვენ გამოვიძახეთ InitBlockChain() და მივანიჭეთ ის ჯაჭვის ცვლადს. 
• შემდეგი, ჩვენ ვამატებთ ბლოკებს ჯაჭვს chain.AddBlock-ის მეშვეობით და ვაძლევთ საჭირო მონაცემებს. 
• ამის შემდეგ ჩვენ ვატარებთ for loop-ს ბლოკჩეინის შესამოწმებლად. შემდეგ გამოვყოფთ თითოეულ ბლოკს და ვბეჭდავთ ველებს თითოეული ბლოკის შიგნით. ჩვენ უბრალოდ ვწერთ:

fmt.Printf(„წინა ჰეში: %x\n“, ბლოკი.PrevHash)

fmt.Printf(„მონაცემები ბლოკში: %s\n“, ბლოკი.მონაცემები)

fmt.Printf(„ჰაში: %x\n“, ბლოკი.ჰაში)

გამოყვანის: 

ასე რომ, შეგვიძლია ვთქვათ, რომ პროგრამა წარმატებულია. ვიმედოვნებ, რომ თქვენ შეძლეთ გაიგოთ ბლოკჩეინის კონცეფციის განხორციელება Golang-ში. უბრალოდ განაგრძეთ ვარჯიში და შეძლებთ რთული პროექტების შესრულებას. 

თქვენი კრიპტო იმსახურებს საუკეთესო უსაფრთხოებას. მიიღეთ ა ლეჯერის ტექნიკის საფულე სულ რაღაც 79 დოლარად!