staticaddr: arbitrary loop-in amount

In this commit we add a new function SelectDeposits
to the loop-in manager. It coin-selects deposits that
meet an arbitrary swap amount provided by the client.
We have to ensure that the server creates the correct
change outputs for the htlc- and sweepless sweep
transactions.

Author: hieblmi

interface.go

@@ -338,6 +338,11 @@ type StaticAddressLoopInRequest struct {
 	// swap payment. If the timeout is reached the swap will be aborted and
 	// the client can retry the swap if desired with different parameters.
 	PaymentTimeoutSeconds uint32
+
+	// SelectedAmount is the amount that the user selected for the swap. If
+	// the user did not select an amount, the amount of the selected
+	// deposits is used.
+	SelectedAmount btcutil.Amount
 }
 
 // LoopInTerms are the server terms on which it executes loop in swaps.

staticaddr/loopin/actions.go

@@ -68,9 +68,18 @@ func (f *FSM) InitHtlcAction(ctx context.Context,
 	}
 
 	// Calculate the swap invoice amount. The server needs to pay us the
-	// sum of all deposits minus the fees that the server charges for the
-	// swap.
-	swapInvoiceAmt := f.loopIn.TotalDepositAmount() - f.loopIn.QuotedSwapFee
+	// swap amount minus the fees that the server charges for the swap. The
+	// swap amount is either the total value of the selected deposits, or
+	// the selected amount if a specific amount was requested.
+	swapAmount := f.loopIn.TotalDepositAmount()
+	var hasChange bool
+	if f.loopIn.SelectedAmount > 0 {
+		swapAmount = f.loopIn.SelectedAmount
+		remainingAmount := f.loopIn.TotalDepositAmount() - swapAmount
+		hasChange = remainingAmount > 0 && remainingAmount <
+			f.loopIn.TotalDepositAmount()
+	}
+	swapInvoiceAmt := swapAmount - f.loopIn.QuotedSwapFee
 
 	// Generate random preimage.
 	var swapPreimage lntypes.Preimage
