forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-26 22:56:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into shivam/temp-master-develop

Browse source
This commit is contained in:
Shivam Sharma 2024-03-20 14:29:04 +05:30
commit 184b2d628d
34 changed files with 239 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
builder/files/config.toml
View file

@ -25,6 +25,7 @@ syncmode = "full"
# json = false
# backtrace = ""
# debug = true
# enable-block-tracking = false
[p2p]
# maxpeers = 1

3
builder/files/genesis-mainnet-v1.json
View file

@ -13,7 +13,8 @@
"muirGlacierBlock": 3395000,
"berlinBlock": 14750000,
"londonBlock": 23850000,
"shanghaiBlock":50523000,
"shanghaiBlock": 50523000,
"cancunBlock": 54876000,
"bor": {
"jaipurBlock": 23850000,
"delhiBlock": 38189056,

5
core/state/state_object.go
View file

@ -21,6 +21,7 @@ import (
"fmt"
"io"
"math/big"
"sync"
"time"
"github.com/ethereum/go-ethereum/common"
@ -73,6 +74,7 @@ type stateObject struct {
trie Trie // storage trie, which becomes non-nil on first access
code Code // contract bytecode, which gets set when code is loaded
storageMutex sync.Mutex
originStorage Storage // Storage cache of original entries to dedup rewrites
pendingStorage Storage // Storage entries that need to be flushed to disk, at the end of an entire block
dirtyStorage Storage // Storage entries that have been modified in the current transaction execution, reset for every transaction
@ -175,6 +177,8 @@ func (s *stateObject) GetState(key common.Hash) common.Hash {
// GetCommittedState retrieves a value from the committed account storage trie.
func (s *stateObject) GetCommittedState(key common.Hash) common.Hash {
s.storageMutex.Lock()
defer s.storageMutex.Unlock()
// If we have a pending write or clean cached, return that
if value, pending := s.pendingStorage[key]; pending {
return value
@ -183,6 +187,7 @@ func (s *stateObject) GetCommittedState(key common.Hash) common.Hash {
if value, cached := s.originStorage[key]; cached {
return value
}
// If the object was destructed in *this* block (and potentially resurrected),
// the storage has been cleared out, and we should *not* consult the previous
// database about any storage values. The only possible alternatives are:

1
core/types/block.go
View file

@ -266,6 +266,7 @@ type Block struct {
// inter-peer block relay.
ReceivedAt time.Time
ReceivedFrom interface{}
AnnouncedAt *time.Time
}
// "external" block encoding. used for eth protocol, etc.

9
docs/cli/example_config.toml
View file

@ -24,10 +24,11 @@ devfakeauthor = false # Run miner without validator set authorization
"32000000" = "0x875500011e5eecc0c554f95d07b31cf59df4ca2505f4dbbfffa7d4e4da917c68"
[log]
vmodule = "" # Per-module verbosity: comma-separated list of <pattern>=<level> (e.g. eth/*=5,p2p=4)
json = false # Format logs with JSON
backtrace = "" # Request a stack trace at a specific logging statement (e.g. "block.go:271")
debug = true # Prepends log messages with call-site location (file and line number) - {requires some effort}
vmodule = "" # Per-module verbosity: comma-separated list of <pattern>=<level> (e.g. eth/*=5,p2p=4)
json = false # Format logs with JSON
backtrace = "" # Request a stack trace at a specific logging statement (e.g. "block.go:271")
debug = true # Prepends log messages with call-site location (file and line number)
enable-block-tracking = false # Enables additional logging of information collected while tracking block lifecycle
[p2p]
maxpeers = 50 # Maximum number of network peers (network disabled if set to 0)

2
docs/cli/server.md
View file

@ -204,6 +204,8 @@ The ```bor server``` command runs the Bor client.
- ```log.debug```: Prepends log messages with call-site location (file and line number) (default: false)
- ```log.enable-block-tracking```: Enables additional logging of information collected while tracking block lifecycle (default: false)
- ```log.json```: Format logs with JSON (default: false)
- ```vmodule```: Per-module verbosity: comma-separated list of <pattern>=<level> (e.g. eth/*=5,p2p=4)

25
eth/backend.go
View file

@ -280,18 +280,19 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
// Permit the downloader to use the trie cache allowance during fast sync
cacheLimit := cacheConfig.TrieCleanLimit + cacheConfig.TrieDirtyLimit + cacheConfig.SnapshotLimit
if eth.handler, err = newHandler(&handlerConfig{
Database: chainDb,
Chain: eth.blockchain,
TxPool: eth.txPool,
Merger: eth.merger,
Network: config.NetworkId,
Sync: config.SyncMode,
BloomCache: uint64(cacheLimit),
EventMux: eth.eventMux,
RequiredBlocks: config.RequiredBlocks,
EthAPI: blockChainAPI,
checker: checker,
txArrivalWait: eth.p2pServer.TxArrivalWait,
Database: chainDb,
Chain: eth.blockchain,
TxPool: eth.txPool,
Merger: eth.merger,
Network: config.NetworkId,
Sync: config.SyncMode,
BloomCache: uint64(cacheLimit),
EventMux: eth.eventMux,
RequiredBlocks: config.RequiredBlocks,
EthAPI: blockChainAPI,
checker: checker,
txArrivalWait: eth.p2pServer.TxArrivalWait,
enableBlockTracking: eth.config.EnableBlockTracking,
}); err != nil {
return nil, err
}

3
eth/ethconfig/config.go
View file

@ -215,6 +215,9 @@ type Config struct {
// OverrideVerkle (TODO: remove after the fork)
OverrideVerkle *big.Int `toml:",omitempty"`
// EnableBlockTracking allows logging of information collected while tracking block lifecycle
EnableBlockTracking bool
}
// CreateConsensusEngine creates a consensus engine for the given chain configuration.

112
eth/fetcher/block_fetcher.go
View file

@ -114,18 +114,20 @@ type blockAnnounce struct {
// headerFilterTask represents a batch of headers needing fetcher filtering.
type headerFilterTask struct {
peer string // The source peer of block headers
headers []*types.Header // Collection of headers to filter
time time.Time // Arrival time of the headers
peer string // The source peer of block headers
headers []*types.Header // Collection of headers to filter
time time.Time // Arrival time of the headers
announcedTime time.Time // Announcement time of the availability of the block
}
// bodyFilterTask represents a batch of block bodies (transactions and uncles)
// needing fetcher filtering.
type bodyFilterTask struct {
peer string // The source peer of block bodies
transactions [][]*types.Transaction // Collection of transactions per block bodies
uncles [][]*types.Header // Collection of uncles per block bodies
time time.Time // Arrival time of the blocks' contents
peer string // The source peer of block bodies
transactions [][]*types.Transaction // Collection of transactions per block bodies
uncles [][]*types.Header // Collection of uncles per block bodies
time time.Time // Arrival time of the blocks' contents
announcedTime time.Time // Announcement time of the availability of the block
}
// blockOrHeaderInject represents a schedules import operation.
@ -197,34 +199,38 @@ type BlockFetcher struct {
fetchingHook func([]common.Hash) // Method to call upon starting a block (eth/61) or header (eth/62) fetch
completingHook func([]common.Hash) // Method to call upon starting a block body fetch (eth/62)
importedHook func(*types.Header, *types.Block) // Method to call upon successful header or block import (both eth/61 and eth/62)
// Logging
enableBlockTracking bool // Whether to log information collected while tracking block lifecycle
}
// NewBlockFetcher creates a block fetcher to retrieve blocks based on hash announcements.
func NewBlockFetcher(light bool, getHeader HeaderRetrievalFn, getBlock blockRetrievalFn, verifyHeader headerVerifierFn, broadcastBlock blockBroadcasterFn, chainHeight chainHeightFn, insertHeaders headersInsertFn, insertChain chainInsertFn, dropPeer peerDropFn) *BlockFetcher {
func NewBlockFetcher(light bool, getHeader HeaderRetrievalFn, getBlock blockRetrievalFn, verifyHeader headerVerifierFn, broadcastBlock blockBroadcasterFn, chainHeight chainHeightFn, insertHeaders headersInsertFn, insertChain chainInsertFn, dropPeer peerDropFn, enableBlockTracking bool) *BlockFetcher {
return &BlockFetcher{
light: light,
notify: make(chan *blockAnnounce),
inject: make(chan *blockOrHeaderInject),
headerFilter: make(chan chan *headerFilterTask),
bodyFilter: make(chan chan *bodyFilterTask),
done: make(chan common.Hash),
quit: make(chan struct{}),
announces: make(map[string]int),
announced: make(map[common.Hash][]*blockAnnounce),
fetching: make(map[common.Hash]*blockAnnounce),
fetched: make(map[common.Hash][]*blockAnnounce),
completing: make(map[common.Hash]*blockAnnounce),
queue: prque.New[int64, *blockOrHeaderInject](nil),
queues: make(map[string]int),
queued: make(map[common.Hash]*blockOrHeaderInject),
getHeader: getHeader,
getBlock: getBlock,
verifyHeader: verifyHeader,
broadcastBlock: broadcastBlock,
chainHeight: chainHeight,
insertHeaders: insertHeaders,
insertChain: insertChain,
dropPeer: dropPeer,
light: light,
notify: make(chan *blockAnnounce),
inject: make(chan *blockOrHeaderInject),
headerFilter: make(chan chan *headerFilterTask),
bodyFilter: make(chan chan *bodyFilterTask),
done: make(chan common.Hash),
quit: make(chan struct{}),
announces: make(map[string]int),
announced: make(map[common.Hash][]*blockAnnounce),
fetching: make(map[common.Hash]*blockAnnounce),
fetched: make(map[common.Hash][]*blockAnnounce),
completing: make(map[common.Hash]*blockAnnounce),
queue: prque.New[int64, *blockOrHeaderInject](nil),
queues: make(map[string]int),
queued: make(map[common.Hash]*blockOrHeaderInject),
getHeader: getHeader,
getBlock: getBlock,
verifyHeader: verifyHeader,
broadcastBlock: broadcastBlock,
chainHeight: chainHeight,
insertHeaders: insertHeaders,
insertChain: insertChain,
dropPeer: dropPeer,
enableBlockTracking: enableBlockTracking,
}
}
@ -276,7 +282,7 @@ func (f *BlockFetcher) Enqueue(peer string, block *types.Block) error {
// FilterHeaders extracts all the headers that were explicitly requested by the fetcher,
// returning those that should be handled differently.
func (f *BlockFetcher) FilterHeaders(peer string, headers []*types.Header, time time.Time) []*types.Header {
func (f *BlockFetcher) FilterHeaders(peer string, headers []*types.Header, time time.Time, announcedAt time.Time) []*types.Header {
log.Trace("Filtering headers", "peer", peer, "headers", len(headers))
// Send the filter channel to the fetcher
@ -289,7 +295,7 @@ func (f *BlockFetcher) FilterHeaders(peer string, headers []*types.Header, time
}
// Request the filtering of the header list
select {
case filter <- &headerFilterTask{peer: peer, headers: headers, time: time}:
case filter <- &headerFilterTask{peer: peer, headers: headers, time: time, announcedTime: announcedAt}:
case <-f.quit:
return nil
}
@ -304,7 +310,7 @@ func (f *BlockFetcher) FilterHeaders(peer string, headers []*types.Header, time
// FilterBodies extracts all the block bodies that were explicitly requested by
// the fetcher, returning those that should be handled differently.
func (f *BlockFetcher) FilterBodies(peer string, transactions [][]*types.Transaction, uncles [][]*types.Header, time time.Time) ([][]*types.Transaction, [][]*types.Header) {
func (f *BlockFetcher) FilterBodies(peer string, transactions [][]*types.Transaction, uncles [][]*types.Header, time time.Time, announcedAt time.Time) ([][]*types.Transaction, [][]*types.Header) {
log.Trace("Filtering bodies", "peer", peer, "txs", len(transactions), "uncles", len(uncles))
// Send the filter channel to the fetcher
@ -317,7 +323,7 @@ func (f *BlockFetcher) FilterBodies(peer string, transactions [][]*types.Transac
}
// Request the filtering of the body list
select {
case filter <- &bodyFilterTask{peer: peer, transactions: transactions, uncles: uncles, time: time}:
case filter <- &bodyFilterTask{peer: peer, transactions: transactions, uncles: uncles, time: time, announcedTime: announcedAt}:
case <-f.quit:
return nil, nil
}
@ -480,7 +486,7 @@ func (f *BlockFetcher) loop() {
log.Trace("Fetching scheduled headers", "peer", peer, "list", hashes)
// Create a closure of the fetch and schedule in on a new thread
fetchHeader, hashes := f.fetching[hashes[0]].fetchHeader, hashes
fetchHeader, hashes, announcedAt := f.fetching[hashes[0]].fetchHeader, hashes, f.fetching[hashes[0]].time
go func(peer string) {
if f.fetchingHook != nil {
f.fetchingHook(hashes)
@ -504,7 +510,7 @@ func (f *BlockFetcher) loop() {
select {
case res := <-resCh:
res.Done <- nil
f.FilterHeaders(peer, *res.Res.(*eth.BlockHeadersRequest), time.Now().Add(res.Time))
f.FilterHeaders(peer, *res.Res.(*eth.BlockHeadersRequest), time.Now(), announcedAt)
case <-timeout.C:
// The peer didn't respond in time. The request
@ -547,6 +553,7 @@ func (f *BlockFetcher) loop() {
fetchBodies := f.completing[hashes[0]].fetchBodies
bodyFetchMeter.Mark(int64(len(hashes)))
announcedAt := f.completing[hashes[0]].time
go func(peer string, hashes []common.Hash) {
resCh := make(chan *eth.Response)
@ -564,8 +571,8 @@ func (f *BlockFetcher) loop() {
case res := <-resCh:
res.Done <- nil
// Ignoring withdrawals here, since the block fetcher is not used post-merge.
txs, uncles, _ := res.Res.(*eth.BlockBodiesResponse).Unpack()
f.FilterBodies(peer, txs, uncles, time.Now())
txs, uncles, _ := res.Res.(*eth.BlockBodiesPacket).Unpack()
f.FilterBodies(peer, txs, uncles, time.Now(), announcedAt)
case <-timeout.C:
// The peer didn't respond in time. The request
@ -631,6 +638,7 @@ func (f *BlockFetcher) loop() {
block := types.NewBlockWithHeader(header)
block.ReceivedAt = task.time
block.AnnouncedAt = &task.announcedTime
complete = append(complete, block)
f.completing[hash] = announce
@ -725,6 +733,7 @@ func (f *BlockFetcher) loop() {
if f.getBlock(hash) == nil {
block := types.NewBlockWithHeader(announce.header).WithBody(task.transactions[i], task.uncles[i])
block.ReceivedAt = task.time
block.AnnouncedAt = &task.announcedTime
blocks = append(blocks, block)
} else {
f.forgetHash(hash)
@ -923,6 +932,31 @@ func (f *BlockFetcher) importBlocks(peer string, block *types.Block) {
log.Debug("Propagated block import failed", "peer", peer, "number", block.Number(), "hash", hash, "err", err)
return
}
if f.enableBlockTracking {
// Log the insertion event
var (
msg string
delayInMs uint64
prettyDelay common.PrettyDuration
)
if block.AnnouncedAt != nil {
msg = "[block tracker] Inserted new block with announcement"
delayInMs = uint64(time.Since(*block.AnnouncedAt).Milliseconds())
prettyDelay = common.PrettyDuration(time.Since(*block.AnnouncedAt))
} else {
msg = "[block tracker] Inserted new block without announcement"
delayInMs = uint64(time.Since(block.ReceivedAt).Milliseconds())
prettyDelay = common.PrettyDuration(time.Since(block.ReceivedAt))
}
totalDelayInMs := uint64(time.Now().UnixMilli()) - block.Time()*1000
totalDelay := common.PrettyDuration(time.Millisecond * time.Duration(totalDelayInMs))
log.Info(msg, "number", block.Number().Uint64(), "hash", hash, "delay", prettyDelay, "delayInMs", delayInMs, "totalDelay", totalDelay, "totalDelayInMs", totalDelayInMs)
}
// If import succeeded, broadcast the block
blockAnnounceOutTimer.UpdateSince(block.ReceivedAt)

2
eth/fetcher/block_fetcher_test.go
View file

@ -104,7 +104,7 @@ func newTester(light bool) *fetcherTester {
blocks: map[common.Hash]*types.Block{genesis.Hash(): genesis},
drops: make(map[string]bool),
}
tester.fetcher = NewBlockFetcher(light, tester.getHeader, tester.getBlock, tester.verifyHeader, tester.broadcastBlock, tester.chainHeight, tester.insertHeaders, tester.insertChain, tester.dropPeer)
tester.fetcher = NewBlockFetcher(light, tester.getHeader, tester.getBlock, tester.verifyHeader, tester.broadcastBlock, tester.chainHeight, tester.insertHeaders, tester.insertChain, tester.dropPeer, false)
tester.fetcher.Start()
return tester

61
eth/handler.go
View file

@ -86,18 +86,19 @@ type txPool interface {
// handlerConfig is the collection of initialization parameters to create a full
// node network handler.
type handlerConfig struct {
Database ethdb.Database // Database for direct sync insertions
Chain *core.BlockChain // Blockchain to serve data from
TxPool txPool // Transaction pool to propagate from
Merger *consensus.Merger // The manager for eth1/2 transition
Network uint64 // Network identifier to adfvertise
Sync downloader.SyncMode // Whether to snap or full sync
BloomCache uint64 // Megabytes to alloc for snap sync bloom
EventMux *event.TypeMux // Legacy event mux, deprecate for `feed`
txArrivalWait time.Duration // Maximum duration to wait for an announced tx before requesting it
checker ethereum.ChainValidator
RequiredBlocks map[uint64]common.Hash // Hard coded map of required block hashes for sync challenges
EthAPI *ethapi.BlockChainAPI // EthAPI to interact
Database ethdb.Database // Database for direct sync insertions
Chain *core.BlockChain // Blockchain to serve data from
TxPool txPool // Transaction pool to propagate from
Merger *consensus.Merger // The manager for eth1/2 transition
Network uint64 // Network identifier to adfvertise
Sync downloader.SyncMode // Whether to snap or full sync
BloomCache uint64 // Megabytes to alloc for snap sync bloom
EventMux *event.TypeMux // Legacy event mux, deprecate for `feed`
txArrivalWait time.Duration // Maximum duration to wait for an announced tx before requesting it
checker ethereum.ChainValidator
RequiredBlocks map[uint64]common.Hash // Hard coded map of required block hashes for sync challenges
EthAPI *ethapi.BlockChainAPI // EthAPI to interact
enableBlockTracking bool // Whether to log information collected while tracking block lifecycle
}
type handler struct {
@ -127,6 +128,8 @@ type handler struct {
requiredBlocks map[uint64]common.Hash
enableBlockTracking bool
// channels for fetcher, syncer, txsyncLoop
quitSync chan struct{}
@ -145,19 +148,20 @@ func newHandler(config *handlerConfig) (*handler, error) {
}
h := &handler{
networkID: config.Network,
forkFilter: forkid.NewFilter(config.Chain),
eventMux: config.EventMux,
database: config.Database,
txpool: config.TxPool,
chain: config.Chain,
peers: newPeerSet(),
merger: config.Merger,
ethAPI: config.EthAPI,
requiredBlocks: config.RequiredBlocks,
quitSync: make(chan struct{}),
handlerDoneCh: make(chan struct{}),
handlerStartCh: make(chan struct{}),
networkID: config.Network,
forkFilter: forkid.NewFilter(config.Chain),
eventMux: config.EventMux,
database: config.Database,
txpool: config.TxPool,
chain: config.Chain,
peers: newPeerSet(),
merger: config.Merger,
ethAPI: config.EthAPI,
requiredBlocks: config.RequiredBlocks,
enableBlockTracking: config.enableBlockTracking,
quitSync: make(chan struct{}),
handlerDoneCh: make(chan struct{}),
handlerStartCh: make(chan struct{}),
}
if config.Sync == downloader.FullSync {
// The database seems empty as the current block is the genesis. Yet the snap
@ -282,7 +286,7 @@ func newHandler(config *handlerConfig) (*handler, error) {
}
return h.chain.InsertChain(blocks)
}
h.blockFetcher = fetcher.NewBlockFetcher(false, nil, h.chain.GetBlockByHash, validator, h.BroadcastBlock, heighter, nil, inserter, h.removePeer)
h.blockFetcher = fetcher.NewBlockFetcher(false, nil, h.chain.GetBlockByHash, validator, h.BroadcastBlock, heighter, nil, inserter, h.removePeer, h.enableBlockTracking)
fetchTx := func(peer string, hashes []common.Hash) error {
p := h.peers.peer(peer)
@ -679,6 +683,11 @@ func (h *handler) minedBroadcastLoop() {
for obj := range h.minedBlockSub.Chan() {
if ev, ok := obj.Data.(core.NewMinedBlockEvent); ok {
if h.enableBlockTracking {
delayInMs := uint64(time.Now().UnixMilli()) - ev.Block.Time()*1000
delay := common.PrettyDuration(time.Millisecond * time.Duration(delayInMs))
log.Info("[block tracker] Broadcasting mined block", "number", ev.Block.NumberU64(), "hash", ev.Block.Hash(), "blockTime", ev.Block.Time(), "now", time.Now().Unix(), "delay", delay, "delayInMs", delayInMs)
}
h.BroadcastBlock(ev.Block, true) // First propagate block to peers
h.BroadcastBlock(ev.Block, false) // Only then announce to the rest
}

2
eth/protocols/eth/handlers.go
View file

@ -333,8 +333,10 @@ func handleNewBlock(backend Backend, msg Decoder, peer *Peer) error {
return nil // TODO(karalabe): return error eventually, but wait a few releases
}
msgTime := msg.Time()
ann.Block.ReceivedAt = msg.Time()
ann.Block.ReceivedFrom = peer
ann.Block.AnnouncedAt = &msgTime
// Mark the peer as owning the block
peer.markBlock(ann.Block.Hash())

67
eth/tracers/api.go
View file

@ -169,11 +169,13 @@ func (api *API) blockByNumberAndHash(ctx context.Context, number rpc.BlockNumber
return api.blockByHash(ctx, hash)
}
// returns block transactions along with state-sync transaction if present
func (api *API) getAllBlockTransactions(ctx context.Context, block *types.Block) (types.Transactions, bool) {
// getAllBlockTransactions returns all blocks transactions including state-sync transaction if present
// along with a flag and it's hash (which is calculated differently than regular transactions)
func (api *API) getAllBlockTransactions(ctx context.Context, block *types.Block) (types.Transactions, bool, common.Hash) {
txs := block.Transactions()
stateSyncPresent := false
stateSyncHash := common.Hash{}
borReceipt := rawdb.ReadBorReceipt(api.backend.ChainDb(), block.Hash(), block.NumberU64(), api.backend.ChainConfig())
if borReceipt != nil {
@ -182,10 +184,11 @@ func (api *API) getAllBlockTransactions(ctx context.Context, block *types.Block)
borTx, _, _, _, _ := api.backend.GetBorBlockTransactionWithBlockHash(ctx, txHash, block.Hash())
txs = append(txs, borTx)
stateSyncPresent = true
stateSyncHash = txHash
}
}
return txs, stateSyncPresent
return txs, stateSyncPresent, stateSyncHash
}
// TraceConfig holds extra parameters to trace functions.
@ -337,19 +340,23 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed
blockCtx = core.NewEVMBlockContext(task.block.Header(), api.chainContext(ctx), nil)
)
// Trace all the transactions contained within
txs, stateSyncPresent := api.getAllBlockTransactions(ctx, task.block)
txs, stateSyncPresent, stateSyncHash := api.getAllBlockTransactions(ctx, task.block)
if !*config.BorTraceEnabled && stateSyncPresent {
txs = txs[:len(txs)-1]
stateSyncPresent = false
}
for i, tx := range task.block.Transactions() {
for i, tx := range txs {
msg, _ := core.TransactionToMessage(tx, signer, task.block.BaseFee())
txHash := tx.Hash()
if stateSyncPresent && i == len(txs)-1 {
txHash = stateSyncHash
}
txctx := &Context{
BlockHash: task.block.Hash(),
BlockNumber: task.block.Number(),
TxIndex: i,
TxHash: tx.Hash(),
TxHash: txHash,
}
var res interface{}
@ -364,14 +371,14 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed
res, err = api.traceTx(ctx, msg, txctx, blockCtx, task.statedb, config)
if err != nil {
task.results[i] = &txTraceResult{TxHash: tx.Hash(), Error: err.Error()}
log.Warn("Tracing failed", "hash", tx.Hash(), "block", task.block.NumberU64(), "err", err)
task.results[i] = &txTraceResult{TxHash: txHash, Error: err.Error()}
log.Warn("Tracing failed", "hash", txHash, "block", task.block.NumberU64(), "err", err)
break
}
// Only delete empty objects if EIP158/161 (a.k.a Spurious Dragon) is in effect
task.statedb.Finalise(api.backend.ChainConfig().IsEIP158(task.block.Number()))
task.results[i] = &txTraceResult{TxHash: tx.Hash(), Result: res}
task.results[i] = &txTraceResult{TxHash: txHash, Result: res}
}
// Tracing state is used up, queue it for de-referencing. Note the
// state is the parent state of trace block, use block.number-1 as
@ -666,7 +673,7 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config
deleteEmptyObjects = chainConfig.IsEIP158(block.Number())
)
txs, stateSyncPresent := api.getAllBlockTransactions(ctx, block)
txs, stateSyncPresent, stateSyncHash := api.getAllBlockTransactions(ctx, block)
for i, tx := range txs {
if err := ctx.Err(); err != nil {
return nil, err
@ -678,14 +685,13 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config
vmenv = vm.NewEVM(vmctx, txContext, statedb, chainConfig, vm.Config{})
)
statedb.SetTxContext(tx.Hash(), i)
//nolint: nestif
if stateSyncPresent && i == len(txs)-1 {
if *config.BorTraceEnabled {
callmsg := prepareCallMessage(*msg)
statedb.SetTxContext(stateSyncHash, i)
if _, err := statefull.ApplyMessage(ctx, callmsg, statedb, block.Header(), api.backend.ChainConfig(), api.chainContext(ctx)); err != nil {
log.Warn("Tracing intermediate roots did not complete", "txindex", i, "txhash", tx.Hash(), "err", err)
log.Warn("Tracing intermediate roots did not complete", "txindex", i, "txhash", stateSyncHash, "err", err)
// We intentionally don't return the error here: if we do, then the RPC server will not
// return the roots. Most likely, the caller already knows that a certain transaction fails to
// be included, but still want the intermediate roots that led to that point.
@ -698,6 +704,7 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config
break
}
} else {
statedb.SetTxContext(tx.Hash(), i)
// nolint : contextcheck
if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.GasLimit), context.Background()); err != nil {
log.Warn("Tracing intermediate roots did not complete", "txindex", i, "txhash", tx.Hash(), "err", err)
@ -787,12 +794,12 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
// Execute all the transaction contained within the block concurrently
var (
txs, stateSyncPresent = api.getAllBlockTransactions(ctx, block)
blockHash = block.Hash()
blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
results = make([]*txTraceResult, len(txs))
pend sync.WaitGroup
txs, stateSyncPresent, stateSyncHash = api.getAllBlockTransactions(ctx, block)
blockHash = block.Hash()
blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
results = make([]*txTraceResult, len(txs))
pend sync.WaitGroup
)
threads := runtime.NumCPU()
@ -810,11 +817,15 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
// Fetch and execute the next transaction trace tasks
for task := range jobs {
msg, _ := core.TransactionToMessage(txs[task.index], signer, block.BaseFee())
txHash := txs[task.index].Hash()
if stateSyncPresent && task.index == len(txs)-1 {
txHash = stateSyncHash
}
txctx := &Context{
BlockHash: blockHash,
BlockNumber: block.Number(),
TxIndex: task.index,
TxHash: txs[task.index].Hash(),
TxHash: txHash,
}
var res interface{}
@ -833,10 +844,10 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
}
if err != nil {
results[task.index] = &txTraceResult{TxHash: txs[task.index].Hash(), Error: err.Error()}
results[task.index] = &txTraceResult{TxHash: txHash, Error: err.Error()}
continue
}
results[task.index] = &txTraceResult{TxHash: txs[task.index].Hash(), Result: res}
results[task.index] = &txTraceResult{TxHash: txHash, Result: res}
}
}()
}
@ -1048,7 +1059,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
chainConfig, canon = overrideConfig(chainConfig, config.Overrides)
}
txs, stateSyncPresent := api.getAllBlockTransactions(ctx, block)
txs, stateSyncPresent, stateSyncHash := api.getAllBlockTransactions(ctx, block)
if !*config.BorTraceEnabled && stateSyncPresent {
txs = txs[:len(txs)-1]
stateSyncPresent = false
@ -1065,7 +1076,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
err error
)
// If the transaction needs tracing, swap out the configs
if tx.Hash() == txHash || txHash == (common.Hash{}) {
if tx.Hash() == txHash || txHash == (common.Hash{}) || txHash == stateSyncHash {
// Generate a unique temporary file to dump it into
prefix := fmt.Sprintf("block_%#x-%d-%#x-", block.Hash().Bytes()[:4], i, tx.Hash().Bytes()[:4])
if !canon {
@ -1088,11 +1099,12 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
}
// Execute the transaction and flush any traces to disk
vmenv := vm.NewEVM(vmctx, txContext, statedb, chainConfig, vmConf)
statedb.SetTxContext(tx.Hash(), i)
//nolint: nestif
if stateSyncPresent && i == len(txs)-1 {
if *config.BorTraceEnabled {
callmsg := prepareCallMessage(*msg)
statedb.SetTxContext(stateSyncHash, i)
_, err = statefull.ApplyBorMessage(vmenv, callmsg)
if writer != nil {
@ -1100,6 +1112,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
}
}
} else {
statedb.SetTxContext(tx.Hash(), i)
// nolint : contextcheck
_, err = core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.GasLimit), context.Background())
@ -1132,9 +1145,9 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
// containsTx reports whether the transaction with a certain hash
// is contained within the specified block.
func (api *API) containsTx(ctx context.Context, block *types.Block, hash common.Hash) bool {
txs, _ := api.getAllBlockTransactions(ctx, block)
txs, _, stateSyncHash := api.getAllBlockTransactions(ctx, block)
for _, tx := range txs {
if tx.Hash() == hash {
if tx.Hash() == hash || stateSyncHash == hash {
return true
}
}

18
eth/tracers/api_bor.go
View file

@ -68,16 +68,20 @@ func (api *API) traceBorBlock(ctx context.Context, block *types.Block, config *T
// Execute all the transaction contained within the block concurrently
var (
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
txs, stateSyncPresent = api.getAllBlockTransactions(ctx, block)
deleteEmptyObjects = api.backend.ChainConfig().IsEIP158(block.Number())
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
txs, stateSyncPresent, stateSyncHash = api.getAllBlockTransactions(ctx, block)
deleteEmptyObjects = api.backend.ChainConfig().IsEIP158(block.Number())
)
blockCtx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
traceTxn := func(indx int, tx *types.Transaction, borTx bool) *TxTraceResult {
traceTxn := func(indx int, tx *types.Transaction, borTx bool, stateSyncHash common.Hash) *TxTraceResult {
message, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
txContext := core.NewEVMTxContext(message)
txHash := tx.Hash()
if borTx {
txHash = stateSyncHash
}
tracer := logger.NewStructLogger(config.Config)
@ -86,7 +90,7 @@ func (api *API) traceBorBlock(ctx context.Context, block *types.Block, config *T
// Call Prepare to clear out the statedb access list
// Not sure if we need to do this
statedb.SetTxContext(tx.Hash(), indx)
statedb.SetTxContext(txHash, indx)
var execRes *core.ExecutionResult
@ -124,9 +128,9 @@ func (api *API) traceBorBlock(ctx context.Context, block *types.Block, config *T
for indx, tx := range txs {
if stateSyncPresent && indx == len(txs)-1 {
res.Transactions = append(res.Transactions, traceTxn(indx, tx, true))
res.Transactions = append(res.Transactions, traceTxn(indx, tx, true, stateSyncHash))
} else {
res.Transactions = append(res.Transactions, traceTxn(indx, tx, false))
res.Transactions = append(res.Transactions, traceTxn(indx, tx, false, stateSyncHash))
}
}

1
internal/cli/server/chains/mainnet.go
View file

@ -28,6 +28,7 @@ var mainnetBor = &Chain{
BerlinBlock: big.NewInt(14750000),
LondonBlock: big.NewInt(23850000),
ShanghaiBlock: big.NewInt(50523000),
CancunBlock: big.NewInt(54876000),
Bor: &params.BorConfig{
JaipurBlock: big.NewInt(23850000),
DelhiBlock: big.NewInt(38189056),

14
internal/cli/server/config.go
View file

@ -157,6 +157,9 @@ type LoggingConfig struct {
// Prepends log messages with call-site location (file and line number)
Debug bool `hcl:"debug,optional" toml:"debug,optional"`
// EnableBlockTracking allows logging of information collected while tracking block lifecycle
EnableBlockTracking bool `hcl:"enable-block-tracking,optional" toml:"enable-block-tracking,optional"`
// TODO - implement this
// // Write execution trace to the given file
// Trace string `hcl:"trace,optional" toml:"trace,optional"`
@ -609,10 +612,11 @@ func DefaultConfig() *Config {
DBEngine: "leveldb",
KeyStoreDir: "",
Logging: &LoggingConfig{
Vmodule: "",
Json: false,
Backtrace: "",
Debug: false,
Vmodule: "",
Json: false,
Backtrace: "",
Debug: false,
EnableBlockTracking: false,
},
RPCBatchLimit: 100,
RPCReturnDataLimit: 100000,
@ -1198,6 +1202,8 @@ func (c *Config) buildEth(stack *node.Node, accountManager *accounts.Manager) (*
n.DatabaseFreezer = c.Ancient
}
n.EnableBlockTracking = c.Logging.EnableBlockTracking
return &n, nil
}

7
internal/cli/server/flags.go
View file

@ -152,6 +152,13 @@ func (c *Command) Flags(config *Config) *flagset.Flagset {
Default: c.cliConfig.Logging.Debug,
Group: "Logging",
})
f.BoolFlag(&flagset.BoolFlag{
Name: "log.enable-block-tracking",
Usage: "Enables additional logging of information collected while tracking block lifecycle",
Value: &c.cliConfig.Logging.EnableBlockTracking,
Default: c.cliConfig.Logging.EnableBlockTracking,
Group: "Logging",
})
// heimdall
f.StringFlag(&flagset.StringFlag{

15
miner/worker.go
View file

@ -960,6 +960,14 @@ func (w *worker) commitTransactions(env *environment, txs *transactionsByPriceAn
mainloop:
for {
// Check interruption signal and abort building if it's fired.
if interrupt != nil {
if signal := interrupt.Load(); signal != commitInterruptNone {
breakCause = "interrupt"
return signalToErr(signal)
}
}
if interruptCtx != nil {
if EnableMVHashMap && w.IsRunning() {
env.state.AddEmptyMVHashMap()
@ -975,13 +983,6 @@ mainloop:
}
}
// Check interruption signal and abort building if it's fired.
if interrupt != nil {
if signal := interrupt.Load(); signal != commitInterruptNone {
breakCause = "interrupt"
return signalToErr(signal)
}
}
// If we don't have enough gas for any further transactions then we're done.
if env.gasPool.Gas() < params.TxGas {
breakCause = "Not enough gas for further transactions"

1
packaging/templates/mainnet-v1/archive/config.toml
View file

@ -21,6 +21,7 @@ gcmode = "archive"
# json = false
# backtrace = ""
# debug = true
# enable-block-tracking = false
[p2p]
maxpeers = 50

1
packaging/templates/mainnet-v1/sentry/sentry/bor/config.toml
View file

@ -21,6 +21,7 @@ syncmode = "full"
# json = false
# backtrace = ""
# debug = true
# enable-block-tracking = false
[p2p]
maxpeers = 50

1
packaging/templates/mainnet-v1/sentry/validator/bor/config.toml
View file

@ -23,6 +23,7 @@ syncmode = "full"
# json = false
# backtrace = ""
# debug = true
# enable-block-tracking = false
[p2p]
maxpeers = 20

1
packaging/templates/mainnet-v1/without-sentry/bor/config.toml
View file

@ -23,6 +23,7 @@ syncmode = "full"
# json = false
# backtrace = ""
# debug = true
# enable-block-tracking = false
[p2p]
maxpeers = 50

2
packaging/templates/package_scripts/control
View file

@ -1,5 +1,5 @@
Source: bor
Version: 1.2.5-beta
Version: 1.2.8
Section: develop
Priority: standard
Maintainer: Polygon <release-team@polygon.technology>

2
packaging/templates/package_scripts/control.arm64
View file

@ -1,5 +1,5 @@
Source: bor
Version: 1.2.5-beta
Version: 1.2.8
Section: develop
Priority: standard
Maintainer: Polygon <release-team@polygon.technology>

2
packaging/templates/package_scripts/control.profile.amd64
View file

@ -1,5 +1,5 @@
Source: bor-profile
Version: 1.2.5-beta
Version: 1.2.8
Section: develop
Priority: standard
Maintainer: Polygon <release-team@polygon.technology>

2
packaging/templates/package_scripts/control.profile.arm64
View file

@ -1,5 +1,5 @@
Source: bor-profile
Version: 1.2.5-beta
Version: 1.2.8
Section: develop
Priority: standard
Maintainer: Polygon <release-team@polygon.technology>

2
packaging/templates/package_scripts/control.validator
View file

@ -1,5 +1,5 @@
Source: bor-profile
Version: 1.2.5-beta
Version: 1.2.8
Section: develop
Priority: standard
Maintainer: Polygon <release-team@polygon.technology>

2
packaging/templates/package_scripts/control.validator.arm64
View file

@ -1,5 +1,5 @@
Source: bor-profile
Version: 1.2.5-beta
Version: 1.2.8
Section: develop
Priority: standard
Maintainer: Polygon <release-team@polygon.technology>

1
packaging/templates/testnet-v4/archive/config.toml
View file

@ -21,6 +21,7 @@ gcmode = "archive"
# json = false
# backtrace = ""
# debug = true
# enable-block-tracking = false
[p2p]
maxpeers = 50

1
packaging/templates/testnet-v4/sentry/sentry/bor/config.toml
View file

@ -21,6 +21,7 @@ syncmode = "full"
# json = false
# backtrace = ""
# debug = true
# enable-block-tracking = false
[p2p]
maxpeers = 50

1
packaging/templates/testnet-v4/sentry/validator/bor/config.toml
View file

@ -23,6 +23,7 @@ syncmode = "full"
# json = false
# backtrace = ""
# debug = true
# enable-block-tracking = false
[p2p]
maxpeers = 1

1
packaging/templates/testnet-v4/without-sentry/bor/config.toml
View file

@ -23,6 +23,7 @@ syncmode = "full"
# json = false
# backtrace = ""
# debug = true
# enable-block-tracking = false
[p2p]
maxpeers = 50

1
params/config.go
View file

@ -310,6 +310,7 @@ var (
BerlinBlock: big.NewInt(14750000),
LondonBlock: big.NewInt(23850000),
ShanghaiBlock: big.NewInt(50523000),
CancunBlock: big.NewInt(54876000),
Bor: &BorConfig{
JaipurBlock: big.NewInt(23850000),
DelhiBlock: big.NewInt(38189056),

8
params/version.go
View file

@ -21,10 +21,10 @@ import (
)
const (
VersionMajor = 1 // Major version component of the current release
VersionMinor = 2 // Minor version component of the current release
VersionPatch = 5 // Patch version component of the current release
VersionMeta = "beta" // Version metadata to append to the version string
VersionMajor = 1 // Major version component of the current release
VersionMinor = 2 // Minor version component of the current release
VersionPatch = 8 // Patch version component of the current release
VersionMeta = "" // Version metadata to append to the version string
)
var GitCommit string