15160358425

Committed 21 May 2025 10:56AM UTC coverage: 58.584% (-10.4%) from 68.996%

Build # 15160358425

Build Type

Pull #9847

github

Committed by

web-flow

Commit Message

Merge 2880b9a35 into c52a6ddeb

Pull Request Pull Request #9847: Refactor Payment PR 4

Run Details

634 of 942 new or added lines in 17 files covered. (67.3%)

28108 existing lines in 450 files now uncovered.

97449 of 166342 relevant lines covered (58.58%)

1.82 hits per line

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

68.67

/channeldb/mp_payment.go

package channeldb

import (
        "bytes"
        "io"
        "math"
        "time"

        "github.com/btcsuite/btcd/wire"
        "github.com/lightningnetwork/lnd/lnwire"
        pymtpkg "github.com/lightningnetwork/lnd/payments"
)

// serializeHTLCSettleInfo serializes the details of a settled htlc.
func serializeHTLCSettleInfo(w io.Writer, s *pymtpkg.HTLCSettleInfo) error {
        if _, err := w.Write(s.Preimage[:]); err != nil {
                return err
        }

        if err := serializeTime(w, s.SettleTime); err != nil {
                return err
        }

        return nil
}

// deserializeHTLCSettleInfo deserializes the details of a settled htlc.
func deserializeHTLCSettleInfo(r io.Reader) (*pymtpkg.HTLCSettleInfo, error) {
        s := &pymtpkg.HTLCSettleInfo{}
        if _, err := io.ReadFull(r, s.Preimage[:]); err != nil {
                return nil, err
        }

        var err error
        s.SettleTime, err = deserializeTime(r)
        if err != nil {
                return nil, err
        }

        return s, nil
}

// serializeHTLCFailInfo serializes the details of a failed htlc including the
// wire failure.
func serializeHTLCFailInfo(w io.Writer, f *pymtpkg.HTLCFailInfo) error {
        if err := serializeTime(w, f.FailTime); err != nil {
                return err
        }

        // Write failure. If there is no failure message, write an empty
        // byte slice.
        var messageBytes bytes.Buffer
        if f.Message != nil {
                err := lnwire.EncodeFailureMessage(&messageBytes, f.Message, 0)
                if err != nil {
                        return err
                }
        }
        if err := wire.WriteVarBytes(w, 0, messageBytes.Bytes()); err != nil {
                return err
        }

        return WriteElements(w, byte(f.Reason), f.FailureSourceIndex)
}

// deserializeHTLCFailInfo deserializes the details of a failed htlc including
// the wire failure.
func deserializeHTLCFailInfo(r io.Reader) (*pymtpkg.HTLCFailInfo, error) {
        f := &pymtpkg.HTLCFailInfo{}
        var err error
        f.FailTime, err = deserializeTime(r)
        if err != nil {
                return nil, err
        }

        // Read failure.
        failureBytes, err := wire.ReadVarBytes(
                r, 0, math.MaxUint16, "failure",
        )
        if err != nil {
                return nil, err
        }
        if len(failureBytes) > 0 {
                f.Message, err = lnwire.DecodeFailureMessage(
                        bytes.NewReader(failureBytes), 0,
                )
                if err != nil {
                        return nil, err
                }
        }

        var reason byte
        err = ReadElements(r, &reason, &f.FailureSourceIndex)
        if err != nil {
                return nil, err
        }
        f.Reason = pymtpkg.HTLCFailReason(reason)

        return f, nil
}

// deserializeTime deserializes time as unix nanoseconds.
func deserializeTime(r io.Reader) (time.Time, error) {
        var scratch [8]byte
        if _, err := io.ReadFull(r, scratch[:]); err != nil {
                return time.Time{}, err
        }

        // Convert to time.Time. Interpret unix nano time zero as a zero
        // time.Time value.
        unixNano := byteOrder.Uint64(scratch[:])
        if unixNano == 0 {
                return time.Time{}, nil
        }

        return time.Unix(0, int64(unixNano)), nil
}

// serializeTime serializes time as unix nanoseconds.
func serializeTime(w io.Writer, t time.Time) error {
        var scratch [8]byte

        // Convert to unix nano seconds, but only if time is non-zero. Calling
        // UnixNano() on a zero time yields an undefined result.
        var unixNano int64
        if !t.IsZero() {
                unixNano = t.UnixNano()
        }

        byteOrder.PutUint64(scratch[:], uint64(unixNano))
        _, err := w.Write(scratch[:])
        return err
}

