graph: fall back to GraphSource for channel updates from payment failures

When a payment fails due to a stale fee policy (e.g. FeeInsufficient),
the router extracts the updated ChannelUpdate from the failure message
and calls ApplyChannelUpdate. Previously, this only looked up the
channel in the local graph DB, so channels that only existed in a remote
graph source (via the Mux) could not be updated, causing the payment to
fail with NO_ROUTE.

This commit adds a fallback path: when the local DB lookup fails and a
GraphSource is configured, ApplyChannelUpdate now queries the
GraphSource (which includes the remote graph) to find the channel,
validates the update signature, and applies the policy change directly
to the graph cache. The router can then retry the payment with the
correct fee policy.

The integration test is updated to assert the fixed behavior: the
payment now succeeds on retry after the cache is updated from the
failure message.

Author: ellemouton

graph/builder.go

@@ -102,6 +102,14 @@ type Config struct {
 	// IsAlias returns whether a passed ShortChannelID is an alias. This is
 	// only used for our local channels.
 	IsAlias func(scid lnwire.ShortChannelID) bool
+
+	// GraphSource is an optional read-only graph source that may combine
+	// local and remote graph data. When set, ApplyChannelUpdate will fall
+	// back to this source to look up channels that don't exist in the
+	// local graph DB (e.g. channels only known via a remote graph). Policy
+	// updates for such channels are applied directly to the graph cache
+	// without a DB write.
+	GraphSource graphdb.GraphSource
 }
 
 // Builder builds and maintains a view of the Lightning Network graph.
