onionmessage: add LRU cache to SCID resolver

Add an LRU cache to GraphNodeResolver to avoid repeated database lookups
when resolving SCIDs to node public keys. The cache stores up to 1000
compressed pubkey entries, which is sufficient for typical onion message
forwarding scenarios.

This change also introduces a NewGraphNodeResolver constructor to
properly initialize the cache, replacing direct struct literal usage.

Author: gijswijs

onionmessage/resolver.go

@@ -4,22 +4,85 @@ import (
 	"encoding/hex"
 
 	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/lightninglabs/neutrino/cache/lru"
 	graphdb "github.com/lightningnetwork/lnd/graph/db"
 	"github.com/lightningnetwork/lnd/lnwire"
 )
 
+const (
+	// defaultSCIDCacheSize is the default number of SCID to pubkey mappings
+	// to cache. This is relatively small since onion message forwarding via
+	// SCID is expected to be infrequent compared to forwarding via explicit
+	// node ID.
+	defaultSCIDCacheSize = 1000
+)
+
+// cachedPubKey is a wrapper around a compressed public key that implements the
+// cache.Value interface required by the LRU cache.
+type cachedPubKey struct {
+	pubKeyBytes [33]byte
+}
+
+// Size returns the "size" of an entry. We return 1 as we just want to limit
+// the total number of entries rather than do accurate size accounting.
+func (c *cachedPubKey) Size() (uint64, error) {
+	return 1, nil
+}
+
+// GraphNodeResolver resolves node public keys from short channel IDs using the
+// channel graph. It maintains an LRU cache to avoid repeated database lookups
+// for frequently used SCIDs.
 type GraphNodeResolver struct {
-	Graph  *graphdb.ChannelGraph
-	OurPub *btcec.PublicKey
+	graph  *graphdb.ChannelGraph
+	ourPub *btcec.PublicKey
+
+	// scidCache is an LRU cache mapping SCID (as uint64) to the remote
+	// node's compressed public key bytes.
+	scidCache *lru.Cache[uint64, *cachedPubKey]
+}
+
+// NewGraphNodeResolver creates a new GraphNodeResolver with the given channel
+// graph and our node's public key. It initializes an LRU cache for SCID
+// lookups.
+func NewGraphNodeResolver(graph *graphdb.ChannelGraph,
+	ourPub *btcec.PublicKey) *GraphNodeResolver {
+
+	return &GraphNodeResolver{
+		graph:  graph,
+		ourPub: ourPub,
+		scidCache: lru.NewCache[uint64, *cachedPubKey](
+			defaultSCIDCacheSize,
+		),
+	}
 }
 
 // RemotePubFromSCID resolves a node public key from a short channel ID.
+// It first checks the LRU cache and falls back to a database lookup on cache
+// miss.
 func (r *GraphNodeResolver) RemotePubFromSCID(
 	scid lnwire.ShortChannelID) (*btcec.PublicKey, error) {
 
-	log.Tracef("Resolving node public key for SCID %v", scid)
+	scidInt := scid.ToUint64()
+
+	// Check the cache first.
+	if cached, err := r.scidCache.Get(scidInt); err == nil {
+		pubKey, parseErr := btcec.ParsePubKey(cached.pubKeyBytes[:])
+		if parseErr == nil {
+			log.Tracef("Resolved SCID %v from cache to node %s",
+				scid,
+				hex.EncodeToString(cached.pubKeyBytes[:]))
+
+			return pubKey, nil
+		}
 
-	edge, _, _, err := r.Graph.FetchChannelEdgesByID(scid.ToUint64())
+		// Cache contained invalid data, fall through to DB lookup.
+		log.Debugf("Invalid cached pubkey for SCID %v: %v",
+			scid, parseErr)
+	}
+
+	log.Tracef("Resolving node public key for SCID %v from graph", scid)
+
+	edge, _, _, err := r.graph.FetchChannelEdgesByID(scidInt)
 	if err != nil {
 		log.Debugf("Failed to fetch channel edges for SCID %v: %v",
 			scid, err)
@@ -28,7 +91,7 @@ func (r *GraphNodeResolver) RemotePubFromSCID(
 	}
 
 	otherNodeKeyBytes, err := edge.OtherNodeKeyBytes(
-		r.OurPub.SerializeCompressed(),
+		r.ourPub.SerializeCompressed(),
 	)
 	if err != nil {
 		log.Debugf("Failed to get other node key for SCID %v: %v",
@@ -45,6 +108,13 @@ func (r *GraphNodeResolver) RemotePubFromSCID(
 		return nil, err
 	}
 
+	// Cache the result for future lookups. We ignore the return values as
+	// caching is best-effort and a failure just means the next lookup will
+	// hit the database again.
+	_, _ = r.scidCache.Put(scidInt, &cachedPubKey{
+		pubKeyBytes: otherNodeKeyBytes,
+	})
+
 	log.Tracef("Resolved SCID %v to node %s", scid,
 		hex.EncodeToString(pubKey.SerializeCompressed()))
 

server.go

@@ -2380,10 +2380,9 @@ func (s *server) Start(ctx context.Context) error {
 		// connections and registered with each peer's message router.
 		// Skip if onion messaging is disabled via config.
 		if !s.cfg.ProtocolOptions.NoOnionMessages() {
-			resolver := &onionmessage.GraphNodeResolver{
-				Graph:  s.graphDB,
-				OurPub: s.identityECDH.PubKey(),
-			}
+			resolver := onionmessage.NewGraphNodeResolver(
+				s.graphDB, s.identityECDH.PubKey(),
+			)
 			s.onionEndpoint, err = onionmessage.NewOnionEndpoint(
 				s.actorSystem.Receptionist(),
 				s.sphinxOnionMsg,