正所谓区块链，怎能不熟悉区块的数据结构呢？区块的结构体被保存在core/types/block.go文件中，下面是我截取出来的：
type Block struct {
header *Header
uncles []*Header
transactions Transactions
withdrawals Withdrawals
// caches
hash atomic.Value
size atomic.Value
// These fields are used by package eth to track
// inter-peer block relay.
ReceivedAt time.Time
ReceivedFrom interface{}
}
我之前主要使用C++语言，可以看出来上面的代码和C++语言还是有一定的差异的，C++结构体中先声明变量的类型，然后给出变量的名称，而上面的代码则是反过来了，先给出了成员变量的名称，然后给出了类型。下面是对各个字段的解释：
| 字段 | 描述 |
|---|---|
| header | 指向Header类型的指针，表示该区块的头部信息 |
| uncles | 指向Header类型的数组，表示该区块的叔父区块 |
| transactions | 区块所包含的交易列表 |
| withdrawals | 区块中的提款列表 |
| hash | 区块的哈希值 |
| size | 区块的大小 |
| ReceivedAt | 接收到该区块的时间 |
| ReceivedFrom | 区块是被谁挖出来的 |
现在对于区块的内容已经有所了解了，再来看看区块头的数据结构：
type Header struct {
ParentHash common.Hash `json:"parentHash" gencodec:"required"`
UncleHash common.Hash `json:"sha3Uncles" gencodec:"required"`
Coinbase common.Address `json:"miner"`
Root common.Hash `json:"stateRoot" gencodec:"required"`
TxHash common.Hash `json:"transactionsRoot" gencodec:"required"`
ReceiptHash common.Hash `json:"receiptsRoot" gencodec:"required"`
Bloom Bloom `json:"logsBloom" gencodec:"required"`
Difficulty *big.Int `json:"difficulty" gencodec:"required"`
Number *big.Int `json:"number" gencodec:"required"`
GasLimit uint64 `json:"gasLimit" gencodec:"required"`
GasUsed uint64 `json:"gasUsed" gencodec:"required"`
Time uint64 `json:"timestamp" gencodec:"required"`
Extra []byte `json:"extraData" gencodec:"required"`
MixDigest common.Hash `json:"mixHash"`
Nonce BlockNonce `json:"nonce"`
// BaseFee was added by EIP-1559 and is ignored in legacy headers.
BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"`
// WithdrawalsHash was added by EIP-4895 and is ignored in legacy headers.
WithdrawalsHash *common.Hash `json:"withdrawalsRoot" rlp:"optional"`
// BlobGasUsed was added by EIP-4844 and is ignored in legacy headers.
BlobGasUsed *uint64 `json:"blobGasUsed" rlp:"optional"`
// ExcessBlobGas was added by EIP-4844 and is ignored in legacy headers.
ExcessBlobGas *uint64 `json:"excessBlobGas" rlp:"optional"`
// ParentBeaconRoot was added by EIP-4788 and is ignored in legacy headers.
ParentBeaconRoot *common.Hash `json:"parentBeaconBlockRoot" rlp:"optional"`
}
下面是对于字段的解释：
| 字段 | 描述 |
|---|---|
| ParentHash | 父区块的哈希值 |
| UncleHash | 叔父区块的哈希值 |
| Coinbase | 挖矿成功的奖励地址 |
| Root | 状态树的根哈希值 |
| TxHash | 交易树的根哈希值 |
| ReceiptHash | 收据树的根哈希值 |
| Bloom | 布隆过滤器 |
| Difficulty | 挖矿难度 |
| Number | 区块的编号 |
| GasLimit | 汽油的最大量限制 |
| GasUsed | 汽油的使用量 |
| Time | 区块的生成时间 |
| Extra | 附加数据 |
| MixDigest | 区块的混合哈希值 |
| Nonce | 挖矿所需要不断尝试的随机数（4字节） |
| BaseFee | 基础手续费 |
| WithdrawalsHash | 提款根的哈希值 |
| BlobGasUsed | 新的燃气类型的使用量 |
| ExcessBlobGas | 辅助识别处理异常情况，当恶意节点试图使用超额的新的燃气类型 |
| ParentBeaconRoo | 跟踪对应的父分片，以太坊2.0引入了分片链的概念，每个分片都是相对独立的链，有一个对应的父分片，目的是提高网络的吞吐量和扩展性。 |
上面的字段中，最后五个字段是新提出来的，在传统的区块中会忽略对应的字段。接下来是区块体：
type Body struct {
Transactions []*Transaction
Uncles []*Header
Withdrawals []*Withdrawal `rlp:"optional"`
}
| 字段 | 描述 |
|---|---|
| Transactions | 保存当前区块的所有交易列表 |
| Uncles | 保存当前区块的所有叔父区块 |
| Withdrawals | 保存当前区块的所有提款列表 |
type headerMarshaling struct {
Difficulty *hexutil.Big
Number *hexutil.Big
GasLimit hexutil.Uint64
GasUsed hexutil.Uint64
Time hexutil.Uint64
Extra hexutil.Bytes
BaseFee *hexutil.Big
Hash common.Hash `json:"hash"` // adds call to Hash() in MarshalJSON
BlobGasUsed *hexutil.Uint64
ExcessBlobGas *hexutil.Uint64
}
如上面结构体所示，以太坊提供了一个将区块头编码的结构体，将区块头中的部分变量换成了十六进制。在以太坊中，还提供了类型覆盖结构体，用于进行编码和解码时指定特定字段的编码方式，以满足不同的需求或协议规范。这种方式允许开发者根据实际情况定制编码和解码的行为，使得数据的序列哈和反序列化更加灵活和可定制。
以太坊中的区块头包含了诸多重要的信息，例如区块号、难度、气体限制、时间戳等等。在不同的协议中，可能需要不同的方式对这些数据进行编码和解码，以满足不同的需求，因此，使用覆盖结构体可以灵活的指定特定字段的编码方式，使得以太坊在不同的环境中具有更强的适应性和可扩展性。
在文件中，还有行代码：
type BlockNonce [8]byte
在工作量证明中，用户打包交易后生成Merck树，然后将其根哈希值保存到区块头中，对整个区块头取哈希的到一个值，这个值需要满足足够小的条件，由于哈希正向容易反向难的特点，矿工很难反向计算得到Nonce值，因此会一个一个数字去尝试，由于不同的矿工打包的交易可能不一样，因此矿工需要找到的Nonce值也可能不一样。上面这行代码说明了Nonce是一个8字节64位的值。通过查询资料得知，由于全网算力的不断增大，64位的难度难以满足要求，因此将Coinbase字段的前4字节也作为取哈希的内容，这部分的内容可以用户自己设置，通常包含挖矿的奖励地址。
言归正传，先声明变量名，然后声明类型已经很奇怪了，后来发现还有更加怪异的，看下面的函数：
func (n BlockNonce) Uint64() uint64 {
return binary.BigEndian.Uint64(n[:])
}
先不用管函数的意义，看看函数的声明是否很奇怪？？？通过查找资料发现：
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
函数体
}
通过上网查询资料发现，接收者类型类似于C++中的this指针，而使用this指针时会修改实际的值，如果是传递一般的参数，则会拷贝一份副本，副本的改变不会导致实参的改变。接收者的声明规则如下：
-
接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为 p，Connector类型的接收者变量应该命名为c等。
-
接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
-
方法名、参数列表、返回参数：具体格式与函数定义相同。
在Go语言中，nil 是一个预定义的标识符，用于表示指针、切片、映射、通道、函数和接口类型的零值或空值。具体含义取决于它所用于的类型。
-
对于指针类型，
nil表示一个空指针，即指针未指向任何有效的内存地址。 -
对于切片、映射、通道、函数和接口类型，
nil表示这些数据结构是空的，即切片、映射、通道为空，函数和接口未指向任何具体的实现或值。
在条件语句中，可以使用 nil 来检查指针、切片、映射、通道、函数和接口是否为零值或空值。
下面是以太坊外部区块的结构体：
type extblock struct {
Header *Header
Txs []*Transaction
Uncles []*Header
Withdrawals []*Withdrawal `rlp:"optional"`
}
-
Header: 代表了区块的头部信息，包括区块的元数据，如区块号、时间戳、难度等。 -
Txs: 是一个包含了所有交易的列表，每个交易都是一个Transaction结构体的实例。 -
Uncles: 是一个包含了叔块（Uncle Block）的列表，每个叔块也是一个Header结构体的实例。 -
Withdrawals: 是一个包含了所有提现的列表，每个提现也是一个Withdrawal结构体的实例。
现在对于区块的相关结构体，我们已经有了一定的了解，那么来看看以太坊是如何产生新区块的。
func NewBlock(header *Header, txs []*Transaction, uncles []*Header, receipts []*Receipt, hasher TrieHasher) *Block {
// 创建一个block对象，拷贝一个header对象来初始化block的header字段
b := &Block{header: CopyHeader(header)}
// 设置交易列表，当交易列表不为空时，根据交易列表计算出哈希值并赋值给TxHash字段并设置block的交易列表
if len(txs) == 0 {
b.header.TxHash = EmptyTxsHash
} else {
b.header.TxHash = DeriveSha(Transactions(txs), hasher)
b.transactions = make(Transactions, len(txs))
copy(b.transactions, txs)
}
// 设置收据树以及布隆过滤器
if len(receipts) == 0 {
b.header.ReceiptHash = EmptyReceiptsHash
} else {
b.header.ReceiptHash = DeriveSha(Receipts(receipts), hasher)
b.header.Bloom = CreateBloom(receipts)
}
// 设置叔节点
if len(uncles) == 0 {
b.header.UncleHash = EmptyUncleHash
} else {
b.header.UncleHash = CalcUncleHash(uncles)
b.uncles = make([]*Header, len(uncles))
for i := range uncles {
b.uncles[i] = CopyHeader(uncles[i])
}
}
return b
}
// 下面的函数允许区块指定额外的体现信息
func NewBlockWithWithdrawals(header *Header, txs []*Transaction, uncles []*Header, receipts []*Receipt, withdrawals []*Withdrawal, hasher TrieHasher) *Block {
b := NewBlock(header, txs, uncles, receipts, hasher)
if withdrawals == nil {
b.header.WithdrawalsHash = nil
} else if len(withdrawals) == 0 {
b.header.WithdrawalsHash = &EmptyWithdrawalsHash
} else {
h := DeriveSha(Withdrawals(withdrawals), hasher)
b.header.WithdrawalsHash = &h
}
return b.WithWithdrawals(withdrawals)
}
// 实现对区块头的深拷贝
func CopyHeader(h *Header) *Header {
cpy := *h
if cpy.Difficulty = new(big.Int); h.Difficulty != nil {
cpy.Difficulty.Set(h.Difficulty)
}
if cpy.Number = new(big.Int); h.Number != nil {
cpy.Number.Set(h.Number)
}
if h.BaseFee != nil {
cpy.BaseFee = new(big.Int).Set(h.BaseFee)
}
if len(h.Extra) > 0 {
cpy.Extra = make([]byte, len(h.Extra))
copy(cpy.Extra, h.Extra)
}
if h.WithdrawalsHash != nil {
cpy.WithdrawalsHash = new(common.Hash)
*cpy.WithdrawalsHash = *h.WithdrawalsHash
}
if h.ExcessBlobGas != nil {
cpy.ExcessBlobGas = new(uint64)
*cpy.ExcessBlobGas = *h.ExcessBlobGas
}
if h.BlobGasUsed != nil {
cpy.BlobGasUsed = new(uint64)
*cpy.BlobGasUsed = *h.BlobGasUsed
}
if h.ParentBeaconRoot != nil {
cpy.ParentBeaconRoot = new(common.Hash)
*cpy.ParentBeaconRoot = *h.ParentBeaconRoot
}
return &cpy
}
下面是一些函数的作用：
| 函数 | 功能 |
|---|---|
| func EncodeNonce(i uint64) BlockNonce | 将输入的64位无符号整数转换成字节数组，转换成BlockNorce类型（大端序） |
| func (n BlockNonce) Uint64() uint64 | 将BlockNonce按照大端序转换成无符号64位整数 |
| func (n BlockNonce) MarshalText() ([]byte, error) | 将BlockNonce类型的值编码为带有0x前缀的十六进制字符串 |
| func (n *BlockNonce) UnmarshalText(input []byte) error | 从带有0x前缀的十六进制字符串解码并填充BlockNonce类型的值 |
| func (h *Header) Hash() common.Hash | 计算区块头的哈希值 |
| func (h *Header) Size() common.StorageSize | 区块头所有内容所占内存大小 |
| func (h *Header) SanityCheck() error | 判断区块头部字段是否在合理范围内 |
| func (h *Header) EmptyBody() bool | 检查头部信息的主体部分是否是空 |
| func (h *Header) EmptyReceipts() bool | 检查头部的收据是否为空 |
| func (b *Block) DecodeRLP(s *rlp.Stream) error | 从流中解码区块数据 |
| func (b *Block) EncodeRLP(w io.Writer) error | 将区块数据序列格式化RLP格式，并写入流中 |
此外还提供了一个更换区块区块头、更换区块体、更换交易列表等函数。