multi: add flat fee percentage to autoloop

Author: carlaKC

liquidity/fees.go

@@ -37,6 +37,11 @@ const (
 	// defaultSweepFeeRateLimit is the default limit we place on estimated
 	// sweep fees, (750 * 4 /1000 = 3 sat/vByte).
 	defaultSweepFeeRateLimit = chainfee.SatPerKWeight(750)
+
+	// minerMultiplier is a multiplier we use to scale our miner fee to
+	// ensure that we will still be able to complete our swap in the case
+	// of a severe fee spike.
+	minerMultiplier = 100
 )
 
 var (
@@ -55,6 +60,10 @@ var (
 	// ErrZeroPrepay is returned if a zero maximum prepay is set.
 	ErrZeroPrepay = errors.New("maximum prepay must be non-zero")
 
+	// ErrInvalidPPM is returned is the parts per million for a fee rate
+	// are invalid.
+	ErrInvalidPPM = errors.New("invalid ppm")
+
 	// ErrInvalidSweepFeeRateLimit is returned if an invalid sweep fee limit
 	// is set.
 	ErrInvalidSweepFeeRateLimit = fmt.Errorf("sweep fee rate limit must "+
@@ -224,3 +233,144 @@ func (f *FeeCategoryLimit) loopOutFees(amount btcutil.Amount,
 
 	return prepayMaxFee, routeMaxFee, f.MaximumMinerFee
 }
+
+// Compile time assertion that FeePortion implements FeeLimit interface.
+var _ FeeLimit = (*FeePortion)(nil)
+
+// FeePortion is a fee limitation which limits fees to a set portion of
+// the swap amount.
+type FeePortion struct {
+	// PartsPerMillion is the total portion of the swap amount that the
+	// swap may consume.
+	PartsPerMillion uint64
+}
+
+// NewFeePortion creates a fee limit based on a flat percentage of swap amount.
+func NewFeePortion(ppm uint64) *FeePortion {
+	return &FeePortion{
+		PartsPerMillion: ppm,
+	}
+}
+
+// String returns a string representation of the fee limit.
+func (f *FeePortion) String() string {
+	return fmt.Sprintf("parts per million: %v", f.PartsPerMillion)
+}
+
+// validate returns an error if the values provided are invalid.
+func (f *FeePortion) validate() error {
+	if f.PartsPerMillion <= 0 {
+		return ErrInvalidPPM
+	}
+
+	return nil
+}
+
+// mayLoopOut checks our estimated loop out sweep fee against our sweep limit.
+// For fee percentage, we do not check anything because we need the full quote
+// to determine whether we can perform a swap.
+func (f *FeePortion) mayLoopOut(_ chainfee.SatPerKWeight) error {
+	return nil
+}
+
+// loopOutLimits checks whether the quote provided is within our fee
+// limits for the swap amount.
+func (f *FeePortion) loopOutLimits(swapAmt btcutil.Amount,
+	quote *loop.LoopOutQuote) error {
+
+	// First, check whether any of the individual fee categories provided
+	// by the server are more than our total limit. We do this so that we
+	// can provide more specific reasons for not executing swaps.
+	feeLimit := ppmToSat(swapAmt, f.PartsPerMillion)
+	minerFee := scaleMinerFee(quote.MinerFee)
+
+	if minerFee > feeLimit {
+		log.Debugf("miner fee: %v greater than fee limit: %v, at "+
+			"%v ppm", minerFee, feeLimit, f.PartsPerMillion)
+
+		return newReasonError(ReasonMinerFee)
+	}
+
+	if quote.SwapFee > feeLimit {
+		log.Debugf("swap fee: %v greater than fee limit: %v, at "+
+			"%v ppm", quote.SwapFee, feeLimit, f.PartsPerMillion)
+
+		return newReasonError(ReasonSwapFee)
+	}
+
+	if quote.PrepayAmount > feeLimit {
+		log.Debugf("prepay amount: %v greater than fee limit: %v, at "+
+			"%v ppm", quote.PrepayAmount, feeLimit, f.PartsPerMillion)
+
+		return newReasonError(ReasonPrepay)
+	}
+
+	// If our miner and swap fee equal our limit, we will have nothing left
+	// for off-chain fees, so we fail out early.
+	if minerFee+quote.SwapFee >= feeLimit {
+		log.Debugf("no budget for off-chain routing with miner fee: "+
+			"%v, swap fee: %v and fee limit: %v, at %v ppm",
+			minerFee, quote.SwapFee, feeLimit, f.PartsPerMillion)
+
+		return newReasonError(ReasonFeePPMInsufficient)
+	}
+
+	prepay, route, miner := f.loopOutFees(swapAmt, quote)
+
+	// Calculate the worst case fees that we could pay for this swap,
+	// ensuring that we are within our fee limit even if the swap fails.
+	fees := worstCaseOutFees(
+		prepay, route, quote.SwapFee, miner, quote.PrepayAmount,
+	)
+
+	if fees > feeLimit {
+		log.Debugf("total fees for swap: %v > fee limit: %v, at "+
+			"%v ppm", fees, feeLimit, f.PartsPerMillion)
+
+		return newReasonError(ReasonFeePPMInsufficient)
+	}
+
+	return nil
+}
+
+// loopOutFees return the maximum prepay and invoice routing fees for a swap
+// amount and quote. Note that the fee portion implementation just returns
+// the quote's miner fee, assuming that this value has already been validated.
+// We also assume that the quote's minerfee + swapfee < fee limit, so that we
+// have some fees left for off-chain routing.
+func (f *FeePortion) loopOutFees(amount btcutil.Amount,
+	quote *loop.LoopOutQuote) (btcutil.Amount, btcutil.Amount,
+	btcutil.Amount) {
+
+	// Calculate the total amount we can spend in fees, and subtract the
+	// amounts provided by the quote to get the total available for
+	// off-chain fees.
+	feeLimit := ppmToSat(amount, f.PartsPerMillion)
+	minerFee := scaleMinerFee(quote.MinerFee)
+
+	available := feeLimit - minerFee - quote.SwapFee
+
+	prepayMaxFee, routeMaxFee := splitOffChain(
+		available, quote.PrepayAmount, amount,
+	)
+
+	return prepayMaxFee, routeMaxFee, minerFee
+}
+
+// splitOffChain takes an available fee budget and divides it among our prepay
+// and swap payments proportional to their volume.
+func splitOffChain(available, prepayAmt,
+	swapAmt btcutil.Amount) (btcutil.Amount, btcutil.Amount) {
+
+	total := swapAmt + prepayAmt
+
+	prepayMaxFee := available * prepayAmt / total
+	routeMaxFee := available * swapAmt / total
+
+	return prepayMaxFee, routeMaxFee
+}
+
+// scaleMinerFee scales our miner fee by our constant multiplier.
+func scaleMinerFee(estimate btcutil.Amount) btcutil.Amount {
+	return estimate * btcutil.Amount(minerMultiplier)
+}

liquidity/liquidity_test.go

@@ -151,6 +151,19 @@ func newTestConfig() (*Config, *test.LndMockServices) {
 	}, lnd
 }
 
+// testPPMFees calculates the split of fees between prepay and swap invoice
+// for the swap amount and ppm, relying on the test quote.
+func testPPMFees(ppm uint64, quote *loop.LoopOutQuote,
+	swapAmount btcutil.Amount) (btcutil.Amount, btcutil.Amount) {
+
+	feeTotal := ppmToSat(swapAmount, ppm)
+	feeAvailable := feeTotal - scaleMinerFee(quote.MinerFee) - quote.SwapFee
+
+	return splitOffChain(
+		feeAvailable, quote.PrepayAmount, swapAmount,
+	)
+}
+
 // TestParameters tests getting and setting of parameters for our manager.
 func TestParameters(t *testing.T) {
 	cfg, _ := newTestConfig()
@@ -1269,6 +1282,147 @@ func TestSizeRestrictions(t *testing.T) {
 	}
 }
 
+// TestFeePercentage tests use of a flat fee percentage to limit the fees we
+// pay for swaps. Our test is setup to require a 7500 sat swap, and we test
+// this amount against various fee percentages and server quotes.
+func TestFeePercentage(t *testing.T) {
+	var (
+		okPPM   uint64 = 30000
+		okQuote        = &loop.LoopOutQuote{
+			SwapFee:      15,
+			PrepayAmount: 30,
+			MinerFee:     1,
+		}
+
+		rec = loop.OutRequest{
+			Amount:          7500,
+			OutgoingChanSet: loopdb.ChannelSet{chanID1.ToUint64()},
+			MaxMinerFee:     scaleMinerFee(okQuote.MinerFee),
+			MaxSwapFee:      okQuote.SwapFee,
+			MaxPrepayAmount: okQuote.PrepayAmount,
+			SweepConfTarget: loop.DefaultSweepConfTarget,
+			Initiator:       autoloopSwapInitiator,
+		}
+	)
+
+	rec.MaxPrepayRoutingFee, rec.MaxSwapRoutingFee = testPPMFees(
+		okPPM, okQuote, 7500,
+	)
+
+	tests := []struct {
+		name        string
+		feePPM      uint64
+		quote       *loop.LoopOutQuote
+		suggestions *Suggestions
+	}{
+		{
+			// With our limit set to 3% of swap amount 7500, we
+			// have a total budget of 225 sat.
+			name:   "fees ok",
+			feePPM: okPPM,
+			quote:  okQuote,
+			suggestions: &Suggestions{
+				OutSwaps: []loop.OutRequest{
+					rec,
+				},
+				DisqualifiedChans: noneDisqualified,
+				DisqualifiedPeers: noPeersDisqualified,
+			},
+		},
+		{
+			name:   "swap fee too high",
+			feePPM: 20000,
+			quote: &loop.LoopOutQuote{
+				SwapFee:      300,
+				PrepayAmount: 30,
+				MinerFee:     1,
+			},
+			suggestions: &Suggestions{
+				DisqualifiedChans: map[lnwire.ShortChannelID]Reason{
+					chanID1: ReasonSwapFee,
+				},
+				DisqualifiedPeers: noPeersDisqualified,
+			},
+		},
+		{
+			name:   "miner fee too high",
+			feePPM: 20000,
+			quote: &loop.LoopOutQuote{
+				SwapFee:      80,
+				PrepayAmount: 30,
+				MinerFee:     300,
+			},
+			suggestions: &Suggestions{
+				DisqualifiedChans: map[lnwire.ShortChannelID]Reason{
+					chanID1: ReasonMinerFee,
+				},
+				DisqualifiedPeers: noPeersDisqualified,
+			},
+		},
+		{
+			name:   "miner and swap too high",
+			feePPM: 20000,
+			quote: &loop.LoopOutQuote{
+				SwapFee:      60,
+				PrepayAmount: 30,
+				MinerFee:     1,
+			},
+			suggestions: &Suggestions{
+				DisqualifiedChans: map[lnwire.ShortChannelID]Reason{
+					chanID1: ReasonFeePPMInsufficient,
+				},
+				DisqualifiedPeers: noPeersDisqualified,
+			},
+		},
+		{
+			name:   "prepay too high",
+			feePPM: 30000,
+			quote: &loop.LoopOutQuote{
+				SwapFee:      75,
+				PrepayAmount: 300,
+				MinerFee:     1,
+			},
+			suggestions: &Suggestions{
+				DisqualifiedChans: map[lnwire.ShortChannelID]Reason{
+					chanID1: ReasonPrepay,
+				},
+				DisqualifiedPeers: noPeersDisqualified,
+			},
+		},
+	}
+
+	for _, testCase := range tests {
+		testCase := testCase
+
+		t.Run(testCase.name, func(t *testing.T) {
+			cfg, lnd := newTestConfig()
+
+			cfg.LoopOutQuote = func(_ context.Context,
+				_ *loop.LoopOutQuoteRequest) (*loop.LoopOutQuote,
+				error) {
+
+				return testCase.quote, nil
+
+			}
+
+			lnd.Channels = []lndclient.ChannelInfo{
+				channel1,
+			}
+
+			params := defaultParameters
+			params.FeeLimit = NewFeePortion(testCase.feePPM)
+			params.ChannelRules = map[lnwire.ShortChannelID]*ThresholdRule{
+				chanID1: chanRule,
+			}
+
+			testSuggestSwaps(
+				t, newSuggestSwapsSetup(cfg, lnd, params),
+				testCase.suggestions, nil,
+			)
+		})
+	}
+}
+
 // testSuggestSwapsSetup contains the elements that are used to create a
 // suggest swaps test.
 type testSuggestSwapsSetup struct {

liquidity/reasons.go

@@ -61,6 +61,10 @@ const (
 	// from budget elapsed, because we still have some budget available,
 	// but we have allocated it to other swaps.
 	ReasonBudgetInsufficient
+
+	// ReasonFeePPMInsufficient indicates that the fees a swap would require
+	// are greater than the portion of swap amount allocated to fees.
+	ReasonFeePPMInsufficient
 )
 
 // String returns a string representation of a reason.
@@ -105,6 +109,9 @@ func (r Reason) String() string {
 	case ReasonBudgetInsufficient:
 		return "budget insufficient"
 
+	case ReasonFeePPMInsufficient:
+		return "fee portion insufficient"
+
 	default:
 		return "unknown"
 	}

loopd/swapclient_server.go

@@ -859,6 +859,9 @@ func rpcAutoloopReason(reason liquidity.Reason) (looprpc.AutoReason, error) {
 	case liquidity.ReasonBudgetInsufficient:
 		return looprpc.AutoReason_AUTO_REASON_BUDGET_INSUFFICIENT, nil
 
+	case liquidity.ReasonFeePPMInsufficient:
+		return looprpc.AutoReason_AUTO_REASON_SWAP_FEE, nil
+
 	default:
 		return 0, fmt.Errorf("unknown autoloop reason: %v", reason)
 	}