From 2be0a686e98420fa5de630003fa3dbad9bc3b4bf Mon Sep 17 00:00:00 2001 From: Julius Andrikonis Date: Tue, 24 Oct 2023 14:51:05 +0300 Subject: [PATCH] Documentation --- .../statemanager/sm_gpa/state_manager_gpa.go | 29 ++++++++++--------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/packages/chain/statemanager/sm_gpa/state_manager_gpa.go b/packages/chain/statemanager/sm_gpa/state_manager_gpa.go index 5692237a82..1a0dc13051 100644 --- a/packages/chain/statemanager/sm_gpa/state_manager_gpa.go +++ b/packages/chain/statemanager/sm_gpa/state_manager_gpa.go @@ -649,7 +649,7 @@ func (smT *stateManagerGPA) pruneStore(commitment *state.L1Commitment, stateInde // to the oldest unpruned block. Usually some block chain is currently known. // However the passed commitment might be newer and not contained in currently // known chain of blocks. The function attempts to use currently known chain as -// much ass possible: while building new chain of blocks, it attempts to find a +// much as possible: while building new chain of blocks, it attempts to find a // place to merge it with already known chain. After the merge it checks if the // end of the merged chain is still what it should be. // This function is extensively tested in `state_manager_gpa_cob_test.go` file. @@ -690,25 +690,29 @@ func (smT *stateManagerGPA) updateChainOfBlocks(commitment *state.L1Commitment, } var err error - // Find chain of newest blocks: the ones, that are newer than currently known chain + // Find chain of newest blocks: the ones, that has larger indexes than currently known chain if lastKnownBi != nil { for err == nil && bi != nil && bi.blockIndex > lastKnownBi.blockIndex && smT.store.HasTrieRoot(bi.trieRoot) { cob.AddStart(bi) bi, err = GetPreviousBlockInfoFun(bi) } } + // Remove blocks from currently known chain, that have larger indexes than + // the newest block: they are older than the newest block, but on the different + // branch of the chain. TODO: Instead of removing, the blocks should probably + // be pruned. if err == nil && bi != nil { for lastKnownBi != nil && lastKnownBi.blockIndex > bi.blockIndex { _ = smT.chainOfBlocks.RemoveEnd() lastKnownBi = GetLastKnownBlockInfoFun() } } - // Try to find a place to merge newest block chain with currently known block chain: `bi.trieRoot.Equals(lastKnownBi.trieRoot)`` + // Try to find a place to merge newest blocks chain with currently known blocks chain: `bi.trieRoot.Equals(lastKnownBi.trieRoot)`` for err == nil && bi != nil && lastKnownBi != nil && !bi.trieRoot.Equals(lastKnownBi.trieRoot) && smT.store.HasTrieRoot(bi.trieRoot) { // Normally, no iteration of this cycle should occur: once a common index - // is reached in previous cycle, trie roots should also match. In an unlikely + // is reached in previous cycles, trie roots should also match. In an unlikely // event of chain split, each iteration of this cycle fetches one older block - // to the newest blocks chain and drops (maybe it should prune) one + // to the newest blocks chain and drops (TODO: maybe it should prune) one // newest ("last known") block from currently known blocks chain. Hence, // this comparison of block indexes should still hold. if bi.blockIndex != lastKnownBi.blockIndex { @@ -721,13 +725,12 @@ func (smT *stateManagerGPA) updateChainOfBlocks(commitment *state.L1Commitment, _ = smT.chainOfBlocks.RemoveEnd() lastKnownBi = GetLastKnownBlockInfoFun() } - // Something failed when trying to construct a new chain if err != nil { smT.log.Errorf("Failed to obtain previous block info: %v", err) return } - if lastKnownBi == nil { // either there were no currently known block chain, - // or newest block chain had no common block infos + if lastKnownBi == nil { // either there were no currently known blocks chain, + // or newest blocks chain had no common block infos // (which is very unlikely): fill the chain from the store. for err == nil && bi != nil && smT.store.HasTrieRoot(bi.trieRoot) { cob.AddStart(bi) @@ -740,12 +743,12 @@ func (smT *stateManagerGPA) updateChainOfBlocks(commitment *state.L1Commitment, smT.chainOfBlocks = cob } else if bi == nil { // origin block has been reached smT.chainOfBlocks = cob - } else if bi.trieRoot.Equals(lastKnownBi.trieRoot) { // Here is the the place to merge newest block chain with currently known block chain + } else if bi.trieRoot.Equals(lastKnownBi.trieRoot) { // Here is the the place to merge newest blocks chain with currently known blocks chain // Normally newest blocks chain should contain only several (usually, 1) - // block indexes and currently known block chain should contain at least - // `PruningMinStatesToKeep` indexes, but on a sudden enabling of pruning - // might contain millions of them. Therefore it is more effective to copy - // newest block chain to the currently known one compared to doing it + // block infos and currently known blocks chain should contain at least + // `PruningMinStatesToKeep` block infos, but on a sudden enabling of pruning + // might contain millions of them. Therefore it is more efficient to copy + // newest blocks chain to the currently known one compared to doing it // the other way round. Let's merge them this way. for cob.Length() > 0 { bi = cob.RemoveStart()