මම මගේ Go blockchain හි කොටස් සහ ගනුදෙනු සැලසුම් කළ ආකාරය

අවසානයේ දත්ත සමුදායක් පමණක් නොව බ්ලොක්චේන් එකක් සමඟ අවසන් වීමට නම්, අපි අපගේ ව්‍යාපෘතියට වැදගත් අංග 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 ප්‍රතිදානයන් යම් අගයක් සහ බයිට් කේතයක් ගබඩා කරයි.

දැන් අපි බලමු ගනුදෙනුවකට එහි දත්ත මත කළ හැකි ක්‍රියා මොනවාද, i.e. ක්‍රම බලමු.

ගනුදෙනුවක් සෑදීමට, ගනුදෙනුව භාවිතා කරන්න.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() තුළ භාවිතා වේ.

Build() ක්‍රමය ගණුදෙණු හෑෂ් පහත පරිදි සකසයි: tx.TxHash = preByteHash(tx.ToBytes()).

ToJSON() තන්තු ක්‍රමය ගනුදෙනුවක් JSON තන්තුවක් බවට පරිවර්තනය කරයි.

FromJSON(data []byte) දෝෂ ක්‍රමය බයිට් පෙත්තක් ලෙස සම්මත කරන ලද JSON ආකෘතියෙන් ගනුදෙනුවක් පූරණය කරයි.

Check() bool ක්‍රමය මගින් මෙම ගනුදෙනුව හැෂ් කිරීමේ ප්‍රතිඵලයක් ලෙස ලබාගත් හෑෂ් සමඟ ගනුදෙනු හැෂ් ක්ෂේත්‍රයෙන් ලැබෙන හැෂ් සංසන්දනය කරයි (හැෂ් ක්ෂේත්‍රය නොසලකා හැරීම).

බ්ලොක් එකට ගනුදෙනු එකතු කරනු ලැබේ: 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 යනු ගනුදෙනු වල සාමාන්‍ය හෑෂ් එකකි.
MerkleRoot යනු මර්කල් ගසේ මුලයි.

තවදුරටත් ක්ෂේත්‍රවල බ්ලොක් නිර්මාතෘගේ පොදු යතුර, නිර්මාතෘගේ අත්සන, බ්ලොක් අනුවාදය, බ්ලොක් එකේ ගනුදෙනු ගණන සහ මෙම ගනුදෙනු ඇත.

අපි එහි ක්රම දෙස බලමු:
බ්ලොක් එකක් සෑදීමට, block.NewBlock() ශ්‍රිතය භාවිතා කරන්න: NewBlock(prevBlockHash string, height int) *Block, එය පෙර බ්ලොක් එකේ හැෂ් සහ බ්ලොක්චේන් හි සාදන ලද බ්ලොක් එක සඳහා සකසා ඇති උස ගනී. බ්ලොක් වර්ගයද වර්ග පැකේජ නියතයෙන් සකසා ඇත:

b.DataType = types.BLOCK_TYPE.

AddTx(tx *transaction.TX) ක්‍රමය බ්ලොක් එකකට ගනුදෙනුවක් එක් කරයි.

Build() ක්‍රමය බ්ලොක් ක්ෂේත්‍ර තුළට අගයන් පටවා එහි වත්මන් හැෂ් ජනනය කර සකසයි.

ToBytesHeader() []byte ක්‍රමය මඟින් වාරණ ශීර්ෂය (ගනුදෙනු නොමැතිව) බයිට් පෙත්තක් බවට පරිවර්තනය කරයි.

ToJSON() තන්තු ක්‍රමය මඟින් දත්ත තන්තු නිරූපණයක බ්ලොක් එක JSON ආකෘතියට පරිවර්තනය කරයි.

FromJSON(data []byte) දෝෂ ක්‍රමය JSON වෙතින් දත්ත වාරණ ව්‍යුහයකට පූරණය කරයි.

Check() bool ක්‍රමය බ්ලොක් හැෂ් එකක් ජනනය කරන අතර එය බ්ලොක් හැෂ් ක්ෂේත්‍රයේ දක්වා ඇති එකක් සමඟ සංසන්දනය කරයි.

GetTxsHash() තන්තු ක්‍රමය බ්ලොක් එකේ සියලුම ගනුදෙනු වල සම්පූර්ණ හැෂ් ලබා දෙයි.

GetMerkleRoot() ක්‍රමය බ්ලොක් එකක ගනුදෙනු සඳහා මර්කල් ගසේ මුල නියම කරයි.

Sign(privk string) ක්‍රමය බ්ලොක් නිර්මාපකයාගේ පුද්ගලික යතුර සමඟ බ්ලොක් එකක් අත්සන් කරයි.

