routing: enforce tlv payloads during path finding

We would always pack our onion payloads in the new tlv format.
We also now make sure we drop any routes which do not support the
tlv format in the first place because the route will fail anyways
when reaching those nodes because they cannot decode it.

Author: ziggie1984

routing/integrated_routing_test.go

@@ -270,7 +270,6 @@ func TestBadFirstHopHint(t *testing.T) {
 // TestMppSend tests that a payment can be completed using multiple shards.
 func TestMppSend(t *testing.T) {
 	for _, testCase := range mppTestCases {
-		testCase := testCase
 
 		t.Run(testCase.name, func(t *testing.T) {
 			testMppSend(t, &testCase)

routing/mock_graph_test.go

@@ -199,7 +199,7 @@ func (m *mockGraph) ForEachNodeDirectedChannel(nodePub route.Vertex,
 					ToNodePubKey: func() route.Vertex {
 						return nodePub
 					},
-					ToNodeFeatures: lnwire.EmptyFeatureVector(),
+					ToNodeFeatures: testFeatures,
 					FeeBaseMSat:    peerNode.baseFee,
 				},
 			},
@@ -224,7 +224,7 @@ func (m *mockGraph) sourceNode() route.Vertex {
 func (m *mockGraph) FetchNodeFeatures(nodePub route.Vertex) (
 	*lnwire.FeatureVector, error) {
 
-	return lnwire.EmptyFeatureVector(), nil
+	return testFeatures, nil
 }
 
 // GraphSession will provide the call-back with access to a

routing/pathfind.go

@@ -226,6 +226,15 @@ func newRoute(sourceVertex route.Vertex,
 			return edge.ToNodeFeatures.HasFeature(feature)
 		}
 
+		// We pack payloads always in TLV format, therefore it will fail
+		// anyways at the forwarding/receiving node in case it doesn't
+		// support it.
+		tlvPayloadSupport := supports(lnwire.TLVOnionPayloadOptional)
+		if !tlvPayloadSupport {
+			return nil, fmt.Errorf("cannot use a route with hops " +
+				"that don't support TLV payloads")
+		}
+
 		if i == len(pathEdges)-1 {
 			// If this is the last hop, then the hop payload will
 			// contain the exact amount. In BOLT #4: Onion Routing
@@ -253,7 +262,7 @@ func newRoute(sourceVertex route.Vertex,
 			// doesn't support both TLV and payment addrs, fail.
 			payAddr := supports(lnwire.PaymentAddrOptional)
 			if !payAddr && finalHop.paymentAddr.IsSome() {
-				return nil, errors.New("cannot attach " +
+				return nil, fmt.Errorf("cannot attach " +
 					"payment addr")
 			}
 

routing/pathfind_test.go

@@ -348,7 +348,7 @@ func parseTestGraph(t *testing.T, useCache bool, path string) (
 			ChannelID:    edge.ChannelID,
 			AuthProof:    &testAuthProof,
 			ChannelPoint: fundingPoint,
-			Features:     lnwire.EmptyFeatureVector(),
+			Features:     testFeatures,
 			Capacity:     btcutil.Amount(edge.Capacity),
 		}
 
@@ -528,6 +528,12 @@ func createTestGraphFromChannels(t *testing.T, useCache bool,
 
 	ctx := t.Context()
 
+	// We enforce TLV payloads for all nodes when blinding paths.
+	testFeatures := lnwire.NewFeatureVector(
+		lnwire.NewRawFeatureVector(lnwire.TLVOnionPayloadRequired),
+		lnwire.Features,
+	)
+
 	// We'll use this fake address for the IP address of all the nodes in
 	// our tests. This value isn't needed for path finding so it doesn't
 	// need to be unique.
@@ -562,7 +568,7 @@ func createTestGraphFromChannels(t *testing.T, useCache bool,
 		privKey, pubKey := btcec.PrivKeyFromBytes(keyBytes)
 
 		if features == nil {
-			features = lnwire.EmptyFeatureVector()
+			features = testFeatures
 		}
 
 		dbNode := &models.Node{
@@ -1490,7 +1496,7 @@ func TestNewRoute(t *testing.T) {
 			ToNodePubKey: func() route.Vertex {
 				return route.Vertex{}
 			},
-			ToNodeFeatures:            lnwire.NewFeatureVector(nil, nil),
+			ToNodeFeatures:            testFeatures,
 			FeeProportionalMillionths: feeRate,
 			FeeBaseMSat:               baseFee,
 			TimeLockDelta:             timeLockDelta,

routing/payment_session_test.go

@@ -223,9 +223,7 @@ func TestRequestRoute(t *testing.T) {
 					ToNodePubKey: func() route.Vertex {
 						return route.Vertex{}
 					},
-					ToNodeFeatures: lnwire.NewFeatureVector(
-						nil, nil,
-					),
+					ToNodeFeatures: testFeatures,
 				},
 			},
 		}

routing/router_test.go

@@ -46,7 +46,11 @@ var (
 		Port: 9000}
 	testAddrs = []net.Addr{testAddr}
 
-	testFeatures = lnwire.NewFeatureVector(nil, lnwire.Features)
+	// We enforce TLV payloads for all nodes when blinding paths.
+	testFeatures = lnwire.NewFeatureVector(
+		lnwire.NewRawFeatureVector(lnwire.TLVOnionPayloadRequired),
+		lnwire.Features,
+	)
 
 	testTime = time.Date(2018, time.January, 9, 14, 00, 00, 0, time.UTC)
 
@@ -1512,7 +1516,10 @@ func TestBuildRoute(t *testing.T) {
 	// Setup a three node network.
 	chanCapSat := btcutil.Amount(100000)
 	paymentAddrFeatures := lnwire.NewFeatureVector(
-		lnwire.NewRawFeatureVector(lnwire.PaymentAddrOptional),
+		lnwire.NewRawFeatureVector(
+			lnwire.PaymentAddrOptional,
+			lnwire.TLVOnionPayloadRequired,
+		),
 		lnwire.Features,
 	)
 	testChannels := []*testChannel{
@@ -2735,13 +2742,26 @@ func TestAddEdgeUnknownVertexes(t *testing.T) {
 	)
 	require.NoError(t, err, "unable to create channel edge")
 
+	// Before we add the edge, we need to add the nodes to the graph.
+	// Although inserting just an edge will also add a node shell in case
+	// the nodes don't exist yet, we want to make sure that the nodes also
+	// have the proper features set because we now require TLV payloads.
+	require.NoError(t, ctx.graph.AddNode(ctxb, &models.Node{
+		PubKeyBytes: pub1,
+		Features:    testFeatures,
+	}))
+	require.NoError(t, ctx.graph.AddNode(ctxb, &models.Node{
+		PubKeyBytes: pub2,
+		Features:    testFeatures,
+	}))
+
 	edge := &models.ChannelEdgeInfo{
 		ChannelID:        chanID.ToUint64(),
 		NodeKey1Bytes:    pub1,
 		NodeKey2Bytes:    pub2,
 		BitcoinKey1Bytes: pub1,
 		BitcoinKey2Bytes: pub2,
-		Features:         lnwire.EmptyFeatureVector(),
+		Features:         testFeatures,
 		AuthProof:        nil,
 	}
 	require.NoError(t, ctx.graph.AddChannelEdge(ctxb, edge))
@@ -2817,7 +2837,7 @@ func TestAddEdgeUnknownVertexes(t *testing.T) {
 
 	edge = &models.ChannelEdgeInfo{
 		ChannelID: chanID.ToUint64(),
-		Features:  lnwire.EmptyFeatureVector(),
+		Features:  testFeatures,
 		AuthProof: nil,
 	}
 	copy(edge.NodeKey1Bytes[:], node1Bytes)