16982438758

Committed 15 Aug 2025 03:47AM UTC coverage: 66.748% (-0.03%) from 66.776%

Build # 16982438758

Build Type

Pull #9455

github

Committed by

web-flow

Commit Message

Merge 9a33d5e7b into 31fc55650

Pull Request Pull Request #9455: [1/2] discovery+lnwire: add support for DNS host name in NodeAnnouncement msg

Run Details

209 of 304 new or added lines in 8 files covered. (68.75%)

1268 existing lines in 30 files now uncovered.

136026 of 203789 relevant lines covered (66.75%)

21540.12 hits per line

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

58.84

/channeldb/codec.go

package channeldb

import (
        "bytes"
        "encoding/binary"
        "fmt"
        "io"
        "net"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/btcsuite/btcd/wire"
        graphdb "github.com/lightningnetwork/lnd/graph/db"
        "github.com/lightningnetwork/lnd/keychain"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/shachain"
        "github.com/lightningnetwork/lnd/tlv"
)

// UnknownElementType is an error returned when the codec is unable to encode or
// decode a particular type.
type UnknownElementType struct {
        method  string
        element interface{}
}

// NewUnknownElementType creates a new UnknownElementType error from the passed
// method name and element.
func NewUnknownElementType(method string, el interface{}) UnknownElementType {
        return UnknownElementType{method: method, element: el}
}

// Error returns the name of the method that encountered the error, as well as
// the type that was unsupported.
func (e UnknownElementType) Error() string {
        return fmt.Sprintf("Unknown type in %s: %T", e.method, e.element)
}

// WriteElement is a one-stop shop to write the big endian representation of
// any element which is to be serialized for storage on disk. The passed
// io.Writer should be backed by an appropriately sized byte slice, or be able
// to dynamically expand to accommodate additional data.
func WriteElement(w io.Writer, element interface{}) error {
        switch e := element.(type) {
        case keychain.KeyDescriptor:
                if err := binary.Write(w, byteOrder, e.Family); err != nil {
                        return err
                }
                if err := binary.Write(w, byteOrder, e.Index); err != nil {
                        return err
                }

                if e.PubKey != nil {
                        if err := binary.Write(w, byteOrder, true); err != nil {
                                return fmt.Errorf("error writing serialized "+
                                        "element: %w", err)
                        }

                        return WriteElement(w, e.PubKey)
                }

                return binary.Write(w, byteOrder, false)
        case ChannelType:
                var buf [8]byte
                if err := tlv.WriteVarInt(w, uint64(e), &buf); err != nil {
                        return err
                }

        case chainhash.Hash:
                if _, err := w.Write(e[:]); err != nil {
                        return err
                }

        case wire.OutPoint:
                return graphdb.WriteOutpoint(w, &e)

        case lnwire.ShortChannelID:
                if err := binary.Write(w, byteOrder, e.ToUint64()); err != nil {
                        return err
                }

        case lnwire.ChannelID:
                if _, err := w.Write(e[:]); err != nil {
                        return err
                }

        case int64, uint64:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case uint32:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case int32:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case uint16:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case uint8:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case bool:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case btcutil.Amount:
                if err := binary.Write(w, byteOrder, uint64(e)); err != nil {
                        return err
                }

        case lnwire.MilliSatoshi:
                if err := binary.Write(w, byteOrder, uint64(e)); err != nil {
                        return err
                }

        case *btcec.PrivateKey:
                b := e.Serialize()
                if _, err := w.Write(b); err != nil {
                        return err
                }

        case *btcec.PublicKey:
                b := e.SerializeCompressed()
                if _, err := w.Write(b); err != nil {
                        return err
                }

        case shachain.Producer:
                return e.Encode(w)

        case shachain.Store:
                return e.Encode(w)

        case *wire.MsgTx:
                return e.Serialize(w)

        case [32]byte:
                if _, err := w.Write(e[:]); err != nil {
                        return err
                }

        case []byte:
                if err := wire.WriteVarBytes(w, 0, e); err != nil {
                        return err
                }

        case lnwire.Message:
                var msgBuf bytes.Buffer
                if _, err := lnwire.WriteMessage(&msgBuf, e, 0); err != nil {
                        return err
                }

                msgLen := uint16(len(msgBuf.Bytes()))
                if err := WriteElements(w, msgLen); err != nil {
                        return err
                }

                if _, err := w.Write(msgBuf.Bytes()); err != nil {
                        return err
                }

        case ChannelStatus:
                var buf [8]byte
                if err := tlv.WriteVarInt(w, uint64(e), &buf); err != nil {
                        return err
                }

        case ClosureType:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case paymentIndexType:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case lnwire.FundingFlag:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case net.Addr:
                if err := graphdb.SerializeAddr(w, e); err != nil {
                        return err
                }

        case []net.Addr:
                if err := WriteElement(w, uint32(len(e))); err != nil {
                        return err
                }

                for _, addr := range e {
                        if err := graphdb.SerializeAddr(w, addr); err != nil {
                                return err
                        }
                }

        default:
                return UnknownElementType{"WriteElement", e}
        }

        return nil
}

