בנה בלוקצ'יין בגולנג מאפס

במאמר זה נתמקד בפיתוח Go blockchain מאפס. עם זאת, לפני שנתחיל, אתה צריך להיות בטוח שאתה מכיר את המושגים הבסיסיים בגולנג. אם לא, אז זה חכם אם תעבור על המושגים המקדימים ואז תחזור לבלוקצ'יין. 

אז בואו נגיע ישר לנושא. 

מתחיל עם ספרייה חדשה 

אנחנו נבנה ספרייה חדשה מלכתחילה. הבה נניח שלספרייה הזו יש את השם "blockchain". אנו נקליד את הקוד בשורת הפקודה (או אם אתה משתמש ב-macOS או לינוקס, עליך להשתמש בטרמינל). לפיכך, אנו מקלידים:

cd go-workspace 

mkdir blockchain 

cd blockchain 

קוד .

כשקוד VS נפתח, ניצור מודול Go בשורת הפקודה. איך אנחנו עושים זאת? ובכן, אנו מקלידים:

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

קידוד ב-main.go 

לאחר מכן, ניצור קובץ מקור Go בשם 'main.go' ונקליד בו את הקוד. אבל קודם בואו נבין מה זה בלוקצ'יין. א blockchain ניתן להגדיר כמאגר מידע ציבורי מבוזר ומופץ בין מספר עמיתים. Blockchain מאפשר למסד הנתונים לתקן את עצמו, גם אם צומת מייצר נתונים לא מדויקים. 

בדרך כלל, בלוק ב-blockchain מורכב מנתונים שאנו חולקים במסד הנתונים, hash ו-hash הצפנה של הבלוק הקודם. 

 אז, האם אתה מוכן לך לפיתוח בלוקצ'יין? גדול! בואו נתחיל. 

חלק תכנות 

בסעיף זה, נבחן את הקובץ main.go. 

חבילה עיקרית

ייבוא ​​(

"בתים"

"crypto/sha256" 

"Fmt" 

)

סוג Cryptoblock struct {

Hash [] בתים 

נתונים [] בתים 

PrevHash [] בתים 

}

• כפי שאתה יכול לראות, נוצר רק מבנה. 

func (c *Cryptoblock) BuildHash() {

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

hash := sha256.Sum256(פרטים)

c.Hash = hash[ : ]

}

• כעת נבנה שיטה שתאפשר לנו ליצור hash בהתאם לנתונים ול-hash הקודם. אנו לייבא את ספריית ה-"bytes" כי אנו נשתמש בה.
• השלב הבא הוא ליצור משתנה שנקרא פרטים ולהשתמש בבייטים מסוג הנתונים. נשתמש ב-Join() כדי לחבר את פרוסות הבתים.

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

כאן, אנו לוקחים פרוסה דו-ממדית של בתים, אנו משדרים את c.Data ואת ה-hash הקודם. לאחר מכן נשלב את הפרוסה הריקה של בתים. 

• לאחר מכן, אנו יוצרים את הגיבוב בפועל בעזרת פונקציית הגיבוב sum256 על הפרטים. אנחנו יכולים להשתמש בזה מכיוון שנייבא את ספריית sha256. 
• לאחר מכן, אנו דוחפים את ה-hash שנוצר לשדה Hash עבור הבלוק. 

func BuildBlock (מחרוזת נתונים, prevHash [] byte) *Cryptoblock {

block := &Cryptoblock{[]byte{}, []byte(data), prevHash}

block.BuildHash()‎

בלוק החזרה

} 

• כעת נבנה פונקציה המאפשרת יצירת בלוק. הפונקציה מקבלת מחרוזת נתונים כקלט, prevHash מהבלוק הקודם כקלט, ואז מוציאה הפניה ל-Cryptoblock. נבנה את הבלוק באמצעות בנאי הבלוק. 
• ה-&Cryptoblock פועל כהתייחסות לבלוק. עבור שדה Hash, אנו משלבים פרוסה ריקה של בתים. עבור שדה נתונים, אנו לוקחים את מחרוזת הנתונים וממירים אותה לפרוסת בתים. ואנחנו משלבים את prevHash בשדה PrevHash. 
• לבסוף, אנו קוראים ל-BuildHash() בבלוק ומחזירים את הבלוק. 

