ನನ್ನ ಗೋ ಬ್ಲಾಕ್‌ಚೈನ್‌ನಲ್ಲಿ ನಾನು ಬ್ಲಾಕ್‌ಗಳು ಮತ್ತು ವಹಿವಾಟುಗಳನ್ನು ಹೇಗೆ ವಿನ್ಯಾಸಗೊಳಿಸಿದೆ

ಅಂತಿಮವಾಗಿ ಬ್ಲಾಕ್‌ಚೈನ್‌ನೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳಲು ಮತ್ತು ಡೇಟಾಬೇಸ್ ಅಲ್ಲ, ನಾವು ನಮ್ಮ ಯೋಜನೆಗೆ 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 ಔಟ್‌ಪುಟ್‌ಗಳು ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಮತ್ತು ಬೈಟ್‌ಕೋಡ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುತ್ತವೆ.

ವಹಿವಾಟು ತನ್ನ ಡೇಟಾದಲ್ಲಿ ಯಾವ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ಈಗ ನೋಡೋಣ, ಅಂದರೆ. ವಿಧಾನಗಳನ್ನು ನೋಡೋಣ.

ವಹಿವಾಟನ್ನು ರಚಿಸಲು, ವಹಿವಾಟನ್ನು ಬಳಸಿ.ಹೊಸ ವಹಿವಾಟು(txtype byte) *TX ಕಾರ್ಯ.

AddTxIn(thattxhash []byte, txoutn int, code []byte) (*TxIn, ದೋಷ) ವಿಧಾನವು ವಹಿವಾಟಿಗೆ ಇನ್‌ಪುಟ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.

AddTxOut(ಮೌಲ್ಯ ಇಂಟ್, ಡೇಟಾ []ಬೈಟ್) (*TxOut, ದೋಷ) ವಿಧಾನವು ವಹಿವಾಟಿಗೆ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.

ToBytes() []byte ವಿಧಾನವು ವಹಿವಾಟನ್ನು ಬೈಟ್ ಸ್ಲೈಸ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.

JavaScript ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಂದ ರಚಿಸಲಾದ ವಹಿವಾಟು ಹ್ಯಾಶ್‌ಗಳೊಂದಿಗೆ ರಚಿತವಾದ ವಹಿವಾಟು ಹ್ಯಾಶ್‌ಗೆ ಹೊಂದಾಣಿಕೆಯಾಗುವಂತೆ ಮಾಡಲು ಆಂತರಿಕ ಕಾರ್ಯ preByteHash(bytes []byte) ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬಿಲ್ಡ್() ಮತ್ತು ಚೆಕ್() ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಬಿಲ್ಡ್() ವಿಧಾನವು ವಹಿವಾಟು ಹ್ಯಾಶ್ ಅನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಹೊಂದಿಸುತ್ತದೆ: 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
}

ಡೇಟಾ ಟೈಪ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ನೋಡ್ ಅದನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ವಹಿವಾಟು ಅಥವಾ ಇತರ ಡೇಟಾದಿಂದ ಬ್ಲಾಕ್ ಅನ್ನು ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ. ಒಂದು ಬ್ಲಾಕ್ಗೆ ಈ ಮೌಲ್ಯವು 1 ಆಗಿದೆ.

ಬ್ಲಾಕ್‌ಹೈಟ್ ಬ್ಲಾಕ್‌ನ ಎತ್ತರವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.
ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್.
ಹೆಡರ್ ಗಾತ್ರವು ಬೈಟ್‌ಗಳಲ್ಲಿ ಬ್ಲಾಕ್ ಗಾತ್ರವಾಗಿದೆ.
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() ವಿಧಾನವು ಬ್ಲಾಕ್‌ನಲ್ಲಿನ ವಹಿವಾಟುಗಳಿಗಾಗಿ ಮರ್ಕಲ್ ಮರದ ಮೂಲವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.

ಸೈನ್ (privk ಸ್ಟ್ರಿಂಗ್) ವಿಧಾನವು ಬ್ಲಾಕ್ ರಚನೆಕಾರರ ಖಾಸಗಿ ಕೀಲಿಯೊಂದಿಗೆ ಬ್ಲಾಕ್ ಅನ್ನು ಸಹಿ ಮಾಡುತ್ತದೆ.

SetHeight(height int) ವಿಧಾನವು ಬ್ಲಾಕ್ನ ಎತ್ತರವನ್ನು ಬ್ಲಾಕ್ ರಚನೆ ಕ್ಷೇತ್ರಕ್ಕೆ ಬರೆಯುತ್ತದೆ.

GetHeight() int ವಿಧಾನವು ಬ್ಲಾಕ್ ರಚನೆಯ ಅನುಗುಣವಾದ ಕ್ಷೇತ್ರದಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದಂತೆ ಬ್ಲಾಕ್‌ನ ಎತ್ತರವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ToGOBBytes() []ಬೈಟ್ ವಿಧಾನವು GOB ಸ್ವರೂಪದಲ್ಲಿ ಬ್ಲಾಕ್ ಅನ್ನು ಎನ್ಕೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಬೈಟ್ ಸ್ಲೈಸ್ ಆಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

FromGOBBytes(data []byte) ದೋಷ ವಿಧಾನವು GOB ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಪಾಸ್ ಮಾಡಿದ ಬೈಟ್ ಸ್ಲೈಸ್‌ನಿಂದ ಬ್ಲಾಕ್ ರಚನೆಗೆ ಬ್ಲಾಕ್ ಡೇಟಾವನ್ನು ಬರೆಯುತ್ತದೆ.

