⚡️ perf: cache pools in FSM state machine

Adds an in-memory pool cache to StateMachine, mirroring the existing
accounts cache. GetPool checks the cache before hitting Pebble; SetPool
populates the cache after a successful store write (cache-after-write
avoids leaking uncommitted state if the store op fails).

Returned and cached pools are deep-cloned via clonePool() to prevent
pointer aliasing on the Points slice — a caller mutating its returned
Pool.Points cannot affect the cached entry, and SetPool callers cannot
leak external mutation into the cache.

The pools map is wired through New(), Copy(), and ResetCaches() so
it is invalidated on per-tx rollback (state.go:338) and per-block
reset, alongside the accounts cache.

Targets the per-block 90s GetPool cost observed in staging localnet-1
profiling (177K calls × 0.504ms).

Author: ezeike

fsm/account.go

@@ -253,6 +253,19 @@ func (s *StateMachine) marshalAccount(account *Account) ([]byte, lib.ErrorI) {
 	to simply prove that no-one owns the private key for that account
 */
 
+// clonePool returns an independent copy of the pool so callers can mutate without
+// affecting the cached entry (Pool.Points is a slice of pointers).
+func clonePool(p *Pool) *Pool {
+	out := &Pool{Id: p.Id, Amount: p.Amount, TotalPoolPoints: p.TotalPoolPoints}
+	if len(p.Points) > 0 {
+		out.Points = make([]*lib.PoolPoints, len(p.Points))
+		for i, pp := range p.Points {
+			out.Points[i] = &lib.PoolPoints{Address: pp.Address, Points: pp.Points}
+		}
+	}
+	return out
+}
+
 // GetPool() returns a Pool structure for a specific ID
 func (s *StateMachine) GetPool(id uint64) (*Pool, lib.ErrorI) {
 	startTime := time.Now()
@@ -261,6 +274,10 @@ func (s *StateMachine) GetPool(id uint64) (*Pool, lib.ErrorI) {
 			s.Metrics.StateOperationTime.WithLabelValues("get_pool").Observe(time.Since(startTime).Seconds())
 		}
 	}()
+	// check cache (return clone to prevent aliasing on the cached struct)
+	if pool, found := s.cache.pools[id]; found {
+		return clonePool(pool), nil
+	}
 	// get the pool bytes from the state using the Key a specific id
 	bz, err := s.Get(KeyForPool(id))
 	if err != nil {
@@ -273,6 +290,8 @@ func (s *StateMachine) GetPool(id uint64) (*Pool, lib.ErrorI) {
 	}
 	// set the pool id from the key
 	pool.Id = id
+	// populate cache with a clone so the returned pointer is not aliased
+	s.cache.pools[id] = clonePool(pool)
 	// return the pool
 	return pool, nil
 }
@@ -334,7 +353,13 @@ func (s *StateMachine) SetPool(pool *Pool) (err lib.ErrorI) {
 	}()
 	// if the pool has a 0 balance
 	if pool.Amount == 0 {
-		return s.Delete(KeyForPool(pool.Id))
+		if err = s.Delete(KeyForPool(pool.Id)); err != nil {
+			return
+		}
+		// cache a clone after successful delete (matches accounts cache: zero-amount is
+		// indistinguishable from a missing entry via unmarshalPool(nil))
+		s.cache.pools[pool.Id] = clonePool(pool)
+		return
 	}
 	// convert the pool to bytes
 	bz, err := s.marshalPool(pool)
@@ -345,6 +370,9 @@ func (s *StateMachine) SetPool(pool *Pool) (err lib.ErrorI) {
 	if err = s.Set(KeyForPool(pool.Id), bz); err != nil {
 		return
 	}
+	// cache a clone after successful write so external mutation of the passed-in pool
+	// cannot leak into the cache
+	s.cache.pools[pool.Id] = clonePool(pool)
 	return
 }
 

fsm/state.go

@@ -45,6 +45,7 @@ type rootCacheStateStore interface {
 // cache is the set of items to be cached used by the state machine
 type cache struct {
 	accounts     map[uint64]*Account // cache of accounts accessed
+	pools        map[uint64]*Pool    // cache of pools accessed
 	feeParams    *FeeParams          // fee params for the current block
 	valParams    *ValidatorParams    // validator params for the current block
 	rootDexBatch *lib.DexBatch       // root dex batch
@@ -66,6 +67,7 @@ func New(c lib.Config, store lib.StoreI, plugin *lib.Plugin, metrics *lib.Metric
 		events:            new(lib.EventsTracker),
 		cache: &cache{
 			accounts: make(map[uint64]*Account),
+			pools:    make(map[uint64]*Pool),
 		},
 	}
 	// initialize the state machine
@@ -604,6 +606,7 @@ func (s *StateMachine) Copy() (*StateMachine, lib.ErrorI) {
 		log:                s.log,
 		cache: &cache{
 			accounts:     make(map[uint64]*Account),
+			pools:        make(map[uint64]*Pool),
 			rootDexBatch: s.cache.rootDexBatch,
 		},
 		LastValidatorSet: s.LastValidatorSet,
@@ -714,6 +717,7 @@ func (s *StateMachine) Reset() {
 // ResetCaches() dumps the state machine caches
 func (s *StateMachine) ResetCaches() {
 	s.cache.accounts = make(map[uint64]*Account)
+	s.cache.pools = make(map[uint64]*Pool)
 	// Params caches must not outlive the current store view, otherwise Reset()/rollback
 	// can leave the FSM reading stale values that disagree with the underlying store.
 	s.cache.valParams = nil

fsm/state_test.go

@@ -73,6 +73,7 @@ func TestInitialize(t *testing.T) {
 				log: log,
 				cache: &cache{
 					accounts: make(map[uint64]*Account),
+					pools:    make(map[uint64]*Pool),
 				},
 			}
 			// set the data dir path
@@ -415,6 +416,7 @@ func newTestStateMachine(t *testing.T) StateMachine {
 		log:    log,
 		cache: &cache{
 			accounts: make(map[uint64]*Account),
+			pools:    make(map[uint64]*Pool),
 		},
 	}
 	require.NoError(t, sm.SetParams(DefaultParams()))