19080946931

Committed 04 Nov 2025 07:47PM UTC coverage: 66.65% (+0.009%) from 66.641%

Build # 19080946931

Build Type

Pull #10340

github

Committed by

web-flow

Commit Message

Merge c364eae9c into 4131a8e58

Pull Request Pull Request #10340: graph: fix zombie chan pruning

Run Details

9 of 25 new or added lines in 1 file covered. (36.0%)

291 existing lines in 18 files now uncovered.

137293 of 205990 relevant lines covered (66.65%)

21217.79 hits per line

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

67.44

/lnwire/error.go

package lnwire

import (
        "bytes"
        "fmt"
        "io"
)

var (
        // ErrParsingExtraTLVBytes is returned when we attempt to parse
        // extra opaque bytes as a TLV stream, but the parsing fails due to
        // and invalid TLV stream.
        ErrParsingExtraTLVBytes = fmt.Errorf("error parsing extra TLV bytes")
)

// FundingError represents a set of errors that can be encountered and sent
// during the funding workflow.
type FundingError uint8

const (
        // ErrMaxPendingChannels is returned by remote peer when the number of
        // active pending channels exceeds their maximum policy limit.
        ErrMaxPendingChannels FundingError = 1

        // ErrChanTooLarge is returned by a remote peer that receives a
        // FundingOpen request for a channel that is above their current
        // soft-limit.
        ErrChanTooLarge FundingError = 2
)

// String returns a human readable version of the target FundingError.
func (e FundingError) String() string {
        switch e {
        case ErrMaxPendingChannels:
                return "Number of pending channels exceed maximum"
        case ErrChanTooLarge:
                return "channel too large"
        default:
                return "unknown error"
        }
}

// Error returns the human readable version of the target FundingError.
//
// NOTE: Satisfies the Error interface.
func (e FundingError) Error() string {
        return e.String()
}

// ErrorData is a set of bytes associated with a particular sent error. A
// receiving node SHOULD only print out data verbatim if the string is composed
// solely of printable ASCII characters. For reference, the printable character
// set includes byte values 32 through 127 inclusive.
type ErrorData []byte

// Error represents a generic error bound to an exact channel. The message
// format is purposefully general in order to allow expression of a wide array
// of possible errors. Each Error message is directed at a particular open
// channel referenced by ChannelPoint.
type Error struct {
        // ChanID references the active channel in which the error occurred
        // within. If the ChanID is all zeros, then this error applies to the
        // entire established connection.
        ChanID ChannelID

        // Data is the attached error data that describes the exact failure
        // which caused the error message to be sent.
        Data ErrorData
}

// NewError creates a new Error message.
func NewError() *Error {
        return &Error{}
}

// A compile time check to ensure Error implements the lnwire.Message
// interface.
var _ Message = (*Error)(nil)

// A compile time check to ensure Error implements the lnwire.SizeableMessage
// interface.
var _ SizeableMessage = (*Error)(nil)

// Error returns the string representation to Error.
//
// NOTE: Satisfies the error interface.
func (c *Error) Error() string {
        errMsg := "non-ascii data"
        if isASCII(c.Data) {
                errMsg = string(c.Data)
        }

        return fmt.Sprintf("chan_id=%v, err=%v", c.ChanID, errMsg)
}

// Decode deserializes a serialized Error message stored in the passed
// io.Reader observing the specified protocol version.
//
// This is part of the lnwire.Message interface.
func (c *Error) Decode(r io.Reader, pver uint32) error {
        return ReadElements(r,
                &c.ChanID,
                &c.Data,
        )
}

// Encode serializes the target Error into the passed io.Writer observing the
// protocol version specified.
//
// This is part of the lnwire.Message interface.
func (c *Error) Encode(w *bytes.Buffer, pver uint32) error {
        if err := WriteBytes(w, c.ChanID[:]); err != nil {
                return err
        }

        return WriteErrorData(w, c.Data)
}

// MsgType returns the integer uniquely identifying an Error message on the
// wire.
//
// This is part of the lnwire.Message interface.
func (c *Error) MsgType() MessageType {
        return MsgError
}

// SerializedSize returns the serialized size of the message in bytes.
//
// This is part of the lnwire.SizeableMessage interface.
func (c *Error) SerializedSize() (uint32, error) {
        return MessageSerializedSize(c)
}

// isASCII is a helper method that checks whether all bytes in `data` would be
// printable ASCII characters if interpreted as a string.
func isASCII(data []byte) bool {
        for _, c := range data {
                if c < 32 || c > 126 {
                        return false
                }
        }
        return true
}

