Merge pull request #679 from sputn1ck/listswaps_filter

Add list swaps filter

Author: sputn1ck

cmd/loop/loopout.go

@@ -15,6 +15,13 @@ import (
 	"github.com/urfave/cli"
 )
 
+var (
+	channelFlag = cli.StringFlag{
+		Name: "channel",
+		Usage: "the comma-separated list of short " +
+			"channel IDs of the channels to loop out",
+	}
+)
 var loopOutCommand = cli.Command{
 	Name:      "out",
 	Usage:     "perform an off-chain to on-chain swap (looping out)",
@@ -28,11 +35,6 @@ var loopOutCommand = cli.Command{
 	Optionally a BASE58/bech32 encoded bitcoin destination address may be
 	specified. If not specified, a new wallet address will be generated.`,
 	Flags: []cli.Flag{
-		cli.StringFlag{
-			Name: "channel",
-			Usage: "the comma-separated list of short " +
-				"channel IDs of the channels to loop out",
-		},
 		cli.StringFlag{
 			Name: "addr",
 			Usage: "the optional address that the looped out funds " +
@@ -93,6 +95,7 @@ var loopOutCommand = cli.Command{
 		forceFlag,
 		labelFlag,
 		verboseFlag,
+		channelFlag,
 	},
 	Action: loopOut,
 }

cmd/loop/swaps.go

@@ -4,9 +4,12 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
+	"strconv"
+	"strings"
 
 	"github.com/lightninglabs/loop/looprpc"
 	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/urfave/cli"
 )
 
@@ -16,6 +19,23 @@ var listSwapsCommand = cli.Command{
 	Description: "Allows the user to get a list of all swaps that are " +
 		"currently stored in the database",
 	Action: listSwaps,
+	Flags: []cli.Flag{
+		cli.BoolFlag{
+			Name:  "loop_out_only",
+			Usage: "only list swaps that are loop out swaps",
+		},
+		cli.BoolFlag{
+			Name:  "loop_in_only",
+			Usage: "only list swaps that are loop in swaps",
+		},
+		cli.BoolFlag{
+			Name:  "pending_only",
+			Usage: "only list pending swaps",
+		},
+		labelFlag,
+		channelFlag,
+		lastHopFlag,
+	},
 }
 
 func listSwaps(ctx *cli.Context) error {
@@ -25,8 +45,64 @@ func listSwaps(ctx *cli.Context) error {
 	}
 	defer cleanup()
 
+	if ctx.Bool("loop_out_only") && ctx.Bool("loop_in_only") {
+		return fmt.Errorf("only one of loop_out_only and loop_in_only " +
+			"can be set")
+	}
+
+	filter := &looprpc.ListSwapsFilter{}
+
+	// Set the swap type filter.
+	switch {
+	case ctx.Bool("loop_out_only"):
+		filter.SwapType = looprpc.ListSwapsFilter_LOOP_OUT
+	case ctx.Bool("loop_in_only"):
+		filter.SwapType = looprpc.ListSwapsFilter_LOOP_IN
+	}
+
+	// Set the pending only filter.
+	filter.PendingOnly = ctx.Bool("pending_only")
+
+	// Parse outgoing channel set. Don't string split if the flag is empty.
+	// Otherwise, strings.Split returns a slice of length one with an empty
+	// element.
+	var outgoingChanSet []uint64
+	if ctx.IsSet(channelFlag.Name) {
+		chanStrings := strings.Split(ctx.String(channelFlag.Name), ",")
+		for _, chanString := range chanStrings {
+			chanID, err := strconv.ParseUint(chanString, 10, 64)
+			if err != nil {
+				return fmt.Errorf("error parsing channel id "+
+					"\"%v\"", chanString)
+			}
+			outgoingChanSet = append(outgoingChanSet, chanID)
+		}
+		filter.OutgoingChanSet = outgoingChanSet
+	}
+
+	// Parse last hop.
+	var lastHop []byte
+	if ctx.IsSet(lastHopFlag.Name) {
+		lastHopVertex, err := route.NewVertexFromStr(
+			ctx.String(lastHopFlag.Name),
+		)
+		if err != nil {
+			return err
+		}
+
+		lastHop = lastHopVertex[:]
+		filter.LoopInLastHop = lastHop
+	}
+
+	// Parse label.
+	if ctx.IsSet(labelFlag.Name) {
+		filter.Label = ctx.String(labelFlag.Name)
+	}
+
 	resp, err := client.ListSwaps(
-		context.Background(), &looprpc.ListSwapsRequest{},
+		context.Background(), &looprpc.ListSwapsRequest{
+			ListSwapFilter: filter,
+		},
 	)
 	if err != nil {
 		return err

loopd/swapclient_server.go

@@ -6,7 +6,9 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"reflect"
 	"sort"
+	"strings"
 	"sync"
 	"time"
 
@@ -470,12 +472,11 @@ func (s *swapClientServer) Monitor(in *clientrpc.MonitorRequest,
 // ListSwaps returns a list of all currently known swaps and their current
 // status.
 func (s *swapClientServer) ListSwaps(_ context.Context,
-	_ *clientrpc.ListSwapsRequest) (*clientrpc.ListSwapsResponse, error) {
+	req *clientrpc.ListSwapsRequest) (*clientrpc.ListSwapsResponse, error) {
 
 	var (
-		rpcSwaps = make([]*clientrpc.SwapStatus, len(s.swaps))
+		rpcSwaps = []*clientrpc.SwapStatus{}
 		idx      = 0
-		err      error
 	)
 
 	s.swapsLock.Lock()
@@ -487,15 +488,93 @@ func (s *swapClientServer) ListSwaps(_ context.Context,
 	// additional index.
 	for _, swp := range s.swaps {
 		swp := swp
-		rpcSwaps[idx], err = s.marshallSwap(&swp)
+
+		// Filter the swap based on the provided filter.
+		if !filterSwap(&swp, req.ListSwapFilter) {
+			continue
+		}
+
+		rpcSwap, err := s.marshallSwap(&swp)
 		if err != nil {
 			return nil, err
 		}
+		rpcSwaps = append(rpcSwaps, rpcSwap)
 		idx++
 	}
 	return &clientrpc.ListSwapsResponse{Swaps: rpcSwaps}, nil
 }
 
+// filterSwap filters the given swap based on the provided filter.
+func filterSwap(swapInfo *loop.SwapInfo, filter *clientrpc.ListSwapsFilter) bool {
+	if filter == nil {
+		return true
+	}
+
+	// If the swap type filter is set, we only return swaps that match the
+	// filter.
+	if filter.SwapType != clientrpc.ListSwapsFilter_ANY {
+		switch filter.SwapType {
+		case clientrpc.ListSwapsFilter_LOOP_IN:
+			if swapInfo.SwapType != swap.TypeIn {
+				return false
+			}
+
+		case clientrpc.ListSwapsFilter_LOOP_OUT:
+			if swapInfo.SwapType != swap.TypeOut {
+				return false
+			}
+		}
+	}
+
+	// If the pending only filter is set, we only return pending swaps.
+	if filter.PendingOnly && !swapInfo.State.IsPending() {
+		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 {
+		// First we sort both channel sets to make sure we can compare
+		// them.
+		sort.Slice(swapInfo.OutgoingChanSet, func(i, j int) bool {
+			return swapInfo.OutgoingChanSet[i] <
+				swapInfo.OutgoingChanSet[j]
+		})
+		sort.Slice(filter.OutgoingChanSet, func(i, j int) bool {
+			return filter.OutgoingChanSet[i] <
+				filter.OutgoingChanSet[j]
+		})
+
+		// Compare the outgoing channel set by using reflect.DeepEqual
+		// which compares the underlying arrays.
+		if !reflect.DeepEqual(swapInfo.OutgoingChanSet,
+			filter.OutgoingChanSet) {
+
+			return false
+		}
+	}
+
+	// If the swap is of type loop in and the last hop filter is set, we
+	// only return swaps that match the filter.
+	if swapInfo.SwapType == swap.TypeIn && filter.LoopInLastHop != nil {
+		// Compare the last hop by using reflect.DeepEqual which
+		// compares the underlying arrays.
+		if !reflect.DeepEqual(swapInfo.LastHop, filter.LoopInLastHop) {
+			return false
+		}
+	}
+
+	// If a label filter is set, we only return swaps that softly match the
+	// filter.
+	if filter.Label != "" {
+		if !strings.Contains(swapInfo.Label, filter.Label) {
+			return false
+		}
+	}
+
+	return true
+}
+
 // SwapInfo returns all known details about a single swap.
 func (s *swapClientServer) SwapInfo(_ context.Context,
 	req *clientrpc.SwapInfoRequest) (*clientrpc.SwapStatus, error) {