core/filtermaps: fix log value search range (#31734)

This PR fixes the out-of-range block number logic of `getBlockLvPointer`
which sometimes caused searches to fail if the head was updated in the
wrong moment. This logic ensures that querying the pointer of a future
block returns the pointer after the last fully indexed block (instead of
failing) and therefore an async range update will not cause the search
to fail. Earier this behaviour only worked when `headIndexed` was true
and `headDelimiter` pointed to the end of the indexed range. Now it also
works for an unfinished index.

This logic is also moved from `FilterMaps.getBlockLvPointer` to
`FilterMapsMatcherBackend.GetBlockLvPointer` because it is only required
by the search anyways. `FilterMaps.getBlockLvPointer` now only returns a
pointer for existing blocks, consistently with how it is used in the
indexer/renderer.

Note that this unhandled case has been present in the code for a long
time but went unnoticed because either one of two previously fixed bugs
did prevent it from being triggered; the incorrectly positive
`tempRange.headIndexed` (fixed in
ethereum/go-ethereum#31680), though caused other
problems, prevented this one from being triggered as with a positive
`headIndexed` no database read was triggered in `getBlockLvPointer`.
Also, the unnecessary `indexLock` in `synced()` (fixed in
ethereum/go-ethereum#31708) usually did prevent
the search seeing the temp range and therefore avoided noticeable
issues.

Author: zsfelfoldi

core/filtermaps/filtermaps.go

@@ -662,15 +662,11 @@ func (f *FilterMaps) mapRowIndex(mapIndex, rowIndex uint32) uint64 {
 }
 
 // getBlockLvPointer returns the starting log value index where the log values
-// generated by the given block are located. If blockNumber is beyond the current
-// head then the first unoccupied log value index is returned.
+// generated by the given block are located.
 //
 // Note that this function assumes that the indexer read lock is being held when
 // called from outside the indexerLoop goroutine.
 func (f *FilterMaps) getBlockLvPointer(blockNumber uint64) (uint64, error) {
-	if blockNumber >= f.indexedRange.blocks.AfterLast() && f.indexedRange.headIndexed {
-		return f.indexedRange.headDelimiter + 1, nil
-	}
 	if lvPointer, ok := f.lvPointerCache.Get(blockNumber); ok {
 		return lvPointer, nil
 	}

core/filtermaps/matcher_backend.go

@@ -82,13 +82,26 @@ func (fm *FilterMapsMatcherBackend) GetFilterMapRow(ctx context.Context, mapInde
 }
 
 // GetBlockLvPointer returns the starting log value index where the log values
-// generated by the given block are located. If blockNumber is beyond the current
-// head then the first unoccupied log value index is returned.
+// generated by the given block are located. If blockNumber is beyond the last
+// indexed block then the pointer will point right after this block, ensuring
+// that the matcher does not fail and can return a set of results where the
+// valid range is correct.
 // GetBlockLvPointer implements MatcherBackend.
 func (fm *FilterMapsMatcherBackend) GetBlockLvPointer(ctx context.Context, blockNumber uint64) (uint64, error) {
 	fm.f.indexLock.RLock()
 	defer fm.f.indexLock.RUnlock()
 
+	if blockNumber >= fm.f.indexedRange.blocks.AfterLast() {
+		if fm.f.indexedRange.headIndexed {
+			// return index after head block
+			return fm.f.indexedRange.headDelimiter + 1, nil
+		}
+		if fm.f.indexedRange.blocks.Count() > 0 {
+			// return index at the beginning of the last, partially indexed
+			// block (after the last fully indexed one)
+			blockNumber = fm.f.indexedRange.blocks.Last()
+		}
+	}
 	return fm.f.getBlockLvPointer(blockNumber)
 }