// WriteElements is writes each element in the elements slice to the passed
// io.Writer using WriteElement.
func WriteElements(w io.Writer, elements ...interface{}) error {
        for _, element := range elements {
                err := WriteElement(w, element)
                if err != nil {
                        return err
                }
        }
        return nil
}

// ReadElement is a one-stop utility function to deserialize any datastructure
// encoded using the serialization format of the database.
func ReadElement(r io.Reader, element interface{}) error {
        switch e := element.(type) {
        case *keychain.KeyDescriptor:
                if err := binary.Read(r, byteOrder, &e.Family); err != nil {
                        return err
                }
                if err := binary.Read(r, byteOrder, &e.Index); err != nil {
                        return err
                }

                var hasPubKey bool
                if err := binary.Read(r, byteOrder, &hasPubKey); err != nil {
                        return err
                }

                if hasPubKey {
                        return ReadElement(r, &e.PubKey)
                }

        case *ChannelType:
                var buf [8]byte
                ctype, err := tlv.ReadVarInt(r, &buf)
                if err != nil {
                        return err
                }

                *e = ChannelType(ctype)

        case *chainhash.Hash:
                if _, err := io.ReadFull(r, e[:]); err != nil {
                        return err
                }

        case *wire.OutPoint:
                return graphdb.ReadOutpoint(r, e)

        case *lnwire.ShortChannelID:
                var a uint64
                if err := binary.Read(r, byteOrder, &a); err != nil {
                        return err
                }
                *e = lnwire.NewShortChanIDFromInt(a)

        case *lnwire.ChannelID:
                if _, err := io.ReadFull(r, e[:]); err != nil {
                        return err
                }

        case *int64, *uint64:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *uint32:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *int32:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *uint16:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *uint8:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *bool:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *btcutil.Amount:
                var a uint64
                if err := binary.Read(r, byteOrder, &a); err != nil {
                        return err
                }

                *e = btcutil.Amount(a)

        case *lnwire.MilliSatoshi:
                var a uint64
                if err := binary.Read(r, byteOrder, &a); err != nil {
                        return err
                }

                *e = lnwire.MilliSatoshi(a)

        case **btcec.PrivateKey:
                var b [btcec.PrivKeyBytesLen]byte
                if _, err := io.ReadFull(r, b[:]); err != nil {
                        return err
                }

                priv, _ := btcec.PrivKeyFromBytes(b[:])
                *e = priv

        case **btcec.PublicKey:
                var b [btcec.PubKeyBytesLenCompressed]byte
                if _, err := io.ReadFull(r, b[:]); err != nil {
                        return err
                }

                pubKey, err := btcec.ParsePubKey(b[:])
                if err != nil {
                        return err
                }
                *e = pubKey

        case *shachain.Producer:
                var root [32]byte
                if _, err := io.ReadFull(r, root[:]); err != nil {
                        return err
                }

                // TODO(roasbeef): remove
                producer, err := shachain.NewRevocationProducerFromBytes(root[:])
                if err != nil {
                        return err
                }

                *e = producer

        case *shachain.Store:
                store, err := shachain.NewRevocationStoreFromBytes(r)
                if err != nil {
                        return err
                }

                *e = store

        case **wire.MsgTx:
                tx := wire.NewMsgTx(2)
                if err := tx.Deserialize(r); err != nil {
                        return err
                }

                *e = tx

        case *[32]byte:
                if _, err := io.ReadFull(r, e[:]); err != nil {
                        return err
                }

        case *[]byte:
                bytes, err := wire.ReadVarBytes(r, 0, 66000, "[]byte")
                if err != nil {
                        return err
                }

                *e = bytes

        case *lnwire.Message:
                var msgLen uint16
                if err := ReadElement(r, &msgLen); err != nil {
                        return err
                }

                msgReader := io.LimitReader(r, int64(msgLen))
                msg, err := lnwire.ReadMessage(msgReader, 0)
                if err != nil {
                        return err
                }

                *e = msg

        case *ChannelStatus:
                var buf [8]byte
                status, err := tlv.ReadVarInt(r, &buf)
                if err != nil {
                        return err
                }

                *e = ChannelStatus(status)

        case *ClosureType:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *paymentIndexType:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *lnwire.FundingFlag:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *net.Addr:
                addr, err := graphdb.DeserializeAddr(r)
                if err != nil {
                        return err
                }
                *e = addr

        case *[]net.Addr:
                var numAddrs uint32
                if err := ReadElement(r, &numAddrs); err != nil {
                        return err
                }

                *e = make([]net.Addr, numAddrs)
                for i := uint32(0); i < numAddrs; i++ {
                        addr, err := graphdb.DeserializeAddr(r)
                        if err != nil {
                                return err
                        }
                        (*e)[i] = addr
                }

        default:
                return UnknownElementType{"ReadElement", e}
        }

        return nil
}

