staticaddr: support dynamic deposit confirmation requirements

- Reduce MinConfs from 6 to 1 to allow faster swap attempts for small
  amounts while the server enforces risk-based confirmation requirements
- Update SelectDeposits to prioritize more-confirmed deposits first,
  increasing the likelihood of server acceptance
- Add client-side logging of insufficient confirmation details from
  server errors, helping users understand when deposits need more
  confirmations

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: hieblmi

staticaddr/deposit/manager.go

@@ -22,8 +22,10 @@ import (
 const (
 	// MinConfs is the minimum number of confirmations we require for a
 	// deposit to be considered available for loop-ins, coop-spends and
-	// timeouts.
-	MinConfs = 6
+	// timeouts. The server enforces dynamic confirmation requirements
+	// based on risk assessment, so the client uses 1 conf as the minimum
+	// to enable faster swap attempts for small amounts.
+	MinConfs = 1
 
 	// MaxConfs is unset since we don't require a max number of
 	// confirmations for deposits.

staticaddr/loopin/actions.go

@@ -30,6 +30,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"google.golang.org/grpc/status"
 )
 
 const (
@@ -146,6 +147,10 @@ func (f *FSM) InitHtlcAction(ctx context.Context,
 		ctx, loopInReq,
 	)
 	if err != nil {
+		// Check if this is an insufficient confirmations error and log
+		// the details to help the user understand what's needed.
+		logInsufficientConfirmationsDetails(err)
+
 		err = fmt.Errorf("unable to initiate the loop-in with the "+
 			"server: %w", err)
 
@@ -910,3 +915,29 @@ func byteSliceTo66ByteSlice(b []byte) ([musig2.PubNonceSize]byte, error) {
 
 	return res, nil
 }
+
+// logInsufficientConfirmationsDetails extracts and logs the per-deposit
+// confirmation details from a gRPC error if present.
+func logInsufficientConfirmationsDetails(err error) {
+	st, ok := status.FromError(err)
+	if !ok {
+		return
+	}
+
+	for _, detail := range st.Details() {
+		confDetails, ok := detail.(*swapserverrpc.InsufficientConfirmationsDetails)
+		if !ok {
+			continue
+		}
+
+		log.Warnf("Insufficient deposit confirmations, max wait: "+
+			"%d blocks", confDetails.MaxBlocksToWait)
+
+		for _, dep := range confDetails.Deposits {
+			log.Warnf("  Deposit %s: %d/%d confirmations "+
+				"(need %d more blocks)",
+				dep.Outpoint, dep.CurrentConfirmations,
+				dep.RequiredConfirmations, dep.BlocksToWait)
+		}
+	}
+}

staticaddr/loopin/manager.go

@@ -888,18 +888,31 @@ func SelectDeposits(targetAmount btcutil.Amount,
 		deposits = append(deposits, d)
 	}
 
-	// Sort the deposits by amount in descending order, then by
-	// blocks-until-expiry in ascending order.
+	// Sort deposits to optimize for successful swaps with dynamic
+	// confirmation requirements:
+	// 1. More confirmations first (higher chance of server acceptance)
+	// 2. Larger amounts first (to minimize number of deposits used)
+	// 3. Expiring sooner first (to use time-sensitive deposits)
 	sort.Slice(deposits, func(i, j int) bool {
-		if deposits[i].Value == deposits[j].Value {
-			iExp := uint32(deposits[i].ConfirmationHeight) +
-				csvExpiry - blockHeight
-			jExp := uint32(deposits[j].ConfirmationHeight) +
-				csvExpiry - blockHeight
+		// Primary: more confirmations first.
+		iConfs := blockHeight - uint32(deposits[i].ConfirmationHeight)
+		jConfs := blockHeight - uint32(deposits[j].ConfirmationHeight)
+		if iConfs != jConfs {
+			return iConfs > jConfs
+		}
 
-			return iExp < jExp
+		// Secondary: larger amounts first.
+		if deposits[i].Value != deposits[j].Value {
+			return deposits[i].Value > deposits[j].Value
 		}
-		return deposits[i].Value > deposits[j].Value
+
+		// Tertiary: expiring sooner first.
+		iExp := uint32(deposits[i].ConfirmationHeight) +
+			csvExpiry - blockHeight
+		jExp := uint32(deposits[j].ConfirmationHeight) +
+			csvExpiry - blockHeight
+
+		return iExp < jExp
 	})
 
 	// Select the deposits that are needed to cover the swap amount without

staticaddr/loopin/manager_test.go

@@ -26,10 +26,14 @@ type testCase struct {
 
 // TestSelectDeposits tests the selectDeposits function, which selects
 // deposits that can cover a target value while respecting the dust limit.
+// Sorting priority: 1) more confirmations first, 2) larger amounts first,
+// 3) expiring sooner first.
 func TestSelectDeposits(t *testing.T) {
+	// Note: confirmations = blockHeight - ConfirmationHeight
+	// Lower ConfirmationHeight means more confirmations at a given block.
 	d1, d2, d3, d4 := &deposit.Deposit{
 		Value:              1_000_000,
-		ConfirmationHeight: 5_000,
+		ConfirmationHeight: 5_000, // most confs at height 5100
 	}, &deposit.Deposit{
 		Value:              2_000_000,
 		ConfirmationHeight: 5_001,
@@ -38,7 +42,7 @@ func TestSelectDeposits(t *testing.T) {
 		ConfirmationHeight: 5_002,
 	}, &deposit.Deposit{
 		Value:              3_000_000,
-		ConfirmationHeight: 5_003,
+		ConfirmationHeight: 5_003, // fewest confs at height 5100
 	}
 	d1.Hash = chainhash.Hash{1}
 	d1.Index = 0
@@ -58,17 +62,20 @@ func TestSelectDeposits(t *testing.T) {
 			expectedErr: "",
 		},
 		{
-			name:        "prefer larger deposit when both cover",
+			// d1 has more confirmations, so it's preferred even
+			// though d2 is larger.
+			name:        "prefer more confirmed deposit over larger",
 			deposits:    []*deposit.Deposit{d1, d2},
 			targetValue: 1_000_000,
-			expected:    []*deposit.Deposit{d2},
+			expected:    []*deposit.Deposit{d1},
 			expectedErr: "",
 		},
 		{
-			name:        "prefer largest among three when one is enough",
+			// d1 has the most confirmations among d1, d2, d3.
+			name:        "prefer most confirmed among three",
 			deposits:    []*deposit.Deposit{d1, d2, d3},
 			targetValue: 1_000_000,
-			expected:    []*deposit.Deposit{d3},
+			expected:    []*deposit.Deposit{d1},
 			expectedErr: "",
 		},
 		{