నేను నా గో బ్లాక్‌చెయిన్‌లో బ్లాక్‌లు మరియు లావాదేవీలను ఎలా డిజైన్ చేసాను

డేటాబేస్ మాత్రమే కాకుండా బ్లాక్‌చెయిన్‌తో అంతిమంగా ముగించడానికి, మేము మా ప్రాజెక్ట్‌కు 3 ముఖ్యమైన అంశాలను జోడించాలి:

• బ్లాక్ డేటా నిర్మాణం మరియు పద్ధతుల వివరణ
• డేటా నిర్మాణం మరియు లావాదేవీ పద్ధతుల వివరణ
• బ్లాక్‌చెయిన్ ఫంక్షన్‌లు బ్లాక్‌లను డేటాబేస్‌లో సేవ్ చేస్తాయి మరియు వాటి హాష్ లేదా ఎత్తు (లేదా మరేదైనా) ద్వారా వాటిని కనుగొనడం.

పరిశ్రమ కోసం బ్లాక్‌చెయిన్ గురించి ఇది రెండవ కథనం, మొదటిది ఇక్కడ.

ఈ సిరీస్‌లోని మునుపటి కథనం గురించి పాఠకులు నన్ను అడిగిన ప్రశ్నలను గుర్తుంచుకోవాలి: ఈ సందర్భంలో, బ్లాక్‌చెయిన్ డేటాను నిల్వ చేయడానికి 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 కోసం), ఆ లావాదేవీ యొక్క హాష్, లావాదేవీ రకం, టైమ్‌స్టాంప్ మరియు ఇన్‌పుట్‌లు మరియు అవుట్‌పుట్‌లను నిల్వ చేస్తుంది. TxIn ఇన్‌పుట్‌లు లావాదేవీకి సంబంధించిన హాష్‌ని నిల్వ చేస్తాయి, దీని అవుట్‌పుట్ రిఫరెన్స్ చేయబడుతుంది, ఈ అవుట్‌పుట్ మరియు బైట్‌కోడ్ సంఖ్య, మరియు TxOut అవుట్‌పుట్‌లు కొంత విలువను మరియు బైట్‌కోడ్‌ను కూడా నిల్వ చేస్తాయి.

లావాదేవీ దాని డేటాపై ఎలాంటి చర్యలను చేయగలదో ఇప్పుడు చూద్దాం, అనగా. పద్ధతులను చూద్దాం.

లావాదేవీని సృష్టించడానికి, లావాదేవీని ఉపయోగించండి.NewTransaction(txtype byte) *TX ఫంక్షన్.

AddTxIn(thattxhash []byte, txoutn int, code []byte) (*TxIn, ఎర్రర్) పద్ధతి లావాదేవీకి ఇన్‌పుట్‌ని జోడిస్తుంది.

AddTxOut(value int, data []byte) (*TxOut, ఎర్రర్) పద్ధతి లావాదేవీకి అవుట్‌పుట్‌ని జోడిస్తుంది.

ToBytes() []బైట్ పద్ధతి లావాదేవీని బైట్ స్లైస్‌గా మారుస్తుంది.

JavaScript అప్లికేషన్‌ల నుండి రూపొందించబడిన లావాదేవీ హ్యాష్‌లకు అనుగుణంగా రూపొందించబడిన లావాదేవీ హాష్‌ని రూపొందించడానికి అంతర్గత ఫంక్షన్ preByteHash(bytes []byte) స్ట్రింగ్ Build() మరియు Check()లో ఉపయోగించబడుతుంది.

Build() పద్ధతి లావాదేవీ హాష్‌ని ఈ క్రింది విధంగా సెట్ చేస్తుంది: tx.TxHash = preByteHash(tx.ToBytes()).

ToJSON() స్ట్రింగ్ పద్ధతి లావాదేవీని JSON స్ట్రింగ్‌గా మారుస్తుంది.

FromJSON(data []byte) లోపం పద్ధతి బైట్ స్లైస్‌గా ఆమోదించబడిన JSON ఫార్మాట్ నుండి లావాదేవీని లోడ్ చేస్తుంది.

