Trie prunning async trigger

consensus/spos/bls/v2/subroundBlock.go

@@ -788,7 +788,7 @@ func (sr *subroundBlock) processBlock(
 		return false
 	}
 
-	if !sr.GetHeader().IsHeaderV3() {
+	if !check.IfNil(sr.GetHeader()) && !sr.GetHeader().IsHeaderV3() {
 		sr.ConsensusCoreHandler.ScheduledProcessor().StartScheduledProcessing(sr.GetHeader(), sr.GetBody(), sr.GetRoundTimeStamp())
 	}
 

epochStart/bootstrap/disabled/disabledAccountsAdapter.go

@@ -99,6 +99,10 @@ func (a *accountsAdapter) RecreateTrieIfNeeded(_ common.RootHashHolder) error {
 func (a *accountsAdapter) CancelPrune(_ []byte, _ state.TriePruningIdentifier) {
 }
 
+// ResetPruning -
+func (a *accountsAdapter) ResetPruning() {
+}
+
 // SnapshotState -
 func (a *accountsAdapter) SnapshotState(_ []byte, _ uint32) {
 }

integrationTests/mock/blockProcessorMock.go

@@ -43,6 +43,7 @@ type BlockProcessorMock struct {
 	) error
 	OnExecutedBlockCalled                           func(header data.HeaderHandler, rootHash []byte) error
 	ProposedDirectSentTransactionsToBroadcastCalled func(proposedBody data.BodyHandler) map[string][][]byte
+	PruneTrieAsyncHeaderCalled                      func()
 }
 
 // ProcessBlock mocks processing a block
@@ -231,6 +232,13 @@ func (bpm *BlockProcessorMock) RemoveHeaderFromPool(headerHash []byte) {
 	}
 }
 
+// PruneTrieAsyncHeader -
+func (bpm *BlockProcessorMock) PruneTrieAsyncHeader() {
+	if bpm.PruneTrieAsyncHeaderCalled != nil {
+		bpm.PruneTrieAsyncHeaderCalled()
+	}
+}
+
 // VerifyBlockProposal -
 func (bpm *BlockProcessorMock) VerifyBlockProposal(
 	headerHandler data.HeaderHandler,

process/asyncExecution/headersExecutor.go

@@ -364,6 +364,8 @@ func (he *headersExecutor) process(pair cache.HeaderBodyPair) error {
 		return nil
 	}
 
+	he.blockProcessor.PruneTrieAsyncHeader()
+
 	he.blockChain.SetFinalBlockInfo(
 		executionResult.GetHeaderNonce(),
 		executionResult.GetHeaderHash(),

process/asyncExecution/interface.go

@@ -25,5 +25,6 @@ type BlockProcessor interface {
 	ProcessBlockProposal(header data.HeaderHandler, headerHash []byte, body data.BodyHandler) (data.BaseExecutionResultHandler, error)
 	CommitBlockProposalState(headerHandler data.HeaderHandler) error
 	RevertBlockProposalState()
+	PruneTrieAsyncHeader()
 	IsInterfaceNil() bool
 }

process/block/baseProcess.go

@@ -152,6 +152,10 @@ type baseProcessor struct {
 	aotSelector                        process.AOTTransactionSelector
 	maxProposalNonceGap                uint64
 	closingNodeStarted                 *atomic.Bool
+
+	lastPrunedHeaderHash  []byte
+	lastPrunedHeaderNonce uint64
+	mutLastPrunedHeader   sync.RWMutex
 }
 
 type bootStorerDataArgs struct {
@@ -4032,3 +4036,80 @@ func (bp *baseProcessor) saveEpochStartEconomicsMetrics(epochStartMetaBlock data
 	bp.appStatusHandler.SetStringValue(common.MetricTotalFees, epochStartMetaBlock.GetAccumulatedFeesInEpoch().String())
 	bp.appStatusHandler.SetStringValue(common.MetricDevRewardsInEpoch, epochStartMetaBlock.GetDevFeesInEpoch().String())
 }
+
+// PruneTrieAsyncHeader will trigger trie pruning for header from async execution flow
+func (bp *baseProcessor) PruneTrieAsyncHeader() {
+	bp.mutLastPrunedHeader.Lock()
+	defer bp.mutLastPrunedHeader.Unlock()
+
+	header := bp.blockChain.GetCurrentBlockHeader()
+	headerHash := bp.blockChain.GetCurrentBlockHeaderHash()
+
+	if len(bp.lastPrunedHeaderHash) == 0 {
+		// last pruned header hash not set, trigger prune trie for the provided header
+		bp.blockProcessor.pruneTrieHeaderV3(header)
+		bp.lastPrunedHeaderHash = headerHash
+		bp.lastPrunedHeaderNonce = header.GetNonce()
+		return
+	}
+
+	// extra check by nonce
+	if header.GetNonce() <= bp.lastPrunedHeaderNonce {
+		return
+	}
+
+	err := bp.pruneTrieForHeadersUnprotected(headerHash, header)
+	if err != nil {
+		// there was an error while fetching intermediate headers
+		// reset pruning context
+		bp.blockProcessor.resetPruning()
+	}
+
+	bp.lastPrunedHeaderHash = headerHash
+	bp.lastPrunedHeaderNonce = header.GetNonce()
+}
+
+func (bp *baseProcessor) pruneTrieForHeadersUnprotected(
+	headerHash []byte,
+	header data.HeaderHandler,
+) error {
+	if bytes.Equal(headerHash, bp.lastPrunedHeaderHash) {
+		return nil
+	}
+
+	headersToPrune := make([]data.HeaderHandler, 0)
+	headersToPrune = append(headersToPrune, header)
+
+	lastPrunedHeaderHash := bp.lastPrunedHeaderHash
+	walkerHash := header.GetPrevHash()
+
+	for !bytes.Equal(walkerHash, lastPrunedHeaderHash) {
+		// headers pool is cleaned on consensus flow based on last execution result
+		// included on the committed header (plus some delta), so intermediate headers
+		// should be available in pool, since trie pruning is triggered from
+		// execution flow; if there are no included blocks from execution flow
+		// (and not pruning triggered) headers will not be removed from pool
+		header, err := process.GetHeader(
+			walkerHash,
+			bp.dataPool.Headers(),
+			bp.store,
+			bp.marshalizer,
+			header.GetShardID(),
+		)
+		if err != nil {
+			log.Warn("failed to get intermediate header for pruning", "error", err)
+			return err
+		}
+
+		headersToPrune = append(headersToPrune, header)
+
+		walkerHash = header.GetPrevHash()
+	}
+
+	for i := len(headersToPrune) - 1; i >= 0; i-- {
+		header := headersToPrune[i]
+		bp.blockProcessor.pruneTrieHeaderV3(header)
+	}
+
+	return nil
+}