erigon-pulse/tests/state_test_util.go

469 lines
15 KiB
Go
Raw Normal View History

// Copyright 2015 The go-ethereum Authors
// This file is part of the go-ethereum library.
2015-07-07 00:54:22 +00:00
//
// The go-ethereum library is free software: you can redistribute it and/or modify
2015-07-07 00:54:22 +00:00
// 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,
2015-07-07 00:54:22 +00:00
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2015-07-07 00:54:22 +00:00
// 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-07-07 00:54:22 +00:00
2015-06-10 18:38:39 +00:00
package tests
import (
"encoding/binary"
"encoding/hex"
"encoding/json"
2015-06-10 18:38:39 +00:00
"fmt"
"math/big"
"strconv"
"strings"
2015-06-10 18:38:39 +00:00
"github.com/holiman/uint256"
2022-11-20 03:58:20 +00:00
"github.com/ledgerwatch/erigon-lib/common/length"
2021-07-29 11:53:13 +00:00
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/erigon/common/hexutil"
"github.com/ledgerwatch/erigon/common/math"
"github.com/ledgerwatch/erigon/core"
"github.com/ledgerwatch/erigon/core/state"
"github.com/ledgerwatch/erigon/core/types"
"github.com/ledgerwatch/erigon/core/vm"
"github.com/ledgerwatch/erigon/crypto"
"github.com/ledgerwatch/erigon/params"
"github.com/ledgerwatch/erigon/rlp"
"github.com/ledgerwatch/erigon/turbo/trie"
"golang.org/x/crypto/sha3"
"github.com/ledgerwatch/erigon/common"
2015-06-10 18:38:39 +00:00
)
// StateTest checks transaction processing without block context.
// See https://github.com/ethereum/EIPs/issues/176 for the test format specification.
type StateTest struct {
json stJSON
}
2015-06-14 21:55:03 +00:00
// StateSubtest selects a specific configuration of a General State Test.
type StateSubtest struct {
Fork string
Index int
2015-06-14 21:55:03 +00:00
}
func (t *StateTest) UnmarshalJSON(in []byte) error {
return json.Unmarshal(in, &t.json)
}
2015-06-14 21:55:03 +00:00
type stJSON struct {
Env stEnv `json:"env"`
Pre core.GenesisAlloc `json:"pre"`
Tx stTransactionMarshaling `json:"transaction"`
Out hexutil.Bytes `json:"out"`
Post map[string][]stPostState `json:"post"`
}
type stPostState struct {
2022-09-02 03:04:49 +00:00
Root common.UnprefixedHash `json:"hash"`
Logs common.UnprefixedHash `json:"logs"`
Tx hexutil.Bytes `json:"txbytes"`
ExpectException string `json:"expectException"`
Indexes struct {
Data int `json:"data"`
Gas int `json:"gas"`
Value int `json:"value"`
}
}
type stTransaction struct {
GasPrice *big.Int `json:"gasPrice"`
MaxFeePerGas *big.Int `json:"maxFeePerGas"`
MaxPriorityFeePerGas *big.Int `json:"maxPriorityFeePerGas"`
Nonce uint64 `json:"nonce"`
To string `json:"to"`
Data []string `json:"data"`
AccessLists []*types.AccessList `json:"accessLists,omitempty"`
GasLimit []uint64 `json:"gasLimit"`
Value []string `json:"value"`
PrivateKey []byte `json:"secretKey"`
}
type stTransactionMarshaling struct {
GasPrice *math.HexOrDecimal256 `json:"gasPrice"`
MaxFeePerGas *math.HexOrDecimal256 `json:"maxFeePerGas"`
MaxPriorityFeePerGas *math.HexOrDecimal256 `json:"maxPriorityFeePerGas"`
Nonce math.HexOrDecimal64 `json:"nonce"`
GasLimit []math.HexOrDecimal64 `json:"gasLimit"`
PrivateKey hexutil.Bytes `json:"secretKey"`
To string `json:"to"`
Data []string `json:"data"`
Value []string `json:"value"`
AccessLists []*types.AccessList `json:"accessLists,omitempty"`
}
2015-06-14 21:55:03 +00:00
//go:generate gencodec -type stEnv -field-override stEnvMarshaling -out gen_stenv.go
2015-06-14 21:55:03 +00:00
type stEnv struct {
Coinbase common.Address `json:"currentCoinbase" gencodec:"required"`
Difficulty *big.Int `json:"currentDifficulty" gencodec:"required"`
Random *big.Int `json:"currentRandom" gencodec:"optional"`
GasLimit uint64 `json:"currentGasLimit" gencodec:"required"`
Number uint64 `json:"currentNumber" gencodec:"required"`
Timestamp uint64 `json:"currentTimestamp" gencodec:"required"`
BaseFee *big.Int `json:"currentBaseFee" gencodec:"optional"`
2015-06-14 21:55:03 +00:00
}
type stEnvMarshaling struct {
Coinbase common.UnprefixedAddress
Difficulty *math.HexOrDecimal256
Random *math.HexOrDecimal256
GasLimit math.HexOrDecimal64
Number math.HexOrDecimal64
Timestamp math.HexOrDecimal64
BaseFee *math.HexOrDecimal256
}
// GetChainConfig takes a fork definition and returns a chain config.
// The fork definition can be
// - a plain forkname, e.g. `Byzantium`,
// - a fork basename, and a list of EIPs to enable; e.g. `Byzantium+1884+1283`.
func GetChainConfig(forkString string) (baseConfig *params.ChainConfig, eips []int, err error) {
var (
splitForks = strings.Split(forkString, "+")
ok bool
baseName, eipsStrings = splitForks[0], splitForks[1:]
)
if baseConfig, ok = Forks[baseName]; !ok {
return nil, nil, UnsupportedForkError{baseName}
}
for _, eip := range eipsStrings {
if eipNum, err := strconv.Atoi(eip); err != nil {
return nil, nil, fmt.Errorf("syntax error, invalid eip number %v", eipNum)
} else {
if !vm.ValidEip(eipNum) {
return nil, nil, fmt.Errorf("syntax error, invalid eip number %v", eipNum)
}
eips = append(eips, eipNum)
}
}
return baseConfig, eips, nil
}
// Subtests returns all valid subtests of the test.
func (t *StateTest) Subtests() []StateSubtest {
var sub []StateSubtest
for fork, pss := range t.json.Post {
2017-11-08 10:45:52 +00:00
for i := range pss {
sub = append(sub, StateSubtest{fork, i})
}
}
return sub
}
// Run executes a specific subtest and verifies the post-state and logs
func (t *StateTest) Run(tx kv.RwTx, subtest StateSubtest, vmconfig vm.Config) (*state.IntraBlockState, error) {
state, root, err := t.RunNoVerify(tx, subtest, vmconfig)
all: seperate consensus error and evm internal error (#20830) * all: seperate consensus error and evm internal error There are actually two types of error will be returned when a tranaction/message call is executed: (a) consensus error (b) evm internal error. The former should be converted to a consensus issue, e.g. The sender doesn't enough asset to purchase the gas it specifies. The latter is allowed since evm itself is a blackbox and internal error is allowed to happen. This PR emphasizes the difference by introducing a executionResult structure. The evm error is embedded inside. So if any error returned, it indicates consensus issue happens. And also this PR improve the `EstimateGas` API to return the concrete revert reason if the transaction always fails * all: polish * accounts/abi/bind/backends: add tests * accounts/abi/bind/backends, internal: cleanup error message * all: address comments * core: fix lint * accounts, core, eth, internal: address comments * accounts, internal: resolve revert reason if possible * accounts, internal: address comments # Conflicts: # accounts/abi/abi.go # accounts/abi/bind/backends/simulated.go # cmd/geth/retesteth.go # core/state/snapshot/difflayer_test.go # core/state/snapshot/disklayer_test.go # core/state/snapshot/iterator_test.go # core/state_processor.go # core/state_transition.go # core/vm/evm.go # core/vm/instructions.go # core/vm/jump_table.go # eth/api_tracer.go # internal/ethapi/api.go # les/odr_test.go # light/odr_test.go # tests/state_test_util.go
2020-04-22 08:25:36 +00:00
if err != nil {
return state, err
all: seperate consensus error and evm internal error (#20830) * all: seperate consensus error and evm internal error There are actually two types of error will be returned when a tranaction/message call is executed: (a) consensus error (b) evm internal error. The former should be converted to a consensus issue, e.g. The sender doesn't enough asset to purchase the gas it specifies. The latter is allowed since evm itself is a blackbox and internal error is allowed to happen. This PR emphasizes the difference by introducing a executionResult structure. The evm error is embedded inside. So if any error returned, it indicates consensus issue happens. And also this PR improve the `EstimateGas` API to return the concrete revert reason if the transaction always fails * all: polish * accounts/abi/bind/backends: add tests * accounts/abi/bind/backends, internal: cleanup error message * all: address comments * core: fix lint * accounts, core, eth, internal: address comments * accounts, internal: resolve revert reason if possible * accounts, internal: address comments # Conflicts: # accounts/abi/abi.go # accounts/abi/bind/backends/simulated.go # cmd/geth/retesteth.go # core/state/snapshot/difflayer_test.go # core/state/snapshot/disklayer_test.go # core/state/snapshot/iterator_test.go # core/state_processor.go # core/state_transition.go # core/vm/evm.go # core/vm/instructions.go # core/vm/jump_table.go # eth/api_tracer.go # internal/ethapi/api.go # les/odr_test.go # light/odr_test.go # tests/state_test_util.go
2020-04-22 08:25:36 +00:00
}
2020-05-19 10:28:20 +00:00
post := t.json.Post[subtest.Fork][subtest.Index]
all: seperate consensus error and evm internal error (#20830) * all: seperate consensus error and evm internal error There are actually two types of error will be returned when a tranaction/message call is executed: (a) consensus error (b) evm internal error. The former should be converted to a consensus issue, e.g. The sender doesn't enough asset to purchase the gas it specifies. The latter is allowed since evm itself is a blackbox and internal error is allowed to happen. This PR emphasizes the difference by introducing a executionResult structure. The evm error is embedded inside. So if any error returned, it indicates consensus issue happens. And also this PR improve the `EstimateGas` API to return the concrete revert reason if the transaction always fails * all: polish * accounts/abi/bind/backends: add tests * accounts/abi/bind/backends, internal: cleanup error message * all: address comments * core: fix lint * accounts, core, eth, internal: address comments * accounts, internal: resolve revert reason if possible * accounts, internal: address comments # Conflicts: # accounts/abi/abi.go # accounts/abi/bind/backends/simulated.go # cmd/geth/retesteth.go # core/state/snapshot/difflayer_test.go # core/state/snapshot/disklayer_test.go # core/state/snapshot/iterator_test.go # core/state_processor.go # core/state_transition.go # core/vm/evm.go # core/vm/instructions.go # core/vm/jump_table.go # eth/api_tracer.go # internal/ethapi/api.go # les/odr_test.go # light/odr_test.go # tests/state_test_util.go
2020-04-22 08:25:36 +00:00
// N.B: We need to do this in a two-step process, because the first Commit takes care
// of suicides, and we need to touch the coinbase _after_ it has potentially suicided.
2022-09-02 03:04:49 +00:00
if root != common.Hash(post.Root) {
return state, fmt.Errorf("post state root mismatch: got %x, want %x", root, post.Root)
all: seperate consensus error and evm internal error (#20830) * all: seperate consensus error and evm internal error There are actually two types of error will be returned when a tranaction/message call is executed: (a) consensus error (b) evm internal error. The former should be converted to a consensus issue, e.g. The sender doesn't enough asset to purchase the gas it specifies. The latter is allowed since evm itself is a blackbox and internal error is allowed to happen. This PR emphasizes the difference by introducing a executionResult structure. The evm error is embedded inside. So if any error returned, it indicates consensus issue happens. And also this PR improve the `EstimateGas` API to return the concrete revert reason if the transaction always fails * all: polish * accounts/abi/bind/backends: add tests * accounts/abi/bind/backends, internal: cleanup error message * all: address comments * core: fix lint * accounts, core, eth, internal: address comments * accounts, internal: resolve revert reason if possible * accounts, internal: address comments # Conflicts: # accounts/abi/abi.go # accounts/abi/bind/backends/simulated.go # cmd/geth/retesteth.go # core/state/snapshot/difflayer_test.go # core/state/snapshot/disklayer_test.go # core/state/snapshot/iterator_test.go # core/state_processor.go # core/state_transition.go # core/vm/evm.go # core/vm/instructions.go # core/vm/jump_table.go # eth/api_tracer.go # internal/ethapi/api.go # les/odr_test.go # light/odr_test.go # tests/state_test_util.go
2020-04-22 08:25:36 +00:00
}
2022-09-02 03:04:49 +00:00
if logs := rlpHash(state.Logs()); logs != common.Hash(post.Logs) {
return state, fmt.Errorf("post state logs hash mismatch: got %x, want %x", logs, post.Logs)
}
return state, nil
}
// RunNoVerify runs a specific subtest and returns the statedb and post-state root
func (t *StateTest) RunNoVerify(tx kv.RwTx, subtest StateSubtest, vmconfig vm.Config) (*state.IntraBlockState, common.Hash, error) {
2020-08-07 12:25:40 +00:00
config, eips, err := GetChainConfig(subtest.Fork)
if err != nil {
2021-03-31 15:30:09 +00:00
return nil, common.Hash{}, UnsupportedForkError{subtest.Fork}
}
vmconfig.ExtraEips = eips
block, _, err := t.genesis(config).ToBlock()
2020-05-19 10:28:20 +00:00
if err != nil {
2021-03-31 15:30:09 +00:00
return nil, common.Hash{}, UnsupportedForkError{subtest.Fork}
2020-05-19 10:28:20 +00:00
}
readBlockNr := block.NumberU64()
2020-05-19 10:28:20 +00:00
writeBlockNr := readBlockNr + 1
_, err = MakePreState(&params.Rules{}, tx, t.json.Pre, readBlockNr)
2020-05-19 10:28:20 +00:00
if err != nil {
2021-03-31 15:30:09 +00:00
return nil, common.Hash{}, UnsupportedForkError{subtest.Fork}
2020-05-19 10:28:20 +00:00
}
statedb := state.New(state.NewPlainStateReader(tx))
w := state.NewPlainStateWriter(tx, nil, writeBlockNr)
var baseFee *big.Int
if config.IsLondon(0) {
baseFee = t.json.Env.BaseFee
if baseFee == nil {
// Retesteth uses `0x10` for genesis baseFee. Therefore, it defaults to
// parent - 2 : 0xa as the basefee for 'this' context.
baseFee = big.NewInt(0x0a)
}
}
post := t.json.Post[subtest.Fork][subtest.Index]
msg, err := toMessage(t.json.Tx, post, baseFee)
if err != nil {
return nil, common.Hash{}, err
}
if len(post.Tx) != 0 {
txn, err := types.UnmarshalTransactionFromBinary(post.Tx)
if err != nil {
return nil, common.Hash{}, err
}
msg, err = txn.AsMessage(*types.MakeSigner(config, 0), baseFee, config.Rules(0))
if err != nil {
return nil, common.Hash{}, err
}
}
all: add support for EIP-2718, EIP-2930 transactions (#21502) This adds support for EIP-2718 typed transactions as well as EIP-2930 access list transactions (tx type 1). These EIPs are scheduled for the Berlin fork. There very few changes to existing APIs in core/types, and several new APIs to deal with access list transactions. In particular, there are two new constructor functions for transactions: types.NewTx and types.SignNewTx. Since the canonical encoding of typed transactions is not RLP-compatible, Transaction now has new methods for encoding and decoding: MarshalBinary and UnmarshalBinary. The existing EIP-155 signer does not support the new transaction types. All code dealing with transaction signatures should be updated to use the newer EIP-2930 signer. To make this easier for future updates, we have added new constructor functions for types.Signer: types.LatestSigner and types.LatestSignerForChainID. This change also adds support for the YoloV3 testnet. Co-authored-by: Martin Holst Swende <martin@swende.se> Co-authored-by: Felix Lange <fjl@twurst.com> Co-authored-by: Ryan Schneider <ryanleeschneider@gmail.com> # Conflicts: # accounts/abi/bind/backends/simulated.go # cmd/evm/internal/t8ntool/execution.go # cmd/evm/internal/t8ntool/transition.go # cmd/geth/main.go # cmd/geth/usage.go # core/bench_test.go # core/state/statedb.go # core/state_prefetcher.go # core/state_processor.go # core/state_transition.go # core/tx_pool.go # core/types/block.go # core/types/derive_sha.go # core/types/gen_tx_json.go # core/types/receipt.go # core/types/receipt_test.go # core/types/transaction.go # core/types/transaction_signing.go # core/types/transaction_test.go # ethclient/ethclient.go # ethclient/signer.go # graphql/graphql.go # internal/ethapi/api.go # internal/guide/guide_test.go # les/benchmark.go # les/odr_test.go # light/odr_test.go # light/txpool.go # miner/worker.go # miner/worker_test.go # signer/core/api.go # tests/state_test_util.go # trie/stacktrie_test.go # turbo/stages/blockchain_test.go
2021-02-25 14:26:57 +00:00
// Prepare the EVM.
txContext := core.NewEVMTxContext(msg)
header := block.Header()
context := core.NewEVMBlockContext(header, core.GetHashFn(header, nil), nil, &t.json.Env.Coinbase)
context.GetHash = vmTestBlockHash
if baseFee != nil {
context.BaseFee = new(uint256.Int)
context.BaseFee.SetFromBig(baseFee)
}
if t.json.Env.Random != nil {
rnd := common.BigToHash(t.json.Env.Random)
context.PrevRanDao = &rnd
}
evm := vm.NewEVM(context, txContext, statedb, config, vmconfig)
all: add support for EIP-2718, EIP-2930 transactions (#21502) This adds support for EIP-2718 typed transactions as well as EIP-2930 access list transactions (tx type 1). These EIPs are scheduled for the Berlin fork. There very few changes to existing APIs in core/types, and several new APIs to deal with access list transactions. In particular, there are two new constructor functions for transactions: types.NewTx and types.SignNewTx. Since the canonical encoding of typed transactions is not RLP-compatible, Transaction now has new methods for encoding and decoding: MarshalBinary and UnmarshalBinary. The existing EIP-155 signer does not support the new transaction types. All code dealing with transaction signatures should be updated to use the newer EIP-2930 signer. To make this easier for future updates, we have added new constructor functions for types.Signer: types.LatestSigner and types.LatestSignerForChainID. This change also adds support for the YoloV3 testnet. Co-authored-by: Martin Holst Swende <martin@swende.se> Co-authored-by: Felix Lange <fjl@twurst.com> Co-authored-by: Ryan Schneider <ryanleeschneider@gmail.com> # Conflicts: # accounts/abi/bind/backends/simulated.go # cmd/evm/internal/t8ntool/execution.go # cmd/evm/internal/t8ntool/transition.go # cmd/geth/main.go # cmd/geth/usage.go # core/bench_test.go # core/state/statedb.go # core/state_prefetcher.go # core/state_processor.go # core/state_transition.go # core/tx_pool.go # core/types/block.go # core/types/derive_sha.go # core/types/gen_tx_json.go # core/types/receipt.go # core/types/receipt_test.go # core/types/transaction.go # core/types/transaction_signing.go # core/types/transaction_test.go # ethclient/ethclient.go # ethclient/signer.go # graphql/graphql.go # internal/ethapi/api.go # internal/guide/guide_test.go # les/benchmark.go # les/odr_test.go # light/odr_test.go # light/txpool.go # miner/worker.go # miner/worker_test.go # signer/core/api.go # tests/state_test_util.go # trie/stacktrie_test.go # turbo/stages/blockchain_test.go
2021-02-25 14:26:57 +00:00
// Execute the message.
snapshot := statedb.Snapshot()
gaspool := new(core.GasPool)
gaspool.AddGas(block.GasLimit())
if _, err = core.ApplyMessage(evm, msg, gaspool, true /* refunds */, false /* gasBailout */); err != nil {
statedb.RevertToSnapshot(snapshot)
}
all: add support for EIP-2718, EIP-2930 transactions (#21502) This adds support for EIP-2718 typed transactions as well as EIP-2930 access list transactions (tx type 1). These EIPs are scheduled for the Berlin fork. There very few changes to existing APIs in core/types, and several new APIs to deal with access list transactions. In particular, there are two new constructor functions for transactions: types.NewTx and types.SignNewTx. Since the canonical encoding of typed transactions is not RLP-compatible, Transaction now has new methods for encoding and decoding: MarshalBinary and UnmarshalBinary. The existing EIP-155 signer does not support the new transaction types. All code dealing with transaction signatures should be updated to use the newer EIP-2930 signer. To make this easier for future updates, we have added new constructor functions for types.Signer: types.LatestSigner and types.LatestSignerForChainID. This change also adds support for the YoloV3 testnet. Co-authored-by: Martin Holst Swende <martin@swende.se> Co-authored-by: Felix Lange <fjl@twurst.com> Co-authored-by: Ryan Schneider <ryanleeschneider@gmail.com> # Conflicts: # accounts/abi/bind/backends/simulated.go # cmd/evm/internal/t8ntool/execution.go # cmd/evm/internal/t8ntool/transition.go # cmd/geth/main.go # cmd/geth/usage.go # core/bench_test.go # core/state/statedb.go # core/state_prefetcher.go # core/state_processor.go # core/state_transition.go # core/tx_pool.go # core/types/block.go # core/types/derive_sha.go # core/types/gen_tx_json.go # core/types/receipt.go # core/types/receipt_test.go # core/types/transaction.go # core/types/transaction_signing.go # core/types/transaction_test.go # ethclient/ethclient.go # ethclient/signer.go # graphql/graphql.go # internal/ethapi/api.go # internal/guide/guide_test.go # les/benchmark.go # les/odr_test.go # light/odr_test.go # light/txpool.go # miner/worker.go # miner/worker_test.go # signer/core/api.go # tests/state_test_util.go # trie/stacktrie_test.go # turbo/stages/blockchain_test.go
2021-02-25 14:26:57 +00:00
if err = statedb.FinalizeTx(evm.ChainRules(), w); err != nil {
2021-03-31 15:30:09 +00:00
return nil, common.Hash{}, err
}
if err = statedb.CommitBlock(evm.ChainRules(), w); err != nil {
2021-03-31 15:30:09 +00:00
return nil, common.Hash{}, err
}
// Generate hashed state
2021-07-28 03:43:51 +00:00
c, err := tx.RwCursor(kv.PlainState)
if err != nil {
return nil, common.Hash{}, err
}
h := common.NewHasher()
defer common.ReturnHasherToPool(h)
for k, v, err := c.First(); k != nil; k, v, err = c.Next() {
if err != nil {
return nil, common.Hash{}, fmt.Errorf("interate over plain state: %w", err)
}
var newK []byte
2022-11-20 03:58:20 +00:00
if len(k) == length.Addr {
newK = make([]byte, length.Hash)
} else {
2022-11-20 03:58:20 +00:00
newK = make([]byte, length.Hash*2+length.Incarnation)
}
h.Sha.Reset()
//nolint:errcheck
2022-11-20 03:58:20 +00:00
h.Sha.Write(k[:length.Addr])
//nolint:errcheck
2022-11-20 03:58:20 +00:00
h.Sha.Read(newK[:length.Hash])
if len(k) > length.Addr {
copy(newK[length.Hash:], k[length.Addr:length.Addr+length.Incarnation])
h.Sha.Reset()
//nolint:errcheck
2022-11-20 03:58:20 +00:00
h.Sha.Write(k[length.Addr+length.Incarnation:])
//nolint:errcheck
2022-11-20 03:58:20 +00:00
h.Sha.Read(newK[length.Hash+length.Incarnation:])
if err = tx.Put(kv.HashedStorage, newK, common.CopyBytes(v)); err != nil {
return nil, common.Hash{}, fmt.Errorf("insert hashed key: %w", err)
}
} else {
if err = tx.Put(kv.HashedAccounts, newK, common.CopyBytes(v)); err != nil {
return nil, common.Hash{}, fmt.Errorf("insert hashed key: %w", err)
}
}
}
c.Close()
root, err := trie.CalcRoot("", tx)
if err != nil {
2021-10-04 15:16:52 +00:00
return nil, common.Hash{}, fmt.Errorf("error calculating state root: %w", err)
}
2021-03-31 15:30:09 +00:00
return statedb, root, nil
}
func MakePreState(rules *params.Rules, tx kv.RwTx, accounts core.GenesisAlloc, blockNr uint64) (*state.IntraBlockState, error) {
r := state.NewPlainStateReader(tx)
statedb := state.New(r)
for addr, a := range accounts {
statedb.SetCode(addr, a.Code)
statedb.SetNonce(addr, a.Nonce)
balance, _ := uint256.FromBig(a.Balance)
statedb.SetBalance(addr, balance)
for k, v := range a.Storage {
key := k
val := uint256.NewInt(0).SetBytes(v.Bytes())
statedb.SetState(addr, &key, *val)
}
if len(a.Code) > 0 || len(a.Storage) > 0 {
statedb.SetIncarnation(addr, state.FirstContractIncarnation)
var b [8]byte
binary.BigEndian.PutUint64(b[:], state.FirstContractIncarnation)
if err := tx.Put(kv.IncarnationMap, addr[:], b[:]); err != nil {
return nil, err
}
}
}
// Commit and re-open to start with a clean state.
if err := statedb.FinalizeTx(rules, state.NewPlainStateWriter(tx, nil, blockNr+1)); err != nil {
return nil, err
}
if err := statedb.CommitBlock(rules, state.NewPlainStateWriter(tx, nil, blockNr+1)); err != nil {
return nil, err
}
return statedb, nil
}
func (t *StateTest) genesis(config *params.ChainConfig) *core.Genesis {
return &core.Genesis{
Config: config,
Coinbase: t.json.Env.Coinbase,
Difficulty: t.json.Env.Difficulty,
GasLimit: t.json.Env.GasLimit,
Number: t.json.Env.Number,
Timestamp: t.json.Env.Timestamp,
Alloc: t.json.Pre,
2015-06-14 21:55:03 +00:00
}
}
2015-06-10 18:38:39 +00:00
func rlpHash(x interface{}) (h common.Hash) {
hw := sha3.NewLegacyKeccak256()
2021-03-17 22:24:46 +00:00
if err := rlp.Encode(hw, x); err != nil {
panic(err)
}
hw.Sum(h[:0])
return h
2015-06-10 18:38:39 +00:00
}
func vmTestBlockHash(n uint64) common.Hash {
return common.BytesToHash(crypto.Keccak256([]byte(big.NewInt(int64(n)).String())))
}
func toMessage(tx stTransactionMarshaling, ps stPostState, baseFee *big.Int) (core.Message, error) {
// Derive sender from private key if present.
var from common.Address
if len(tx.PrivateKey) > 0 {
key, err := crypto.ToECDSA(tx.PrivateKey)
if err != nil {
return nil, fmt.Errorf("invalid private key: %v", err)
}
from = crypto.PubkeyToAddress(key.PublicKey)
}
// Parse recipient if present.
var to *common.Address
if tx.To != "" {
to = new(common.Address)
if err := to.UnmarshalText([]byte(tx.To)); err != nil {
return nil, fmt.Errorf("invalid to address: %v", err)
}
}
// Get values specific to this post state.
if ps.Indexes.Data > len(tx.Data) {
return nil, fmt.Errorf("tx data index %d out of bounds", ps.Indexes.Data)
}
if ps.Indexes.Value > len(tx.Value) {
return nil, fmt.Errorf("tx value index %d out of bounds", ps.Indexes.Value)
}
if ps.Indexes.Gas > len(tx.GasLimit) {
return nil, fmt.Errorf("tx gas limit index %d out of bounds", ps.Indexes.Gas)
}
dataHex := tx.Data[ps.Indexes.Data]
valueHex := tx.Value[ps.Indexes.Value]
gasLimit := tx.GasLimit[ps.Indexes.Gas]
value := new(uint256.Int)
if valueHex != "0x" {
va, ok := math.ParseBig256(valueHex)
if !ok {
return nil, fmt.Errorf("invalid tx value %q", valueHex)
}
v, overflow := uint256.FromBig(va)
if overflow {
return nil, fmt.Errorf("invalid tx value (overflowed) %q", valueHex)
}
value = v
}
data, err := hex.DecodeString(strings.TrimPrefix(dataHex, "0x"))
if err != nil {
return nil, fmt.Errorf("invalid tx data %q", dataHex)
}
var accessList types.AccessList
if tx.AccessLists != nil && tx.AccessLists[ps.Indexes.Data] != nil {
accessList = *tx.AccessLists[ps.Indexes.Data]
}
var feeCap, tipCap big.Int
// If baseFee provided, set gasPrice to effectiveGasPrice.
gasPrice := tx.GasPrice
if baseFee != nil {
if tx.MaxFeePerGas == nil {
tx.MaxFeePerGas = gasPrice
}
if tx.MaxFeePerGas == nil {
tx.MaxFeePerGas = math.NewHexOrDecimal256(0)
}
if tx.MaxPriorityFeePerGas == nil {
tx.MaxPriorityFeePerGas = tx.MaxFeePerGas
}
2022-09-02 03:04:49 +00:00
feeCap = big.Int(*tx.MaxPriorityFeePerGas)
tipCap = big.Int(*tx.MaxFeePerGas)
gp := math.BigMin(new(big.Int).Add(&feeCap, baseFee), &tipCap)
gasPrice = math.NewHexOrDecimal256(gp.Int64())
}
if gasPrice == nil {
return nil, fmt.Errorf("no gas price provided")
}
gpi := big.Int(*gasPrice)
gasPriceInt := uint256.NewInt(gpi.Uint64())
// TODO the conversion to int64 then uint64 then new int isn't working!
msg := types.NewMessage(
from,
to,
uint64(tx.Nonce),
value,
uint64(gasLimit),
gasPriceInt,
uint256.NewInt(feeCap.Uint64()),
uint256.NewInt(tipCap.Uint64()),
data,
accessList,
false, /* checkNonce */
false /* isFree */)
return msg, nil
}