મેં મારા ગો બ્લોકચેનમાં બ્લોક્સ અને વ્યવહારો કેવી રીતે ડિઝાઇન કર્યા

આખરે બ્લોકચેન સાથે સમાપ્ત થવા માટે અને માત્ર ડેટાબેઝ જ નહીં, અમારે અમારા પ્રોજેક્ટમાં 3 મહત્વપૂર્ણ ઘટકો ઉમેરવાની જરૂર છે:

• બ્લોક ડેટા માળખું અને પદ્ધતિઓનું વર્ણન
• ડેટા માળખું અને વ્યવહાર પદ્ધતિઓનું વર્ણન
• બ્લોકચેન ફંક્શન્સ કે જે ડેટાબેઝમાં બ્લોક્સને સાચવે છે અને તેમને તેમના હેશ અથવા ઊંચાઈ (અથવા બીજું કંઈક) દ્વારા ત્યાં શોધે છે.

ઉદ્યોગ માટે બ્લોકચેન વિશેનો આ બીજો લેખ છે, પહેલો અહીં.

આ શ્રેણીના પાછલા લેખ વિશે વાચકોએ મને પૂછેલા પ્રશ્નોને યાદ રાખીને, તે નોંધવું જોઈએ: આ કિસ્સામાં, લેવલડીબી ડેટાબેઝનો ઉપયોગ બ્લોકચેન ડેટાને સંગ્રહિત કરવા માટે થાય છે, પરંતુ કહો કે, 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(વેલ્યુ int, data []byte) (*TxOut, એરર) પદ્ધતિ વ્યવહારમાં આઉટપુટ ઉમેરે છે.

ToBytes() []બાઇટ પદ્ધતિ ટ્રાન્ઝેક્શનને બાઇટ સ્લાઇસમાં ફેરવે છે.

આંતરિક ફંક્શન preByteHash(bytes []byte) સ્ટ્રિંગનો ઉપયોગ Build() અને Check() માં થાય છે જેથી જનરેટ કરેલ ટ્રાન્ઝેક્શન હેશ જાવાસ્ક્રિપ્ટ એપ્લીકેશનમાંથી જનરેટ થયેલ ટ્રાન્ઝેક્શન હેશ સાથે સુસંગત બને.

બિલ્ડ() પદ્ધતિ નીચે પ્રમાણે ટ્રાન્ઝેક્શન હેશ સેટ કરે છે: 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 બ્લોકની ઊંચાઈને સંગ્રહિત કરે છે.
ટાઇમસ્ટેમ્પ ટાઇમસ્ટેમ્પ.
હેડરસાઈઝ એ બાઈટમાં બ્લોકનું કદ છે.
PrevBlockHash એ પહેલાના બ્લોકનું હેશ છે, અને SelfBlockHash એ વર્તમાનનું હેશ છે.
TxsHash એ વ્યવહારોનું સામાન્ય હેશ છે.
મર્કલરૂટ એ મર્કલ વૃક્ષનું મૂળ છે.

આગળ ક્ષેત્રોમાં બ્લોકના નિર્માતાની સાર્વજનિક કી, નિર્માતાની સહી, બ્લોકનું સંસ્કરણ, બ્લોકમાં વ્યવહારોની સંખ્યા અને આ વ્યવહારો પોતે જ છે.

ચાલો તેની પદ્ધતિઓ જોઈએ:
બ્લોક બનાવવા માટે, block.NewBlock() ફંક્શનનો ઉપયોગ કરો: NewBlock(prevBlockHash string, height int) *Block, જે પહેલાના બ્લોકની હેશ લે છે અને બ્લોકચેનમાં બનાવેલ બ્લોક માટે સેટ કરેલી ઊંચાઈ. બ્લોકનો પ્રકાર પણ પેકેજ કોન્સ્ટન્ટના પ્રકારોમાંથી સેટ કરેલ છે:

b.DataType = types.BLOCK_TYPE.

AddTx(tx *transaction.TX) પદ્ધતિ બ્લોકમાં ટ્રાન્ઝેક્શન ઉમેરે છે.

બિલ્ડ() પદ્ધતિ બ્લોકના ક્ષેત્રોમાં મૂલ્યો લોડ કરે છે અને તેના વર્તમાન હેશને જનરેટ અને સેટ કરે છે.

ToBytesHeader() []બાઇટ પદ્ધતિ બ્લોક હેડરને (ટ્રાન્ઝેક્શન વિના) બાઇટ સ્લાઇસમાં રૂપાંતરિત કરે છે.

ToJSON() સ્ટ્રિંગ પદ્ધતિ ડેટાના સ્ટ્રિંગ રજૂઆતમાં બ્લોકને JSON ફોર્મેટમાં રૂપાંતરિત કરે છે.

FromJSON(data []byte) ભૂલ પદ્ધતિ JSON માંથી ડેટાને બ્લોક સ્ટ્રક્ચરમાં લોડ કરે છે.

