Hur jag designade block och transaktioner i min blockchain på Go

För att i slutändan få en blockchain, och inte bara en databas, behöver vi lägga till tre viktiga element i vårt projekt:

• Beskrivning av dataskstrukturen och metoderna för blocket
• Beskrivning av dataskstrukturen och metoderna för transaktionen
• Blockchain-funktioner som sparar block i databasen och hittar dem där efter deras hash eller höjd (eller på något annat sätt).

Detta är den andra artikeln om blockchain för industrin; den första ). Ett typiskt exempel på användning:.

När jag minns de frågor som mina läsare ställde efter den föregående artikeln i denna serie, bör det noteras: för lagring av blockchain-data används i detta fall databasen LevelDB, men ingenting hindrar oss från att använda vilken annan som helst, till exempel MySQL. Nu ska vi ta en titt på strukturen för dessa data.

Låt oss börja med transaktionerna: github.com/Rusldv/bcstartup/blob/master/transaction/builder.go

Här är dess dataskstrukur:

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
}

I TX lagras datatypen (för transaktionen 2), hash för denna transaktion, typen av själva transaktionen, tidsstämpeln samt ingångar och utgångar. Ingångarna TxIn sparar hash för transaktionen som deras utgång refererar till, numret på denna utgång och bytekoden, medan utgångarna TxOut lagrar ett värde och också bytekoden.

Nu ska vi se vilka åtgärder transaktionen kan utföra med sina data, det vill säga vi kommer att gå igenom metoderna.

För att skapa en transaktion används funktionen transaction.NewTransaction(txtype byte) *TX.

Metoden AddTxIn(thattxhash []byte, txoutn int, code []byte) (*TxIn, error) lägger till en ingång till transaktionen.

Metoden AddTxOut(value int, data []byte) (*TxOut, error) lägger till en utgång till transaktionen.

Metoden ToBytes() []byte omvandlar transaktionen till en byte-array.

Den interna funktionen preByteHash(bytes []byte) string används i Build() och Check() för att säkerställa att den skapade hash:en av transaktionerna är kompatibel med hash:ar som genereras från applikationer i JavaScript.

Metoden Build() ställer in hash för transaktionen på följande sätt: tx.TxHash = preByteHash(tx.ToBytes()).

Metoden ToJSON() string omvandlar transaktionen till en JSON-sträng.

Metoden FromJSON(data []byte) error laddar transaktionen från JSON-formatet som överförts som en byte-array.

Metoden Check() bool jämför den erhållna hash av fältet i transaktionens hash med den hash som erhållits genom hashning av denna transaktion (utan att ta hänsyn till hashfältet).

Transaktioner läggs till blocket: github.com/Rusldv/bcstartup/blob/master/block/builder.go

Dataskstrukturen för blocket är mer omfattande:

typ 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 lagrar datatypen, enligt vilken noden avgör blocket från transaktionen eller andra data. För block är detta värde 1.

BlockHeight lagrar blockets höjd.
Timestamp är tidsstämpeln.
HeaderSize är blockets storlek i byte.
PrevBlockHash är hash av föregående block, medan SelfBlockHash är det aktuella.
TxsHash är den totala hash av transaktionerna.
MerkleRoot är roten i Merkle-trädet.

Näst i fälten finns den offentliga nyckeln för blockskaparen, signaturen från skaparen, blockets version, antal transaktioner i blocket och faktiskt dessa transaktioner.

Låt oss titta på dess metoder:
För att skapa ett block används funktionen block.NewBlock(): NewBlock(prevBlockHash string, height int) *Block, som tar hash av föregående block och höjden inställd för det nyskapade blocket i blockkedjan. Typen av blocket anges från konstanten i paketet types:

b.DataType = types.BLOCK_TYPE.

Metoden AddTx(tx *transaction.TX) lägger till en transaktion i blocket.

Metoden Build() laddar värden i blockets fält och genererar och ställer in dess aktuella hash.

Metoden ToBytesHeader() []byte konverterar blockets rubrik (utan transaktioner) till en byte-slice.

Metoden ToJSON() string konverterar blocket till JSON-format i strängrepresentation.

Metoden FromJSON(data []byte) error laddar data från JSON till blockstrukturen.

Metoden Check() bool genererar blockets hash och jämför med den angivna i blockets hash-fält.

Metoden GetTxsHash() string returnerar den totala hash av alla transaktioner i blocket.

Metoden GetMerkleRoot() sätter roten i Merkle-trädet för transaktionerna i blocket.

Metoden Sign(privk string) signerar blocket med blockskaparen nyckel.

Metoden SetHeight(height int) skriver blockets höjd i blockstrukturens fält.

Metoden GetHeight() int returnerar blockets höjd enligt det angivna fältet i blockstrukturen.

Metoden ToGOBBytes() []byte kodar blocket i GOB-format och returnerar det som en byte-slice.

Metoden FromGOBBytes(data []byte) error skriver blockets data i blockstrukturen från den angivna byte-slicen i GOB-format.

Metoden GetHash() string returnerar hash av detta block.

Metoden GetPrevHash() string returnerar hash av föregående block.

Metoden SetPublicKey(pubk string) skriver den offentliga nyckeln för blockskaparen i blocket.

Genom metoderna för Block-objektet kan vi enkelt konvertera det till ett format för överföring över nätverket och lagring i LevelDB.

Funktionerna i paketet blockchain ansvarar för lagring i blockkedjan: github.com/Rusldv/bcstartup/tree/master/blockchain

För detta måste blocket implementera gränssnittet IBlock:

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

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

}

Anslutningen till databasen skapas en gång vid initialisering av paketet i funktionen init():

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

CloseDB() är en omslagsfunktion för db.Close() — anropas efter att ha arbetat med funktionerna i paketet för att stänga kopplingen till databasen.

Funktionen SetTargetBlockHash(hash string) error skriver hash för det aktuella blocket i databasen med nyckeln definierad av konstanten BLOCK_HASH.

Funktionen GetTargetBlockHash() (string, error) returnerar hash för det aktuella blocket som lagras i databasen.

Funktionen SetTargetBlockHeight(height int) error skriver värdet för blockkedjans höjd för noden i databasen med nyckeln definierad av konstanten BLOCK_HEIGHT.

Funktionen GetTargetBlockHeight() (int, error) returnerar blockkedjans höjd för denna nod, lagrad i databasen.

Funktionen CheckBlock(block IBlock) bool kontrollerar blockets korrekthet innan det läggs till i blockkedjan.

Funktionen AddBlock(block IBlock) error lägger till blocket i blockkedjan.

Funktionerna för att hämta och visa block finns i filen explore.go i paketet blockchain:

Funktionen GetBlockByHash(hash string) (*block.Block, error) skapar ett tomt blockobjekt, laddar blocket med den angivna hashen från databasen och returnerar en pekare till det.

Skapandet av genesis-blocket utförs av funktionen Genesis() error från filen genesis.go i paketet blockchain.

I nästa artikel kommer vi att diskutera hur man ansluter till noden via WebSocket-mekanismen.

Källa: habr.com