11393106485

Committed 17 Oct 2024 09:10PM UTC coverage: 57.848% (-1.0%) from 58.81%

Build # 11393106485

Build Type

Pull #9148

github

Committed by

ProofOfKeags

Commit Message

lnwire: convert DynPropose and DynCommit to use typed tlv records

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

Run Details

142 of 177 new or added lines in 4 files covered. (80.23%)

18983 existing lines in 242 files now uncovered.

99003 of 171143 relevant lines covered (57.85%)

36968.25 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 {	38✔
47		38✔
48	return ErrTypeForDecoding{	38✔
49	val: val,	38✔
50	expType: expType,	38✔
51	valLength: valLength,	38✔
52	expLength: expLength,	38✔
53	}	38✔
54	}	38✔
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,229✔
70	if i, ok := val.(*uint8); ok {	20,457✔
71	return EUint8T(w, *i, buf)	10,228✔
72	}	10,228✔
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,228✔
80	buf[0] = val	10,228✔
81	_, err := w.Write(buf[:1])	10,228✔
82	return err	10,228✔
83	}	10,228✔
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 {	491,606✔
88	if i, ok := val.(*uint16); ok {	983,211✔
89	return EUint16T(w, *i, buf)	491,605✔
90	}	491,605✔
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 {	491,605✔
98	byteOrder.PutUint16(buf[:2], val)	491,605✔
99	_, err := w.Write(buf[:2])	491,605✔
100	return err	491,605✔
101	}	491,605✔
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 {	244,717✔
106	if i, ok := val.(*uint32); ok {	489,433✔
107	return EUint32T(w, *i, buf)	244,716✔
108	}	244,716✔
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 {	259,942✔
116	byteOrder.PutUint32(buf[:4], val)	259,942✔
117	_, err := w.Write(buf[:4])	259,942✔
118	return err	259,942✔
119	}	259,942✔
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,608✔
124	if i, ok := val.(*uint64); ok {	73,215✔
125	return EUint64T(w, *i, buf)	36,607✔
126	}	36,607✔
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 {	41,157✔
134	byteOrder.PutUint64(buf[:], val)	41,157✔
135	_, err := w.Write(buf[:])	41,157✔
136	return err	41,157✔
137	}	41,157✔
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 {	236,544✔
141	if i, ok := val.(*bool); ok {	473,087✔
142	return EBoolT(w, *i, buf)	236,543✔
143	}	236,543✔
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 {	236,543✔
151	if val {	354,545✔
152	buf[0] = 1	118,002✔
153	} else {	236,543✔
154	buf[0] = 0	118,541✔
155	}	118,541✔
156	_, err := w.Write(buf[:1])	236,543✔
157	return err	236,543✔
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,097✔
163	if i, ok := val.(*uint8); ok && l == 1 {	22,193✔
164	if _, err := io.ReadFull(r, buf[:1]); err != nil {	11,096✔
165	return err	×
166	}	×
167	*i = buf[0]	11,096✔
168	return nil	11,096✔
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,255✔
176	if i, ok := val.(*uint16); ok && l == 2 {	20,506✔
177	if _, err := io.ReadFull(r, buf[:2]); err != nil {	10,251✔
UNCOV 178	return err	×
UNCOV 179	}	×
180	*i = byteOrder.Uint16(buf[:2])	10,251✔
181	return nil	10,251✔
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,781✔
189	if i, ok := val.(*uint32); ok && l == 4 {	69,559✔
190	if _, err := io.ReadFull(r, buf[:4]); err != nil {	34,781✔
191	return err	3✔
192	}	3✔
193	*i = byteOrder.Uint32(buf[:4])	34,775✔
194	return nil	34,775✔
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,614✔
202	if i, ok := val.(*uint64); ok && l == 8 {	125,225✔
203	if _, err := io.ReadFull(r, buf[:]); err != nil {	62,613✔
204	return err	2✔
205	}	2✔
206	*i = byteOrder.Uint64(buf[:])	62,609✔
207	return nil	62,609✔
208	}
209	return NewTypeForDecodingErr(val, "uint64", l, 8)	3✔
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 {	252,850✔
230	if b, ok := val.(*[32]byte); ok {	505,699✔
231	_, err := w.Write(b[:])	252,849✔
232	return err	252,849✔
233	}	252,849✔
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 {	314✔
250	if b, ok := val.(*[33]byte); ok {	627✔
251	_, err := w.Write(b[:])	313✔
252	return err	313✔
253	}	313✔
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 {	302✔
260	if b, ok := val.(*[33]byte); ok {	603✔
261	_, err := io.ReadFull(r, b[:])	301✔
262	return err	301✔
263	}	301✔
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 {	324✔
270	if b, ok := val.(*[64]byte); ok {	647✔
271	_, err := w.Write(b[:])	323✔
272	return err	323✔
273	}	323✔
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 {	338✔
280	if b, ok := val.(*[64]byte); ok && l == 64 {	671✔
281	_, err := io.ReadFull(r, b[:])	333✔
282	return err	333✔
283	}	333✔
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 {	89✔
290	if pk, ok := val.(**btcec.PublicKey); ok {	177✔
291	_, err := w.Write((*pk).SerializeCompressed())	88✔
292	return err	88✔
293	}	88✔
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 {	74✔
300	if pk, ok := val.(**btcec.PublicKey); ok && l == 33 {	147✔
301	var b [33]byte	73✔
302	_, err := io.ReadFull(r, b[:])	73✔
303	if err != nil {	73✔
UNCOV 304	return err	×
UNCOV 305	}	×
306
307	p, err := btcec.ParsePubKey(b[:])	73✔
308	if err != nil {	74✔
309	return err	1✔
310	}	1✔
311
312	*pk = p	72✔
313		72✔
314	return nil	72✔
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,003✔
322	if b, ok := val.(*[]byte); ok {	36,005✔
323	_, err := w.Write(*b)	18,002✔
324	return err	18,002✔
325	}	18,002✔
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,782✔
332	if b, ok := val.(*[]byte); ok {	39,563✔
333	*b = make([]byte, l)	19,781✔
334	_, err := io.ReadFull(r, *b)	19,781✔
335	return err	19,781✔
336	}	19,781✔
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 {	254,680✔
343	if i, ok := val.(*uint32); ok {	254,683✔
344	return WriteVarInt(w, uint64(*i), buf)	3✔
345	}	3✔
346
347	if i, ok := val.(*uint64); ok {	509,354✔
348	return WriteVarInt(w, uint64(*i), buf)	254,677✔
349	}	254,677✔
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 {	10,116✔
357	if i, ok := val.(*uint32); ok {	10,119✔
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 {	20,226✔
367	v, err := ReadVarInt(r, buf)	10,113✔
368	if err != nil {	10,113✔
369	return err	×
370	}	×
371	*i = v	10,113✔
372	return nil	10,113✔
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 {	268,837✔
380	var size uint64	268,837✔
381		268,837✔
382	if i, ok := val.(*uint32); ok {	268,843✔
383	size = VarIntSize(uint64(*i))	6✔
384	}	6✔
385
386	if i, ok := val.(*uint64); ok {	537,320✔
387	size = VarIntSize(uint64(*i))	268,483✔
388	}	268,483✔
389
390	return func() uint64 {	523,517✔
391	return size	254,680✔
392	}	254,680✔
393	}

lightningnetwork / lnd / 11393106485

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