fixup! lnrpc: add filters to forwardhistoryrequest

Author: funyug

channeldb/forwarding_log.go

@@ -303,41 +303,41 @@ func (f *ForwardingLog) Query(q ForwardingEventQuery) (ForwardingLogTimeSlice, e
 				}
 
 				// Check if the incoming channel ID matches the
-				// filter criteria.
-				// Either no filtering is applied (IsEmpty), or
-				// the ID is explicitly included.
+				// filter criteria. Either no filtering is
+				// applied (IsEmpty), or the ID is explicitly
+				// included.
 				incomingMatch := q.IncomingChanIDs.IsEmpty() ||
 					q.IncomingChanIDs.Contains(
 						event.IncomingChanID.ToUint64(),
 					)
 
 				// Check if the outgoing channel ID matches the
-				// filter criteria.
-				// Either no filtering is applied (IsEmpty), or
-				// the ID is explicitly included.
+				// filter criteria. Either no filtering is
+				// applied (IsEmpty), or  the ID is explicitly
+				// included.
 				outgoingMatch := q.OutgoingChanIDs.IsEmpty() ||
 					q.OutgoingChanIDs.Contains(
 						event.OutgoingChanID.ToUint64(),
 					)
 
-				// If both conditions are met, then we'll add
-				// the event to our return payload.
-				if incomingMatch && outgoingMatch {
-					// If we're not yet past the user
-					// defined offset , then we'll continue
-					// to seek forward.
-					if recordsToSkip > 0 {
-						recordsToSkip--
-						continue
-					}
-
-					event.Timestamp = currentTime
-					resp.ForwardingEvents = append(
-						resp.ForwardingEvents,
-						event,
-					)
-					recordOffset++
+				// Skip this event if it doesn't match the
+				// filters.
+				if !incomingMatch || !outgoingMatch {
+					continue
+				}
+				// If we're not yet past the user defined offset
+				// then we'll continue to seek forward.
+				if recordsToSkip > 0 {
+					recordsToSkip--
+					continue
 				}
+
+				event.Timestamp = currentTime
+				resp.ForwardingEvents = append(
+					resp.ForwardingEvents,
+					event,
+				)
+				recordOffset++
 			}
 		}
 

channeldb/forwarding_log_test.go

@@ -362,9 +362,10 @@ func TestForwardingLogStoreEvent(t *testing.T) {
 	}
 }
 
