13536249039

Committed 26 Feb 2025 03:42AM UTC coverage: 57.462% (-1.4%) from 58.835%

Build # 13536249039

Build Type

Pull #8453

github

Committed by

Roasbeef

Commit Message

peer: update chooseDeliveryScript to gen script if needed

In this commit, we update `chooseDeliveryScript` to generate a new
script if needed. This allows us to fold in a few other lines that
always followed this function into this expanded function.

The tests have been updated accordingly.

Pull Request Pull Request #8453: [4/4] - multi: integrate new rbf coop close FSM into the existing peer flow

Run Details

275 of 1318 new or added lines in 22 files covered. (20.86%)

19521 existing lines in 257 files now uncovered.

103858 of 180741 relevant lines covered (57.46%)

24750.23 hits per line

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

0.0

/htlcswitch/linkfailure.go

package htlcswitch

import "github.com/go-errors/errors"

var (
        // ErrLinkShuttingDown signals that the link is shutting down.
        ErrLinkShuttingDown = errors.New("link shutting down")

        // ErrLinkFailedShutdown signals that a requested shutdown failed.
        ErrLinkFailedShutdown = errors.New("link failed to shutdown")
)

// errorCode encodes the possible types of errors that will make us fail the
// current link.
type errorCode uint8

const (
        // ErrInternalError indicates that something internal in the link
        // failed. In this case we will send a generic error to our peer.
        ErrInternalError errorCode = iota

        // ErrRemoteError indicates that our peer sent an error, prompting up
        // to fail the link.
        ErrRemoteError

        // ErrRemoteUnresponsive indicates that our peer took too long to
        // complete a commitment dance.
        ErrRemoteUnresponsive

        // ErrSyncError indicates that we failed synchronizing the state of the
        // channel with our peer.
        ErrSyncError

        // ErrInvalidUpdate indicates that the peer send us an invalid update.
        ErrInvalidUpdate

        // ErrInvalidCommitment indicates that the remote peer sent us an
        // invalid commitment signature.
        ErrInvalidCommitment

        // ErrInvalidRevocation indicates that the remote peer send us an
        // invalid revocation message.
        ErrInvalidRevocation

        // ErrRecoveryError the channel was unable to be resumed, we need the
        // remote party to force close the channel out on chain now as a
        // result.
        ErrRecoveryError

        // ErrCircuitError indicates a duplicate keystone error was hit in the
        // circuit map. This is non-fatal and will resolve itself (usually
        // within several minutes).
        ErrCircuitError

        // ErrStfuViolation indicates that the quiescence protocol has been
        // violated, either because Stfu has been sent/received at an invalid
        // time, or that an update has been sent/received while the channel is
        // quiesced.
        ErrStfuViolation
)

// LinkFailureAction is an enum-like type that describes the action that should
// be taken in response to a link failure.
type LinkFailureAction uint8

const (
        // LinkFailureForceNone indicates no action is to be taken.
        LinkFailureForceNone LinkFailureAction = iota

        // LinkFailureForceClose indicates that the channel should be force
        // closed.
        LinkFailureForceClose

        // LinkFailureDisconnect indicates that we should disconnect in an
        // attempt to recycle the connection. This can be useful if we think a
        // TCP connection or state machine is stalled.
        LinkFailureDisconnect
)

// LinkFailureError encapsulates an error that will make us fail the current
// link. It contains the necessary information needed to determine if we should
// force close the channel in the process, and if any error data should be sent
// to the peer.
type LinkFailureError struct {
        // code is the type of error this LinkFailureError encapsulates.
        code errorCode

        // FailureAction describes what we should do to fail the channel.
        FailureAction LinkFailureAction

        // PermanentFailure indicates whether this failure is permanent, and
        // the channel should not be attempted loaded again.
        PermanentFailure bool

        // Warning denotes if this is a non-terminal error that doesn't warrant
        // failing the channel all together.
        Warning bool

        // SendData is a byte slice that will be sent to the peer. If nil a
        // generic error will be sent.
        SendData []byte
}

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

// Error returns a generic error for the LinkFailureError.
//
// NOTE: Part of the error interface.
func (e LinkFailureError) Error() string {
        switch e.code {
        case ErrInternalError:
                return "internal error"
        case ErrRemoteError:
                return "remote error"
        case ErrRemoteUnresponsive:
                return "remote unresponsive"
        case ErrSyncError:
                return "sync error"
        case ErrInvalidUpdate:
                return "invalid update"
        case ErrInvalidCommitment:
                return "invalid commitment"
        case ErrInvalidRevocation:
                return "invalid revocation"
        case ErrRecoveryError:
                return "unable to resume channel, recovery required"
        case ErrCircuitError:
                return "non-fatal circuit map error"
        case ErrStfuViolation:
                return "quiescence protocol executed improperly"
        default:
                return "unknown error"
        }
}

// ShouldSendToPeer indicates whether we should send an error to the peer if
// the link fails with this LinkFailureError.
func (e LinkFailureError) ShouldSendToPeer() bool {
        switch e.code {

        // Since sending an error can lead some nodes to force close the
        // channel, create a whitelist of the failures we want to send so that
        // newly added error codes aren't automatically sent to the remote peer.
        case
                ErrInternalError,
                ErrRemoteError,
                ErrSyncError,
                ErrInvalidUpdate,
                ErrInvalidCommitment,
                ErrInvalidRevocation,
                ErrRecoveryError:

                return true

        // In all other cases we will not attempt to send our peer an error.
        default:
                return false
        }
}

