ਮੈਂ ਆਪਣੇ ਗੋ ਬਲਾਕਚੈਨ ਵਿੱਚ ਬਲਾਕ ਅਤੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਡਿਜ਼ਾਈਨ ਕੀਤਾ

ਅੰਤ ਵਿੱਚ ਇੱਕ ਬਲਾਕਚੈਨ ਨਾਲ ਖਤਮ ਕਰਨ ਲਈ ਨਾ ਕਿ ਸਿਰਫ ਇੱਕ ਡੇਟਾਬੇਸ, ਸਾਨੂੰ ਸਾਡੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ 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, error) ਵਿਧੀ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵਿੱਚ ਇੱਕ ਇਨਪੁਟ ਜੋੜਦੀ ਹੈ।

AddTxOut(value int, data []byte) (*TxOut, error) ਵਿਧੀ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵਿੱਚ ਇੱਕ ਆਉਟਪੁੱਟ ਜੋੜਦੀ ਹੈ।

ToBytes() []ਬਾਈਟ ਵਿਧੀ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਨੂੰ ਬਾਈਟ ਸਲਾਈਸ ਵਿੱਚ ਬਦਲ ਦਿੰਦੀ ਹੈ।

ਅੰਦਰੂਨੀ ਫੰਕਸ਼ਨ preByteHash(bytes []byte) ਸਟ੍ਰਿੰਗ ਨੂੰ JavaScript ਐਪਲੀਕੇਸ਼ਨਾਂ ਤੋਂ ਤਿਆਰ ਕੀਤੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਹੈਸ਼ ਦੇ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ 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 ਹੈ।

ਬਲਾਕਹਾਈਟ ਬਲਾਕ ਦੀ ਉਚਾਈ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ।
ਟਾਈਮਸਟੈਂਪ ਟਾਈਮਸਟੈਂਪ।
HeaderSize ਬਾਈਟ ਵਿੱਚ ਬਲਾਕ ਦਾ ਆਕਾਰ ਹੈ।
PrevBlockHash ਪਿਛਲੇ ਬਲਾਕ ਦਾ ਹੈਸ਼ ਹੈ, ਅਤੇ SelfBlockHash ਮੌਜੂਦਾ ਇੱਕ ਦਾ ਹੈਸ਼ ਹੈ।
TxsHash ਲੈਣ-ਦੇਣ ਦਾ ਇੱਕ ਆਮ ਹੈਸ਼ ਹੈ।
MerkleRoot Merkle ਰੁੱਖ ਦੀ ਜੜ੍ਹ ਹੈ.

ਹੋਰ ਖੇਤਰਾਂ ਵਿੱਚ ਬਲਾਕ ਦੇ ਸਿਰਜਣਹਾਰ ਦੀ ਜਨਤਕ ਕੁੰਜੀ, ਸਿਰਜਣਹਾਰ ਦੇ ਦਸਤਖਤ, ਬਲਾਕ ਦਾ ਸੰਸਕਰਣ, ਬਲਾਕ ਵਿੱਚ ਲੈਣ-ਦੇਣ ਦੀ ਸੰਖਿਆ, ਅਤੇ ਇਹ ਲੈਣ-ਦੇਣ ਖੁਦ ਹੁੰਦੇ ਹਨ।

ਆਓ ਇਸਦੇ ਤਰੀਕਿਆਂ ਨੂੰ ਵੇਖੀਏ:
ਇੱਕ ਬਲਾਕ ਬਣਾਉਣ ਲਈ, 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() ਵਿਧੀ ਇੱਕ ਬਲਾਕ ਵਿੱਚ ਲੈਣ-ਦੇਣ ਲਈ Merkle ਟ੍ਰੀ ਦੀ ਜੜ੍ਹ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।

