13086553769

Committed 01 Feb 2025 07:39AM UTC coverage: 58.822% (+0.01%) from 58.808%

Build # 13086553769

Build Type

Pull #9175

github

Committed by

ellemouton

Commit Message

lnwire: add NodeAnnouncement2

Pull Request Pull Request #9175: lnwire+netann: update structure of g175 messages to be pure TLV

Run Details

414 of 581 new or added lines in 13 files covered. (71.26%)

87 existing lines in 23 files now uncovered.

136444 of 231959 relevant lines covered (58.82%)

19261.9 hits per line

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

90.71

/tlv/primitive.go

package tlv

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

        "github.com/btcsuite/btcd/btcec/v2"
)

// ErrTypeForEncoding signals that an incorrect type was passed to an Encoder.
type ErrTypeForEncoding struct {
        val     interface{}
        expType string
}

// NewTypeForEncodingErr creates a new ErrTypeForEncoding given the incorrect
// val and the expected type.
func NewTypeForEncodingErr(val interface{}, expType string) ErrTypeForEncoding {
        return ErrTypeForEncoding{
                val:     val,
                expType: expType,
        }
}

// Error returns a human-readable description of the type mismatch.
func (e ErrTypeForEncoding) Error() string {
        return fmt.Sprintf("ErrTypeForEncoding want (type: *%s), "+
                "got (type: %T)", e.expType, e.val)
}

// ErrTypeForDecoding signals that an incorrect type was passed to a Decoder or
// that the expected length of the encoding is different from that required by
// the expected type.
type ErrTypeForDecoding struct {
        val       interface{}
        expType   string
        valLength uint64
        expLength uint64
}

// NewTypeForDecodingErr creates a new ErrTypeForDecoding given the incorrect
// val and expected type, or the mismatch in their expected lengths.
func NewTypeForDecodingErr(val interface{}, expType string,
        valLength, expLength uint64) ErrTypeForDecoding {

        return ErrTypeForDecoding{
                val:       val,
                expType:   expType,
                valLength: valLength,
                expLength: expLength,
        }
}

// Error returns a human-readable description of the type mismatch.
func (e ErrTypeForDecoding) Error() string {
        return fmt.Sprintf("ErrTypeForDecoding want (type: *%s, length: %v), "+
                "got (type: %T, length: %v)", e.expType, e.expLength, e.val,
                e.valLength)
}

var (
        byteOrder = binary.BigEndian
)

// EUint8 is an Encoder for uint8 values. An error is returned if val is not a
// *uint8.
func EUint8(w io.Writer, val interface{}, buf *[8]byte) error {
        if i, ok := val.(*uint8); ok {
                return EUint8T(w, *i, buf)
        }
        return NewTypeForEncodingErr(val, "uint8")
}

// EUint8T encodes a uint8 val to the provided io.Writer. This method is exposed
// so that encodings for custom uint8-like types can be created without
// incurring an extra heap allocation.
func EUint8T(w io.Writer, val uint8, buf *[8]byte) error {
        buf[0] = val
        _, err := w.Write(buf[:1])
        return err
}

// EUint16 is an Encoder for uint16 values. An error is returned if val is not a
// *uint16.
func EUint16(w io.Writer, val interface{}, buf *[8]byte) error {
        if i, ok := val.(*uint16); ok {
                return EUint16T(w, *i, buf)
        }
        return NewTypeForEncodingErr(val, "uint16")
}

// EUint16T encodes a uint16 val to the provided io.Writer. This method is
// exposed so that encodings for custom uint16-like types can be created without
// incurring an extra heap allocation.
func EUint16T(w io.Writer, val uint16, buf *[8]byte) error {
        byteOrder.PutUint16(buf[:2], val)
        _, err := w.Write(buf[:2])
        return err
}

// EUint32 is an Encoder for uint32 values. An error is returned if val is not a
// *uint32.
func EUint32(w io.Writer, val interface{}, buf *[8]byte) error {
        if i, ok := val.(*uint32); ok {
                return EUint32T(w, *i, buf)
        }
        return NewTypeForEncodingErr(val, "uint32")
}

// EUint32T encodes a uint32 val to the provided io.Writer. This method is
// exposed so that encodings for custom uint32-like types can be created without
// incurring an extra heap allocation.
func EUint32T(w io.Writer, val uint32, buf *[8]byte) error {
        byteOrder.PutUint32(buf[:4], val)
        _, err := w.Write(buf[:4])
        return err
}

