fixup! sphinx_test: add test for blinded route processing

Author: gijswijs

path_test.go

@@ -403,7 +403,7 @@ func TestOnionMessageRouteBlinding(t *testing.T) {
 	require.NoError(t, err)
 
 	// Once we have the raw file, we'll unpack it into our
-	// onionMessageJsonTestCase struct defined above.
+	// onionMessageJsonTestCase struct defined below.
 	testCase := &onionMessageJsonTestCase{}
 	require.NoError(t, json.Unmarshal(jsonBytes, testCase))
 
@@ -426,6 +426,10 @@ func TestOnionMessageRouteBlinding(t *testing.T) {
 		require.NoError(t, r.Start())
 		defer r.Stop()
 
+		// Onion messages don't use associated data, so we pass in nil
+		// here. Also, we set a random value for incomingCLTV as it's
+		// only used as an accompanying purposefully general type in the
+		// ReplayLog.
 		res, err := r.ProcessOnionPacket(
 			onionPacket, nil, 10,
 			WithBlindingPoint(blindingPoint),
@@ -437,26 +441,30 @@ func TestOnionMessageRouteBlinding(t *testing.T) {
 
 	hops := testCase.Generate.Hops
 
-	// There are some things that the processor of the onion packet will
-	// only be able to determine from the actual contents of the encrypted
-	// data it receives. These things include the next_blinding_point for
-	// the introduction point and the next_blinding_override. The decryption
-	// of this data is dependent on the encoding chosen by higher layers.
-	// The test uses TLVs. Since the extraction of this data is dependent
-	// on layers outside the scope of this library, we provide handle these
-	// cases manually for the sake of the test.
+	// There are some things that the processor of the onion will only be
+	// able to determine from the actual contents of the onion_message and
+	// the encrypted_recipient_date it receives. These things include the
+	// first_path_key for the introduction point and the
+	// next_path_key_override. This test doesn't decode the onion_message
+	// and the decryption of the encrypted_recipient_data so it doesn't
+	// extract these values. Instead we provide them manually. It also needs
+	// to know where the next_path_key_override is located in the route,
+	// hence it needs the concatIndex, where the part of the blinded route
+	// constructed by Dave starts.
 	var (
-		firstBlinding    = pubKeyFromString(testCase.Route.FirstPathKey)
-		concatIndex      = 1
-		blindingOverride = pubKeyFromString(
+		firstPathKey = pubKeyFromString(
+			testCase.Route.FirstPathKey,
+		)
+		concatIndex         = 1
+		nextPathKeyOverride = pubKeyFromString(
 			hops[0].EncodedOnionMessageTLVs.NextPathKeyOverride,
 		)
 	)
 
-	// Onion message routes are always entirely blinded, so
-	// the first hop will always use the first blinding
-	// point.
-	blindingPoint := firstBlinding
+	// Onion message routes are always entirely blinded, so the first hop
+	// will always use the first path key.
+	pathKey := firstPathKey
+
 	currentOnionPacket := onionPacket
 	for i, hop := range testCase.Decrypt.Hops {
 		// We encode the onion message packet to a buffer at each hop to
@@ -480,23 +488,23 @@ func TestOnionMessageRouteBlinding(t *testing.T) {
 		priv := privKeyFromString(hop.PrivKey)
 
 		if i == concatIndex {
-			blindingPoint = blindingOverride
+			pathKey = nextPathKeyOverride
 		}
 
 		// With peelOnion we call into ProcessOnionPacket (with the
 		// functional option WithBlindingPoint) and we expect that the
 		// onion message packet for this hop is processed without error,
 		// otherwise peelOnion fails the test.
 		processedPkt := peelOnion(
-			priv, blindingPoint, currentOnionPacket,
+			priv, pathKey, currentOnionPacket,
 		)
 
-		// We derive the next blinding point from the current blinding
-		// point and the private key of the current hop. The new
-		// blindingPoint will be used to peel the next hop's onion
-		// unless it is overridden by a blinding override.
-		blindingPoint, err = NextEphemeral(
-			&PrivKeyECDH{priv}, blindingPoint,
+		// We derive the next path key from the current path key and the
+		// private key of the current hop. The new path key will be used
+		// to peel the next hop's onion unless it is overridden by a
+		// path key  override.
+		pathKey, err = NextEphemeral(
+			&PrivKeyECDH{priv}, pathKey,
 		)
 		require.NoError(t, err)
 
@@ -568,6 +576,7 @@ type routeOnionMessageData struct {
 	Hops         []blindedOnionMessageHop `json:"hops"`
 }
 
+//nolint:tagliatelle
 type onionMessageData struct {
 	OnionMessagePacket string `json:"onion_message_packet"`
 }