2020-06-30 03:12:51 -05:00
|
|
|
// Copyright 2020 The go-ethereum Authors
|
2022-05-24 13:39:40 -05:00
|
|
|
// This file is part of go-ethereum.
|
2020-06-30 03:12:51 -05:00
|
|
|
//
|
2022-05-24 13:39:40 -05:00
|
|
|
// go-ethereum is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU General Public License as published by
|
2020-06-30 03:12:51 -05:00
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
2022-05-24 13:39:40 -05:00
|
|
|
// go-ethereum is distributed in the hope that it will be useful,
|
2020-06-30 03:12:51 -05:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2022-05-24 13:39:40 -05:00
|
|
|
// GNU General Public License for more details.
|
2020-06-30 03:12:51 -05:00
|
|
|
//
|
2022-05-24 13:39:40 -05:00
|
|
|
// You should have received a copy of the GNU General Public License
|
|
|
|
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
2020-06-30 03:12:51 -05:00
|
|
|
|
|
|
|
package t8ntool
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
"github.com/ethereum/go-ethereum/common/math"
|
2021-08-25 08:04:26 -05:00
|
|
|
"github.com/ethereum/go-ethereum/consensus/ethash"
|
2020-06-30 03:12:51 -05:00
|
|
|
"github.com/ethereum/go-ethereum/consensus/misc"
|
2023-08-01 06:58:26 -05:00
|
|
|
"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
|
2020-06-30 03:12:51 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
|
|
|
"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"
|
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
|
|
"github.com/ethereum/go-ethereum/log"
|
|
|
|
"github.com/ethereum/go-ethereum/params"
|
|
|
|
"github.com/ethereum/go-ethereum/rlp"
|
2020-08-21 07:10:40 -05:00
|
|
|
"github.com/ethereum/go-ethereum/trie"
|
2020-06-30 03:12:51 -05:00
|
|
|
"golang.org/x/crypto/sha3"
|
|
|
|
)
|
|
|
|
|
|
|
|
type Prestate struct {
|
|
|
|
Env stEnv `json:"env"`
|
|
|
|
Pre core.GenesisAlloc `json:"pre"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// ExecutionResult contains the execution status after running a state test, any
|
|
|
|
// error that might have occurred and a dump of the final state if requested.
|
|
|
|
type ExecutionResult struct {
|
2023-08-01 06:58:26 -05:00
|
|
|
StateRoot common.Hash `json:"stateRoot"`
|
|
|
|
TxRoot common.Hash `json:"txRoot"`
|
|
|
|
ReceiptRoot common.Hash `json:"receiptsRoot"`
|
|
|
|
LogsHash common.Hash `json:"logsHash"`
|
|
|
|
Bloom types.Bloom `json:"logsBloom" gencodec:"required"`
|
|
|
|
Receipts types.Receipts `json:"receipts"`
|
|
|
|
Rejected []*rejectedTx `json:"rejected,omitempty"`
|
|
|
|
Difficulty *math.HexOrDecimal256 `json:"currentDifficulty" gencodec:"required"`
|
|
|
|
GasUsed math.HexOrDecimal64 `json:"gasUsed"`
|
|
|
|
BaseFee *math.HexOrDecimal256 `json:"currentBaseFee,omitempty"`
|
|
|
|
WithdrawalsRoot *common.Hash `json:"withdrawalsRoot,omitempty"`
|
|
|
|
CurrentExcessBlobGas *math.HexOrDecimal64 `json:"currentExcessBlobGas,omitempty"`
|
|
|
|
CurrentBlobGasUsed *math.HexOrDecimal64 `json:"currentBlobGasUsed,omitempty"`
|
2020-06-30 03:12:51 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
type ommer struct {
|
|
|
|
Delta uint64 `json:"delta"`
|
|
|
|
Address common.Address `json:"address"`
|
|
|
|
}
|
|
|
|
|
2022-04-12 13:24:02 -05:00
|
|
|
//go:generate go run github.com/fjl/gencodec -type stEnv -field-override stEnvMarshaling -out gen_stenv.go
|
2020-06-30 03:12:51 -05:00
|
|
|
type stEnv struct {
|
2023-08-22 07:33:39 -05:00
|
|
|
Coinbase common.Address `json:"currentCoinbase" gencodec:"required"`
|
|
|
|
Difficulty *big.Int `json:"currentDifficulty"`
|
|
|
|
Random *big.Int `json:"currentRandom"`
|
|
|
|
ParentDifficulty *big.Int `json:"parentDifficulty"`
|
|
|
|
ParentBaseFee *big.Int `json:"parentBaseFee,omitempty"`
|
|
|
|
ParentGasUsed uint64 `json:"parentGasUsed,omitempty"`
|
|
|
|
ParentGasLimit uint64 `json:"parentGasLimit,omitempty"`
|
|
|
|
GasLimit uint64 `json:"currentGasLimit" gencodec:"required"`
|
|
|
|
Number uint64 `json:"currentNumber" gencodec:"required"`
|
|
|
|
Timestamp uint64 `json:"currentTimestamp" gencodec:"required"`
|
|
|
|
ParentTimestamp uint64 `json:"parentTimestamp,omitempty"`
|
|
|
|
BlockHashes map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
|
|
|
|
Ommers []ommer `json:"ommers,omitempty"`
|
|
|
|
Withdrawals []*types.Withdrawal `json:"withdrawals,omitempty"`
|
|
|
|
BaseFee *big.Int `json:"currentBaseFee,omitempty"`
|
|
|
|
ParentUncleHash common.Hash `json:"parentUncleHash"`
|
|
|
|
ExcessBlobGas *uint64 `json:"excessBlobGas,omitempty"`
|
|
|
|
ParentExcessBlobGas *uint64 `json:"parentExcessBlobGas,omitempty"`
|
|
|
|
ParentBlobGasUsed *uint64 `json:"parentBlobGasUsed,omitempty"`
|
|
|
|
ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot"`
|
2020-06-30 03:12:51 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
type stEnvMarshaling struct {
|
2023-08-01 06:58:26 -05:00
|
|
|
Coinbase common.UnprefixedAddress
|
|
|
|
Difficulty *math.HexOrDecimal256
|
|
|
|
Random *math.HexOrDecimal256
|
|
|
|
ParentDifficulty *math.HexOrDecimal256
|
|
|
|
ParentBaseFee *math.HexOrDecimal256
|
|
|
|
ParentGasUsed math.HexOrDecimal64
|
|
|
|
ParentGasLimit math.HexOrDecimal64
|
|
|
|
GasLimit math.HexOrDecimal64
|
|
|
|
Number math.HexOrDecimal64
|
|
|
|
Timestamp math.HexOrDecimal64
|
|
|
|
ParentTimestamp math.HexOrDecimal64
|
|
|
|
BaseFee *math.HexOrDecimal256
|
|
|
|
ExcessBlobGas *math.HexOrDecimal64
|
|
|
|
ParentExcessBlobGas *math.HexOrDecimal64
|
|
|
|
ParentBlobGasUsed *math.HexOrDecimal64
|
2020-06-30 03:12:51 -05:00
|
|
|
}
|
|
|
|
|
2021-06-07 07:37:56 -05:00
|
|
|
type rejectedTx struct {
|
|
|
|
Index int `json:"index"`
|
|
|
|
Err string `json:"error"`
|
|
|
|
}
|
|
|
|
|
2020-06-30 03:12:51 -05:00
|
|
|
// Apply applies a set of transactions to a pre-state
|
|
|
|
func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
|
|
|
|
txs types.Transactions, miningReward int64,
|
2021-11-05 05:48:21 -05:00
|
|
|
getTracerFn func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error)) (*state.StateDB, *ExecutionResult, error) {
|
2020-06-30 03:12:51 -05:00
|
|
|
// Capture errors for BLOCKHASH operation, if we haven't been supplied the
|
|
|
|
// required blockhashes
|
|
|
|
var hashError error
|
|
|
|
getHash := func(num uint64) common.Hash {
|
|
|
|
if pre.Env.BlockHashes == nil {
|
|
|
|
hashError = fmt.Errorf("getHash(%d) invoked, no blockhashes provided", num)
|
|
|
|
return common.Hash{}
|
|
|
|
}
|
|
|
|
h, ok := pre.Env.BlockHashes[math.HexOrDecimal64(num)]
|
|
|
|
if !ok {
|
|
|
|
hashError = fmt.Errorf("getHash(%d) invoked, blockhash for that block not provided", num)
|
|
|
|
}
|
|
|
|
return h
|
|
|
|
}
|
|
|
|
var (
|
|
|
|
statedb = MakePreState(rawdb.NewMemoryDatabase(), pre.Pre)
|
2023-04-21 04:52:02 -05:00
|
|
|
signer = types.MakeSigner(chainConfig, new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp)
|
2020-06-30 03:12:51 -05:00
|
|
|
gaspool = new(core.GasPool)
|
|
|
|
blockHash = common.Hash{0x13, 0x37}
|
2021-06-07 07:37:56 -05:00
|
|
|
rejectedTxs []*rejectedTx
|
2020-06-30 03:12:51 -05:00
|
|
|
includedTxs types.Transactions
|
|
|
|
gasUsed = uint64(0)
|
|
|
|
receipts = make(types.Receipts, 0)
|
|
|
|
txIndex = 0
|
|
|
|
)
|
|
|
|
gaspool.AddGas(pre.Env.GasLimit)
|
2020-11-13 06:42:19 -06:00
|
|
|
vmContext := vm.BlockContext{
|
2020-06-30 03:12:51 -05:00
|
|
|
CanTransfer: core.CanTransfer,
|
|
|
|
Transfer: core.Transfer,
|
|
|
|
Coinbase: pre.Env.Coinbase,
|
|
|
|
BlockNumber: new(big.Int).SetUint64(pre.Env.Number),
|
2023-01-25 05:12:28 -06:00
|
|
|
Time: pre.Env.Timestamp,
|
2020-06-30 03:12:51 -05:00
|
|
|
Difficulty: pre.Env.Difficulty,
|
|
|
|
GasLimit: pre.Env.GasLimit,
|
|
|
|
GetHash: getHash,
|
|
|
|
}
|
2021-05-17 08:13:22 -05:00
|
|
|
// If currentBaseFee is defined, add it to the vmContext.
|
|
|
|
if pre.Env.BaseFee != nil {
|
|
|
|
vmContext.BaseFee = new(big.Int).Set(pre.Env.BaseFee)
|
|
|
|
}
|
2022-01-10 01:44:21 -06:00
|
|
|
// If random is defined, add it to the vmContext.
|
|
|
|
if pre.Env.Random != nil {
|
|
|
|
rnd := common.BigToHash(pre.Env.Random)
|
|
|
|
vmContext.Random = &rnd
|
|
|
|
}
|
2023-10-02 04:49:29 -05:00
|
|
|
// Calculate the BlobBaseFee
|
|
|
|
var excessBlobGas uint64
|
2023-08-01 06:58:26 -05:00
|
|
|
if pre.Env.ExcessBlobGas != nil {
|
2023-10-02 04:49:29 -05:00
|
|
|
excessBlobGas := *pre.Env.ExcessBlobGas
|
|
|
|
vmContext.BlobBaseFee = eip4844.CalcBlobFee(excessBlobGas)
|
2023-08-01 06:58:26 -05:00
|
|
|
} else {
|
|
|
|
// If it is not explicitly defined, but we have the parent values, we try
|
|
|
|
// to calculate it ourselves.
|
|
|
|
parentExcessBlobGas := pre.Env.ParentExcessBlobGas
|
|
|
|
parentBlobGasUsed := pre.Env.ParentBlobGasUsed
|
|
|
|
if parentExcessBlobGas != nil && parentBlobGasUsed != nil {
|
2023-10-02 04:49:29 -05:00
|
|
|
excessBlobGas = eip4844.CalcExcessBlobGas(*parentExcessBlobGas, *parentBlobGasUsed)
|
|
|
|
vmContext.BlobBaseFee = eip4844.CalcBlobFee(excessBlobGas)
|
2023-08-01 06:58:26 -05:00
|
|
|
}
|
|
|
|
}
|
2020-06-30 03:12:51 -05:00
|
|
|
// If DAO is supported/enabled, we need to handle it here. In geth 'proper', it's
|
|
|
|
// done in StateProcessor.Process(block, ...), right before transactions are applied.
|
|
|
|
if chainConfig.DAOForkSupport &&
|
|
|
|
chainConfig.DAOForkBlock != nil &&
|
|
|
|
chainConfig.DAOForkBlock.Cmp(new(big.Int).SetUint64(pre.Env.Number)) == 0 {
|
|
|
|
misc.ApplyDAOHardFork(statedb)
|
|
|
|
}
|
2023-08-22 07:33:39 -05:00
|
|
|
if beaconRoot := pre.Env.ParentBeaconBlockRoot; beaconRoot != nil {
|
|
|
|
evm := vm.NewEVM(vmContext, vm.TxContext{}, statedb, chainConfig, vmConfig)
|
|
|
|
core.ProcessBeaconBlockRoot(*beaconRoot, evm, statedb)
|
|
|
|
}
|
2023-08-01 06:58:26 -05:00
|
|
|
var blobGasUsed uint64
|
2020-06-30 03:12:51 -05:00
|
|
|
for i, tx := range txs {
|
2023-10-02 04:49:29 -05:00
|
|
|
if tx.Type() == types.BlobTxType && vmContext.BlobBaseFee == nil {
|
2023-08-01 06:58:26 -05:00
|
|
|
errMsg := "blob tx used but field env.ExcessBlobGas missing"
|
|
|
|
log.Warn("rejected tx", "index", i, "hash", tx.Hash(), "error", errMsg)
|
|
|
|
rejectedTxs = append(rejectedTxs, &rejectedTx{i, errMsg})
|
|
|
|
continue
|
|
|
|
}
|
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
|
|
|
msg, err := core.TransactionToMessage(tx, signer, pre.Env.BaseFee)
|
2020-06-30 03:12:51 -05:00
|
|
|
if err != nil {
|
2021-06-07 07:37:56 -05:00
|
|
|
log.Warn("rejected tx", "index", i, "hash", tx.Hash(), "error", err)
|
|
|
|
rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()})
|
2020-06-30 03:12:51 -05:00
|
|
|
continue
|
|
|
|
}
|
2020-08-19 04:31:13 -05:00
|
|
|
tracer, err := getTracerFn(txIndex, tx.Hash())
|
2020-06-30 03:12:51 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
vmConfig.Tracer = tracer
|
2022-11-16 03:18:52 -06:00
|
|
|
statedb.SetTxContext(tx.Hash(), txIndex)
|
2023-03-07 04:23:52 -06:00
|
|
|
|
|
|
|
var (
|
|
|
|
txContext = core.NewEVMTxContext(msg)
|
|
|
|
snapshot = statedb.Snapshot()
|
|
|
|
prevGas = gaspool.Gas()
|
|
|
|
)
|
2021-02-25 08:26:57 -06:00
|
|
|
evm := vm.NewEVM(vmContext, txContext, statedb, chainConfig, vmConfig)
|
|
|
|
|
2020-06-30 03:12:51 -05:00
|
|
|
// (ret []byte, usedGas uint64, failed bool, err error)
|
|
|
|
msgResult, err := core.ApplyMessage(evm, msg, gaspool)
|
|
|
|
if err != nil {
|
|
|
|
statedb.RevertToSnapshot(snapshot)
|
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
|
|
|
log.Info("rejected tx", "index", i, "hash", tx.Hash(), "from", msg.From, "error", err)
|
2021-06-07 07:37:56 -05:00
|
|
|
rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()})
|
2023-03-07 04:23:52 -06:00
|
|
|
gaspool.SetGas(prevGas)
|
2020-06-30 03:12:51 -05:00
|
|
|
continue
|
|
|
|
}
|
2023-08-01 06:58:26 -05:00
|
|
|
if tx.Type() == types.BlobTxType {
|
|
|
|
blobGasUsed += params.BlobTxBlobGasPerBlob
|
|
|
|
}
|
2020-06-30 03:12:51 -05:00
|
|
|
includedTxs = append(includedTxs, tx)
|
|
|
|
if hashError != nil {
|
|
|
|
return nil, nil, NewError(ErrorMissingBlockhash, hashError)
|
|
|
|
}
|
|
|
|
gasUsed += msgResult.UsedGas
|
2021-02-25 08:26:57 -06:00
|
|
|
|
|
|
|
// Receipt:
|
2020-06-30 03:12:51 -05:00
|
|
|
{
|
|
|
|
var root []byte
|
|
|
|
if chainConfig.IsByzantium(vmContext.BlockNumber) {
|
|
|
|
statedb.Finalise(true)
|
|
|
|
} else {
|
|
|
|
root = statedb.IntermediateRoot(chainConfig.IsEIP158(vmContext.BlockNumber)).Bytes()
|
|
|
|
}
|
|
|
|
|
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: gasUsed}
|
|
|
|
if msgResult.Failed() {
|
|
|
|
receipt.Status = types.ReceiptStatusFailed
|
|
|
|
} else {
|
|
|
|
receipt.Status = types.ReceiptStatusSuccessful
|
|
|
|
}
|
2020-06-30 03:12:51 -05:00
|
|
|
receipt.TxHash = tx.Hash()
|
|
|
|
receipt.GasUsed = msgResult.UsedGas
|
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())
|
2020-06-30 03:12:51 -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(), vmContext.BlockNumber.Uint64(), blockHash)
|
2020-06-30 03:12:51 -05:00
|
|
|
receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
|
2021-02-25 08:26:57 -06:00
|
|
|
// These three are non-consensus fields:
|
2020-06-30 03:12:51 -05:00
|
|
|
//receipt.BlockHash
|
2021-02-25 08:26:57 -06:00
|
|
|
//receipt.BlockNumber
|
2020-06-30 03:12:51 -05:00
|
|
|
receipt.TransactionIndex = uint(txIndex)
|
|
|
|
receipts = append(receipts, receipt)
|
|
|
|
}
|
2021-02-25 08:26:57 -06:00
|
|
|
|
2020-06-30 03:12:51 -05:00
|
|
|
txIndex++
|
|
|
|
}
|
|
|
|
statedb.IntermediateRoot(chainConfig.IsEIP158(vmContext.BlockNumber))
|
2022-11-09 02:34:42 -06:00
|
|
|
// Add mining reward? (-1 means rewards are disabled)
|
|
|
|
if miningReward >= 0 {
|
2020-06-30 03:12:51 -05:00
|
|
|
// Add mining reward. The mining reward may be `0`, which only makes a difference in the cases
|
|
|
|
// where
|
2023-07-15 09:35:30 -05:00
|
|
|
// - the coinbase self-destructed, or
|
2020-06-30 03:12:51 -05:00
|
|
|
// - there are only 'bad' transactions, which aren't executed. In those cases,
|
|
|
|
// the coinbase gets no txfee, so isn't created, and thus needs to be touched
|
|
|
|
var (
|
|
|
|
blockReward = big.NewInt(miningReward)
|
|
|
|
minerReward = new(big.Int).Set(blockReward)
|
|
|
|
perOmmer = new(big.Int).Div(blockReward, big.NewInt(32))
|
|
|
|
)
|
|
|
|
for _, ommer := range pre.Env.Ommers {
|
|
|
|
// Add 1/32th for each ommer included
|
|
|
|
minerReward.Add(minerReward, perOmmer)
|
|
|
|
// Add (8-delta)/8
|
|
|
|
reward := big.NewInt(8)
|
2022-06-14 07:09:48 -05:00
|
|
|
reward.Sub(reward, new(big.Int).SetUint64(ommer.Delta))
|
2020-06-30 03:12:51 -05:00
|
|
|
reward.Mul(reward, blockReward)
|
|
|
|
reward.Div(reward, big.NewInt(8))
|
|
|
|
statedb.AddBalance(ommer.Address, reward)
|
|
|
|
}
|
|
|
|
statedb.AddBalance(pre.Env.Coinbase, minerReward)
|
|
|
|
}
|
2023-01-25 08:32:25 -06:00
|
|
|
// Apply withdrawals
|
|
|
|
for _, w := range pre.Env.Withdrawals {
|
|
|
|
// Amount is in gwei, turn into wei
|
|
|
|
amount := new(big.Int).Mul(new(big.Int).SetUint64(w.Amount), big.NewInt(params.GWei))
|
|
|
|
statedb.AddBalance(w.Address, amount)
|
|
|
|
}
|
2020-06-30 03:12:51 -05:00
|
|
|
// Commit block
|
2023-07-24 05:22:09 -05:00
|
|
|
root, err := statedb.Commit(vmContext.BlockNumber.Uint64(), chainConfig.IsEIP158(vmContext.BlockNumber))
|
2020-06-30 03:12:51 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, NewError(ErrorEVM, fmt.Errorf("could not commit state: %v", err))
|
|
|
|
}
|
|
|
|
execRs := &ExecutionResult{
|
|
|
|
StateRoot: root,
|
2021-02-02 06:09:23 -06:00
|
|
|
TxRoot: types.DeriveSha(includedTxs, trie.NewStackTrie(nil)),
|
|
|
|
ReceiptRoot: types.DeriveSha(receipts, trie.NewStackTrie(nil)),
|
2020-06-30 03:12:51 -05:00
|
|
|
Bloom: types.CreateBloom(receipts),
|
|
|
|
LogsHash: rlpHash(statedb.Logs()),
|
|
|
|
Receipts: receipts,
|
|
|
|
Rejected: rejectedTxs,
|
2021-08-25 08:04:26 -05:00
|
|
|
Difficulty: (*math.HexOrDecimal256)(vmContext.Difficulty),
|
2021-11-16 01:43:58 -06:00
|
|
|
GasUsed: (math.HexOrDecimal64)(gasUsed),
|
2022-10-28 05:25:37 -05:00
|
|
|
BaseFee: (*math.HexOrDecimal256)(vmContext.BaseFee),
|
2020-06-30 03:12:51 -05:00
|
|
|
}
|
2023-01-25 08:32:25 -06:00
|
|
|
if pre.Env.Withdrawals != nil {
|
|
|
|
h := types.DeriveSha(types.Withdrawals(pre.Env.Withdrawals), trie.NewStackTrie(nil))
|
|
|
|
execRs.WithdrawalsRoot = &h
|
|
|
|
}
|
2023-10-02 04:49:29 -05:00
|
|
|
if vmContext.BlobBaseFee != nil {
|
|
|
|
execRs.CurrentExcessBlobGas = (*math.HexOrDecimal64)(&excessBlobGas)
|
2023-08-01 06:58:26 -05:00
|
|
|
execRs.CurrentBlobGasUsed = (*math.HexOrDecimal64)(&blobGasUsed)
|
|
|
|
}
|
cmd, core/state, eth, tests, trie: improve state reader (#27428)
The state availability is checked during the creation of a state reader.
- In hash-based database, if the specified root node does not exist on disk disk, then
the state reader won't be created and an error will be returned.
- In path-based database, if the specified state layer is not available, then the
state reader won't be created and an error will be returned.
This change also contains a stricter semantics regarding the `Commit` operation: once it has been performed, the trie is no longer usable, and certain operations will return an error.
2023-06-20 14:31:45 -05:00
|
|
|
// Re-create statedb instance with new root upon the updated database
|
|
|
|
// for accessing latest states.
|
|
|
|
statedb, err = state.New(root, statedb.Database(), nil)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, NewError(ErrorEVM, fmt.Errorf("could not reopen state: %v", err))
|
|
|
|
}
|
2020-06-30 03:12:51 -05:00
|
|
|
return statedb, execRs, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func MakePreState(db ethdb.Database, accounts core.GenesisAlloc) *state.StateDB {
|
2022-07-27 13:37:04 -05:00
|
|
|
sdb := state.NewDatabaseWithConfig(db, &trie.Config{Preimages: true})
|
2023-05-11 02:19:42 -05:00
|
|
|
statedb, _ := state.New(types.EmptyRootHash, sdb, nil)
|
2020-06-30 03:12:51 -05:00
|
|
|
for addr, a := range accounts {
|
|
|
|
statedb.SetCode(addr, a.Code)
|
|
|
|
statedb.SetNonce(addr, a.Nonce)
|
|
|
|
statedb.SetBalance(addr, a.Balance)
|
|
|
|
for k, v := range a.Storage {
|
|
|
|
statedb.SetState(addr, k, v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Commit and re-open to start with a clean state.
|
2023-07-24 05:22:09 -05:00
|
|
|
root, _ := statedb.Commit(0, false)
|
2020-06-30 03:12:51 -05:00
|
|
|
statedb, _ = state.New(root, sdb, nil)
|
|
|
|
return statedb
|
|
|
|
}
|
|
|
|
|
|
|
|
func rlpHash(x interface{}) (h common.Hash) {
|
|
|
|
hw := sha3.NewLegacyKeccak256()
|
|
|
|
rlp.Encode(hw, x)
|
|
|
|
hw.Sum(h[:0])
|
|
|
|
return h
|
|
|
|
}
|
2021-08-25 08:04:26 -05:00
|
|
|
|
|
|
|
// calcDifficulty is based on ethash.CalcDifficulty. This method is used in case
|
|
|
|
// the caller does not provide an explicit difficulty, but instead provides only
|
|
|
|
// parent timestamp + difficulty.
|
|
|
|
// Note: this method only works for ethash engine.
|
|
|
|
func calcDifficulty(config *params.ChainConfig, number, currentTime, parentTime uint64,
|
|
|
|
parentDifficulty *big.Int, parentUncleHash common.Hash) *big.Int {
|
|
|
|
uncleHash := parentUncleHash
|
|
|
|
if uncleHash == (common.Hash{}) {
|
|
|
|
uncleHash = types.EmptyUncleHash
|
|
|
|
}
|
|
|
|
parent := &types.Header{
|
|
|
|
ParentHash: common.Hash{},
|
|
|
|
UncleHash: uncleHash,
|
|
|
|
Difficulty: parentDifficulty,
|
|
|
|
Number: new(big.Int).SetUint64(number - 1),
|
|
|
|
Time: parentTime,
|
|
|
|
}
|
|
|
|
return ethash.CalcDifficulty(config, currentTime, parent)
|
|
|
|
}
|