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: %w", 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,8 +564,11 @@ func (s *swapClientServer) ListSwaps(ctx context.Context,
 	req *looprpc.ListSwapsRequest) (*looprpc.ListSwapsResponse, error) {
 
 	var (
-		rpcSwaps = []*looprpc.SwapStatus{}
-		idx      = 0
+		rpcSwaps      = []*looprpc.SwapStatus{}
+		rpcSwapInfo   = []*loop.SwapInfo{}
+		maxSwaps      = int(req.MaxSwaps)
+		nextStartTime = int64(0)
+		canPage       = false
 	)
 
 	s.swapsLock.Lock()
@@ -580,14 +584,46 @@ func (s *swapClientServer) ListSwaps(ctx context.Context,
 			continue
 		}
 
-		rpcSwap, err := s.marshallSwap(ctx, &swp)
+		rpcSwapInfo = append(rpcSwapInfo, &swp)
+	}
+
+	// Sort the swaps by initiation time in ascending order (oldest first).
+	slices.SortFunc(rpcSwapInfo, func(a, b *loop.SwapInfo) int {
+		if a.InitiationTime.UnixNano() > b.InitiationTime.UnixNano() {
+			return 1
+		}
+		if a.InitiationTime.UnixNano() < b.InitiationTime.UnixNano() {
+			return -1
+		}
+		return 0
+	})
+
+	// Apply the maxSwaps limit if specified.
+	if maxSwaps > 0 && len(rpcSwapInfo) > maxSwaps {
+		canPage = true
+		rpcSwapInfo = rpcSwapInfo[:maxSwaps]
+	}
+
+	// Marshal the filtered and limited swaps.
+	for _, swp := range rpcSwapInfo {
+		rpcSwap, err := s.marshallSwap(ctx, swp)
 		if err != nil {
 			return nil, err
 		}
 		rpcSwaps = append(rpcSwaps, rpcSwap)
-		idx++
 	}
-	return &looprpc.ListSwapsResponse{Swaps: rpcSwaps}, nil
+
+	// Set the next start time for pagination if needed.
+	if canPage && len(rpcSwaps) > 0 {
+		// Use the initiation time of the last swap plus 1 nanosecond.
+		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 +653,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 {