Normalize naming prevStep -> step (#17726)

Small rename refactoring to clarify meaning in the code:

- The concept of "prev step" is only used in SharedDomains as
GetLatest() is used as prev value of next mutation
- Inside GetLatest() chain of calls it is actually just the step whose
that latest mutation occurred, "prev step" sounds strange and confusing
when reading the code
- Most of GetLatest() chain of calls are already using only "step" as
the named variable, so this PR just completes the standardization of
naming.

Author: wmitsuda

db/kv/kv_interface.go

@@ -468,7 +468,7 @@ type TemporalDebugDB interface {
 type TemporalMemBatch interface {
 	DomainPut(domain Domain, k string, v []byte, txNum uint64, preval []byte, prevStep Step) error
 	DomainDel(domain Domain, k string, txNum uint64, preval []byte, prevStep Step) error
-	GetLatest(table Domain, key []byte) (v []byte, prevStep Step, ok bool)
+	GetLatest(domain Domain, key []byte) (v []byte, step Step, ok bool)
 	GetDiffset(tx RwTx, blockHash common.Hash, blockNumber uint64) ([DomainLen][]DomainEntryDiff, bool, error)
 	ClearRam()
 	IndexAdd(table InvertedIdx, key []byte, txNum uint64) (err error)

db/state/domain_stream.go

@@ -49,7 +49,7 @@ type CursorItem struct {
 	cDup    kv.CursorDupSort
 	cNonDup kv.Cursor
 
-	iter         btree2.MapIter[string, dataWithPrevStep]
+	iter         btree2.MapIter[string, dataWithStep]
 	idx          *seg.Reader
 	hist         *seg.PagedReader
 	btCursor     *Cursor
@@ -313,7 +313,7 @@ func (hi *DomainLatestIterFile) Next() ([]byte, []byte, error) {
 // debugIteratePrefix iterates over key-value pairs of the storage domain that start with given prefix
 //
 // k and v lifetime is bounded by the lifetime of the iterator
-func (dt *DomainRoTx) debugIteratePrefixLatest(prefix []byte, ramIter btree2.MapIter[string, dataWithPrevStep], it func(k []byte, v []byte, step kv.Step) (cont bool, err error), roTx kv.Tx) error {
+func (dt *DomainRoTx) debugIteratePrefixLatest(prefix []byte, ramIter btree2.MapIter[string, dataWithStep], it func(k []byte, v []byte, step kv.Step) (cont bool, err error), roTx kv.Tx) error {
 	// Implementation:
 	//     File endTxNum  = last txNum of file step
 	//     DB endTxNum    = first txNum of step in db

db/state/execctx/domain_shared.go

@@ -274,9 +274,9 @@ func (sd *SharedDomains) GetLatest(domain kv.Domain, tx kv.TemporalTx, k []byte)
 		return nil, 0, errors.New("sd.GetLatest: unexpected nil tx")
 	}
 	start := time.Now()
-	if v, prevStep, ok := sd.mem.GetLatest(domain, k); ok {
+	if v, _step, ok := sd.mem.GetLatest(domain, k); ok {
 		sd.metrics.UpdateCacheReads(domain, start)
-		return v, prevStep, nil
+		return v, _step, nil
 	}
 	//if aggTx, ok := tx.AggTx().(*state.AggregatorRoTx); ok {
 	//	v, step, _, err = aggTx.getLatest(domain, k, tx, &sd.metrics, start)

db/state/temporal_mem_batch.go

@@ -37,10 +37,10 @@ const (
 	put
 )
 
-type dataWithPrevStep struct {
-	data     []byte
-	prevStep kv.Step
-	dir      iodir
+type dataWithStep struct {
+	data []byte
+	step kv.Step
+	dir  iodir
 }
 
 // TemporalMemBatch - temporal read-write interface - which storing updates in RAM. Don't forget to call `.Flush()`
@@ -50,8 +50,8 @@ type TemporalMemBatch struct {
 	getCacheSize int
 
 	latestStateLock sync.RWMutex
-	domains         [kv.DomainLen]map[string]dataWithPrevStep
-	storage         *btree2.Map[string, dataWithPrevStep] // TODO: replace hardcoded domain name to per-config configuration of available Guarantees/AccessMethods (range vs get)
+	domains         [kv.DomainLen]map[string]dataWithStep
+	storage         *btree2.Map[string, dataWithStep] // TODO: replace hardcoded domain name to per-config configuration of available Guarantees/AccessMethods (range vs get)
 
 	domainWriters   [kv.DomainLen]*DomainBufferedWriter
 	iiWriters       []*InvertedIndexBufferedWriter
@@ -64,7 +64,7 @@ type TemporalMemBatch struct {
 
 func NewTemporalMemBatch(tx kv.TemporalTx, ioMetrics interface{}) *TemporalMemBatch {
 	sd := &TemporalMemBatch{
-		storage: btree2.NewMap[string, dataWithPrevStep](128),
+		storage: btree2.NewMap[string, dataWithStep](128),
 		metrics: ioMetrics.(*changeset.DomainMetrics),
 	}
 	aggTx := AggTx(tx)
@@ -77,7 +77,7 @@ func NewTemporalMemBatch(tx kv.TemporalTx, ioMetrics interface{}) *TemporalMemBa
 	}
 
 	for id, d := range aggTx.d {
-		sd.domains[id] = map[string]dataWithPrevStep{}
+		sd.domains[id] = map[string]dataWithStep{}
 		sd.domainWriters[id] = d.NewWriter()
 	}
 
@@ -109,10 +109,10 @@ func (sd *TemporalMemBatch) putHistory(domain kv.Domain, k, v []byte, txNum uint
 func (sd *TemporalMemBatch) putLatest(domain kv.Domain, key string, val []byte, txNum uint64) {
 	sd.latestStateLock.Lock()
 	defer sd.latestStateLock.Unlock()
-	valWithPrevStep := dataWithPrevStep{data: val, prevStep: kv.Step(txNum / sd.stepSize)}
+	valWithStep := dataWithStep{data: val, step: kv.Step(txNum / sd.stepSize)}
 	putSize := 0
 	if domain == kv.StorageDomain {
-		if old, ok := sd.storage.Set(key, valWithPrevStep); ok {
+		if old, ok := sd.storage.Set(key, valWithStep); ok {
 			putSize += len(val) - len(old.data)
 		} else {
 			putSize += len(key) + len(val)
@@ -139,7 +139,7 @@ func (sd *TemporalMemBatch) putLatest(domain kv.Domain, key string, val []byte,
 	} else {
 		putSize += len(key) + len(val)
 	}
-	sd.domains[domain][key] = valWithPrevStep
+	sd.domains[domain][key] = valWithStep
 
 	if dm, ok := sd.metrics.Domains[domain]; ok {
 		dm.CachePutCount++
@@ -156,20 +156,20 @@ func (sd *TemporalMemBatch) putLatest(domain kv.Domain, key string, val []byte,
 	sd.metrics.Unlock()
 }
 
-func (sd *TemporalMemBatch) GetLatest(table kv.Domain, key []byte) (v []byte, prevStep kv.Step, ok bool) {
+func (sd *TemporalMemBatch) GetLatest(domain kv.Domain, key []byte) (v []byte, step kv.Step, ok bool) {
 	sd.latestStateLock.RLock()
 	defer sd.latestStateLock.RUnlock()
 
 	keyS := toStringZeroCopy(key)
-	var dataWithPrevStep dataWithPrevStep
-	if table == kv.StorageDomain {
-		dataWithPrevStep, ok = sd.storage.Get(keyS)
-		return dataWithPrevStep.data, dataWithPrevStep.prevStep, ok
+	var dataWithStep dataWithStep
+	if domain == kv.StorageDomain {
+		dataWithStep, ok = sd.storage.Get(keyS)
+		return dataWithStep.data, dataWithStep.step, ok
 
 	}
 
-	dataWithPrevStep, ok = sd.domains[table][keyS]
-	return dataWithPrevStep.data, dataWithPrevStep.prevStep, ok
+	dataWithStep, ok = sd.domains[domain][keyS]
+	return dataWithStep.data, dataWithStep.step, ok
 }
 
 func (sd *TemporalMemBatch) SizeEstimate() uint64 {
@@ -185,10 +185,10 @@ func (sd *TemporalMemBatch) ClearRam() {
 	sd.latestStateLock.Lock()
 	defer sd.latestStateLock.Unlock()
 	for i := range sd.domains {
-		sd.domains[i] = map[string]dataWithPrevStep{}
+		sd.domains[i] = map[string]dataWithStep{}
 	}
 
-	sd.storage = btree2.NewMap[string, dataWithPrevStep](128)
+	sd.storage = btree2.NewMap[string, dataWithStep](128)
 	sd.metrics.Lock()
 	defer sd.metrics.Unlock()
 	sd.metrics.CachePutSize = 0
@@ -202,7 +202,7 @@ func (sd *TemporalMemBatch) ClearRam() {
 func (sd *TemporalMemBatch) IteratePrefix(domain kv.Domain, prefix []byte, roTx kv.Tx, it func(k []byte, v []byte, step kv.Step) (cont bool, err error)) error {
 	sd.latestStateLock.RLock()
 	defer sd.latestStateLock.RUnlock()
-	var ramIter btree2.MapIter[string, dataWithPrevStep]
+	var ramIter btree2.MapIter[string, dataWithStep]
 	if domain == kv.StorageDomain {
 		ramIter = sd.storage.Iter()
 	}