fixup! sphinx_test: add test for blinded route processing

Author: gijswijs

path_test.go

@@ -385,7 +385,7 @@ func TestOnionMessageRouteBlinding(t *testing.T) {
 	require.NoError(t, err)
 
 	// Once we have the raw file, we'll unpack it into our
-	// blindingJsonTestCase struct defined above.
+	// onionMessageJsonTestCase struct defined above.
 	testCase := &onionMessageJsonTestCase{}
 	require.NoError(t, json.Unmarshal(jsonBytes, testCase))
 
@@ -402,9 +402,7 @@ func TestOnionMessageRouteBlinding(t *testing.T) {
 	peelOnion := func(key *btcec.PrivateKey,
 		blindingPoint *btcec.PublicKey) *ProcessedPacket {
 
-		r := NewRouter(
-			&PrivKeyECDH{PrivKey: key}, NewMemoryReplayLog(),
-		)
+		r := NewRouter(&PrivKeyECDH{PrivKey: key}, NewMemoryReplayLog())
 
 		require.NoError(t, r.Start())
 		defer r.Stop()
@@ -429,22 +427,30 @@ func TestOnionMessageRouteBlinding(t *testing.T) {
 	// on layers outside the scope of this library, we provide handle these
 	// cases manually for the sake of the test.
 	var (
-		firstBlinding = pubKeyFromString(testCase.Route.FirstPathKey)
-
+		firstBlinding    = pubKeyFromString(testCase.Route.FirstPathKey)
 		concatIndex      = 1
-		blindingOverride = pubKeyFromString(hops[0].EncodedOnionMessageTLVs.NextPathKeyOverride)
+		blindingOverride = pubKeyFromString(
+			hops[0].EncodedOnionMessageTLVs.NextPathKeyOverride,
+		)
 	)
 
-	var blindingPoint *btcec.PublicKey
+	// Onion message routes are always entirely blinded, so
+	// the first hop will always use the first blinding
+	// point.
+	blindingPoint := firstBlinding
+	currentOnionPacket := onionPacket
 	for i, hop := range testCase.Decrypt.Hops {
+		// We encode the onion message packet to a buffer at each hop to
+		// compare it to the onion message packet in the test vector.
 		buff := bytes.NewBuffer(nil)
-		require.NoError(t, onionPacket.Encode(buff))
+		require.NoError(t, currentOnionPacket.Encode(buff))
 
 		// hop.OnionMessage contains the onion_message hex string. This
 		// contains the type 513 (two bytes), the path_key (33 bytes)
 		// and the length of the onion_message_packet (two bytes). We
 		// are only interested in the onion_message_packet so we only
-		// check that part.
+		// check that part. 2 + 33 + 2 = 37 bytes, so we skip the first
+		// 37 bytes, which equals 74 hex characters.
 		const onionMessageHexHeaderLen = 74
 
 		require.Equal(
@@ -454,24 +460,30 @@ func TestOnionMessageRouteBlinding(t *testing.T) {
 
 		priv := privKeyFromString(hop.PrivKey)
 
-		switch i {
-		case 0:
-			// Onion message routes are always entirely blinded, so
-			// the first hop will always use the first blinding
-			// point.
-			blindingPoint = firstBlinding
-		case concatIndex:
+		if i == concatIndex {
 			blindingPoint = blindingOverride
 		}
 
+		// 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)
 
+		// 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,
 		)
 		require.NoError(t, err)
 
-		onionPacket = processedPkt.NextPacket
+		// We set the current onion packet to the next packet in the
+		// processed packet. This is the packet that the next hop will
+		// process. During the next iteration we will run all the above
+		// checks on this packet.
+		currentOnionPacket = processedPkt.NextPacket
 	}
 }