1	package lnwire
2
3	import (
4	"bytes"
5	"fmt"
6	"io"
7	)
8
9	var (
10	// ErrParsingExtraTLVBytes is returned when we attempt to parse
11	// extra opaque bytes as a TLV stream, but the parsing fails due to
12	// and invalid TLV stream.
13	ErrParsingExtraTLVBytes = fmt.Errorf("error parsing extra TLV bytes")
14	)
15
16	// FundingError represents a set of errors that can be encountered and sent
17	// during the funding workflow.
18	type FundingError uint8
19
20	const (
21	// ErrMaxPendingChannels is returned by remote peer when the number of
22	// active pending channels exceeds their maximum policy limit.
23	ErrMaxPendingChannels FundingError = 1
24
25	// ErrChanTooLarge is returned by a remote peer that receives a
26	// FundingOpen request for a channel that is above their current
27	// soft-limit.
28	ErrChanTooLarge FundingError = 2
29	)
30
31	// String returns a human readable version of the target FundingError.
32	func (e FundingError) String() string {	7✔
33	switch e {	7✔
34	case ErrMaxPendingChannels:	7✔
35	return "Number of pending channels exceed maximum"	7✔
36	case ErrChanTooLarge:	×
37	return "channel too large"	×
38	default:	×
39	return "unknown error"	×
40	}
41	}
42
43	// Error returns the human readable version of the target FundingError.
44	//
45	// NOTE: Satisfies the Error interface.
46	func (e FundingError) Error() string {	7✔
47	return e.String()	7✔
48	}	7✔
49
50	// ErrorData is a set of bytes associated with a particular sent error. A
51	// receiving node SHOULD only print out data verbatim if the string is composed
52	// solely of printable ASCII characters. For reference, the printable character
53	// set includes byte values 32 through 127 inclusive.
54	type ErrorData []byte
55
56	// Error represents a generic error bound to an exact channel. The message
57	// format is purposefully general in order to allow expression of a wide array
58	// of possible errors. Each Error message is directed at a particular open
59	// channel referenced by ChannelPoint.
60	type Error struct {
61	// ChanID references the active channel in which the error occurred
62	// within. If the ChanID is all zeros, then this error applies to the
63	// entire established connection.
64	ChanID ChannelID
65
66	// Data is the attached error data that describes the exact failure
67	// which caused the error message to be sent.
68	Data ErrorData
69	}
70
71	// NewError creates a new Error message.
72	func NewError() *Error {	×
73	return &Error{}	×
74	}	×
75
76	// A compile time check to ensure Error implements the lnwire.Message
77	// interface.
78	var _ Message = (*Error)(nil)
79
80	// A compile time check to ensure Error implements the lnwire.SizeableMessage
81	// interface.
82	var _ SizeableMessage = (*Error)(nil)
83
84	// Error returns the string representation to Error.
85	//
86	// NOTE: Satisfies the error interface.
87	func (c *Error) Error() string {	38✔
88	errMsg := "non-ascii data"	38✔
89	if isASCII(c.Data) {	76✔
90	errMsg = string(c.Data)	38✔
91	}	38✔
92
93	return fmt.Sprintf("chan_id=%v, err=%v", c.ChanID, errMsg)	38✔
94	}
95
96	// Decode deserializes a serialized Error message stored in the passed
97	// io.Reader observing the specified protocol version.
98	//
99	// This is part of the lnwire.Message interface.
100	func (c *Error) Decode(r io.Reader, pver uint32) error {	116✔
101	return ReadElements(r,	116✔
102	&c.ChanID,	116✔
103	&c.Data,	116✔
104	)	116✔
105	}	116✔
106
107	// Encode serializes the target Error into the passed io.Writer observing the
108	// protocol version specified.
109	//
110	// This is part of the lnwire.Message interface.
111	func (c Error) Encode(w bytes.Buffer, pver uint32) error {	108✔
112	if err := WriteBytes(w, c.ChanID[:]); err != nil {	108✔
113	return err	×
114	}	×
115
116	return WriteErrorData(w, c.Data)	108✔
117	}
118
119	// MsgType returns the integer uniquely identifying an Error message on the
120	// wire.
121	//
122	// This is part of the lnwire.Message interface.
123	func (c *Error) MsgType() MessageType {	109✔
124	return MsgError	109✔
125	}	109✔
126
127	// SerializedSize returns the serialized size of the message in bytes.
128	//
129	// This is part of the lnwire.SizeableMessage interface.
UNCOV 130	func (c *Error) SerializedSize() (uint32, error) {	×
UNCOV 131	return MessageSerializedSize(c)	×
UNCOV 132	}	×
133
134	// isASCII is a helper method that checks whether all bytes in `data` would be
135	// printable ASCII characters if interpreted as a string.
136	func isASCII(data []byte) bool {	83✔
137	for _, c := range data {	829✔
138	if c < 32 \|\| c > 126 {	746✔
139	return false	×
140	}	×
141	}
142	return true	83✔
143	}

lightningnetwork / lnd / 19080946931

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