Merge pull request #1654 from lightninglabs/0-6-1-pull-requests

release: create minor release v0.6.1 side branch

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,

asset/asset.go

@@ -521,6 +521,85 @@ func (s *Specifier) AssertNotEmpty() error {
 	return nil
 }
 
+// Equal compares this specifier to another one, returning true if they are
+// equal. If strict is true, then both specifiers need to either have both equal
+// asset IDs and group keys set or only one of those (but matching). If strict
+// is false, then it's enough to have the same group key _or_ the same asset ID
+// (if one has no group key set). This is useful for cases where one specifier
+// only specifies the group key, while the other one specifies both the group
+// key and the asset ID. In that case, we can consider them equal if the group
+// keys match, even if the asset IDs are different (or one is not set).
+func (s *Specifier) Equal(other *Specifier, strict bool) (bool, error) {
+	// If both specifiers are nil, they are equal.
+	if s == nil && other == nil {
+		return true, nil
+	}
+
+	// If one of the specifiers is nil, they are not equal.
+	if s == nil || other == nil {
+		return false, nil
+	}
+
+	// If either of them is empty while the other is not, they are not
+	// equal.
+	if (s.HasId() || s.HasGroupPubKey()) !=
+		(other.HasId() || other.HasGroupPubKey()) {
+
+		return false, nil
+	}
+
+	// If they both have distinct elements set, then they are not equal.
+	if s.HasId() != other.HasId() &&
+		s.HasGroupPubKey() != other.HasGroupPubKey() {
+
+		return false, nil
+	}
+
+	// If both specifiers have a group public key, compare them.
+	if s.HasGroupPubKey() && other.HasGroupPubKey() {
+		groupKeyA := s.UnwrapGroupKeyToPtr()
+		groupKeyB := other.UnwrapGroupKeyToPtr()
+
+		// If any unwrapped element is nil, something's wrong, and we
+		// can't compare them.
+		if groupKeyA == nil || groupKeyB == nil {
+			return false, fmt.Errorf("unable to unwrap group key "+
+				"from specifier: %v vs %v", s, other)
+		}
+
+		if !groupKeyA.IsEqual(groupKeyB) {
+			return false, nil
+		}
+
+		// If we're not doing a strict comparison, then we can return
+		// true here if the group keys match. The group key has higher
+		// priority than the ID, so if they match and the comparison
+		// isn't strict, we can consider the specifiers equal.
+		if !strict {
+			return true, nil
+		}
+	}
+
+	// If both specifiers have an ID, compare them.
+	if s.HasId() && other.HasId() {
+		idA := s.UnwrapIdToPtr()
+		idB := other.UnwrapIdToPtr()
+
+		// If any unwrapped element is nil, something's wrong and we
+		// can't compare them.
+		if idA == nil || idB == nil {
+			return false, fmt.Errorf("unable to unwrap asset ID "+
+				"from specifier: %v vs %v", s, other)
+		}
+
+		if *idA != *idB {
+			return false, nil
+		}
+	}
+
+	return true, nil
+}
+
 // Type denotes the asset types supported by the Taproot Asset protocol.
 type Type uint8
 

asset/asset_test.go

@@ -1247,3 +1247,125 @@ func TestDecodeAsset(t *testing.T) {
 
 	t.Logf("Decoded asset: %v", string(assetJSON))
 }
