liquidity: add reasons for autoloops not executing

Author: carlaKC

liquidity/liquidity.go

@@ -516,12 +516,12 @@ func cloneParameters(params Parameters) Parameters {
 // autoloop gets a set of suggested swaps and dispatches them automatically if
 // we have automated looping enabled.
 func (m *Manager) autoloop(ctx context.Context) error {
-	swaps, err := m.SuggestSwaps(ctx, true)
+	suggestion, err := m.SuggestSwaps(ctx, true)
 	if err != nil {
 		return err
 	}
 
-	for _, swap := range swaps {
+	for _, swap := range suggestion.OutSwaps {
 		// If we don't actually have dispatch of swaps enabled, log
 		// suggestions.
 		if !m.params.Autoloop {
@@ -557,14 +557,44 @@ func (m *Manager) ForceAutoLoop(ctx context.Context) error {
 	}
 }
 
+// Suggestions provides a set of suggested swaps, and the set of channels that
+// were excluded from consideration.
+type Suggestions struct {
+	// OutSwaps is the set of loop out swaps that we suggest executing.
+	OutSwaps []loop.OutRequest
+
+	// DisqualifiedChans maps the set of channels that we do not recommend
+	// swaps on to the reason that we did not recommend a swap.
+	DisqualifiedChans map[lnwire.ShortChannelID]Reason
+}
+
+func newSuggestions() *Suggestions {
+	return &Suggestions{
+		DisqualifiedChans: make(map[lnwire.ShortChannelID]Reason),
+	}
+}
+
+// singleReasonSuggestion is a helper function which returns a set of
+// suggestions where all of our rules are disqualified due to a reason that
+// applies to all of them (such as being out of budget).
+func (m *Manager) singleReasonSuggestion(reason Reason) *Suggestions {
+	resp := newSuggestions()
+
+	for id := range m.params.ChannelRules {
+		resp.DisqualifiedChans[id] = reason
+	}
+
+	return resp
+}
+
 // SuggestSwaps returns a set of swap suggestions based on our current liquidity
 // balance for the set of rules configured for the manager, failing if there are
 // no rules set. It takes an autoloop boolean that indicates whether the
 // suggestions are being used for our internal autolooper. This boolean is used
 // to determine the information we add to our swap suggestion and whether we
 // return any suggestions.
 func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
-	[]loop.OutRequest, error) {
+	*Suggestions, error) {
 
 	m.paramsLock.Lock()
 	defer m.paramsLock.Unlock()
@@ -582,7 +612,7 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
 		log.Debugf("autoloop fee budget start time: %v is in "+
 			"the future", m.params.AutoFeeStartDate)
 
-		return nil, nil
+		return m.singleReasonSuggestion(ReasonBudgetNotStarted), nil
 	}
 
 	// Before we get any swap suggestions, we check what the current fee
@@ -603,7 +633,7 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
 			satPerKwToSatPerVByte(estimate),
 			satPerKwToSatPerVByte(m.params.SweepFeeRateLimit))
 
-		return nil, nil
+		return m.singleReasonSuggestion(ReasonSweepFees), nil
 	}
 
 	// Get the current server side restrictions, combined with the client
@@ -640,7 +670,7 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
 			m.params.AutoFeeBudget, summary.spentFees,
 			summary.pendingFees)
 
-		return nil, nil
+		return m.singleReasonSuggestion(ReasonBudgetElapsed), nil
 	}
 
 	// If we have already reached our total allowed number of in flight
@@ -649,7 +679,8 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
 	if allowedSwaps <= 0 {
 		log.Debugf("%v autoloops allowed, %v in flight",
 			m.params.MaxAutoInFlight, summary.inFlightCount)
-		return nil, nil
+
+		return m.singleReasonSuggestion(ReasonInFlight), nil
 	}
 
 	channels, err := m.cfg.Lnd.Client.ListChannels(ctx)
@@ -661,7 +692,10 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
 	// to ongoing swaps.
 	traffic := m.currentSwapTraffic(loopOut, loopIn)
 
-	var suggestions []loop.OutRequest
+	var (
+		suggestions  []loop.OutRequest
+		disqualified = make(map[lnwire.ShortChannelID]Reason)
+	)
 
 	for _, channel := range channels {
 		balance := newBalances(channel)
@@ -671,14 +705,19 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
 			continue
 		}
 
