chain_bridge: refactor GetBlockTimestamp to use GetBlockHeaderByHeight

Refactored GetBlockTimestamp to call GetBlockHeaderByHeight and return
an optional error type. Removed the timestamp-to-block-height cache, as
it did not handle re-orgs correctly. This prepares the codebase for a
more comprehensive caching mechanism to be added in a follow-up commit.

Author: ffranr

lndservices/chain_bridge.go

@@ -10,7 +10,6 @@ import (
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/lndclient"
-	"github.com/lightninglabs/neutrino/cache/lru"
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/proof"
@@ -21,12 +20,6 @@ import (
 )
 
 const (
-	// maxNumBlocksInCache is the maximum number of blocks we'll cache
-	// 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 = 400_000
-
 	// medianTimeBlocks is the number of previous blocks which should be
 	// used to calculate the median time used to validate block timestamps.
 	medianTimeBlocks = 11
@@ -38,25 +31,16 @@ var (
 	errTxNotFound = fmt.Errorf("transaction not found in proof file")
 )
 
-// cacheableTimestamp is a wrapper around an uint32 that can be used as a value
-// in an LRU cache.
-type cacheableTimestamp uint32
-
-// Size returns the size of the cacheable timestamp. Since we scale the cache by
-// the number of items and not the total memory size, we can simply return 1
-// here to count each timestamp as 1 item.
-func (c cacheableTimestamp) Size() (uint64, error) {
-	return 1, nil
-}
-
 // LndRpcChainBridge is an implementation of the tapgarden.ChainBridge
 // interface backed by an active remote lnd node.
 type LndRpcChainBridge struct {
+	// lnd is the active lnd services client.
 	lnd *lndclient.LndServices
 
-	blockTimestampCache *lru.Cache[uint32, cacheableTimestamp]
-	retryConfig         fn.RetryConfig
+	// retryConfig is the configuration used for retrying operations.
+	retryConfig fn.RetryConfig
 
+	// assetStore is a handle to the asset store.
 	assetStore *tapdb.AssetStore
 }
 
@@ -66,10 +50,7 @@ func NewLndRpcChainBridge(lnd *lndclient.LndServices,
 	assetStore *tapdb.AssetStore) *LndRpcChainBridge {
 
 	return &LndRpcChainBridge{
-		lnd: lnd,
-		blockTimestampCache: lru.NewCache[uint32, cacheableTimestamp](
-			maxNumBlocksInCache,
-		),
+		lnd:         lnd,
 		retryConfig: fn.DefaultRetryConfig(),
 		assetStore:  assetStore,
 	}
@@ -268,38 +249,20 @@ func (l *LndRpcChainBridge) CurrentHeight(ctx context.Context) (uint32, error) {
 
 // GetBlockTimestamp returns the timestamp of the block at the given height.
 func (l *LndRpcChainBridge) GetBlockTimestamp(ctx context.Context,
-	height uint32) int64 {
+	height uint32) (int64, error) {
 
 	// Shortcut any lookup in case we don't have a valid height in the first
 	// place.
 	if height == 0 {
-		return 0
-	}
-
-	cacheTS, err := l.blockTimestampCache.Get(height)
-	if err == nil {
-		return int64(cacheTS)
-	}
-
-	hash, err := fn.RetryFuncN(
-		ctx, l.retryConfig, func() (chainhash.Hash, error) {
-			return l.lnd.ChainKit.GetBlockHash(ctx, int64(height))
-		},
-	)
-	if err != nil {
-		return 0
+		return 0, nil
 	}
 
-	// Get block header.
-	header, err := l.GetBlockHeader(ctx, hash)
+	blockHeader, err := l.GetBlockHeaderByHeight(ctx, int64(height))
 	if err != nil {
-		return 0
+		return 0, fmt.Errorf("unable to fetch block header: %w", err)
 	}
 
-	ts := uint32(header.Timestamp.Unix())
-	_, _ = l.blockTimestampCache.Put(height, cacheableTimestamp(ts))
-
-	return int64(ts)
+	return blockHeader.Timestamp.Unix(), nil
 }
 
 // PublishTransaction attempts to publish a new transaction to the
@@ -472,7 +435,14 @@ func (l *ProofChainLookup) MeanBlockTimestamp(ctx context.Context,
 			break
 		}
 
-		unixTs := l.chainBridge.GetBlockTimestamp(ctx, blockHeight-i)
+		unixTs, err := l.chainBridge.GetBlockTimestamp(
+			ctx, blockHeight-i,
+		)
+		if err != nil {
+			return time.Time{}, fmt.Errorf("unable to fetch block "+
+				"header timestamp: %w", err)
+		}
+
 		if unixTs == 0 {
 			return time.Time{}, fmt.Errorf("couldn't find "+
 				"timestamp for block height %d", blockHeight)

rpcserver.go

@@ -1259,9 +1259,15 @@ func (r *rpcServer) MarshalChainAsset(ctx context.Context, a asset.ChainAsset,
 
 	// Ensure the block timestamp is set if a block height is set.
 	if a.AnchorBlockTimestamp == 0 && a.AnchorBlockHeight > 0 {
-		a.AnchorBlockTimestamp = r.cfg.ChainBridge.GetBlockTimestamp(
+		timestamp, err := r.cfg.ChainBridge.GetBlockTimestamp(
 			ctx, a.AnchorBlockHeight,
 		)
+		if err != nil {
+			return nil, fmt.Errorf("unable to fetch block header "+
+				"timestamp: %w", err)
+		}
+
+		a.AnchorBlockTimestamp = timestamp
 	}
 
 	return rpcutils.MarshalChainAsset(
@@ -7761,24 +7767,31 @@ func (r *rpcServer) UniverseStats(ctx context.Context,
 // marshalAssetSyncSnapshot maps a universe asset sync stat snapshot to the RPC
 // counterpart.
 func (r *rpcServer) marshalAssetSyncSnapshot(ctx context.Context,
-	a universe.AssetSyncSnapshot) *unirpc.AssetStatsSnapshot {
+	a universe.AssetSyncSnapshot) (*unirpc.AssetStatsSnapshot, error) {
 
 	resp := &unirpc.AssetStatsSnapshot{
 		TotalSyncs:  int64(a.TotalSyncs),
 		TotalProofs: int64(a.TotalProofs),
 		GroupSupply: int64(a.GroupSupply),
 	}
+
+	blockTimestamp, err := r.cfg.ChainBridge.GetBlockTimestamp(
+		ctx, a.GenesisHeight,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query block header "+
+			"timestamp for genesis height: %w", err)
+	}
+
 	rpcAsset := &unirpc.AssetStatsAsset{
-		AssetId:       a.AssetID[:],
-		GenesisPoint:  a.GenesisPoint.String(),
-		AssetName:     a.AssetName,
-		AssetType:     taprpc.AssetType(a.AssetType),
-		TotalSupply:   int64(a.TotalSupply),
-		GenesisHeight: int32(a.GenesisHeight),
-		GenesisTimestamp: r.cfg.ChainBridge.GetBlockTimestamp(
-			ctx, a.GenesisHeight,
-		),
-		AnchorPoint: a.AnchorPoint.String(),
+		AssetId:          a.AssetID[:],
+		GenesisPoint:     a.GenesisPoint.String(),
+		AssetName:        a.AssetName,
+		AssetType:        taprpc.AssetType(a.AssetType),
+		TotalSupply:      int64(a.TotalSupply),
+		GenesisHeight:    int32(a.GenesisHeight),
+		GenesisTimestamp: blockTimestamp,
+		AnchorPoint:      a.AnchorPoint.String(),
 	}
 
 	decDisplay, err := r.cfg.AddrBook.DecDisplayForAssetID(ctx, a.AssetID)
@@ -7795,7 +7808,7 @@ func (r *rpcServer) marshalAssetSyncSnapshot(ctx context.Context,
 		resp.Asset = rpcAsset
 	}
 
-	return resp
+	return resp, nil
 }
 
 // QueryAssetStats returns a set of statistics for a given set of assets.
@@ -7839,7 +7852,13 @@ func (r *rpcServer) QueryAssetStats(ctx context.Context,
 		),
 	}
 	for idx, snapshot := range assetStats.SyncStats {
-		resp.AssetStats[idx] = r.marshalAssetSyncSnapshot(ctx, snapshot)
+		rpcSnapshot, err := r.marshalAssetSyncSnapshot(ctx, snapshot)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal asset "+
+				"snapshot: %w", err)
+		}
+
+		resp.AssetStats[idx] = rpcSnapshot
 	}
 
 	return resp, nil

tapgarden/interface.go

@@ -348,7 +348,7 @@ type ChainBridge interface {
 
 	// GetBlockTimestamp returns the timestamp of the block at the given
 	// height.
-	GetBlockTimestamp(context.Context, uint32) int64
+	GetBlockTimestamp(context.Context, uint32) (int64, error)
 
 	// GetBlockHeaderByHeight returns a block header given the block height.
 	GetBlockHeaderByHeight(ctx context.Context,

tapgarden/mock.go

@@ -734,8 +734,10 @@ func (m *MockChainBridge) CurrentHeight(_ context.Context) (uint32, error) {
 	return 0, nil
 }
 
-func (m *MockChainBridge) GetBlockTimestamp(_ context.Context, _ uint32) int64 {
-	return 0
+func (m *MockChainBridge) GetBlockTimestamp(_ context.Context, _ uint32) (int64,
+	error) {
+
+	return 0, nil
 }
 
 func (m *MockChainBridge) PublishTransaction(_ context.Context,

universe/supplycommit/mock.go

@@ -14,6 +14,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/mssmt"
 	"github.com/lightninglabs/taproot-assets/proof"
+	"github.com/lightninglabs/taproot-assets/tapgarden"
 	"github.com/lightninglabs/taproot-assets/tapsend"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	lfn "github.com/lightningnetwork/lnd/fn/v2"
@@ -268,10 +269,10 @@ func (m *mockChainBridge) VerifyBlock(ctx context.Context,
 }
 
 func (m *mockChainBridge) GetBlockTimestamp(ctx context.Context,
-	height uint32) int64 {
+	height uint32) (int64, error) {
 
 	args := m.Called(ctx, height)
-	return args.Get(0).(int64)
+	return args.Get(0).(int64), args.Error(1)
 }
 
 func (m *mockChainBridge) GenFileChainLookup(f *proof.File) asset.ChainLookup {
@@ -289,6 +290,9 @@ func (m *mockChainBridge) GenProofChainLookup(
 	return args.Get(0).(asset.ChainLookup), args.Error(1)
 }
 
+// Ensure mockChainBridge implements the tapgarden.ChainBridge interface.
+var _ tapgarden.ChainBridge = (*mockChainBridge)(nil)
+
 // mockStateMachineStore is a mock implementation of the StateMachineStore
 // interface.
 type mockStateMachineStore struct {