Merge branch '0-6-1-pull-requests-1650' into 0-6-1-pull-requests

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]),
 	}
 }
 
@@ -334,6 +348,68 @@ func (b *Book) FetchAssetMetaForAsset(ctx context.Context,
 	return meta, nil
 }
 
+// DecDisplayForAssetID attempts to fetch the meta reveal for a specific asset
+// ID and extract the decimal display value from it.
+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)
+	}
+
+	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.
 func (b *Book) NewAddress(ctx context.Context, addrVersion Version,
 	assetID asset.ID, amount uint64,

chain_bridge.go

@@ -27,10 +27,10 @@ import (
 
 const (
 	// maxNumBlocksInCache is the maximum number of blocks we'll cache
-	// timestamps for. With 100k blocks we should only take up approximately
-	// 800kB of memory (4 bytes for the block height and 4 bytes for the
+	// timestamps for. With 400k blocks we should only take up approximately
+	// 3200kB of memory (4 bytes for the block height and 4 bytes for the
 	// timestamp, not including any map/cache overhead).
-	maxNumBlocksInCache = 100_000
+	maxNumBlocksInCache = 400_000
 )
 
 // cacheableTimestamp is a wrapper around an uint32 that can be used as a value

rpcserver.go

@@ -1228,7 +1228,9 @@ func (r *rpcServer) MarshalChainAsset(ctx context.Context, a asset.ChainAsset,
 	case meta != nil:
 		decDisplay, err = meta.DecDisplayOption()
 	default:
-		decDisplay, err = r.DecDisplayForAssetID(ctx, a.ID())
+		decDisplay, err = r.cfg.AddrBook.DecDisplayForAssetID(
+			ctx, a.ID(),
+		)
 	}
 	if err != nil {
 		return nil, err
@@ -5440,7 +5442,9 @@ func (r *rpcServer) AssetLeaves(ctx context.Context,
 	for i, assetLeaf := range assetLeaves {
 		assetLeaf := assetLeaf
 
-		decDisplay, err := r.DecDisplayForAssetID(ctx, assetLeaf.ID())
+		decDisplay, err := r.cfg.AddrBook.DecDisplayForAssetID(
+			ctx, assetLeaf.ID(),
+		)
 		if err != nil {
 			return nil, err
 		}
@@ -5544,7 +5548,9 @@ func (r *rpcServer) marshalUniverseProofLeaf(ctx context.Context,
 		return nil, err
 	}
 
-	decDisplay, err := r.DecDisplayForAssetID(ctx, proof.Leaf.ID())
+	decDisplay, err := r.cfg.AddrBook.DecDisplayForAssetID(
+		ctx, proof.Leaf.ID(),
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -6012,7 +6018,7 @@ func (r *rpcServer) marshalUniverseDiff(ctx context.Context,
 
 		leaves := make([]*unirpc.AssetLeaf, len(diff.NewLeafProofs))
 		for i, leaf := range diff.NewLeafProofs {
-			decDisplay, err := r.DecDisplayForAssetID(
+			decDisplay, err := r.cfg.AddrBook.DecDisplayForAssetID(
 				ctx, leaf.ID(),
 			)
 			if err != nil {
@@ -6507,7 +6513,7 @@ func (r *rpcServer) marshalAssetSyncSnapshot(ctx context.Context,
 		AnchorPoint: a.AnchorPoint.String(),
 	}
 
-	decDisplay, err := r.DecDisplayForAssetID(ctx, a.AssetID)
+	decDisplay, err := r.cfg.AddrBook.DecDisplayForAssetID(ctx, a.AssetID)
 	if err == nil {
 		decDisplay.WhenSome(func(u uint32) {
 			rpcAsset.DecimalDisplay = u
@@ -8536,20 +8542,6 @@ func encodeVirtualPackets(packets []*tappsbt.VPacket) ([][]byte, error) {
 	return rawPackets, nil
 }
 
-// DecDisplayForAssetID attempts to fetch the meta reveal for a specific asset
-// ID and extract the decimal display value from it.
-func (r *rpcServer) DecDisplayForAssetID(ctx context.Context,
-	id asset.ID) (fn.Option[uint32], error) {
-
-	meta, err := r.cfg.AddrBook.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()
-}
-
 // getInboundPolicy returns the policy of the given channel that points towards
 // our node, so it's the policy set by the remote peer.
 func (r *rpcServer) getInboundPolicy(ctx context.Context, chanID uint64,
@@ -8751,7 +8743,7 @@ func (r *rpcServer) DecodeAssetPayReq(ctx context.Context,
 
 	// The final piece of information we need is the decimal display
 	// information for this asset ID.
-	decDisplay, err := r.DecDisplayForAssetID(ctx, assetID)
+	decDisplay, err := r.cfg.AddrBook.DecDisplayForAssetID(ctx, assetID)
 	if err != nil {
 		return nil, err
 	}

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.