15561477203

Committed 10 Jun 2025 01:54PM UTC coverage: 58.351% (-10.1%) from 68.487%

Build # 15561477203

Build Type

Pull #9356

github

Committed by

web-flow

Commit Message

Merge 6440b25db into c6d6d4c0b

Pull Request Pull Request #9356: lnrpc: add incoming/outgoing channel ids filter to forwarding history request

Run Details

33 of 36 new or added lines in 2 files covered. (91.67%)

28366 existing lines in 455 files now uncovered.

97715 of 167461 relevant lines covered (58.35%)

1.81 hits per line

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

72.58

/lnwire/timestamps.go

package lnwire

import (
        "bytes"
        "fmt"
        "io"

        "github.com/lightningnetwork/lnd/tlv"
)

const (
        // TimestampsRecordType is the TLV number of the timestamps TLV record
        // in the reply_channel_range message.
        TimestampsRecordType tlv.Type = 1

        // timestampPairSize is the number of bytes required to encode two
        // timestamps. Each timestamp is four bytes.
        timestampPairSize = 8
)

// Timestamps is a type representing the timestamps TLV field used in the
// reply_channel_range message to communicate the timestamps info of the updates
// of the SCID list being communicated.
type Timestamps []ChanUpdateTimestamps

// ChanUpdateTimestamps holds the timestamp info of the latest known channel
// updates corresponding to the two sides of a channel.
type ChanUpdateTimestamps struct {
        Timestamp1 uint32
        Timestamp2 uint32
}

// Record constructs the tlv.Record from the Timestamps.
func (t *Timestamps) Record() tlv.Record {
        return tlv.MakeDynamicRecord(
                TimestampsRecordType, t, t.encodedLen, timeStampsEncoder,
                timeStampsDecoder,
        )
}

// encodedLen calculates the length of the encoded Timestamps.
func (t *Timestamps) encodedLen() uint64 {
        return uint64(1 + timestampPairSize*(len(*t)))
}

// timeStampsEncoder encodes the Timestamps and writes the encoded bytes to the
// given writer.
func timeStampsEncoder(w io.Writer, val interface{}, _ *[8]byte) error {
        if v, ok := val.(*Timestamps); ok {
                var buf bytes.Buffer

                // Add the encoding byte.
                err := WriteQueryEncoding(&buf, EncodingSortedPlain)
                if err != nil {
                        return err
                }

                // For each timestamp, write 4 byte timestamp of node 1 and the
                // 4 byte timestamp of node 2.
                for _, timestamps := range *v {
                        err = WriteUint32(&buf, timestamps.Timestamp1)
                        if err != nil {
                                return err
                        }

                        err = WriteUint32(&buf, timestamps.Timestamp2)
                        if err != nil {
                                return err
                        }
                }

                _, err = w.Write(buf.Bytes())

                return err
        }

        return tlv.NewTypeForEncodingErr(val, "lnwire.Timestamps")
}

// timeStampsDecoder attempts to read and reconstruct a Timestamps object from
// the given reader.
func timeStampsDecoder(r io.Reader, val interface{}, _ *[8]byte,
        l uint64) error {

        if v, ok := val.(*Timestamps); ok {
                var encodingByte [1]byte
                if _, err := r.Read(encodingByte[:]); err != nil {
                        return err
                }

                encoding := QueryEncoding(encodingByte[0])
                if encoding != EncodingSortedPlain {
                        return fmt.Errorf("unsupported encoding: %x", encoding)
                }

                // The number of timestamps bytes is equal to the passed length
                // minus one since the first byte is used for the encoding type.
                numTimestampBytes := l - 1

                if numTimestampBytes%timestampPairSize != 0 {
                        return fmt.Errorf("whole number of timestamps not " +
                                "encoded")
                }

                numTimestamps := int(numTimestampBytes) / timestampPairSize
                timestamps := make(Timestamps, numTimestamps)
                for i := 0; i < numTimestamps; i++ {
                        err := ReadElements(
                                r, &timestamps[i].Timestamp1,
                                &timestamps[i].Timestamp2,
                        )
                        if err != nil {
                                return err
                        }
                }

                *v = timestamps

                return nil
        }

        return tlv.NewTypeForEncodingErr(val, "lnwire.Timestamps")
}

