2015-07-06 19:54:22 -05:00
|
|
|
// Copyright 2015 The go-ethereum Authors
|
2015-07-22 11:48:40 -05:00
|
|
|
// This file is part of the go-ethereum library.
|
2015-07-06 19:54:22 -05:00
|
|
|
//
|
2015-07-23 11:35:11 -05:00
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
2015-07-06 19:54:22 -05: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.
|
|
|
|
//
|
2015-07-22 11:48:40 -05:00
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
2015-07-06 19:54:22 -05:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2015-07-22 11:48:40 -05:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-06 19:54:22 -05:00
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
2015-07-22 11:48:40 -05:00
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-06 19:54:22 -05:00
|
|
|
|
2017-07-11 06:49:14 -05:00
|
|
|
// Package tests implements execution of Ethereum JSON tests.
|
2015-03-13 12:01:51 -05:00
|
|
|
package tests
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"encoding/hex"
|
2017-07-11 06:49:14 -05:00
|
|
|
"encoding/json"
|
2015-03-13 12:01:51 -05:00
|
|
|
"fmt"
|
|
|
|
"math/big"
|
2021-06-07 07:37:56 -05:00
|
|
|
"os"
|
2023-02-06 13:52:51 -06:00
|
|
|
"reflect"
|
2015-03-13 12:01:51 -05:00
|
|
|
|
2015-03-16 05:27:38 -05:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2017-07-11 06:49:14 -05:00
|
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
|
|
"github.com/ethereum/go-ethereum/common/math"
|
2022-12-20 08:56:52 -06:00
|
|
|
"github.com/ethereum/go-ethereum/consensus/beacon"
|
2017-04-04 17:16:29 -05:00
|
|
|
"github.com/ethereum/go-ethereum/consensus/ethash"
|
2015-04-17 09:30:15 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2018-09-24 07:57:49 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
2015-03-23 16:05:12 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/state"
|
2015-03-16 17:10:26 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
2017-01-17 05:19:50 -06:00
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
2016-10-20 06:36:29 -05:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2015-03-13 12:01:51 -05:00
|
|
|
"github.com/ethereum/go-ethereum/rlp"
|
all: activate pbss as experimental feature (#26274)
* all: activate pbss
* core/rawdb: fix compilation error
* cma, core, eth, les, trie: address comments
* cmd, core, eth, trie: polish code
* core, cmd, eth: address comments
* cmd, core, eth, les, light, tests: address comment
* cmd/utils: shorten log message
* trie/triedb/pathdb: limit node buffer size to 1gb
* cmd/utils: fix opening non-existing db
* cmd/utils: rename flag name
* cmd, core: group chain history flags and fix tests
* core, eth, trie: fix memory leak in snapshot generation
* cmd, eth, internal: deprecate flags
* all: enable state tests for pathdb, fixes
* cmd, core: polish code
* trie/triedb/pathdb: limit the node buffer size to 256mb
---------
Co-authored-by: Martin Holst Swende <martin@swende.se>
Co-authored-by: Péter Szilágyi <peterke@gmail.com>
2023-08-10 14:21:36 -05:00
|
|
|
"github.com/ethereum/go-ethereum/trie"
|
|
|
|
"github.com/ethereum/go-ethereum/trie/triedb/hashdb"
|
|
|
|
"github.com/ethereum/go-ethereum/trie/triedb/pathdb"
|
2015-03-13 12:01:51 -05:00
|
|
|
)
|
|
|
|
|
2017-07-11 06:49:14 -05:00
|
|
|
// A BlockTest checks handling of entire blocks.
|
2015-04-20 11:14:57 -05:00
|
|
|
type BlockTest struct {
|
2017-07-11 06:49:14 -05:00
|
|
|
json btJSON
|
|
|
|
}
|
2015-04-20 11:14:57 -05:00
|
|
|
|
2018-06-05 05:31:34 -05:00
|
|
|
// UnmarshalJSON implements json.Unmarshaler interface.
|
2017-07-11 06:49:14 -05:00
|
|
|
func (t *BlockTest) UnmarshalJSON(in []byte) error {
|
|
|
|
return json.Unmarshal(in, &t.json)
|
2015-04-20 11:14:57 -05:00
|
|
|
}
|
|
|
|
|
2015-03-13 12:01:51 -05:00
|
|
|
type btJSON struct {
|
2018-10-15 17:26:47 -05:00
|
|
|
Blocks []btBlock `json:"blocks"`
|
|
|
|
Genesis btHeader `json:"genesisBlockHeader"`
|
|
|
|
Pre core.GenesisAlloc `json:"pre"`
|
|
|
|
Post core.GenesisAlloc `json:"postState"`
|
|
|
|
BestBlock common.UnprefixedHash `json:"lastblockhash"`
|
|
|
|
Network string `json:"network"`
|
|
|
|
SealEngine string `json:"sealEngine"`
|
2015-03-13 12:01:51 -05:00
|
|
|
}
|
|
|
|
|
2015-04-20 11:14:57 -05:00
|
|
|
type btBlock struct {
|
2021-06-07 07:37:56 -05:00
|
|
|
BlockHeader *btHeader
|
|
|
|
ExpectException string
|
|
|
|
Rlp string
|
|
|
|
UncleHeaders []*btHeader
|
2015-04-20 11:14:57 -05:00
|
|
|
}
|
|
|
|
|
2022-04-12 13:24:02 -05:00
|
|
|
//go:generate go run github.com/fjl/gencodec -type btHeader -field-override btHeaderMarshaling -out gen_btheader.go
|
2015-03-13 12:01:51 -05:00
|
|
|
|
|
|
|
type btHeader struct {
|
2017-07-11 06:49:14 -05:00
|
|
|
Bloom types.Bloom
|
|
|
|
Coinbase common.Address
|
|
|
|
MixHash common.Hash
|
|
|
|
Nonce types.BlockNonce
|
|
|
|
Number *big.Int
|
|
|
|
Hash common.Hash
|
|
|
|
ParentHash common.Hash
|
|
|
|
ReceiptTrie common.Hash
|
|
|
|
StateRoot common.Hash
|
|
|
|
TransactionsTrie common.Hash
|
|
|
|
UncleHash common.Hash
|
|
|
|
ExtraData []byte
|
|
|
|
Difficulty *big.Int
|
2017-11-13 05:47:27 -06:00
|
|
|
GasLimit uint64
|
|
|
|
GasUsed uint64
|
2019-04-02 15:28:48 -05:00
|
|
|
Timestamp uint64
|
2021-07-29 07:05:22 -05:00
|
|
|
BaseFeePerGas *big.Int
|
2023-02-06 13:52:51 -06:00
|
|
|
WithdrawalsRoot *common.Hash
|
2015-03-13 12:01:51 -05:00
|
|
|
}
|
|
|
|
|
2017-07-11 06:49:14 -05:00
|
|
|
type btHeaderMarshaling struct {
|
2021-07-29 07:05:22 -05:00
|
|
|
ExtraData hexutil.Bytes
|
|
|
|
Number *math.HexOrDecimal256
|
|
|
|
Difficulty *math.HexOrDecimal256
|
|
|
|
GasLimit math.HexOrDecimal64
|
|
|
|
GasUsed math.HexOrDecimal64
|
|
|
|
Timestamp math.HexOrDecimal64
|
|
|
|
BaseFeePerGas *math.HexOrDecimal256
|
2015-06-14 16:55:03 -05:00
|
|
|
}
|
|
|
|
|
all: activate pbss as experimental feature (#26274)
* all: activate pbss
* core/rawdb: fix compilation error
* cma, core, eth, les, trie: address comments
* cmd, core, eth, trie: polish code
* core, cmd, eth: address comments
* cmd, core, eth, les, light, tests: address comment
* cmd/utils: shorten log message
* trie/triedb/pathdb: limit node buffer size to 1gb
* cmd/utils: fix opening non-existing db
* cmd/utils: rename flag name
* cmd, core: group chain history flags and fix tests
* core, eth, trie: fix memory leak in snapshot generation
* cmd, eth, internal: deprecate flags
* all: enable state tests for pathdb, fixes
* cmd, core: polish code
* trie/triedb/pathdb: limit the node buffer size to 256mb
---------
Co-authored-by: Martin Holst Swende <martin@swende.se>
Co-authored-by: Péter Szilágyi <peterke@gmail.com>
2023-08-10 14:21:36 -05:00
|
|
|
func (t *BlockTest) Run(snapshotter bool, scheme string, tracer vm.EVMLogger) error {
|
2017-08-10 04:38:17 -05:00
|
|
|
config, ok := Forks[t.json.Network]
|
|
|
|
if !ok {
|
|
|
|
return UnsupportedForkError{t.json.Network}
|
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
// import pre accounts & construct test genesis block & state root
|
all: activate pbss as experimental feature (#26274)
* all: activate pbss
* core/rawdb: fix compilation error
* cma, core, eth, les, trie: address comments
* cmd, core, eth, trie: polish code
* core, cmd, eth: address comments
* cmd, core, eth, les, light, tests: address comment
* cmd/utils: shorten log message
* trie/triedb/pathdb: limit node buffer size to 1gb
* cmd/utils: fix opening non-existing db
* cmd/utils: rename flag name
* cmd, core: group chain history flags and fix tests
* core, eth, trie: fix memory leak in snapshot generation
* cmd, eth, internal: deprecate flags
* all: enable state tests for pathdb, fixes
* cmd, core: polish code
* trie/triedb/pathdb: limit the node buffer size to 256mb
---------
Co-authored-by: Martin Holst Swende <martin@swende.se>
Co-authored-by: Péter Szilágyi <peterke@gmail.com>
2023-08-10 14:21:36 -05:00
|
|
|
var (
|
|
|
|
db = rawdb.NewMemoryDatabase()
|
|
|
|
tconf = &trie.Config{}
|
|
|
|
)
|
|
|
|
if scheme == rawdb.PathScheme {
|
|
|
|
tconf.PathDB = pathdb.Defaults
|
|
|
|
} else {
|
|
|
|
tconf.HashDB = hashdb.Defaults
|
|
|
|
}
|
|
|
|
// Commit genesis state
|
2022-08-30 11:22:28 -05:00
|
|
|
gspec := t.genesis(config)
|
all: activate pbss as experimental feature (#26274)
* all: activate pbss
* core/rawdb: fix compilation error
* cma, core, eth, les, trie: address comments
* cmd, core, eth, trie: polish code
* core, cmd, eth: address comments
* cmd, core, eth, les, light, tests: address comment
* cmd/utils: shorten log message
* trie/triedb/pathdb: limit node buffer size to 1gb
* cmd/utils: fix opening non-existing db
* cmd/utils: rename flag name
* cmd, core: group chain history flags and fix tests
* core, eth, trie: fix memory leak in snapshot generation
* cmd, eth, internal: deprecate flags
* all: enable state tests for pathdb, fixes
* cmd, core: polish code
* trie/triedb/pathdb: limit the node buffer size to 256mb
---------
Co-authored-by: Martin Holst Swende <martin@swende.se>
Co-authored-by: Péter Szilágyi <peterke@gmail.com>
2023-08-10 14:21:36 -05:00
|
|
|
triedb := trie.NewDatabase(db, tconf)
|
|
|
|
gblock, err := gspec.Commit(db, triedb)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
triedb.Close() // close the db to prevent memory leak
|
|
|
|
|
2017-07-11 06:49:14 -05:00
|
|
|
if gblock.Hash() != t.json.Genesis.Hash {
|
2018-05-02 03:20:19 -05:00
|
|
|
return fmt.Errorf("genesis block hash doesn't match test: computed=%x, test=%x", gblock.Hash().Bytes()[:6], t.json.Genesis.Hash[:6])
|
2015-06-10 11:04:56 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if gblock.Root() != t.json.Genesis.StateRoot {
|
|
|
|
return fmt.Errorf("genesis block state root does not match test: computed=%x, test=%x", gblock.Root().Bytes()[:6], t.json.Genesis.StateRoot[:6])
|
2015-06-10 11:04:56 -05:00
|
|
|
}
|
2022-12-20 08:56:52 -06:00
|
|
|
// Wrap the original engine within the beacon-engine
|
2023-05-03 04:58:39 -05:00
|
|
|
engine := beacon.New(ethash.NewFaker())
|
2022-12-20 08:56:52 -06:00
|
|
|
|
all: activate pbss as experimental feature (#26274)
* all: activate pbss
* core/rawdb: fix compilation error
* cma, core, eth, les, trie: address comments
* cmd, core, eth, trie: polish code
* core, cmd, eth: address comments
* cmd, core, eth, les, light, tests: address comment
* cmd/utils: shorten log message
* trie/triedb/pathdb: limit node buffer size to 1gb
* cmd/utils: fix opening non-existing db
* cmd/utils: rename flag name
* cmd, core: group chain history flags and fix tests
* core, eth, trie: fix memory leak in snapshot generation
* cmd, eth, internal: deprecate flags
* all: enable state tests for pathdb, fixes
* cmd, core: polish code
* trie/triedb/pathdb: limit the node buffer size to 256mb
---------
Co-authored-by: Martin Holst Swende <martin@swende.se>
Co-authored-by: Péter Szilágyi <peterke@gmail.com>
2023-08-10 14:21:36 -05:00
|
|
|
cache := &core.CacheConfig{TrieCleanLimit: 0, StateScheme: scheme}
|
2020-03-03 01:10:23 -06:00
|
|
|
if snapshotter {
|
|
|
|
cache.SnapshotLimit = 1
|
|
|
|
cache.SnapshotWait = true
|
|
|
|
}
|
2023-06-06 03:27:40 -05:00
|
|
|
chain, err := core.NewBlockChain(db, cache, gspec, nil, engine, vm.Config{
|
|
|
|
Tracer: tracer,
|
|
|
|
}, nil, nil)
|
2015-06-10 11:04:56 -05:00
|
|
|
if err != nil {
|
2015-10-06 09:35:55 -05:00
|
|
|
return err
|
2015-06-10 11:04:56 -05:00
|
|
|
}
|
2017-02-20 04:54:23 -06:00
|
|
|
defer chain.Stop()
|
2016-03-21 17:00:39 -05:00
|
|
|
|
2017-07-11 06:49:14 -05:00
|
|
|
validBlocks, err := t.insertBlocks(chain)
|
2015-06-10 11:04:56 -05:00
|
|
|
if err != nil {
|
2015-06-10 15:10:33 -05:00
|
|
|
return err
|
2015-06-10 11:04:56 -05:00
|
|
|
}
|
2018-01-30 10:39:32 -06:00
|
|
|
cmlast := chain.CurrentBlock().Hash()
|
2017-07-11 06:49:14 -05:00
|
|
|
if common.Hash(t.json.BestBlock) != cmlast {
|
|
|
|
return fmt.Errorf("last block hash validation mismatch: want: %x, have: %x", t.json.BestBlock, cmlast)
|
2015-09-18 10:15:59 -05:00
|
|
|
}
|
2016-03-21 17:00:39 -05:00
|
|
|
newDB, err := chain.State()
|
2015-10-06 09:35:55 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if err = t.validatePostState(newDB); err != nil {
|
2015-06-10 15:10:33 -05:00
|
|
|
return fmt.Errorf("post state validation failed: %v", err)
|
2015-06-10 11:04:56 -05:00
|
|
|
}
|
2020-03-31 03:25:41 -05:00
|
|
|
// Cross-check the snapshot-to-hash against the trie hash
|
|
|
|
if snapshotter {
|
2023-03-02 00:29:15 -06:00
|
|
|
if err := chain.Snapshots().Verify(chain.CurrentBlock().Root); err != nil {
|
2020-04-29 04:53:08 -05:00
|
|
|
return err
|
2020-03-31 03:25:41 -05:00
|
|
|
}
|
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
return t.validateImportedHeaders(chain, validBlocks)
|
2015-06-10 11:04:56 -05:00
|
|
|
}
|
|
|
|
|
2017-07-11 06:49:14 -05:00
|
|
|
func (t *BlockTest) genesis(config *params.ChainConfig) *core.Genesis {
|
|
|
|
return &core.Genesis{
|
|
|
|
Config: config,
|
|
|
|
Nonce: t.json.Genesis.Nonce.Uint64(),
|
2019-04-02 15:28:48 -05:00
|
|
|
Timestamp: t.json.Genesis.Timestamp,
|
2017-07-11 06:49:14 -05:00
|
|
|
ParentHash: t.json.Genesis.ParentHash,
|
|
|
|
ExtraData: t.json.Genesis.ExtraData,
|
2017-11-13 05:47:27 -06:00
|
|
|
GasLimit: t.json.Genesis.GasLimit,
|
|
|
|
GasUsed: t.json.Genesis.GasUsed,
|
2017-07-11 06:49:14 -05:00
|
|
|
Difficulty: t.json.Genesis.Difficulty,
|
|
|
|
Mixhash: t.json.Genesis.MixHash,
|
|
|
|
Coinbase: t.json.Genesis.Coinbase,
|
|
|
|
Alloc: t.json.Pre,
|
2021-07-29 07:05:22 -05:00
|
|
|
BaseFee: t.json.Genesis.BaseFeePerGas,
|
2015-03-20 03:10:13 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-10 06:25:40 -05:00
|
|
|
/*
|
|
|
|
See https://github.com/ethereum/tests/wiki/Blockchain-Tests-II
|
2015-04-20 11:14:57 -05:00
|
|
|
|
2022-09-10 06:25:40 -05:00
|
|
|
Whether a block is valid or not is a bit subtle, it's defined by presence of
|
|
|
|
blockHeader, transactions and uncleHeaders fields. If they are missing, the block is
|
|
|
|
invalid and we must verify that we do not accept it.
|
2015-04-20 11:14:57 -05:00
|
|
|
|
2022-09-10 06:25:40 -05:00
|
|
|
Since some tests mix valid and invalid blocks we need to check this for every block.
|
2015-04-20 11:14:57 -05:00
|
|
|
|
2022-09-10 06:25:40 -05:00
|
|
|
If a block is invalid it does not necessarily fail the test, if it's invalidness is
|
|
|
|
expected we are expected to ignore it and continue processing and then validate the
|
|
|
|
post state.
|
2015-04-20 11:14:57 -05:00
|
|
|
*/
|
2017-07-11 06:49:14 -05:00
|
|
|
func (t *BlockTest) insertBlocks(blockchain *core.BlockChain) ([]btBlock, error) {
|
2015-09-18 10:15:59 -05:00
|
|
|
validBlocks := make([]btBlock, 0)
|
2015-04-20 11:14:57 -05:00
|
|
|
// insert the test blocks, which will execute all transactions
|
2021-06-07 07:37:56 -05:00
|
|
|
for bi, b := range t.json.Blocks {
|
2017-07-11 06:49:14 -05:00
|
|
|
cb, err := b.decode()
|
2015-04-20 11:14:57 -05:00
|
|
|
if err != nil {
|
|
|
|
if b.BlockHeader == nil {
|
|
|
|
continue // OK - block is supposed to be invalid, continue with next block
|
|
|
|
} else {
|
2019-11-23 05:51:37 -06:00
|
|
|
return nil, fmt.Errorf("block RLP decoding failed when expected to succeed: %v", err)
|
2015-04-20 11:14:57 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// RLP decoding worked, try to insert into chain:
|
2016-01-19 16:48:50 -06:00
|
|
|
blocks := types.Blocks{cb}
|
|
|
|
i, err := blockchain.InsertChain(blocks)
|
2015-04-20 11:14:57 -05:00
|
|
|
if err != nil {
|
|
|
|
if b.BlockHeader == nil {
|
|
|
|
continue // OK - block is supposed to be invalid, continue with next block
|
|
|
|
} else {
|
2019-11-23 05:51:37 -06:00
|
|
|
return nil, fmt.Errorf("block #%v insertion into chain failed: %v", blocks[i].Number(), err)
|
2015-04-20 11:14:57 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if b.BlockHeader == nil {
|
2021-06-07 07:37:56 -05:00
|
|
|
if data, err := json.MarshalIndent(cb.Header(), "", " "); err == nil {
|
|
|
|
fmt.Fprintf(os.Stderr, "block (index %d) insertion should have failed due to: %v:\n%v\n",
|
|
|
|
bi, b.ExpectException, string(data))
|
|
|
|
}
|
|
|
|
return nil, fmt.Errorf("block (index %d) insertion should have failed due to: %v",
|
|
|
|
bi, b.ExpectException)
|
2015-04-20 11:14:57 -05:00
|
|
|
}
|
2015-09-14 07:27:25 -05:00
|
|
|
|
|
|
|
// validate RLP decoding by checking all values against test file JSON
|
2015-09-18 10:15:59 -05:00
|
|
|
if err = validateHeader(b.BlockHeader, cb.Header()); err != nil {
|
2019-11-23 05:51:37 -06:00
|
|
|
return nil, fmt.Errorf("deserialised block header validation failed: %v", err)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2015-09-18 10:15:59 -05:00
|
|
|
validBlocks = append(validBlocks, b)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2015-09-18 10:15:59 -05:00
|
|
|
return validBlocks, nil
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
|
|
|
|
2015-09-18 10:15:59 -05:00
|
|
|
func validateHeader(h *btHeader, h2 *types.Header) error {
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.Bloom != h2.Bloom {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("bloom: want: %x have: %x", h.Bloom, h2.Bloom)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.Coinbase != h2.Coinbase {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("coinbase: want: %x have: %x", h.Coinbase, h2.Coinbase)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.MixHash != h2.MixDigest {
|
|
|
|
return fmt.Errorf("MixHash: want: %x have: %x", h.MixHash, h2.MixDigest)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.Nonce != h2.Nonce {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("nonce: want: %x have: %x", h.Nonce, h2.Nonce)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.Number.Cmp(h2.Number) != 0 {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("number: want: %v have: %v", h.Number, h2.Number)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.ParentHash != h2.ParentHash {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("parent hash: want: %x have: %x", h.ParentHash, h2.ParentHash)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.ReceiptTrie != h2.ReceiptHash {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("receipt hash: want: %x have: %x", h.ReceiptTrie, h2.ReceiptHash)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.TransactionsTrie != h2.TxHash {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("tx hash: want: %x have: %x", h.TransactionsTrie, h2.TxHash)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.StateRoot != h2.Root {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("state hash: want: %x have: %x", h.StateRoot, h2.Root)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.UncleHash != h2.UncleHash {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("uncle hash: want: %x have: %x", h.UncleHash, h2.UncleHash)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if !bytes.Equal(h.ExtraData, h2.Extra) {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("extra data: want: %x have: %x", h.ExtraData, h2.Extra)
|
2015-04-17 09:30:15 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if h.Difficulty.Cmp(h2.Difficulty) != 0 {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("difficulty: want: %v have: %v", h.Difficulty, h2.Difficulty)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-11-13 05:47:27 -06:00
|
|
|
if h.GasLimit != h2.GasLimit {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("gasLimit: want: %d have: %d", h.GasLimit, h2.GasLimit)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2017-11-13 05:47:27 -06:00
|
|
|
if h.GasUsed != h2.GasUsed {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("gasUsed: want: %d have: %d", h.GasUsed, h2.GasUsed)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2019-04-02 15:28:48 -05:00
|
|
|
if h.Timestamp != h2.Time {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("timestamp: want: %v have: %v", h.Timestamp, h2.Time)
|
2015-04-22 21:38:47 -05:00
|
|
|
}
|
2023-02-06 13:52:51 -06:00
|
|
|
if !reflect.DeepEqual(h.BaseFeePerGas, h2.BaseFee) {
|
|
|
|
return fmt.Errorf("baseFeePerGas: want: %v have: %v", h.BaseFeePerGas, h2.BaseFee)
|
|
|
|
}
|
|
|
|
if !reflect.DeepEqual(h.WithdrawalsRoot, h2.WithdrawalsHash) {
|
|
|
|
return fmt.Errorf("withdrawalsRoot: want: %v have: %v", h.WithdrawalsRoot, h2.WithdrawalsHash)
|
|
|
|
}
|
2015-04-20 11:14:57 -05:00
|
|
|
return nil
|
2015-04-17 09:30:15 -05:00
|
|
|
}
|
|
|
|
|
2017-07-11 06:49:14 -05:00
|
|
|
func (t *BlockTest) validatePostState(statedb *state.StateDB) error {
|
2015-09-14 07:27:25 -05:00
|
|
|
// validate post state accounts in test file against what we have in state db
|
2017-07-11 06:49:14 -05:00
|
|
|
for addr, acct := range t.json.Post {
|
2015-03-20 03:10:13 -05:00
|
|
|
// address is indirectly verified by the other fields, as it's the db key
|
2017-07-11 06:49:14 -05:00
|
|
|
code2 := statedb.GetCode(addr)
|
|
|
|
balance2 := statedb.GetBalance(addr)
|
|
|
|
nonce2 := statedb.GetNonce(addr)
|
|
|
|
if !bytes.Equal(code2, acct.Code) {
|
|
|
|
return fmt.Errorf("account code mismatch for addr: %s want: %v have: %s", addr, acct.Code, hex.EncodeToString(code2))
|
2015-03-20 03:10:13 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if balance2.Cmp(acct.Balance) != 0 {
|
|
|
|
return fmt.Errorf("account balance mismatch for addr: %s, want: %d, have: %d", addr, acct.Balance, balance2)
|
2015-03-20 03:10:13 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
if nonce2 != acct.Nonce {
|
|
|
|
return fmt.Errorf("account nonce mismatch for addr: %s want: %d have: %d", addr, acct.Nonce, nonce2)
|
2015-03-20 03:10:13 -05:00
|
|
|
}
|
2015-03-13 12:01:51 -05:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-07-11 06:49:14 -05:00
|
|
|
func (t *BlockTest) validateImportedHeaders(cm *core.BlockChain, validBlocks []btBlock) error {
|
2015-09-18 10:15:59 -05:00
|
|
|
// to get constant lookup when verifying block headers by hash (some tests have many blocks)
|
2017-07-11 06:49:14 -05:00
|
|
|
bmap := make(map[common.Hash]btBlock, len(t.json.Blocks))
|
2015-09-18 10:15:59 -05:00
|
|
|
for _, b := range validBlocks {
|
|
|
|
bmap[b.BlockHeader.Hash] = b
|
|
|
|
}
|
|
|
|
// iterate over blocks backwards from HEAD and validate imported
|
|
|
|
// headers vs test file. some tests have reorgs, and we import
|
|
|
|
// block-by-block, so we can only validate imported headers after
|
2017-07-11 06:49:14 -05:00
|
|
|
// all blocks have been processed by BlockChain, as they may not
|
2015-09-18 10:15:59 -05:00
|
|
|
// be part of the longest chain until last block is imported.
|
2023-03-02 00:29:15 -06:00
|
|
|
for b := cm.CurrentBlock(); b != nil && b.Number.Uint64() != 0; b = cm.GetBlockByHash(b.ParentHash).Header() {
|
|
|
|
if err := validateHeader(bmap[b.Hash()].BlockHeader, b); err != nil {
|
2019-11-23 05:51:37 -06:00
|
|
|
return fmt.Errorf("imported block header validation failed: %v", err)
|
2015-09-18 10:15:59 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-07-11 06:49:14 -05:00
|
|
|
func (bb *btBlock) decode() (*types.Block, error) {
|
|
|
|
data, err := hexutil.Decode(bb.Rlp)
|
2015-03-13 12:01:51 -05:00
|
|
|
if err != nil {
|
2015-06-10 17:11:30 -05:00
|
|
|
return nil, err
|
2015-03-13 12:01:51 -05:00
|
|
|
}
|
2017-07-11 06:49:14 -05:00
|
|
|
var b types.Block
|
|
|
|
err = rlp.DecodeBytes(data, &b)
|
|
|
|
return &b, err
|
2015-04-15 15:37:16 -05:00
|
|
|
}
|