ਸਾਈਨ (privk ਸਤਰ) ਵਿਧੀ ਬਲਾਕ ਸਿਰਜਣਹਾਰ ਦੀ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਨਾਲ ਇੱਕ ਬਲਾਕ ਨੂੰ ਸਾਈਨ ਕਰਦੀ ਹੈ।

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(ਹੈਸ਼ ਸਟ੍ਰਿੰਗ) ਐਰਰ ਫੰਕਸ਼ਨ ਮੌਜੂਦਾ ਬਲਾਕ ਦੇ ਹੈਸ਼ ਨੂੰ ਡਾਟਾਬੇਸ ਲਈ BLOCK_HASH ਸਥਿਰ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੁੰਜੀ ਨਾਲ ਲਿਖਦਾ ਹੈ।

GetTargetBlockHash() (ਸਟਰਿੰਗ, ਐਰਰ) ਫੰਕਸ਼ਨ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਮੌਜੂਦਾ ਬਲਾਕ ਦਾ ਹੈਸ਼ ਵਾਪਸ ਕਰਦਾ ਹੈ।

SetTargetBlockHeight(height int) ਐਰਰ ਫੰਕਸ਼ਨ BLOCK_HEIGHT ਸਥਿਰਾਂਕ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੁੰਜੀ ਦੇ ਨਾਲ ਨੋਡ ਲਈ ਬਲਾਕਚੈਨ ਉਚਾਈ ਦਾ ਮੁੱਲ ਡਾਟਾਬੇਸ ਨੂੰ ਲਿਖਦਾ ਹੈ।

GetTargetBlockHeight() (int, error) ਫੰਕਸ਼ਨ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਗਏ ਨੋਡ ਲਈ ਬਲਾਕਚੈਨ ਦੀ ਉਚਾਈ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਚੈੱਕਬਲਾਕ (ਬਲਾਕ IBlock) ਬੂਲ ਫੰਕਸ਼ਨ ਬਲਾਕਚੈਨ ਵਿੱਚ ਇਸ ਬਲਾਕ ਨੂੰ ਜੋੜਨ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਬਲਾਕ ਦੀ ਸ਼ੁੱਧਤਾ ਲਈ ਜਾਂਚ ਕਰਦਾ ਹੈ।

ਐਡਬਲਾਕ (ਬਲਾਕ IBlock) ਗਲਤੀ ਫੰਕਸ਼ਨ ਬਲਾਕਚੈਨ ਵਿੱਚ ਇੱਕ ਬਲਾਕ ਜੋੜਦਾ ਹੈ।

ਬਲਾਕਚੈਨ ਪੈਕੇਜ ਦੀ explore.go ਫਾਈਲ ਵਿੱਚ ਬਲਾਕਾਂ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਦੇਖਣ ਲਈ ਫੰਕਸ਼ਨ ਹਨ:

GetBlockByHash(hash string) (*block.Block, error) ਫੰਕਸ਼ਨ ਇੱਕ ਖਾਲੀ ਬਲਾਕ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ, ਡੇਟਾਬੇਸ ਤੋਂ ਇਸ ਵਿੱਚ ਇੱਕ ਬਲਾਕ ਲੋਡ ਕਰਦਾ ਹੈ, ਜਿਸ ਦਾ ਹੈਸ਼ ਇਸ ਨੂੰ ਪਾਸ ਕੀਤਾ ਗਿਆ ਸੀ, ਅਤੇ ਇਸ ਨੂੰ ਇੱਕ ਪੁਆਇੰਟਰ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਇੱਕ ਜੈਨੇਸਿਸ ਬਲਾਕ ਦੀ ਰਚਨਾ ਬਲਾਕਚੈਨ ਪੈਕੇਜ ਦੀ genesis.go ਫਾਈਲ ਤੋਂ Genesis() ਐਰਰ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਅਗਲਾ ਲੇਖ WebSocket ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਗਾਹਕਾਂ ਨੂੰ ਨੋਡ ਨਾਲ ਜੋੜਨ ਬਾਰੇ ਗੱਲ ਕਰੇਗਾ।

ਸਰੋਤ: www.habr.com