Extend devnet test coverage (#19334)

This extends TestExecutionSpecBlockchainDevnet and has a technical fix
which was preventing the paris tests from running caused by a deadlick
from runing the parallel executor on domains in parallel tests.

The hang is due to code in shared domains, so likley causes hangs in
parallel runs with a serial executor. I have not investigated why
multiple tests are run whith the same domain, becuase this does not
cause logical errors, but conceivaly could do.

Author: mh0lt

db/kv/kv_interface.go

@@ -487,6 +487,7 @@ type TemporalMemBatch interface {
 	ClearRam()
 	IndexAdd(table InvertedIdx, key []byte, txNum uint64) (err error)
 	IteratePrefix(domain Domain, prefix []byte, roTx Tx, it func(k []byte, v []byte, step Step) (cont bool, err error)) error
+	HasPrefix(domain Domain, prefix []byte, roTx Tx) ([]byte, []byte, bool, error)
 	SizeEstimate() uint64
 	Flush(ctx context.Context, tx RwTx) error
 	Close()

db/state/execctx/domain_shared.go

@@ -337,22 +337,7 @@ func (sd *SharedDomains) SetTrace(b, capture bool) []string {
 }
 
 func (sd *SharedDomains) HasPrefix(domain kv.Domain, prefix []byte, roTx kv.Tx) ([]byte, []byte, bool, error) {
-	var firstKey, firstVal []byte
-	var hasPrefix bool
-	err := sd.IteratePrefix(domain, prefix, roTx, func(k []byte, v []byte, step kv.Step) (bool, error) {
-		// we need to do this to ensure the value has not been unwound
-		if lv, _, ok := sd.mem.GetLatest(domain, k); ok {
-			v = lv
-		}
-		if len(v) > 0 {
-			firstKey = common.Copy(k)
-			firstVal = common.Copy(v)
-			hasPrefix = true
-			return false, nil // do not continue, end on first occurrence
-		}
-		return true, nil
-	})
-	return firstKey, firstVal, hasPrefix, err
+	return sd.mem.HasPrefix(domain, prefix, roTx)
 }
 
 func (sd *SharedDomains) IteratePrefix(domain kv.Domain, prefix []byte, roTx kv.Tx, it func(k []byte, v []byte, step kv.Step) (cont bool, err error)) error {

db/state/temporal_mem_batch.go

@@ -175,7 +175,13 @@ func (sd *TemporalMemBatch) putLatest(domain kv.Domain, key string, val []byte,
 func (sd *TemporalMemBatch) GetLatest(domain kv.Domain, key []byte) (v []byte, step kv.Step, ok bool) {
 	sd.latestStateLock.RLock()
 	defer sd.latestStateLock.RUnlock()
+	return sd.getLatest(domain, key)
+}
 
+// getLatest is the lock-free implementation of GetLatest.
+// The caller must already hold latestStateLock (either RLock or Lock),
+// e.g. from within an IteratePrefix callback.
+func (sd *TemporalMemBatch) getLatest(domain kv.Domain, key []byte) (v []byte, step kv.Step, ok bool) {
 	var unwoundLatest = func(domain kv.Domain, key string) (v []byte, step kv.Step, ok bool) {
 		if sd.unwindChangeset != nil {
 			if values := sd.unwindChangeset[domain]; values != nil {
@@ -294,6 +300,24 @@ func (sd *TemporalMemBatch) IteratePrefix(domain kv.Domain, prefix []byte, roTx
 	return AggTx(roTx).d[domain].debugIteratePrefixLatest(prefix, ramIter, it, roTx)
 }
 
+func (sd *TemporalMemBatch) HasPrefix(domain kv.Domain, prefix []byte, roTx kv.Tx) ([]byte, []byte, bool, error) {
+	var firstKey, firstVal []byte
+	var hasPrefix bool
+	err := sd.IteratePrefix(domain, prefix, roTx, func(k []byte, v []byte, step kv.Step) (bool, error) {
+		if lv, _, ok := sd.getLatest(domain, k); ok {
+			v = lv
+		}
+		if len(v) > 0 {
+			firstKey = common.Copy(k)
+			firstVal = common.Copy(v)
+			hasPrefix = true
+			return false, nil // do not continue, end on first occurrence
+		}
+		return true, nil
+	})
+	return firstKey, firstVal, hasPrefix, err
+}
+
 func (sd *TemporalMemBatch) SetChangesetAccumulator(acc *changeset.StateChangeSet) {
 	sd.currentChangesAccumulator = acc
 	for idx := range sd.domainWriters {

execution/state/journal.go

@@ -237,7 +237,7 @@ func (ch selfdestructChange) revert(s *IntraBlockState) error {
 			if ch.wasCommited {
 				if trace {
 					if v, ok := s.versionedWrites[ch.account][AccountKey{Path: SelfDestructPath}]; ok {
-						fmt.Printf("%s WRT Revert %x: %d -> %d\n", tracePrefix, ch.account, v.Val, &ch.prev)
+						fmt.Printf("%s WRT Revert %x: %v -> %v\n", tracePrefix, ch.account, v.Val, &ch.prev)
 					}
 					if v, ok := s.versionedWrites[ch.account][AccountKey{Path: BalancePath}]; ok {
 						val := v.Val.(uint256.Int)
@@ -248,12 +248,16 @@ func (ch selfdestructChange) revert(s *IntraBlockState) error {
 				s.versionedWrites.Delete(ch.account, AccountKey{Path: SelfDestructPath})
 			} else {
 				if v, ok := s.versionedWrites[ch.account][AccountKey{Path: SelfDestructPath}]; ok {
-					fmt.Printf("%s WRT Revert %x: %d -> %d\n", tracePrefix, ch.account, v.Val, &ch.prev)
+					if trace {
+						fmt.Printf("%s WRT Revert %x: %v -> %v\n", tracePrefix, ch.account, v.Val, &ch.prev)
+					}
 					v.Val = ch.prev
 				}
 				if v, ok := s.versionedWrites[ch.account][AccountKey{Path: BalancePath}]; ok {
 					val := v.Val.(uint256.Int)
-					fmt.Printf("%s WRT Revert %x: %d -> %d\n", tracePrefix, ch.account, &val, &ch.prevbalance)
+					if trace {
+						fmt.Printf("%s WRT Revert %x: %d -> %d\n", tracePrefix, ch.account, &val, &ch.prevbalance)
+					}
 					v.Val = ch.prevbalance
 				}
 			}

execution/tests/block_test.go

@@ -25,7 +25,6 @@ import (
 	"testing"
 
 	"github.com/erigontech/erigon/common/log/v3"
-	"github.com/erigontech/erigon/common/race"
 	"github.com/erigontech/erigon/execution/tests/testutil"
 )
 
@@ -104,9 +103,9 @@ func TestExecutionSpecBlockchainDevnet(t *testing.T) {
 	if testing.Short() {
 		t.Skip()
 	}
-	if race.Enabled {
-		// TODO fix -race issues with parallel exec
-		//		t.Skip("skipping from race tests until parallel exec flow is race free")
+	if runtime.GOOS == "windows" {
+		// TODO(yperbasis, mh0lt)
+		t.Skip("fix me on windows please")
 	}
 
 	t.Parallel()
@@ -116,7 +115,58 @@ func TestExecutionSpecBlockchainDevnet(t *testing.T) {
 	bt := new(testMatcher)
 	// to run only tests for 1 eip do:
 	//bt.whitelist(`.*amsterdam/eip8024_dupn_swapn_exchange.*`)
-	bt.whitelist(`.*amsterdam.*`) // TODO run tests for older forks too once we fix amsterdam eips, for now focus only on amsterdam eips
+
+	// byzantium — BAL mismatch
+	bt.skipLoad(`^byzantium/eip214_staticcall/test_staticcall_call_to_precompile.json`)
+	bt.skipLoad(`^byzantium/eip214_staticcall/test_staticcall_call_to_precompile_from_contract_init.json`)
+	bt.skipLoad(`^byzantium/eip214_staticcall/test_staticcall_nested_call_to_precompile.json`)
+	bt.skipLoad(`^byzantium/eip214_staticcall/test_staticcall_reentrant_call_to_precompile.json`)
+
+	// cancun — BAL mismatch
+	bt.skipLoad(`^cancun/create/test_create_oog_from_eoa_refunds.json`)
+	bt.skipLoad(`^cancun/eip4844_blobs/test_correct_decreasing_blob_gas_costs.json`)
+	bt.skipLoad(`^cancun/eip4844_blobs/test_correct_increasing_blob_gas_costs.json`)
+	bt.skipLoad(`^cancun/eip6780_selfdestruct/test_dynamic_create2_selfdestruct_collision_multi_tx.json`)
+	bt.skipLoad(`^cancun/eip6780_selfdestruct/test_dynamic_create2_selfdestruct_collision_two_different_transactions.json`)
+	bt.skipLoad(`^cancun/eip6780_selfdestruct/test_self_destructing_initcode.json`)
+	bt.skipLoad(`^cancun/eip6780_selfdestruct/test_selfdestruct_created_in_same_tx_with_revert.json`)
+	bt.skipLoad(`^cancun/eip6780_selfdestruct/test_selfdestruct_not_created_in_same_tx_with_revert.json`)
+
+	// frontier — BAL mismatch
+	bt.skipLoad(`^frontier/identity_precompile/test_call_identity_precompile.json`)
+	bt.skipLoad(`^frontier/scenarios/test_scenarios.json`)
+
+	// osaka — BAL mismatch
+	bt.skipLoad(`^osaka/eip7918_blob_reserve_price/test_reserve_price_boundary.json`)
+
+	// paris — BAL mismatch
+	bt.skipLoad(`^paris/security/test_tx_selfdestruct_balance_bug.json`)
+
+	// prague — invalid state root hash
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_call_pointer_to_created_from_create_after_oog_call_again.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_call_to_precompile_in_pointer_context.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_delegated_eoa_can_send_creating_tx.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_delegation_clearing.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_delegation_clearing_and_set.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_delegation_clearing_tx_to.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_delegation_replacement_call_previous_contract.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_pointer_contract_pointer_loop.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_pointer_normal.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_pointer_resets_an_empty_code_account_with_storage.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_pointer_reverts.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_pointer_to_pointer.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_pointer_to_precompile.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_pointer_to_static.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_pointer_to_static_reentry.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_reset_code.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_self_sponsored_set_code.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_set_code_to_sstore.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_set_code_to_sstore_then_sload.json`)
+	bt.skipLoad(`^prague/eip7702_set_code_tx/test_static_to_pointer.json`)
+
+	// static — tested in state test format by TestState
+	bt.skipLoad(`^static/state_tests/`)
+
 	bt.walk(t, dir, func(t *testing.T, name string, test *testutil.BlockTest) {
 		// import pre accounts & construct test genesis block & state root
 		test.ExperimentalBAL = true // TODO eventually remove this from BlockTest and run normally