@@ -120,6 +129,7 @@ func (f *FSM) InitHtlcAction(ctx context.Context,
 	loopInReq := &swapserverrpc.ServerStaticAddressLoopInRequest{
 		SwapHash:              f.loopIn.SwapHash[:],
 		DepositOutpoints:      f.loopIn.DepositOutpoints,
+		Amount:                uint64(f.loopIn.SelectedAmount),
 		HtlcClientPubKey:      f.loopIn.ClientPubkey.SerializeCompressed(),
 		SwapInvoice:           f.loopIn.SwapInvoice,
 		ProtocolVersion:       version.CurrentRPCProtocolVersion(),
@@ -204,15 +214,15 @@ func (f *FSM) InitHtlcAction(ctx context.Context,
 	// We need to defend against the server setting high fees for the htlc
 	// tx since we might have to sweep the timeout path. We maximally allow
 	// a configured percentage of the swap value to be spent on fees.
-	amt := float64(f.loopIn.TotalDepositAmount())
+	amt := float64(swapAmount)
 	maxHtlcTxFee := btcutil.Amount(amt *
 		f.cfg.MaxStaticAddrHtlcFeePercentage)
 
 	maxHtlcTxBackupFee := btcutil.Amount(amt *
 		f.cfg.MaxStaticAddrHtlcBackupFeePercentage)
 
 	feeRate := chainfee.SatPerKWeight(loopInResp.StandardHtlcInfo.FeeRate)
-	fee := feeRate.FeeForWeight(f.loopIn.htlcWeight())
+	fee := feeRate.FeeForWeight(f.loopIn.htlcWeight(hasChange))
 	if fee > maxHtlcTxFee {
 		// Abort the swap by pushing empty sigs to the server.
 		pushEmptySigs()
@@ -225,7 +235,7 @@ func (f *FSM) InitHtlcAction(ctx context.Context,
 	f.loopIn.HtlcTxFeeRate = feeRate
 
 	highFeeRate := chainfee.SatPerKWeight(loopInResp.HighFeeHtlcInfo.FeeRate)
-	fee = highFeeRate.FeeForWeight(f.loopIn.htlcWeight())
+	fee = highFeeRate.FeeForWeight(f.loopIn.htlcWeight(hasChange))
 	if fee > maxHtlcTxBackupFee {
 		// Abort the swap by pushing empty sigs to the server.
 		pushEmptySigs()
@@ -241,7 +251,7 @@ func (f *FSM) InitHtlcAction(ctx context.Context,
 	extremelyHighFeeRate := chainfee.SatPerKWeight(
 		loopInResp.ExtremeFeeHtlcInfo.FeeRate,
 	)
-	fee = extremelyHighFeeRate.FeeForWeight(f.loopIn.htlcWeight())
+	fee = extremelyHighFeeRate.FeeForWeight(f.loopIn.htlcWeight(hasChange))
 	if fee > maxHtlcTxBackupFee {
 		// Abort the swap by pushing empty sigs to the server.
 		pushEmptySigs()

staticaddr/loopin/deduce_amount_test.go

@@ -0,0 +1,85 @@
+package loopin
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/lightningnetwork/lnd/input"
+	"github.com/lightningnetwork/lnd/lnwallet"
+	"github.com/stretchr/testify/require"
+)
+
+// TestDeduceSwapAmount covers all validation branches of DeduceSwapAmount.
+func TestDeduceSwapAmount(t *testing.T) {
+	dl := lnwallet.DustLimitForSize(input.P2TRSize)
+
+	tests := []struct {
+		name      string
+		total     btcutil.Amount
+		selectAmt btcutil.Amount
+		wantAmt   btcutil.Amount
+		wantErr   string
+	}{
+		{
+			name:      "negative selected amount",
+			total:     dl * 10,
+			selectAmt: -1,
+			wantErr:   "negative",
+		},
+		{
+			name:      "selected is dust (>0 < dust)",
+			total:     dl * 10,
+			selectAmt: dl - 1,
+			wantErr:   "is dust",
+		},
+		{
+			name:      "total deposit is dust",
+			total:     dl - 1,
+			selectAmt: 0,
+			wantErr:   "total deposit value",
+		},
+		{
+			name:      "selected exceeds total",
+			total:     dl * 5,
+			selectAmt: dl*5 + 1,
+			wantErr:   "exceeds total",
+		},
+		{
+			name:      "leaves dust change",
+			total:     dl*5 + (dl - 1),
+			selectAmt: dl * 5,
+			wantErr:   "leaves dust change",
+		},
+		{
+			name:      "selected zero => swap total",
+			total:     dl * 7,
+			selectAmt: 0,
+			wantAmt:   dl * 7,
+		},
+		{
+			name:      "selected equals total",
+			total:     dl * 9,
+			selectAmt: dl * 9,
+			wantAmt:   dl * 9,
+		},
+		{
+			name:      "selected and remaining both >= dust",
+			total:     dl*10 + dl, // 11*dust
+			selectAmt: dl * 10,    // remaining = dust
+			wantAmt:   dl * 10,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			amt, err := DeduceSwapAmount(tc.total, tc.selectAmt)
+			if tc.wantErr != "" {
+				require.Error(t, err)
+				require.ErrorContains(t, err, tc.wantErr)
+				return
+			}
+			require.NoError(t, err)
+			require.Equal(t, tc.wantAmt, amt)
+		})
+	}
+}

staticaddr/loopin/interface.go

@@ -53,6 +53,11 @@ type DepositManager interface {
 	// outpoints.
 	DepositsForOutpoints(ctx context.Context, outpoints []string) (
 		[]*deposit.Deposit, error)
+
+	// GetActiveDepositsInState returns all active deposits in the given
+	// state.
+	GetActiveDepositsInState(stateFilter fsm.StateType) ([]*deposit.Deposit,
+		error)
 }
 
 // StaticAddressLoopInStore provides access to the static address loop-in DB.

staticaddr/loopin/loopin.go

@@ -1,6 +1,7 @@
 package loopin
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -91,8 +92,15 @@ type StaticAddressLoopIn struct {
 
 	// The outpoints in the format txid:vout that are part of the loop-in
 	// swap.
+	// TODO(hieblmi): Replace this with a getter method that fetches the
+	//      outpoints from the deposits.
 	DepositOutpoints []string
 
+	// SelectedAmount is the amount that the user selected for the swap. If
+	// the user did not select an amount, the amount of all deposits is
+	// used.
+	SelectedAmount btcutil.Amount
+
 	// state is the current state of the swap.
 	state fsm.StateType
 
@@ -283,14 +291,25 @@ func (l *StaticAddressLoopIn) createHtlcTx(chainParams *chaincfg.Params,
 		})
 	}
 
+	// Determine the swap amount. If the user selected a specific amount, we
+	// use that and use the difference to the total deposit amount as the
+	// change.
+	var (
+		swapAmt      = l.TotalDepositAmount()
+		changeAmount btcutil.Amount
+	)
+	if l.SelectedAmount > 0 {
+		swapAmt = l.SelectedAmount
+		changeAmount = l.TotalDepositAmount() - l.SelectedAmount
+	}
+
 	// Calculate htlc tx fee for server provided fee rate.
-	weight := l.htlcWeight()
+	hasChange := changeAmount > 0
+	weight := l.htlcWeight(hasChange)
 	fee := feeRate.FeeForWeight(weight)
 
 	// Check if the server breaches our fee limits.
-	amt := float64(l.TotalDepositAmount())
-	feeLimit := btcutil.Amount(amt * maxFeePercentage)
-
+	feeLimit := btcutil.Amount(float64(swapAmt) * maxFeePercentage)
 	if fee > feeLimit {
 		return nil, fmt.Errorf("htlc tx fee %v exceeds max fee %v",
 			fee, feeLimit)
@@ -308,12 +327,20 @@ func (l *StaticAddressLoopIn) createHtlcTx(chainParams *chaincfg.Params,
 
 	// Create the sweep output
 	sweepOutput := &wire.TxOut{
-		Value:    int64(l.TotalDepositAmount()) - int64(fee),
+		Value:    int64(swapAmt - fee),
 		PkScript: pkscript,
 	}
 
 	msgTx.AddTxOut(sweepOutput)
 
+	// We expect change to be sent back to our static address output script.
+	if changeAmount > 0 {
+		msgTx.AddTxOut(&wire.TxOut{
+			Value:    int64(changeAmount),
+			PkScript: l.AddressParams.PkScript,
+		})
+	}
+
 	return msgTx, nil
 }
 
@@ -325,7 +352,7 @@ func (l *StaticAddressLoopIn) isHtlcTimedOut(height int32) bool {
 }
 
 // htlcWeight returns the weight for the htlc transaction.
-func (l *StaticAddressLoopIn) htlcWeight() lntypes.WeightUnit {
+func (l *StaticAddressLoopIn) htlcWeight(hasChange bool) lntypes.WeightUnit {
 	var weightEstimator input.TxWeightEstimator
 	for i := 0; i < len(l.Deposits); i++ {
 		weightEstimator.AddTaprootKeySpendInput(
@@ -335,6 +362,10 @@ func (l *StaticAddressLoopIn) htlcWeight() lntypes.WeightUnit {
 
 	weightEstimator.AddP2WSHOutput()
 
+	if hasChange {
+		weightEstimator.AddP2TROutput()
+	}
+
 	return weightEstimator.Weight()
 }
 
@@ -373,11 +404,25 @@ func (l *StaticAddressLoopIn) createHtlcSweepTx(ctx context.Context,
 		return nil, err
 	}
 
+	// Check if the htlc tx has a change output. If so we need to select the
+	// non-change output index to construct the sweep with.
+	htlcInputIndex := uint32(0)
+	if len(htlcTx.TxOut) == 2 {
+		// If the first htlc tx output matches our static address
+		// script we need to select the second output to sweep from.
+		if bytes.Equal(
+			htlcTx.TxOut[0].PkScript, l.AddressParams.PkScript,
+		) {
+
+			htlcInputIndex = 1
+		}
+	}
+
 	// Add the htlc input.
 	sweepTx.AddTxIn(&wire.TxIn{
 		PreviousOutPoint: wire.OutPoint{
 			Hash:  htlcTx.TxHash(),
-			Index: 0,
+			Index: htlcInputIndex,
 		},
 		SignatureScript: htlc.SigScript,
 		Sequence:        htlc.SuccessSequence(),