12313002221

Committed 13 Dec 2024 09:25AM UTC coverage: 57.486% (+8.6%) from 48.92%

Build # 12313002221

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9343 from ellemouton/contextGuard

fn: expand the ContextGuard and add tests

Run Details

101902 of 177264 relevant lines covered (57.49%)

24909.26 hits per line

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

40.0

/lnwallet/errors.go

package lnwallet

import (
        "errors"
        "fmt"

        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/lightningnetwork/lnd/lnwire"
)

// ReservationError wraps certain errors returned during channel reservation
// that can be sent across the wire to the remote peer. Errors not being
// ReservationErrors will not be sent to the remote in case of a failed channel
// reservation, as they may contain private information.
type ReservationError struct {
        error
}

// A compile time check to ensure ReservationError implements the error
// interface.
var _ error = (*ReservationError)(nil)

// ErrZeroCapacity returns an error indicating the funder attempted to put zero
// funds into the channel.
func ErrZeroCapacity() ReservationError {
        return ReservationError{
                errors.New("zero channel funds"),
        }
}

// ErrChainMismatch returns an error indicating that the initiator tried to
// open a channel for an unknown chain.
func ErrChainMismatch(knownChain,
        unknownChain *chainhash.Hash) ReservationError {
        return ReservationError{
                fmt.Errorf("unknown chain=%v, supported chain=%v",
                        unknownChain, knownChain),
        }
}

// ErrFunderBalanceDust returns an error indicating the initial balance of the
// funder is considered dust at the current commitment fee.
func ErrFunderBalanceDust(commitFee, funderBalance,
        minBalance int64) ReservationError {
        return ReservationError{
                fmt.Errorf("funder balance too small (%v) with fee=%v sat, "+
                        "minimum=%v sat required", funderBalance,
                        commitFee, minBalance),
        }
}

// ErrCsvDelayTooLarge returns an error indicating that the CSV delay was to
// large to be accepted, along with the current max.
func ErrCsvDelayTooLarge(remoteDelay, maxDelay uint16) ReservationError {
        return ReservationError{
                fmt.Errorf("CSV delay too large: %v, max is %v",
                        remoteDelay, maxDelay),
        }
}

// ErrChanReserveTooSmall returns an error indicating that the channel reserve
// the remote is requiring is too small to be accepted.
func ErrChanReserveTooSmall(reserve, dustLimit btcutil.Amount) ReservationError {
        return ReservationError{
                fmt.Errorf("channel reserve of %v sat is too small, min is %v "+
                        "sat", int64(reserve), int64(dustLimit)),
        }
}

// ErrChanReserveTooLarge returns an error indicating that the chan reserve the
// remote is requiring, is too large to be accepted.
func ErrChanReserveTooLarge(reserve,
        maxReserve btcutil.Amount) ReservationError {
        return ReservationError{
                fmt.Errorf("channel reserve is too large: %v sat, max "+
                        "is %v sat", int64(reserve), int64(maxReserve)),
        }
}

// ErrNonZeroPushAmount is returned by a remote peer that receives a
// FundingOpen request for a channel with non-zero push amount while
// they have 'rejectpush' enabled.
func ErrNonZeroPushAmount() ReservationError {
        return ReservationError{errors.New("non-zero push amounts are disabled")}
}

// ErrMinHtlcTooLarge returns an error indicating that the MinHTLC value the
// remote required is too large to be accepted.
func ErrMinHtlcTooLarge(minHtlc,
        maxMinHtlc lnwire.MilliSatoshi) ReservationError {
        return ReservationError{
                fmt.Errorf("minimum HTLC value is too large: %v, max is %v",
                        minHtlc, maxMinHtlc),
        }
}

// ErrMaxHtlcNumTooLarge returns an error indicating that the 'max HTLCs in
// flight' value the remote required is too large to be accepted.
func ErrMaxHtlcNumTooLarge(maxHtlc, maxMaxHtlc uint16) ReservationError {
        return ReservationError{
                fmt.Errorf("maxHtlcs is too large: %d, max is %d",
                        maxHtlc, maxMaxHtlc),
        }
}

// ErrMaxHtlcNumTooSmall returns an error indicating that the 'max HTLCs in
// flight' value the remote required is too small to be accepted.
func ErrMaxHtlcNumTooSmall(maxHtlc, minMaxHtlc uint16) ReservationError {
        return ReservationError{
                fmt.Errorf("maxHtlcs is too small: %d, min is %d",
                        maxHtlc, minMaxHtlc),
        }
}

