13035292482

Committed 29 Jan 2025 03:59PM UTC coverage: 49.3% (-9.5%) from 58.777%

Build # 13035292482

Build Type

Pull #9456

github

Committed by

mohamedawnallah

Commit Message

docs: update release-notes-0.19.0.md

In this commit, we warn users about the removal
of RPCs `SendToRoute`, `SendToRouteSync`, `SendPayment`,
and `SendPaymentSync` in the next release 0.20.

Pull Request Pull Request #9456: lnrpc+docs: deprecate warning `SendToRoute`, `SendToRouteSync`, `SendPayment`, and `SendPaymentSync` in Release 0.19

Run Details

100634 of 204126 relevant lines covered (49.3%)

1.54 hits per line

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

73.58

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

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

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 {	3✔
50		3✔
51	return &ClosingSigned{	3✔
52	ChannelID: cid,	3✔
53	FeeSatoshis: fs,	3✔
54	Signature: sig,	3✔
55	}	3✔
56	}	3✔
57
58	// A compile time check to ensure ClosingSigned implements the lnwire.Message
59	// interface.
60	var _ Message = (*ClosingSigned)(nil)
61
62	// Decode deserializes a serialized ClosingSigned message stored in the passed
63	// io.Reader observing the specified protocol version.
64	//
65	// This is part of the lnwire.Message interface.
66	func (c *ClosingSigned) Decode(r io.Reader, pver uint32) error {	3✔
67	err := ReadElements(	3✔
68	r, &c.ChannelID, &c.FeeSatoshis, &c.Signature,	3✔
69	)	3✔
70	if err != nil {	3✔
71	return err	×
72	}	×
73
74	var tlvRecords ExtraOpaqueData	3✔
75	if err := ReadElements(r, &tlvRecords); err != nil {	3✔
76	return err	×
77	}	×
78
79	partialSig := c.PartialSig.Zero()	3✔
80	typeMap, err := tlvRecords.ExtractRecords(&partialSig)	3✔
81	if err != nil {	3✔
82	return err	×
83	}	×
84
85	// Set the corresponding TLV types if they were included in the stream.
86	if val, ok := typeMap[c.PartialSig.TlvType()]; ok && val == nil {	6✔
87	c.PartialSig = tlv.SomeRecordT(partialSig)	3✔
88	}	3✔
89
90	if len(tlvRecords) != 0 {	6✔
91	c.ExtraData = tlvRecords	3✔
92	}	3✔
93
94	return nil	3✔
95	}
96
97	// Encode serializes the target ClosingSigned into the passed io.Writer
98	// observing the protocol version specified.
99	//
100	// This is part of the lnwire.Message interface.
101	func (c ClosingSigned) Encode(w bytes.Buffer, pver uint32) error {	3✔
102	recordProducers := make([]tlv.RecordProducer, 0, 1)	3✔
103	c.PartialSig.WhenSome(func(sig PartialSigTLV) {	6✔
104	recordProducers = append(recordProducers, &sig)	3✔
105	})	3✔
106	err := EncodeMessageExtraData(&c.ExtraData, recordProducers...)	3✔
107	if err != nil {	3✔
108	return err	×
109	}	×
110
111	if err := WriteChannelID(w, c.ChannelID); err != nil {	3✔
112	return err	×
113	}	×
114
115	if err := WriteSatoshi(w, c.FeeSatoshis); err != nil {	3✔
116	return err	×
117	}	×
118
119	if err := WriteSig(w, c.Signature); err != nil {	3✔
120	return err	×
121	}	×
122
123	return WriteBytes(w, c.ExtraData)	3✔
124	}
125
126	// MsgType returns the integer uniquely identifying this message type on the
127	// wire.
128	//
129	// This is part of the lnwire.Message interface.
130	func (c *ClosingSigned) MsgType() MessageType {	3✔
131	return MsgClosingSigned	3✔
132	}	3✔

lightningnetwork / lnd / 13035292482

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