htlcswitch: move hop iterator into htlcswitch/hop package

Prepares for onion blob decoding outside of htlcswitch.

htlcswitch/hop/iterator_test.go

@@ -0,0 +1,100 @@
+package hop
+
+import (
+	"bytes"
+	"encoding/binary"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+	sphinx "github.com/lightningnetwork/lightning-onion"
+	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/record"
+	"github.com/lightningnetwork/lnd/tlv"
+)
+
+// TestSphinxHopIteratorForwardingInstructions tests that we're able to
+// properly decode an onion payload, no matter the payload type, into the
+// original set of forwarding instructions.
+func TestSphinxHopIteratorForwardingInstructions(t *testing.T) {
+	t.Parallel()
+
+	// First, we'll make the hop data that the sender would create to send
+	// an HTLC through our imaginary route.
+	hopData := sphinx.HopData{
+		ForwardAmount: 100000,
+		OutgoingCltv:  4343,
+	}
+	copy(hopData.NextAddress[:], bytes.Repeat([]byte("a"), 8))
+
+	// Next, we'll make the hop forwarding information that we should
+	// extract each type, no matter the payload type.
+	nextAddrInt := binary.BigEndian.Uint64(hopData.NextAddress[:])
+	expectedFwdInfo := ForwardingInfo{
+		NextHop:         lnwire.NewShortChanIDFromInt(nextAddrInt),
+		AmountToForward: lnwire.MilliSatoshi(hopData.ForwardAmount),
+		OutgoingCTLV:    hopData.OutgoingCltv,
+	}
+
+	// For our TLV payload, we'll serialize the hop into into a TLV stream
+	// as we would normally in the routing network.
+	var b bytes.Buffer
+	tlvRecords := []tlv.Record{
+		record.NewAmtToFwdRecord(&hopData.ForwardAmount),
+		record.NewLockTimeRecord(&hopData.OutgoingCltv),
+		record.NewNextHopIDRecord(&nextAddrInt),
+	}
+	tlvStream, err := tlv.NewStream(tlvRecords...)
+	if err != nil {
+		t.Fatalf("unable to create stream: %v", err)
+	}
+	if err := tlvStream.Encode(&b); err != nil {
+		t.Fatalf("unable to encode stream: %v", err)
+	}
+
+	var testCases = []struct {
+		sphinxPacket    *sphinx.ProcessedPacket
+		expectedFwdInfo ForwardingInfo
+	}{
+		// A regular legacy payload that signals more hops.
+		{
+			sphinxPacket: &sphinx.ProcessedPacket{
+				Payload: sphinx.HopPayload{
+					Type: sphinx.PayloadLegacy,
+				},
+				Action:                 sphinx.MoreHops,
+				ForwardingInstructions: &hopData,
+			},
+			expectedFwdInfo: expectedFwdInfo,
+		},
+		// A TLV payload, we can leave off the action as we'll always
+		// read the cid encoded.
+		{
+			sphinxPacket: &sphinx.ProcessedPacket{
+				Payload: sphinx.HopPayload{
+					Type:    sphinx.PayloadTLV,
+					Payload: b.Bytes(),
+				},
+			},
+			expectedFwdInfo: expectedFwdInfo,
+		},
+	}
+
+	// Finally, we'll test that we get the same set of
+	// ForwardingInstructions for each payload type.
+	iterator := sphinxHopIterator{}
+	for i, testCase := range testCases {
+		iterator.processedPacket = testCase.sphinxPacket
+
+		fwdInfo, err := iterator.ForwardingInstructions()
+		if err != nil {
+			t.Fatalf("#%v: unable to extract forwarding "+
+				"instructions: %v", i, err)
+		}
+
+		if fwdInfo != testCase.expectedFwdInfo {
+			t.Fatalf("#%v: wrong fwding info: expected %v, got %v",
+				i, spew.Sdump(testCase.expectedFwdInfo),
+				spew.Sdump(fwdInfo))
+		}
+	}
+}