-		if !traffic.maySwap(channel.PubKeyBytes, balance.channelID) {
+		// Check whether we can perform a swap, adding the channel to
+		// our set of disqualified swaps if it is not eligible.
+		reason := traffic.maySwap(channel.PubKeyBytes, balance.channelID)
+		if reason != ReasonNone {
+			disqualified[balance.channelID] = reason
 			continue
 		}
 
 		// We can have nil suggestions in the case where no action is
 		// required, so we skip over them.
 		suggestion := rule.suggestSwap(balance, restrictions)
 		if suggestion == nil {
+			disqualified[balance.channelID] = ReasonLiquidityOk
 			continue
 		}
 
@@ -700,11 +739,9 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
 
 		// Check that the estimated fees for the suggested swap are
 		// below the fee limits configured by the manager.
-		err = m.checkFeeLimits(quote, suggestion.Amount)
-		if err != nil {
-			log.Infof("suggestion: %v expected fees too high: %v",
-				suggestion, err)
-
+		feeReason := m.checkFeeLimits(quote, suggestion.Amount)
+		if feeReason != ReasonNone {
+			disqualified[balance.channelID] = feeReason
 			continue
 		}
 
@@ -717,10 +754,16 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
 		suggestions = append(suggestions, outRequest)
 	}
 
-	// If we have no suggestions after we have applied all of our limits,
-	// just return.
+	// Finally, run through all possible swaps, excluding swaps that are
+	// not feasible due to fee or budget restrictions.
+	resp := &Suggestions{
+		DisqualifiedChans: disqualified,
+	}
+
+	// If we have no swaps to execute after we have applied all of our
+	// limits, just return our set of disqualified swaps.
 	if len(suggestions) == 0 {
-		return nil, nil
+		return resp, nil
 	}
 
 	// Sort suggestions by amount in descending order.
@@ -730,12 +773,38 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
 
 	// Run through our suggested swaps in descending order of amount and
 	// return all of the swaps which will fit within our remaining budget.
-	var (
-		available = m.params.AutoFeeBudget - summary.totalFees()
-		inBudget  []loop.OutRequest
-	)
+	available := m.params.AutoFeeBudget - summary.totalFees()
+
+	// setReason is a helper that adds a swap's channels to our disqualified
+	// list with the reason provided.
+	setReason := func(reason Reason, swap loop.OutRequest) {
+		for _, id := range swap.OutgoingChanSet {
+			chanID := lnwire.NewShortChanIDFromInt(id)
+
+			resp.DisqualifiedChans[chanID] = reason
+		}
+	}
 
 	for _, swap := range suggestions {
+		swap := swap
+
+		// If we do not have enough funds available, or we hit our
+		// in flight limit, we record this value for the rest of the
+		// swaps.
+		var reason Reason
+		switch {
+		case available == 0:
+			reason = ReasonBudgetInsufficient
+
+		case len(resp.OutSwaps) == allowedSwaps:
+			reason = ReasonInFlight
+		}
+
+		if reason != ReasonNone {
+			setReason(reason, swap)
+			continue
+		}
+
 		fees := worstCaseOutFees(
 			swap.MaxPrepayRoutingFee, swap.MaxSwapRoutingFee,
 			swap.MaxSwapFee, swap.MaxMinerFee, swap.MaxPrepayAmount,
@@ -746,17 +815,13 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
 		// fall within the budget and decrement our available amount.
 		if fees <= available {
 			available -= fees
-			inBudget = append(inBudget, swap)
-		}
-
-		// If we're out of budget, or we have hit the max number of
-		// swaps that we want to dispatch at one time, exit early.
-		if available == 0 || allowedSwaps == len(inBudget) {
-			break
+			resp.OutSwaps = append(resp.OutSwaps, swap)
+		} else {
+			setReason(ReasonBudgetInsufficient, swap)
 		}
 	}
 
-	return inBudget, nil
+	return resp, nil
 }
 
 // getSwapRestrictions queries the server for its latest swap size restrictions,
@@ -1030,56 +1095,62 @@ func newSwapTraffic() *swapTraffic {
 // maySwap returns a boolean that indicates whether we may perform a swap for a
 // peer and its set of channels.
 func (s *swapTraffic) maySwap(peer route.Vertex,
-	chanID lnwire.ShortChannelID) bool {
+	chanID lnwire.ShortChannelID) Reason {
 
 	lastFail, recentFail := s.failedLoopOut[chanID]
 	if recentFail {
 		log.Debugf("Channel: %v not eligible for suggestions, was "+
 			"part of a failed swap at: %v", chanID, lastFail)
 
-		return false
+		return ReasonFailureBackoff
 	}
 
 	if s.ongoingLoopOut[chanID] {
 		log.Debugf("Channel: %v not eligible for suggestions, "+
 			"ongoing loop out utilizing channel", chanID)
 
-		return false
+		return ReasonLoopOut
 	}
 
 	if s.ongoingLoopIn[peer] {
 		log.Debugf("Peer: %x not eligible for suggestions ongoing "+
 			"loop in utilizing peer", peer)
 
-		return false
+		return ReasonLoopIn
 	}
 
-	return true
+	return ReasonNone
 }
 
 // checkFeeLimits takes a set of fees for a swap and checks whether they exceed
 // our swap limits.
 func (m *Manager) checkFeeLimits(quote *loop.LoopOutQuote,
-	swapAmt btcutil.Amount) error {
+	swapAmt btcutil.Amount) Reason {
 
 	maxFee := ppmToSat(swapAmt, m.params.MaximumSwapFeePPM)
 
 	if quote.SwapFee > maxFee {
-		return fmt.Errorf("quoted swap fee: %v > maximum swap fee: %v",
+		log.Debugf("quoted swap fee: %v > maximum swap fee: %v",
 			quote.SwapFee, maxFee)
+
+		return ReasonSwapFee
 	}
 
 	if quote.MinerFee > m.params.MaximumMinerFee {
-		return fmt.Errorf("quoted miner fee: %v > maximum miner "+
+		log.Debugf("quoted miner fee: %v > maximum miner "+
 			"fee: %v", quote.MinerFee, m.params.MaximumMinerFee)
+
+		return ReasonMinerFee
 	}
 
 	if quote.PrepayAmount > m.params.MaximumPrepay {
-		return fmt.Errorf("quoted prepay: %v > maximum prepay: %v",
+		log.Debugf("quoted prepay: %v > maximum prepay: %v",
 			quote.PrepayAmount, m.params.MaximumPrepay)
+
+		return ReasonPrepay
 	}
 
-	return nil
+	return ReasonNone
 }
 
 // satPerKwToSatPerVByte converts sat per kWeight to sat per vByte.