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

76.36

/lnwire/revoke_and_ack.go

package lnwire

import (
        "bytes"
        "io"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/lightningnetwork/lnd/tlv"
)

// RevokeAndAck is sent by either side once a CommitSig message has been
// received, and validated. This message serves to revoke the prior commitment
// transaction, which was the most up to date version until a CommitSig message
// referencing the specified ChannelPoint was received.  Additionally, this
// message also piggyback's the next revocation hash that Alice should use when
// constructing the Bob's version of the next commitment transaction (which
// would be done before sending a CommitSig message).  This piggybacking allows
// Alice to send the next CommitSig message modifying Bob's commitment
// transaction without first asking for a revocation hash initially.
type RevokeAndAck struct {
        // ChanID uniquely identifies to which currently active channel this
        // RevokeAndAck applies to.
        ChanID ChannelID

        // Revocation is the preimage to the revocation hash of the now prior
        // commitment transaction.
        Revocation [32]byte

        // NextRevocationKey is the next commitment point which should be used
        // for the next commitment transaction the remote peer creates for us.
        // This, in conjunction with revocation base point will be used to
        // create the proper revocation key used within the commitment
        // transaction.
        NextRevocationKey *btcec.PublicKey

        // LocalNonce is the next _local_ nonce for the sending party. This
        // allows the receiving party to propose a new commitment using their
        // remote nonce and the sender's local nonce.
        LocalNonce OptMusig2NonceTLV

        // ExtraData is the set of data that was appended to this message to
        // fill out the full maximum transport message size. These fields can
        // be used to specify optional data such as custom TLV fields.
        ExtraData ExtraOpaqueData
}

// NewRevokeAndAck creates a new RevokeAndAck message.
func NewRevokeAndAck() *RevokeAndAck {
        return &RevokeAndAck{
                ExtraData: make([]byte, 0),
        }
}

// A compile time check to ensure RevokeAndAck implements the lnwire.Message
// interface.
var _ Message = (*RevokeAndAck)(nil)

// Decode deserializes a serialized RevokeAndAck message stored in the
// passed io.Reader observing the specified protocol version.
//
// This is part of the lnwire.Message interface.
func (c *RevokeAndAck) Decode(r io.Reader, pver uint32) error {
        err := ReadElements(r,
                &c.ChanID,
                c.Revocation[:],
                &c.NextRevocationKey,
        )
        if err != nil {
                return err
        }

        var tlvRecords ExtraOpaqueData
        if err := ReadElements(r, &tlvRecords); err != nil {
                return err
        }

        localNonce := c.LocalNonce.Zero()
        typeMap, err := tlvRecords.ExtractRecords(&localNonce)
        if err != nil {
                return err
        }

        // Set the corresponding TLV types if they were included in the stream.
        if val, ok := typeMap[c.LocalNonce.TlvType()]; ok && val == nil {
                c.LocalNonce = tlv.SomeRecordT(localNonce)
        }

        if len(tlvRecords) != 0 {
                c.ExtraData = tlvRecords
        }

        return nil
}

// Encode serializes the target RevokeAndAck into the passed io.Writer
// observing the protocol version specified.
//
// This is part of the lnwire.Message interface.
func (c *RevokeAndAck) Encode(w *bytes.Buffer, pver uint32) error {
        recordProducers := make([]tlv.RecordProducer, 0, 1)
        c.LocalNonce.WhenSome(func(localNonce Musig2NonceTLV) {
                recordProducers = append(recordProducers, &localNonce)
        })
        err := EncodeMessageExtraData(&c.ExtraData, recordProducers...)
        if err != nil {
                return err
        }

        if err := WriteChannelID(w, c.ChanID); err != nil {
                return err
        }

        if err := WriteBytes(w, c.Revocation[:]); err != nil {
                return err
        }

        if err := WritePublicKey(w, c.NextRevocationKey); err != nil {
                return err
        }

        return WriteBytes(w, c.ExtraData)
}

// MsgType returns the integer uniquely identifying this message type on the
// wire.
//
// This is part of the lnwire.Message interface.
func (c *RevokeAndAck) MsgType() MessageType {
        return MsgRevokeAndAck
}

// TargetChanID returns the channel id of the link for which this message is
// intended.
//
// NOTE: Part of peer.LinkUpdater interface.
func (c *RevokeAndAck) TargetChanID() ChannelID {
        return c.ChanID
}