చెక్() బూల్ పద్ధతి ఈ లావాదేవీని హ్యాష్ చేయడం వల్ల పొందిన హాష్‌తో లావాదేవీ హాష్ ఫీల్డ్ నుండి వచ్చే హాష్‌ను పోలుస్తుంది (హాష్ ఫీల్డ్‌ను విస్మరించడం).

లావాదేవీలు బ్లాక్‌కు జోడించబడ్డాయి: 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 అనేది మునుపటి బ్లాక్ యొక్క హాష్, మరియు SelfBlockHash అనేది ప్రస్తుత హాష్.
TxsHash అనేది లావాదేవీల యొక్క సాధారణ హాష్.
మెర్కిల్ రూట్ మెర్కిల్ చెట్టు యొక్క మూలం.

ఇక ఫీల్డ్‌లలో బ్లాక్ సృష్టికర్త యొక్క పబ్లిక్ కీ, సృష్టికర్త యొక్క సంతకం, బ్లాక్ వెర్షన్, బ్లాక్‌లోని లావాదేవీల సంఖ్య మరియు ఈ లావాదేవీలు ఉంటాయి.

దాని పద్ధతులను చూద్దాం:
బ్లాక్‌ని సృష్టించడానికి, block.NewBlock() ఫంక్షన్‌ని ఉపయోగించండి: NewBlock(prevBlockHash స్ట్రింగ్, ఎత్తు పూర్ణాంకానికి) *బ్లాక్, ఇది మునుపటి బ్లాక్ యొక్క హాష్ మరియు బ్లాక్‌చెయిన్‌లో సృష్టించబడిన బ్లాక్ కోసం సెట్ చేయబడిన ఎత్తును తీసుకుంటుంది. బ్లాక్ రకం కూడా రకాల ప్యాకేజీ స్థిరాంకం నుండి సెట్ చేయబడింది:

b.DataType = types.BLOCK_TYPE.

AddTx(tx *transaction.TX) పద్ధతి బ్లాక్‌కి లావాదేవీని జోడిస్తుంది.

బిల్డ్() పద్ధతి బ్లాక్ యొక్క ఫీల్డ్‌లలోకి విలువలను లోడ్ చేస్తుంది మరియు దాని ప్రస్తుత హాష్‌ను ఉత్పత్తి చేస్తుంది మరియు సెట్ చేస్తుంది.

ToBytesHeader() []బైట్ పద్ధతి బ్లాక్ హెడర్‌ను (లావాదేవీలు లేకుండా) బైట్ స్లైస్‌గా మారుస్తుంది.

ToJSON() స్ట్రింగ్ పద్ధతి డేటా యొక్క స్ట్రింగ్ ప్రాతినిధ్యంలో బ్లాక్‌ను JSON ఆకృతికి మారుస్తుంది.

FromJSON(data []byte) ఎర్రర్ మెథడ్ JSON నుండి డేటాను బ్లాక్ స్ట్రక్చర్‌లోకి లోడ్ చేస్తుంది.

చెక్() బూల్ పద్ధతి బ్లాక్ హాష్‌ను ఉత్పత్తి చేస్తుంది మరియు బ్లాక్ హాష్ ఫీల్డ్‌లో పేర్కొన్న దానితో పోల్చింది.

GetTxsHash() స్ట్రింగ్ పద్ధతి బ్లాక్‌లోని అన్ని లావాదేవీల మొత్తం హాష్‌ని అందిస్తుంది.

GetMerkleRoot() పద్ధతి ఒక బ్లాక్‌లో లావాదేవీల కోసం మెర్కిల్ ట్రీ యొక్క మూలాన్ని నిర్దేశిస్తుంది.

Sign(privk string) పద్ధతి బ్లాక్ సృష్టికర్త యొక్క ప్రైవేట్ కీతో బ్లాక్‌పై సంతకం చేస్తుంది.

SetHeight(height int) పద్ధతి బ్లాక్ యొక్క ఎత్తును బ్లాక్ స్ట్రక్చర్ ఫీల్డ్‌కు వ్రాస్తుంది.

GetHeight() int పద్ధతి బ్లాక్ నిర్మాణం యొక్క సంబంధిత ఫీల్డ్‌లో పేర్కొన్న విధంగా బ్లాక్ యొక్క ఎత్తును అందిస్తుంది.

