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.

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

staticaddr/loopin/loopin.go

@@ -1,6 +1,7 @@
 package loopin
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -93,6 +94,8 @@ type StaticAddressLoopIn struct {
 	// swap.
 	DepositOutpoints []string
 
+	SelectedAmount btcutil.Amount
+
 	// state is the current state of the swap.
 	state fsm.StateType
 
@@ -287,10 +290,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      = float64(l.TotalDepositAmount())
+		changeAmount btcutil.Amount
+	)
+	if l.SelectedAmount > 0 {
+		swapAmt = float64(l.SelectedAmount)
+		changeAmount = l.TotalDepositAmount() - l.SelectedAmount
+	}
 
+	// Check if the server breaches our fee limits.
+	feeLimit := btcutil.Amount(swapAmt * maxFeePercentage)
 	if fee > feeLimit {
 		return nil, fmt.Errorf("htlc tx fee %v exceeds max fee %v",
 			fee, feeLimit)
@@ -314,6 +327,14 @@ func (l *StaticAddressLoopIn) createHtlcTx(chainParams *chaincfg.Params,
 
 	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 +394,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(),

staticaddr/loopin/manager.go

@@ -4,10 +4,12 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"sort"
 	"sync/atomic"
 	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2/schnorr/musig2"
+	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/psbt"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
@@ -20,7 +22,9 @@ import (
 	"github.com/lightninglabs/loop/staticaddr/deposit"
 	"github.com/lightninglabs/loop/swapserverrpc"
 	looprpc "github.com/lightninglabs/loop/swapserverrpc"
+	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/routing/route"
 )
 
@@ -205,8 +209,8 @@ func (m *Manager) Run(ctx context.Context, currentHeight uint32) error {
 			case request.respChan <- resp:
 
 			case <-ctx.Done():
-				// Noify subroutines that the main loop has been
-				// canceled.
+				// Notify subroutines that the main loop has
+				// been canceled.
 				close(m.exitChan)
 
 				return ctx.Err()
@@ -530,14 +534,30 @@ func (m *Manager) initiateLoopIn(ctx context.Context,
 	req *loop.StaticAddressLoopInRequest) (*StaticAddressLoopIn, error) {
 
 	// Validate the loop-in request.
+	if len(req.DepositOutpoints) == 0 && req.SelectedAmount == 0 {
+		return nil, fmt.Errorf("no deposit outpoints provided and no " +
+			"amount selected")
+	}
+
+	var (
+		err               error
+		selectedOutpoints = req.DepositOutpoints
+	)
+	// If there's only an amount selected by the user, we need to find
+	// deposits that cover this amount.
 	if len(req.DepositOutpoints) == 0 {
-		return nil, fmt.Errorf("no deposit outpoints provided")
+		selectedOutpoints, err = m.selectDeposits(
+			ctx, req.SelectedAmount,
+		)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	// Retrieve all deposits referenced by the outpoints and ensure that
 	// they are in state Deposited.
 	deposits, active := m.cfg.DepositManager.AllStringOutpointsActiveDeposits( //nolint:lll
-		req.DepositOutpoints, deposit.Deposited,
+		selectedOutpoints, deposit.Deposited,
 	)
 	if !active {
 		return nil, fmt.Errorf("one or more deposits are not in "+
@@ -550,8 +570,17 @@ func (m *Manager) initiateLoopIn(ctx context.Context,
 	}
 	totalDepositAmount := tmp.TotalDepositAmount()
 
+	// 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-req.SelectedAmount < dustLimit {
+		return nil, fmt.Errorf("selected amount %v leaves "+
+			"dust or exceeds total deposit value %v",
+			req.SelectedAmount, totalDepositAmount)
+	}
+
 	// Check that the label is valid.
-	err := labels.Validate(req.Label)
+	err = labels.Validate(req.Label)
 	if err != nil {
 		return nil, fmt.Errorf("invalid label: %w", err)
 	}
@@ -617,6 +646,7 @@ func (m *Manager) initiateLoopIn(ctx context.Context,
 	}
 
 	swap := &StaticAddressLoopIn{
+		SelectedAmount:        req.SelectedAmount,
 		DepositOutpoints:      req.DepositOutpoints,
 		Deposits:              deposits,
 		Label:                 req.Label,
@@ -636,6 +666,52 @@ func (m *Manager) initiateLoopIn(ctx context.Context,
 	return m.startLoopInFsm(ctx, swap)
 }
 
+// selectDeposits finds a set of deposits that are ready to be used for a
+// loop-in and cover a given amount. It returns the outpoints of the selected
+// deposits.
+func (m *Manager) selectDeposits(ctx context.Context,
+	amount btcutil.Amount) ([]string, error) {
+
+	// TODO(hieblmi): provide sql query to get all deposits in given state.
+	allDeposits, err := m.cfg.DepositManager.GetAllDeposits(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	deposits := make([]*deposit.Deposit, 0)
+	for _, d := range allDeposits {
+		if d.IsInState(deposit.Deposited) {
+			deposits = append(deposits, d)
+		}
+	}
+
+	// Sort deposits by confirmation block in descending order first to pick
+	// the oldest deposits, then sort by deposit amount in descending order.
+	sort.Slice(deposits, func(i, j int) bool {
+		if deposits[i].ConfirmationHeight !=
+			deposits[j].ConfirmationHeight {
+
+			return deposits[i].ConfirmationHeight >
+				deposits[j].ConfirmationHeight
+		}
+
+		return deposits[i].Value > deposits[j].Value
+	})
+
+	// Now select deposits from the front of the sorted slice until the sum
+	// satisfies the required amount.
+	selectedDeposits := make([]string, 0)
+	for _, d := range deposits {
+		amount -= d.Value
+		selectedDeposits = append(selectedDeposits, d.OutPoint.String())
+		if amount <= 0 {
+			return selectedDeposits, nil
+		}
+	}
+
+	return nil, fmt.Errorf("not enough deposits to cover amount")
+}
+
 // startLoopInFsm initiates a loop-in state machine based on the user-provided
 // swap information, sends that info to the server and waits for the server to
 // return htlc signature information. It then creates the loop-in object in the

staticaddr/loopin/sql_store.go

@@ -230,6 +230,7 @@ func (s *SqlStore) CreateLoopIn(ctx context.Context,
 		HtlcTimeoutSweepAddress: loopIn.HtlcTimeoutSweepAddress.String(),
 		HtlcTxFeeRateSatKw:      int64(loopIn.HtlcTxFeeRate),
 		DepositOutpoints:        joinedOutpoints,
+		SelectedAmount:          int64(loopIn.SelectedAmount),
 		PaymentTimeoutSeconds:   int32(loopIn.PaymentTimeoutSeconds),
 	}
 
@@ -378,6 +379,7 @@ func toStaticAddressLoopIn(_ context.Context, network *chaincfg.Params,
 		LastHop:               row.LastHop,
 		QuotedSwapFee:         btcutil.Amount(row.QuotedSwapFeeSatoshis),
 		DepositOutpoints:      depositOutpoints,
+		SelectedAmount:        btcutil.Amount(row.SelectedAmount),
 		HtlcTxFeeRate: chainfee.SatPerKWeight(
 			row.HtlcTxFeeRateSatKw,
 		),