Merge remote-tracking branch 'origin/develop' into v2.3.4-candidate

Author: lucca30

consensus/bor/bor.go

@@ -249,6 +249,11 @@ type Bor struct {
 	fakeDiff      bool // Skip difficulty verifications
 	DevFakeAuthor bool
 
+	// The block time defined by the miner. Needs to be larger or equal to the consensus block time. If not set (default = 0), the miner will use the consensus block time.
+	blockTime time.Duration
+
+	lastMinedBlockTime time.Time
+
 	quit      chan struct{}
 	closeOnce sync.Once
 }
@@ -268,6 +273,7 @@ func New(
 	heimdallWSClient IHeimdallWSClient,
 	genesisContracts GenesisContract,
 	devFakeAuthor bool,
+	blockTime time.Duration,
 ) *Bor {
 	// get bor config
 	borConfig := chainConfig.Bor
@@ -308,6 +314,7 @@ func New(
 		HeimdallWSClient:       heimdallWSClient,
 		spanStore:              spanStore,
 		DevFakeAuthor:          devFakeAuthor,
+		blockTime:              blockTime,
 		quit:                   make(chan struct{}),
 	}
 
@@ -986,17 +993,34 @@ func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header) e
 		}
 	}
 
-	header.Time = parent.Time + CalcProducerDelay(number, succession, c.config)
+	if c.blockTime > 0 && uint64(c.blockTime.Seconds()) < c.config.CalculatePeriod(number) {
+		return fmt.Errorf("the floor of custom mining block time (%v) is less than the consensus block time: %v < %v", c.blockTime, c.blockTime.Seconds(), c.config.CalculatePeriod(number))
+	}
+
+	if c.blockTime > 0 && c.config.IsRio(header.Number) {
+		// Only enable custom block time for Rio and later
+		parentActualTime := c.lastMinedBlockTime
+		if parentActualTime.IsZero() || parentActualTime.Before(time.Unix(int64(parent.Time), 0)) {
+			parentActualTime = time.Unix(int64(parent.Time), 0)
+		}
+		actualNewBlockTime := parentActualTime.Add(c.blockTime)
+		c.lastMinedBlockTime = actualNewBlockTime
+		header.Time = uint64(actualNewBlockTime.Unix())
+		header.ActualTime = actualNewBlockTime
+	} else {
+		header.Time = parent.Time + CalcProducerDelay(number, succession, c.config)
+	}
+
 	if header.Time < uint64(time.Now().Unix()) {
-		header.Time = uint64(time.Now().Unix()) + CalcProducerDelay(number, succession, c.config)
+		header.Time = uint64(time.Now().Unix())
 	} else {
 		// For primary validators, wait until the current block production window
 		// starts. This prevents bor from starting to build next block before time
 		// as we'd like to wait for new transactions. Although this change doesn't
 		// need a check for hard fork as it doesn't change any consensus rules, we
 		// still keep it for safety and testing.
 		if c.config.IsBhilai(big.NewInt(int64(number))) && succession == 0 {
-			startTime := time.Unix(int64(header.Time-c.config.CalculatePeriod(number)), 0)
+			startTime := header.GetActualTime().Add(-time.Duration(c.config.CalculatePeriod(number)) * time.Second)
 			time.Sleep(time.Until(startTime))
 		}
 	}
@@ -1202,15 +1226,15 @@ func (c *Bor) Seal(chain consensus.ChainHeaderReader, block *types.Block, witnes
 
 	// Sweet, the protocol permits us to sign the block, wait for our time
 	if c.config.IsBhilai(header.Number) {
-		delay = time.Until(time.Unix(int64(header.Time), 0)) // Wait until we reach header time for non-primary validators
+		delay = time.Until(header.GetActualTime()) // Wait until we reach header time for non-primary validators
 		// Disable early block announcement
 		// if successionNumber == 0 {
 		// 	// For primary producers, set the delay to `header.Time - block time` instead of `header.Time`
 		// 	// for early block announcement instead of waiting for full block time.
 		// 	delay = time.Until(time.Unix(int64(header.Time-c.config.CalculatePeriod(number)), 0))
 		// }
 	} else {
-		delay = time.Until(time.Unix(int64(header.Time), 0)) // Wait until we reach header time
+		delay = time.Until(header.GetActualTime()) // Wait until we reach header time
 	}
 
 	// wiggle was already accounted for in header.Time, this is just for logging

consensus/bor/bor_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"math/big"
 	"testing"
+	"time"
 
 	"github.com/holiman/uint256"
 	"github.com/stretchr/testify/require"
@@ -530,3 +531,204 @@ func TestSnapshot(t *testing.T) {
 		})
 	}
 }
