github.com/puppeth/go-ethereum@v0.8.6-0.20171014130046-e9295163aa25/core/state_processor.go (about) 1 // Copyright 2015 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package core 18 19 import ( 20 "math/big" 21 22 "github.com/ethereum/go-ethereum/common" 23 "github.com/ethereum/go-ethereum/consensus" 24 "github.com/ethereum/go-ethereum/consensus/misc" 25 "github.com/ethereum/go-ethereum/core/state" 26 "github.com/ethereum/go-ethereum/core/types" 27 "github.com/ethereum/go-ethereum/core/vm" 28 "github.com/ethereum/go-ethereum/crypto" 29 "github.com/ethereum/go-ethereum/params" 30 ) 31 32 // StateProcessor is a basic Processor, which takes care of transitioning 33 // state from one point to another. 34 // 35 // StateProcessor implements Processor. 36 type StateProcessor struct { 37 config *params.ChainConfig // Chain configuration options 38 bc *BlockChain // Canonical block chain 39 engine consensus.Engine // Consensus engine used for block rewards 40 } 41 42 // NewStateProcessor initialises a new StateProcessor. 43 func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consensus.Engine) *StateProcessor { 44 return &StateProcessor{ 45 config: config, 46 bc: bc, 47 engine: engine, 48 } 49 } 50 51 // Process processes the state changes according to the Ethereum rules by running 52 // the transaction messages using the statedb and applying any rewards to both 53 // the processor (coinbase) and any included uncles. 54 // 55 // Process returns the receipts and logs accumulated during the process and 56 // returns the amount of gas that was used in the process. If any of the 57 // transactions failed to execute due to insufficient gas it will return an error. 58 func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error) { 59 var ( 60 receipts types.Receipts 61 totalUsedGas = big.NewInt(0) 62 header = block.Header() 63 allLogs []*types.Log 64 gp = new(GasPool).AddGas(block.GasLimit()) 65 ) 66 // Mutate the the block and state according to any hard-fork specs 67 if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 { 68 misc.ApplyDAOHardFork(statedb) 69 } 70 // Iterate over and process the individual transactions 71 for i, tx := range block.Transactions() { 72 statedb.Prepare(tx.Hash(), block.Hash(), i) 73 receipt, _, err := ApplyTransaction(p.config, p.bc, nil, gp, statedb, header, tx, totalUsedGas, cfg) 74 if err != nil { 75 return nil, nil, nil, err 76 } 77 receipts = append(receipts, receipt) 78 allLogs = append(allLogs, receipt.Logs...) 79 } 80 // Finalize the block, applying any consensus engine specific extras (e.g. block rewards) 81 p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), receipts) 82 83 return receipts, allLogs, totalUsedGas, nil 84 } 85 86 // ApplyTransaction attempts to apply a transaction to the given state database 87 // and uses the input parameters for its environment. It returns the receipt 88 // for the transaction, gas used and an error if the transaction failed, 89 // indicating the block was invalid. 90 func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, cfg vm.Config) (*types.Receipt, *big.Int, error) { 91 msg, err := tx.AsMessage(types.MakeSigner(config, header.Number)) 92 if err != nil { 93 return nil, nil, err 94 } 95 // Create a new context to be used in the EVM environment 96 context := NewEVMContext(msg, header, bc, author) 97 // Create a new environment which holds all relevant information 98 // about the transaction and calling mechanisms. 99 vmenv := vm.NewEVM(context, statedb, config, cfg) 100 // Apply the transaction to the current state (included in the env) 101 _, gas, failed, err := ApplyMessage(vmenv, msg, gp) 102 if err != nil { 103 return nil, nil, err 104 } 105 106 // Update the state with pending changes 107 var root []byte 108 if config.IsByzantium(header.Number) { 109 statedb.Finalise(true) 110 } else { 111 root = statedb.IntermediateRoot(config.IsEIP158(header.Number)).Bytes() 112 } 113 usedGas.Add(usedGas, gas) 114 115 // Create a new receipt for the transaction, storing the intermediate root and gas used by the tx 116 // based on the eip phase, we're passing wether the root touch-delete accounts. 117 receipt := types.NewReceipt(root, failed, usedGas) 118 receipt.TxHash = tx.Hash() 119 receipt.GasUsed = new(big.Int).Set(gas) 120 // if the transaction created a contract, store the creation address in the receipt. 121 if msg.To() == nil { 122 receipt.ContractAddress = crypto.CreateAddress(vmenv.Context.Origin, tx.Nonce()) 123 } 124 125 // Set the receipt logs and create a bloom for filtering 126 receipt.Logs = statedb.GetLogs(tx.Hash()) 127 receipt.Bloom = types.CreateBloom(types.Receipts{receipt}) 128 129 return receipt, gas, err 130 }