Understanding of the blockchain structure of Ethereum: Does a block contain the list of transactions or just the Merkle tree?
As a blockchain enthusiast, you probably heard from Ethereum and its decentralized digital ledger technology. A fundamental aspect of the architecture of Ethereum is that it not only stores the current state of blockchain (the list of transactions), but also various other data structures in order to facilitate efficient query, manipulation and review of transactions. In this article we will deal with the way a block encodes its transactions in an Ethereum transactions and examines whether it contains the Merkle tree or whether it only stores the hash.
The role of blocks in Ethereum
In the blockchain architecture of Ethereum, blocks are the basic units that store a collection of transactions. A single block typically contains several transactions, which are summarized in “depicted” (i.e. verified) and “un mined” (i.e. not yet verified). The first code lines in each block contain metadata via the block itself, including the hash, the timeline and other essential information.
The Merkle tree: a key data structure
Now let’s talk about the Merkle tree. A Merkle tree is a tree-like data structure with which the integrity and authenticity of transactions can be checked within a block. Every knot in the tree represents a transaction, and its hash value serves as a digital fingerprint to identify it. By combining several hashes from different nodes into a single hash (the root), you create a clear identifier for each transaction.
The Merkle tree is generated at the time of block creation using the transactions stored in the block. This process includes recursive individual elements in the tree until they reach a leaf node, which is then hydrated to create the hash of his parent. The resulting hash value is used as the root of the Merkle tree.
Ethereum stores the list of transactions or just the Merkle tree?
Does an Ethereum block contain both the list of transactions and the Merkle tree? In short, yes, it does it! The first code lines in each block serve as metadata, including:
- Transaction data
: The actual transactions stored in the block.
- Merkle Tree : A digital representation of the transactions created from their hashes.
In other words, a block contains both a list of transactions (the “transactions” array) and a Merkle tree (the “tree” variable) to facilitate transaction check and query.
Sample code -nippets
In order to illustrate this concept, we consider an example using solidity, the Ethereum Smart Contract Language:
`Solidity
Pragma solidity ^0.8.0;
Contract Simpl doorsum {
// The first code lines in each block contain metadata around the block.
Constructor () public {
uint256 _TIMESTAMP = block.Timestamp;
String memory _hash = Keccak256 (Abi.encodepacked (_TIMESTAMP));
Bytes memory _Blockhash = Keccak256 (Abi.encodepacked (_hash, “Mytransaction”));
Metadata (_Blockhash) emit;
}
Struct block metadata {
Uint256 Time stamp;
Bytes32 hash;
}
// in the constructor function of block metadata …
Block metadata public metadata;
// When a block is created …
Modifier pre -block (Uint256 _TIMESTAMP) {
require (_TIMESTAMP <= block.Timestamp, "timestamp is not in the past");
Metadata (Block.Hash) emit;
return;
}
}
`
In this example, the “metadata variable within the” simpllethereum “variables represents a block with the time stamp and its hash. When creating a new block, the constructor function” Metadata “is called up to generate a” block metadata “structure that contains both metadata values.