+
+func TestCustomBlockTimeValidation(t *testing.T) {
+	t.Parallel()
+
+	addr1 := common.HexToAddress("0x1")
+
+	testCases := []struct {
+		name            string
+		blockTime       time.Duration
+		consensusPeriod uint64
+		blockNumber     uint64
+		expectError     bool
+		description     string
+	}{
+		{
+			name:            "blockTime is zero (default) - should succeed",
+			blockTime:       0,
+			consensusPeriod: 2,
+			blockNumber:     1,
+			expectError:     false,
+			description:     "Default blockTime of 0 should use standard consensus delay",
+		},
+		{
+			name:            "blockTime equals consensus period - should succeed",
+			blockTime:       2 * time.Second,
+			consensusPeriod: 2,
+			blockNumber:     1,
+			expectError:     false,
+			description:     "Custom blockTime equal to consensus period should be valid",
+		},
+		{
+			name:            "blockTime greater than consensus period - should succeed",
+			blockTime:       5 * time.Second,
+			consensusPeriod: 2,
+			blockNumber:     1,
+			expectError:     false,
+			description:     "Custom blockTime greater than consensus period should be valid",
+		},
+		{
+			name:            "blockTime less than consensus period - should fail",
+			blockTime:       1 * time.Second,
+			consensusPeriod: 2,
+			blockNumber:     1,
+			expectError:     true,
+			description:     "Custom blockTime less than consensus period should be invalid",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			sp := &fakeSpanner{vals: []*valset.Validator{{Address: addr1, VotingPower: 1}}}
+			borCfg := &params.BorConfig{
+				Sprint:   map[string]uint64{"0": 64},
+				Period:   map[string]uint64{"0": tc.consensusPeriod},
+				RioBlock: big.NewInt(0), // Enable Rio from genesis
+			}
+			chain, b := newChainAndBorForTest(t, sp, borCfg, true, addr1)
+			b.blockTime = tc.blockTime
+
+			// Get genesis block as parent
+			genesis := chain.HeaderChain().GetHeaderByNumber(0)
+			require.NotNil(t, genesis)
+
+			header := &types.Header{
+				Number:     big.NewInt(int64(tc.blockNumber)),
+				ParentHash: genesis.Hash(),
+			}
+
+			err := b.Prepare(chain.HeaderChain(), header)
+
+			if tc.expectError {
+				require.Error(t, err, tc.description)
+				require.Contains(t, err.Error(), "less than the consensus block time", tc.description)
+			} else {
+				require.NoError(t, err, tc.description)
+			}
+		})
+	}
+}
+
+func TestCustomBlockTimeCalculation(t *testing.T) {
+	t.Parallel()
+
+	addr1 := common.HexToAddress("0x1")
+
+	t.Run("sequential blocks with custom blockTime", func(t *testing.T) {
+		sp := &fakeSpanner{vals: []*valset.Validator{{Address: addr1, VotingPower: 1}}}
+		borCfg := &params.BorConfig{
+			Sprint:   map[string]uint64{"0": 64},
+			Period:   map[string]uint64{"0": 2},
+			RioBlock: big.NewInt(0),
+		}
+		chain, b := newChainAndBorForTest(t, sp, borCfg, true, addr1)
+		b.blockTime = 5 * time.Second
+
+		genesis := chain.HeaderChain().GetHeaderByNumber(0)
+		require.NotNil(t, genesis)
+		baseTime := genesis.Time
+
+		header1 := &types.Header{
+			Number:     big.NewInt(1),
+			ParentHash: genesis.Hash(),
+		}
+		err := b.Prepare(chain.HeaderChain(), header1)
+		require.NoError(t, err)
+
+		require.False(t, header1.ActualTime.IsZero(), "ActualTime should be set")
+		expectedTime := time.Unix(int64(baseTime), 0).Add(5 * time.Second)
+		require.Equal(t, expectedTime.Unix(), header1.ActualTime.Unix())
+	})
+
+	t.Run("lastMinedBlockTime is zero (first block)", func(t *testing.T) {
+		sp := &fakeSpanner{vals: []*valset.Validator{{Address: addr1, VotingPower: 1}}}
+		borCfg := &params.BorConfig{
+			Sprint:   map[string]uint64{"0": 64},
+			Period:   map[string]uint64{"0": 2},
+			RioBlock: big.NewInt(0),
+		}
+		chain, b := newChainAndBorForTest(t, sp, borCfg, true, addr1)
+		b.blockTime = 3 * time.Second
+
+		genesis := chain.HeaderChain().GetHeaderByNumber(0)
+		require.NotNil(t, genesis)
+		baseTime := genesis.Time
+
+		header := &types.Header{
+			Number:     big.NewInt(1),
+			ParentHash: genesis.Hash(),
+		}
+
+		err := b.Prepare(chain.HeaderChain(), header)
+		require.NoError(t, err)
+
+		expectedTime := time.Unix(int64(baseTime), 0).Add(3 * time.Second)
+		require.Equal(t, expectedTime.Unix(), header.ActualTime.Unix())
+	})
+
+	t.Run("lastMinedBlockTime before parent time (fallback)", func(t *testing.T) {
+		sp := &fakeSpanner{vals: []*valset.Validator{{Address: addr1, VotingPower: 1}}}
+		borCfg := &params.BorConfig{
+			Sprint:   map[string]uint64{"0": 64},
+			Period:   map[string]uint64{"0": 2},
+			RioBlock: big.NewInt(0),
+		}
+		chain, b := newChainAndBorForTest(t, sp, borCfg, true, addr1)
+		b.blockTime = 4 * time.Second
+
+		genesis := chain.HeaderChain().GetHeaderByNumber(0)
+		require.NotNil(t, genesis)
+		baseTime := genesis.Time
+
+		if baseTime > 10 {
+			b.lastMinedBlockTime = time.Unix(int64(baseTime-10), 0)
+		} else {
+			b.lastMinedBlockTime = time.Unix(0, 0)
+		}
+
+		header := &types.Header{
+			Number:     big.NewInt(1),
+			ParentHash: genesis.Hash(),
+		}
+
+		err := b.Prepare(chain.HeaderChain(), header)
+		require.NoError(t, err)
+
+		expectedTime := time.Unix(int64(baseTime), 0).Add(4 * time.Second)
+		require.Equal(t, expectedTime.Unix(), header.ActualTime.Unix())
+	})
+}
+
+func TestCustomBlockTimeBackwardCompatibility(t *testing.T) {
+	t.Parallel()
+
+	addr1 := common.HexToAddress("0x1")
+
+	t.Run("blockTime is zero uses standard CalcProducerDelay", func(t *testing.T) {
+		sp := &fakeSpanner{vals: []*valset.Validator{{Address: addr1, VotingPower: 1}}}
+		borCfg := &params.BorConfig{
+			Sprint:           map[string]uint64{"0": 64},
+			Period:           map[string]uint64{"0": 2},
+			ProducerDelay:    map[string]uint64{"0": 3},
+			BackupMultiplier: map[string]uint64{"0": 2},
+			RioBlock:         big.NewInt(0),
+		}
+		chain, b := newChainAndBorForTest(t, sp, borCfg, true, addr1)
+		b.blockTime = 0
+
+		genesis := chain.HeaderChain().GetHeaderByNumber(0)
+		require.NotNil(t, genesis)
+
+		header := &types.Header{
+			Number:     big.NewInt(1),
+			ParentHash: genesis.Hash(),
+		}
+
+		err := b.Prepare(chain.HeaderChain(), header)
+		require.NoError(t, err)
+
+		require.True(t, header.ActualTime.IsZero(), "ActualTime should not be set when blockTime is 0")
+	})
+}

