12343072627

Committed 15 Dec 2024 11:09PM UTC coverage: 57.504% (-1.1%) from 58.636%

Build # 12343072627

Build Type

Pull #9315

github

Committed by

yyforyongyu

Commit Message

contractcourt: offer outgoing htlc one block earlier before its expiry

We need to offer the outgoing htlc one block earlier to make sure when
the expiry height hits, the sweeper will not miss sweeping it in the
same block. This also means the outgoing contest resolver now only does
one thing - watch for preimage spend till height expiry-1, which can
easily be moved into the timeout resolver instead in the future.

Pull Request Pull Request #9315: Implement `blockbeat`

Run Details

1445 of 2007 new or added lines in 26 files covered. (72.0%)

19246 existing lines in 249 files now uncovered.

102342 of 177975 relevant lines covered (57.5%)

24772.24 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 / 12343072627

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