// ErrMaxValueInFlightTooSmall returns an error indicating that the 'max HTLC
// value in flight' the remote required is too small to be accepted.
func ErrMaxValueInFlightTooSmall(maxValInFlight,
        minMaxValInFlight lnwire.MilliSatoshi) ReservationError {
        return ReservationError{
                fmt.Errorf("maxValueInFlight too small: %v, min is %v",
                        maxValInFlight, minMaxValInFlight),
        }
}

// ErrNumConfsTooLarge returns an error indicating that the number of
// confirmations required for a channel is too large.
func ErrNumConfsTooLarge(numConfs, maxNumConfs uint32) error {
        return ReservationError{
                fmt.Errorf("minimum depth of %d is too large, max is %d",
                        numConfs, maxNumConfs),
        }
}

// ErrChanTooSmall returns an error indicating that an incoming channel request
// was too small. We'll reject any incoming channels if they're below our
// configured value for the min channel size we'll accept.
func ErrChanTooSmall(chanSize, minChanSize btcutil.Amount) ReservationError {
        return ReservationError{
                fmt.Errorf("chan size of %v is below min chan size of %v",
                        chanSize, minChanSize),
        }
}

// ErrChanTooLarge returns an error indicating that an incoming channel request
// was too large. We'll reject any incoming channels if they're above our
// configured value for the max channel size we'll accept.
func ErrChanTooLarge(chanSize, maxChanSize btcutil.Amount) ReservationError {
        return ReservationError{
                fmt.Errorf("chan size of %v exceeds maximum chan size of %v",
                        chanSize, maxChanSize),
        }
}

// ErrInvalidDustLimit returns an error indicating that a proposed DustLimit
// was rejected.
func ErrInvalidDustLimit(dustLimit btcutil.Amount) ReservationError {
        return ReservationError{
                fmt.Errorf("dust limit %v is invalid", dustLimit),
        }
}

// ErrHtlcIndexAlreadyFailed is returned when the HTLC index has already been
// failed, but has not been committed by our commitment state.
type ErrHtlcIndexAlreadyFailed uint64

// Error returns a message indicating the index that had already been failed.
func (e ErrHtlcIndexAlreadyFailed) Error() string {
        return fmt.Sprintf("HTLC with ID %d has already been failed", e)
}

// ErrHtlcIndexAlreadySettled is returned when the HTLC index has already been
// settled, but has not been committed by our commitment state.
type ErrHtlcIndexAlreadySettled uint64

// Error returns a message indicating the index that had already been settled.
func (e ErrHtlcIndexAlreadySettled) Error() string {
        return fmt.Sprintf("HTLC with ID %d has already been settled", e)
}

// ErrInvalidSettlePreimage is returned when trying to settle an HTLC, but the
// preimage does not correspond to the payment hash.
type ErrInvalidSettlePreimage struct {
        preimage []byte
        rhash    []byte
}

// Error returns an error message with the offending preimage and intended
// payment hash.
func (e ErrInvalidSettlePreimage) Error() string {
        return fmt.Sprintf("Invalid payment preimage %x for hash %x",
                e.preimage, e.rhash)
}

// ErrUnknownHtlcIndex is returned when locally settling or failing an HTLC, but
// the HTLC index is not known to the channel. This typically indicates that the
// HTLC was already settled in a prior commitment.
type ErrUnknownHtlcIndex struct {
        chanID lnwire.ShortChannelID
        index  uint64
}

// Error returns an error logging the channel and HTLC index that was unknown.
func (e ErrUnknownHtlcIndex) Error() string {
        return fmt.Sprintf("No HTLC with ID %d in channel %v",
                e.index, e.chanID)
}