core/blockchain.go

@@ -2573,7 +2573,7 @@ func (bc *BlockChain) InsertChainStateless(chain types.Blocks, witnesses []*stat
 		statedb.SetWitness(witness)
 
 		// Write the block to the chain without committing state
-		if _, err := bc.writeBlockAndSetHead(block, nil, nil, statedb, false, true); err != nil {
+		if _, err := bc.writeBlockAndSetHead(block, res.Receipts, res.Logs, statedb, false, true); err != nil {
 			return processed, err
 		}
 

core/blockchain_test.go

@@ -2145,7 +2145,7 @@ func testInsertReceiptChainRollback(t *testing.T, scheme string) {
 	}
 
 	// Set up a BlockChain that uses the ancient store.
-	ancientDb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false, false, false, false)
+	ancientDb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false, false, false, false, false, false)
 	if err != nil {
 		t.Fatalf("failed to create temp freezer db: %v", err)
 	}

core/rawdb/accessors_chain.go

@@ -1117,3 +1117,21 @@ func ReadHeadBlock(db ethdb.Reader) *types.Block {
 
 	return ReadBlock(db, headBlockHash, *headBlockNumber)
 }
+
+func ReadBlockPruneCursor(db ethdb.KeyValueReader) *uint64 {
+	log.Debug("ReadBlockCursor")
+	data, err := db.Get(blockPruneCursorKey())
+	if err != nil || len(data) == 0 {
+		return nil
+	}
+
+	number := binary.BigEndian.Uint64(data)
+	return &number
+}
+
+func WriteBlockPruneCursor(db ethdb.KeyValueWriter, cursor uint64) {
+	log.Debug("WriteBlockPruneCursor", "cursor", cursor)
+	if err := db.Put(blockPruneCursorKey(), encodeBlockNumber(cursor)); err != nil {
+		log.Crit("Failed to store block cursor", "err", err)
+	}
+}

core/rawdb/accessors_state.go

@@ -373,6 +373,6 @@ func ReadWitnessPruneCursor(db ethdb.KeyValueReader) *uint64 {
 func WriteWitnessPruneCursor(db ethdb.KeyValueWriter, cursor uint64) {
 	log.Debug("WriteWitnessPruneCursor", "cursor", cursor)
 	if err := db.Put(witnessPruneCursorKey(), encodeBlockNumber(cursor)); err != nil {
-		log.Crit("Failed to store witness", "err", err)
+		log.Crit("Failed to store witness cursor", "err", err)
 	}
 }