SetHeight(height int) ක්‍රමය බ්ලොක් ව්‍යුහ ක්ෂේත්‍රයට බ්ලොක් එකේ උස ලියයි.

GetHeight() int ක්‍රමය බ්ලොක් ව්‍යුහයේ අනුරූප ක්ෂේත්‍රයේ දක්වා ඇති පරිදි බ්ලොක් එකේ උස ආපසු ලබා දෙයි.

ToGOBBytes() []byte ක්‍රමය බ්ලොක් එකක් GOB ආකෘතියෙන් සංකේතනය කර එය බයිට් පෙත්තක් ලෙස ලබා දෙයි.

FromGOBBytes(data []byte) දෝෂ ක්‍රමය මඟින් GOB ආකෘතියෙන් සම්මත වූ බයිට් පෙත්තෙන් වාරණ ව්‍යුහයට වාරණ දත්ත ලියයි.

GetHash() තන්තු ක්‍රමය ලබා දී ඇති බ්ලොක් එකේ හැෂ් ආපසු ලබා දෙයි.

GetPrevHash() තන්තු ක්‍රමය පෙර බ්ලොක් එකේ හැෂ් ලබා දෙයි.

SetPublicKey(pubk string) ක්‍රමය බ්ලොක් නිර්මාපකයාගේ පොදු යතුර බ්ලොක් එකට ලියයි.

මේ අනුව, බ්ලොක් වස්තුවේ ක්‍රම භාවිතා කරමින්, අපට එය පහසුවෙන් ජාලය හරහා සම්ප්‍රේෂණය සඳහා ආකෘතියක් බවට පරිවර්තනය කර LevelDB දත්ත ගබඩාවට සුරැකිය හැක.

blockchain පැකේජයේ කාර්යයන් blockchain වෙත සුරැකීමට වගකිව යුතුය: 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() සඳහා වන wrapper එකකි - දත්ත සමුදාය වෙත සම්බන්ධතාවය වසා දැමීම සඳහා පැකේජ ක්‍රියාකාරකම් සමඟ වැඩ කිරීමෙන් පසුව කැඳවනු ලැබේ.

SetTargetBlockHash(hash string) දෝෂ ශ්‍රිතය BLOCK_HASH නියතය මඟින් නියම කර ඇති යතුර සමඟ වත්මන් බ්ලොක් එකේ හැෂ් දත්ත ගබඩාවට ලියයි.

GetTargetBlockHash() (string, error) ශ්‍රිතය දත්ත සමුදායේ ගබඩා කර ඇති වත්මන් බ්ලොක් එකේ හැෂ් ලබා දෙයි.

SetTargetBlockHeight(height int) දෝෂ ශ්‍රිතය BLOCK_HEIGHT නියතය මඟින් නියම කර ඇති යතුර සමඟින් නෝඩය සඳහා බ්ලොක්චේන් උසෙහි අගය දත්ත ගබඩාවට ලියයි.

GetTargetBlockHeight() (int, error) ශ්‍රිතය දත්ත සමුදායේ ගබඩා කර ඇති දී ඇති node එකක් සඳහා blockchain හි උස ලබා දෙයි.

CheckBlock(block IBlock) bool ශ්‍රිතය බ්ලොක්චේන් එකට මෙම බ්ලොක් එක එක් කිරීමට පෙර බ්ලොක් එකක් නිවැරදි දැයි පරික්ෂා කරයි.

AddBlock(block IBlock) දෝෂ ශ්‍රිතය blockchain වෙත වාරණයක් එක් කරයි.

බ්ලොක්චේන් පැකේජයේ explore.go ගොනුව තුළ කුට්ටි ලබා ගැනීම සහ බැලීම සඳහා වන කාර්යයන් ඇත:

GetBlockByHash(hash string) (*block.Block, error) ශ්‍රිතය හිස් බ්ලොක් වස්තුවක් නිර්මාණය කරයි, දත්ත සමුදායෙන් බ්ලොක් එකක් එයට පූරණය කරයි, එහි හැෂ් එයට යවා, එයට පොයින්ටරයක් ​​ලබා දෙයි.

බ්ලොක්චේන් පැකේජයේ genesis.go ගොනුවෙන් Genesis() දෝෂ ශ්‍රිතය මඟින් උත්පත්ති වාරණයක් නිර්මාණය කිරීම සිදු කරයි.

WebSocket යාන්ත්‍රණය භාවිතයෙන් සේවාදායකයන් නෝඩයකට සම්බන්ධ කිරීම ගැන ඊළඟ ලිපියෙන් කතා කරනු ඇත.

මූලාශ්රය: www.habr.com