evm源码分析第一篇

func (w *worker) (tx *types.Transaction, coinbase common.Address) ([]*types.Log, error) {
   snap := w.current.state.Snapshot()

   receipt, _, err := core.ApplyTransaction(w.config, w.chain, &coinbase, w.current.gasPool, w.current.state, w.current.header, tx, &w.current.header.GasUsed, *w.chain.GetVMConfig())
   if err != nil {
      w.current.state.RevertToSnapshot(snap)
      return nil, err
   }
   w.current.txs = append(w.current.txs, tx)
   w.current.receipts = append(w.current.receipts, receipt)

   return receipt.Logs, nil
}

func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, uint64, error) {
   msg, err := tx.AsMessage(types.MakeSigner(config, header.Number))
   if err != nil {
      return nil, 0, err
   }
   // 创建一个新的evm执行上下文环境
   context := NewEVMContext(msg, header, bc, author)
   // 创建一个包含所有相关信息的新环境， 包括事务和调用机制
   vmenv := vm.NewEVM(context, statedb, config, cfg)
   // 将事务应用于当前状态(包含在env中)
   _, gas, failed, err := ApplyMessage(vmenv, msg, gp)
   if err != nil {
      return nil, 0, err
   }
   // Update the state with pending changes
   var root []byte
   if config.IsByzantium(header.Number) {
      statedb.Finalise(true)
   } else {
      root = statedb.IntermediateRoot(config.IsEIP158(header.Number)).Bytes()
   }
   *usedGas += gas

   //创建一个新的收据为这笔交易，存储中间状态根和gas使用情况
   // based on the eip phase, we're passing whether the root touch-delete accounts.
   receipt := types.NewReceipt(root, failed, *usedGas)
   receipt.TxHash = tx.Hash()
   receipt.GasUsed = gas
   //如果这笔交易是创建一个合约， 存储合约地址在收据里面
   if msg.To() == nil {
      receipt.ContractAddress = crypto.CreateAddress(vmenv.Context.Origin, tx.Nonce())
   }
   // 设置收据日志和创建布隆过滤器
   receipt.Logs = statedb.GetLogs(tx.Hash())
   receipt.Bloom = types.CreateBloom(types.Receipts{receipt})

   return receipt, gas, err
}

func (tx *Transaction) AsMessage(s Signer) (Message, error) {
   msg := Message{
      nonce:      tx.data.AccountNonce,
      gasLimit:   tx.data.GasLimit,
      gasPrice:   new(big.Int).Set(tx.data.Price),
      to:         tx.data.Recipient,
      amount:     tx.data.Amount,
      data:       tx.data.Payload,
      checkNonce: true,
   }

   var err error
   msg.from, err = Sender(s, tx)
   return msg, err
}

// NewEVMContext creates a new context for use in the EVM.
func NewEVMContext(msg Message, header *types.Header, chain ChainContext, author *common.Address) vm.Context {
   //如果不能得到一个明确的author,那就从区块头里面解析author
   var beneficiary common.Address
   //如果函数参数里面的author为nil,则从区块头里面解析author， 这里不叫coinbase 主要是为了区别ehthash与clique引擎
    if author == nil {
      beneficiary, _ = chain.Engine().Author(header) // Ignore error, we're past header validation
   } else {
      beneficiary = *author
   }
   return vm.Context{
      CanTransfer: CanTransfer,
      Transfer:    Transfer,
      GetHash:     GetHashFn(header, chain),
      Origin:      msg.From(),
      Coinbase:    beneficiary,
      BlockNumber: new(big.Int).Set(header.Number),
      Time:        new(big.Int).Set(header.Time),
      Difficulty:  new(big.Int).Set(header.Difficulty),
      GasLimit:    header.GasLimit,
      GasPrice:    new(big.Int).Set(msg.GasPrice()),
   }
}