@@ -938,7 +946,15 @@ func (b *Builder) ApplyChannelUpdate(msg *lnwire.ChannelUpdate1) bool {
 
 	ch, _, _, err := b.GetChannelByID(msg.ShortChannelID)
 	if err != nil {
+		// If the channel isn't in the local DB but we have a
+		// GraphSource (e.g. a remote graph), try looking it up there
+		// and apply the update directly to the graph cache.
+		if b.cfg.GraphSource != nil {
+			return b.applyChannelUpdateFromSource(ctx, msg)
+		}
+
 		log.Errorf("Unable to retrieve channel by id: %v", err)
+
 		return false
 	}
 
@@ -982,6 +998,83 @@ func (b *Builder) ApplyChannelUpdate(msg *lnwire.ChannelUpdate1) bool {
 	return true
 }
 
+// applyChannelUpdateFromSource handles channel updates for channels that only
+// exist in the GraphSource (e.g. via a remote graph) and not in the local DB.
+// It looks up the channel from the GraphSource, validates the update signature,
+// and applies the policy change directly to the graph cache.
+func (b *Builder) applyChannelUpdateFromSource(ctx context.Context,
+	msg *lnwire.ChannelUpdate1) bool {
+
+	chanID := msg.ShortChannelID.ToUint64()
+
+	ch, _, _, err := b.cfg.GraphSource.FetchChannelEdgesByID(ctx, chanID)
+	if err != nil {
+		log.Errorf("Unable to retrieve channel %v from graph "+
+			"source: %v", chanID, err)
+
+		return false
+	}
+
+	var pubKey *btcec.PublicKey
+
+	switch msg.ChannelFlags & lnwire.ChanUpdateDirection {
+	case 0:
+		pubKey, _ = ch.NodeKey1()
+
+	case 1:
+		pubKey, _ = ch.NodeKey2()
+	}
+
+	if pubKey == nil {
+		log.Errorf("Unable to decide pubkey with ChannelFlags=%v",
+			msg.ChannelFlags)
+
+		return false
+	}
+
+	err = netann.ValidateChannelUpdateAnn(pubKey, ch.Capacity, msg)
+	if err != nil {
+		log.Errorf("Unable to validate channel update: %v", err)
+
+		return false
+	}
+
+	update, err := models.ChanEdgePolicyFromWire(chanID, msg)
+	if err != nil {
+		log.Errorf("Unable to parse channel update: %v", err)
+
+		return false
+	}
+
+	cache := b.cfg.Graph.GraphCacheStore()
+	if cache == nil {
+		log.Errorf("No graph cache available for remote channel "+
+			"update (chan_id=%v)", chanID)
+
+		return false
+	}
+
+	fromNode, _ := ch.NodeKey1()
+	toNode, _ := ch.NodeKey2()
+
+	if fromNode == nil || toNode == nil {
+		log.Errorf("Unable to get node keys for channel %v", chanID)
+
+		return false
+	}
+
+	cache.UpdatePolicy(
+		models.NewCachedPolicy(update),
+		route.NewVertex(fromNode),
+		route.NewVertex(toNode),
+	)
+
+	log.Debugf("Applied channel update from graph source for "+
+		"chan_id=%v directly to graph cache", chanID)
+
+	return true
+}
+
 // AddNode is used to add information about a node to the router database. If
 // the node with this pubkey is not present in an existing channel, it will
 // be ignored.

itest/lnd_remote_graph_test.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/lightningnetwork/lnd/lnrpc"
-	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
 	"github.com/lightningnetwork/lnd/lntest"
 	"github.com/lightningnetwork/lnd/lntest/node"
 	"github.com/lightningnetwork/lnd/lntest/wait"
@@ -381,51 +380,14 @@ func testRemoteGraphPolicyUpdate(ht *lntest.HarnessTest) {
 	require.Equal(ht.T, oldBobFeeRate, zaneBobFeeRate,
 		"zane should still see old fee rate")
 
-	// Now Zane tries to pay Alice again. The payment will be attempted
-	// with the stale fee policy. Bob will reject it with FeeInsufficient
-	// and include the updated ChannelUpdate in the failure message.
-	//
-	// The router will extract the ChannelUpdate and call
-	// ApplyChannelUpdate. Currently, this fails silently because the
-	// channel only exists in the remote graph (via Greg), not in Zane's
-	// local DB.
-	//
-	// We use a high fee limit to ensure the payment would succeed if
-	// Zane had the correct fee info.
+	// Now Zane tries to pay Alice again. The first attempt uses the stale
+	// fee policy, so Bob rejects it with FeeInsufficient and includes the
+	// updated ChannelUpdate in the failure message. ApplyChannelUpdate
+	// falls back to the GraphSource (since the channel isn't in Zane's
+	// local DB), updates the graph cache, and the router retries with
+	// the correct fees.
 	invoice2 := alice.RPC.AddInvoice(&lnrpc.Invoice{Value: 100})
-
-	// TODO(elle): Once the fix is applied, this payment should succeed
-	// because ApplyChannelUpdate will update the graph cache from the
-	// failure message, and the router will retry with the correct fees.
-	// For now, we assert the BROKEN behavior: the payment fails because
-	// Zane can't learn the updated fee from the failure message.
-	ht.SendPaymentAssertFail(
-		zane,
-		&routerrpc.SendPaymentRequest{
-			PaymentRequest: invoice2.PaymentRequest,
-			TimeoutSeconds: 30,
-			FeeLimitMsat:   10_000_000,
-			MaxParts:       1,
-		},
-		lnrpc.PaymentFailureReason_FAILURE_REASON_NO_ROUTE,
-	)
-
-	// Verify Zane's cached policy for Bob->Alice is still the OLD fee.
-	// This confirms that ApplyChannelUpdate did NOT update the cache
-	// from the failure message (the bug).
-	zaneChanInfo, err = zane.RPC.LN.GetChanInfo(
-		ctx, &lnrpc.ChanInfoRequest{ChanId: bobAliceChanID},
-	)
-	require.NoError(ht.T, err)
-
-	if zaneChanInfo.Node1Pub == bob.PubKeyStr {
-		zaneBobFeeRate = zaneChanInfo.Node1Policy.FeeRateMilliMsat
-	} else {
-		zaneBobFeeRate = zaneChanInfo.Node2Policy.FeeRateMilliMsat
-	}
-	require.Equal(ht.T, oldBobFeeRate, zaneBobFeeRate,
-		"bug confirmed: zane's cache was NOT updated from "+
-			"the payment failure message")
+	ht.CompletePaymentRequests(zane, []string{invoice2.PaymentRequest})
 
 	// Clean up.
 	ht.CloseChannel(zane, chanPointZane)

server.go

@@ -1112,6 +1112,7 @@ func newServer(ctx context.Context, cfg *Config, listenAddrs []net.Addr,
 		AssumeChannelValid:  cfg.Routing.AssumeChannelValid,
 		StrictZombiePruning: strictPruning,
 		IsAlias:             aliasmgr.IsAlias,
+		GraphSource:         s.graphSource,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("can't create graph builder: %w", err)