1	package htlcswitch
2
3	import "github.com/go-errors/errors"
4
5	var (
6	// ErrLinkShuttingDown signals that the link is shutting down.
7	ErrLinkShuttingDown = errors.New("link shutting down")
8
9	// ErrLinkFailedShutdown signals that a requested shutdown failed.
10	ErrLinkFailedShutdown = errors.New("link failed to shutdown")
11	)
12
13	// errorCode encodes the possible types of errors that will make us fail the
14	// current link.
15	type errorCode uint8
16
17	const (
18	// ErrInternalError indicates that something internal in the link
19	// failed. In this case we will send a generic error to our peer.
20	ErrInternalError errorCode = iota
21
22	// ErrRemoteError indicates that our peer sent an error, prompting up
23	// to fail the link.
24	ErrRemoteError
25
26	// ErrRemoteUnresponsive indicates that our peer took too long to
27	// complete a commitment dance.
28	ErrRemoteUnresponsive
29
30	// ErrSyncError indicates that we failed synchronizing the state of the
31	// channel with our peer.
32	ErrSyncError
33
34	// ErrInvalidUpdate indicates that the peer send us an invalid update.
35	ErrInvalidUpdate
36
37	// ErrInvalidCommitment indicates that the remote peer sent us an
38	// invalid commitment signature.
39	ErrInvalidCommitment
40
41	// ErrInvalidRevocation indicates that the remote peer send us an
42	// invalid revocation message.
43	ErrInvalidRevocation
44
45	// ErrRecoveryError the channel was unable to be resumed, we need the
46	// remote party to force close the channel out on chain now as a
47	// result.
48	ErrRecoveryError
49
50	// ErrCircuitError indicates a duplicate keystone error was hit in the
51	// circuit map. This is non-fatal and will resolve itself (usually
52	// within several minutes).
53	ErrCircuitError
54
55	// ErrStfuViolation indicates that the quiescence protocol has been
56	// violated, either because Stfu has been sent/received at an invalid
57	// time, or that an update has been sent/received while the channel is
58	// quiesced.
59	ErrStfuViolation
60	)
61
62	// LinkFailureAction is an enum-like type that describes the action that should
63	// be taken in response to a link failure.
64	type LinkFailureAction uint8
65
66	const (
67	// LinkFailureForceNone indicates no action is to be taken.
68	LinkFailureForceNone LinkFailureAction = iota
69
70	// LinkFailureForceClose indicates that the channel should be force
71	// closed.
72	LinkFailureForceClose
73
74	// LinkFailureDisconnect indicates that we should disconnect in an
75	// attempt to recycle the connection. This can be useful if we think a
76	// TCP connection or state machine is stalled.
77	LinkFailureDisconnect
78	)
79
80	// LinkFailureError encapsulates an error that will make us fail the current
81	// link. It contains the necessary information needed to determine if we should
82	// force close the channel in the process, and if any error data should be sent
83	// to the peer.
84	type LinkFailureError struct {
85	// code is the type of error this LinkFailureError encapsulates.
86	code errorCode
87
88	// FailureAction describes what we should do to fail the channel.
89	FailureAction LinkFailureAction
90
91	// PermanentFailure indicates whether this failure is permanent, and
92	// the channel should not be attempted loaded again.
93	PermanentFailure bool
94
95	// Warning denotes if this is a non-terminal error that doesn't warrant
96	// failing the channel all together.
97	Warning bool
98
99	// SendData is a byte slice that will be sent to the peer. If nil a
100	// generic error will be sent.
101	SendData []byte
102	}
103
104	// A compile time check to ensure LinkFailureError implements the error
105	// interface.
106	var _ error = (*LinkFailureError)(nil)
107
108	// Error returns a generic error for the LinkFailureError.
109	//
110	// NOTE: Part of the error interface.
UNCOV 111	func (e LinkFailureError) Error() string {	×
UNCOV 112	switch e.code {	×
UNCOV 113	case ErrInternalError:	×
UNCOV 114	return "internal error"	×
UNCOV 115	case ErrRemoteError:	×
UNCOV 116	return "remote error"	×
117	case ErrRemoteUnresponsive:	×
118	return "remote unresponsive"	×
UNCOV 119	case ErrSyncError:	×
UNCOV 120	return "sync error"	×
UNCOV 121	case ErrInvalidUpdate:	×
UNCOV 122	return "invalid update"	×
123	case ErrInvalidCommitment:	×
124	return "invalid commitment"	×
125	case ErrInvalidRevocation:	×
126	return "invalid revocation"	×
UNCOV 127	case ErrRecoveryError:	×
UNCOV 128	return "unable to resume channel, recovery required"	×
129	case ErrCircuitError:	×
130	return "non-fatal circuit map error"	×
131	case ErrStfuViolation:	×
132	return "quiescence protocol executed improperly"	×
133	default:	×
134	return "unknown error"	×
135	}
136	}
137
138	// ShouldSendToPeer indicates whether we should send an error to the peer if
139	// the link fails with this LinkFailureError.
UNCOV 140	func (e LinkFailureError) ShouldSendToPeer() bool {	×
UNCOV 141	switch e.code {	×
142
143	// Since sending an error can lead some nodes to force close the
144	// channel, create a whitelist of the failures we want to send so that
145	// newly added error codes aren't automatically sent to the remote peer.
146	case
147	ErrInternalError,
148	ErrRemoteError,
149	ErrSyncError,
150	ErrInvalidUpdate,
151	ErrInvalidCommitment,
152	ErrInvalidRevocation,
UNCOV 153	ErrRecoveryError:	×
UNCOV 154		×
UNCOV 155	return true	×
156
157	// In all other cases we will not attempt to send our peer an error.
158	default:	×
159	return false	×
160	}
161	}

lightningnetwork / lnd / 13536249039

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