// EUint64 is an Encoder for uint64 values. An error is returned if val is not a
// *uint64.
func EUint64(w io.Writer, val interface{}, buf *[8]byte) error {
        if i, ok := val.(*uint64); ok {
                return EUint64T(w, *i, buf)
        }
        return NewTypeForEncodingErr(val, "uint64")
}

// EUint64T encodes a uint64 val to the provided io.Writer. This method is
// exposed so that encodings for custom uint64-like types can be created without
// incurring an extra heap allocation.
func EUint64T(w io.Writer, val uint64, buf *[8]byte) error {
        byteOrder.PutUint64(buf[:], val)
        _, err := w.Write(buf[:])
        return err
}

// EBool encodes a boolean. An error is returned if val is not a boolean.
func EBool(w io.Writer, val interface{}, buf *[8]byte) error {
        if i, ok := val.(*bool); ok {
                return EBoolT(w, *i, buf)
        }
        return NewTypeForEncodingErr(val, "bool")
}

// EBoolT encodes a bool val to the provided io.Writer. This method is exposed
// so that encodings for custom bool-like types can be created without
// incurring an extra heap allocation.
func EBoolT(w io.Writer, val bool, buf *[8]byte) error {
        if val {
                buf[0] = 1
        } else {
                buf[0] = 0
        }
        _, err := w.Write(buf[:1])
        return err
}

// DUint8 is a Decoder for uint8 values. An error is returned if val is not a
// *uint8.
func DUint8(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
        if i, ok := val.(*uint8); ok && l == 1 {
                if _, err := io.ReadFull(r, buf[:1]); err != nil {
                        return err
                }
                *i = buf[0]
                return nil
        }
        return NewTypeForDecodingErr(val, "uint8", l, 1)
}

// DUint16 is a Decoder for uint16 values. An error is returned if val is not a
// *uint16.
func DUint16(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
        if i, ok := val.(*uint16); ok && l == 2 {
                if _, err := io.ReadFull(r, buf[:2]); err != nil {
                        return err
                }
                *i = byteOrder.Uint16(buf[:2])
                return nil
        }
        return NewTypeForDecodingErr(val, "uint16", l, 2)
}

// DUint32 is a Decoder for uint32 values. An error is returned if val is not a
// *uint32.
func DUint32(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
        if i, ok := val.(*uint32); ok && l == 4 {
                if _, err := io.ReadFull(r, buf[:4]); err != nil {
                        return err
                }
                *i = byteOrder.Uint32(buf[:4])
                return nil
        }
        return NewTypeForDecodingErr(val, "uint32", l, 4)
}

// DUint64 is a Decoder for uint64 values. An error is returned if val is not a
// *uint64.
func DUint64(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
        if i, ok := val.(*uint64); ok && l == 8 {
                if _, err := io.ReadFull(r, buf[:]); err != nil {
                        return err
                }
                *i = byteOrder.Uint64(buf[:])
                return nil
        }
        return NewTypeForDecodingErr(val, "uint64", l, 8)
}

// DBool decodes a boolean. An error is returned if val is not a boolean.
func DBool(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
        if i, ok := val.(*bool); ok && l == 1 {
                if _, err := io.ReadFull(r, buf[:1]); err != nil {
                        return err
                }
                if buf[0] != 0 && buf[0] != 1 {
                        return errors.New("corrupted data")
                }
                *i = buf[0] != 0
                return nil
        }
        return NewTypeForDecodingErr(val, "bool", l, 1)
}

// EBytes32 is an Encoder for 32-byte arrays. An error is returned if val is not
// a *[32]byte.
func EBytes32(w io.Writer, val interface{}, _ *[8]byte) error {
        if b, ok := val.(*[32]byte); ok {
                _, err := w.Write(b[:])
                return err
        }
        return NewTypeForEncodingErr(val, "[32]byte")
}

// DBytes32 is a Decoder for 32-byte arrays. An error is returned if val is not
// a *[32]byte.
func DBytes32(r io.Reader, val interface{}, _ *[8]byte, l uint64) error {
        if b, ok := val.(*[32]byte); ok && l == 32 {
                _, err := io.ReadFull(r, b[:])
                return err
        }
        return NewTypeForDecodingErr(val, "[32]byte", l, 32)
}

