14035127674

Committed 24 Mar 2025 12:21PM UTC coverage: 68.999% (+0.01%) from 68.989%

Build # 14035127674

Build Type

Pull #9631

github

Committed by

web-flow

Commit Message

Merge 06c7cd82e into 5235f3b24

Pull Request Pull Request #9631: rpcserver: warn if sendcoins default conf target is used

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

79 existing lines in 23 files now uncovered.

132917 of 192637 relevant lines covered (69.0%)

22283.53 hits per line

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

76.79

/lnwire/closing_signed.go

package lnwire

import (
        "bytes"
        "io"

        "github.com/btcsuite/btcd/btcutil"
        "github.com/lightningnetwork/lnd/tlv"
)

// ClosingSigned is sent by both parties to a channel once the channel is clear
// of HTLCs, and is primarily concerned with negotiating fees for the close
// transaction. Each party provides a signature for a transaction with a fee
// that they believe is fair. The process terminates when both sides agree on
// the same fee, or when one side force closes the channel.
//
// NOTE: The responder is able to send a signature without any additional
// messages as all transactions are assembled observing BIP 69 which defines a
// canonical ordering for input/outputs. Therefore, both sides are able to
// arrive at an identical closure transaction as they know the order of the
// inputs/outputs.
type ClosingSigned struct {
        // ChannelID serves to identify which channel is to be closed.
        ChannelID ChannelID

        // FeeSatoshis is the total fee in satoshis that the party to the
        // channel would like to propose for the close transaction.
        FeeSatoshis btcutil.Amount

        // Signature is for the proposed channel close transaction.
        Signature Sig

        // PartialSig is used to transmit a musig2 extended partial signature
        // that signs the latest fee offer. The nonce isn't sent along side, as
        // that has already been sent in the initial shutdown message.
        //
        // NOTE: This field is only populated if a musig2 taproot channel is
        // being signed for. In this case, the above Sig type MUST be blank.
        PartialSig OptPartialSigTLV

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

// NewClosingSigned creates a new empty ClosingSigned message.
func NewClosingSigned(cid ChannelID, fs btcutil.Amount,
        sig Sig) *ClosingSigned {

        return &ClosingSigned{
                ChannelID:   cid,
                FeeSatoshis: fs,
                Signature:   sig,
        }
}

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

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

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

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

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

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

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

        return nil
}

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

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

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

        if err := WriteSig(w, c.Signature); 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 *ClosingSigned) MsgType() MessageType {
        return MsgClosingSigned
}

// SerializedSize returns the serialized size of the message in bytes.
//
// This is part of the lnwire.SizeableMessage interface.
func (c *ClosingSigned) SerializedSize() (uint32, error) {
        return MessageSerializedSize(c)
}

