14358372723

Committed 09 Apr 2025 01:26PM UTC coverage: 56.696% (-12.3%) from 69.037%

Build # 14358372723

Build Type

Pull #9696

github

Committed by

web-flow

Commit Message

Merge e2837e400 into 867d27d68

Pull Request Pull Request #9696: Add `development_guidelines.md` for both human and machine

Run Details

107055 of 188823 relevant lines covered (56.7%)

22721.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.28

/sweep/tx_input_set.go

package sweep

import (
        "fmt"
        "math"
        "sort"

        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/txscript"
        "github.com/btcsuite/btcd/wire"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/input"
        "github.com/lightningnetwork/lnd/lnwallet"
        "github.com/lightningnetwork/lnd/lnwallet/chainfee"
)

var (
        // ErrNotEnoughInputs is returned when there are not enough wallet
        // inputs to construct a non-dust change output for an input set.
        ErrNotEnoughInputs = fmt.Errorf("not enough inputs")

        // ErrDeadlinesMismatch is returned when the deadlines of the input
        // sets do not match.
        ErrDeadlinesMismatch = fmt.Errorf("deadlines mismatch")

        // ErrDustOutput is returned when the output value is below the dust
        // limit.
        ErrDustOutput = fmt.Errorf("dust output")
)

// InputSet defines an interface that's responsible for filtering a set of
// inputs that can be swept economically.
type InputSet interface {
        // Inputs returns the set of inputs that should be used to create a tx.
        Inputs() []input.Input

        // AddWalletInputs adds wallet inputs to the set until a non-dust
        // change output can be made. Return an error if there are not enough
        // wallet inputs.
        AddWalletInputs(wallet Wallet) error

        // NeedWalletInput returns true if the input set needs more wallet
        // inputs.
        NeedWalletInput() bool

        // DeadlineHeight returns an absolute block height to express the
        // time-sensitivity of the input set. The outputs from a force close tx
        // have different time preferences:
        // - to_local: no time pressure as it can only be swept by us.
        // - first level outgoing HTLC: must be swept before its corresponding
        //   incoming HTLC's CLTV is reached.
        // - first level incoming HTLC: must be swept before its CLTV is
        //   reached.
        // - second level HTLCs: no time pressure.
        // - anchor: for CPFP-purpose anchor, it must be swept before any of
        //   the above CLTVs is reached. For non-CPFP purpose anchor, there's
        //   no time pressure.
        DeadlineHeight() int32

        // Budget givens the total amount that can be used as fees by this
        // input set.
        Budget() btcutil.Amount

        // StartingFeeRate returns the max starting fee rate found in the
        // inputs.
        StartingFeeRate() fn.Option[chainfee.SatPerKWeight]

        // Immediate returns a boolean to indicate whether the tx made from
        // this input set should be published immediately.
        //
        // TODO(yy): create a new method `Params` to combine the informational
        // methods DeadlineHeight, Budget, StartingFeeRate and Immediate.
        Immediate() bool
}

// createWalletTxInput converts a wallet utxo into an object that can be added
// to the other inputs to sweep.
func createWalletTxInput(utxo *lnwallet.Utxo) (input.Input, error) {
        signDesc := &input.SignDescriptor{
                Output: &wire.TxOut{
                        PkScript: utxo.PkScript,
                        Value:    int64(utxo.Value),
                },
                HashType: txscript.SigHashAll,
        }

        var witnessType input.WitnessType
        switch utxo.AddressType {
        case lnwallet.WitnessPubKey:
                witnessType = input.WitnessKeyHash
        case lnwallet.NestedWitnessPubKey:
                witnessType = input.NestedWitnessKeyHash
        case lnwallet.TaprootPubkey:
                witnessType = input.TaprootPubKeySpend
                signDesc.HashType = txscript.SigHashDefault
        default:
                return nil, fmt.Errorf("unknown address type %v",
                        utxo.AddressType)
        }

        // A height hint doesn't need to be set, because we don't monitor these
        // inputs for spend.
        heightHint := uint32(0)

        return input.NewBaseInput(
                &utxo.OutPoint, witnessType, signDesc, heightHint,
        ), nil
}

// BudgetInputSet implements the interface `InputSet`. It takes a list of
// pending inputs which share the same deadline height and groups them into a
// set conditionally based on their economical values.
type BudgetInputSet struct {
        // inputs is the set of inputs that have been added to the set after
        // considering their economical contribution.
        inputs []*SweeperInput

        // deadlineHeight is the height which the inputs in this set must be
        // confirmed by.
        deadlineHeight int32

        // extraBudget is a value that should be allocated to sweep the given
        // set of inputs. This can be used to add extra funds to the sweep
        // transaction, for example to cover fees for additional outputs of
        // custom channels.
        extraBudget btcutil.Amount
}

