以太坊go-ethereum源码研读（一）从Process函数相关自定义类型和结构体开始

写在前面

现在自己对其中一些代码的理解还不够，等我逐渐深入学习后回回来再修改的。
其中对于一些代码的理解参考了以太坊黄皮书的内容。
链接: https://ethereum.github.io/yellowpaper/paper.pdf

一些自定义类型

一些结构体

Receipt

位于core\types\receipt.go
为了方便索引、搜索交易和对交易的零知识证明，将交易执行中的某些信息进行编码形成了Receipt

参考黄皮书4.3.1

Log

位于core\types\log.go
以太坊中定义了event和log机制，用于表示一个合约的日志。

Header

位于core\types\block.go
表示区块头

ChainConfig

位于params\config.go
代表区块链的配置

BlockChain

位于core\blockchain.go
待补充

Transaction

位于core\types\transaction.go
其中txdata是一个接口，定义如下，位于相同位置

位于core\types\transaction.go

Block

位于core\types\block.go
表示区块

StateProcessor

位于core\state_processor.go

BlockContext

位于core\vm\evm.go
表示区块上下文，很多属性和前面是重复的。

evm

位于core\vm\evm.go
待补充

Message

位于core\types\transaction.go
派生的事务（待补充）

StateDB

位于core\state\statedb.go
StateDB结构用于存储所有的与Merkle trie相关的存储, 包括一些循环state结构

accessList

位于core\state\access_list.go
每个事务的访问列表,在某些形式的 EVM 执行过程中会触及的账户和合约存储位置的列表

Engine

位于consensus\consensus.go
engine是一个算法无关的用作共识层面的引擎

相关函数

Process

位于core\state_processor.go

func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) {var (receipts    types.ReceiptsusedGas     = new(uint64)header      = block.Header()blockHash   = block.Hash()blockNumber = block.Number()allLogs     []*types.Loggp          = new(GasPool).AddGas(block.GasLimit()))// Mutate the block and state according to any hard-fork specsif p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {misc.ApplyDAOHardFork(statedb)}blockContext := NewEVMBlockContext(header, p.bc, nil)vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg)// Iterate over and process the individual transactionsfor i, tx := range block.Transactions() {msg, err := tx.AsMessage(types.MakeSigner(p.config, header.Number), header.BaseFee)if err != nil {return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)}statedb.Prepare(tx.Hash(), i)receipt, err := applyTransaction(msg, p.config, p.bc, nil, gp, statedb, blockNumber, blockHash, tx, usedGas, vmenv)if err != nil {return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)}receipts = append(receipts, receipt)allLogs = append(allLogs, receipt.Logs...)}// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles())return receipts, allLogs, *usedGas, nil
}

首先该函数判断当前区块是否为DAO硬分叉的区块，若是则调用ApplyDAOHardFork函数（待补充）。
然后调用NewEVMBlockContext函数为当前区块创立一个运行上下文。
随后调用NewEVM函数建立一个以太坊虚拟机，准备编译执行程序。
然后枚举区块中的交易并把它转换为消息格式，随后调用Prepare函数设置当前状态的交易hash和序号，随后调用applyTransaction在虚拟机中执行交易相关指令（见以太坊go-ethereum源码研读（二）进一步分析），得到返回的收据后，加入到列表中，并获取其中的日志加入到列表中，最后调用共识引擎的Finalize函数计算区块奖励并加入到最终状态中。

NewEVMBlockContext

位于core\evm.go
根据区块头信息，建立并返回一个BlockContext区块上下文信息结构体

func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common.Address) vm.BlockContext {var (beneficiary common.AddressbaseFee     *big.Int)// If we don't have an explicit author (i.e. not mining), extract from the headerif author == nil {beneficiary, _ = chain.Engine().Author(header) // Ignore error, we're past header validation} else {beneficiary = *author}if header.BaseFee != nil {baseFee = new(big.Int).Set(header.BaseFee)}return vm.BlockContext{CanTransfer: CanTransfer,Transfer:    Transfer,GetHash:     GetHashFn(header, chain),Coinbase:    beneficiary,BlockNumber: new(big.Int).Set(header.Number),Time:        new(big.Int).SetUint64(header.Time),Difficulty:  new(big.Int).Set(header.Difficulty),BaseFee:     baseFee,GasLimit:    header.GasLimit,}
}