1	package lnwallet
2
3	import (
4	"errors"
5	"fmt"
6
7	"github.com/btcsuite/btcd/btcutil"
8	"github.com/btcsuite/btcd/chaincfg/chainhash"
9	"github.com/lightningnetwork/lnd/lnwire"
10	)
11
12	// ReservationError wraps certain errors returned during channel reservation
13	// that can be sent across the wire to the remote peer. Errors not being
14	// ReservationErrors will not be sent to the remote in case of a failed channel
15	// reservation, as they may contain private information.
16	type ReservationError struct {
17	error
18	}
19
20	// A compile time check to ensure ReservationError implements the error
21	// interface.
22	var _ error = (*ReservationError)(nil)
23
24	// ErrZeroCapacity returns an error indicating the funder attempted to put zero
25	// funds into the channel.
26	func ErrZeroCapacity() ReservationError {	×
27	return ReservationError{	×
28	errors.New("zero channel funds"),	×
29	}	×
30	}	×
31
32	// ErrChainMismatch returns an error indicating that the initiator tried to
33	// open a channel for an unknown chain.
34	func ErrChainMismatch(knownChain,
35	unknownChain *chainhash.Hash) ReservationError {	×
36	return ReservationError{	×
37	fmt.Errorf("unknown chain=%v, supported chain=%v",	×
38	unknownChain, knownChain),	×
39	}	×
40	}	×
41
42	// ErrFunderBalanceDust returns an error indicating the initial balance of the
43	// funder is considered dust at the current commitment fee.
44	func ErrFunderBalanceDust(commitFee, funderBalance,
45	minBalance int64) ReservationError {	4✔
46	return ReservationError{	4✔
47	fmt.Errorf("funder balance too small (%v) with fee=%v sat, "+	4✔
48	"minimum=%v sat required", funderBalance,	4✔
49	commitFee, minBalance),	4✔
50	}	4✔
51	}	4✔
52
53	// ErrCsvDelayTooLarge returns an error indicating that the CSV delay was to
54	// large to be accepted, along with the current max.
55	func ErrCsvDelayTooLarge(remoteDelay, maxDelay uint16) ReservationError {	1✔
56	return ReservationError{	1✔
57	fmt.Errorf("CSV delay too large: %v, max is %v",	1✔
58	remoteDelay, maxDelay),	1✔
59	}	1✔
60	}	1✔
61
62	// ErrChanReserveTooSmall returns an error indicating that the channel reserve
63	// the remote is requiring is too small to be accepted.
64	func ErrChanReserveTooSmall(reserve, dustLimit btcutil.Amount) ReservationError {	1✔
65	return ReservationError{	1✔
66	fmt.Errorf("channel reserve of %v sat is too small, min is %v "+	1✔
67	"sat", int64(reserve), int64(dustLimit)),	1✔
68	}	1✔
69	}	1✔
70
71	// ErrChanReserveTooLarge returns an error indicating that the chan reserve the
72	// remote is requiring, is too large to be accepted.
73	func ErrChanReserveTooLarge(reserve,
74	maxReserve btcutil.Amount) ReservationError {	1✔
75	return ReservationError{	1✔
76	fmt.Errorf("channel reserve is too large: %v sat, max "+	1✔
77	"is %v sat", int64(reserve), int64(maxReserve)),	1✔
78	}	1✔
79	}	1✔
80
81	// ErrNonZeroPushAmount is returned by a remote peer that receives a
82	// FundingOpen request for a channel with non-zero push amount while
83	// they have 'rejectpush' enabled.
84	func ErrNonZeroPushAmount() ReservationError {	1✔
85	return ReservationError{errors.New("non-zero push amounts are disabled")}	1✔
86	}	1✔
87
88	// ErrMinHtlcTooLarge returns an error indicating that the MinHTLC value the
89	// remote required is too large to be accepted.
90	func ErrMinHtlcTooLarge(minHtlc,
91	maxMinHtlc lnwire.MilliSatoshi) ReservationError {	×
92	return ReservationError{	×
93	fmt.Errorf("minimum HTLC value is too large: %v, max is %v",	×
94	minHtlc, maxMinHtlc),	×
95	}	×
96	}	×
97
98	// ErrMaxHtlcNumTooLarge returns an error indicating that the 'max HTLCs in
99	// flight' value the remote required is too large to be accepted.
100	func ErrMaxHtlcNumTooLarge(maxHtlc, maxMaxHtlc uint16) ReservationError {	×
101	return ReservationError{	×
102	fmt.Errorf("maxHtlcs is too large: %d, max is %d",	×
103	maxHtlc, maxMaxHtlc),	×
104	}	×
105	}	×
106
107	// ErrMaxHtlcNumTooSmall returns an error indicating that the 'max HTLCs in
108	// flight' value the remote required is too small to be accepted.
109	func ErrMaxHtlcNumTooSmall(maxHtlc, minMaxHtlc uint16) ReservationError {	×
110	return ReservationError{	×
111	fmt.Errorf("maxHtlcs is too small: %d, min is %d",	×
112	maxHtlc, minMaxHtlc),	×
113	}	×
114	}	×
115
116	// ErrMaxValueInFlightTooSmall returns an error indicating that the 'max HTLC
117	// value in flight' the remote required is too small to be accepted.
118	func ErrMaxValueInFlightTooSmall(maxValInFlight,
119	minMaxValInFlight lnwire.MilliSatoshi) ReservationError {	×
120	return ReservationError{	×
121	fmt.Errorf("maxValueInFlight too small: %v, min is %v",	×
122	maxValInFlight, minMaxValInFlight),	×
123	}	×
124	}	×
125
126	// ErrNumConfsTooLarge returns an error indicating that the number of
127	// confirmations required for a channel is too large.
128	func ErrNumConfsTooLarge(numConfs, maxNumConfs uint32) error {	1✔
129	return ReservationError{	1✔
130	fmt.Errorf("minimum depth of %d is too large, max is %d",	1✔
131	numConfs, maxNumConfs),	1✔
132	}	1✔
133	}	1✔
134
135	// ErrChanTooSmall returns an error indicating that an incoming channel request
136	// was too small. We'll reject any incoming channels if they're below our
137	// configured value for the min channel size we'll accept.
138	func ErrChanTooSmall(chanSize, minChanSize btcutil.Amount) ReservationError {	×
139	return ReservationError{	×
140	fmt.Errorf("chan size of %v is below min chan size of %v",	×
141	chanSize, minChanSize),	×
142	}	×
143	}	×
144
145	// ErrChanTooLarge returns an error indicating that an incoming channel request
146	// was too large. We'll reject any incoming channels if they're above our
147	// configured value for the max channel size we'll accept.
148	func ErrChanTooLarge(chanSize, maxChanSize btcutil.Amount) ReservationError {	2✔
149	return ReservationError{	2✔
150	fmt.Errorf("chan size of %v exceeds maximum chan size of %v",	2✔
151	chanSize, maxChanSize),	2✔
152	}	2✔
153	}	2✔
154
155	// ErrInvalidDustLimit returns an error indicating that a proposed DustLimit
156	// was rejected.
157	func ErrInvalidDustLimit(dustLimit btcutil.Amount) ReservationError {	×
158	return ReservationError{	×
159	fmt.Errorf("dust limit %v is invalid", dustLimit),	×
160	}	×
161	}	×
162
163	// ErrHtlcIndexAlreadyFailed is returned when the HTLC index has already been
164	// failed, but has not been committed by our commitment state.
165	type ErrHtlcIndexAlreadyFailed uint64
166
167	// Error returns a message indicating the index that had already been failed.
168	func (e ErrHtlcIndexAlreadyFailed) Error() string {	×
169	return fmt.Sprintf("HTLC with ID %d has already been failed", e)	×
170	}	×
171
172	// ErrHtlcIndexAlreadySettled is returned when the HTLC index has already been
173	// settled, but has not been committed by our commitment state.
174	type ErrHtlcIndexAlreadySettled uint64
175
176	// Error returns a message indicating the index that had already been settled.
177	func (e ErrHtlcIndexAlreadySettled) Error() string {	×
178	return fmt.Sprintf("HTLC with ID %d has already been settled", e)	×
179	}	×
180
181	// ErrInvalidSettlePreimage is returned when trying to settle an HTLC, but the
182	// preimage does not correspond to the payment hash.
183	type ErrInvalidSettlePreimage struct {
184	preimage []byte
185	rhash []byte
186	}
187
188	// Error returns an error message with the offending preimage and intended
189	// payment hash.
190	func (e ErrInvalidSettlePreimage) Error() string {	×
191	return fmt.Sprintf("Invalid payment preimage %x for hash %x",	×
192	e.preimage, e.rhash)	×
193	}	×
194
195	// ErrUnknownHtlcIndex is returned when locally settling or failing an HTLC, but
196	// the HTLC index is not known to the channel. This typically indicates that the
197	// HTLC was already settled in a prior commitment.
198	type ErrUnknownHtlcIndex struct {
199	chanID lnwire.ShortChannelID
200	index uint64
201	}
202
203	// Error returns an error logging the channel and HTLC index that was unknown.
204	func (e ErrUnknownHtlcIndex) Error() string {	×
205	return fmt.Sprintf("No HTLC with ID %d in channel %v",	×
206	e.index, e.chanID)	×
207	}	×

lightningnetwork / lnd / 12313002221

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