ચેક() બૂલ પદ્ધતિ બ્લોક હેશ જનરેટ કરે છે અને બ્લોક હેશ ફીલ્ડમાં ઉલ્લેખિત સાથે તેની તુલના કરે છે.

GetTxsHash() સ્ટ્રિંગ પદ્ધતિ બ્લોકમાંના તમામ વ્યવહારોની કુલ હેશ પરત કરે છે.

GetMerkleRoot() પદ્ધતિ બ્લોકમાં વ્યવહારો માટે મર્કલ ટ્રીના મૂળનો ઉલ્લેખ કરે છે.

સાઇન (પ્રિવકે સ્ટ્રિંગ) પદ્ધતિ બ્લોક નિર્માતાની ખાનગી કી વડે બ્લોક પર સહી કરે છે.

SetHeight(height int) પદ્ધતિ બ્લોક સ્ટ્રક્ચર ફીલ્ડમાં બ્લોકની ઊંચાઈ લખે છે.

GetHeight() int મેથડ બ્લોક સ્ટ્રક્ચરના અનુરૂપ ફીલ્ડમાં સ્પષ્ટ કર્યા મુજબ બ્લોકની ઊંચાઈ પરત કરે છે.

ToGOBBytes() []બાઈટ પદ્ધતિ GOB ફોર્મેટમાં બ્લોકને એન્કોડ કરે છે અને તેને બાઈટ સ્લાઈસ તરીકે પરત કરે છે.

FromGOBBytes(data []byte) એરર મેથડ GOB ફોર્મેટમાં પાસ કરેલ બાઈટ સ્લાઈસમાંથી બ્લોક સ્ટ્રક્ચરમાં બ્લોક ડેટા લખે છે.

GetHash() સ્ટ્રિંગ પદ્ધતિ આપેલ બ્લોકની હેશ પરત કરે છે.

GetPrevHash() સ્ટ્રિંગ પદ્ધતિ અગાઉના બ્લોકની હેશ પરત કરે છે.

SetPublicKey(pubk સ્ટ્રિંગ) પદ્ધતિ બ્લોક નિર્માતાની જાહેર કીને બ્લોક પર લખે છે.

આમ, બ્લોક ઑબ્જેક્ટની પદ્ધતિઓનો ઉપયોગ કરીને, અમે તેને નેટવર્ક પર ટ્રાન્સમિશન અને લેવલડીબી ડેટાબેઝમાં સાચવવા માટે સરળતાથી ફોર્મેટમાં રૂપાંતરિત કરી શકીએ છીએ.

બ્લોકચેન પેકેજના કાર્યો બ્લોકચેનમાં બચત કરવા માટે જવાબદાર છે: 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 string) એરર ફંક્શન ડેટાબેઝમાં BLOCK_HASH કોન્સ્ટન્ટ દ્વારા નિર્દિષ્ટ કી વડે વર્તમાન બ્લોકના હેશને લખે છે.

GetTargetBlockHash() (સ્ટ્રિંગ, એરર) ફંક્શન ડેટાબેઝમાં સંગ્રહિત વર્તમાન બ્લોકની હેશ પરત કરે છે.

SetTargetBlockHeight(height int) એરર ફંક્શન ડેટાબેઝ પર BLOCK_HEIGHT કોન્સ્ટન્ટ દ્વારા ઉલ્લેખિત કી સાથે નોડ માટે બ્લોકચેન ઊંચાઈનું મૂલ્ય લખે છે.

GetTargetBlockHeight() (int, error) ફંક્શન ડેટાબેઝમાં સંગ્રહિત આપેલ નોડ માટે બ્લોકચેનની ઊંચાઈ પરત કરે છે.

ચેકબ્લોક (બ્લોક આઇબ્લોક) બૂલ ફંક્શન આ બ્લોકને બ્લોકચેનમાં ઉમેરતા પહેલા ચોકસાઈ માટે બ્લોક તપાસે છે.

AddBlock(block IBlock) એરર ફંક્શન બ્લોકચેનમાં બ્લોક ઉમેરે છે.

બ્લોક્સ પુનઃપ્રાપ્ત કરવા અને જોવા માટેનાં કાર્યો બ્લોકચેન પેકેજની explore.go ફાઇલમાં છે:

GetBlockByHash(hash string) (*block.Block, error) ફંક્શન એક ખાલી બ્લોક ઑબ્જેક્ટ બનાવે છે, ડેટાબેઝમાંથી તેમાં એક બ્લોક લોડ કરે છે, જેમાંથી હેશ તેને પસાર કરવામાં આવ્યો હતો, અને તેના પર એક પોઇન્ટર પરત કરે છે.

બ્લોકચેન પેકેજની genesis.go ફાઇલમાંથી Genesis() એરર ફંક્શન દ્વારા જિનેસિસ બ્લોકનું નિર્માણ હાથ ધરવામાં આવે છે.

આગળનો લેખ WebSocket મિકેનિઝમનો ઉપયોગ કરીને ક્લાયંટને નોડ સાથે કનેક્ટ કરવા વિશે વાત કરશે.

સોર્સ: www.habr.com