status-im/status-go

package balance

import (
    "context"
    "math/big"
    "time"

    "github.com/jellydator/ttlcache/v3"

    "github.com/ethereum/go-ethereum/log"
)

var (
    defaultTTLValue = 5 * time.Minute
)

func NewCacherWithTTL(ttl time.Duration) Cacher {
    return newCacherImpl(newCacheWithTTL(ttl))
}

// TTL cache implementation of cacheIface
type ttlCache[K comparable, V any] struct {
    cache *ttlcache.Cache[K, V]
}

//nolint:golint,unused // linter does not detect using it via reflect
func (c *ttlCache[K, V]) get(key K) V {
    item := c.cache.Get(key)
    if item == nil {
        var v V
        return v
    }
    return item.Value()
}

//nolint:golint,unused // linter does not detect using it via reflect
func (c *ttlCache[K, V]) set(key K, value V) {
    _ = c.cache.Set(key, value, ttlcache.DefaultTTL)
}

//nolint:golint,unused // linter does not detect using it via reflect
func (c *ttlCache[K, V]) len() int {
    return c.cache.Len()
}

//nolint:golint,unused // linter does not detect using it via reflect
func (c *ttlCache[K, V]) keys() []K {
    return c.cache.Keys()
}

//nolint:golint,unused // linter does not detect using it via reflect
func (c *ttlCache[K, V]) init() {
    c.cache = ttlcache.New[K, V](
        ttlcache.WithTTL[K, V](defaultTTLValue),
    )
    c.cache.OnEviction(func(ctx context.Context, reason ttlcache.EvictionReason, item *ttlcache.Item[K, V]) {
        log.Debug("Evicting item from balance/nonce cache", "reason", reason, "key", item.Key, "value", item.Value)
    })
    go c.cache.Start() // starts automatic expired item deletion
}

//nolint:golint,unused // linter does not detect using it via reflect
func (c *ttlCache[K, V]) clear() {
    c.cache.DeleteAll()
}

// specializes generic cache
type cacheWithTTL struct {
    // TODO: use ttlCache instead of mapCache for nonceRangeCache. For that we need to update sortedRanges on item eviction
    // For now, nonceRanges cache is not updated on nonces items eviction, but it should not be as big as nonceCache is
    genericCache[*ttlCache[uint64, *big.Int], *ttlCache[uint64, *int64], *mapCache[int64, nonceRange]]
}

func newCacheWithTTL(ttl time.Duration) *cacheWithTTL {
    defaultTTLValue = ttl

    return &cacheWithTTL{
        genericCache: genericCache[*ttlCache[uint64, *big.Int], *ttlCache[uint64, *int64], *mapCache[int64, nonceRange]]{
            balances:        make(addressChainMap[*ttlCache[uint64, *big.Int]]),
            nonces:          make(addressChainMap[*ttlCache[uint64, *int64]]),
            nonceRangeCache: *newNonceRangeCache[*mapCache[int64, nonceRange]](),
        },
    }
}

func (c *cacheWithTTL) Clear() {
    c.rw.Lock()
    defer c.rw.Unlock()

    // TTL cache removes expired items automatically
    // but in case we want to clear it manually we can do it here
    for _, chainCache := range c.balances {
        for _, cache := range chainCache {
            cache.clear()
        }
    }

    for _, chainCache := range c.nonces {
        for _, cache := range chainCache {
            cache.clear()
        }
    }

    c.nonceRangeCache.clear()
}