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.Uint64Flag{
+			Name:  "index_offset",
+			Usage: "index to start listing filtered swaps from",
+		},
 	},
 }
 
@@ -102,6 +110,8 @@ func listSwaps(ctx *cli.Context) error {
 	resp, err := client.ListSwaps(
 		context.Background(), &looprpc.ListSwapsRequest{
 			ListSwapFilter: filter,
+			IndexOffset:    uint32(ctx.Uint("index_offset")),
+			MaxSwaps:       uint32(ctx.Uint("max_swaps")),
 		},
 	)
 	if err != nil {

loopd/swapclient_server.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"slices"
 	"sort"
 	"strings"
 	"sync"
@@ -565,29 +566,64 @@ func (s *swapClientServer) ListSwaps(ctx context.Context,
 	var (
 		rpcSwaps = []*looprpc.SwapStatus{}
 		idx      = 0
+		lastIdx  = 0
+		maxSwaps = int(req.MaxSwaps)
 	)
 
 	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 idx >= int(req.IndexOffset) {
+			// 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)
+				lastIdx = idx
+			}
+
 		}
-		rpcSwaps = append(rpcSwaps, rpcSwap)
 		idx++
 	}
-	return &looprpc.ListSwapsResponse{Swaps: rpcSwaps}, nil
+
+	response := looprpc.ListSwapsResponse{
+		Swaps:              rpcSwaps,
+		FirstIndexOffset:   req.IndexOffset,
+		LastIndexOffset:    uint64(lastIdx),
+		TotalFilteredSwaps: uint64(idx),
+	}
+	return &response, nil
 }
 
 // filterSwap filters the given swap based on the provided filter.