core, miner: cover pipelined SRC branches

Author: pratikspatil024

core/block_validator_test.go

@@ -21,6 +21,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/beacon"
@@ -30,6 +32,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/trie"
 )
 
 // Tests that simple header verification works, for both good and bad blocks.
@@ -38,6 +41,50 @@ func TestHeaderVerification(t *testing.T) {
 	testHeaderVerification(t, rawdb.PathScheme)
 }
 
+func TestValidateStateCheap(t *testing.T) {
+	validator := NewBlockValidator(params.TestChainConfig, nil)
+	receipts := []*types.Receipt{{Status: types.ReceiptStatusSuccessful, CumulativeGasUsed: 21_000}}
+	receiptHash := types.DeriveSha(types.Receipts(receipts), trie.NewStackTrie(nil))
+	bloom := types.MergeBloom(receipts)
+
+	newBlock := func() *types.Block {
+		return types.NewBlockWithHeader(&types.Header{
+			Number:      big.NewInt(1),
+			GasUsed:     21_000,
+			Bloom:       bloom,
+			ReceiptHash: receiptHash,
+		})
+	}
+	valid := &ProcessResult{Receipts: receipts, GasUsed: 21_000}
+	require.NoError(t, validator.ValidateStateCheap(newBlock(), nil, valid))
+	require.Error(t, validator.ValidateStateCheap(newBlock(), nil, nil))
+
+	gasMismatch := *valid
+	gasMismatch.GasUsed++
+	require.ErrorIs(t, validator.ValidateStateCheap(newBlock(), nil, &gasMismatch), ErrGasUsedMismatch)
+
+	bloomMismatch := *newBlock().Header()
+	bloomMismatch.Bloom[0] = 1
+	require.ErrorIs(t, validator.ValidateStateCheap(types.NewBlockWithHeader(&bloomMismatch), nil, valid), ErrBloomMismatch)
+
+	receiptMismatch := *newBlock().Header()
+	receiptMismatch.ReceiptHash = common.HexToHash("0x01")
+	require.ErrorIs(t, validator.ValidateStateCheap(types.NewBlockWithHeader(&receiptMismatch), nil, valid), ErrReceiptRootMismatch)
+
+	requests := [][]byte{{1, 2, 3}}
+	requestHash := types.CalcRequestsHash(requests)
+	withRequests := *newBlock().Header()
+	withRequests.RequestsHash = &requestHash
+	validRequests := &ProcessResult{Receipts: receipts, GasUsed: 21_000, Requests: requests}
+	require.NoError(t, validator.ValidateStateCheap(types.NewBlockWithHeader(&withRequests), nil, validRequests))
+
+	requestMismatch := requestHash
+	requestMismatch[0] ^= 1
+	withRequests.RequestsHash = &requestMismatch
+	require.ErrorIs(t, validator.ValidateStateCheap(types.NewBlockWithHeader(&withRequests), nil, validRequests), ErrRequestsHashMismatch)
+	require.EqualError(t, validator.ValidateStateCheap(newBlock(), nil, validRequests), "block has requests before prague fork")
+}
+
 func testHeaderVerification(t *testing.T, scheme string) {
 	// Create a simple chain to verify
 	var (

core/blockchain_test.go

@@ -4304,6 +4304,68 @@ func TestHasStateTreatsRecentPipelinedRootAsAvailable(t *testing.T) {
 	require.False(t, chain.HasRecentPipelinedHeadState(block.Hash(), block.Root()))
 }
 
+func TestPipelinedWitnessWaitPaths(t *testing.T) {
+	_, _, chain, err := newCanonical(ethash.NewFaker(), 0, true, rawdb.HashScheme)
+	require.NoError(t, err)
+	t.Cleanup(chain.Stop)
+	chain.cfg.EnablePipelinedImportSRC = true
+
+	block := types.NewBlockWithHeader(&types.Header{Number: big.NewInt(1)})
+	hash := block.Hash()
+
+	chain.pendingImportSRC = &pendingImportSRCState{
+		block:       block,
+		makeWitness: false,
+		collectedCh: make(chan struct{}),
+	}
+	witness, matched := chain.waitForPendingSRCWitness(hash)
+	require.True(t, matched)
+	require.Nil(t, witness)
+	require.Nil(t, chain.waitForPipelinedWitness(hash))
+
+	chain.pendingImportSRC = &pendingImportSRCState{
+		block:       block,
+		makeWitness: true,
+		collectedCh: make(chan struct{}),
+	}
+	chain.CacheWitness(hash, []byte("witness"))
+	close(chain.pendingImportSRC.collectedCh)
+	witness, matched = chain.waitForPendingSRCWitness(hash)
+	require.True(t, matched)
+	require.Equal(t, []byte("witness"), witness)
+
+	chain.pendingImportSRC = nil
+	chain.pipelinedMakeWitness.Store(false)
+	require.Nil(t, chain.waitForPipelinedWitness(common.HexToHash("0x1234")))
+
+	polledHash := common.HexToHash("0x5678")
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		chain.CacheWitness(polledHash, []byte("polled"))
+	}()
+	require.Equal(t, []byte("polled"), chain.pollWitnessCache(polledHash, time.Second, time.Millisecond))
+}
+
+func TestWithinPipelinedImportStateGrace(t *testing.T) {
+	now := time.Now()
+	tests := []struct {
+		name  string
+		start time.Time
+		want  bool
+	}{
+		{name: "zero", start: time.Time{}, want: false},
+		{name: "future", start: now.Add(time.Nanosecond), want: false},
+		{name: "current", start: now, want: true},
+		{name: "boundary", start: now.Add(-pipelinedImportStateAvailabilityGrace), want: true},
+		{name: "expired", start: now.Add(-pipelinedImportStateAvailabilityGrace - time.Nanosecond), want: false},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			require.Equal(t, test.want, withinPipelinedImportStateGrace(test.start, now))
+		})
+	}
+}
+
 func TestCreateThenDeletePostByzantium(t *testing.T) {
 	t.Parallel()
 	testCreateThenDelete(t, params.TestChainConfig)

core/state/warm_snapshot_test.go

@@ -274,3 +274,47 @@ func TestWarmSnapshot_OwnerScoped(t *testing.T) {
 	_, ok = snap.Lookup(storageOwner, path, crypto.Keccak256Hash(accountBlob))
 	require.False(t, ok, "must not serve account blob to storage owner even when that blob's hash matches expectedHash")
 }
+
+func TestWarmSnapshotInputAndBounds(t *testing.T) {
+	t.Parallel()
+
+	owner := common.HexToHash("0x44")
+	path := []byte{0x01, 0x02}
+	blob := []byte("warm-node")
+	tooLong := make([]byte, 65)
+
+	key, ok := makeWarmKey(owner, path, crypto.Keccak256Hash(blob))
+	require.True(t, ok)
+	require.Equal(t, uint8(len(path)), key.pathLen)
+	_, ok = makeWarmKey(owner, tooLong, common.Hash{})
+	require.False(t, ok)
+
+	require.Nil(t, NewWarmSnapshotInput(nil))
+	var nilInput *WarmSnapshotInput
+	require.Nil(t, nilInput.Build())
+
+	input := NewWarmSnapshotInput([]TrieWarmNodes{{
+		Owner: owner,
+		Nodes: map[string][]byte{
+			string(path):    blob,
+			"empty":         nil,
+			string(tooLong): []byte("ignored"),
+		},
+	}})
+	snapshot := input.Build()
+	require.NotNil(t, snapshot)
+	require.Equal(t, 1, snapshot.Len())
+	require.Equal(t, len(blob), snapshot.SizeBytes())
+
+	got, ok := snapshot.Lookup(owner, path, crypto.Keccak256Hash(blob))
+	require.True(t, ok)
+	require.Equal(t, blob, got)
+	blob[0] = 'X'
+	require.Equal(t, []byte("warm-node"), got)
+	_, ok = snapshot.Lookup(owner, tooLong, common.Hash{})
+	require.False(t, ok)
+
+	var nilSnapshot *WarmSnapshot
+	require.Zero(t, nilSnapshot.Len())
+	require.Zero(t, nilSnapshot.SizeBytes())
+}