// Compile-time constraint to ensure budgetInputSet implements InputSet.
var _ InputSet = (*BudgetInputSet)(nil)

// errEmptyInputs is returned when the input slice is empty.
var errEmptyInputs = fmt.Errorf("inputs slice is empty")

// validateInputs is used when creating new BudgetInputSet to ensure there are
// no duplicate inputs and they all share the same deadline heights, if set.
func validateInputs(inputs []SweeperInput, deadlineHeight int32) error {
        // Sanity check the input slice to ensure it's non-empty.
        if len(inputs) == 0 {
                return errEmptyInputs
        }

        // inputDeadline tracks the input's deadline height. It will be updated
        // if the input has a different deadline than the specified
        // deadlineHeight.
        inputDeadline := deadlineHeight

        // dedupInputs is a set used to track unique outpoints of the inputs.
        dedupInputs := fn.NewSet(
                // Iterate all the inputs and map the function.
                fn.Map(inputs, func(inp SweeperInput) wire.OutPoint {
                        // If the input has a deadline height, we'll check if
                        // it's the same as the specified.
                        inp.params.DeadlineHeight.WhenSome(func(h int32) {
                                // Exit early if the deadlines matched.
                                if h == deadlineHeight {
                                        return
                                }

                                // Update the deadline height if it's
                                // different.
                                inputDeadline = h
                        })

                        return inp.OutPoint()
                })...,
        )

        // Make sure the inputs share the same deadline height when there is
        // one.
        if inputDeadline != deadlineHeight {
                return fmt.Errorf("input deadline height not matched: want "+
                        "%d, got %d", deadlineHeight, inputDeadline)
        }

        // Provide a defensive check to ensure that we don't have any duplicate
        // inputs within the set.
        if len(dedupInputs) != len(inputs) {
                return fmt.Errorf("duplicate inputs")
        }

        return nil
}

// NewBudgetInputSet creates a new BudgetInputSet.
func NewBudgetInputSet(inputs []SweeperInput, deadlineHeight int32,
        auxSweeper fn.Option[AuxSweeper]) (*BudgetInputSet, error) {

        // Validate the supplied inputs.
        if err := validateInputs(inputs, deadlineHeight); err != nil {
                return nil, err
        }

        bi := &BudgetInputSet{
                deadlineHeight: deadlineHeight,
                inputs:         make([]*SweeperInput, 0, len(inputs)),
        }

        for _, input := range inputs {
                bi.addInput(input)
        }

        log.Tracef("Created %v", bi.String())

        // Attach an optional budget. This will be a no-op if the auxSweeper
        // is not set.
        if err := bi.attachExtraBudget(auxSweeper); err != nil {
                return nil, err
        }

        return bi, nil
}

// attachExtraBudget attaches an extra budget to the input set, if the passed
// aux sweeper is set.
func (b *BudgetInputSet) attachExtraBudget(s fn.Option[AuxSweeper]) error {
        extraBudget, err := fn.MapOptionZ(
                s, func(aux AuxSweeper) fn.Result[btcutil.Amount] {
                        return aux.ExtraBudgetForInputs(b.Inputs())
                },
        ).Unpack()
        if err != nil {
                return err
        }

        b.extraBudget = extraBudget

        return nil
}

// String returns a human-readable description of the input set.
func (b *BudgetInputSet) String() string {
        inputsDesc := ""
        for _, input := range b.inputs {
                inputsDesc += fmt.Sprintf("\n%v", input)
        }

        return fmt.Sprintf("BudgetInputSet(budget=%v, deadline=%v, "+
                "inputs=[%v])", b.Budget(), b.DeadlineHeight(), inputsDesc)
}

// addInput adds an input to the input set.
func (b *BudgetInputSet) addInput(input SweeperInput) {
        b.inputs = append(b.inputs, &input)
}

// addWalletInput takes a wallet UTXO and adds it as an input to be used as
// budget for the input set.
func (b *BudgetInputSet) addWalletInput(utxo *lnwallet.Utxo) error {
        input, err := createWalletTxInput(utxo)
        if err != nil {
                return err
        }

        pi := SweeperInput{
                Input: input,
                params: Params{
                        DeadlineHeight: fn.Some(b.deadlineHeight),
                },
        }
        b.addInput(pi)

        log.Debugf("Added wallet input to input set: op=%v, amt=%v",
                pi.OutPoint(), utxo.Value)

        return nil
}