ToGOBBytes() []బైట్ పద్ధతి GOB ఆకృతిలో బ్లాక్‌ను ఎన్‌కోడ్ చేస్తుంది మరియు దానిని బైట్ స్లైస్‌గా అందిస్తుంది.

FromGOBBytes(data []byte) ఎర్రర్ మెథడ్ GOB ఫార్మాట్‌లో పాస్ చేసిన బైట్ స్లైస్ నుండి బ్లాక్ స్ట్రక్చర్‌కు బ్లాక్ డేటాను వ్రాస్తుంది.

GetHash() స్ట్రింగ్ మెథడ్ ఇచ్చిన బ్లాక్ యొక్క హాష్‌ని అందిస్తుంది.

GetPrevHash() స్ట్రింగ్ పద్ధతి మునుపటి బ్లాక్ యొక్క హాష్‌ని అందిస్తుంది.

SetPublicKey(pubk స్ట్రింగ్) పద్ధతి బ్లాక్ సృష్టికర్త యొక్క పబ్లిక్ కీని బ్లాక్‌కి వ్రాస్తుంది.

అందువలన, బ్లాక్ ఆబ్జెక్ట్ యొక్క పద్ధతులను ఉపయోగించి, మేము దానిని నెట్‌వర్క్ ద్వారా ప్రసారం చేయడానికి మరియు 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 స్ట్రింగ్) ఎర్రర్ ఫంక్షన్ డేటాబేస్‌కు BLOCK_HASH స్థిరాంకం ద్వారా పేర్కొన్న కీతో ప్రస్తుత బ్లాక్ యొక్క హాష్‌ను వ్రాస్తుంది.

GetTargetBlockHash() (స్ట్రింగ్, ఎర్రర్) ఫంక్షన్ డేటాబేస్‌లో నిల్వ చేయబడిన ప్రస్తుత బ్లాక్ యొక్క హాష్‌ను అందిస్తుంది.

SetTargetBlockHeight(height int) ఎర్రర్ ఫంక్షన్ BLOCK_HEIGHT స్థిరాంకం ద్వారా పేర్కొన్న కీతో నోడ్ కోసం బ్లాక్‌చెయిన్ ఎత్తు విలువను డేటాబేస్‌కు వ్రాస్తుంది.

GetTargetBlockHeight() (int, ఎర్రర్) ఫంక్షన్ డేటాబేస్‌లో నిల్వ చేయబడిన ఇచ్చిన నోడ్ కోసం బ్లాక్‌చెయిన్ యొక్క ఎత్తును అందిస్తుంది.

చెక్‌బ్లాక్(బ్లాక్ ఐబ్లాక్) బూల్ ఫంక్షన్ బ్లాక్‌చెయిన్‌కు ఈ బ్లాక్‌ను జోడించే ముందు ఖచ్చితత్వం కోసం బ్లాక్‌ని తనిఖీ చేస్తుంది.

AddBlock(బ్లాక్ IBlock) ఎర్రర్ ఫంక్షన్ బ్లాక్‌చెయిన్‌కు ఒక బ్లాక్‌ని జోడిస్తుంది.

బ్లాక్‌చెయిన్ ప్యాకేజీలోని explore.go ఫైల్‌లో బ్లాక్‌లను తిరిగి పొందడం మరియు వీక్షించడం కోసం విధులు ఉన్నాయి:

GetBlockByHash(hash string) (*block.Block, error) ఫంక్షన్ ఒక ఖాళీ బ్లాక్ ఆబ్జెక్ట్‌ను సృష్టిస్తుంది, డేటాబేస్ నుండి దానిలో ఒక బ్లాక్‌ను లోడ్ చేస్తుంది, దాని యొక్క హాష్ దానికి పంపబడింది మరియు దానికి పాయింటర్‌ను అందిస్తుంది.

బ్లాక్‌చెయిన్ ప్యాకేజీ యొక్క genesis.go ఫైల్ నుండి జెనెసిస్() లోపం ఫంక్షన్ ద్వారా జెనెసిస్ బ్లాక్‌ని సృష్టించడం జరుగుతుంది.

వెబ్‌సాకెట్ మెకానిజంను ఉపయోగించి క్లయింట్‌లను నోడ్‌కి కనెక్ట్ చేయడం గురించి తదుపరి కథనం మాట్లాడుతుంది.

మూలం: www.habr.com