איך עיצבתי בלוקים ועסקאות בבלוקצ'יין Go שלי

כדי בסופו של דבר להגיע לבלוקצ'יין ולא רק למסד נתונים, עלינו להוסיף 3 אלמנטים חשובים לפרויקט שלנו:

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

זהו המאמר השני על בלוקצ'יין לתעשייה, הראשון כאן.

כשזוכרים את השאלות ששאלו אותי הקוראים לגבי המאמר הקודם בסדרה זו, יש לציין: במקרה זה, מסד הנתונים של LevelDB משמש לאחסון נתוני בלוקצ'יין, אבל שום דבר לא מונע מכם להשתמש בכל, למשל, MySQL אחר. עכשיו בואו נסתכל על המבנה של נתונים אלה.

נתחיל בעסקאות: github.com/Rusldv/bcstartup/blob/master/transaction/builder.go

להלן מבנה הנתונים שלו:

type TX struct {
	DataType byte		
	TxHash string 
	TxType byte	
	Timestamp int64		
	INs []TxIn
	OUTs []TxOut
}

type TxIn struct {
	ThatTxHash string
	TxOutN int
	ByteCode string
}

type TxOut struct {
	Value int
	ByteCode string
}

TX מאחסן את סוג הנתונים (עבור עסקה 2), ה-hash של אותה עסקה, סוג העסקה עצמה, חותמת זמן וכניסות ופלטים. כניסות TxIn מאחסנות את ה-hash של העסקה שהפלט שלה מופנה, את מספר הפלט וה-bytecode, ויציאות TxOut מאחסנות ערך מסוים וגם קוד בתים.

כעת נראה אילו פעולות עסקה יכולה לבצע על הנתונים שלה, כלומר. בואו נסתכל על השיטות.

כדי ליצור עסקה, השתמש בפונקציה transaction.NewTransaction(TXtype byte) *TX.

השיטה AddTxIn(thattxhash []byte, txoutn int, code []byte) (*TxIn, error) מוסיפה קלט לעסקה.

השיטה AddTxOut(value int, data []byte) (*TxOut, error) מוסיפה פלט לעסקה.

השיטה ToBytes() []byte הופכת את העסקה לפרוסת בתים.

הפונקציה הפנימית preByteHash(bytes []byte) משמשת ב-Build() וב-Check() כדי להפוך את ה-hash של העסקה שנוצר לתואם ל-hash של טרנזקציות שנוצרו מיישומי JavaScript.

השיטה Build() מגדירה את ה-hash של העסקה באופן הבא: tx.TxHash = preByteHash(tx.ToBytes()).

שיטת המחרוזת ToJSON() ממירה עסקה למחרוזת JSON.

שיטת השגיאה FromJSON(data []byte) טוענת עסקה מפורמט JSON המועבר כפרוסת בתים.

שיטת Check() bool משווה את ה-hash המתקבל משדה ה-hash של הטרנזקציה עם ה-hash המתקבל כתוצאה מה-hash של הטרנזקציה הזו (התעלמות משדה ה-hash).

עסקאות מתווספות לבלוק: github.com/Rusldv/bcstartup/blob/master/block/builder.go

מבנה נתוני הבלוק הוא רחב יותר:

type Block struct {
	DataType byte				
	BlockHeight int					
        Timestamp int64				 
        HeaderSize int					
        PrevBlockHash string				 
        SelfBlockHash string			
	TxsHash string			
	MerkleRoot string
	CreatorPublicKey string			
	CreatorSig string
	Version int
	TxsN int
	Txs []transaction.TX
}

DataType מאחסן את סוג הנתונים, הצומת משתמש בו ומבדיל את הבלוק מעסקה או נתונים אחרים. עבור בלוק ערך זה הוא 1.

BlockHeight מאחסן את גובה הבלוק.
חותמת זמן.
HeaderSize הוא גודל הבלוק בבתים.
PrevBlockHash הוא ה-hash של הבלוק הקודם, ו-SelfBlockHash הוא ה-hash של הבלוק הנוכחי.
TxsHash הוא גיבוב כללי של עסקאות.
MerkleRoot הוא השורש של עץ מרקל.

בהמשך השדות יש את המפתח הציבורי של יוצר הבלוק, חתימת היוצר, גרסת הבלוק, מספר העסקאות בבלוק ועסקאות אלו עצמן.

בואו נסתכל על השיטות שלו:
כדי ליצור בלוק, השתמש בפונקציה block.NewBlock(): NewBlock(prevBlockHash string, height int) *Block, שלוקח את ה-hash של הבלוק הקודם ואת הגובה שנקבע לבלוק שנוצר בבלוקצ'יין. סוג הבלוק נקבע גם מתוך קבוע חבילת הסוגים:

b.DataType = types.BLOCK_TYPE.

