11216766535

Committed 07 Oct 2024 01:37PM UTC coverage: 57.817% (-1.0%) from 58.817%

Build # 11216766535

Build Type

Pull #9148

github

Committed by

ProofOfKeags

Commit Message

lnwire: remove kickoff feerate from propose/commit

Pull Request Pull Request #9148: DynComms [2/n]: lnwire: add authenticated wire messages for Dyn*

Run Details

571 of 879 new or added lines in 16 files covered. (64.96%)

23253 existing lines in 251 files now uncovered.

99022 of 171268 relevant lines covered (57.82%)

38420.67 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 {	171✔
85	c.LocalNonce = tlv.SomeRecordT(localNonce)	57✔
86	}	57✔
87
88	if len(tlvRecords) != 0 {	175✔
89	c.ExtraData = tlvRecords	61✔
90	}	61✔
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) {	163✔
102	recordProducers = append(recordProducers, &localNonce)	56✔
103	})	56✔
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 {	2,735✔
129	return MsgRevokeAndAck	2,735✔
130	}	2,735✔
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 / 11216766535

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