12343072627

Committed 15 Dec 2024 11:09PM UTC coverage: 57.504% (-1.1%) from 58.636%

Build # 12343072627

Build Type

Pull #9315

github

Committed by

yyforyongyu

Commit Message

contractcourt: offer outgoing htlc one block earlier before its expiry

We need to offer the outgoing htlc one block earlier to make sure when
the expiry height hits, the sweeper will not miss sweeping it in the
same block. This also means the outgoing contest resolver now only does
one thing - watch for preimage spend till height expiry-1, which can
easily be moved into the timeout resolver instead in the future.

Pull Request Pull Request #9315: Implement `blockbeat`

Run Details

1445 of 2007 new or added lines in 26 files covered. (72.0%)

19246 existing lines in 249 files now uncovered.

102342 of 177975 relevant lines covered (57.5%)

24772.24 hits per line

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

68.0

/record/amp.go

package record

import (
        "fmt"
        "io"

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

// AMPOnionType is the type used in the onion to reference the AMP fields:
// root_share, set_id, and child_index.
const AMPOnionType tlv.Type = 14

// AMP is a record that encodes the fields necessary for atomic multi-path
// payments.
type AMP struct {
        rootShare  [32]byte
        setID      [32]byte
        childIndex uint32
}

// MaxAmpPayLoadSize is an AMP Record which when serialized to a tlv record uses
// the maximum payload size. The `childIndex` is created randomly and is a
// 4 byte `varint` type so we make sure we use an index which will be encoded in
// 4 bytes.
var MaxAmpPayLoadSize = AMP{
        rootShare:  [32]byte{},
        setID:      [32]byte{},
        childIndex: 0x80000000,
}

// NewAMP generate a new AMP record with the given root_share, set_id, and
// child_index.
func NewAMP(rootShare, setID [32]byte, childIndex uint32) *AMP {
        return &AMP{
                rootShare:  rootShare,
                setID:      setID,
                childIndex: childIndex,
        }
}

// RootShare returns the root share contained in the AMP record.
func (a *AMP) RootShare() [32]byte {
        return a.rootShare
}

// SetID returns the set id contained in the AMP record.
func (a *AMP) SetID() [32]byte {
        return a.setID
}

// ChildIndex returns the child index contained in the AMP record.
func (a *AMP) ChildIndex() uint32 {
        return a.childIndex
}

// AMPEncoder writes the AMP record to the provided io.Writer.
func AMPEncoder(w io.Writer, val interface{}, buf *[8]byte) error {
        if v, ok := val.(*AMP); ok {
                if err := tlv.EBytes32(w, &v.rootShare, buf); err != nil {
                        return err
                }

                if err := tlv.EBytes32(w, &v.setID, buf); err != nil {
                        return err
                }

                return tlv.ETUint32T(w, v.childIndex, buf)
        }
        return tlv.NewTypeForEncodingErr(val, "AMP")
}

const (
        // minAMPLength is the minimum length of a serialized AMP TLV record,
        // which occurs when the truncated encoding of child_index takes 0
        // bytes, leaving only the root_share and set_id.
        minAMPLength = 64

        // maxAMPLength is the maximum length of a serialized AMP TLV record,
        // which occurs when the truncated encoding of a child_index takes 2
        // bytes.
        maxAMPLength = 68
)

// AMPDecoder reads the AMP record from the provided io.Reader.
func AMPDecoder(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
        if v, ok := val.(*AMP); ok && minAMPLength <= l && l <= maxAMPLength {
                if err := tlv.DBytes32(r, &v.rootShare, buf, 32); err != nil {
                        return err
                }

                if err := tlv.DBytes32(r, &v.setID, buf, 32); err != nil {
                        return err
                }

                return tlv.DTUint32(r, &v.childIndex, buf, l-minAMPLength)
        }
        return tlv.NewTypeForDecodingErr(val, "AMP", l, maxAMPLength)
}

// Record returns a tlv.Record that can be used to encode or decode this record.
func (a *AMP) Record() tlv.Record {
        return tlv.MakeDynamicRecord(
                AMPOnionType, a, a.PayloadSize, AMPEncoder, AMPDecoder,
        )
}

// PayloadSize returns the size this record takes up in encoded form.
func (a *AMP) PayloadSize() uint64 {
        return 32 + 32 + tlv.SizeTUint32(a.childIndex)
}

// String returns a human-readable description of the amp payload fields.
func (a *AMP) String() string {
        if a == nil {
                return "<nil>"
        }

        return fmt.Sprintf("root_share=%x set_id=%x child_index=%d",
                a.rootShare, a.setID, a.childIndex)
}

1	package record
2
3	import (
4	"fmt"
5	"io"
6
7	"github.com/lightningnetwork/lnd/tlv"
8	)
9
10	// AMPOnionType is the type used in the onion to reference the AMP fields:
11	// root_share, set_id, and child_index.
12	const AMPOnionType tlv.Type = 14
13
14	// AMP is a record that encodes the fields necessary for atomic multi-path
15	// payments.
16	type AMP struct {
17	rootShare [32]byte
18	setID [32]byte
19	childIndex uint32
20	}
21
22	// MaxAmpPayLoadSize is an AMP Record which when serialized to a tlv record uses
23	// the maximum payload size. The `childIndex` is created randomly and is a
24	// 4 byte `varint` type so we make sure we use an index which will be encoded in
25	// 4 bytes.
26	var MaxAmpPayLoadSize = AMP{
27	rootShare: [32]byte{},
28	setID: [32]byte{},
29	childIndex: 0x80000000,
30	}
31
32	// NewAMP generate a new AMP record with the given root_share, set_id, and
33	// child_index.
34	func NewAMP(rootShare, setID [32]byte, childIndex uint32) *AMP {	256✔
35	return &AMP{	256✔
36	rootShare: rootShare,	256✔
37	setID: setID,	256✔
38	childIndex: childIndex,	256✔
39	}	256✔
40	}	256✔
41
42	// RootShare returns the root share contained in the AMP record.
43	func (a *AMP) RootShare() [32]byte {	74✔
44	return a.rootShare	74✔
45	}	74✔
46
47	// SetID returns the set id contained in the AMP record.
48	func (a *AMP) SetID() [32]byte {	706✔
49	return a.setID	706✔
50	}	706✔
51
52	// ChildIndex returns the child index contained in the AMP record.
53	func (a *AMP) ChildIndex() uint32 {	74✔
54	return a.childIndex	74✔
55	}	74✔
56
57	// AMPEncoder writes the AMP record to the provided io.Writer.
58	func AMPEncoder(w io.Writer, val interface{}, buf *[8]byte) error {	106✔
59	if v, ok := val.(*AMP); ok {	212✔
60	if err := tlv.EBytes32(w, &v.rootShare, buf); err != nil {	106✔
61	return err	×
62	}	×
63
64	if err := tlv.EBytes32(w, &v.setID, buf); err != nil {	106✔
65	return err	×
66	}	×
67
68	return tlv.ETUint32T(w, v.childIndex, buf)	106✔
69	}
70	return tlv.NewTypeForEncodingErr(val, "AMP")	×
71	}
72
73	const (
74	// minAMPLength is the minimum length of a serialized AMP TLV record,
75	// which occurs when the truncated encoding of child_index takes 0
76	// bytes, leaving only the root_share and set_id.
77	minAMPLength = 64
78
79	// maxAMPLength is the maximum length of a serialized AMP TLV record,
80	// which occurs when the truncated encoding of a child_index takes 2
81	// bytes.
82	maxAMPLength = 68
83	)
84
85	// AMPDecoder reads the AMP record from the provided io.Reader.
86	func AMPDecoder(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {	739✔
87	if v, ok := val.(*AMP); ok && minAMPLength <= l && l <= maxAMPLength {	1,478✔
88	if err := tlv.DBytes32(r, &v.rootShare, buf, 32); err != nil {	739✔
89	return err	×
90	}	×
91
92	if err := tlv.DBytes32(r, &v.setID, buf, 32); err != nil {	739✔
93	return err	×
94	}	×
95
96	return tlv.DTUint32(r, &v.childIndex, buf, l-minAMPLength)	739✔
97	}
98	return tlv.NewTypeForDecodingErr(val, "AMP", l, maxAMPLength)	×
99	}
100
101	// Record returns a tlv.Record that can be used to encode or decode this record.
102	func (a *AMP) Record() tlv.Record {	799✔
103	return tlv.MakeDynamicRecord(	799✔
104	AMPOnionType, a, a.PayloadSize, AMPEncoder, AMPDecoder,	799✔
105	)	799✔
106	}	799✔
107
108	// PayloadSize returns the size this record takes up in encoded form.
109	func (a *AMP) PayloadSize() uint64 {	42✔
110	return 32 + 32 + tlv.SizeTUint32(a.childIndex)	42✔
111	}	42✔
112
113	// String returns a human-readable description of the amp payload fields.
UNCOV 114	func (a *AMP) String() string {	×
UNCOV 115	if a == nil {	×
UNCOV 116	return "<nil>"	×
UNCOV 117	}	×
118
UNCOV 119	return fmt.Sprintf("root_share=%x set_id=%x child_index=%d",	×
UNCOV 120	a.rootShare, a.setID, a.childIndex)	×
121	}

lightningnetwork / lnd / 12343072627

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