1	package lnwire
2
3	import (
4	"bytes"
5	"io"
6
7	"github.com/btcsuite/btcd/btcec/v2"
8	"github.com/lightningnetwork/lnd/tlv"
9	)
10
11	// RevokeAndAck is sent by either side once a CommitSig message has been
12	// received, and validated. This message serves to revoke the prior commitment
13	// transaction, which was the most up to date version until a CommitSig message
14	// referencing the specified ChannelPoint was received. Additionally, this
15	// message also piggyback's the next revocation hash that Alice should use when
16	// constructing the Bob's version of the next commitment transaction (which
17	// would be done before sending a CommitSig message). This piggybacking allows
18	// Alice to send the next CommitSig message modifying Bob's commitment
19	// transaction without first asking for a revocation hash initially.
20	type RevokeAndAck struct {
21	// ChanID uniquely identifies to which currently active channel this
22	// RevokeAndAck applies to.
23	ChanID ChannelID
24
25	// Revocation is the preimage to the revocation hash of the now prior
26	// commitment transaction.
27	Revocation [32]byte
28
29	// NextRevocationKey is the next commitment point which should be used
30	// for the next commitment transaction the remote peer creates for us.
31	// This, in conjunction with revocation base point will be used to
32	// create the proper revocation key used within the commitment
33	// transaction.
34	NextRevocationKey *btcec.PublicKey
35
36	// LocalNonce is the next _local_ nonce for the sending party. This
37	// allows the receiving party to propose a new commitment using their
38	// remote nonce and the sender's local nonce.
39	LocalNonce OptMusig2NonceTLV
40
41	// ExtraData is the set of data that was appended to this message to
42	// fill out the full maximum transport message size. These fields can
43	// be used to specify optional data such as custom TLV fields.
44	ExtraData ExtraOpaqueData
45	}
46
47	// NewRevokeAndAck creates a new RevokeAndAck message.
48	func NewRevokeAndAck() *RevokeAndAck {	100✔
49	return &RevokeAndAck{	100✔
50	ExtraData: make([]byte, 0),	100✔
51	}	100✔
52	}	100✔
53
54	// A compile time check to ensure RevokeAndAck implements the lnwire.Message
55	// interface.
56	var _ Message = (*RevokeAndAck)(nil)
57
58	// Decode deserializes a serialized RevokeAndAck message stored in the
59	// passed io.Reader observing the specified protocol version.
60	//
61	// This is part of the lnwire.Message interface.
62	func (c *RevokeAndAck) Decode(r io.Reader, pver uint32) error {	163✔
63	err := ReadElements(r,	163✔
64	&c.ChanID,	163✔
65	c.Revocation[:],	163✔
66	&c.NextRevocationKey,	163✔
67	)	163✔
68	if err != nil {	171✔
69	return err	8✔
70	}	8✔
71
72	var tlvRecords ExtraOpaqueData	155✔
73	if err := ReadElements(r, &tlvRecords); err != nil {	155✔
74	return err	×
75	}	×
76
77	localNonce := c.LocalNonce.Zero()	155✔
78	typeMap, err := tlvRecords.ExtractRecords(&localNonce)	155✔
79	if err != nil {	196✔
80	return err	41✔
81	}	41✔
82
83	// Set the corresponding TLV types if they were included in the stream.
84	if val, ok := typeMap[c.LocalNonce.TlvType()]; ok && val == nil {	165✔
85	c.LocalNonce = tlv.SomeRecordT(localNonce)	51✔
86	}	51✔
87
88	if len(tlvRecords) != 0 {	169✔
89	c.ExtraData = tlvRecords	55✔
90	}	55✔
91
92	return nil	114✔
93	}
94
95	// Encode serializes the target RevokeAndAck into the passed io.Writer
96	// observing the protocol version specified.
97	//
98	// This is part of the lnwire.Message interface.
99	func (c RevokeAndAck) Encode(w bytes.Buffer, pver uint32) error {	107✔
100	recordProducers := make([]tlv.RecordProducer, 0, 1)	107✔
101	c.LocalNonce.WhenSome(func(localNonce Musig2NonceTLV) {	157✔
102	recordProducers = append(recordProducers, &localNonce)	50✔
103	})	50✔
104	err := EncodeMessageExtraData(&c.ExtraData, recordProducers...)	107✔
105	if err != nil {	107✔
106	return err	×
107	}	×
108
109	if err := WriteChannelID(w, c.ChanID); err != nil {	107✔
110	return err	×
111	}	×
112
113	if err := WriteBytes(w, c.Revocation[:]); err != nil {	107✔
114	return err	×
115	}	×
116
117	if err := WritePublicKey(w, c.NextRevocationKey); err != nil {	107✔
118	return err	×
119	}	×
120
121	return WriteBytes(w, c.ExtraData)	107✔
122	}
123
124	// MsgType returns the integer uniquely identifying this message type on the
125	// wire.
126	//
127	// This is part of the lnwire.Message interface.
128	func (c *RevokeAndAck) MsgType() MessageType {	1,342✔
129	return MsgRevokeAndAck	1,342✔
130	}	1,342✔
131
132	// TargetChanID returns the channel id of the link for which this message is
133	// intended.
134	//
135	// NOTE: Part of peer.LinkUpdater interface.
UNCOV 136	func (c *RevokeAndAck) TargetChanID() ChannelID {	×
UNCOV 137	return c.ChanID	×
UNCOV 138	}	×

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