1	package lnwire
2
3	import (
4	"bytes"
5	"fmt"
6	"io"
7
8	"github.com/lightningnetwork/lnd/tlv"
9	)
10
11	const (
12	// TimestampsRecordType is the TLV number of the timestamps TLV record
13	// in the reply_channel_range message.
14	TimestampsRecordType tlv.Type = 1
15
16	// timestampPairSize is the number of bytes required to encode two
17	// timestamps. Each timestamp is four bytes.
18	timestampPairSize = 8
19	)
20
21	// Timestamps is a type representing the timestamps TLV field used in the
22	// reply_channel_range message to communicate the timestamps info of the updates
23	// of the SCID list being communicated.
24	type Timestamps []ChanUpdateTimestamps
25
26	// ChanUpdateTimestamps holds the timestamp info of the latest known channel
27	// updates corresponding to the two sides of a channel.
28	type ChanUpdateTimestamps struct {
29	Timestamp1 uint32
30	Timestamp2 uint32
31	}
32
33	// Record constructs the tlv.Record from the Timestamps.
34	func (t *Timestamps) Record() tlv.Record {	3✔
35	return tlv.MakeDynamicRecord(	3✔
36	TimestampsRecordType, t, t.encodedLen, timeStampsEncoder,	3✔
37	timeStampsDecoder,	3✔
38	)	3✔
39	}	3✔
40
41	// encodedLen calculates the length of the encoded Timestamps.
42	func (t *Timestamps) encodedLen() uint64 {	3✔
43	return uint64(1 + timestampPairSize(len(t)))	3✔
44	}	3✔
45
46	// timeStampsEncoder encodes the Timestamps and writes the encoded bytes to the
47	// given writer.
48	func timeStampsEncoder(w io.Writer, val interface{}, _ *[8]byte) error {	3✔
49	if v, ok := val.(*Timestamps); ok {	6✔
50	var buf bytes.Buffer	3✔
51		3✔
52	// Add the encoding byte.	3✔
53	err := WriteQueryEncoding(&buf, EncodingSortedPlain)	3✔
54	if err != nil {	3✔
55	return err	×
56	}	×
57
58	// For each timestamp, write 4 byte timestamp of node 1 and the
59	// 4 byte timestamp of node 2.
60	for _, timestamps := range *v {	6✔
61	err = WriteUint32(&buf, timestamps.Timestamp1)	3✔
62	if err != nil {	3✔
63	return err	×
64	}	×
65
66	err = WriteUint32(&buf, timestamps.Timestamp2)	3✔
67	if err != nil {	3✔
68	return err	×
69	}	×
70	}
71
72	_, err = w.Write(buf.Bytes())	3✔
73		3✔
74	return err	3✔
75	}
76
77	return tlv.NewTypeForEncodingErr(val, "lnwire.Timestamps")	×
78	}
79
80	// timeStampsDecoder attempts to read and reconstruct a Timestamps object from
81	// the given reader.
82	func timeStampsDecoder(r io.Reader, val interface{}, _ *[8]byte,
83	l uint64) error {	3✔
84		3✔
85	if v, ok := val.(*Timestamps); ok {	6✔
86	var encodingByte [1]byte	3✔
87	if _, err := r.Read(encodingByte[:]); err != nil {	3✔
UNCOV 88	return err	×
UNCOV 89	}	×
90
91	encoding := QueryEncoding(encodingByte[0])	3✔
92	if encoding != EncodingSortedPlain {	3✔
UNCOV 93	return fmt.Errorf("unsupported encoding: %x", encoding)	×
UNCOV 94	}	×
95
96	// The number of timestamps bytes is equal to the passed length
97	// minus one since the first byte is used for the encoding type.
98	numTimestampBytes := l - 1	3✔
99		3✔
100	if numTimestampBytes%timestampPairSize != 0 {	3✔
UNCOV 101	return fmt.Errorf("whole number of timestamps not " +	×
UNCOV 102	"encoded")	×
UNCOV 103	}	×
104
105	numTimestamps := int(numTimestampBytes) / timestampPairSize	3✔
106	timestamps := make(Timestamps, numTimestamps)	3✔
107	for i := 0; i < numTimestamps; i++ {	6✔
108	err := ReadElements(	3✔
109	r, &timestamps[i].Timestamp1,	3✔
110	&timestamps[i].Timestamp2,	3✔
111	)	3✔
112	if err != nil {	3✔
UNCOV 113	return err	×
UNCOV 114	}	×
115	}
116
117	*v = timestamps	3✔
118		3✔
119	return nil	3✔
120	}
121
122	return tlv.NewTypeForEncodingErr(val, "lnwire.Timestamps")	×
123	}

lightningnetwork / lnd / 15561477203

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