Support Volta hard fork(#277)

RenRick · web-flow · commit 62db53240284 · 2025-03-29T15:32:07.000+08:00
feat: support volta hard fork
diff --git a/beacon/engine/types.go b/beacon/engine/types.go
@@ -18,6 +18,7 @@ package engine
 
 import (
 	"fmt"
+	"github.com/holiman/uint256"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -26,6 +27,11 @@ import (
 	"github.com/ethereum/go-ethereum/trie"
 )
 
+var (
+	OldBlockMillisecondsInterval uint64 = 1000
+	NewBlockMillisecondsInterval uint64 = 500
+)
+
 // PayloadVersion denotes the version of PayloadAttributes used to request the
 // building of the payload to commence.
 type PayloadVersion byte
@@ -58,12 +64,22 @@ type PayloadAttributes struct {
 
 // JSON type overrides for PayloadAttributes.
 type payloadAttributesMarshaling struct {
-	Timestamp hexutil.Uint64
+	TempTimestamp hexutil.Uint64 // temp change 'Timestamp' to 'TempTimestamp' for debugging
+	Random        hexutil.Bytes  // Random store the milliseconds
 
 	Transactions []hexutil.Bytes
 	GasLimit     *hexutil.Uint64
 }
 
+func (p *PayloadAttributes) millisecondes() uint64 {
+	if p.Random == (common.Hash{}) {
+		return 0
+	}
+	return uint256.NewInt(0).SetBytes2(p.Random[:2]).Uint64()
+}
+
+func (p *PayloadAttributes) MilliTimestamp() uint64 { return p.Timestamp*1000 + p.millisecondes() }
+
 //go:generate go run github.com/fjl/gencodec -type ExecutableData -field-override executableDataMarshaling -out gen_ed.go
 
 // ExecutableData is the data necessary to execute an EL payload.
@@ -93,6 +109,7 @@ type executableDataMarshaling struct {
 	GasLimit      hexutil.Uint64
 	GasUsed       hexutil.Uint64
 	Timestamp     hexutil.Uint64
+	Random        hexutil.Bytes // Random store the milliseconds
 	BaseFeePerGas *hexutil.Big
 	ExtraData     hexutil.Bytes
 	LogsBloom     hexutil.Bytes
diff --git a/consensus/beacon/consensus.go b/consensus/beacon/consensus.go
@@ -255,7 +255,7 @@ func (beacon *Beacon) verifyHeader(chain consensus.ChainHeaderReader, header, pa
 		return errInvalidUncleHash
 	}
 	// Verify the timestamp
-	if header.Time <= parent.Time {
+	if header.MilliTimestamp() <= parent.MilliTimestamp() {
 		return errInvalidTimestamp
 	}
 	// Verify the block's difficulty to ensure it's the default constant
diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go
@@ -230,7 +230,7 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, pa
 			return consensus.ErrFutureBlock
 		}
 	}
-	if header.Time <= parent.Time {
+	if header.MilliTimestamp() <= parent.MilliTimestamp() {
 		return errOlderBlockTime
 	}
 	// Verify the block's difficulty based on its timestamp and parent's difficulty
@@ -539,6 +539,7 @@ func (ethash *Ethash) SealHash(header *types.Header) (hash common.Hash) {
 		header.GasLimit,
 		header.GasUsed,
 		header.Time,
+		header.MixDigest,
 		header.Extra,
 	}
 	if header.BaseFee != nil {
diff --git a/core/blockchain.go b/core/blockchain.go
@@ -683,16 +683,16 @@ func (bc *BlockChain) loadLastState() error {
 		blockTd  = bc.GetTd(headBlock.Hash(), headBlock.NumberU64())
 	)
 	if headHeader.Hash() != headBlock.Hash() {
-		log.Info("Loaded most recent local header", "number", headHeader.Number, "hash", headHeader.Hash(), "td", headerTd, "age", common.PrettyAge(time.Unix(int64(headHeader.Time), 0)))
+		log.Info("Loaded most recent local header", "number", headHeader.Number, "hash", headHeader.Hash(), "td", headerTd, "age", common.PrettyAge(time.Unix(int64(headHeader.MilliTimestamp()), 0)))
 	}
-	log.Info("Loaded most recent local block", "number", headBlock.Number(), "hash", headBlock.Hash(), "td", blockTd, "age", common.PrettyAge(time.Unix(int64(headBlock.Time()), 0)))
+	log.Info("Loaded most recent local block", "number", headBlock.Number(), "hash", headBlock.Hash(), "td", blockTd, "age", common.PrettyAge(time.Unix(int64(headBlock.MilliTimestamp()), 0)))
 	if headBlock.Hash() != currentSnapBlock.Hash() {
 		snapTd := bc.GetTd(currentSnapBlock.Hash(), currentSnapBlock.Number.Uint64())
-		log.Info("Loaded most recent local snap block", "number", currentSnapBlock.Number, "hash", currentSnapBlock.Hash(), "td", snapTd, "age", common.PrettyAge(time.Unix(int64(currentSnapBlock.Time), 0)))
+		log.Info("Loaded most recent local snap block", "number", currentSnapBlock.Number, "hash", currentSnapBlock.Hash(), "td", snapTd, "age", common.PrettyAge(time.Unix(int64(currentSnapBlock.MilliTimestamp()), 0)))
 	}
 	if currentFinalBlock != nil {
 		finalTd := bc.GetTd(currentFinalBlock.Hash(), currentFinalBlock.Number.Uint64())
-		log.Info("Loaded most recent local finalized block", "number", currentFinalBlock.Number, "hash", currentFinalBlock.Hash(), "td", finalTd, "age", common.PrettyAge(time.Unix(int64(currentFinalBlock.Time), 0)))
+		log.Info("Loaded most recent local finalized block", "number", currentFinalBlock.Number, "hash", currentFinalBlock.Hash(), "td", finalTd, "age", common.PrettyAge(time.Unix(int64(currentFinalBlock.MilliTimestamp()), 0)))
 	}
 	if pivot := rawdb.ReadLastPivotNumber(bc.db); pivot != nil {
 		log.Info("Loaded last snap-sync pivot marker", "number", *pivot)
@@ -1505,7 +1505,7 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 		head    = blockChain[len(blockChain)-1]
 		context = []interface{}{
 			"count", stats.processed, "elapsed", common.PrettyDuration(time.Since(start)),
-			"number", head.Number(), "hash", head.Hash(), "age", common.PrettyAge(time.Unix(int64(head.Time()), 0)),
+			"number", head.Number(), "hash", head.Hash(), "age", common.PrettyAge(time.Unix(int64(head.MilliTimestamp()), 0)),
 			"size", common.StorageSize(size),
 		}
 	)
@@ -1728,7 +1728,7 @@ func (bc *BlockChain) writeBlockAndSetHead(block *types.Block, receipts []*types
 func (bc *BlockChain) addFutureBlock(block *types.Block) error {
 	max := uint64(time.Now().Unix() + maxTimeFutureBlocks)
 	if block.Time() > max {
-		return fmt.Errorf("future block timestamp %v > allowed %v", block.Time(), max)
+		return fmt.Errorf("future block timestamp %v > allowed %v", block.MilliTimestamp(), max)
 	}
 	if block.Difficulty().Cmp(common.Big0) == 0 {
 		// Never add PoS blocks into the future queue
@@ -2251,6 +2251,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error)
 		if bc.snaps != nil {
 			snapDiffItems, snapBufItems = bc.snaps.Size()
 		}
+
 		trieDiffNodes, trieBufNodes, trieImmutableBufNodes, _ := bc.triedb.Size()
 		stats.report(chain, it.index, snapDiffItems, snapBufItems, trieDiffNodes, trieBufNodes, trieImmutableBufNodes, setHead)
 		blockGasUsedGauge.Update(int64(block.GasUsed()) / 1000000)
diff --git a/core/chain_makers.go b/core/chain_makers.go
@@ -217,6 +217,7 @@ func (b *BlockGen) TxNonce(addr common.Address) uint64 {
 func (b *BlockGen) AddUncle(h *types.Header) {
 	// The uncle will have the same timestamp and auto-generated difficulty
 	h.Time = b.header.Time
+	h.MixDigest = b.header.MixDigest
 
 	var parent *types.Header
 	for i := b.i - 1; i >= 0; i-- {
diff --git a/core/headerchain.go b/core/headerchain.go
@@ -38,8 +38,8 @@ import (
 )
 
 const (
-	headerCacheLimit = 512
-	tdCacheLimit     = 1024
+	headerCacheLimit = 1280
+	tdCacheLimit     = 1280
 	numberCacheLimit = 2048
 )
 
diff --git a/core/txpool/blobpool/blobpool.go b/core/txpool/blobpool/blobpool.go
@@ -401,7 +401,7 @@ func (p *BlobPool) Init(gasTip uint64, head *types.Header, reserve txpool.Addres
 		p.recheck(addr, nil)
 	}
 	var (
-		basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), p.head, p.head.Time+1))
+		basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), p.head, p.head.NextSecondsTimestamp()))
 		blobfee = uint256.NewInt(params.BlobTxMinBlobGasprice)
 	)
 	if p.head.ExcessBlobGas != nil {
@@ -822,7 +822,7 @@ func (p *BlobPool) Reset(oldHead, newHead *types.Header) {
 	}
 	// Reset the price heap for the new set of basefee/blobfee pairs
 	var (
-		basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), newHead, newHead.Time+1))
+		basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), newHead, newHead.NextSecondsTimestamp()))
 		blobfee = uint256.MustFromBig(big.NewInt(params.BlobTxMinBlobGasprice))
 	)
 	if newHead.ExcessBlobGas != nil {
diff --git a/core/txpool/legacypool/legacypool.go b/core/txpool/legacypool/legacypool.go
@@ -1465,7 +1465,7 @@ func (pool *LegacyPool) runReorg(done chan struct{}, reset *txpoolResetRequest,
 		var pendingBaseFee = pool.priced.urgent.baseFee
 		if reset.newHead != nil {
 			if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) {
-				pendingBaseFee = eip1559.CalcBaseFee(pool.chainconfig, reset.newHead, reset.newHead.Time+1)
+				pendingBaseFee = eip1559.CalcBaseFee(pool.chainconfig, reset.newHead, reset.newHead.NextSecondsTimestamp())
 				pool.priced.SetBaseFee(pendingBaseFee)
 			}
 		}
diff --git a/core/types/block.go b/core/types/block.go
@@ -20,6 +20,7 @@ package types
 import (
 	"encoding/binary"
 	"fmt"
+	"github.com/holiman/uint256"
 	"io"
 	"math/big"
 	"reflect"
@@ -31,6 +32,11 @@ import (
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
+var (
+	OldBlockMillisecondsInterval uint64 = 1000
+	NewBlockMillisecondsInterval uint64 = 500
+)
+
 // A BlockNonce is a 64-bit hash which proves (combined with the
 // mix-hash) that a sufficient amount of computation has been carried
 // out on a block.
@@ -101,14 +107,33 @@ type headerMarshaling struct {
 	Number        *hexutil.Big
 	GasLimit      hexutil.Uint64
 	GasUsed       hexutil.Uint64
-	Time          hexutil.Uint64
+	Time          hexutil.Uint64 // temp change 'Time' to 'TempTime' for debugging
+	MixDigest     hexutil.Bytes  // MixDigest store the milliseconds
 	Extra         hexutil.Bytes
 	BaseFee       *hexutil.Big
 	Hash          common.Hash `json:"hash"` // adds call to Hash() in MarshalJSON
 	BlobGasUsed   *hexutil.Uint64
 	ExcessBlobGas *hexutil.Uint64
 }
 
+func (h *Header) millisecondes() uint64 {
+	if h.MixDigest == (common.Hash{}) {
+		return 0
+	}
+	return uint256.NewInt(0).SetBytes2(h.MixDigest[:2]).Uint64()
+}
+
+func (h *Header) MilliTimestamp() uint64 { return h.Time*1000 + h.millisecondes() }
+
+func (h *Header) NextMilliTimestamp() uint64 {
+	if h.MixDigest == (common.Hash{}) {
+		return h.Time*1000 + OldBlockMillisecondsInterval
+	}
+	return h.MilliTimestamp() + NewBlockMillisecondsInterval
+}
+
+func (h *Header) NextSecondsTimestamp() uint64 { return h.NextMilliTimestamp() / 1000 }
+
 // Hash returns the block hash of the header, which is simply the keccak256 hash of its
 // RLP encoding.
 func (h *Header) Hash() common.Hash {
@@ -358,11 +383,12 @@ func (b *Block) Header() *Header {
 
 // Header value accessors. These do copy!
 
-func (b *Block) Number() *big.Int     { return new(big.Int).Set(b.header.Number) }
-func (b *Block) GasLimit() uint64     { return b.header.GasLimit }
-func (b *Block) GasUsed() uint64      { return b.header.GasUsed }
-func (b *Block) Difficulty() *big.Int { return new(big.Int).Set(b.header.Difficulty) }
-func (b *Block) Time() uint64         { return b.header.Time }
+func (b *Block) Number() *big.Int       { return new(big.Int).Set(b.header.Number) }
+func (b *Block) GasLimit() uint64       { return b.header.GasLimit }
+func (b *Block) GasUsed() uint64        { return b.header.GasUsed }
+func (b *Block) Difficulty() *big.Int   { return new(big.Int).Set(b.header.Difficulty) }
+func (b *Block) Time() uint64           { return b.header.Time }
+func (b *Block) MilliTimestamp() uint64 { return b.header.MilliTimestamp() }
 
 func (b *Block) NumberU64() uint64        { return b.header.Number.Uint64() }
 func (b *Block) MixDigest() common.Hash   { return b.header.MixDigest }
diff --git a/core/vm/evm.go b/core/vm/evm.go
@@ -88,11 +88,12 @@ type BlockContext struct {
 	Coinbase    common.Address // Provides information for COINBASE
 	GasLimit    uint64         // Provides information for GASLIMIT
 	BlockNumber *big.Int       // Provides information for NUMBER
-	Time        uint64         // Provides information for TIME
-	Difficulty  *big.Int       // Provides information for DIFFICULTY
-	BaseFee     *big.Int       // Provides information for BASEFEE (0 if vm runs with NoBaseFee flag and 0 gas price)
-	BlobBaseFee *big.Int       // Provides information for BLOBBASEFEE (0 if vm runs with NoBaseFee flag and 0 blob gas price)
-	Random      *common.Hash   // Provides information for PREVRANDAO
+	// Time is used for checking fork, so the seconds timestamp is enough.
+	Time        uint64       // Provides information for TIME
+	Difficulty  *big.Int     // Provides information for DIFFICULTY
+	BaseFee     *big.Int     // Provides information for BASEFEE (0 if vm runs with NoBaseFee flag and 0 gas price)
+	BlobBaseFee *big.Int     // Provides information for BLOBBASEFEE (0 if vm runs with NoBaseFee flag and 0 blob gas price)
+	Random      *common.Hash // Provides information for PREVRANDAO
 }
 
 // TxContext provides the EVM with information about a transaction.
diff --git a/eth/catalyst/api.go b/eth/catalyst/api.go
@@ -648,8 +648,8 @@ func (api *ConsensusAPI) newPayload(params engine.ExecutableData, versionedHashe
 		log.Error("Ignoring pre-merge parent block", "number", params.Number, "hash", params.BlockHash, "td", ptd, "ttd", ttd)
 		return engine.INVALID_TERMINAL_BLOCK, nil
 	}
-	if block.Time() <= parent.Time() {
-		log.Warn("Invalid timestamp", "parent", block.Time(), "block", block.Time())
+	if block.MilliTimestamp() <= parent.MilliTimestamp() {
+		log.Warn("Invalid mill timestamp", "parent", block.MilliTimestamp(), "block", block.MilliTimestamp())
 		return api.invalid(errors.New("invalid timestamp"), parent.Header()), nil
 	}
 	// Another corner case: if the node is in snap sync mode, but the CL client
diff --git a/eth/catalyst/api_test.go b/eth/catalyst/api_test.go
@@ -279,8 +279,8 @@ func TestInvalidPayloadTimestamp(t *testing.T) {
 	for i, test := range tests {
 		t.Run(fmt.Sprintf("Timestamp test: %v", i), func(t *testing.T) {
 			params := engine.PayloadAttributes{
-				Timestamp:             test.time,
-				Random:                crypto.Keccak256Hash([]byte{byte(123)}),
+				Timestamp: test.time,
+				//Random:                crypto.Keccak256Hash([]byte{byte(123)}),
 				SuggestedFeeRecipient: parent.Coinbase,
 			}
 			fcState := engine.ForkchoiceStateV1{
@@ -630,8 +630,8 @@ func TestNewPayloadOnInvalidChain(t *testing.T) {
 		time.Sleep(500 * time.Millisecond)
 		var (
 			params = engine.PayloadAttributes{
-				Timestamp:             parent.Time + 1,
-				Random:                crypto.Keccak256Hash([]byte{byte(i)}),
+				Timestamp: parent.Time + 1,
+				//Random:                crypto.Keccak256Hash([]byte{byte(i)}),
 				SuggestedFeeRecipient: parent.Coinbase,
 			}
 			fcState = engine.ForkchoiceStateV1{
diff --git a/eth/catalyst/simulated_beacon.go b/eth/catalyst/simulated_beacon.go
@@ -17,7 +17,6 @@
 package catalyst
 
 import (
-	"crypto/rand"
 	"errors"
 	"math/big"
 	"sync"
@@ -154,13 +153,12 @@ func (c *SimulatedBeacon) sealBlock(withdrawals []*types.Withdrawal, timestamp u
 		c.setCurrentState(header.Hash(), *finalizedHash)
 	}
 
-	var random [32]byte
-	rand.Read(random[:])
+	//var random [32]byte
+	//rand.Read(random[:])
 	fcResponse, err := c.engineAPI.forkchoiceUpdated(c.curForkchoiceState, &engine.PayloadAttributes{
 		Timestamp:             timestamp,
 		SuggestedFeeRecipient: feeRecipient,
 		Withdrawals:           withdrawals,
-		Random:                random,
 	}, engine.PayloadV2, true)
 	if err != nil {
 		return err
diff --git a/eth/gasprice/feehistory.go b/eth/gasprice/feehistory.go
@@ -83,7 +83,7 @@ func (oracle *Oracle) processBlock(bf *blockFees, percentiles []float64) {
 		bf.results.baseFee = new(big.Int)
 	}
 	if chainconfig.IsLondon(big.NewInt(int64(bf.blockNumber + 1))) {
-		bf.results.nextBaseFee = eip1559.CalcBaseFee(chainconfig, bf.header, bf.header.Time+1)
+		bf.results.nextBaseFee = eip1559.CalcBaseFee(chainconfig, bf.header, bf.header.NextSecondsTimestamp())
 	} else {
 		bf.results.nextBaseFee = new(big.Int)
 	}
diff --git a/graphql/graphql.go b/graphql/graphql.go
@@ -773,7 +773,7 @@ func (b *Block) NextBaseFeePerGas(ctx context.Context) (*hexutil.Big, error) {
 			return nil, nil
 		}
 	}
-	nextBaseFee := eip1559.CalcBaseFee(chaincfg, header, header.Time+1)
+	nextBaseFee := eip1559.CalcBaseFee(chaincfg, header, header.NextSecondsTimestamp())
 	return (*hexutil.Big)(nextBaseFee), nil
 }
 
diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
@@ -1420,6 +1420,7 @@ func RPCMarshalBlock(ctx context.Context, block *types.Block, inclTx bool, fullT
 func (s *BlockChainAPI) rpcMarshalHeader(ctx context.Context, header *types.Header) map[string]interface{} {
 	fields := RPCMarshalHeader(header)
 	fields["totalDifficulty"] = (*hexutil.Big)(s.b.GetTd(ctx, header.Hash()))
+	fields["milliTimestamp"] = hexutil.Uint64(header.MilliTimestamp())
 	return fields
 }
 
@@ -1432,6 +1433,7 @@ func (s *BlockChainAPI) rpcMarshalBlock(ctx context.Context, b *types.Block, inc
 	}
 	if inclTx {
 		fields["totalDifficulty"] = (*hexutil.Big)(s.b.GetTd(ctx, b.Hash()))
+		fields["milliTimestamp"] = hexutil.Uint64(b.Header().MilliTimestamp())
 	}
 	return fields, nil
 }
@@ -1585,7 +1587,7 @@ func NewRPCPendingTransaction(tx *types.Transaction, current *types.Header, conf
 		blockTime   = uint64(0)
 	)
 	if current != nil {
-		baseFee = eip1559.CalcBaseFee(config, current, current.Time+1)
+		baseFee = eip1559.CalcBaseFee(config, current, current.NextSecondsTimestamp())
 		blockNumber = current.Number.Uint64()
 		blockTime = current.Time
 	}
diff --git a/internal/ethapi/api_test.go b/internal/ethapi/api_test.go
@@ -1959,6 +1959,10 @@ func TestRPCGetBlockOrHeader(t *testing.T) {
 			continue
 		}
 
+		if result != nil {
+			delete(result, "milliTimestamp")
+		}
+
 		testRPCResponseWithFile(t, i, result, rpc, tt.file)
 	}
 }
diff --git a/miner/miner.go b/miner/miner.go
diff --git a/miner/payload_building.go b/miner/payload_building.go
diff --git a/miner/worker.go b/miner/worker.go

Original file line number	Diff line number	Diff line change
`@@ -255,7 +255,7 @@ func (beacon *Beacon) verifyHeader(chain consensus.ChainHeaderReader, header, pa`
`255`	`255`	`return errInvalidUncleHash`
`256`	`256`	`}`
`257`	`257`	`// Verify the timestamp`
`258`		`- if header.Time <= parent.Time {`
	`258`	`+ if header.MilliTimestamp() <= parent.MilliTimestamp() {`
`259`	`259`	`return errInvalidTimestamp`
`260`	`260`	`}`
`261`	`261`	`// Verify the block's difficulty to ensure it's the default constant`
Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,7 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, pa`
`230`	`230`	`return consensus.ErrFutureBlock`
`231`	`231`	`}`
`232`	`232`	`}`
`233`		`- if header.Time <= parent.Time {`
	`233`	`+ if header.MilliTimestamp() <= parent.MilliTimestamp() {`
`234`	`234`	`return errOlderBlockTime`
`235`	`235`	`}`
`236`	`236`	`// Verify the block's difficulty based on its timestamp and parent's difficulty`
`@@ -539,6 +539,7 @@ func (ethash Ethash) SealHash(header types.Header) (hash common.Hash) {`
`539`	`539`	`header.GasLimit,`
`540`	`540`	`header.GasUsed,`
`541`	`541`	`header.Time,`
	`542`	`+ header.MixDigest,`
`542`	`543`	`header.Extra,`
`543`	`544`	`}`
`544`	`545`	`if header.BaseFee != nil {`
Original file line number	Diff line number	Diff line change
`@@ -683,16 +683,16 @@ func (bc *BlockChain) loadLastState() error {`
`683`	`683`	`blockTd = bc.GetTd(headBlock.Hash(), headBlock.NumberU64())`
`684`	`684`	`)`
`685`	`685`	`if headHeader.Hash() != headBlock.Hash() {`
`686`		`- log.Info("Loaded most recent local header", "number", headHeader.Number, "hash", headHeader.Hash(), "td", headerTd, "age", common.PrettyAge(time.Unix(int64(headHeader.Time), 0)))`
	`686`	`+ log.Info("Loaded most recent local header", "number", headHeader.Number, "hash", headHeader.Hash(), "td", headerTd, "age", common.PrettyAge(time.Unix(int64(headHeader.MilliTimestamp()), 0)))`
`687`	`687`	`}`
`688`		`- log.Info("Loaded most recent local block", "number", headBlock.Number(), "hash", headBlock.Hash(), "td", blockTd, "age", common.PrettyAge(time.Unix(int64(headBlock.Time()), 0)))`
	`688`	`+ log.Info("Loaded most recent local block", "number", headBlock.Number(), "hash", headBlock.Hash(), "td", blockTd, "age", common.PrettyAge(time.Unix(int64(headBlock.MilliTimestamp()), 0)))`
`689`	`689`	`if headBlock.Hash() != currentSnapBlock.Hash() {`
`690`	`690`	`snapTd := bc.GetTd(currentSnapBlock.Hash(), currentSnapBlock.Number.Uint64())`
`691`		`- log.Info("Loaded most recent local snap block", "number", currentSnapBlock.Number, "hash", currentSnapBlock.Hash(), "td", snapTd, "age", common.PrettyAge(time.Unix(int64(currentSnapBlock.Time), 0)))`
	`691`	`+ log.Info("Loaded most recent local snap block", "number", currentSnapBlock.Number, "hash", currentSnapBlock.Hash(), "td", snapTd, "age", common.PrettyAge(time.Unix(int64(currentSnapBlock.MilliTimestamp()), 0)))`
`692`	`692`	`}`
`693`	`693`	`if currentFinalBlock != nil {`
`694`	`694`	`finalTd := bc.GetTd(currentFinalBlock.Hash(), currentFinalBlock.Number.Uint64())`
`695`		`- log.Info("Loaded most recent local finalized block", "number", currentFinalBlock.Number, "hash", currentFinalBlock.Hash(), "td", finalTd, "age", common.PrettyAge(time.Unix(int64(currentFinalBlock.Time), 0)))`
	`695`	`+ log.Info("Loaded most recent local finalized block", "number", currentFinalBlock.Number, "hash", currentFinalBlock.Hash(), "td", finalTd, "age", common.PrettyAge(time.Unix(int64(currentFinalBlock.MilliTimestamp()), 0)))`
`696`	`696`	`}`
`697`	`697`	`if pivot := rawdb.ReadLastPivotNumber(bc.db); pivot != nil {`
`698`	`698`	`log.Info("Loaded last snap-sync pivot marker", "number", *pivot)`
`@@ -1505,7 +1505,7 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [`
`1505`	`1505`	`head = blockChain[len(blockChain)-1]`
`1506`	`1506`	`context = []interface{}{`
`1507`	`1507`	`"count", stats.processed, "elapsed", common.PrettyDuration(time.Since(start)),`
`1508`		`- "number", head.Number(), "hash", head.Hash(), "age", common.PrettyAge(time.Unix(int64(head.Time()), 0)),`
	`1508`	`+ "number", head.Number(), "hash", head.Hash(), "age", common.PrettyAge(time.Unix(int64(head.MilliTimestamp()), 0)),`
`1509`	`1509`	`"size", common.StorageSize(size),`
`1510`	`1510`	`}`
`1511`	`1511`	`)`
`@@ -1728,7 +1728,7 @@ func (bc BlockChain) writeBlockAndSetHead(block types.Block, receipts []*types`
`1728`	`1728`	`func (bc BlockChain) addFutureBlock(block types.Block) error {`
`1729`	`1729`	`max := uint64(time.Now().Unix() + maxTimeFutureBlocks)`
`1730`	`1730`	`if block.Time() > max {`
`1731`		`- return fmt.Errorf("future block timestamp %v > allowed %v", block.Time(), max)`
	`1731`	`+ return fmt.Errorf("future block timestamp %v > allowed %v", block.MilliTimestamp(), max)`
`1732`	`1732`	`}`
`1733`	`1733`	`if block.Difficulty().Cmp(common.Big0) == 0 {`
`1734`	`1734`	`// Never add PoS blocks into the future queue`
`@@ -2251,6 +2251,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error)`
`2251`	`2251`	`if bc.snaps != nil {`
`2252`	`2252`	`snapDiffItems, snapBufItems = bc.snaps.Size()`
`2253`	`2253`	`}`
	`2254`	`+`
`2254`	`2255`	`trieDiffNodes, trieBufNodes, trieImmutableBufNodes, _ := bc.triedb.Size()`
`2255`	`2256`	`stats.report(chain, it.index, snapDiffItems, snapBufItems, trieDiffNodes, trieBufNodes, trieImmutableBufNodes, setHead)`
`2256`	`2257`	`blockGasUsedGauge.Update(int64(block.GasUsed()) / 1000000)`
Original file line number	Diff line number	Diff line change
`@@ -38,8 +38,8 @@ import (`
`38`	`38`	`)`
`39`	`39`
`40`	`40`	`const (`
`41`		`- headerCacheLimit = 512`
`42`		`- tdCacheLimit = 1024`
	`41`	`+ headerCacheLimit = 1280`
	`42`	`+ tdCacheLimit = 1280`
`43`	`43`	`numberCacheLimit = 2048`
`44`	`44`	`)`
`45`	`45`
Original file line number	Diff line number	Diff line change
`@@ -401,7 +401,7 @@ func (p BlobPool) Init(gasTip uint64, head types.Header, reserve txpool.Addres`
`401`	`401`	`p.recheck(addr, nil)`
`402`	`402`	`}`
`403`	`403`	`var (`
`404`		`- basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), p.head, p.head.Time+1))`
	`404`	`+ basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), p.head, p.head.NextSecondsTimestamp()))`
`405`	`405`	`blobfee = uint256.NewInt(params.BlobTxMinBlobGasprice)`
`406`	`406`	`)`
`407`	`407`	`if p.head.ExcessBlobGas != nil {`
`@@ -822,7 +822,7 @@ func (p BlobPool) Reset(oldHead, newHead types.Header) {`
`822`	`822`	`}`
`823`	`823`	`// Reset the price heap for the new set of basefee/blobfee pairs`
`824`	`824`	`var (`
`825`		`- basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), newHead, newHead.Time+1))`
	`825`	`+ basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), newHead, newHead.NextSecondsTimestamp()))`
`826`	`826`	`blobfee = uint256.MustFromBig(big.NewInt(params.BlobTxMinBlobGasprice))`
`827`	`827`	`)`
`828`	`828`	`if newHead.ExcessBlobGas != nil {`
Original file line number	Diff line number	Diff line change
`@@ -1465,7 +1465,7 @@ func (pool LegacyPool) runReorg(done chan struct{}, reset txpoolResetRequest,`
`1465`	`1465`	`var pendingBaseFee = pool.priced.urgent.baseFee`
`1466`	`1466`	`if reset.newHead != nil {`
`1467`	`1467`	`if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) {`
`1468`		`- pendingBaseFee = eip1559.CalcBaseFee(pool.chainconfig, reset.newHead, reset.newHead.Time+1)`
	`1468`	`+ pendingBaseFee = eip1559.CalcBaseFee(pool.chainconfig, reset.newHead, reset.newHead.NextSecondsTimestamp())`
`1469`	`1469`	`pool.priced.SetBaseFee(pendingBaseFee)`
`1470`	`1470`	`}`
`1471`	`1471`	`}`