// EBytes33 is an Encoder for 33-byte arrays. An error is returned if val is not
// a *[33]byte.
func EBytes33(w io.Writer, val interface{}, _ *[8]byte) error {
        if b, ok := val.(*[33]byte); ok {
                _, err := w.Write(b[:])
                return err
        }
        return NewTypeForEncodingErr(val, "[33]byte")
}

// DBytes33 is a Decoder for 33-byte arrays. An error is returned if val is not
// a *[33]byte.
func DBytes33(r io.Reader, val interface{}, _ *[8]byte, l uint64) error {
        if b, ok := val.(*[33]byte); ok {
                _, err := io.ReadFull(r, b[:])
                return err
        }
        return NewTypeForDecodingErr(val, "[33]byte", l, 33)
}

// EBytes64 is an Encoder for 64-byte arrays. An error is returned if val is not
// a *[64]byte.
func EBytes64(w io.Writer, val interface{}, _ *[8]byte) error {
        if b, ok := val.(*[64]byte); ok {
                _, err := w.Write(b[:])
                return err
        }
        return NewTypeForEncodingErr(val, "[64]byte")
}

// DBytes64 is an Decoder for 64-byte arrays. An error is returned if val is not
// a *[64]byte.
func DBytes64(r io.Reader, val interface{}, _ *[8]byte, l uint64) error {
        if b, ok := val.(*[64]byte); ok && l == 64 {
                _, err := io.ReadFull(r, b[:])
                return err
        }
        return NewTypeForDecodingErr(val, "[64]byte", l, 64)
}

// EPubKey is an Encoder for *btcec.PublicKey values. An error is returned if
// val is not a **btcec.PublicKey.
func EPubKey(w io.Writer, val interface{}, _ *[8]byte) error {
        if pk, ok := val.(**btcec.PublicKey); ok {
                _, err := w.Write((*pk).SerializeCompressed())
                return err
        }
        return NewTypeForEncodingErr(val, "*btcec.PublicKey")
}

// DPubKey is a Decoder for *btcec.PublicKey values. An error is returned if val
// is not a **btcec.PublicKey.
func DPubKey(r io.Reader, val interface{}, _ *[8]byte, l uint64) error {
        if pk, ok := val.(**btcec.PublicKey); ok && l == 33 {
                var b [33]byte
                _, err := io.ReadFull(r, b[:])
                if err != nil {
                        return err
                }

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

                *pk = p

                return nil
        }
        return NewTypeForDecodingErr(val, "*btcec.PublicKey", l, 33)
}

// EVarBytes is an Encoder for variable byte slices. An error is returned if val
// is not *[]byte.
func EVarBytes(w io.Writer, val interface{}, _ *[8]byte) error {
        if b, ok := val.(*[]byte); ok {
                _, err := w.Write(*b)
                return err
        }
        return NewTypeForEncodingErr(val, "[]byte")
}

// DVarBytes is a Decoder for variable byte slices. An error is returned if val
// is not *[]byte.
func DVarBytes(r io.Reader, val interface{}, _ *[8]byte, l uint64) error {
        if b, ok := val.(*[]byte); ok {
                *b = make([]byte, l)
                _, err := io.ReadFull(r, *b)
                return err
        }
        return NewTypeForDecodingErr(val, "[]byte", l, l)
}

// EBigSize encodes an uint32 or an uint64 using BigSize format. An error is
// returned if val is not either *uint32 or *uint64.
func EBigSize(w io.Writer, val interface{}, buf *[8]byte) error {
        if i, ok := val.(*uint32); ok {
                return WriteVarInt(w, uint64(*i), buf)
        }

        if i, ok := val.(*uint64); ok {
                return WriteVarInt(w, uint64(*i), buf)
        }

        return NewTypeForEncodingErr(val, "BigSize")
}

// DBigSize decodes an uint32 or an uint64 using BigSize format. An error is
// returned if val is not either *uint32 or *uint64.
func DBigSize(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
        if i, ok := val.(*uint32); ok {
                v, err := ReadVarInt(r, buf)
                if err != nil {
                        return err
                }
                *i = uint32(v)
                return nil
        }

        if i, ok := val.(*uint64); ok {
                v, err := ReadVarInt(r, buf)
                if err != nil {
                        return err
                }
                *i = v
                return nil
        }

        return NewTypeForDecodingErr(val, "BigSize", l, 8)
}

