എന്റെ ഗോ ബ്ലോക്ക്‌ചെയിനിൽ ബ്ലോക്കുകളും ഇടപാടുകളും ഞാൻ എങ്ങനെ രൂപകൽപ്പന ചെയ്‌തു

ആത്യന്തികമായി ഒരു ബ്ലോക്ക്‌ചെയിനിൽ അവസാനിക്കുന്നതിന്, ഒരു ഡാറ്റാബേസ് മാത്രമല്ല, ഞങ്ങളുടെ പ്രോജക്റ്റിലേക്ക് 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, error) രീതി ഇടപാടിലേക്ക് ഒരു ഇൻപുട്ട് ചേർക്കുന്നു.

AddTxOut(value int, data []byte) (*TxOut, error) രീതി ഇടപാടിലേക്ക് ഒരു ഔട്ട്പുട്ട് ചേർക്കുന്നു.

ToBytes() []byte രീതി ഇടപാടിനെ ഒരു ബൈറ്റ് സ്ലൈസാക്കി മാറ്റുന്നു.

ഇൻ്റേണൽ ഫംഗ്‌ഷൻ preByteHash(bytes []byte) സ്ട്രിംഗ്, JavaScript ആപ്ലിക്കേഷനുകളിൽ നിന്ന് ജനറേറ്റ് ചെയ്യുന്ന ട്രാൻസാക്ഷൻ ഹാഷുകൾക്ക് അനുയോജ്യമാക്കുന്നതിന്, 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 എന്നത് ഇടപാടുകളുടെ ഒരു പൊതു ഹാഷാണ്.
മെർക്കൽ മരത്തിൻ്റെ വേരാണ് മെർക്കൽ റൂട്ട്.

ഫീൽഡുകളിൽ ബ്ലോക്കിൻ്റെ സ്രഷ്ടാവിൻ്റെ പൊതു കീ, സ്രഷ്ടാവിൻ്റെ ഒപ്പ്, ബ്ലോക്കിൻ്റെ പതിപ്പ്, ബ്ലോക്കിലെ ഇടപാടുകളുടെ എണ്ണം, ഈ ഇടപാടുകൾ എന്നിവയുണ്ട്.

അതിൻ്റെ രീതികൾ നോക്കാം:
ഒരു ബ്ലോക്ക് സൃഷ്‌ടിക്കുന്നതിന്, ബ്ലോക്ക്.NewBlock() ഫംഗ്‌ഷൻ ഉപയോഗിക്കുക: NewBlock(prevBlockHash സ്ട്രിംഗ്, ഉയരം int) *ബ്ലോക്ക്, ഇത് ബ്ലോക്ക്ചെയിനിൽ സൃഷ്‌ടിച്ച ബ്ലോക്കിൻ്റെ മുൻ ബ്ലോക്കിൻ്റെ ഹാഷും ഉയരം സെറ്റും എടുക്കുന്നു. തരം പാക്കേജ് സ്ഥിരാങ്കത്തിൽ നിന്നും ബ്ലോക്ക് തരവും സജ്ജീകരിച്ചിരിക്കുന്നു:

b.DataType = types.BLOCK_TYPE.

AddTx(tx *transaction.TX) രീതി ഒരു ബ്ലോക്കിലേക്ക് ഒരു ഇടപാട് ചേർക്കുന്നു.

ബിൽഡ് () രീതി ബ്ലോക്കിൻ്റെ ഫീൽഡുകളിലേക്ക് മൂല്യങ്ങൾ ലോഡ് ചെയ്യുകയും അതിൻ്റെ നിലവിലെ ഹാഷ് ജനറേറ്റ് ചെയ്യുകയും സജ്ജമാക്കുകയും ചെയ്യുന്നു.

ToBytesHeader() []ബൈറ്റ് രീതി ബ്ലോക്ക് തലക്കെട്ടിനെ (ഇടപാടുകളില്ലാതെ) ഒരു ബൈറ്റ് സ്ലൈസാക്കി മാറ്റുന്നു.

ToJSON() സ്ട്രിംഗ് രീതി ഡാറ്റയുടെ ഒരു സ്ട്രിംഗ് പ്രാതിനിധ്യത്തിൽ ബ്ലോക്കിനെ JSON ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.

FromJSON(data []byte) പിശക് രീതി JSON-ൽ നിന്നുള്ള ഡാറ്റ ഒരു ബ്ലോക്ക് ഘടനയിലേക്ക് ലോഡ് ചെയ്യുന്നു.

ചെക്ക്() ബൂൾ രീതി ഒരു ബ്ലോക്ക് ഹാഷ് ജനറേറ്റ് ചെയ്യുകയും ബ്ലോക്ക് ഹാഷ് ഫീൽഡിൽ വ്യക്തമാക്കിയിരിക്കുന്നതുമായി താരതമ്യം ചെയ്യുകയും ചെയ്യുന്നു.

GetTxsHash() സ്ട്രിംഗ് രീതി ബ്ലോക്കിലെ എല്ലാ ഇടപാടുകളുടെയും മൊത്തം ഹാഷ് നൽകുന്നു.

