11170835610

Committed 03 Oct 2024 10:41PM UTC coverage: 49.188% (-9.6%) from 58.738%

Build # 11170835610

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9154 from ziggie1984/master

multi: bump btcd version.

Run Details

3 of 6 new or added lines in 6 files covered. (50.0%)

26110 existing lines in 428 files now uncovered.

97359 of 197934 relevant lines covered (49.19%)

1.04 hits per line

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

54.34

/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"
        "github.com/lightningnetwork/lnd/keychain"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/shachain"
        "github.com/lightningnetwork/lnd/tlv"
)

// writeOutpoint writes an outpoint to the passed writer using the minimal
// amount of bytes possible.
func writeOutpoint(w io.Writer, o *wire.OutPoint) error {
        if _, err := w.Write(o.Hash[:]); err != nil {
                return err
        }
        if err := binary.Write(w, byteOrder, o.Index); err != nil {
                return err
        }

        return nil
}

// readOutpoint reads an outpoint from the passed reader that was previously
// written using the writeOutpoint struct.
func readOutpoint(r io.Reader, o *wire.OutPoint) error {
        if _, err := io.ReadFull(r, o.Hash[:]); err != nil {
                return err
        }
        if err := binary.Read(r, byteOrder, &o.Index); err != nil {
                return err
        }

        return nil
}

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

lightningnetwork / lnd / 11170835610

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