// NeedWalletInput returns true if the input set needs more wallet inputs.
//
// A set may need wallet inputs when it has a required output or its total
// value cannot cover its total budget.
func (b *BudgetInputSet) NeedWalletInput() bool {
        var (
                // budgetNeeded is the amount that needs to be covered from
                // other inputs. We start at the value of the extra budget,
                // which might be needed for custom channels that add extra
                // outputs.
                budgetNeeded = b.extraBudget

                // budgetBorrowable is the amount that can be borrowed from
                // other inputs.
                budgetBorrowable btcutil.Amount
        )

        for _, inp := range b.inputs {
                // If this input has a required output, we can assume it's a
                // second-level htlc txns input. Although this input must have
                // a value that can cover its budget, it cannot be used to pay
                // fees. Instead, we need to borrow budget from other inputs to
                // make the sweep happen. Once swept, the input value will be
                // credited to the wallet.
                if inp.RequiredTxOut() != nil {
                        budgetNeeded += inp.params.Budget
                        continue
                }

                // Get the amount left after covering the input's own budget.
                // This amount can then be lent to the above input. For a wallet
                // input, its `Budget` is set to zero, which means the whole
                // input can be borrowed to cover the budget.
                budget := inp.params.Budget
                output := btcutil.Amount(inp.SignDesc().Output.Value)
                budgetBorrowable += output - budget

                // If the input's budget is not even covered by itself, we need
                // to borrow outputs from other inputs.
                if budgetBorrowable < 0 {
                        log.Tracef("Input %v specified a budget that exceeds "+
                                "its output value: %v > %v", inp, budget,
                                output)
                }
        }

        log.Debugf("NeedWalletInput: budgetNeeded=%v, budgetBorrowable=%v",
                budgetNeeded, budgetBorrowable)

        // If we don't have enough extra budget to borrow, we need wallet
        // inputs.
        return budgetBorrowable < budgetNeeded
}

// hasNormalInput return a bool to indicate whether there exists an input that
// doesn't require a TxOut. When an input has no required outputs, it's either a
// wallet input, or an input we want to sweep.
func (b *BudgetInputSet) hasNormalInput() bool {
        for _, inp := range b.inputs {
                if inp.RequiredTxOut() != nil {
                        continue
                }

                return true
        }

        return false
}

// AddWalletInputs adds wallet inputs to the set until the specified budget is
// met. When sweeping inputs with required outputs, although there's budget
// specified, it cannot be directly spent from these required outputs. Instead,
// we need to borrow budget from other inputs to make the sweep happen.
// There are two sources to borrow from: 1) other inputs, 2) wallet utxos. If
// we are calling this method, it means other inputs cannot cover the specified
// budget, so we need to borrow from wallet utxos.
//
// Return an error if there are not enough wallet inputs, and the budget set is
// set to its initial state by removing any wallet inputs added.
//
// NOTE: must be called with the wallet lock held via `WithCoinSelectLock`.
func (b *BudgetInputSet) AddWalletInputs(wallet Wallet) error {
        // Retrieve wallet utxos. Only consider confirmed utxos to prevent
        // problems around RBF rules for unconfirmed inputs. This currently
        // ignores the configured coin selection strategy.
        utxos, err := wallet.ListUnspentWitnessFromDefaultAccount(
                1, math.MaxInt32,
        )
        if err != nil {
                return fmt.Errorf("list unspent witness: %w", err)
        }

        // Sort the UTXOs by putting smaller values at the start of the slice
        // to avoid locking large UTXO for sweeping.
        //
        // TODO(yy): add more choices to CoinSelectionStrategy and use the
        // configured value here.
        sort.Slice(utxos, func(i, j int) bool {
                return utxos[i].Value < utxos[j].Value
        })

        // Add wallet inputs to the set until the specified budget is covered.
        for _, utxo := range utxos {
                err := b.addWalletInput(utxo)
                if err != nil {
                        return err
                }

                // Return if we've reached the minimum output amount.
                if !b.NeedWalletInput() {
                        return nil
                }
        }

        // Exit if there are no inputs can contribute to the fees.
        if !b.hasNormalInput() {
                return ErrNotEnoughInputs
        }

        // If there's at least one input that can contribute to fees, we allow
        // the sweep to continue, even though the full budget can't be met.
        // Maybe later more wallet inputs will become available and we can add
        // them if needed.
        budget := b.Budget()
        total, spendable := b.inputAmts()
        log.Warnf("Not enough wallet UTXOs: need budget=%v, has spendable=%v, "+
                "total=%v, missing at least %v, sweeping anyway...", budget,
                spendable, total, budget-spendable)

        return nil
}

