15736109134

Committed 18 Jun 2025 02:46PM UTC coverage: 58.197% (-10.1%) from 68.248%

Build # 15736109134

Build Type

Pull #9752

github

Committed by

web-flow

Commit Message

Merge d2634a68c into 31c74f20f

Pull Request Pull Request #9752: routerrpc: reject payment to invoice that don't have payment secret or blinded paths

Run Details

6 of 13 new or added lines in 2 files covered. (46.15%)

28331 existing lines in 455 files now uncovered.

97860 of 168153 relevant lines covered (58.2%)

1.81 hits per line

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

0.0

/channeldb/migration_01_to_11/codec.go

package migration_01_to_11

import (
        "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"
        lnwire "github.com/lightningnetwork/lnd/channeldb/migration/lnwire21"
        "github.com/lightningnetwork/lnd/keychain"
        "github.com/lightningnetwork/lnd/shachain"
)

// 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{}
}

// 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:
                if err := binary.Write(w, byteOrder, e); 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:
                if _, err := lnwire.WriteMessage(w, e, 0); err != nil {
                        return err
                }

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

        case ClosureType:
                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:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        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:
                msg, err := lnwire.ReadMessage(r, 0)
                if err != nil {
                        return err
                }

                *e = msg

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

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

lightningnetwork / lnd / 15736109134

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