השיטה AddTx(tx *transaction.TX) מוסיפה טרנזקציה לבלוק.

שיטת Build() טוענת ערכים לשדות הבלוק ויוצרת ומגדירה את ה-hash הנוכחי שלו.

השיטה ToBytesHeader() []byte ממירה את כותרת הבלוק (ללא טרנזקציות) לפרוסת בתים.

שיטת המחרוזת ToJSON() ממירה את הבלוק לפורמט JSON בייצוג מחרוזת של הנתונים.

שיטת השגיאה FromJSON(data []byte) טוענת נתונים מ-JSON למבנה בלוק.

השיטה Check() bool מייצרת גיבוב של בלוק ומשווה אותו לזה שצוין בשדה הגיבוב של הבלוק.

שיטת המחרוזת GetTxsHash() מחזירה את סך ה-hash של כל העסקאות בבלוק.

השיטה GetMerkleRoot() מציינת את השורש של עץ Merkle עבור עסקאות בבלוק.

שיטת Sign(privk string) חותמת בלוק עם המפתח הפרטי של יוצר הבלוק.

שיטת SetHeight(height int) כותבת את גובה הבלוק לשדה מבנה הבלוק.

השיטה GetHeight() int מחזירה את גובה הבלוק כפי שצוין בשדה המתאים של מבנה הבלוק.

שיטת ToGOBBytes() []byte מקודדת בלוק בפורמט GOB ומחזירה אותו כפרוסת בתים.

שיטת השגיאה FromGOBBytes(data []byte) כותבת נתוני בלוק למבנה הבלוק מפרוסת הבתים המועברת בפורמט GOB.

שיטת המחרוזת GetHash() מחזירה את ה-hash של הבלוק הנתון.

שיטת המחרוזת GetPrevHash() מחזירה את ה-hash של הבלוק הקודם.

שיטת SetPublicKey(pubk string) כותבת את המפתח הציבורי של יוצר הבלוק לבלוק.

כך, באמצעות השיטות של אובייקט ה-Block, נוכל להמיר אותו בקלות לפורמט לשידור דרך הרשת ולשמירה במסד הנתונים LevelDB.

הפונקציות של חבילת הבלוקצ'יין אחראיות לשמירה בבלוקצ'יין: github.com/Rusldv/bcstartup/tree/master/blockchain

לשם כך, הבלוק חייב ליישם את ממשק IBlock:

type IGOBBytes interface {
	ToGOBBytes() []byte
	FromGOBBytes(data []byte) error
}

type IBlock interface {
	IGOBBytes
	GetHash() string
	GetPrevHash() string
	GetHeight() int
	Check() bool

}

חיבור מסד הנתונים נוצר פעם אחת כאשר החבילה מאותחלת בפונקציה init():

db, err = leveldb.OpenFile(BLOCKCHAIN_DB_DEBUG, nil).

CloseDB() הוא מעטפת עבור db.Cloce() - נקרא לאחר עבודה עם פונקציות החבילה כדי לסגור את החיבור למסד הנתונים.

פונקציית השגיאה SetTargetBlockHash(מחרוזת hash) כותבת את ה-hash של הבלוק הנוכחי עם המפתח שצוין על ידי הקבוע BLOCK_HASH למסד הנתונים.

הפונקציה GetTargetBlockHash() (מחרוזת, שגיאה) מחזירה את ה-hash של הבלוק הנוכחי המאוחסן במסד הנתונים.

פונקציית השגיאה SetTargetBlockHeight(height int) כותבת למסד הנתונים את הערך של גובה הבלוקצ'יין עבור הצומת עם המפתח שצוין בקבוע BLOCK_HEIGHT.

הפונקציה GetTargetBlockHeight() (int, error) מחזירה את גובה הבלוקצ'יין עבור צומת נתון, המאוחסן במסד הנתונים.

הפונקציה CheckBlock(block IBlock) bool בודקת תקינות של בלוק לפני הוספת הבלוק הזה לבלוקצ'יין.

פונקציית השגיאה AddBlock(בלוק IBlock) מוסיפה בלוק לבלוקצ'יין.

הפונקציות לאחזור והצגת בלוקים נמצאות בקובץ explore.go של חבילת הבלוקצ'יין:

הפונקציה GetBlockByHash(מחרוזת hash) (*block.Block, error) יוצרת אובייקט בלוק ריק, טוענת לתוכו בלוק ממסד הנתונים, שה-hash שלו הועבר אליו, ומחזירה אליו מצביע.

היצירה של בלוק genesis מתבצעת על ידי פונקציית השגיאה Genesis() מהקובץ genesis.go של חבילת הבלוקצ'יין.

המאמר הבא ידבר על חיבור לצומת לקוח באמצעות מנגנון WebSocket.

מקור: www.habr.com