address+tapdb: add cache for decimal display

To avoid needing to make a DB query for each asset to find out its
decimal display value, we cache it upon first request.

Author: guggero

address/book.go

@@ -137,6 +137,11 @@ type Storage interface {
 	// transfer comes in later on.
 	InsertScriptKey(ctx context.Context, scriptKey asset.ScriptKey,
 		keyType asset.ScriptKeyType) error
+
+	// FetchAllAssetMeta attempts to fetch all asset meta known to the
+	// database.
+	FetchAllAssetMeta(
+		ctx context.Context) (map[asset.ID]*proof.MetaReveal, error)
 }
 
 // KeyRing is used to create script and internal keys for Taproot Asset
@@ -190,6 +195,14 @@ type Book struct {
 	// subscriberMtx guards the subscribers map and access to the
 	// subscriptionID.
 	subscriberMtx sync.Mutex
+
+	// decimalDisplayCache is a cache for the decimal display value of
+	// assets. This is used to avoid repeated database queries for the same
+	// asset ID.
+	decimalDisplayCache map[asset.ID]fn.Option[uint32]
+
+	// decDisplayCacheMtx guards the decimalDisplayCache map.
+	decDisplayCacheMtx sync.Mutex
 }
 
 // A compile-time assertion to make sure Book satisfies the
@@ -203,6 +216,7 @@ func NewBook(cfg BookConfig) *Book {
 		subscribers: make(
 			map[uint64]*fn.EventReceiver[*AddrWithKeyInfo],
 		),
+		decimalDisplayCache: make(map[asset.ID]fn.Option[uint32]),
 	}
 }
 
@@ -339,13 +353,61 @@ func (b *Book) FetchAssetMetaForAsset(ctx context.Context,
 func (b *Book) DecDisplayForAssetID(ctx context.Context,
 	id asset.ID) (fn.Option[uint32], error) {
 
+	b.decDisplayCacheMtx.Lock()
+	defer b.decDisplayCacheMtx.Unlock()
+
+	// If we don't have anything in the cache, we'll attempt to load it.
+	// This will be re-attempted every time if there are no assets in the
+	// database. But this isn't expected to remain the case for long.
+	if len(b.decimalDisplayCache) == 0 {
+		// If the cache is empty, we'll populate it with all asset
+		// metas known to the database.
+		allMeta, err := b.cfg.Store.FetchAllAssetMeta(ctx)
+		if err != nil {
+			return fn.None[uint32](), fmt.Errorf("unable to fetch "+
+				"all asset meta: %v", err)
+		}
+
+		for assetID, meta := range allMeta {
+			if meta == nil {
+				continue
+			}
+
+			displayOpt, err := meta.DecDisplayOption()
+			if err != nil {
+				return fn.None[uint32](), fmt.Errorf("unable "+
+					"to extract decimal display option "+
+					"for asset %v: %v", assetID, err)
+			}
+
+			b.decimalDisplayCache[assetID] = displayOpt
+		}
+	}
+
+	// If we have the value in the cache, return it from there.
+	if displayOpt, ok := b.decimalDisplayCache[id]; ok {
+		return displayOpt, nil
+	}
+
+	// If we don't have the value in the cache, it was added after we filled
+	// the cache, and we'll attempt to fetch the asset meta from the
+	// database instead.
 	meta, err := b.FetchAssetMetaForAsset(ctx, id)
 	if err != nil {
 		return fn.None[uint32](), fmt.Errorf("unable to fetch asset "+
 			"meta for asset_id=%v :%v", id, err)
 	}
 
-	return meta.DecDisplayOption()
+	opt, err := meta.DecDisplayOption()
+	if err != nil {
+		return fn.None[uint32](), fmt.Errorf("unable to extract "+
+			"decimal display option for asset %v: %v", id, err)
+	}
+
+	// Store the value in the cache for future lookups.
+	b.decimalDisplayCache[id] = opt
+
+	return opt, nil
 }
 
 // NewAddress creates a new Taproot Asset address based on the input parameters.

tapdb/addrs.go

@@ -80,6 +80,10 @@ type (
 
 	// AssetMeta is the metadata record for an asset.
 	AssetMeta = sqlc.FetchAssetMetaForAssetRow
+
+	// AllAssetMetaRow is a type alias for fetching all asset metadata
+	// records.
+	AllAssetMetaRow = sqlc.FetchAllAssetMetaRow
 )
 
 var (
@@ -180,6 +184,10 @@ type AddrBook interface {
 	// FetchAssetMetaForAsset fetches the asset meta for a given asset.
 	FetchAssetMetaForAsset(ctx context.Context,
 		assetID []byte) (AssetMeta, error)
+
+	// FetchAllAssetMeta fetches all asset metadata records from the
+	// database.
+	FetchAllAssetMeta(ctx context.Context) ([]AllAssetMetaRow, error)
 }
 
 // AddrBookTxOptions defines the set of db txn options the AddrBook
@@ -1164,6 +1172,49 @@ func (t *TapAddressBook) FetchAssetMetaForAsset(ctx context.Context,
 	return assetMeta, nil
 }
 
+// FetchAllAssetMeta attempts to fetch all asset meta known to the database.
+func (t *TapAddressBook) FetchAllAssetMeta(
+	ctx context.Context) (map[asset.ID]*proof.MetaReveal, error) {
+
+	var assetMetas map[asset.ID]*proof.MetaReveal
+
+	readOpts := NewAssetStoreReadTx()
+	dbErr := t.db.ExecTx(ctx, &readOpts, func(q AddrBook) error {
+		dbMetas, err := q.FetchAllAssetMeta(ctx)
+		if err != nil {
+			return err
+		}
+
+		assetMetas = make(map[asset.ID]*proof.MetaReveal, len(dbMetas))
+		for _, dbMeta := range dbMetas {
+			// If no record is present, we should get a
+			// sql.ErrNoRows error
+			// above.
+			metaOpt, err := parseAssetMetaReveal(dbMeta.AssetsMetum)
+			if err != nil {
+				return fmt.Errorf("unable to parse asset "+
+					"meta: %w", err)
+			}
+
+			metaOpt.WhenSome(func(meta proof.MetaReveal) {
+				var id asset.ID
+				copy(id[:], dbMeta.AssetID)
+				assetMetas[id] = &meta
+			})
+		}
+
+		return nil
+	})
+	switch {
+	case errors.Is(dbErr, sql.ErrNoRows):
+		return nil, address.ErrAssetMetaNotFound
+	case dbErr != nil:
+		return nil, dbErr
+	}
+
+	return assetMetas, nil
+}
+
 // insertFullAssetGen inserts a new asset genesis and optional asset group
 // into the database. A placeholder for the asset meta inserted as well.
 func insertFullAssetGen(ctx context.Context,

tapdb/sqlc/assets.sql.go

@@ -1034,6 +1034,13 @@ JOIN assets_meta
     ON assets.meta_data_id = assets_meta.meta_id
 WHERE assets.asset_id = $1;
 
+-- name: FetchAllAssetMeta :many
+SELECT sqlc.embed(assets_meta), genesis_assets.asset_id
+FROM assets_meta
+JOIN genesis_assets
+    ON genesis_assets.meta_data_id = assets_meta.meta_id
+ORDER BY assets_meta.meta_id;
+
 -- Upsert a record into the mint_anchor_uni_commitments table.
 -- If a record with the same batch_id and group_key already exists, update the
 -- existing record. Otherwise, insert a new record.