// Budget returns the total budget of the set.
//
// NOTE: part of the InputSet interface.
func (b *BudgetInputSet) Budget() btcutil.Amount {
        budget := btcutil.Amount(0)
        for _, input := range b.inputs {
                budget += input.params.Budget
        }

        // We'll also tack on the extra budget which will eventually be
        // accounted for by the wallet txns when we're broadcasting.
        return budget + b.extraBudget
}

// DeadlineHeight returns the deadline height of the set.
//
// NOTE: part of the InputSet interface.
func (b *BudgetInputSet) DeadlineHeight() int32 {
        return b.deadlineHeight
}

// Inputs returns the inputs that should be used to create a tx.
//
// NOTE: part of the InputSet interface.
func (b *BudgetInputSet) Inputs() []input.Input {
        inputs := make([]input.Input, 0, len(b.inputs))
        for _, inp := range b.inputs {
                inputs = append(inputs, inp.Input)
        }

        return inputs
}

// inputAmts returns two values for the set - the total input amount, and the
// spendable amount. Only the spendable amount can be used to pay the fees.
func (b *BudgetInputSet) inputAmts() (btcutil.Amount, btcutil.Amount) {
        var (
                totalAmt     btcutil.Amount
                spendableAmt btcutil.Amount
        )

        for _, inp := range b.inputs {
                output := btcutil.Amount(inp.SignDesc().Output.Value)
                totalAmt += output

                if inp.RequiredTxOut() != nil {
                        continue
                }

                spendableAmt += output
        }

        return totalAmt, spendableAmt
}

// StartingFeeRate returns the max starting fee rate found in the inputs.
//
// NOTE: part of the InputSet interface.
func (b *BudgetInputSet) StartingFeeRate() fn.Option[chainfee.SatPerKWeight] {
        maxFeeRate := chainfee.SatPerKWeight(0)
        startingFeeRate := fn.None[chainfee.SatPerKWeight]()

        for _, inp := range b.inputs {
                feerate := inp.params.StartingFeeRate.UnwrapOr(0)
                if feerate > maxFeeRate {
                        maxFeeRate = feerate
                        startingFeeRate = fn.Some(maxFeeRate)
                }
        }

        return startingFeeRate
}

// Immediate returns whether the inputs should be swept immediately.
//
// NOTE: part of the InputSet interface.
func (b *BudgetInputSet) Immediate() bool {
        for _, inp := range b.inputs {
                // As long as one of the inputs is immediate, the whole set is
                // immediate.
                if inp.params.Immediate {
                        return true
                }
        }

        return false
}

