staticaddr: fractional loop-in amount

Author: hieblmi

interface.go

@@ -338,6 +338,8 @@ 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 btcutil.Amount
 }
 
 // LoopInTerms are the server terms on which it executes loop in swaps.

loopd/swapclient_server.go

@@ -34,8 +34,10 @@ import (
 	"github.com/lightninglabs/loop/swap"
 	"github.com/lightninglabs/loop/swapserverrpc"
 	"github.com/lightninglabs/taproot-assets/rfqmath"
+	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
 	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/queue"
 	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/lightningnetwork/lnd/zpay32"
@@ -843,21 +845,26 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
 	infof("Loop in quote request received")
 
 	var (
-		numDeposits = uint32(len(req.DepositOutpoints))
-		err         error
+		selectedAmount     = btcutil.Amount(req.Amt)
+		totalDepositAmount btcutil.Amount
+		numDeposits        = len(req.DepositOutpoints)
+		err                error
 	)
 
 	htlcConfTarget, err := validateLoopInRequest(
-		req.ConfTarget, req.ExternalHtlc, numDeposits, req.Amt,
+		req.ConfTarget, req.ExternalHtlc, uint32(numDeposits),
+		int64(selectedAmount),
 	)
 	if err != nil {
 		return nil, err
 	}
 
 	// Retrieve deposits to calculate their total value.
 	var depositList *looprpc.ListStaticAddressDepositsResponse
-	amount := btcutil.Amount(req.Amt)
-	if len(req.DepositOutpoints) > 0 {
+
+	// If deposits are selected, we need to retrieve them to calculate the
+	// total value which we request a quote for.
+	if numDeposits > 0 {
 		depositList, err = s.ListStaticAddressDeposits(
 			ctx, &looprpc.ListStaticAddressDepositsRequest{
 				Outpoints: req.DepositOutpoints,
@@ -872,20 +879,34 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
 				"deposit outpoints")
 		}
 
-		// The requested amount should be 0 here if the request
-		// contained deposit outpoints.
-		if amount != 0 && len(depositList.FilteredDeposits) > 0 {
-			return nil, fmt.Errorf("amount should be 0 for " +
-				"deposit quotes")
+		if numDeposits != len(depositList.FilteredDeposits) {
+			return nil, fmt.Errorf("expected %d deposits, got %d",
+				numDeposits, len(depositList.FilteredDeposits))
 		}
 
 		// In case we quote for deposits we send the server both the
-		// total value and the number of deposits. This is so the server
-		// can probe the total amount and calculate the per input fee.
-		if amount == 0 && len(depositList.FilteredDeposits) > 0 {
-			for _, deposit := range depositList.FilteredDeposits {
-				amount += btcutil.Amount(deposit.Value)
-			}
+		// selected value and the number of deposits. This is so the
+		// server can probe the selected value and calculate the per
+		// input fee.
+		for _, deposit := range depositList.FilteredDeposits {
+			totalDepositAmount += btcutil.Amount(
+				deposit.Value,
+			)
+		}
+
+		// If the selected amount would leave a dust change output or
+		// exceeds the total deposits value, we return an error.
+		dustLimit := lnwallet.DustLimitForSize(input.P2TRSize)
+		if totalDepositAmount-selectedAmount < dustLimit {
+			return nil, fmt.Errorf("selected amount %v leaves "+
+				"dust or exceeds total deposit value %v",
+				selectedAmount, totalDepositAmount)
+		}
+
+		// If the client didn't select an amount we quote for the total
+		// deposits value.
+		if selectedAmount == 0 {
+			selectedAmount = totalDepositAmount
 		}
 	}
 
@@ -912,14 +933,14 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
 	}
 
 	quote, err := s.impl.LoopInQuote(ctx, &loop.LoopInQuoteRequest{
-		Amount:         amount,
+		Amount:         selectedAmount,
 		HtlcConfTarget: htlcConfTarget,
 		ExternalHtlc:   req.ExternalHtlc,
 		LastHop:        lastHop,
 		RouteHints:     routeHints,
 		Private:        req.Private,
 		Initiator:      defaultLoopdInitiator,
-		NumDeposits:    numDeposits,
+		NumDeposits:    uint32(numDeposits),
 	})
 	if err != nil {
 		return nil, err
@@ -1762,6 +1783,7 @@ func (s *swapClientServer) StaticAddressLoopIn(ctx context.Context,
 	}
 
 	req := &loop.StaticAddressLoopInRequest{
+		SelectedAmount:        btcutil.Amount(in.Amount),
 		DepositOutpoints:      in.Outpoints,
 		MaxSwapFee:            btcutil.Amount(in.MaxSwapFeeSatoshis),
 		Label:                 in.Label,

staticaddr/loopin/actions.go

@@ -68,9 +68,14 @@ 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()
+	if f.loopIn.SelectedAmount > 0 {
+		swapAmount = f.loopIn.SelectedAmount
+	}
+	swapInvoiceAmt := swapAmount - f.loopIn.QuotedSwapFee
 
 	// Generate random preimage.
 	var swapPreimage lntypes.Preimage
@@ -120,6 +125,7 @@ func (f *FSM) InitHtlcAction(ctx context.Context,
 	loopInReq := &looprpc.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,7 +210,7 @@ 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)
 

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
 
@@ -287,10 +293,20 @@ func (l *StaticAddressLoopIn) createHtlcTx(chainParams *chaincfg.Params,
 	weight := l.htlcWeight()
 	fee := feeRate.FeeForWeight(weight)
 
-	// Check if the server breaches our fee limits.
-	amt := float64(l.TotalDepositAmount())
-	feeLimit := btcutil.Amount(amt * maxFeePercentage)
+	// 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
+	}
 
+	// Check if the server breaches our fee limits.
+	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 +324,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
 }
 
@@ -373,11 +397,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(),