looprpc: add simple pagination to the ListSwaps command

This commit adds the ability to set a max_swaps and an index_offset
flag to the ListSwaps command. These new fields are applied AFTER
the initial filtering step. The response also now passes additional
information about the index count and total swaps filtered.

Author: kornpow

cmd/loop/swaps.go

@@ -35,6 +35,14 @@ var listSwapsCommand = cli.Command{
 		labelFlag,
 		channelFlag,
 		lastHopFlag,
+		cli.Uint64Flag{
+			Name:  "max_swaps",
+			Usage: "Max number of swaps to return after filtering",
+		},
+		cli.Int64Flag{
+			Name:  "start_time_ns",
+			Usage: "Unix timestamp to start listing swaps from (default: 0, meaning no start time filter)",
+		},
 	},
 }
 
@@ -99,9 +107,19 @@ func listSwaps(ctx *cli.Context) error {
 		filter.Label = ctx.String(labelFlag.Name)
 	}
 
+	// Parse start timestamp if set.
+	if ctx.IsSet("start_time_ns") {
+		startTimestamp, err := strconv.ParseInt(ctx.String("start_time_ns"), 10, 64)
+		if err != nil {
+			return fmt.Errorf("error parsing start timestamp: %v", err)
+		}
+		filter.StartTimestampNs = startTimestamp
+	}
+
 	resp, err := client.ListSwaps(
 		context.Background(), &looprpc.ListSwapsRequest{
 			ListSwapFilter: filter,
+			MaxSwaps:       ctx.Uint64("max_swaps"),
 		},
 	)
 	if err != nil {

loopd/swapclient_server.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"slices"
 	"sort"
 	"strings"
 	"sync"
@@ -563,31 +564,67 @@ func (s *swapClientServer) ListSwaps(ctx context.Context,
 	req *looprpc.ListSwapsRequest) (*looprpc.ListSwapsResponse, error) {
 
 	var (
-		rpcSwaps = []*looprpc.SwapStatus{}
-		idx      = 0
+		rpcSwaps      = []*looprpc.SwapStatus{}
+		maxSwaps      = int(req.MaxSwaps)
+		nextStartTime = int64(0)
+		canPage       = false
 	)
 
 	s.swapsLock.Lock()
 	defer s.swapsLock.Unlock()
 
+	// Convert the swaps map into a slice which can be ordered.
+	var swapList []loop.SwapInfo
+	for _, swp := range s.swaps {
+		swapList = append(swapList, swp)
+	}
+
+	// Sort all swaps by a consistent field, InitiationTime.
+	slices.SortFunc(swapList, func(a, b loop.SwapInfo) int {
+		// For descending order (newest first)
+		if a.InitiationTime.UnixNano() > b.InitiationTime.UnixNano() {
+			return 1
+		}
+		if a.InitiationTime.UnixNano() < b.InitiationTime.UnixNano() {
+			return -1
+		}
+		return 0
+	})
 	// We can just use the server's in-memory cache as that contains the
 	// most up-to-date state including temporary failures which aren't
 	// persisted to disk. The swaps field is a map, that's why we need an
 	// additional index.
-	for _, swp := range s.swaps {
+	for _, swp := range swapList {
 		// Filter the swap based on the provided filter.
 		if !filterSwap(&swp, req.ListSwapFilter) {
 			continue
 		}
 
-		rpcSwap, err := s.marshallSwap(ctx, &swp)
-		if err != nil {
-			return nil, err
+		// Check if this swap is within our pagination window.
+		// If maxSwaps is 0, we return all swaps.
+		// Otherwise, check if we've reached our limit.
+		if maxSwaps == 0 || len(rpcSwaps) < maxSwaps {
+			rpcSwap, err := s.marshallSwap(ctx, &swp)
+			if err != nil {
+				return nil, err
+			}
+			rpcSwaps = append(rpcSwaps, rpcSwap)
+		} else {
+			// Indicate that paging is enabled, and exit the loop.
+			canPage = true
+			break
 		}
-		rpcSwaps = append(rpcSwaps, rpcSwap)
-		idx++
 	}
-	return &looprpc.ListSwapsResponse{Swaps: rpcSwaps}, nil
+
+	if canPage {
+		nextStartTime = rpcSwaps[len(rpcSwaps)-1].InitiationTime + 1
+	}
+
+	response := looprpc.ListSwapsResponse{
+		Swaps:         rpcSwaps,
+		NextStartTime: nextStartTime,
+	}
+	return &response, nil
 }
 
 // filterSwap filters the given swap based on the provided filter.
@@ -617,6 +654,11 @@ func filterSwap(swapInfo *loop.SwapInfo, filter *looprpc.ListSwapsFilter) bool {
 		return false
 	}
 
+	// If timestamp filters are set, only return swaps within the specified time range.
+	if filter.StartTimestampNs > 0 && swapInfo.InitiationTime.UnixNano() < filter.StartTimestampNs {
+		return false
+	}
+
 	// If the swap is of type loop out and the outgoing channel filter is
 	// set, we only return swaps that match the filter.
 	if swapInfo.SwapType == swap.TypeOut && filter.OutgoingChanSet != nil {