2016-04-14 11:18:24 -05:00
|
|
|
// Copyright 2015 The go-ethereum Authors
|
|
|
|
// This file is part of the go-ethereum library.
|
|
|
|
//
|
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
2015-10-19 09:08:17 -05:00
|
|
|
package core
|
|
|
|
|
|
|
|
import (
|
2023-05-25 07:24:09 -05:00
|
|
|
"errors"
|
2020-12-04 05:22:19 -06:00
|
|
|
"fmt"
|
2021-06-30 08:17:01 -05:00
|
|
|
"math/big"
|
2020-12-04 05:22:19 -06:00
|
|
|
|
2017-04-12 08:38:31 -05:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2017-04-04 17:16:29 -05:00
|
|
|
"github.com/ethereum/go-ethereum/consensus"
|
|
|
|
"github.com/ethereum/go-ethereum/consensus/misc"
|
2015-10-19 09:08:17 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/state"
|
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
2016-10-20 06:36:29 -05:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2015-10-19 09:08:17 -05:00
|
|
|
)
|
|
|
|
|
2016-03-01 16:32:43 -06:00
|
|
|
// StateProcessor is a basic Processor, which takes care of transitioning
|
|
|
|
// state from one point to another.
|
|
|
|
//
|
|
|
|
// StateProcessor implements Processor.
|
2015-10-19 09:08:17 -05:00
|
|
|
type StateProcessor struct {
|
2017-04-04 17:16:29 -05:00
|
|
|
config *params.ChainConfig // Chain configuration options
|
|
|
|
bc *BlockChain // Canonical block chain
|
|
|
|
engine consensus.Engine // Consensus engine used for block rewards
|
2015-10-19 09:08:17 -05:00
|
|
|
}
|
|
|
|
|
2016-03-01 16:32:43 -06:00
|
|
|
// NewStateProcessor initialises a new StateProcessor.
|
2017-04-04 17:16:29 -05:00
|
|
|
func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consensus.Engine) *StateProcessor {
|
2016-03-01 16:32:43 -06:00
|
|
|
return &StateProcessor{
|
|
|
|
config: config,
|
|
|
|
bc: bc,
|
2017-04-04 17:16:29 -05:00
|
|
|
engine: engine,
|
2016-03-01 16:32:43 -06:00
|
|
|
}
|
2015-10-19 09:08:17 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Process processes the state changes according to the Ethereum rules by running
|
|
|
|
// the transaction messages using the statedb and applying any rewards to both
|
|
|
|
// the processor (coinbase) and any included uncles.
|
|
|
|
//
|
|
|
|
// Process returns the receipts and logs accumulated during the process and
|
|
|
|
// returns the amount of gas that was used in the process. If any of the
|
|
|
|
// transactions failed to execute due to insufficient gas it will return an error.
|
2017-11-13 05:47:27 -06:00
|
|
|
func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) {
|
2015-10-19 09:08:17 -05:00
|
|
|
var (
|
2021-06-30 08:17:01 -05:00
|
|
|
receipts types.Receipts
|
|
|
|
usedGas = new(uint64)
|
|
|
|
header = block.Header()
|
|
|
|
blockHash = block.Hash()
|
|
|
|
blockNumber = block.Number()
|
|
|
|
allLogs []*types.Log
|
|
|
|
gp = new(GasPool).AddGas(block.GasLimit())
|
2015-10-19 09:08:17 -05:00
|
|
|
)
|
2018-08-27 03:49:29 -05:00
|
|
|
// Mutate the block and state according to any hard-fork specs
|
2016-07-11 05:55:11 -05:00
|
|
|
if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
|
2017-04-04 17:16:29 -05:00
|
|
|
misc.ApplyDAOHardFork(statedb)
|
2016-07-11 05:55:11 -05:00
|
|
|
}
|
2023-04-21 04:52:02 -05:00
|
|
|
var (
|
|
|
|
context = NewEVMBlockContext(header, p.bc, nil)
|
|
|
|
vmenv = vm.NewEVM(context, vm.TxContext{}, statedb, p.config, cfg)
|
|
|
|
signer = types.MakeSigner(p.config, header.Number, header.Time)
|
|
|
|
)
|
2023-08-22 07:33:39 -05:00
|
|
|
if beaconRoot := block.BeaconRoot(); beaconRoot != nil {
|
|
|
|
ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb)
|
|
|
|
}
|
2016-07-11 05:55:11 -05:00
|
|
|
// Iterate over and process the individual transactions
|
2015-10-19 09:08:17 -05:00
|
|
|
for i, tx := range block.Transactions() {
|
2023-04-21 04:52:02 -05:00
|
|
|
msg, err := TransactionToMessage(tx, signer, header.BaseFee)
|
2020-11-13 06:42:19 -06:00
|
|
|
if err != nil {
|
2021-05-17 08:13:22 -05:00
|
|
|
return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)
|
2020-11-13 06:42:19 -06:00
|
|
|
}
|
2022-11-16 03:18:52 -06:00
|
|
|
statedb.SetTxContext(tx.Hash(), i)
|
2022-12-13 06:54:16 -06:00
|
|
|
receipt, err := applyTransaction(msg, p.config, gp, statedb, blockNumber, blockHash, tx, usedGas, vmenv)
|
2015-10-19 09:08:17 -05:00
|
|
|
if err != nil {
|
2020-12-04 05:22:19 -06:00
|
|
|
return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)
|
2015-10-19 09:08:17 -05:00
|
|
|
}
|
|
|
|
receipts = append(receipts, receipt)
|
2017-01-05 04:52:10 -06:00
|
|
|
allLogs = append(allLogs, receipt.Logs...)
|
2015-10-19 09:08:17 -05:00
|
|
|
}
|
2023-01-25 08:32:25 -06:00
|
|
|
// Fail if Shanghai not enabled and len(withdrawals) is non-zero.
|
|
|
|
withdrawals := block.Withdrawals()
|
2023-05-19 03:27:19 -05:00
|
|
|
if len(withdrawals) > 0 && !p.config.IsShanghai(block.Number(), block.Time()) {
|
2023-05-25 07:24:09 -05:00
|
|
|
return nil, nil, 0, errors.New("withdrawals before shanghai")
|
2023-01-25 08:32:25 -06:00
|
|
|
}
|
2017-04-04 17:16:29 -05:00
|
|
|
// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
|
2023-01-25 08:32:25 -06:00
|
|
|
p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), withdrawals)
|
2015-10-19 09:08:17 -05:00
|
|
|
|
2017-11-13 05:47:27 -06:00
|
|
|
return receipts, allLogs, *usedGas, nil
|
2015-10-19 09:08:17 -05:00
|
|
|
}
|
|
|
|
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
func applyTransaction(msg *Message, config *params.ChainConfig, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM) (*types.Receipt, error) {
|
2021-02-25 08:26:57 -06:00
|
|
|
// Create a new context to be used in the EVM environment.
|
2020-11-13 06:42:19 -06:00
|
|
|
txContext := NewEVMTxContext(msg)
|
|
|
|
evm.Reset(txContext, statedb)
|
2021-02-25 08:26:57 -06:00
|
|
|
|
|
|
|
// Apply the transaction to the current state (included in the env).
|
2020-11-13 06:42:19 -06:00
|
|
|
result, err := ApplyMessage(evm, msg, gp)
|
2015-10-19 09:08:17 -05:00
|
|
|
if err != nil {
|
2019-09-12 14:22:22 -05:00
|
|
|
return nil, err
|
2015-10-19 09:08:17 -05:00
|
|
|
}
|
2021-02-25 08:26:57 -06:00
|
|
|
|
|
|
|
// Update the state with pending changes.
|
2017-07-17 03:34:53 -05:00
|
|
|
var root []byte
|
2021-06-30 08:17:01 -05:00
|
|
|
if config.IsByzantium(blockNumber) {
|
2017-08-24 05:42:00 -05:00
|
|
|
statedb.Finalise(true)
|
2017-07-17 03:34:53 -05:00
|
|
|
} else {
|
2021-06-30 08:17:01 -05:00
|
|
|
root = statedb.IntermediateRoot(config.IsEIP158(blockNumber)).Bytes()
|
2017-07-17 03:34:53 -05:00
|
|
|
}
|
2020-04-22 03:25:36 -05:00
|
|
|
*usedGas += result.UsedGas
|
2017-07-17 03:34:53 -05:00
|
|
|
|
2021-02-25 08:26:57 -06:00
|
|
|
// Create a new receipt for the transaction, storing the intermediate root and gas used
|
|
|
|
// by the tx.
|
|
|
|
receipt := &types.Receipt{Type: tx.Type(), PostState: root, CumulativeGasUsed: *usedGas}
|
|
|
|
if result.Failed() {
|
|
|
|
receipt.Status = types.ReceiptStatusFailed
|
|
|
|
} else {
|
|
|
|
receipt.Status = types.ReceiptStatusSuccessful
|
|
|
|
}
|
2015-10-19 09:08:17 -05:00
|
|
|
receipt.TxHash = tx.Hash()
|
2020-04-22 03:25:36 -05:00
|
|
|
receipt.GasUsed = result.UsedGas
|
2021-02-25 08:26:57 -06:00
|
|
|
|
2023-08-25 21:52:12 -05:00
|
|
|
receipt.BlobGasUsed = uint64(len(tx.BlobHashes()) * params.BlobTxBlobGasPerBlob)
|
|
|
|
receipt.BlobGasPrice = tx.BlobGasFeeCap()
|
|
|
|
|
2021-02-25 08:26:57 -06:00
|
|
|
// If the transaction created a contract, store the creation address in the receipt.
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if msg.To == nil {
|
2020-11-13 06:42:19 -06:00
|
|
|
receipt.ContractAddress = crypto.CreateAddress(evm.TxContext.Origin, tx.Nonce())
|
2015-10-19 09:08:17 -05:00
|
|
|
}
|
2021-02-25 08:26:57 -06:00
|
|
|
|
|
|
|
// Set the receipt logs and create the bloom filter.
|
2022-12-13 06:54:16 -06:00
|
|
|
receipt.Logs = statedb.GetLogs(tx.Hash(), blockNumber.Uint64(), blockHash)
|
2015-10-19 09:08:17 -05:00
|
|
|
receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
|
2021-06-30 08:17:01 -05:00
|
|
|
receipt.BlockHash = blockHash
|
|
|
|
receipt.BlockNumber = blockNumber
|
2019-03-27 07:39:25 -05:00
|
|
|
receipt.TransactionIndex = uint(statedb.TxIndex())
|
2019-09-12 14:22:22 -05:00
|
|
|
return receipt, err
|
2015-10-19 09:08:17 -05:00
|
|
|
}
|
2020-11-13 06:42:19 -06:00
|
|
|
|
|
|
|
// ApplyTransaction attempts to apply a transaction to the given state database
|
|
|
|
// and uses the input parameters for its environment. It returns the receipt
|
|
|
|
// for the transaction, gas used and an error if the transaction failed,
|
|
|
|
// indicating the block was invalid.
|
|
|
|
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, error) {
|
2023-04-21 04:52:02 -05:00
|
|
|
msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number, header.Time), header.BaseFee)
|
2020-11-13 06:42:19 -06:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
// Create a new context to be used in the EVM environment
|
|
|
|
blockContext := NewEVMBlockContext(header, bc, author)
|
2023-07-15 16:27:36 -05:00
|
|
|
vmenv := vm.NewEVM(blockContext, vm.TxContext{BlobHashes: tx.BlobHashes()}, statedb, config, cfg)
|
2022-12-13 06:54:16 -06:00
|
|
|
return applyTransaction(msg, config, gp, statedb, header.Number, header.Hash(), tx, usedGas, vmenv)
|
2020-11-13 06:42:19 -06:00
|
|
|
}
|
2023-08-22 07:33:39 -05:00
|
|
|
|
|
|
|
// ProcessBeaconBlockRoot applies the EIP-4788 system call to the beacon block root
|
|
|
|
// contract. This method is exported to be used in tests.
|
|
|
|
func ProcessBeaconBlockRoot(beaconRoot common.Hash, vmenv *vm.EVM, statedb *state.StateDB) {
|
|
|
|
// If EIP-4788 is enabled, we need to invoke the beaconroot storage contract with
|
|
|
|
// the new root
|
|
|
|
msg := &Message{
|
|
|
|
From: params.SystemAddress,
|
|
|
|
GasLimit: 30_000_000,
|
|
|
|
GasPrice: common.Big0,
|
|
|
|
GasFeeCap: common.Big0,
|
|
|
|
GasTipCap: common.Big0,
|
|
|
|
To: ¶ms.BeaconRootsStorageAddress,
|
|
|
|
Data: beaconRoot[:],
|
|
|
|
}
|
|
|
|
vmenv.Reset(NewEVMTxContext(msg), statedb)
|
|
|
|
statedb.AddAddressToAccessList(params.BeaconRootsStorageAddress)
|
|
|
|
_, _, _ = vmenv.Call(vm.AccountRef(msg.From), *msg.To, msg.Data, 30_000_000, common.Big0)
|
|
|
|
statedb.Finalise(true)
|
|
|
|
}
|