// SizeBigSize returns a SizeFunc that can compute the length of BigSize.
func SizeBigSize(val interface{}) SizeFunc {
        var size uint64

        if i, ok := val.(*uint32); ok {
                size = VarIntSize(uint64(*i))
        }

        if i, ok := val.(*uint64); ok {
                size = VarIntSize(uint64(*i))
        }

        return func() uint64 {
                return size
        }
}

1	package tlv
2
3	import (
4	"encoding/binary"
5	"errors"
6	"fmt"
7	"io"
8
9	"github.com/btcsuite/btcd/btcec/v2"
10	)
11
12	// ErrTypeForEncoding signals that an incorrect type was passed to an Encoder.
13	type ErrTypeForEncoding struct {
14	val interface{}
15	expType string
16	}
17
18	// NewTypeForEncodingErr creates a new ErrTypeForEncoding given the incorrect
19	// val and the expected type.
20	func NewTypeForEncodingErr(val interface{}, expType string) ErrTypeForEncoding {	10✔
21	return ErrTypeForEncoding{	10✔
22	val: val,	10✔
23	expType: expType,	10✔
24	}	10✔
25	}	10✔
26
27	// Error returns a human-readable description of the type mismatch.
28	func (e ErrTypeForEncoding) Error() string {	×
29	return fmt.Sprintf("ErrTypeForEncoding want (type: *%s), "+	×
30	"got (type: %T)", e.expType, e.val)	×
31	}	×
32
33	// ErrTypeForDecoding signals that an incorrect type was passed to a Decoder or
34	// that the expected length of the encoding is different from that required by
35	// the expected type.
36	type ErrTypeForDecoding struct {
37	val interface{}
38	expType string
39	valLength uint64
40	expLength uint64
41	}
42
43	// NewTypeForDecodingErr creates a new ErrTypeForDecoding given the incorrect
44	// val and expected type, or the mismatch in their expected lengths.
45	func NewTypeForDecodingErr(val interface{}, expType string,
46	valLength, expLength uint64) ErrTypeForDecoding {	46✔
47		46✔
48	return ErrTypeForDecoding{	46✔
49	val: val,	46✔
50	expType: expType,	46✔
51	valLength: valLength,	46✔
52	expLength: expLength,	46✔
53	}	46✔
54	}	46✔
55
56	// Error returns a human-readable description of the type mismatch.
57	func (e ErrTypeForDecoding) Error() string {	×
58	return fmt.Sprintf("ErrTypeForDecoding want (type: *%s, length: %v), "+	×
59	"got (type: %T, length: %v)", e.expType, e.expLength, e.val,	×
60	e.valLength)	×
61	}	×
62
63	var (
64	byteOrder = binary.BigEndian
65	)
66
67	// EUint8 is an Encoder for uint8 values. An error is returned if val is not a
68	// *uint8.
69	func EUint8(w io.Writer, val interface{}, buf *[8]byte) error {	6,923✔
70	if i, ok := val.(*uint8); ok {	13,845✔
71	return EUint8T(w, *i, buf)	6,922✔
72	}	6,922✔
73	return NewTypeForEncodingErr(val, "uint8")	1✔
74	}
75
76	// EUint8T encodes a uint8 val to the provided io.Writer. This method is exposed
77	// so that encodings for custom uint8-like types can be created without
78	// incurring an extra heap allocation.
79	func EUint8T(w io.Writer, val uint8, buf *[8]byte) error {	6,922✔
80	buf[0] = val	6,922✔
81	_, err := w.Write(buf[:1])	6,922✔
82	return err	6,922✔
83	}	6,922✔
84
85	// EUint16 is an Encoder for uint16 values. An error is returned if val is not a
86	// *uint16.
87	func EUint16(w io.Writer, val interface{}, buf *[8]byte) error {	23,295✔
88	if i, ok := val.(*uint16); ok {	46,589✔
89	return EUint16T(w, *i, buf)	23,294✔
90	}	23,294✔
91	return NewTypeForEncodingErr(val, "uint16")	1✔
92	}
93
94	// EUint16T encodes a uint16 val to the provided io.Writer. This method is
95	// exposed so that encodings for custom uint16-like types can be created without
96	// incurring an extra heap allocation.
97	func EUint16T(w io.Writer, val uint16, buf *[8]byte) error {	23,294✔
98	byteOrder.PutUint16(buf[:2], val)	23,294✔
99	_, err := w.Write(buf[:2])	23,294✔
100	return err	23,294✔
101	}	23,294✔
102
103	// EUint32 is an Encoder for uint32 values. An error is returned if val is not a
104	// *uint32.
105	func EUint32(w io.Writer, val interface{}, buf *[8]byte) error {	8,846✔
106	if i, ok := val.(*uint32); ok {	17,691✔
107	return EUint32T(w, *i, buf)	8,845✔
108	}	8,845✔
109	return NewTypeForEncodingErr(val, "uint32")	1✔
110	}
111
112	// EUint32T encodes a uint32 val to the provided io.Writer. This method is
113	// exposed so that encodings for custom uint32-like types can be created without
114	// incurring an extra heap allocation.
115	func EUint32T(w io.Writer, val uint32, buf *[8]byte) error {	21,976✔
116	byteOrder.PutUint32(buf[:4], val)	21,976✔
117	_, err := w.Write(buf[:4])	21,976✔
118	return err	21,976✔
119	}	21,976✔
120
121	// EUint64 is an Encoder for uint64 values. An error is returned if val is not a
122	// *uint64.
123	func EUint64(w io.Writer, val interface{}, buf *[8]byte) error {	23,225✔
124	if i, ok := val.(*uint64); ok {	46,449✔
125	return EUint64T(w, *i, buf)	23,224✔
126	}	23,224✔
127	return NewTypeForEncodingErr(val, "uint64")	1✔
128	}
129
130	// EUint64T encodes a uint64 val to the provided io.Writer. This method is
131	// exposed so that encodings for custom uint64-like types can be created without
132	// incurring an extra heap allocation.
133	func EUint64T(w io.Writer, val uint64, buf *[8]byte) error {	26,834✔
134	byteOrder.PutUint64(buf[:], val)	26,834✔
135	_, err := w.Write(buf[:])	26,834✔
136	return err	26,834✔
137	}	26,834✔
138
139	// EBool encodes a boolean. An error is returned if val is not a boolean.
140	func EBool(w io.Writer, val interface{}, buf *[8]byte) error {	3,489✔
141	if i, ok := val.(*bool); ok {	6,977✔
142	return EBoolT(w, *i, buf)	3,488✔
143	}	3,488✔
144	return NewTypeForEncodingErr(val, "bool")	1✔
145	}
146
147	// EBoolT encodes a bool val to the provided io.Writer. This method is exposed
148	// so that encodings for custom bool-like types can be created without
149	// incurring an extra heap allocation.
150	func EBoolT(w io.Writer, val bool, buf *[8]byte) error {	3,488✔
151	if val {	5,203✔
152	buf[0] = 1	1,715✔
153	} else {	3,488✔
154	buf[0] = 0	1,773✔
155	}	1,773✔
156	_, err := w.Write(buf[:1])	3,488✔
157	return err	3,488✔
158	}
159
160	// DUint8 is a Decoder for uint8 values. An error is returned if val is not a
161	// *uint8.
162	func DUint8(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {	8,266✔
163	if i, ok := val.(*uint8); ok && l == 1 {	16,531✔
164	if _, err := io.ReadFull(r, buf[:1]); err != nil {	8,265✔
UNCOV 165	return err	×
UNCOV 166	}	×
167	*i = buf[0]	8,265✔
168	return nil	8,265✔
169	}
170	return NewTypeForDecodingErr(val, "uint8", l, 1)	1✔
171	}
172
173	// DUint16 is a Decoder for uint16 values. An error is returned if val is not a
174	// *uint16.
175	func DUint16(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {	10,158✔
176	if i, ok := val.(*uint16); ok && l == 2 {	20,311✔
177	if _, err := io.ReadFull(r, buf[:2]); err != nil {	10,154✔
178	return err	1✔
179	}	1✔
180	*i = byteOrder.Uint16(buf[:2])	10,152✔
181	return nil	10,152✔
182	}
183	return NewTypeForDecodingErr(val, "uint16", l, 2)	5✔
184	}
185
186	// DUint32 is a Decoder for uint32 values. An error is returned if val is not a
187	// *uint32.
188	func DUint32(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {	26,645✔
189	if i, ok := val.(*uint32); ok && l == 4 {	53,285✔
190	if _, err := io.ReadFull(r, buf[:4]); err != nil {	26,649✔
191	return err	9✔
192	}	9✔
193	*i = byteOrder.Uint32(buf[:4])	26,631✔
194	return nil	26,631✔
195	}
196	return NewTypeForDecodingErr(val, "uint32", l, 4)	5✔
197	}
198
199	// DUint64 is a Decoder for uint64 values. An error is returned if val is not a
200	// *uint64.
201	func DUint64(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {	44,883✔
202	if i, ok := val.(*uint64); ok && l == 8 {	89,760✔
203	if _, err := io.ReadFull(r, buf[:]); err != nil {	44,881✔
204	return err	4✔
205	}	4✔
206	*i = byteOrder.Uint64(buf[:])	44,873✔
207	return nil	44,873✔
208	}
209	return NewTypeForDecodingErr(val, "uint64", l, 8)	6✔
210	}
211
212	// DBool decodes a boolean. An error is returned if val is not a boolean.
213	func DBool(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {	31✔
214	if i, ok := val.(*bool); ok && l == 1 {	61✔
215	if _, err := io.ReadFull(r, buf[:1]); err != nil {	30✔
216	return err	×
217	}	×
218	if buf[0] != 0 && buf[0] != 1 {	30✔
219	return errors.New("corrupted data")	×
220	}	×
221	*i = buf[0] != 0	30✔
222	return nil	30✔
223	}
224	return NewTypeForDecodingErr(val, "bool", l, 1)	1✔
225	}
226
227	// EBytes32 is an Encoder for 32-byte arrays. An error is returned if val is not
228	// a *[32]byte.
229	func EBytes32(w io.Writer, val interface{}, _ *[8]byte) error {	16,401✔
230	if b, ok := val.(*[32]byte); ok {	32,801✔
231	_, err := w.Write(b[:])	16,400✔
232	return err	16,400✔
233	}	16,400✔
234	return NewTypeForEncodingErr(val, "[32]byte")	1✔
235	}
236
237	// DBytes32 is a Decoder for 32-byte arrays. An error is returned if val is not
238	// a *[32]byte.
239	func DBytes32(r io.Reader, val interface{}, _ *[8]byte, l uint64) error {	14,104✔
240	if b, ok := val.(*[32]byte); ok && l == 32 {	28,207✔
241	_, err := io.ReadFull(r, b[:])	14,103✔
242	return err	14,103✔
243	}	14,103✔
244	return NewTypeForDecodingErr(val, "[32]byte", l, 32)	1✔
245	}
246
247	// EBytes33 is an Encoder for 33-byte arrays. An error is returned if val is not
248	// a *[33]byte.
249	func EBytes33(w io.Writer, val interface{}, _ *[8]byte) error {	422✔
250	if b, ok := val.(*[33]byte); ok {	843✔
251	_, err := w.Write(b[:])	421✔
252	return err	421✔
253	}	421✔
254	return NewTypeForEncodingErr(val, "[33]byte")	1✔
255	}
256
257	// DBytes33 is a Decoder for 33-byte arrays. An error is returned if val is not
258	// a *[33]byte.
259	func DBytes33(r io.Reader, val interface{}, _ *[8]byte, l uint64) error {	402✔
260	if b, ok := val.(*[33]byte); ok {	803✔
261	_, err := io.ReadFull(r, b[:])	401✔
262	return err	401✔
263	}	401✔
264	return NewTypeForDecodingErr(val, "[33]byte", l, 33)	1✔
265	}
266
267	// EBytes64 is an Encoder for 64-byte arrays. An error is returned if val is not
268	// a *[64]byte.
269	func EBytes64(w io.Writer, val interface{}, _ *[8]byte) error {	588✔
270	if b, ok := val.(*[64]byte); ok {	1,175✔
271	_, err := w.Write(b[:])	587✔
272	return err	587✔
273	}	587✔
274	return NewTypeForEncodingErr(val, "[64]byte")	1✔
275	}
276
277	// DBytes64 is an Decoder for 64-byte arrays. An error is returned if val is not
278	// a *[64]byte.
279	func DBytes64(r io.Reader, val interface{}, _ *[8]byte, l uint64) error {	602✔
280	if b, ok := val.(*[64]byte); ok && l == 64 {	1,199✔
281	_, err := io.ReadFull(r, b[:])	597✔
282	return err	597✔
283	}	597✔
284	return NewTypeForDecodingErr(val, "[64]byte", l, 64)	5✔
285	}
286
287	// EPubKey is an Encoder for *btcec.PublicKey values. An error is returned if
288	// val is not a **btcec.PublicKey.
289	func EPubKey(w io.Writer, val interface{}, _ *[8]byte) error {	160✔
290	if pk, ok := val.(**btcec.PublicKey); ok {	319✔
291	_, err := w.Write((*pk).SerializeCompressed())	159✔
292	return err	159✔
293	}	159✔
294	return NewTypeForEncodingErr(val, "*btcec.PublicKey")	1✔
295	}
296
297	// DPubKey is a Decoder for *btcec.PublicKey values. An error is returned if val
298	// is not a **btcec.PublicKey.
299	func DPubKey(r io.Reader, val interface{}, _ *[8]byte, l uint64) error {	164✔
300	if pk, ok := val.(**btcec.PublicKey); ok && l == 33 {	325✔
301	var b [33]byte	161✔
302	_, err := io.ReadFull(r, b[:])	161✔
303	if err != nil {	164✔
304	return err	3✔
305	}	3✔
306
307	p, err := btcec.ParsePubKey(b[:])	158✔
308	if err != nil {	167✔
309	return err	9✔
310	}	9✔
311
312	*pk = p	149✔
313		149✔
314	return nil	149✔
315	}
316	return NewTypeForDecodingErr(val, "*btcec.PublicKey", l, 33)	3✔
317	}
318
319	// EVarBytes is an Encoder for variable byte slices. An error is returned if val
320	// is not *[]byte.
321	func EVarBytes(w io.Writer, val interface{}, _ *[8]byte) error {	12,613✔
322	if b, ok := val.(*[]byte); ok {	25,225✔
323	_, err := w.Write(*b)	12,612✔
324	return err	12,612✔
325	}	12,612✔
326	return NewTypeForEncodingErr(val, "[]byte")	1✔
327	}
328
329	// DVarBytes is a Decoder for variable byte slices. An error is returned if val
330	// is not *[]byte.
331	func DVarBytes(r io.Reader, val interface{}, _ *[8]byte, l uint64) error {	14,303✔
332	if b, ok := val.(*[]byte); ok {	28,605✔
333	*b = make([]byte, l)	14,302✔
334	_, err := io.ReadFull(r, *b)	14,302✔
335	return err	14,302✔
336	}	14,302✔
337	return NewTypeForDecodingErr(val, "[]byte", l, l)	1✔
338	}
339
340	// EBigSize encodes an uint32 or an uint64 using BigSize format. An error is
341	// returned if val is not either uint32 or uint64.
342	func EBigSize(w io.Writer, val interface{}, buf *[8]byte) error {	9,993✔
343	if i, ok := val.(*uint32); ok {	9,996✔
344	return WriteVarInt(w, uint64(*i), buf)	3✔
345	}	3✔
346
347	if i, ok := val.(*uint64); ok {	19,980✔
348	return WriteVarInt(w, uint64(*i), buf)	9,990✔
349	}	9,990✔
350
351	return NewTypeForEncodingErr(val, "BigSize")	×
352	}
353
354	// DBigSize decodes an uint32 or an uint64 using BigSize format. An error is
355	// returned if val is not either uint32 or uint64.
356	func DBigSize(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {	2,250✔
357	if i, ok := val.(*uint32); ok {	2,253✔
358	v, err := ReadVarInt(r, buf)	3✔
359	if err != nil {	3✔
360	return err	×
361	}	×
362	*i = uint32(v)	3✔
363	return nil	3✔
364	}
365
366	if i, ok := val.(*uint64); ok {	4,494✔
367	v, err := ReadVarInt(r, buf)	2,247✔
368	if err != nil {	2,247✔
UNCOV 369	return err	×
UNCOV 370	}	×
371	*i = v	2,247✔
372	return nil	2,247✔
373	}
374
375	return NewTypeForDecodingErr(val, "BigSize", l, 8)	×
376	}
377
378	// SizeBigSize returns a SizeFunc that can compute the length of BigSize.
379	func SizeBigSize(val interface{}) SizeFunc {	24,378✔
380	var size uint64	24,378✔
381		24,378✔
382	if i, ok := val.(*uint32); ok {	24,384✔
383	size = VarIntSize(uint64(*i))	6✔
384	}	6✔
385
386	if i, ok := val.(*uint64); ok {	48,026✔
387	size = VarIntSize(uint64(*i))	23,648✔
388	}	23,648✔
389
390	return func() uint64 {	34,371✔
391	return size	9,993✔
392	}	9,993✔
393	}

lightningnetwork / lnd / 13086553769

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