github.com/nnlgsakib/mind-dpos@v0.0.0-20230606105614-f3c8ca06f808/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/TTCECO/gttc/common" 21 "github.com/TTCECO/gttc/consensus" 22 "github.com/TTCECO/gttc/core/state" 23 "github.com/TTCECO/gttc/core/types" 24 "github.com/TTCECO/gttc/core/vm" 25 "github.com/TTCECO/gttc/crypto" 26 "github.com/TTCECO/gttc/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 64 // Iterate over and process the individual transactions 65 for i, tx := range block.Transactions() { 66 statedb.Prepare(tx.Hash(), block.Hash(), i) 67 receipt, _, err := ApplyTransaction(p.config, p.bc, nil, gp, statedb, header, tx, usedGas, cfg) 68 if err != nil { 69 return nil, nil, 0, err 70 } 71 receipts = append(receipts, receipt) 72 allLogs = append(allLogs, receipt.Logs...) 73 } 74 // Finalize the block, applying any consensus engine specific extras (e.g. block rewards) 75 p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), receipts) 76 77 return receipts, allLogs, *usedGas, nil 78 } 79 80 // ApplyTransaction attempts to apply a transaction to the given state database 81 // and uses the input parameters for its environment. It returns the receipt 82 // for the transaction, gas used and an error if the transaction failed, 83 // indicating the block was invalid. 84 func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, uint64, error) { 85 msg, err := tx.AsMessage(types.MakeSigner(config, header.Number)) 86 if err != nil { 87 return nil, 0, err 88 } 89 // Create a new context to be used in the EVM environment 90 context := NewEVMContext(msg, header, bc, author) 91 // Create a new environment which holds all relevant information 92 // about the transaction and calling mechanisms. 93 vmenv := vm.NewEVM(context, statedb, config, cfg) 94 // Apply the transaction to the current state (included in the env) 95 _, gas, failed, err := ApplyMessage(vmenv, msg, gp) 96 if err != nil { 97 return nil, 0, err 98 } 99 // Update the state with pending changes 100 var root []byte 101 if config.IsByzantium(header.Number) { 102 statedb.Finalise(true) 103 } else { 104 root = statedb.IntermediateRoot(config.IsEIP158(header.Number)).Bytes() 105 } 106 *usedGas += gas 107 108 // Create a new receipt for the transaction, storing the intermediate root and gas used by the tx 109 // based on the eip phase, we're passing wether the root touch-delete accounts. 110 receipt := types.NewReceipt(root, failed, *usedGas) 111 receipt.TxHash = tx.Hash() 112 receipt.GasUsed = gas 113 // if the transaction created a contract, store the creation address in the receipt. 114 if msg.To() == nil { 115 receipt.ContractAddress = crypto.CreateAddress(vmenv.Context.Origin, tx.Nonce()) 116 } 117 // Set the receipt logs and create a bloom for filtering 118 receipt.Logs = statedb.GetLogs(tx.Hash()) 119 receipt.Bloom = types.CreateBloom(types.Receipts{receipt}) 120 121 return receipt, gas, err 122 }