// ReadElements deserializes a variable number of elements into the passed
// io.Reader, with each element being deserialized according to the ReadElement
// function.
func ReadElements(r io.Reader, elements ...interface{}) error {
        for _, element := range elements {
                err := ReadElement(r, element)
                if err != nil {
                        return err
                }
        }
        return nil
}

1	package channeldb
2
3	import (
4	"bytes"
5	"encoding/binary"
6	"fmt"
7	"io"
8	"net"
9
10	"github.com/btcsuite/btcd/btcec/v2"
11	"github.com/btcsuite/btcd/btcutil"
12	"github.com/btcsuite/btcd/chaincfg/chainhash"
13	"github.com/btcsuite/btcd/wire"
14	graphdb "github.com/lightningnetwork/lnd/graph/db"
15	"github.com/lightningnetwork/lnd/keychain"
16	"github.com/lightningnetwork/lnd/lnwire"
17	"github.com/lightningnetwork/lnd/shachain"
18	"github.com/lightningnetwork/lnd/tlv"
19	)
20
21	// UnknownElementType is an error returned when the codec is unable to encode or
22	// decode a particular type.
23	type UnknownElementType struct {
24	method string
25	element interface{}
26	}
27
28	// NewUnknownElementType creates a new UnknownElementType error from the passed
29	// method name and element.
30	func NewUnknownElementType(method string, el interface{}) UnknownElementType {
31	return UnknownElementType{method: method, element: el}	×
32	}	×
UNCOV 33		×
34	// Error returns the name of the method that encountered the error, as well as
35	// the type that was unsupported.
36	func (e UnknownElementType) Error() string {
37	return fmt.Sprintf("Unknown type in %s: %T", e.method, e.element)	×
38	}	×
UNCOV 39		×
40	// WriteElement is a one-stop shop to write the big endian representation of
41	// any element which is to be serialized for storage on disk. The passed
42	// io.Writer should be backed by an appropriately sized byte slice, or be able
43	// to dynamically expand to accommodate additional data.
44	func WriteElement(w io.Writer, element interface{}) error {
45	switch e := element.(type) {	1,007,220✔
46	case keychain.KeyDescriptor:	1,007,220✔
47	if err := binary.Write(w, byteOrder, e.Family); err != nil {	34,043✔
48	return err	34,043✔
49	}	×
UNCOV 50	if err := binary.Write(w, byteOrder, e.Index); err != nil {	×
51	return err	34,043✔
52	}	×
UNCOV 53		×
54	if e.PubKey != nil {
55	if err := binary.Write(w, byteOrder, true); err != nil {	68,076✔
56	return fmt.Errorf("error writing serialized "+	34,033✔
57	"element: %w", err)	×
58	}	×
UNCOV 59		×
60	return WriteElement(w, e.PubKey)
61	}	34,033✔
62
63	return binary.Write(w, byteOrder, false)
64	case ChannelType:	10✔
65	var buf [8]byte	3,346✔
66	if err := tlv.WriteVarInt(w, uint64(e), &buf); err != nil {	3,346✔
67	return err	3,346✔
68	}	×
UNCOV 69		×
70	case chainhash.Hash:
71	if _, err := w.Write(e[:]); err != nil {	4,531✔
72	return err	4,531✔
73	}	×
UNCOV 74		×
75	case wire.OutPoint:
76	return graphdb.WriteOutpoint(w, &e)	3,597✔
77		3,597✔
78	case lnwire.ShortChannelID:
79	if err := binary.Write(w, byteOrder, e.ToUint64()); err != nil {	4,737✔
80	return err	4,737✔
81	}	×
UNCOV 82		×
83	case lnwire.ChannelID:
84	if _, err := w.Write(e[:]); err != nil {	211,016✔
85	return err	211,016✔
86	}	×
UNCOV 87		×
88	case int64, uint64:
89	if err := binary.Write(w, byteOrder, e); err != nil {	320,715✔
90	return err	320,715✔
91	}	×
UNCOV 92		×
93	case uint32:
94	if err := binary.Write(w, byteOrder, e); err != nil {	37,432✔
95	return err	37,432✔
96	}	×
UNCOV 97		×
98	case int32:
99	if err := binary.Write(w, byteOrder, e); err != nil {	28,097✔
100	return err	28,097✔
101	}	×
UNCOV 102		×
103	case uint16:
104	if err := binary.Write(w, byteOrder, e); err != nil {	39,429✔
105	return err	39,429✔
106	}	×
UNCOV 107		×
108	case uint8:
109	if err := binary.Write(w, byteOrder, e); err != nil {	1,297✔
110	return err	1,297✔
111	}	×
UNCOV 112		×
113	case bool:
114	if err := binary.Write(w, byteOrder, e); err != nil {	40,171✔
115	return err	40,171✔
116	}	×
UNCOV 117		×
118	case btcutil.Amount:
119	if err := binary.Write(w, byteOrder, uint64(e)); err != nil {	34,943✔
120	return err	34,943✔
121	}	×
UNCOV 122		×
123	case lnwire.MilliSatoshi:
124	if err := binary.Write(w, byteOrder, uint64(e)); err != nil {	66,971✔
125	return err	66,971✔
126	}	×
UNCOV 127		×
128	case *btcec.PrivateKey:
129	b := e.Serialize()	1✔
130	if _, err := w.Write(b); err != nil {	1✔
131	return err	1✔
132	}	×
UNCOV 133		×
134	case *btcec.PublicKey:
135	b := e.SerializeCompressed()	45,059✔
136	if _, err := w.Write(b); err != nil {	45,059✔
137	return err	45,059✔
138	}	×
UNCOV 139		×
140	case shachain.Producer:
141	return e.Encode(w)	3,940✔
142		3,940✔
143	case shachain.Store:
144	return e.Encode(w)	3,940✔
145		3,940✔
146	case *wire.MsgTx:
147	return e.Serialize(w)	10,756✔
148		10,756✔
149	case [32]byte:
150	if _, err := w.Write(e[:]); err != nil {	28,172✔
151	return err	28,172✔
152	}	×
UNCOV 153		×
154	case []byte:
155	if err := wire.WriteVarBytes(w, 0, e); err != nil {	67,746✔
156	return err	67,746✔
157	}	×
UNCOV 158		×
159	case lnwire.Message:
160	var msgBuf bytes.Buffer	7,656✔
161	if _, err := lnwire.WriteMessage(&msgBuf, e, 0); err != nil {	7,656✔
162	return err	7,656✔
163	}	×
UNCOV 164		×
165	msgLen := uint16(len(msgBuf.Bytes()))
166	if err := WriteElements(w, msgLen); err != nil {	7,656✔
167	return err	7,656✔
168	}	×
UNCOV 169		×
170	if _, err := w.Write(msgBuf.Bytes()); err != nil {
171	return err	7,656✔
172	}	×
UNCOV 173		×
174	case ChannelStatus:
175	var buf [8]byte	3,346✔
176	if err := tlv.WriteVarInt(w, uint64(e), &buf); err != nil {	3,346✔
177	return err	3,346✔
178	}	×
UNCOV 179		×
180	case ClosureType:
181	if err := binary.Write(w, byteOrder, e); err != nil {	134✔
182	return err	134✔
183	}	×
UNCOV 184		×
185	case paymentIndexType:
186	if err := binary.Write(w, byteOrder, e); err != nil {	3,346✔
187	return err	3,346✔
188	}	×
UNCOV 189		×
190	case lnwire.FundingFlag:
UNCOV 191	if err := binary.Write(w, byteOrder, e); err != nil {	×
192	return err	×
193	}	×
UNCOV 194		×
195	case net.Addr:
196	if err := graphdb.SerializeAddr(w, e); err != nil {	206✔
197	return err	206✔
198	}	×
UNCOV 199		×
200	case []net.Addr:
201	if err := WriteElement(w, uint32(len(e))); err != nil {	718✔
202	return err	512✔
203	}	×
UNCOV 204		×
205	for _, addr := range e {
206	if err := graphdb.SerializeAddr(w, addr); err != nil {
207	return err	2,668✔
208	}	2,668✔
209	}
210
211	default:	948,294✔
212	return UnknownElementType{"WriteElement", e}
213	}
214
215	return nil
216	}	77,197✔
217		601,736✔
218	// WriteElements is writes each element in the elements slice to the passed	524,539✔
219	// io.Writer using WriteElement.	524,539✔
UNCOV 220	func WriteElements(w io.Writer, elements ...interface{}) error {	×
UNCOV 221	for _, element := range elements {	×
222	err := WriteElement(w, element)
223	if err != nil {	77,197✔
224	return err
225	}
226	}
227	return nil
228	}	1,643,618✔
229		1,643,618✔
230	// ReadElement is a one-stop utility function to deserialize any datastructure	75,133✔
231	// encoded using the serialization format of the database.	75,133✔
UNCOV 232	func ReadElement(r io.Reader, element interface{}) error {	×
UNCOV 233	switch e := element.(type) {	×
234	case *keychain.KeyDescriptor:	75,133✔
UNCOV 235	if err := binary.Read(r, byteOrder, &e.Family); err != nil {	×
236	return err	×
237	}
238	if err := binary.Read(r, byteOrder, &e.Index); err != nil {	75,133✔
239	return err	75,133✔
240	}	×
UNCOV 241		×
242	var hasPubKey bool
243	if err := binary.Read(r, byteOrder, &hasPubKey); err != nil {	150,246✔
244	return err	75,113✔
245	}	75,113✔
246
247	if hasPubKey {	7,455✔
248	return ReadElement(r, &e.PubKey)	7,455✔
249	}	7,455✔
250		7,455✔
UNCOV 251	case *ChannelType:	×
UNCOV 252	var buf [8]byte	×
253	ctype, err := tlv.ReadVarInt(r, &buf)
254	if err != nil {	7,455✔
255	return err
256	}	7,715✔
257		7,715✔
UNCOV 258	*e = ChannelType(ctype)	×
UNCOV 259		×
260	case *chainhash.Hash:
261	if _, err := io.ReadFull(r, e[:]); err != nil {	7,588✔
262	return err	7,588✔
263	}
264		8,709✔
265	case *wire.OutPoint:	8,709✔
266	return graphdb.ReadOutpoint(r, e)	8,709✔
UNCOV 267		×
UNCOV 268	case *lnwire.ShortChannelID:	×
269	var a uint64	8,709✔
270	if err := binary.Read(r, byteOrder, &a); err != nil {
271	return err	211,253✔
272	}	211,253✔
UNCOV 273	*e = lnwire.NewShortChanIDFromInt(a)	×
UNCOV 274		×
275	case *lnwire.ChannelID:
276	if _, err := io.ReadFull(r, e[:]); err != nil {	436,161✔
277	return err	436,171✔
278	}	10✔
279		10✔
280	case int64, uint64:
281	if err := binary.Read(r, byteOrder, e); err != nil {	81,528✔
282	return err	81,528✔
UNCOV 283	}	×
UNCOV 284		×
285	case *uint32:
286	if err := binary.Read(r, byteOrder, e); err != nil {	63,718✔
287	return err	63,718✔
288	}	×
UNCOV 289		×
290	case *int32:
291	if err := binary.Read(r, byteOrder, e); err != nil {	67,547✔
292	return err	67,547✔
293	}	×
UNCOV 294		×
295	case *uint16:
296	if err := binary.Read(r, byteOrder, e); err != nil {	1,832✔
297	return err	1,832✔
298	}	×
UNCOV 299		×
300	case *uint8:
301	if err := binary.Read(r, byteOrder, e); err != nil {	85,277✔
302	return err	85,277✔
303	}	×
UNCOV 304		×
305	case *bool:
306	if err := binary.Read(r, byteOrder, e); err != nil {	72,051✔
307	return err	72,051✔
308	}	72,051✔
UNCOV 309		×
UNCOV 310	case *btcutil.Amount:	×
311	var a uint64
312	if err := binary.Read(r, byteOrder, &a); err != nil {	72,051✔
313	return err
314	}	145,544✔
315		145,544✔
316	*e = btcutil.Amount(a)	145,544✔
UNCOV 317		×
UNCOV 318	case *lnwire.MilliSatoshi:	×
319	var a uint64
320	if err := binary.Read(r, byteOrder, &a); err != nil {	145,544✔
321	return err
322	}	×
UNCOV 323		×
UNCOV 324	*e = lnwire.MilliSatoshi(a)	×
UNCOV 325		×
326	case **btcec.PrivateKey:	×
327	var b [btcec.PrivKeyBytesLen]byte
328	if _, err := io.ReadFull(r, b[:]); err != nil {	×
329	return err	×
330	}
331		97,985✔
332	priv, _ := btcec.PrivKeyFromBytes(b[:])	97,985✔
333	*e = priv	97,985✔
UNCOV 334		×
UNCOV 335	case **btcec.PublicKey:	×
336	var b [btcec.PubKeyBytesLenCompressed]byte
337	if _, err := io.ReadFull(r, b[:]); err != nil {	97,985✔
338	return err	97,985✔
339	}	×
UNCOV 340		×
341	pubKey, err := btcec.ParsePubKey(b[:])	97,985✔
342	if err != nil {
343	return err	7,470✔
344	}	7,470✔
345	*e = pubKey	7,470✔
UNCOV 346		×
UNCOV 347	case *shachain.Producer:	×
348	var root [32]byte
349	if _, err := io.ReadFull(r, root[:]); err != nil {
350	return err	7,470✔
351	}	7,470✔
UNCOV 352		×
UNCOV 353	// TODO(roasbeef): remove	×
354	producer, err := shachain.NewRevocationProducerFromBytes(root[:])
355	if err != nil {	7,470✔
356	return err
357	}	7,470✔
358		7,470✔
359	*e = producer	7,470✔
UNCOV 360		×
UNCOV 361	case *shachain.Store:	×
362	store, err := shachain.NewRevocationStoreFromBytes(r)
363	if err != nil {	7,470✔
364	return err
365	}	21,052✔
366		21,052✔
367	*e = store	21,052✔
UNCOV 368		×
UNCOV 369	case **wire.MsgTx:	×
370	tx := wire.NewMsgTx(2)
371	if err := tx.Deserialize(r); err != nil {	21,052✔
372	return err
373	}	64,426✔
374		64,426✔
UNCOV 375	*e = tx	×
UNCOV 376		×
377	case *[32]byte:
378	if _, err := io.ReadFull(r, e[:]); err != nil {	149,526✔
379	return err	149,526✔
380	}	149,526✔
UNCOV 381		×
UNCOV 382	case *[]byte:	×
383	bytes, err := wire.ReadVarBytes(r, 0, 66000, "[]byte")
384	if err != nil {	149,526✔
385	return err
386	}	5,775✔
387		5,775✔
388	*e = bytes	5,775✔
UNCOV 389		×
UNCOV 390	case *lnwire.Message:	×
391	var msgLen uint16
392	if err := ReadElement(r, &msgLen); err != nil {	5,775✔
393	return err	5,775✔
394	}	5,775✔
UNCOV 395		×
UNCOV 396	msgReader := io.LimitReader(r, int64(msgLen))	×
397	msg, err := lnwire.ReadMessage(msgReader, 0)
398	if err != nil {	5,775✔
399	return err
400	}	7,455✔
401		7,455✔
402	*e = msg	7,455✔
403		7,455✔
UNCOV 404	case *ChannelStatus:	×
UNCOV 405	var buf [8]byte	×
406	status, err := tlv.ReadVarInt(r, &buf)
407	if err != nil {	7,455✔
408	return err
409	}	133✔
410		133✔
UNCOV 411	*e = ChannelStatus(status)	×
UNCOV 412		×
413	case *ClosureType:
414	if err := binary.Read(r, byteOrder, e); err != nil {	7,455✔
415	return err	7,455✔
416	}	×
UNCOV 417		×
418	case *paymentIndexType:
UNCOV 419	if err := binary.Read(r, byteOrder, e); err != nil {	×
420	return err	×
421	}	×
UNCOV 422		×
UNCOV 423	case *lnwire.FundingFlag:	×
UNCOV 424	if err := binary.Read(r, byteOrder, e); err != nil {	×
425	return err
426	}	316✔
427		316✔
428	case *net.Addr:	316✔
429	addr, err := graphdb.DeserializeAddr(r)	×
430	if err != nil {	×
431	return err
432	}	316✔
433	*e = addr	944✔
434		628✔
435	case *[]net.Addr:	628✔
UNCOV 436	var numAddrs uint32	×
UNCOV 437	if err := ReadElement(r, &numAddrs); err != nil {	×
438	return err	628✔
439	}
440
441	*e = make([]net.Addr, numAddrs)	3,119✔
442	for i := uint32(0); i < numAddrs; i++ {	3,119✔
443	addr, err := graphdb.DeserializeAddr(r)
444	if err != nil {
445	return err	1,557,797✔
446	}
447	(*e)[i] = addr
448	}
449
450	default:
451	return UnknownElementType{"ReadElement", e}	133,841✔
452	}	1,223,802✔
453		1,089,961✔
454	return nil	1,089,971✔
455	}	10✔
456		10✔
457	// ReadElements deserializes a variable number of elements into the passed
458	// io.Reader, with each element being deserialized according to the ReadElement	133,831✔
459	// function.
460	func ReadElements(r io.Reader, elements ...interface{}) error {
461	for _, element := range elements {
462	err := ReadElement(r, element)	5✔
463	if err != nil {	5✔
464	return err	5✔
UNCOV 465	}	×
UNCOV 466	}	×
467	return nil
468	}

lightningnetwork / lnd / 16982438758

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