func NewEVM(ctx Context, statedb StateDB, chainConfig *params.ChainConfig, vmConfig Config) *EVM {
   evm := &EVM{
      Context:      ctx,
      StateDB:      statedb,
      vmConfig:     vmConfig,
      chainConfig:  chainConfig,
      chainRules:   chainConfig.Rules(ctx.BlockNumber),
      interpreters: make([]Interpreter, 0, 1),
   }

   if chainConfig.IsEWASM(ctx.BlockNumber) {
      // to be implemented by EVM-C and Wagon PRs.
      // if vmConfig.EWASMInterpreter != "" {
      //  extIntOpts := strings.Split(vmConfig.EWASMInterpreter, ":")
      //  path := extIntOpts[0]
      //  options := []string{}
      //  if len(extIntOpts) > 1 {
      //    options = extIntOpts[1..]
      //  }
      //  evm.interpreters = append(evm.interpreters, NewEVMVCInterpreter(evm, vmConfig, options))
      // } else {
      //     evm.interpreters = append(evm.interpreters, NewEWASMInterpreter(evm, vmConfig))
      // }
      panic("No supported ewasm interpreter yet.")
   }

   //vmConfig.EVMInterpreter 将会被使用在EVM-C， 这里不会使用。
   //因为我们希望内置的EVM作为出错转移的备用选项 
   evm.interpreters = append(evm.interpreters, NewEVMInterpreter(evm, vmConfig))
   evm.interpreter = evm.interpreters[0]

   return evm
}

// ApplyMessage 通过给定的message计算新的DB状态，继而改变旧的DB状态
// ApplyMessage 返回EVM执行的返回结果和gas使用情况（包括gas refunds）和error(如果有错误出现)。
// 如果一个错误总是作为一个core error 出现，那么这个message将永远不会被这个区块所接受。
func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) ([]byte, uint64, bool, error) {
   return NewStateTransition(evm, msg, gp).TransitionDb()
}

// TransitionDB 函数通过 apply message 将会改变state 并且返回 包含gas使用情况的结果。
// 如果执行失败，将会返回一个error, 这个error代表一个共识错误。
func (st *StateTransition) TransitionDb() (ret []byte, usedGas uint64, failed bool, err error) {
    //进行最初的检查，

   if err = st.preCheck(); err != nil {
      return
   }
   msg := st.msg
   sender := vm.AccountRef(msg.From())
   homestead := st.evm.ChainConfig().IsHomestead(st.evm.BlockNumber)
   contractCreation := msg.To() == nil

   // Pay intrinsic gas
   gas, err := IntrinsicGas(st.data, contractCreation, homestead)
   if err != nil {
      return nil, 0, false, err
   }
   if err = st.useGas(gas); err != nil {
      return nil, 0, false, err
   }

   var (
      evm = st.evm
      // vm errors do not effect consensus and are therefor
      // not assigned to err, except for insufficient balance
      // error.
      vmerr error
   )
   if contractCreation {
      ret, _, st.gas, vmerr = evm.Create(sender, st.data, st.gas, st.value)
   } else {
      // Increment the nonce for the next transaction
      st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)
      ret, st.gas, vmerr = evm.Call(sender, st.to(), st.data, st.gas, st.value)
   }
   if vmerr != nil {
      log.Debug("VM returned with error", "err", vmerr)
      // The only possible consensus-error would be if there wasn't
      // sufficient balance to make the transfer happen. The first
      // balance transfer may never fail.
      if vmerr == vm.ErrInsufficientBalance {
         return nil, 0, false, vmerr
      }
   }
   st.refundGas()
   st.state.AddBalance(st.evm.Coinbase, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.gasPrice))

   return ret, st.gasUsed(), vmerr != nil, err
}

//IntrinsicGas 计算给定数据的固定gas消耗
func IntrinsicGas(data []byte, contractCreation, homestead bool) (uint64, error) {
   // Set the starting gas for the raw transaction
   var gas uint64
   if contractCreation && homestead {
      gas = params.TxGasContractCreation
   } else {
      gas = params.TxGas
   }
   // 通过事务数据量增加所需的气体
   if len(data) > 0 {
      // 零字节和非零字节的定价不同
      var nz uint64
      //获取非零字节的个数
      for _, byt := range data {
         if byt != 0 {
            nz++
         }
      }
      // 防止所需gas超过最大限制
      if (math.MaxUint64-gas)/params.TxDataNonZeroGas < nz {
         return 0, vm.ErrOutOfGas
      }
      //计算非0字节的gas消耗
      gas += nz * params.TxDataNonZeroGas

      z := uint64(len(data)) - nz
      if (math.MaxUint64-gas)/params.TxDataZeroGas < z {
         return 0, vm.ErrOutOfGas
      }
      gas += z * params.TxDataZeroGas
   }
   return gas, nil
}

// Create creates a new contract using code as deployment code.
func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {
   contractAddr = crypto.CreateAddress(caller.Address(), evm.StateDB.GetNonce(caller.Address()))
   return evm.create(caller, &codeAndHash{code: code}, gas, value, contractAddr)
}