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

70.83

/lnwire/stfu.go

package lnwire

import (
        "bytes"
        "io"
)

// Stfu is a message that is sent to lock the channel state prior to some other
// interactive protocol where channel updates need to be paused.
type Stfu struct {
        // ChanID identifies which channel needs to be frozen.
        ChanID ChannelID

        // Initiator is a byte that identifies whether we are the initiator of
        // this process.
        Initiator bool

        // 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
}

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

// Encode serializes the target Stfu into the passed io.Writer.
// Serialization will observe the rules defined by the passed protocol version.
//
// This is a part of the lnwire.Message interface.
func (s *Stfu) Encode(w *bytes.Buffer, _ uint32) error {
        if err := WriteChannelID(w, s.ChanID); err != nil {
                return err
        }

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

        return WriteBytes(w, s.ExtraData)
}

// Decode deserializes the serialized Stfu stored in the passed io.Reader
// into the target Stfu using the deserialization rules defined by the
// passed protocol version.
//
// This is a part of the lnwire.Message interface.
func (s *Stfu) Decode(r io.Reader, _ uint32) error {
        if err := ReadElements(
                r, &s.ChanID, &s.Initiator, &s.ExtraData,
        ); err != nil {
                return err
        }

        // This is required to pass the fuzz test round trip equality check.
        if len(s.ExtraData) == 0 {
                s.ExtraData = nil
        }

        return nil
}

// MsgType returns the MessageType code which uniquely identifies this message
// as a Stfu on the wire.
//
// This is part of the lnwire.Message interface.
func (s *Stfu) MsgType() MessageType {
        return MsgStfu
}

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

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

1	package lnwire
2
3	import (
4	"bytes"
5	"io"
6	)
7
8	// Stfu is a message that is sent to lock the channel state prior to some other
9	// interactive protocol where channel updates need to be paused.
10	type Stfu struct {
11	// ChanID identifies which channel needs to be frozen.
12	ChanID ChannelID
13
14	// Initiator is a byte that identifies whether we are the initiator of
15	// this process.
16	Initiator bool
17
18	// ExtraData is the set of data that was appended to this message to
19	// fill out the full maximum transport message size. These fields can
20	// be used to specify optional data such as custom TLV fields.
21	ExtraData ExtraOpaqueData
22	}
23
24	// A compile time check to ensure Stfu implements the lnwire.Message interface.
25	var _ Message = (*Stfu)(nil)
26
27	// Encode serializes the target Stfu into the passed io.Writer.
28	// Serialization will observe the rules defined by the passed protocol version.
29	//
30	// This is a part of the lnwire.Message interface.
31	func (s Stfu) Encode(w bytes.Buffer, _ uint32) error {	115✔
32	if err := WriteChannelID(w, s.ChanID); err != nil {	115✔
33	return err	×
34	}	×
35
36	if err := WriteBool(w, s.Initiator); err != nil {	115✔
37	return err	×
38	}	×
39
40	return WriteBytes(w, s.ExtraData)	115✔
41	}
42
43	// Decode deserializes the serialized Stfu stored in the passed io.Reader
44	// into the target Stfu using the deserialization rules defined by the
45	// passed protocol version.
46	//
47	// This is a part of the lnwire.Message interface.
48	func (s *Stfu) Decode(r io.Reader, _ uint32) error {	133✔
49	if err := ReadElements(	133✔
50	r, &s.ChanID, &s.Initiator, &s.ExtraData,	133✔
51	); err != nil {	136✔
52	return err	3✔
53	}	3✔
54
55	// This is required to pass the fuzz test round trip equality check.
56	if len(s.ExtraData) == 0 {	179✔
57	s.ExtraData = nil	49✔
58	}	49✔
59
60	return nil	130✔
61	}
62
63	// MsgType returns the MessageType code which uniquely identifies this message
64	// as a Stfu on the wire.
65	//
66	// This is part of the lnwire.Message interface.
67	func (s *Stfu) MsgType() MessageType {	119✔
68	return MsgStfu	119✔
69	}	119✔
70
71	// A compile time check to ensure Stfu implements the
72	// lnwire.LinkUpdater interface.
73	var _ LinkUpdater = (*Stfu)(nil)
74
75	// TargetChanID returns the channel id of the link for which this message is
76	// intended.
77	//
78	// NOTE: Part of peer.LinkUpdater interface.
UNCOV 79	func (s *Stfu) TargetChanID() ChannelID {	×
UNCOV 80	return s.ChanID	×
UNCOV 81	}	×

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