-// TestForwardingLogQueryIncomingChanIDs tests that querying the forwarding log
-// using only incoming channel IDs returns the correct subset of events.
-func TestForwardingLogQueryIncomingChanIDs(t *testing.T) {
+// TestForwardingLogQueryIncomingOrOutgoingChanIDs tests that querying the
+// forwarding log using only incoming channel IDs or outgoing channel IDs
+// returns the correct subset of events.
+func TestForwardingLogQueryIncomingOrOutgoingChanIDs(t *testing.T) {
 	t.Parallel()
 
 	// Set up a test database.
@@ -378,7 +379,7 @@ func TestForwardingLogQueryIncomingChanIDs(t *testing.T) {
 	initialTime := time.Unix(1234, 0)
 	endTime := time.Unix(1234, 0)
 
-	// Create 10 random events with varying incoming ChanIDs.
+	// Create 10 random events with varying incoming and outgoing ChanIDs.
 	numEvents := 10
 	events := make([]ForwardingEvent, numEvents)
 	incomingChanIDs := []lnwire.ShortChannelID{
@@ -387,111 +388,95 @@ func TestForwardingLogQueryIncomingChanIDs(t *testing.T) {
 		lnwire.NewShortChanIDFromInt(2003),
 	}
 
+	outgoingChanIDs := []lnwire.ShortChannelID{
+		lnwire.NewShortChanIDFromInt(3001),
+		lnwire.NewShortChanIDFromInt(3002),
+		lnwire.NewShortChanIDFromInt(3003),
+	}
+
 	for i := 0; i < numEvents; i++ {
 		events[i] = ForwardingEvent{
 			Timestamp:      endTime,
 			IncomingChanID: incomingChanIDs[i%len(incomingChanIDs)],
+			OutgoingChanID: outgoingChanIDs[i%len(outgoingChanIDs)],
 			AmtIn:          lnwire.MilliSatoshi(rand.Int63()),
 			AmtOut:         lnwire.MilliSatoshi(rand.Int63()),
 		}
 		endTime = endTime.Add(time.Minute * 10)
 	}
 
 	// Add events to the database.
-	require.NoError(t, log.AddForwardingEvents(events),
-		"unable to add events")
+	require.NoError(
+		t,
+		log.AddForwardingEvents(events),
+		"unable to add events",
+	)
 
 	// Query with multiple incoming channel IDs.
-	eventQuery := ForwardingEventQuery{
+	incomingEventQuery := ForwardingEventQuery{
 		StartTime: initialTime,
 		EndTime:   endTime,
-		IncomingChanIDs: fn.NewSet(incomingChanIDs[0].ToUint64(),
-			incomingChanIDs[1].ToUint64()),
+		IncomingChanIDs: fn.NewSet(
+			incomingChanIDs[0].ToUint64(),
+			incomingChanIDs[1].ToUint64(),
+		),
 		IndexOffset:  0,
 		NumMaxEvents: 10,
 	}
-	timeSlice, err := log.Query(eventQuery)
+	incomingEventsTimeSlice, err := log.Query(incomingEventQuery)
 	require.NoError(t, err, "unable to query for events")
 
 	// Verify that only events with the specified incomingChanIDs are
 	// returned.
-	expectedEvents := []ForwardingEvent{}
+	expectedIncomingEvents := []ForwardingEvent{}
 	for _, e := range events {
 		if e.IncomingChanID == incomingChanIDs[0] ||
 			e.IncomingChanID == incomingChanIDs[1] {
 
-			expectedEvents = append(expectedEvents, e)
-		}
-	}
-
-	require.Equal(t, expectedEvents, timeSlice.ForwardingEvents,
-		"unexpected events returned")
-}
-
-// TestForwardingLogQueryOutgoingChanIDs tests that querying the forwarding log
-// using only outgoing channel IDs returns the correct subset of events.
-func TestForwardingLogQueryOutgoingChanIDs(t *testing.T) {
-	t.Parallel()
-
-	// Set up a test database.
-	db, err := MakeTestDB(t)
-	require.NoError(t, err, "unable to make test db")
-
-	log := ForwardingLog{
-		db: db,
-	}
-
-	initialTime := time.Unix(1234, 0)
-	endTime := time.Unix(1234, 0)
-
-	// Create 10 random events with varying outgoing ChanIDs.
-	numEvents := 10
-	events := make([]ForwardingEvent, numEvents)
-	outgoingChanIDs := []lnwire.ShortChannelID{
-		lnwire.NewShortChanIDFromInt(2001),
-		lnwire.NewShortChanIDFromInt(2002),
-		lnwire.NewShortChanIDFromInt(2003),
-	}
-
-	for i := 0; i < numEvents; i++ {
-		events[i] = ForwardingEvent{
-			Timestamp:      endTime,
-			OutgoingChanID: outgoingChanIDs[i%len(outgoingChanIDs)],
-			AmtIn:          lnwire.MilliSatoshi(rand.Int63()),
-			AmtOut:         lnwire.MilliSatoshi(rand.Int63()),
+			expectedIncomingEvents = append(
+				expectedIncomingEvents, e,
+			)
 		}
-		endTime = endTime.Add(time.Minute * 10)
 	}
 
-	// Add events to the database.
-	require.NoError(t, log.AddForwardingEvents(events),
-		"unable to add events")
+	require.Equal(
+		t,
+		expectedIncomingEvents,
+		incomingEventsTimeSlice.ForwardingEvents,
+	)
 
 	// Query with multiple outgoing channel IDs.
-	eventQuery := ForwardingEventQuery{
+	outgoingEventQuery := ForwardingEventQuery{
 		StartTime: initialTime,
 		EndTime:   endTime,
-		OutgoingChanIDs: fn.NewSet(outgoingChanIDs[0].ToUint64(),
-			outgoingChanIDs[1].ToUint64()),
+		OutgoingChanIDs: fn.NewSet(
+			outgoingChanIDs[0].ToUint64(),
+			outgoingChanIDs[1].ToUint64(),
+		),
 		IndexOffset:  0,
 		NumMaxEvents: 10,
 	}
-	timeSlice, err := log.Query(eventQuery)
+	outgoingEventsTimeSlice, err := log.Query(outgoingEventQuery)
 	require.NoError(t, err, "unable to query for events")
 
 	// Verify that only events with the specified outgoingChanIDs are
 	// returned.
-	expectedEvents := []ForwardingEvent{}
+	expectedOutgoingEvents := []ForwardingEvent{}
 	for _, e := range events {
 		if e.OutgoingChanID == outgoingChanIDs[0] ||
 			e.OutgoingChanID == outgoingChanIDs[1] {
 
-			expectedEvents = append(expectedEvents, e)
+			expectedOutgoingEvents = append(
+				expectedOutgoingEvents, e,
+			)
 		}
 	}
 
-	require.Equal(t, expectedEvents, timeSlice.ForwardingEvents,
-		"unexpected events returned")
+	require.Equal(
+		t,
+		expectedOutgoingEvents,
+		outgoingEventsTimeSlice.ForwardingEvents,
+	)
 }
 
 // TestForwardingLogQueryIncomingAndOutgoingChanIDs tests that querying the
@@ -545,10 +530,14 @@ func TestForwardingLogQueryIncomingAndOutgoingChanIDs(t *testing.T) {
 	eventQuery := ForwardingEventQuery{
 		StartTime: initialTime,
 		EndTime:   endTime,
-		OutgoingChanIDs: fn.NewSet(outgoingChanIDs[0].ToUint64(),
-			outgoingChanIDs[1].ToUint64()),
-		IncomingChanIDs: fn.NewSet(incomingChanIDs[0].ToUint64(),
-			incomingChanIDs[1].ToUint64()),
+		OutgoingChanIDs: fn.NewSet(
+			outgoingChanIDs[0].ToUint64(),
+			outgoingChanIDs[1].ToUint64(),
+		),
+		IncomingChanIDs: fn.NewSet(
+			incomingChanIDs[0].ToUint64(),
+			incomingChanIDs[1].ToUint64(),
+		),
 		IndexOffset:  0,
 		NumMaxEvents: 10,
 	}
@@ -568,6 +557,5 @@ func TestForwardingLogQueryIncomingAndOutgoingChanIDs(t *testing.T) {
 		}
 	}
 
-	require.Equal(t, expectedEvents, timeSlice.ForwardingEvents,
-		"unexpected events returned")
+	require.Equal(t, expectedEvents, timeSlice.ForwardingEvents)
 }

cmd/commands/cmd_payments.go

@@ -1523,13 +1523,15 @@ var forwardingHistoryCommand = cli.Command{
 		},
 		cli.Int64SliceFlag{
 			Name: "incoming_chan_ids",
-			Usage: "the short channel ids of the incoming " +
-				"channels to filter events by",
+			Usage: "the short channel id of the incoming " +
+				"channel to filter events by; can be " +
+				"specified multiple times in the same command",
 		},
 		cli.Int64SliceFlag{
 			Name: "outgoing_chan_ids",
-			Usage: "the short channel ids of the outgoing " +
-				"channels to filter events by",
+			Usage: "the short channel id of the outgoing " +
+				"channel to filter events by; can be " +
+				"specified multiple times in the same command",
 		},
 	},
 	Action: actionDecorator(forwardingHistory),

rpcserver.go

@@ -7954,8 +7954,7 @@ func (r *rpcServer) ForwardingHistory(ctx context.Context,
 	var (
 		startTime, endTime time.Time
 
-		numEvents                        uint32
-		incomingChanIDs, outgoingChanIDs fn.Set[uint64]
+		numEvents uint32
 	)
 
 	// startTime defaults to the Unix epoch (0 unixtime, or
@@ -7979,15 +7978,8 @@ func (r *rpcServer) ForwardingHistory(ctx context.Context,
 
 	// Create sets of incoming and outgoing channel IDs from the request
 	// for faster lookups for filtering.
-	incomingChanIDs = make(fn.Set[uint64], len(req.IncomingChanIds))
-	outgoingChanIDs = make(fn.Set[uint64], len(req.OutgoingChanIds))
-	for _, chanID := range req.IncomingChanIds {
-		incomingChanIDs.Add(chanID)
-	}
-
-	for _, chanID := range req.OutgoingChanIds {
-		outgoingChanIDs.Add(chanID)
-	}
+	incomingChanIDs := fn.NewSet(req.IncomingChanIds...)
+	outgoingChanIDs := fn.NewSet(req.OutgoingChanIds...)
 
 	// Next, we'll map the proto request into a format that is understood by
 	// the forwarding log.