GetMerkleRoot() രീതി ഒരു ബ്ലോക്കിലെ ഇടപാടുകൾക്കായി Merkle ട്രീയുടെ റൂട്ട് വ്യക്തമാക്കുന്നു.

Sign(privk string) രീതി ബ്ലോക്ക് സ്രഷ്ടാവിൻ്റെ സ്വകാര്യ കീ ഉപയോഗിച്ച് ഒരു ബ്ലോക്ക് സൈൻ ചെയ്യുന്നു.

SetHeight(height int) രീതി ബ്ലോക്കിൻ്റെ ഉയരം ബ്ലോക്ക് ഘടന ഫീൽഡിലേക്ക് എഴുതുന്നു.

GetHeight() int രീതി ബ്ലോക്ക് ഘടനയുടെ അനുബന്ധ ഫീൽഡിൽ വ്യക്തമാക്കിയ ബ്ലോക്കിൻ്റെ ഉയരം നൽകുന്നു.

ToGOBBytes() []ബൈറ്റ് രീതി GOB ഫോർമാറ്റിൽ ഒരു ബ്ലോക്ക് എൻകോഡ് ചെയ്യുകയും അത് ഒരു ബൈറ്റ് സ്ലൈസായി നൽകുകയും ചെയ്യുന്നു.

FromGOBBytes(data []byte) പിശക് രീതി GOB ഫോർമാറ്റിൽ പാസ്സാക്കിയ ബൈറ്റ് സ്ലൈസിൽ നിന്ന് ബ്ലോക്ക് ഘടനയിലേക്ക് ബ്ലോക്ക് ഡാറ്റ എഴുതുന്നു.

GetHash() സ്ട്രിംഗ് രീതി തന്നിരിക്കുന്ന ബ്ലോക്കിൻ്റെ ഹാഷ് നൽകുന്നു.

GetPrevHash() സ്ട്രിംഗ് രീതി മുമ്പത്തെ ബ്ലോക്കിൻ്റെ ഹാഷ് നൽകുന്നു.

SetPublicKey(pubk string) രീതി ബ്ലോക്ക് സ്രഷ്ടാവിൻ്റെ പൊതു കീ ബ്ലോക്കിലേക്ക് എഴുതുന്നു.

അങ്ങനെ, ബ്ലോക്ക് ഒബ്‌ജക്റ്റിൻ്റെ രീതികൾ ഉപയോഗിച്ച്, നെറ്റ്‌വർക്കിലൂടെ സംപ്രേഷണം ചെയ്യുന്നതിനും ലെവൽഡിബി ഡാറ്റാബേസിലേക്ക് സംരക്ഷിക്കുന്നതിനുമുള്ള ഒരു ഫോർമാറ്റിലേക്ക് നമുക്ക് എളുപ്പത്തിൽ പരിവർത്തനം ചെയ്യാൻ കഴിയും.

ബ്ലോക്ക്ചെയിനിലേക്ക് സംരക്ഷിക്കുന്നതിന് ബ്ലോക്ക്ചെയിൻ പാക്കേജിൻ്റെ പ്രവർത്തനങ്ങൾ ഉത്തരവാദികളാണ്: 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) പിശക് പ്രവർത്തനം ബ്ലോക്ക്ചെയിനിലേക്ക് ഒരു ബ്ലോക്ക് ചേർക്കുന്നു.

ബ്ലോക്കുകൾ വീണ്ടെടുക്കുന്നതിനും കാണുന്നതിനുമുള്ള പ്രവർത്തനങ്ങൾ blockchain പാക്കേജിൻ്റെ explore.go ഫയലിലുണ്ട്:

GetBlockByHash(hash string) (*block.Block, error) ഫംഗ്‌ഷൻ ഒരു ശൂന്യമായ ബ്ലോക്ക് ഒബ്‌ജക്‌റ്റ് സൃഷ്‌ടിക്കുന്നു, ഡാറ്റാബേസിൽ നിന്ന് അതിലേക്ക് ഒരു ബ്ലോക്ക് ലോഡ് ചെയ്യുന്നു, അതിൻ്റെ ഹാഷ് അതിലേക്ക് കൈമാറി, അതിലേക്ക് ഒരു പോയിൻ്റർ തിരികെ നൽകുന്നു.

ബ്ലോക്ക്‌ചെയിൻ പാക്കേജിൻ്റെ genesis.go ഫയലിൽ നിന്നുള്ള Genesis() പിശക് ഫംഗ്‌ഷൻ വഴിയാണ് ഒരു ജനിതക ബ്ലോക്ക് സൃഷ്ടിക്കുന്നത്.

WebSocket മെക്കാനിസം ഉപയോഗിച്ച് ഒരു നോഡിലേക്ക് ക്ലയൻ്റുകളെ ബന്ധിപ്പിക്കുന്നതിനെക്കുറിച്ച് അടുത്ത ലേഖനം സംസാരിക്കും.

അവലംബം: www.habr.com