github.com/Aodurkeen/go-ubiq@v2.3.0+incompatible/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 "github.com/ubiq/go-ubiq/common" 21 "github.com/ubiq/go-ubiq/consensus" 22 "github.com/ubiq/go-ubiq/core/state" 23 "github.com/ubiq/go-ubiq/core/types" 24 "github.com/ubiq/go-ubiq/core/vm" 25 "github.com/ubiq/go-ubiq/crypto" 26 "github.com/ubiq/go-ubiq/params" 27 ) 28 29 // StateProcessor is a basic Processor, which takes care of transitioning 30 // state from one point to another. 31 // 32 // StateProcessor implements Processor. 33 type StateProcessor struct { 34 config *params.ChainConfig // Chain configuration options 35 bc *BlockChain // Canonical block chain 36 engine consensus.Engine // Consensus engine used for block rewards 37 } 38 39 // NewStateProcessor initialises a new StateProcessor. 40 func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consensus.Engine) *StateProcessor { 41 return &StateProcessor{ 42 config: config, 43 bc: bc, 44 engine: engine, 45 } 46 } 47 48 // Process processes the state changes according to the Ethereum rules by running 49 // the transaction messages using the statedb and applying any rewards to both 50 // the processor (coinbase) and any included uncles. 51 // 52 // Process returns the receipts and logs accumulated during the process and 53 // returns the amount of gas that was used in the process. If any of the 54 // transactions failed to execute due to insufficient gas it will return an error. 55 func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) { 56 var ( 57 receipts types.Receipts 58 usedGas = new(uint64) 59 header = block.Header() 60 allLogs []*types.Log 61 gp = new(GasPool).AddGas(block.GasLimit()) 62 ) 63 // Iterate over and process the individual transactions 64 for i, tx := range block.Transactions() { 65 statedb.Prepare(tx.Hash(), block.Hash(), i) 66 receipt, _, err := ApplyTransaction(p.config, p.bc, nil, gp, statedb, header, tx, usedGas, cfg) 67 if err != nil { 68 return nil, nil, 0, err 69 } 70 receipts = append(receipts, receipt) 71 allLogs = append(allLogs, receipt.Logs...) 72 } 73 // Finalize the block, applying any consensus engine specific extras (e.g. block rewards) 74 p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), receipts) 75 76 return receipts, allLogs, *usedGas, nil 77 } 78 79 // ApplyTransaction attempts to apply a transaction to the given state database 80 // and uses the input parameters for its environment. It returns the receipt 81 // for the transaction, gas used and an error if the transaction failed, 82 // indicating the block was invalid. 83 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) { 84 msg, err := tx.AsMessage(types.MakeSigner(config, header.Number)) 85 if err != nil { 86 return nil, 0, err 87 } 88 // Create a new context to be used in the EVM environment 89 context := NewEVMContext(msg, header, bc, author) 90 // Create a new environment which holds all relevant information 91 // about the transaction and calling mechanisms. 92 vmenv := vm.NewEVM(context, statedb, config, cfg) 93 // Apply the transaction to the current state (included in the env) 94 _, gas, failed, err := ApplyMessage(vmenv, msg, gp) 95 if err != nil { 96 return nil, 0, err 97 } 98 // Update the state with pending changes 99 var root []byte 100 if config.IsByzantium(header.Number) { 101 statedb.Finalise(true) 102 } else { 103 root = statedb.IntermediateRoot(config.IsEIP158(header.Number)).Bytes() 104 } 105 *usedGas += gas 106 107 // Create a new receipt for the transaction, storing the intermediate root and gas used by the tx 108 // based on the eip phase, we're passing whether the root touch-delete accounts. 109 receipt := types.NewReceipt(root, failed, *usedGas) 110 receipt.TxHash = tx.Hash() 111 receipt.GasUsed = gas 112 // if the transaction created a contract, store the creation address in the receipt. 113 if msg.To() == nil { 114 receipt.ContractAddress = crypto.CreateAddress(vmenv.Context.Origin, tx.Nonce()) 115 } 116 // Set the receipt logs and create a bloom for filtering 117 receipt.Logs = statedb.GetLogs(tx.Hash()) 118 receipt.Bloom = types.CreateBloom(types.Receipts{receipt}) 119 120 return receipt, gas, err 121 }