GetHash() ಸ್ಟ್ರಿಂಗ್ ವಿಧಾನವು ಕೊಟ್ಟಿರುವ ಬ್ಲಾಕ್‌ನ ಹ್ಯಾಶ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

GetPrevHash() ಸ್ಟ್ರಿಂಗ್ ವಿಧಾನವು ಹಿಂದಿನ ಬ್ಲಾಕ್‌ನ ಹ್ಯಾಶ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

SetPublicKey(pubk string) ವಿಧಾನವು ಬ್ಲಾಕ್ ರಚನೆಕಾರರ ಸಾರ್ವಜನಿಕ ಕೀಲಿಯನ್ನು ಬ್ಲಾಕ್‌ಗೆ ಬರೆಯುತ್ತದೆ.

ಹೀಗಾಗಿ, ಬ್ಲಾಕ್ ಆಬ್ಜೆಕ್ಟ್ನ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ಸುಲಭವಾಗಿ ನೆಟ್ವರ್ಕ್ ಮೂಲಕ ಪ್ರಸರಣಕ್ಕಾಗಿ ಸ್ವರೂಪವಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು ಮತ್ತು 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(ಹ್ಯಾಶ್ ಸ್ಟ್ರಿಂಗ್) ದೋಷ ಕಾರ್ಯವು ಪ್ರಸ್ತುತ ಬ್ಲಾಕ್‌ನ ಹ್ಯಾಶ್ ಅನ್ನು ಡೇಟಾಬೇಸ್‌ಗೆ BLOCK_HASH ಸ್ಥಿರದಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕೀಲಿಯೊಂದಿಗೆ ಬರೆಯುತ್ತದೆ.

GetTargetBlockHash() (ಸ್ಟ್ರಿಂಗ್, ದೋಷ) ಕಾರ್ಯವು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಪ್ರಸ್ತುತ ಬ್ಲಾಕ್‌ನ ಹ್ಯಾಶ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

SetTargetBlockHeight(height int) ದೋಷ ಕಾರ್ಯವು BLOCK_HEIGHT ಸ್ಥಿರಾಂಕದಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕೀಲಿಯೊಂದಿಗೆ ನೋಡ್‌ಗಾಗಿ ಬ್ಲಾಕ್‌ಚೈನ್ ಎತ್ತರದ ಮೌಲ್ಯವನ್ನು ಡೇಟಾಬೇಸ್‌ಗೆ ಬರೆಯುತ್ತದೆ.

GetTargetBlockHeight() (ಇಂಟ್, ದೋಷ) ಕಾರ್ಯವು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ನಿರ್ದಿಷ್ಟ ನೋಡ್‌ಗಾಗಿ ಬ್ಲಾಕ್‌ಚೈನ್‌ನ ಎತ್ತರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಚೆಕ್‌ಬ್ಲಾಕ್(ಬ್ಲಾಕ್ ಐಬ್ಲಾಕ್) ಬೂಲ್ ಕಾರ್ಯವು ಬ್ಲಾಕ್‌ಚೈನ್‌ಗೆ ಈ ಬ್ಲಾಕ್ ಅನ್ನು ಸೇರಿಸುವ ಮೊದಲು ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.

ಆಡ್‌ಬ್ಲಾಕ್ (ಬ್ಲಾಕ್ ಐಬ್ಲಾಕ್) ದೋಷ ಕಾರ್ಯವು ಬ್ಲಾಕ್‌ಚೈನ್‌ಗೆ ಬ್ಲಾಕ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.

ಬ್ಲಾಕ್‌ಚೈನ್ ಪ್ಯಾಕೇಜ್‌ನ explore.go ಫೈಲ್‌ನಲ್ಲಿ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಹಿಂಪಡೆಯುವ ಮತ್ತು ವೀಕ್ಷಿಸುವ ಕಾರ್ಯಗಳು:

GetBlockByHash(ಹ್ಯಾಶ್ ಸ್ಟ್ರಿಂಗ್) (*block.Block, ದೋಷ) ಕಾರ್ಯವು ಖಾಲಿ ಬ್ಲಾಕ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಡೇಟಾಬೇಸ್‌ನಿಂದ ಅದರೊಳಗೆ ಒಂದು ಬ್ಲಾಕ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ, ಅದರ ಹ್ಯಾಶ್ ಅನ್ನು ಅದಕ್ಕೆ ರವಾನಿಸಲಾಗಿದೆ ಮತ್ತು ಅದಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಬ್ಲಾಕ್‌ಚೈನ್ ಪ್ಯಾಕೇಜ್‌ನ genesis.go ಫೈಲ್‌ನಿಂದ ಜೆನೆಸಿಸ್ () ದೋಷ ಕಾರ್ಯದಿಂದ ಜೆನೆಸಿಸ್ ಬ್ಲಾಕ್‌ನ ರಚನೆಯನ್ನು ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ.

ಮುಂದಿನ ಲೇಖನವು ವೆಬ್‌ಸಾಕೆಟ್ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ಲೈಂಟ್‌ಗಳನ್ನು ನೋಡ್‌ಗೆ ಸಂಪರ್ಕಿಸುವ ಕುರಿತು ಮಾತನಾಡುತ್ತದೆ.

ಮೂಲ: www.habr.com