15951470896

Committed 29 Jun 2025 04:23AM UTC coverage: 67.594% (-0.01%) from 67.606%

Build # 15951470896

Build Type

Pull #9751

github

Committed by

web-flow

Commit Message

Merge 599d9b051 into 6290edf14

Pull Request Pull Request #9751: multi: update Go to 1.23.10 and update some packages

Run Details

135088 of 199851 relevant lines covered (67.59%)

21909.44 hits per line

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

58.7

/watchtower/wtwire/wtwire.go

package wtwire

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

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/btcsuite/btcd/wire"
        "github.com/lightningnetwork/lnd/lnwallet/chainfee"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/watchtower/blob"
)

// WriteElement is a one-stop shop to write the big endian representation of
// any element which is to be serialized for the wire protocol. 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 uint8:
                var b [1]byte
                b[0] = e
                if _, err := w.Write(b[:]); err != nil {
                        return err
                }

        case uint16:
                var b [2]byte
                binary.BigEndian.PutUint16(b[:], e)
                if _, err := w.Write(b[:]); err != nil {
                        return err
                }

        case blob.Type:
                var b [2]byte
                binary.BigEndian.PutUint16(b[:], uint16(e))
                if _, err := w.Write(b[:]); err != nil {
                        return err
                }

        case uint32:
                var b [4]byte
                binary.BigEndian.PutUint32(b[:], e)
                if _, err := w.Write(b[:]); err != nil {
                        return err
                }

        case uint64:
                var b [8]byte
                binary.BigEndian.PutUint64(b[:], e)
                if _, err := w.Write(b[:]); err != nil {
                        return err
                }

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

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

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

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

        case chainfee.SatPerKWeight:
                var b [8]byte
                binary.BigEndian.PutUint64(b[:], uint64(e))
                if _, err := w.Write(b[:]); err != nil {
                        return err
                }

        case ErrorCode:
                var b [2]byte
                binary.BigEndian.PutUint16(b[:], uint16(e))
                if _, err := w.Write(b[:]); err != nil {
                        return err
                }

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

        case *lnwire.RawFeatureVector:
                if e == nil {
                        return fmt.Errorf("cannot write nil feature vector")
                }

                if err := e.Encode(w); err != nil {
                        return err
                }

        case *btcec.PublicKey:
                if e == nil {
                        return fmt.Errorf("cannot write nil pubkey")
                }

                var b [33]byte
                serializedPubkey := e.SerializeCompressed()
                copy(b[:], serializedPubkey)
                if _, err := w.Write(b[:]); err != nil {
                        return err
                }

        default:
                return fmt.Errorf("Unknown type in WriteElement: %T", 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 lnwire.
func ReadElement(r io.Reader, element interface{}) error {
        switch e := element.(type) {
        case *uint8:
                var b [1]uint8
                if _, err := r.Read(b[:]); err != nil {
                        return err
                }
                *e = b[0]

        case *uint16:
                var b [2]byte
                if _, err := io.ReadFull(r, b[:]); err != nil {
                        return err
                }
                *e = binary.BigEndian.Uint16(b[:])

        case *blob.Type:
                var b [2]byte
                if _, err := io.ReadFull(r, b[:]); err != nil {
                        return err
                }
                *e = blob.Type(binary.BigEndian.Uint16(b[:]))

        case *uint32:
                var b [4]byte
                if _, err := io.ReadFull(r, b[:]); err != nil {
                        return err
                }
                *e = binary.BigEndian.Uint32(b[:])

        case *uint64:
                var b [8]byte
                if _, err := io.ReadFull(r, b[:]); err != nil {
                        return err
                }
                *e = binary.BigEndian.Uint64(b[:])

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

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

        case *[33]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 *chainfee.SatPerKWeight:
                var b [8]byte
                if _, err := io.ReadFull(r, b[:]); err != nil {
                        return err
                }
                *e = chainfee.SatPerKWeight(binary.BigEndian.Uint64(b[:]))

        case *ErrorCode:
                var b [2]byte
                if _, err := io.ReadFull(r, b[:]); err != nil {
                        return err
                }
                *e = ErrorCode(binary.BigEndian.Uint16(b[:]))

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

        case **lnwire.RawFeatureVector:
                f := lnwire.NewRawFeatureVector()
                err := f.Decode(r)
                if err != nil {
                        return err
                }

                *e = f

        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

        default:
                return fmt.Errorf("Unknown type in ReadElement: %T", 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 wtwire
2
3	import (
4	"encoding/binary"
5	"fmt"
6	"io"
7
8	"github.com/btcsuite/btcd/btcec/v2"
9	"github.com/btcsuite/btcd/chaincfg/chainhash"
10	"github.com/btcsuite/btcd/wire"
11	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
12	"github.com/lightningnetwork/lnd/lnwire"
13	"github.com/lightningnetwork/lnd/watchtower/blob"
14	)
15
16	// WriteElement is a one-stop shop to write the big endian representation of
17	// any element which is to be serialized for the wire protocol. The passed
18	// io.Writer should be backed by an appropriately sized byte slice, or be able
19	// to dynamically expand to accommodate additional data.
20	func WriteElement(w io.Writer, element interface{}) error {	9,488✔
21	switch e := element.(type) {	9,488✔
22	case uint8:	822✔
23	var b [1]byte	822✔
24	b[0] = e	822✔
25	if _, err := w.Write(b[:]); err != nil {	822✔
26	return err	×
27	}	×
28
29	case uint16:	2,668✔
30	var b [2]byte	2,668✔
31	binary.BigEndian.PutUint16(b[:], e)	2,668✔
32	if _, err := w.Write(b[:]); err != nil {	2,668✔
33	return err	×
34	}	×
35
36	case blob.Type:	232✔
37	var b [2]byte	232✔
38	binary.BigEndian.PutUint16(b[:], uint16(e))	232✔
39	if _, err := w.Write(b[:]); err != nil {	232✔
40	return err	×
41	}	×
42
43	case uint32:	461✔
44	var b [4]byte	461✔
45	binary.BigEndian.PutUint32(b[:], e)	461✔
46	if _, err := w.Write(b[:]); err != nil {	461✔
47	return err	×
48	}	×
49
50	case uint64:	×
51	var b [8]byte	×
52	binary.BigEndian.PutUint64(b[:], e)	×
53	if _, err := w.Write(b[:]); err != nil {	×
54	return err	×
55	}	×
56
57	case [16]byte:	822✔
58	if _, err := w.Write(e[:]); err != nil {	822✔
59	return err	×
60	}	×
61
62	case [32]byte:	×
63	if _, err := w.Write(e[:]); err != nil {	×
64	return err	×
65	}	×
66
67	case [33]byte:	×
68	if _, err := w.Write(e[:]); err != nil {	×
69	return err	×
70	}	×
71
72	case []byte:	1,129✔
73	if err := wire.WriteVarBytes(w, 0, e); err != nil {	1,129✔
74	return err	×
75	}	×
76
77	case chainfee.SatPerKWeight:	232✔
78	var b [8]byte	232✔
79	binary.BigEndian.PutUint64(b[:], uint64(e))	232✔
80	if _, err := w.Write(b[:]); err != nil {	232✔
81	return err	×
82	}	×
83
84	case ErrorCode:	1,013✔
85	var b [2]byte	1,013✔
86	binary.BigEndian.PutUint16(b[:], uint16(e))	1,013✔
87	if _, err := w.Write(b[:]); err != nil {	1,013✔
88	return err	×
89	}	×
90
91	case chainhash.Hash:	1,068✔
92	if _, err := w.Write(e[:]); err != nil {	1,068✔
93	return err	×
94	}	×
95
96	case *lnwire.RawFeatureVector:	1,068✔
97	if e == nil {	1,068✔
98	return fmt.Errorf("cannot write nil feature vector")	×
99	}	×
100
101	if err := e.Encode(w); err != nil {	1,068✔
102	return err	×
103	}	×
104
105	case *btcec.PublicKey:	×
106	if e == nil {	×
107	return fmt.Errorf("cannot write nil pubkey")	×
108	}	×
109
110	var b [33]byte	×
111	serializedPubkey := e.SerializeCompressed()	×
112	copy(b[:], serializedPubkey)	×
113	if _, err := w.Write(b[:]); err != nil {	×
114	return err	×
115	}	×
116
117	default:	×
118	return fmt.Errorf("Unknown type in WriteElement: %T", e)	×
119	}
120
121	return nil	9,488✔
122	}
123
124	// WriteElements is writes each element in the elements slice to the passed
125	// io.Writer using WriteElement.
126	func WriteElements(w io.Writer, elements ...interface{}) error {	3,126✔
127	for _, element := range elements {	12,614✔
128	err := WriteElement(w, element)	9,488✔
129	if err != nil {	9,488✔
130	return err	×
131	}	×
132	}
133	return nil	3,126✔
134	}
135
136	// ReadElement is a one-stop utility function to deserialize any datastructure
137	// encoded using the serialization format of lnwire.
138	func ReadElement(r io.Reader, element interface{}) error {	9,764✔
139	switch e := element.(type) {	9,764✔
140	case *uint8:	842✔
141	var b [1]uint8	842✔
142	if _, err := r.Read(b[:]); err != nil {	843✔
143	return err	1✔
144	}	1✔
145	*e = b[0]	841✔
146
147	case *uint16:	2,737✔
148	var b [2]byte	2,737✔
149	if _, err := io.ReadFull(r, b[:]); err != nil {	2,743✔
150	return err	6✔
151	}	6✔
152	*e = binary.BigEndian.Uint16(b[:])	2,731✔
153
154	case *blob.Type:	239✔
155	var b [2]byte	239✔
156	if _, err := io.ReadFull(r, b[:]); err != nil {	240✔
157	return err	1✔
158	}	1✔
159	*e = blob.Type(binary.BigEndian.Uint16(b[:]))	238✔
160
161	case *uint32:	469✔
162	var b [4]byte	469✔
163	if _, err := io.ReadFull(r, b[:]); err != nil {	472✔
164	return err	3✔
165	}	3✔
166	*e = binary.BigEndian.Uint32(b[:])	466✔
167
168	case *uint64:	×
169	var b [8]byte	×
170	if _, err := io.ReadFull(r, b[:]); err != nil {	×
171	return err	×
172	}	×
173	*e = binary.BigEndian.Uint64(b[:])	×
174
175	case *[16]byte:	841✔
176	if _, err := io.ReadFull(r, e[:]); err != nil {	842✔
177	return err	1✔
178	}	1✔
179
180	case *[32]byte:	×
181	if _, err := io.ReadFull(r, e[:]); err != nil {	×
182	return err	×
183	}	×
184
185	case *[33]byte:	×
186	if _, err := io.ReadFull(r, e[:]); err != nil {	×
187	return err	×
188	}	×
189
190	case *[]byte:	1,182✔
191	bytes, err := wire.ReadVarBytes(r, 0, 66000, "[]byte")	1,182✔
192	if err != nil {	1,219✔
193	return err	37✔
194	}	37✔
195	*e = bytes	1,145✔
196
197	case *chainfee.SatPerKWeight:	234✔
198	var b [8]byte	234✔
199	if _, err := io.ReadFull(r, b[:]); err != nil {	235✔
200	return err	1✔
201	}	1✔
202	*e = chainfee.SatPerKWeight(binary.BigEndian.Uint64(b[:]))	233✔
203
204	case *ErrorCode:	1,059✔
205	var b [2]byte	1,059✔
206	if _, err := io.ReadFull(r, b[:]); err != nil {	1,066✔
207	return err	7✔
208	}	7✔
209	*e = ErrorCode(binary.BigEndian.Uint16(b[:]))	1,052✔
210
211	case *chainhash.Hash:	1,093✔
212	if _, err := io.ReadFull(r, e[:]); err != nil {	1,106✔
213	return err	13✔
214	}	13✔
215
216	case **lnwire.RawFeatureVector:	1,095✔
217	f := lnwire.NewRawFeatureVector()	1,095✔
218	err := f.Decode(r)	1,095✔
219	if err != nil {	1,097✔
220	return err	2✔
221	}	2✔
222
223	*e = f	1,093✔
224
225	case **btcec.PublicKey:	×
226	var b [btcec.PubKeyBytesLenCompressed]byte	×
227	if _, err := io.ReadFull(r, b[:]); err != nil {	×
228	return err	×
229	}	×
230
231	pubKey, err := btcec.ParsePubKey(b[:])	×
232	if err != nil {	×
233	return err	×
234	}	×
235	*e = pubKey	×
236
237	default:	×
238	return fmt.Errorf("Unknown type in ReadElement: %T", e)	×
239	}
240
241	return nil	9,692✔
242	}
243
244	// ReadElements deserializes a variable number of elements into the passed
245	// io.Reader, with each element being deserialized according to the ReadElement
246	// function.
247	func ReadElements(r io.Reader, elements ...interface{}) error {	3,228✔
248	for _, element := range elements {	12,992✔
249	err := ReadElement(r, element)	9,764✔
250	if err != nil {	9,836✔
251	return err	72✔
252	}	72✔
253	}
254	return nil	3,156✔
255	}

lightningnetwork / lnd / 15951470896

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