11216766535

Committed 07 Oct 2024 01:37PM UTC coverage: 57.817% (-1.0%) from 58.817%

Build # 11216766535

Build Type

Pull #9148

github

Committed by

ProofOfKeags

Commit Message

lnwire: remove kickoff feerate from propose/commit

Pull Request Pull Request #9148: DynComms [2/n]: lnwire: add authenticated wire messages for Dyn*

Run Details

571 of 879 new or added lines in 16 files covered. (64.96%)

23253 existing lines in 251 files now uncovered.

99022 of 171268 relevant lines covered (57.82%)

38420.67 hits per line

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

88.94

/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 {	39✔
47		39✔
48	return ErrTypeForDecoding{	39✔
49	val: val,	39✔
50	expType: expType,	39✔
51	valLength: valLength,	39✔
52	expLength: expLength,	39✔
53	}	39✔
54	}	39✔
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 {	10,231✔
70	if i, ok := val.(*uint8); ok {	20,461✔
71	return EUint8T(w, *i, buf)	10,230✔
72	}	10,230✔
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 {	10,230✔
80	buf[0] = val	10,230✔
81	_, err := w.Write(buf[:1])	10,230✔
82	return err	10,230✔
83	}	10,230✔
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 {	494,748✔
88	if i, ok := val.(*uint16); ok {	989,495✔
89	return EUint16T(w, *i, buf)	494,747✔
90	}	494,747✔
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 {	494,747✔
98	byteOrder.PutUint16(buf[:2], val)	494,747✔
99	_, err := w.Write(buf[:2])	494,747✔
100	return err	494,747✔
101	}	494,747✔
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 {	245,945✔
106	if i, ok := val.(*uint32); ok {	491,889✔
107	return EUint32T(w, *i, buf)	245,944✔
108	}	245,944✔
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 {	261,891✔
116	byteOrder.PutUint32(buf[:4], val)	261,891✔
117	_, err := w.Write(buf[:4])	261,891✔
118	return err	261,891✔
119	}	261,891✔
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 {	37,342✔
124	if i, ok := val.(*uint64); ok {	74,683✔
125	return EUint64T(w, *i, buf)	37,341✔
126	}	37,341✔
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 {	42,243✔
134	byteOrder.PutUint64(buf[:], val)	42,243✔
135	_, err := w.Write(buf[:])	42,243✔
136	return err	42,243✔
137	}	42,243✔
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 {	237,760✔
141	if i, ok := val.(*bool); ok {	475,519✔
142	return EBoolT(w, *i, buf)	237,759✔
143	}	237,759✔
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 {	237,759✔
151	if val {	356,370✔
152	buf[0] = 1	118,611✔
153	} else {	237,759✔
154	buf[0] = 0	119,148✔
155	}	119,148✔
156	_, err := w.Write(buf[:1])	237,759✔
157	return err	237,759✔
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 {	11,102✔
163	if i, ok := val.(*uint8); ok && l == 1 {	22,203✔
164	if _, err := io.ReadFull(r, buf[:1]); err != nil {	11,101✔
165	return err	×
166	}	×
167	*i = buf[0]	11,101✔
168	return nil	11,101✔
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,252✔
176	if i, ok := val.(*uint16); ok && l == 2 {	20,500✔
177	if _, err := io.ReadFull(r, buf[:2]); err != nil {	10,248✔
UNCOV 178	return err	×
UNCOV 179	}	×
180	*i = byteOrder.Uint16(buf[:2])	10,248✔
181	return nil	10,248✔
182	}
183	return NewTypeForDecodingErr(val, "uint16", l, 2)	4✔
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 {	36,949✔
189	if i, ok := val.(*uint32); ok && l == 4 {	73,895✔
190	if _, err := io.ReadFull(r, buf[:4]); err != nil {	36,949✔
191	return err	3✔
192	}	3✔
193	*i = byteOrder.Uint32(buf[:4])	36,943✔
194	return nil	36,943✔
195	}
196	return NewTypeForDecodingErr(val, "uint32", l, 4)	3✔
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 {	65,866✔
202	if i, ok := val.(*uint64); ok && l == 8 {	131,728✔
203	if _, err := io.ReadFull(r, buf[:]); err != nil {	65,864✔
204	return err	2✔
205	}	2✔
206	*i = byteOrder.Uint64(buf[:])	65,860✔
207	return nil	65,860✔
208	}
209	return NewTypeForDecodingErr(val, "uint64", l, 8)	4✔
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 {	254,446✔
230	if b, ok := val.(*[32]byte); ok {	508,891✔
231	_, err := w.Write(b[:])	254,445✔
232	return err	254,445✔
233	}	254,445✔
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 {	16,327✔
240	if b, ok := val.(*[32]byte); ok && l == 32 {	32,653✔
241	_, err := io.ReadFull(r, b[:])	16,326✔
242	return err	16,326✔
243	}	16,326✔
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 {	308✔
250	if b, ok := val.(*[33]byte); ok {	615✔
251	_, err := w.Write(b[:])	307✔
252	return err	307✔
253	}	307✔
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 {	296✔
260	if b, ok := val.(*[33]byte); ok {	591✔
261	_, err := io.ReadFull(r, b[:])	295✔
262	return err	295✔
263	}	295✔
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 {	307✔
270	if b, ok := val.(*[64]byte); ok {	613✔
271	_, err := w.Write(b[:])	306✔
272	return err	306✔
273	}	306✔
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 {	321✔
280	if b, ok := val.(*[64]byte); ok && l == 64 {	637✔
281	_, err := io.ReadFull(r, b[:])	316✔
282	return err	316✔
283	}	316✔
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 {	185✔
290	if pk, ok := val.(**btcec.PublicKey); ok {	369✔
291	_, err := w.Write((*pk).SerializeCompressed())	184✔
292	return err	184✔
293	}	184✔
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 {	170✔
300	if pk, ok := val.(**btcec.PublicKey); ok && l == 33 {	339✔
301	var b [33]byte	169✔
302	_, err := io.ReadFull(r, b[:])	169✔
303	if err != nil {	169✔
UNCOV 304	return err	×
UNCOV 305	}	×
306
307	p, err := btcec.ParsePubKey(b[:])	169✔
308	if err != nil {	170✔
309	return err	1✔
310	}	1✔
311
312	*pk = p	168✔
313		168✔
314	return nil	168✔
315	}
316	return NewTypeForDecodingErr(val, "*btcec.PublicKey", l, 33)	1✔
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 {	18,373✔
322	if b, ok := val.(*[]byte); ok {	36,745✔
323	_, err := w.Write(*b)	18,372✔
324	return err	18,372✔
325	}	18,372✔
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 {	20,012✔
332	if b, ok := val.(*[]byte); ok {	40,023✔
333	*b = make([]byte, l)	20,011✔
334	_, err := io.ReadFull(r, *b)	20,011✔
335	return err	20,011✔
336	}	20,011✔
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 {	246,941✔
343	if i, ok := val.(*uint32); ok {	246,944✔
344	return WriteVarInt(w, uint64(*i), buf)	3✔
345	}	3✔
346
347	if i, ok := val.(*uint64); ok {	493,876✔
348	return WriteVarInt(w, uint64(*i), buf)	246,938✔
349	}	246,938✔
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,207✔
357	if i, ok := val.(*uint32); ok {	2,210✔
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,408✔
367	v, err := ReadVarInt(r, buf)	2,204✔
368	if err != nil {	2,204✔
369	return err	×
370	}	×
371	*i = v	2,204✔
372	return nil	2,204✔
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 {	261,098✔
380	var size uint64	261,098✔
381		261,098✔
382	if i, ok := val.(*uint32); ok {	261,104✔
383	size = VarIntSize(uint64(*i))	6✔
384	}	6✔
385
386	if i, ok := val.(*uint64); ok {	521,831✔
387	size = VarIntSize(uint64(*i))	260,733✔
388	}	260,733✔
389
390	return func() uint64 {	508,039✔
391	return size	246,941✔
392	}	246,941✔
393	}

lightningnetwork / lnd / 11216766535

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