+
+// TestSpecifierEqual tests the Specifier.Equal method for all possible cases.
+func TestSpecifierEqual(t *testing.T) {
+	id1 := ID{1, 2, 3}
+	id2 := ID{4, 5, 6}
+	pk1, _ := btcec.NewPrivateKey()
+	pubKey1 := pk1.PubKey()
+	pk2, _ := btcec.NewPrivateKey()
+	pubKey2 := pk2.PubKey()
+
+	cases := []struct {
+		name      string
+		s, other  *Specifier
+		strict    bool
+		expects   bool
+		expectErr bool
+	}{
+		{
+			name:    "both nil",
+			s:       nil,
+			other:   nil,
+			strict:  false,
+			expects: true,
+		},
+		{
+			name:    "one nil (s)",
+			s:       nil,
+			other:   &Specifier{},
+			strict:  false,
+			expects: false,
+		},
+		{
+			name:    "one nil (other)",
+			s:       &Specifier{},
+			other:   nil,
+			strict:  false,
+			expects: false,
+		},
+		{
+			name:    "both empty",
+			s:       &Specifier{},
+			other:   &Specifier{},
+			strict:  false,
+			expects: true,
+		},
+		{
+			name:    "both with same ID",
+			s:       &Specifier{id: fn.Some(id1)},
+			other:   &Specifier{id: fn.Some(id1)},
+			strict:  false,
+			expects: true,
+		},
+		{
+			name:    "both with different ID",
+			s:       &Specifier{id: fn.Some(id1)},
+			other:   &Specifier{id: fn.Some(id2)},
+			strict:  false,
+			expects: false,
+		},
+		{
+			name:    "both with same group key",
+			s:       &Specifier{groupKey: fn.Some(*pubKey1)},
+			other:   &Specifier{groupKey: fn.Some(*pubKey1)},
+			strict:  false,
+			expects: true,
+		},
+		{
+			name:    "both with different group key",
+			s:       &Specifier{groupKey: fn.Some(*pubKey1)},
+			other:   &Specifier{groupKey: fn.Some(*pubKey2)},
+			strict:  false,
+			expects: false,
+		},
+		{
+			name:    "one with ID, one with group key",
+			s:       &Specifier{id: fn.Some(id1)},
+			other:   &Specifier{groupKey: fn.Some(*pubKey1)},
+			strict:  false,
+			expects: false,
+		},
+		{
+			name:    "both with ID, strict true",
+			s:       &Specifier{id: fn.Some(id1)},
+			other:   &Specifier{id: fn.Some(id1)},
+			strict:  true,
+			expects: true,
+		},
+		{
+			name:    "both with group key, strict true",
+			s:       &Specifier{groupKey: fn.Some(*pubKey1)},
+			other:   &Specifier{groupKey: fn.Some(*pubKey1)},
+			strict:  true,
+			expects: true,
+		},
+		{
+			name:    "one with ID, one with group key, strict true",
+			s:       &Specifier{id: fn.Some(id1)},
+			other:   &Specifier{groupKey: fn.Some(*pubKey1)},
+			strict:  true,
+			expects: false,
+		},
+		{
+			name:    "both empty, strict true",
+			s:       &Specifier{},
+			other:   &Specifier{},
+			strict:  true,
+			expects: true,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			eq, err := tc.s.Equal(tc.other, tc.strict)
+			if tc.expectErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.expects, eq)
+			}
+		})
+	}
+}

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

go.mod

@@ -9,8 +9,8 @@ require (
 	github.com/btcsuite/btcd/btcutil/psbt v1.1.10
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0
 	github.com/btcsuite/btclog v0.0.0-20241003133417-09c4e92e319c
-	github.com/btcsuite/btclog/v2 v2.0.1-0.20250110154127-3ae4bf1cb318
-	github.com/btcsuite/btcwallet v0.16.13
+	github.com/btcsuite/btclog/v2 v2.0.1-0.20250602222548-9967d19bb084
+	github.com/btcsuite/btcwallet v0.16.14
 	github.com/btcsuite/btcwallet/wallet/txsizes v1.2.5
 	github.com/btcsuite/btcwallet/wtxmgr v1.5.6
 	github.com/caddyserver/certmagic v0.17.2
@@ -27,10 +27,11 @@ require (
 	github.com/lib/pq v1.10.9
 	github.com/lightninglabs/aperture v0.3.13-beta
 	github.com/lightninglabs/lightning-node-connect/hashmailrpc v1.0.3
-	github.com/lightninglabs/lndclient v0.19.0-7
+	github.com/lightninglabs/lndclient v0.19.0-12
 	github.com/lightninglabs/neutrino/cache v1.1.2
-	github.com/lightninglabs/taproot-assets/taprpc v1.0.7
-	github.com/lightningnetwork/lnd v0.19.0-beta
+	// The commit cf2a5e5b corresponds to the tapd v0.6.0 tag.
+	github.com/lightninglabs/taproot-assets/taprpc v1.0.8-0.20250617163017-cf2a5e5bb47c
+	github.com/lightningnetwork/lnd v0.19.2-beta
 	github.com/lightningnetwork/lnd/cert v1.2.2
 	github.com/lightningnetwork/lnd/clock v1.1.1
 	github.com/lightningnetwork/lnd/fn/v2 v2.0.8
@@ -88,7 +89,7 @@ require (
 	github.com/fergusstrange/embedded-postgres v1.25.0 // indirect
 	github.com/go-logr/logr v1.4.2 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
+	github.com/go-viper/mapstructure/v2 v2.3.0 // indirect
 	github.com/goccy/go-yaml v1.15.23 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang-jwt/jwt/v4 v4.5.2 // indirect