tapdb: replace confg arg proof count cache limit with size-based limit

- Replace `proofs-per-universe` configuration with
  `max-proof-cache-size`, allowing proof cache limits to be defined by
  total memory size instead of proof count.
- Add logic to parse and handle human-readable size values
  (e.g., "32MB").
- Update default configuration and related comments.
- Adjust `NewMultiverseStore` to use parsed cache size values and
  improve error handling.

Author: ffranr

go.mod

@@ -16,6 +16,7 @@ require (
 	github.com/caddyserver/certmagic v0.17.2
 	github.com/davecgh/go-spew v1.1.1
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0
+	github.com/dustin/go-humanize v1.0.1
 	github.com/go-errors/errors v1.0.1
 	github.com/golang-migrate/migrate/v4 v4.17.0
 	github.com/grpc-ecosystem/go-grpc-middleware v1.4.0
@@ -85,7 +86,6 @@ require (
 	github.com/docker/docker v28.1.1+incompatible // indirect
 	github.com/docker/go-connections v0.5.0 // indirect
 	github.com/docker/go-units v0.5.0 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/fergusstrange/embedded-postgres v1.25.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect

sample-tapd.conf

@@ -388,8 +388,9 @@
 
 [multiverse-caches]
 
-; The number of proofs that are cached per universe. (default: 5)
-; universe.multiverse-caches.proofs-per-universe=5
+; The maximum total size of the cached proofs. Accepts human readable values
+; such as 32MB or 1GB. (default: 32MB)
+; universe.multiverse-caches.max-proof-cache-size=32MB
 
 ; The number of universes that can have a cache of leaf keys. (default: 2000)
 ; universe.multiverse-caches.leaves-num-cached-universes=2000

tapdb/multiverse.go

@@ -144,6 +144,11 @@ type MultiverseStore struct {
 func NewMultiverseStore(db BatchedMultiverse,
 	cfg *MultiverseStoreConfig) (*MultiverseStore, error) {
 
+	proofCacheSize, err := cfg.Caches.maxProofCacheSizeBytes()
+	if err != nil {
+		return nil, fmt.Errorf("parse max proof cache size: %w", err)
+	}
+
 	return &MultiverseStore{
 		db:  db,
 		cfg: cfg,
@@ -154,9 +159,7 @@ func NewMultiverseStore(db BatchedMultiverse,
 		rootNodeCache: newRootNodeCache(
 			cfg.Caches.RootNodePageCacheSize,
 		),
-		proofCache: newUniverseProofCache(
-			cfg.Caches.ProofsPerUniverse,
-		),
+		proofCache: newUniverseProofCache(proofCacheSize),
 		leafKeysCache: newUniverseLeafPageCache(
 			cfg.Caches.LeavesNumCachedUniverses,
 			cfg.Caches.LeavesPerUniverse,

tapdb/multiverse_cache.go

@@ -2,27 +2,33 @@ package tapdb
 
 import (
 	"bytes"
+	"fmt"
 	"slices"
 	"sort"
 	"sync"
 	"sync/atomic"
 
+	"github.com/dustin/go-humanize"
 	"github.com/lightninglabs/neutrino/cache/lru"
 	"github.com/lightninglabs/taproot-assets/universe"
 	"github.com/lightningnetwork/lnd/lnutils"
 )
 
+const (
+	// defaultMaxProofCacheSize is the default maximum size of the proof
+	// cache expressed as a human-readable string type so that we can
+	// present it directly to CLI users.
+	defaultMaxProofCacheSize = "32MB"
+)
+
 // MultiverseCacheConfig is the configuration for the different multiverse
 // caches that exist.
 //
 //nolint:lll
 type MultiverseCacheConfig struct {
-	// ProofsPerUniverse is the number of proofs that are cached per
-	// universe. This number needs to be multiplied by the total number of
-	// universes to get the total number of proofs that are cached. There is
-	// no limit to the number of universes that can hold cached keys, so a
-	// cache is created for each universe that receives a request.
-	ProofsPerUniverse uint64 `long:"proofs-per-universe" description:"The number of proofs that are cached per universe."`
+	// MaxProofCacheSize is the maximum size of the proof cache expressed
+	// as a human-readable string, for example, "32MB" or "1GB".
+	MaxProofCacheSize string `long:"max-proof-cache-size" description:"The maximum total size of the cached proofs. Accepts human readable values such as 32MB or 1GB."`
 
 	// LeavesNumCachedUniverses is the number of universes that can have a
 	// cache of leaf keys. Each cached universe can have up to
@@ -56,7 +62,7 @@ type MultiverseCacheConfig struct {
 // multiverse cache.
 func DefaultMultiverseCacheConfig() MultiverseCacheConfig {
 	return MultiverseCacheConfig{
-		ProofsPerUniverse:        5,
+		MaxProofCacheSize:        defaultMaxProofCacheSize,
 		LeavesNumCachedUniverses: 2_000,
 		LeavesPerUniverse:        50,
 		SyncerCacheEnabled:       false,
@@ -65,6 +71,22 @@ func DefaultMultiverseCacheConfig() MultiverseCacheConfig {
 	}
 }
 
+// maxProofCacheSizeBytes returns the parsed byte representation of the proof
+// cache size limit.
+func (c MultiverseCacheConfig) maxProofCacheSizeBytes() (uint64, error) {
+	sizeStr := c.MaxProofCacheSize
+	if sizeStr == "" {
+		sizeStr = defaultMaxProofCacheSize
+	}
+
+	sizeBytes, err := humanize.ParseBytes(sizeStr)
+	if err != nil {
+		return 0, fmt.Errorf("parse max proof cache size: %w", err)
+	}
+
+	return sizeBytes, nil
+}
+
 // cachedProofs is a list of cached proof leaves.
 type cachedProofs []*universe.Proof