routing: fix missing graph data for local channels

docs/release-notes/release-notes-0.21.0.md

@@ -51,6 +51,13 @@
   DBytes33 (33 bytes) records, preventing malformed TLV data from being
   accepted.
 
+- [Fixed missing graph data for local channels](https://github.com/lightningnetwork/lnd/pull/10516)
+  that prevented channels from being used for sending or forwarding payments.
+  The fix introduces a conditional mechanism to defer failure of channels with
+  missing edge policies when the `createMissingEdge` flag is enabled, allowing
+  them to be properly recreated instead of being immediately excluded from
+  policy updates.
+
 # New Features
 
 - Basic Support for [onion messaging forwarding](https://github.com/lightningnetwork/lnd/pull/9868) 

routing/localchans/manager.go

@@ -104,11 +104,19 @@ func (r *Manager) UpdatePolicy(ctx context.Context,
 				"a channel. Channel point: %v",
 				info.ChannelPoint.String())
 
-			failedUpdates = append(failedUpdates, makeFailureItem(
-				info.ChannelPoint,
-				lnrpc.UpdateFailure_UPDATE_FAILURE_NOT_FOUND,
-				"edge policy not found",
-			))
+			// If createMissingEdge is true, we need to keep this
+			// channel in unprocessedChans so it can be handled by
+			// the createMissingEdge logic later.
+			if createMissingEdge {
+				unprocessedChans[info.ChannelPoint] = struct{}{}
+			} else {
+				failedUpdates = append(failedUpdates,
+					makeFailureItem(
+						info.ChannelPoint,
+						lnrpc.UpdateFailure_UPDATE_FAILURE_NOT_FOUND,
+						"edge policy not found",
+					))
+			}
 
 			return nil
 		}

routing/localchans/manager_test.go

@@ -29,7 +29,11 @@ func TestManager(t *testing.T) {
 	t.Parallel()
 
 	type channel struct {
-		edgeInfo *models.ChannelEdgeInfo
+		edgeInfo   *models.ChannelEdgeInfo
+		edgePolicy *models.ChannelEdgePolicy
+		// allowNilPolicy signals whether we should pass a nil edge policy
+		// to the callback instead of defaulting to currentPolicy.
+		allowNilPolicy bool
 	}
 
 	var (
@@ -130,7 +134,14 @@ func TestManager(t *testing.T) {
 			*models.ChannelEdgePolicy) error, _ func()) error {
 
 		for _, c := range channelSet {
-			if err := cb(c.edgeInfo, &currentPolicy); err != nil {
+			// Use the channel's specific edge policy if set,
+			// otherwise use the default current policy.
+			edgePolicy := c.edgePolicy
+			if edgePolicy == nil && !c.allowNilPolicy &&
+				len(c.edgeInfo.ChannelPoint.Hash) != 0 {
+				edgePolicy = &currentPolicy
+			}
+			if err := cb(c.edgeInfo, edgePolicy); err != nil {
 				return err
 			}
 		}
@@ -309,6 +320,54 @@ func TestManager(t *testing.T) {
 			},
 			expectErr: nil,
 		},
+		{
+			// Here, the edge policy is nil but edge info exists.
+			// The edge should be recreated because
+			// createMissingEdge is true.
+			name:          "nil edge policy recreated",
+			currentPolicy: models.ChannelEdgePolicy{},
+			newPolicy:     newPolicy,
+			channelSet: []channel{
+				{
+					edgeInfo: &models.ChannelEdgeInfo{
+						Capacity:     chanCap,
+						ChannelPoint: chanPointValid,
+					},
+					edgePolicy: nil,
+				allowNilPolicy: true,
+				},
+			},
+			specifiedChanPoints:    []wire.OutPoint{chanPointValid},
+			createMissingEdge:      true,
+			expectedNumUpdates:     1,
+			expectedUpdateFailures: []lnrpc.UpdateFailure{},
+			expectErr:              nil,
+		},
+		{
+			// Here, the edge policy is nil but edge info exists.
+			// The edge will not be recreated because
+			// createMissingEdge is false.
+			name:          "nil edge policy not recreated",
+			currentPolicy: models.ChannelEdgePolicy{},
+			newPolicy:     newPolicy,
+			channelSet: []channel{
+				{
+					edgeInfo: &models.ChannelEdgeInfo{
+						Capacity:     chanCap,
+						ChannelPoint: chanPointValid,
+					},
+					edgePolicy: nil,
+				allowNilPolicy: true,
+				},
+			},
+			specifiedChanPoints: []wire.OutPoint{chanPointValid},
+			createMissingEdge:   false,
+			expectedNumUpdates:  0,
+			expectedUpdateFailures: []lnrpc.UpdateFailure{
+				lnrpc.UpdateFailure_UPDATE_FAILURE_NOT_FOUND,
+			},
+			expectErr: nil,
+		},
 	}
 
 	for _, test := range tests {