staticaddr: use dp autoloop selector

Replace the recursive full-deposit autoloop selector with a bounded-memory
DP implementation in staticaddr/loopin/autoloop_dp.go. The new selector
keeps the existing no-change semantics, first finds the best reachable
total, then applies the 25 percent band rule so earlier-expiring deposits
can win inside that near-optimal range.

The DP table is capped at 128 MiB and keeps exact satoshi sums alongside
compressed bucket weights, so planning stays memory-bounded without
allowing oversized candidates. The compressed weighting now rounds down
with a minimum of one bucket, which avoids rejecting valid sums after
multiple per-deposit rounding steps while leaving the exact-sum check
as the real safety boundary.

Author: starius

staticaddr/loopin/autoloop.go

@@ -3,8 +3,6 @@ package loopin
 import (
 	"context"
 	"errors"
-	"slices"
-	"sort"
 
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/lightninglabs/loop"
@@ -91,164 +89,8 @@ func selectNoChangeDeposits(maxAmount, minAmount btcutil.Amount,
 	unfilteredDeposits []*deposit.Deposit, csvExpiry, blockHeight uint32,
 	excludedOutpoints map[string]struct{}) ([]*deposit.Deposit, error) {
 
-	// Filter out deposits that cannot safely participate in a loop-in or
-	// were already allocated to a larger suggestion earlier in the same
-	// planning pass.
-	deposits := make([]*deposit.Deposit, 0, len(unfilteredDeposits))
-	for _, deposit := range unfilteredDeposits {
-		if _, ok := excludedOutpoints[deposit.OutPoint.String()]; ok {
-			continue
-		}
-
-		swappable := IsSwappable(
-			uint32(deposit.ConfirmationHeight), blockHeight,
-			csvExpiry,
-		)
-		if !swappable {
-			continue
-		}
-
-		if deposit.Value > maxAmount {
-			continue
-		}
-
-		deposits = append(deposits, deposit)
-	}
-
-	if len(deposits) == 0 {
-		return nil, ErrNoAutoloopCandidate
-	}
-
-	// Sort by value so the search finds large feasible totals early. The
-	// expiry tie-break keeps equal-value deposits deterministic and helps
-	// the later candidate comparison prefer sooner-expiring funds.
-	sort.SliceStable(deposits, func(i, j int) bool {
-		if deposits[i].Value == deposits[j].Value {
-			return deposits[i].ConfirmationHeight <
-				deposits[j].ConfirmationHeight
-		}
-
-		return deposits[i].Value > deposits[j].Value
-	})
-
-	// Precompute a suffix sum so branches that cannot possibly beat the
-	// current best total can be pruned before exploring the expensive part
-	// of the search tree.
-	suffixSums := make([]btcutil.Amount, len(deposits)+1)
-	for i := len(deposits) - 1; i >= 0; i-- {
-		suffixSums[i] = suffixSums[i+1] + deposits[i].Value
-	}
-
-	var (
-		bestSelection []int
-		bestTotal     btcutil.Amount
+	return selectNoChangeDepositsWithMemoryBudget(
+		maxAmount, minAmount, unfilteredDeposits, csvExpiry,
+		blockHeight, excludedOutpoints, autoloopDPMaxMemoryBytes,
 	)
-
-	// betterSelection applies the full-deposit ordering:
-	// 1. highest total not exceeding the target
-	// 2. fewer deposits
-	// 3. earlier-expiring deposits
-	betterSelection := func(candidate []int, total btcutil.Amount) bool {
-		switch {
-		case total > bestTotal:
-			return true
-
-		case total < bestTotal:
-			return false
-
-		case bestSelection == nil:
-			return true
-
-		case len(candidate) < len(bestSelection):
-			return true
-
-		case len(candidate) > len(bestSelection):
-			return false
-		}
-
-		// Use signed arithmetic here so an expired deposit cannot wrap
-		// the residual-life comparison if height updates race the
-		// earlier swappability filter.
-		left := make([]int64, len(candidate))
-		for i, index := range candidate {
-			left[i] = deposits[index].ConfirmationHeight +
-				int64(csvExpiry) - int64(blockHeight)
-		}
-
-		right := make([]int64, len(bestSelection))
-		for i, index := range bestSelection {
-			right[i] = deposits[index].ConfirmationHeight +
-				int64(csvExpiry) - int64(blockHeight)
-		}
-
-		slices.Sort(left)
-		slices.Sort(right)
-
-		for i := range left {
-			if left[i] == right[i] {
-				continue
-			}
-
-			return left[i] < right[i]
-		}
-
-		return false
-	}
-
-	// search explores include/exclude choices. The branch-and-bound checks
-	// are intentionally conservative: they only prune when no combination
-	// below the current node can beat the best known total or tie it with a
-	// smaller deposit count.
-	var search func(index int, total btcutil.Amount, selected []int)
-	search = func(index int, total btcutil.Amount, selected []int) {
-		if total > maxAmount {
-			return
-		}
-
-		if total >= minAmount && betterSelection(selected, total) {
-			bestTotal = total
-			bestSelection = append([]int(nil), selected...)
-		}
-
-		if index == len(deposits) {
-			return
-		}
-
-		maxReachable := total + suffixSums[index]
-		if maxReachable < bestTotal {
-			return
-		}
-
-		if maxReachable == bestTotal && bestSelection != nil &&
-			len(selected) >= len(bestSelection) {
-
-			return
-		}
-
-		// The include branch must not reuse selected's backing array.
-		// Otherwise a later append can leak into the exclude branch
-		// when the slice still has spare capacity.
-		selectedWithIndex := make([]int, len(selected)+1)
-		copy(selectedWithIndex, selected)
-		selectedWithIndex[len(selected)] = index
-
-		search(
-			index+1, total+deposits[index].Value,
-			selectedWithIndex,
-		)
-		search(index+1, total, selected)
-	}
-
-	search(0, 0, nil)
-
-	if len(bestSelection) == 0 {
-		return nil, ErrNoAutoloopCandidate
-	}
-
-	selectedDeposits := make([]*deposit.Deposit, 0, len(bestSelection))
-	for _, index := range bestSelection {
-		selectedDeposits = append(selectedDeposits, deposits[index])
-	}
-
-	return selectedDeposits, nil
 }