1	package lnwire
2
3	import (
4	"bytes"
5	"io"
6
7	"github.com/btcsuite/btcd/btcutil"
8	"github.com/lightningnetwork/lnd/tlv"
9	)
10
11	// ClosingSigned is sent by both parties to a channel once the channel is clear
12	// of HTLCs, and is primarily concerned with negotiating fees for the close
13	// transaction. Each party provides a signature for a transaction with a fee
14	// that they believe is fair. The process terminates when both sides agree on
15	// the same fee, or when one side force closes the channel.
16	//
17	// NOTE: The responder is able to send a signature without any additional
18	// messages as all transactions are assembled observing BIP 69 which defines a
19	// canonical ordering for input/outputs. Therefore, both sides are able to
20	// arrive at an identical closure transaction as they know the order of the
21	// inputs/outputs.
22	type ClosingSigned struct {
23	// ChannelID serves to identify which channel is to be closed.
24	ChannelID ChannelID
25
26	// FeeSatoshis is the total fee in satoshis that the party to the
27	// channel would like to propose for the close transaction.
28	FeeSatoshis btcutil.Amount
29
30	// Signature is for the proposed channel close transaction.
31	Signature Sig
32
33	// PartialSig is used to transmit a musig2 extended partial signature
34	// that signs the latest fee offer. The nonce isn't sent along side, as
35	// that has already been sent in the initial shutdown message.
36	//
37	// NOTE: This field is only populated if a musig2 taproot channel is
38	// being signed for. In this case, the above Sig type MUST be blank.
39	PartialSig OptPartialSigTLV
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	// NewClosingSigned creates a new empty ClosingSigned message.
48	func NewClosingSigned(cid ChannelID, fs btcutil.Amount,
49	sig Sig) *ClosingSigned {	22✔
50		22✔
51	return &ClosingSigned{	22✔
52	ChannelID: cid,	22✔
53	FeeSatoshis: fs,	22✔
54	Signature: sig,	22✔
55	}	22✔
56	}	22✔
57
58	// A compile time check to ensure ClosingSigned implements the lnwire.Message
59	// interface.
60	var _ Message = (*ClosingSigned)(nil)
61
62	// A compile time check to ensure ClosingSigned implements the
63	// lnwire.SizeableMessage interface.
64	var _ SizeableMessage = (*ClosingSigned)(nil)
65
66	// Decode deserializes a serialized ClosingSigned message stored in the passed
67	// io.Reader observing the specified protocol version.
68	//
69	// This is part of the lnwire.Message interface.
70	func (c *ClosingSigned) Decode(r io.Reader, pver uint32) error {	176✔
71	err := ReadElements(	176✔
72	r, &c.ChannelID, &c.FeeSatoshis, &c.Signature,	176✔
73	)	176✔
74	if err != nil {	181✔
75	return err	5✔
76	}	5✔
77
78	var tlvRecords ExtraOpaqueData	171✔
79	if err := ReadElements(r, &tlvRecords); err != nil {	171✔
80	return err	×
81	}	×
82
83	partialSig := c.PartialSig.Zero()	171✔
84	typeMap, err := tlvRecords.ExtractRecords(&partialSig)	171✔
85	if err != nil {	215✔
86	return err	44✔
87	}	44✔
88
89	// Set the corresponding TLV types if they were included in the stream.
90	if val, ok := typeMap[c.PartialSig.TlvType()]; ok && val == nil {	191✔
91	c.PartialSig = tlv.SomeRecordT(partialSig)	64✔
92	}	64✔
93
94	if len(tlvRecords) != 0 {	200✔
95	c.ExtraData = tlvRecords	73✔
96	}	73✔
97
98	return nil	127✔
99	}
100
101	// Encode serializes the target ClosingSigned into the passed io.Writer
102	// observing the protocol version specified.
103	//
104	// This is part of the lnwire.Message interface.
105	func (c ClosingSigned) Encode(w bytes.Buffer, pver uint32) error {	115✔
106	recordProducers := make([]tlv.RecordProducer, 0, 1)	115✔
107	c.PartialSig.WhenSome(func(sig PartialSigTLV) {	177✔
108	recordProducers = append(recordProducers, &sig)	62✔
109	})	62✔
110	err := EncodeMessageExtraData(&c.ExtraData, recordProducers...)	115✔
111	if err != nil {	115✔
112	return err	×
113	}	×
114
115	if err := WriteChannelID(w, c.ChannelID); err != nil {	115✔
116	return err	×
117	}	×
118
119	if err := WriteSatoshi(w, c.FeeSatoshis); err != nil {	115✔
120	return err	×
121	}	×
122
123	if err := WriteSig(w, c.Signature); err != nil {	115✔
124	return err	×
125	}	×
126
127	return WriteBytes(w, c.ExtraData)	115✔
128	}
129
130	// MsgType returns the integer uniquely identifying this message type on the
131	// wire.
132	//
133	// This is part of the lnwire.Message interface.
134	func (c *ClosingSigned) MsgType() MessageType {	115✔
135	return MsgClosingSigned	115✔
136	}	115✔
137
138	// SerializedSize returns the serialized size of the message in bytes.
139	//
140	// This is part of the lnwire.SizeableMessage interface.
UNCOV 141	func (c *ClosingSigned) SerializedSize() (uint32, error) {	×
UNCOV 142	return MessageSerializedSize(c)	×
UNCOV 143	}	×

lightningnetwork / lnd / 14035127674

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