11333802987

Committed 14 Oct 2024 07:26PM UTC coverage: 57.859% (-0.9%) from 58.779%

Build # 11333802987

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

351 of 627 new or added lines in 12 files covered. (55.98%)

19006 existing lines in 242 files now uncovered.

99279 of 171588 relevant lines covered (57.86%)

36687.28 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,234✔
70	if i, ok := val.(*uint8); ok {	20,467✔
71	return EUint8T(w, *i, buf)	10,233✔
72	}	10,233✔
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,233✔
80	buf[0] = val	10,233✔
81	_, err := w.Write(buf[:1])	10,233✔
82	return err	10,233✔
83	}	10,233✔
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 {	487,257✔
88	if i, ok := val.(*uint16); ok {	974,513✔
89	return EUint16T(w, *i, buf)	487,256✔
90	}	487,256✔
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 {	487,256✔
98	byteOrder.PutUint16(buf[:2], val)	487,256✔
99	_, err := w.Write(buf[:2])	487,256✔
100	return err	487,256✔
101	}	487,256✔
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 {	242,627✔
106	if i, ok := val.(*uint32); ok {	485,253✔
107	return EUint32T(w, *i, buf)	242,626✔
108	}	242,626✔
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 {	257,739✔
116	byteOrder.PutUint32(buf[:4], val)	257,739✔
117	_, err := w.Write(buf[:4])	257,739✔
118	return err	257,739✔
119	}	257,739✔
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 {	36,496✔
124	if i, ok := val.(*uint64); ok {	72,991✔
125	return EUint64T(w, *i, buf)	36,495✔
126	}	36,495✔
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 {	40,983✔
134	byteOrder.PutUint64(buf[:], val)	40,983✔
135	_, err := w.Write(buf[:])	40,983✔
136	return err	40,983✔
137	}	40,983✔
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 {	234,425✔
141	if i, ok := val.(*bool); ok {	468,849✔
142	return EBoolT(w, *i, buf)	234,424✔
143	}	234,424✔
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 {	234,424✔
151	if val {	351,607✔
152	buf[0] = 1	117,183✔
153	} else {	234,424✔
154	buf[0] = 0	117,241✔
155	}	117,241✔
156	_, err := w.Write(buf[:1])	234,424✔
157	return err	234,424✔
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,104✔
163	if i, ok := val.(*uint8); ok && l == 1 {	22,207✔
164	if _, err := io.ReadFull(r, buf[:1]); err != nil {	11,103✔
165	return err	×
166	}	×
167	*i = buf[0]	11,103✔
168	return nil	11,103✔
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,253✔
176	if i, ok := val.(*uint16); ok && l == 2 {	20,502✔
177	if _, err := io.ReadFull(r, buf[:2]); err != nil {	10,249✔
UNCOV 178	return err	×
UNCOV 179	}	×
180	*i = byteOrder.Uint16(buf[:2])	10,249✔
181	return nil	10,249✔
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 {	34,488✔
189	if i, ok := val.(*uint32); ok && l == 4 {	68,973✔
190	if _, err := io.ReadFull(r, buf[:4]); err != nil {	34,488✔
191	return err	3✔
192	}	3✔
193	*i = byteOrder.Uint32(buf[:4])	34,482✔
194	return nil	34,482✔
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 {	62,140✔
202	if i, ok := val.(*uint64); ok && l == 8 {	124,276✔
203	if _, err := io.ReadFull(r, buf[:]); err != nil {	62,138✔
204	return err	2✔
205	}	2✔
206	*i = byteOrder.Uint64(buf[:])	62,134✔
207	return nil	62,134✔
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 {	250,686✔
230	if b, ok := val.(*[32]byte); ok {	501,371✔
231	_, err := w.Write(b[:])	250,685✔
232	return err	250,685✔
233	}	250,685✔
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,304✔
240	if b, ok := val.(*[32]byte); ok && l == 32 {	32,607✔
241	_, err := io.ReadFull(r, b[:])	16,303✔
242	return err	16,303✔
243	}	16,303✔
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 {	320✔
250	if b, ok := val.(*[33]byte); ok {	639✔
251	_, err := w.Write(b[:])	319✔
252	return err	319✔
253	}	319✔
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 {	308✔
260	if b, ok := val.(*[33]byte); ok {	615✔
261	_, err := io.ReadFull(r, b[:])	307✔
262	return err	307✔
263	}	307✔
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 {	286✔
270	if b, ok := val.(*[64]byte); ok {	571✔
271	_, err := w.Write(b[:])	285✔
272	return err	285✔
273	}	285✔
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 {	300✔
280	if b, ok := val.(*[64]byte); ok && l == 64 {	595✔
281	_, err := io.ReadFull(r, b[:])	295✔
282	return err	295✔
283	}	295✔
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 {	184✔
290	if pk, ok := val.(**btcec.PublicKey); ok {	367✔
291	_, err := w.Write((*pk).SerializeCompressed())	183✔
292	return err	183✔
293	}	183✔
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 {	169✔
300	if pk, ok := val.(**btcec.PublicKey); ok && l == 33 {	337✔
301	var b [33]byte	168✔
302	_, err := io.ReadFull(r, b[:])	168✔
303	if err != nil {	168✔
UNCOV 304	return err	×
UNCOV 305	}	×
306
307	p, err := btcec.ParsePubKey(b[:])	168✔
308	if err != nil {	169✔
309	return err	1✔
310	}	1✔
311
312	*pk = p	167✔
313		167✔
314	return nil	167✔
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,066✔
322	if b, ok := val.(*[]byte); ok {	36,131✔
323	_, err := w.Write(*b)	18,065✔
324	return err	18,065✔
325	}	18,065✔
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 {	19,908✔
332	if b, ok := val.(*[]byte); ok {	39,815✔
333	*b = make([]byte, l)	19,907✔
334	_, err := io.ReadFull(r, *b)	19,907✔
335	return err	19,907✔
336	}	19,907✔
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 {	242,781✔
343	if i, ok := val.(*uint32); ok {	242,784✔
344	return WriteVarInt(w, uint64(*i), buf)	3✔
345	}	3✔
346
347	if i, ok := val.(*uint64); ok {	485,556✔
348	return WriteVarInt(w, uint64(*i), buf)	242,778✔
349	}	242,778✔
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,204✔
357	if i, ok := val.(*uint32); ok {	2,207✔
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,402✔
367	v, err := ReadVarInt(r, buf)	2,201✔
368	if err != nil {	2,201✔
369	return err	×
370	}	×
371	*i = v	2,201✔
372	return nil	2,201✔
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 {	256,938✔
380	var size uint64	256,938✔
381		256,938✔
382	if i, ok := val.(*uint32); ok {	256,944✔
383	size = VarIntSize(uint64(*i))	6✔
384	}	6✔
385
386	if i, ok := val.(*uint64); ok {	513,514✔
387	size = VarIntSize(uint64(*i))	256,576✔
388	}	256,576✔
389
390	return func() uint64 {	499,719✔
391	return size	242,781✔
392	}	242,781✔
393	}

lightningnetwork / lnd / 11333802987

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