1	package channeldb
2
3	import (
4	"bytes"
5	"io"
6	"math"
7	"time"
8
9	"github.com/btcsuite/btcd/wire"
10	"github.com/lightningnetwork/lnd/lnwire"
11	pymtpkg "github.com/lightningnetwork/lnd/payments"
12	)
13
14	// serializeHTLCSettleInfo serializes the details of a settled htlc.
15	func serializeHTLCSettleInfo(w io.Writer, s *pymtpkg.HTLCSettleInfo) error {	3✔
16	if _, err := w.Write(s.Preimage[:]); err != nil {	3✔
17	return err	×
18	}	×
19
20	if err := serializeTime(w, s.SettleTime); err != nil {	3✔
21	return err	×
22	}	×
23
24	return nil	3✔
25	}
26
27	// deserializeHTLCSettleInfo deserializes the details of a settled htlc.
28	func deserializeHTLCSettleInfo(r io.Reader) (*pymtpkg.HTLCSettleInfo, error) {	3✔
29	s := &pymtpkg.HTLCSettleInfo{}	3✔
30	if _, err := io.ReadFull(r, s.Preimage[:]); err != nil {	3✔
31	return nil, err	×
32	}	×
33
34	var err error	3✔
35	s.SettleTime, err = deserializeTime(r)	3✔
36	if err != nil {	3✔
37	return nil, err	×
38	}	×
39
40	return s, nil	3✔
41	}
42
43	// serializeHTLCFailInfo serializes the details of a failed htlc including the
44	// wire failure.
45	func serializeHTLCFailInfo(w io.Writer, f *pymtpkg.HTLCFailInfo) error {	3✔
46	if err := serializeTime(w, f.FailTime); err != nil {	3✔
47	return err	×
48	}	×
49
50	// Write failure. If there is no failure message, write an empty
51	// byte slice.
52	var messageBytes bytes.Buffer	3✔
53	if f.Message != nil {	6✔
54	err := lnwire.EncodeFailureMessage(&messageBytes, f.Message, 0)	3✔
55	if err != nil {	3✔
56	return err	×
57	}	×
58	}
59	if err := wire.WriteVarBytes(w, 0, messageBytes.Bytes()); err != nil {	3✔
60	return err	×
61	}	×
62
63	return WriteElements(w, byte(f.Reason), f.FailureSourceIndex)	3✔
64	}
65
66	// deserializeHTLCFailInfo deserializes the details of a failed htlc including
67	// the wire failure.
68	func deserializeHTLCFailInfo(r io.Reader) (*pymtpkg.HTLCFailInfo, error) {	3✔
69	f := &pymtpkg.HTLCFailInfo{}	3✔
70	var err error	3✔
71	f.FailTime, err = deserializeTime(r)	3✔
72	if err != nil {	3✔
73	return nil, err	×
74	}	×
75
76	// Read failure.
77	failureBytes, err := wire.ReadVarBytes(	3✔
78	r, 0, math.MaxUint16, "failure",	3✔
79	)	3✔
80	if err != nil {	3✔
81	return nil, err	×
82	}	×
83	if len(failureBytes) > 0 {	6✔
84	f.Message, err = lnwire.DecodeFailureMessage(	3✔
85	bytes.NewReader(failureBytes), 0,	3✔
86	)	3✔
87	if err != nil {	3✔
88	return nil, err	×
89	}	×
90	}
91
92	var reason byte	3✔
93	err = ReadElements(r, &reason, &f.FailureSourceIndex)	3✔
94	if err != nil {	3✔
95	return nil, err	×
96	}	×
97	f.Reason = pymtpkg.HTLCFailReason(reason)	3✔
98		3✔
99	return f, nil	3✔
100	}
101
102	// deserializeTime deserializes time as unix nanoseconds.
103	func deserializeTime(r io.Reader) (time.Time, error) {	3✔
104	var scratch [8]byte	3✔
105	if _, err := io.ReadFull(r, scratch[:]); err != nil {	3✔
106	return time.Time{}, err	×
107	}	×
108
109	// Convert to time.Time. Interpret unix nano time zero as a zero
110	// time.Time value.
111	unixNano := byteOrder.Uint64(scratch[:])	3✔
112	if unixNano == 0 {	3✔
UNCOV 113	return time.Time{}, nil	×
UNCOV 114	}	×
115
116	return time.Unix(0, int64(unixNano)), nil	3✔
117	}
118
119	// serializeTime serializes time as unix nanoseconds.
120	func serializeTime(w io.Writer, t time.Time) error {	3✔
121	var scratch [8]byte	3✔
122		3✔
123	// Convert to unix nano seconds, but only if time is non-zero. Calling	3✔
124	// UnixNano() on a zero time yields an undefined result.	3✔
125	var unixNano int64	3✔
126	if !t.IsZero() {	6✔
127	unixNano = t.UnixNano()	3✔
128	}	3✔
129
130	byteOrder.PutUint64(scratch[:], uint64(unixNano))	3✔
131	_, err := w.Write(scratch[:])	3✔
132	return err	3✔
133	}

lightningnetwork / lnd / 15160358425

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