liquidity: add peer-level liquidity rules to allow aggregate management

We add 'peer-level' rules to allow assessment of liquidity on a per-peer
level, rather than on an individual channel basis. No overlap is allowed
with the existing set of channel rules because this could lead to
contradictory rules.

Author: carlaKC

liquidity/autoloop_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/btcsuite/btcutil"
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/loop"
 	"github.com/lightninglabs/loop/labels"
@@ -12,6 +13,7 @@ import (
 	"github.com/lightninglabs/loop/test"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/routing/route"
 )
 
 // TestAutoLoopDisabled tests the case where we need to perform a swap, but
@@ -266,6 +268,161 @@ func TestAutoLoopEnabled(t *testing.T) {
 	c.stop()
 }
 
+// TestCompositeRules tests the case where we have rules set on a per peer
+// and per channel basis, and perform swaps for both targets.
+func TestCompositeRules(t *testing.T) {
+	defer test.Guard(t)()
+
+	// Setup our channels so that we have two channels with peer 2, and
+	// a single channel with peer 1.
+	channel3 := lndclient.ChannelInfo{
+		ChannelID:     chanID3.ToUint64(),
+		PubKeyBytes:   peer2,
+		LocalBalance:  10000,
+		RemoteBalance: 0,
+		Capacity:      10000,
+	}
+
+	channels := []lndclient.ChannelInfo{
+		channel1, channel2, channel3,
+	}
+
+	// Create a set of parameters with autoloop enabled, set our budget to
+	// a value that will easily accommodate our two swaps.
+	params := Parameters{
+		Autoloop:                   true,
+		AutoFeeBudget:              100000,
+		AutoFeeStartDate:           testTime,
+		MaxAutoInFlight:            2,
+		FailureBackOff:             time.Hour,
+		SweepFeeRateLimit:          20000,
+		SweepConfTarget:            10,
+		MaximumPrepay:              20000,
+		MaximumSwapFeePPM:          1000,
+		MaximumRoutingFeePPM:       1000,
+		MaximumPrepayRoutingFeePPM: 1000,
+		MaximumMinerFee:            20000,
+		ChannelRules: map[lnwire.ShortChannelID]*ThresholdRule{
+			chanID1: chanRule,
+		},
+		PeerRules: map[route.Vertex]*ThresholdRule{
+			peer2: chanRule,
+		},
+	}
+
+	c := newAutoloopTestCtx(t, params, channels, testRestrictions)
+	c.start()
+
+	// Calculate our maximum allowed fees and create quotes that fall within
+	// our budget.
+	var (
+		// Create a quote for our peer level swap that is within
+		// our budget, with an amount which would balance the peer
+		/// across all of its channels.
+		peerAmount     = btcutil.Amount(15000)
+		maxPeerSwapFee = ppmToSat(peerAmount, params.MaximumSwapFeePPM)
+
+		peerSwapQuote = &loop.LoopOutQuote{
+			SwapFee:      maxPeerSwapFee,
+			PrepayAmount: params.MaximumPrepay - 20,
+		}
+
+		peerSwapQuoteRequest = &loop.LoopOutQuoteRequest{
+			Amount:          peerAmount,
+			SweepConfTarget: params.SweepConfTarget,
+		}
+
+		maxPeerRouteFee = ppmToSat(
+			peerAmount, params.MaximumRoutingFeePPM,
+		)
+
+		peerSwap = &loop.OutRequest{
+			Amount:            peerAmount,
+			MaxSwapRoutingFee: maxPeerRouteFee,
+			MaxPrepayRoutingFee: ppmToSat(
+				peerSwapQuote.PrepayAmount,
+				params.MaximumPrepayRoutingFeePPM,
+			),
+			MaxSwapFee:      peerSwapQuote.SwapFee,
+			MaxPrepayAmount: peerSwapQuote.PrepayAmount,
+			MaxMinerFee:     params.MaximumMinerFee,
+			SweepConfTarget: params.SweepConfTarget,
+			OutgoingChanSet: loopdb.ChannelSet{
+				chanID2.ToUint64(), chanID3.ToUint64(),
+			},
+			Label:     labels.AutoloopLabel(swap.TypeOut),
+			Initiator: autoloopSwapInitiator,
+		}
+		// Create a quote for our single channel swap that is within
+		// our budget.
+		chanAmount     = chan1Rec.Amount
+		maxChanSwapFee = ppmToSat(chanAmount, params.MaximumSwapFeePPM)
+
+		channelSwapQuote = &loop.LoopOutQuote{
+			SwapFee:      maxChanSwapFee,
+			PrepayAmount: params.MaximumPrepay - 10,
+		}
+
+		chanSwapQuoteRequest = &loop.LoopOutQuoteRequest{
+			Amount:          chanAmount,
+			SweepConfTarget: params.SweepConfTarget,
+		}
+
+		maxChanRouteFee = ppmToSat(
+			chanAmount, params.MaximumRoutingFeePPM,
+		)
+
+		chanSwap = &loop.OutRequest{
+			Amount:            chanAmount,
+			MaxSwapRoutingFee: maxChanRouteFee,
+			MaxPrepayRoutingFee: ppmToSat(
+				channelSwapQuote.PrepayAmount,
+				params.MaximumPrepayRoutingFeePPM,
+			),
+			MaxSwapFee:      channelSwapQuote.SwapFee,
+			MaxPrepayAmount: channelSwapQuote.PrepayAmount,
+			MaxMinerFee:     params.MaximumMinerFee,
+			SweepConfTarget: params.SweepConfTarget,
+			OutgoingChanSet: loopdb.ChannelSet{chanID1.ToUint64()},
+			Label:           labels.AutoloopLabel(swap.TypeOut),
+			Initiator:       autoloopSwapInitiator,
+		}
+		quotes = []quoteRequestResp{
+			{
+				request: peerSwapQuoteRequest,
+				quote:   peerSwapQuote,
+			},
+			{
+				request: chanSwapQuoteRequest,
+				quote:   channelSwapQuote,
+			},
+		}
+
+		loopOuts = []loopOutRequestResp{
+			{
+				request: peerSwap,
+				response: &loop.LoopOutSwapInfo{
+					SwapHash: lntypes.Hash{2},
+				},
+			},
+			{
+				request: chanSwap,
+				response: &loop.LoopOutSwapInfo{
+					SwapHash: lntypes.Hash{1},
+				},
+			},
+		}
+	)
+
+	// Tick our autolooper with no existing swaps, we expect a loop out
+	// swap to be dispatched for each of our rules. We set our server side
+	// maximum to be greater than the swap amount for our peer swap (which
+	// is the larger of the two swaps).
+	c.autoloop(1, peerAmount+1, nil, quotes, loopOuts)
+
+	c.stop()
+}
+
 // existingSwapFromRequest is a helper function which returns the db
 // representation of a loop out request with the event set provided.
 func existingSwapFromRequest(request *loop.OutRequest, initTime time.Time,

liquidity/balances.go

@@ -19,8 +19,10 @@ type balances struct {
 	// outgoing is the local balance of the channel.
 	outgoing btcutil.Amount
 
-	// channelID is the channel that has these balances.
-	channelID lnwire.ShortChannelID
+	// channels is the channel that has these balances represent. This may
+	// be more than one channel in the case where we are examining a peer's
+	// liquidity as a whole.
+	channels []lnwire.ShortChannelID
 
 	// pubkey is the public key of the peer we have this balances set with.
 	pubkey route.Vertex
@@ -29,10 +31,12 @@ type balances struct {
 // newBalances creates a balances struct from lndclient channel information.
 func newBalances(info lndclient.ChannelInfo) *balances {
 	return &balances{
-		capacity:  info.Capacity,
-		incoming:  info.RemoteBalance,
-		outgoing:  info.LocalBalance,
-		channelID: lnwire.NewShortChanIDFromInt(info.ChannelID),
-		pubkey:    info.PubKeyBytes,
+		capacity: info.Capacity,
+		incoming: info.RemoteBalance,
+		outgoing: info.LocalBalance,
+		channels: []lnwire.ShortChannelID{
+			lnwire.NewShortChanIDFromInt(info.ChannelID),
+		},
+		pubkey: info.PubKeyBytes,
 	}
 }