1	package sweep
2
3	import (
4	"fmt"
5	"math"
6	"sort"
7
8	"github.com/btcsuite/btcd/btcutil"
9	"github.com/btcsuite/btcd/txscript"
10	"github.com/btcsuite/btcd/wire"
11	"github.com/lightningnetwork/lnd/fn/v2"
12	"github.com/lightningnetwork/lnd/input"
13	"github.com/lightningnetwork/lnd/lnwallet"
14	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
15	)
16
17	var (
18	// ErrNotEnoughInputs is returned when there are not enough wallet
19	// inputs to construct a non-dust change output for an input set.
20	ErrNotEnoughInputs = fmt.Errorf("not enough inputs")
21
22	// ErrDeadlinesMismatch is returned when the deadlines of the input
23	// sets do not match.
24	ErrDeadlinesMismatch = fmt.Errorf("deadlines mismatch")
25
26	// ErrDustOutput is returned when the output value is below the dust
27	// limit.
28	ErrDustOutput = fmt.Errorf("dust output")
29	)
30
31	// InputSet defines an interface that's responsible for filtering a set of
32	// inputs that can be swept economically.
33	type InputSet interface {
34	// Inputs returns the set of inputs that should be used to create a tx.
35	Inputs() []input.Input
36
37	// AddWalletInputs adds wallet inputs to the set until a non-dust
38	// change output can be made. Return an error if there are not enough
39	// wallet inputs.
40	AddWalletInputs(wallet Wallet) error
41
42	// NeedWalletInput returns true if the input set needs more wallet
43	// inputs.
44	NeedWalletInput() bool
45
46	// DeadlineHeight returns an absolute block height to express the
47	// time-sensitivity of the input set. The outputs from a force close tx
48	// have different time preferences:
49	// - to_local: no time pressure as it can only be swept by us.
50	// - first level outgoing HTLC: must be swept before its corresponding
51	// incoming HTLC's CLTV is reached.
52	// - first level incoming HTLC: must be swept before its CLTV is
53	// reached.
54	// - second level HTLCs: no time pressure.
55	// - anchor: for CPFP-purpose anchor, it must be swept before any of
56	// the above CLTVs is reached. For non-CPFP purpose anchor, there's
57	// no time pressure.
58	DeadlineHeight() int32
59
60	// Budget givens the total amount that can be used as fees by this
61	// input set.
62	Budget() btcutil.Amount
63
64	// StartingFeeRate returns the max starting fee rate found in the
65	// inputs.
66	StartingFeeRate() fn.Option[chainfee.SatPerKWeight]
67
68	// Immediate returns a boolean to indicate whether the tx made from
69	// this input set should be published immediately.
70	//
71	// TODO(yy): create a new method `Params` to combine the informational
72	// methods DeadlineHeight, Budget, StartingFeeRate and Immediate.
73	Immediate() bool
74	}
75
76	// createWalletTxInput converts a wallet utxo into an object that can be added
77	// to the other inputs to sweep.
78	func createWalletTxInput(utxo *lnwallet.Utxo) (input.Input, error) {	6✔
79	signDesc := &input.SignDescriptor{	6✔
80	Output: &wire.TxOut{	6✔
81	PkScript: utxo.PkScript,	6✔
82	Value: int64(utxo.Value),	6✔
83	},	6✔
84	HashType: txscript.SigHashAll,	6✔
85	}	6✔
86		6✔
87	var witnessType input.WitnessType	6✔
88	switch utxo.AddressType {	6✔
89	case lnwallet.WitnessPubKey:	4✔
90	witnessType = input.WitnessKeyHash	4✔
91	case lnwallet.NestedWitnessPubKey:	×
92	witnessType = input.NestedWitnessKeyHash	×
93	case lnwallet.TaprootPubkey:	×
94	witnessType = input.TaprootPubKeySpend	×
95	signDesc.HashType = txscript.SigHashDefault	×
96	default:	2✔
97	return nil, fmt.Errorf("unknown address type %v",	2✔
98	utxo.AddressType)	2✔
99	}
100
101	// A height hint doesn't need to be set, because we don't monitor these
102	// inputs for spend.
103	heightHint := uint32(0)	4✔
104		4✔
105	return input.NewBaseInput(	4✔
106	&utxo.OutPoint, witnessType, signDesc, heightHint,	4✔
107	), nil	4✔
108	}
109
110	// BudgetInputSet implements the interface `InputSet`. It takes a list of
111	// pending inputs which share the same deadline height and groups them into a
112	// set conditionally based on their economical values.
113	type BudgetInputSet struct {
114	// inputs is the set of inputs that have been added to the set after
115	// considering their economical contribution.
116	inputs []*SweeperInput
117
118	// deadlineHeight is the height which the inputs in this set must be
119	// confirmed by.
120	deadlineHeight int32
121
122	// extraBudget is a value that should be allocated to sweep the given
123	// set of inputs. This can be used to add extra funds to the sweep
124	// transaction, for example to cover fees for additional outputs of
125	// custom channels.
126	extraBudget btcutil.Amount
127	}
128
129	// Compile-time constraint to ensure budgetInputSet implements InputSet.
130	var _ InputSet = (*BudgetInputSet)(nil)
131
132	// errEmptyInputs is returned when the input slice is empty.
133	var errEmptyInputs = fmt.Errorf("inputs slice is empty")
134
135	// validateInputs is used when creating new BudgetInputSet to ensure there are
136	// no duplicate inputs and they all share the same deadline heights, if set.
137	func validateInputs(inputs []SweeperInput, deadlineHeight int32) error {	24✔
138	// Sanity check the input slice to ensure it's non-empty.	24✔
139	if len(inputs) == 0 {	26✔
140	return errEmptyInputs	2✔
141	}	2✔
142
143	// inputDeadline tracks the input's deadline height. It will be updated
144	// if the input has a different deadline than the specified
145	// deadlineHeight.
146	inputDeadline := deadlineHeight	22✔
147		22✔
148	// dedupInputs is a set used to track unique outpoints of the inputs.	22✔
149	dedupInputs := fn.NewSet(	22✔
150	// Iterate all the inputs and map the function.	22✔
151	fn.Map(inputs, func(inp SweeperInput) wire.OutPoint {	56✔
152	// If the input has a deadline height, we'll check if	34✔
153	// it's the same as the specified.	34✔
154	inp.params.DeadlineHeight.WhenSome(func(h int32) {	50✔
155	// Exit early if the deadlines matched.	16✔
156	if h == deadlineHeight {	28✔
157	return	12✔
158	}	12✔
159
160	// Update the deadline height if it's
161	// different.
162	inputDeadline = h	4✔
163	})
164
165	return inp.OutPoint()	34✔
166	})...,
167	)
168
169	// Make sure the inputs share the same deadline height when there is
170	// one.
171	if inputDeadline != deadlineHeight {	25✔
172	return fmt.Errorf("input deadline height not matched: want "+	3✔
173	"%d, got %d", deadlineHeight, inputDeadline)	3✔
174	}	3✔
175
176	// Provide a defensive check to ensure that we don't have any duplicate
177	// inputs within the set.
178	if len(dedupInputs) != len(inputs) {	20✔
179	return fmt.Errorf("duplicate inputs")	1✔
180	}	1✔
181
182	return nil	18✔
183	}
184
185	// NewBudgetInputSet creates a new BudgetInputSet.
186	func NewBudgetInputSet(inputs []SweeperInput, deadlineHeight int32,
187	auxSweeper fn.Option[AuxSweeper]) (*BudgetInputSet, error) {	24✔
188		24✔
189	// Validate the supplied inputs.	24✔
190	if err := validateInputs(inputs, deadlineHeight); err != nil {	30✔
191	return nil, err	6✔
192	}	6✔
193
194	bi := &BudgetInputSet{	18✔
195	deadlineHeight: deadlineHeight,	18✔
196	inputs: make([]*SweeperInput, 0, len(inputs)),	18✔
197	}	18✔
198		18✔
199	for _, input := range inputs {	44✔
200	bi.addInput(input)	26✔
201	}	26✔
202
203	log.Tracef("Created %v", bi.String())	18✔
204		18✔
205	// Attach an optional budget. This will be a no-op if the auxSweeper	18✔
206	// is not set.	18✔
207	if err := bi.attachExtraBudget(auxSweeper); err != nil {	18✔
208	return nil, err	×
209	}	×
210
211	return bi, nil	18✔
212	}
213
214	// attachExtraBudget attaches an extra budget to the input set, if the passed
215	// aux sweeper is set.
216	func (b *BudgetInputSet) attachExtraBudget(s fn.Option[AuxSweeper]) error {	18✔
217	extraBudget, err := fn.MapOptionZ(	18✔
218	s, func(aux AuxSweeper) fn.Result[btcutil.Amount] {	24✔
219	return aux.ExtraBudgetForInputs(b.Inputs())	6✔
220	},	6✔
221	).Unpack()
222	if err != nil {	18✔
223	return err	×
224	}	×
225
226	b.extraBudget = extraBudget	18✔
227		18✔
228	return nil	18✔
229	}
230
231	// String returns a human-readable description of the input set.
232	func (b *BudgetInputSet) String() string {	18✔
233	inputsDesc := ""	18✔
234	for _, input := range b.inputs {	44✔
235	inputsDesc += fmt.Sprintf("\n%v", input)	26✔
236	}	26✔
237
238	return fmt.Sprintf("BudgetInputSet(budget=%v, deadline=%v, "+	18✔
239	"inputs=[%v])", b.Budget(), b.DeadlineHeight(), inputsDesc)	18✔
240	}
241
242	// addInput adds an input to the input set.
243	func (b *BudgetInputSet) addInput(input SweeperInput) {	31✔
244	b.inputs = append(b.inputs, &input)	31✔
245	}	31✔
246
247	// addWalletInput takes a wallet UTXO and adds it as an input to be used as
248	// budget for the input set.
249	func (b BudgetInputSet) addWalletInput(utxo lnwallet.Utxo) error {	6✔
250	input, err := createWalletTxInput(utxo)	6✔
251	if err != nil {	8✔
252	return err	2✔
253	}	2✔
254
255	pi := SweeperInput{	4✔
256	Input: input,	4✔
257	params: Params{	4✔
258	DeadlineHeight: fn.Some(b.deadlineHeight),	4✔
259	},	4✔
260	}	4✔
261	b.addInput(pi)	4✔
262		4✔
263	log.Debugf("Added wallet input to input set: op=%v, amt=%v",	4✔
264	pi.OutPoint(), utxo.Value)	4✔
265		4✔
266	return nil	4✔
267	}
268
269	// NeedWalletInput returns true if the input set needs more wallet inputs.
270	//
271	// A set may need wallet inputs when it has a required output or its total
272	// value cannot cover its total budget.
273	func (b *BudgetInputSet) NeedWalletInput() bool {	9✔
274	var (	9✔
275	// budgetNeeded is the amount that needs to be covered from	9✔
276	// other inputs. We start at the value of the extra budget,	9✔
277	// which might be needed for custom channels that add extra	9✔
278	// outputs.	9✔
279	budgetNeeded = b.extraBudget	9✔
280		9✔
281	// budgetBorrowable is the amount that can be borrowed from	9✔
282	// other inputs.	9✔
283	budgetBorrowable btcutil.Amount	9✔
284	)	9✔
285		9✔
286	for _, inp := range b.inputs {	24✔
287	// If this input has a required output, we can assume it's a	15✔
288	// second-level htlc txns input. Although this input must have	15✔
289	// a value that can cover its budget, it cannot be used to pay	15✔
290	// fees. Instead, we need to borrow budget from other inputs to	15✔
291	// make the sweep happen. Once swept, the input value will be	15✔
292	// credited to the wallet.	15✔
293	if inp.RequiredTxOut() != nil {	21✔
294	budgetNeeded += inp.params.Budget	6✔
295	continue	6✔
296	}
297
298	// Get the amount left after covering the input's own budget.
299	// This amount can then be lent to the above input. For a wallet
300	// input, its `Budget` is set to zero, which means the whole
301	// input can be borrowed to cover the budget.
302	budget := inp.params.Budget	9✔
303	output := btcutil.Amount(inp.SignDesc().Output.Value)	9✔
304	budgetBorrowable += output - budget	9✔
305		9✔
306	// If the input's budget is not even covered by itself, we need	9✔
307	// to borrow outputs from other inputs.	9✔
308	if budgetBorrowable < 0 {	10✔
309	log.Tracef("Input %v specified a budget that exceeds "+	1✔
310	"its output value: %v > %v", inp, budget,	1✔
311	output)	1✔
312	}	1✔
313	}
314
315	log.Debugf("NeedWalletInput: budgetNeeded=%v, budgetBorrowable=%v",	9✔
316	budgetNeeded, budgetBorrowable)	9✔
317		9✔
318	// If we don't have enough extra budget to borrow, we need wallet	9✔
319	// inputs.	9✔
320	return budgetBorrowable < budgetNeeded	9✔
321	}
322
323	// hasNormalInput return a bool to indicate whether there exists an input that
324	// doesn't require a TxOut. When an input has no required outputs, it's either a
325	// wallet input, or an input we want to sweep.
326	func (b *BudgetInputSet) hasNormalInput() bool {	3✔
327	for _, inp := range b.inputs {	7✔
328	if inp.RequiredTxOut() != nil {	6✔
329	continue	2✔
330	}
331
332	return true	2✔
333	}
334
335	return false	1✔
336	}
337
338	// AddWalletInputs adds wallet inputs to the set until the specified budget is
339	// met. When sweeping inputs with required outputs, although there's budget
340	// specified, it cannot be directly spent from these required outputs. Instead,
341	// we need to borrow budget from other inputs to make the sweep happen.
342	// There are two sources to borrow from: 1) other inputs, 2) wallet utxos. If
343	// we are calling this method, it means other inputs cannot cover the specified
344	// budget, so we need to borrow from wallet utxos.
345	//
346	// Return an error if there are not enough wallet inputs, and the budget set is
347	// set to its initial state by removing any wallet inputs added.
348	//
349	// NOTE: must be called with the wallet lock held via `WithCoinSelectLock`.
350	func (b *BudgetInputSet) AddWalletInputs(wallet Wallet) error {	6✔
351	// Retrieve wallet utxos. Only consider confirmed utxos to prevent	6✔
352	// problems around RBF rules for unconfirmed inputs. This currently	6✔
353	// ignores the configured coin selection strategy.	6✔
354	utxos, err := wallet.ListUnspentWitnessFromDefaultAccount(	6✔
355	1, math.MaxInt32,	6✔
356	)	6✔
357	if err != nil {	7✔
358	return fmt.Errorf("list unspent witness: %w", err)	1✔
359	}	1✔
360
361	// Sort the UTXOs by putting smaller values at the start of the slice
362	// to avoid locking large UTXO for sweeping.
363	//
364	// TODO(yy): add more choices to CoinSelectionStrategy and use the
365	// configured value here.
366	sort.Slice(utxos, func(i, j int) bool {	6✔
367	return utxos[i].Value < utxos[j].Value	1✔
368	})	1✔
369
370	// Add wallet inputs to the set until the specified budget is covered.
371	for _, utxo := range utxos {	9✔
372	err := b.addWalletInput(utxo)	4✔
373	if err != nil {	5✔
374	return err	1✔
375	}	1✔
376
377	// Return if we've reached the minimum output amount.
378	if !b.NeedWalletInput() {	4✔
379	return nil	1✔
380	}	1✔
381	}
382
383	// Exit if there are no inputs can contribute to the fees.
384	if !b.hasNormalInput() {	4✔
385	return ErrNotEnoughInputs	1✔
386	}	1✔
387
388	// If there's at least one input that can contribute to fees, we allow
389	// the sweep to continue, even though the full budget can't be met.
390	// Maybe later more wallet inputs will become available and we can add
391	// them if needed.
392	budget := b.Budget()	2✔
393	total, spendable := b.inputAmts()	2✔
394	log.Warnf("Not enough wallet UTXOs: need budget=%v, has spendable=%v, "+	2✔
395	"total=%v, missing at least %v, sweeping anyway...", budget,	2✔
396	spendable, total, budget-spendable)	2✔
397		2✔
398	return nil	2✔
399	}
400
401	// Budget returns the total budget of the set.
402	//
403	// NOTE: part of the InputSet interface.
404	func (b *BudgetInputSet) Budget() btcutil.Amount {	25✔
405	budget := btcutil.Amount(0)	25✔
406	for _, input := range b.inputs {	66✔
407	budget += input.params.Budget	41✔
408	}	41✔
409
410	// We'll also tack on the extra budget which will eventually be
411	// accounted for by the wallet txns when we're broadcasting.
412	return budget + b.extraBudget	25✔
413	}
414
415	// DeadlineHeight returns the deadline height of the set.
416	//
417	// NOTE: part of the InputSet interface.
418	func (b *BudgetInputSet) DeadlineHeight() int32 {	22✔
419	return b.deadlineHeight	22✔
420	}	22✔
421
422	// Inputs returns the inputs that should be used to create a tx.
423	//
424	// NOTE: part of the InputSet interface.
425	func (b *BudgetInputSet) Inputs() []input.Input {	10✔
426	inputs := make([]input.Input, 0, len(b.inputs))	10✔
427	for _, inp := range b.inputs {	25✔
428	inputs = append(inputs, inp.Input)	15✔
429	}	15✔
430
431	return inputs	10✔
432	}
433
434	// inputAmts returns two values for the set - the total input amount, and the
435	// spendable amount. Only the spendable amount can be used to pay the fees.
436	func (b *BudgetInputSet) inputAmts() (btcutil.Amount, btcutil.Amount) {	2✔
437	var (	2✔
438	totalAmt btcutil.Amount	2✔
439	spendableAmt btcutil.Amount	2✔
440	)	2✔
441		2✔
442	for _, inp := range b.inputs {	6✔
443	output := btcutil.Amount(inp.SignDesc().Output.Value)	4✔
444	totalAmt += output	4✔
445		4✔
446	if inp.RequiredTxOut() != nil {	6✔
447	continue	2✔
448	}
449
450	spendableAmt += output	2✔
451	}
452
453	return totalAmt, spendableAmt	2✔
454	}
455
456	// StartingFeeRate returns the max starting fee rate found in the inputs.
457	//
458	// NOTE: part of the InputSet interface.
459	func (b *BudgetInputSet) StartingFeeRate() fn.Option[chainfee.SatPerKWeight] {	×
460	maxFeeRate := chainfee.SatPerKWeight(0)	×
461	startingFeeRate := fn.None[chainfee.SatPerKWeight]()	×
462		×
463	for _, inp := range b.inputs {	×
464	feerate := inp.params.StartingFeeRate.UnwrapOr(0)	×
465	if feerate > maxFeeRate {	×
466	maxFeeRate = feerate	×
467	startingFeeRate = fn.Some(maxFeeRate)	×
468	}	×
469	}
470
471	return startingFeeRate	×
472	}
473
474	// Immediate returns whether the inputs should be swept immediately.
475	//
476	// NOTE: part of the InputSet interface.
477	func (b *BudgetInputSet) Immediate() bool {	×
478	for _, inp := range b.inputs {	×
479	// As long as one of the inputs is immediate, the whole set is	×
480	// immediate.	×
481	if inp.params.Immediate {	×
482	return true	×
483	}	×
484	}
485
486	return false	×
487	}

lightningnetwork / lnd / 14358372723

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous