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/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"
@@ -93,6 +94,11 @@ type StaticAddressLoopIn struct {
 	// swap.
 	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 +289,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 +325,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 +350,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 +360,10 @@ func (l *StaticAddressLoopIn) htlcWeight() lntypes.WeightUnit {
 
 	weightEstimator.AddP2WSHOutput()
 
+	if hasChange {
+		weightEstimator.AddP2TROutput()
+	}
+
 	return weightEstimator.Weight()
 }
 
@@ -373,11 +402,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(),