סוג BlockChain struct {

blocks []*Cryptoblock

}

• נדרש סוג שיעזור בביטוי הבלוקצ'יין. ויישמנו מבנה כדי להשיג זאת. המבנה מסוג BlockChain מורכב ממערך של מצביעים ל-Cryptoblock.

func (שרשרת *BlockChain) AddBlock(מחרוזת נתונים) {

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

new := BuildBlock(data, prevBlock.Hash)

chain.blocks = append(chain.blocks, new)

}

• כאן, אנו יוצרים שיטה המאפשרת לנו לחבר בלוק לשרשרת. השיטה מאחזרת את מצביע הבלוקצ'יין. לאחר מכן, הוא מקבל מחרוזת נתונים. 
• קורא chain.blocks, אנחנו מגיעים לבלוק הקודם בבלוקצ'יין. לאחר מכן, עברנו את אורך הבלוקצ'יין [len(chain.blocks)-1].
• במשתנה החדש, אנו קוראים לפונקציה BuildBlock ומעבירים מחרוזת נתונים ו-prevBlock.Hash.
• על ידי שימוש בפונקציית append, הוספת זאת ל-chain.blocks, אנו מצמידים את הבלוק החדש לבלוקצ'יין.

func Inception() *Cryptoblock {

return BuildBlock(“Inception”, []byte{})

}

• השלב הבא הוא יצירת פונקציה בשם Inception שתתאר את הבלוק הראשון של הבלוקצ'יין. ונחזיר BuildBlock חדש בפונקציה, יחד עם הנתונים בבלוק הראשון. כאן. שילבתי "Inception" ופרוסת בתים שמייצגת hash קודם ריק. 

func InitBlockChain() *BlockChain {

return &BlockChain{[]*Cryptoblock{Inception()}}

}

• על מנת ליצור את הבלוקצ'יין הראשון, הצגתי את הפונקציה InitBlockChain. הנה, אני רק מחזיר את ההתייחסות המסוימת ל- BlockChain. לאחר מכן, אנו בונים מערך של Cryptoblock, שבו אנו מבצעים קריאה לפונקציית Inception. 

func main () {

chain := InitBlockChain()

chain.AddBlock("חסימה ראשונה לאחר הקמתה")

chain.AddBlock ("חסימה שנייה לאחר ההתחלה")

chain.AddBlock("חסימה שלישית לאחר ההקמה")

עבור _, block := range chain.blocks {

fmt.Printf(“Previous Hash: %x\n”, block.PrevHash)

fmt.Printf(“Data in Block: %s\n”, block.Data)

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

}

}

• לבסוף, הגענו לפונקציה המרכזית. כפי שאתה יכול לראות, קראנו ל-InitBlockChain() והקצינו אותו למשתנה השרשרת. 
• לאחר מכן, אנו מוסיפים בלוקים לשרשרת באמצעות chain.AddBlock, ואנו מעבירים את הנתונים הדרושים. 
• בעקבות זאת, אנו מפעילים לולאת for כדי לבדוק את הבלוקצ'יין. לאחר מכן אנו מייחדים כל בלוק ומדפיסים את השדות בתוך כל בלוק. אנחנו פשוט מקלידים:

fmt.Printf(“Previous Hash: %x\n”, block.PrevHash)

fmt.Printf(“Data in Block: %s\n”, block.Data)

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

פלט: 

אז אנחנו יכולים לומר שהתוכנית מוצלחת. אני מקווה שהצלחתם להבין את היישום של מושג הבלוקצ'יין בגולנג. פשוט תמשיך להתאמן ותוכל להתמודד עם פרויקטים מורכבים. 

הקריפטו שלך ראוי לאבטחה הטובה ביותר. לקבל ארנק חומרה לדג'ר ב-79$ בלבד!