NewEVM

位于core/vm/evm.go
根据之前的上下文信息，以及其他的配置和内容建立虚拟机，同时调用NewEVMInterpreter函数建立对应解释器。

// NewEVM returns a new EVM. The returned EVM is not thread safe and should
// only ever be used *once*.
func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config) *EVM {evm := &EVM{Context:     blockCtx,TxContext:   txCtx,StateDB:     statedb,Config:      config,chainConfig: chainConfig,chainRules:  chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil),}evm.interpreter = NewEVMInterpreter(evm, config)return evm
}

NewEVMInterpreter

根据采取的不同链规则不同来建立对应EVM解释器

// NewEVMInterpreter returns a new instance of the Interpreter.
func NewEVMInterpreter(evm *EVM, cfg Config) *EVMInterpreter {// If jump table was not initialised we set the default one.if cfg.JumpTable == nil {switch {case evm.chainRules.IsLondon:cfg.JumpTable = &londonInstructionSetcase evm.chainRules.IsBerlin:cfg.JumpTable = &berlinInstructionSetcase evm.chainRules.IsIstanbul:cfg.JumpTable = &istanbulInstructionSetcase evm.chainRules.IsConstantinople:cfg.JumpTable = &constantinopleInstructionSetcase evm.chainRules.IsByzantium:cfg.JumpTable = &byzantiumInstructionSetcase evm.chainRules.IsEIP158:cfg.JumpTable = &spuriousDragonInstructionSetcase evm.chainRules.IsEIP150:cfg.JumpTable = &tangerineWhistleInstructionSetcase evm.chainRules.IsHomestead:cfg.JumpTable = &homesteadInstructionSetdefault:cfg.JumpTable = &frontierInstructionSet}for i, eip := range cfg.ExtraEips {copy := *cfg.JumpTableif err := EnableEIP(eip, &copy); err != nil {// Disable it, so caller can check if it's activated or notcfg.ExtraEips = append(cfg.ExtraEips[:i], cfg.ExtraEips[i+1:]...)log.Error("EIP activation failed", "eip", eip, "error", err)}cfg.JumpTable = &copy}}return &EVMInterpreter{evm: evm,cfg: cfg,}
}

AsMessage

位于core\types\transaction.go
将交易返回为消息格式

// AsMessage returns the transaction as a core.Message.
func (tx *Transaction) AsMessage(s Signer, baseFee *big.Int) (Message, error) {msg := Message{nonce:      tx.Nonce(),gasLimit:   tx.Gas(),gasPrice:   new(big.Int).Set(tx.GasPrice()),gasFeeCap:  new(big.Int).Set(tx.GasFeeCap()),gasTipCap:  new(big.Int).Set(tx.GasTipCap()),to:         tx.To(),amount:     tx.Value(),data:       tx.Data(),accessList: tx.AccessList(),isFake:     false,}// If baseFee provided, set gasPrice to effectiveGasPrice.if baseFee != nil {msg.gasPrice = math.BigMin(msg.gasPrice.Add(msg.gasTipCap, baseFee), msg.gasFeeCap)}var err errormsg.from, err = Sender(s, tx)return msg, err
}

Prepare

位于core\state\statedb.go
在EVM需要生成新的状态时调用此函数来设置当前交易的hash和序号

// Prepare sets the current transaction hash and index which are
// used when the EVM emits new state logs.
func (s *StateDB) Prepare(thash common.Hash, ti int) {s.thash = thashs.txIndex = tis.accessList = newAccessList()
}

Finalize

// Finalize implements consensus.Engine, accumulating the block and uncle rewards,
// setting the final state on the header
func (ethash *Ethash) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header) {// Accumulate any block and uncle rewards and commit the final state rootaccumulateRewards(chain.Config(), state, header, uncles)header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
}

位于consensus\ethash\consensus.go
该函数累积区块和叔块的奖励并设置在头部的最终状态中。