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

0.0

/lnwire/dyn_propose.go

package lnwire

import (
        "bytes"
        "io"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/btcsuite/btcd/btcutil"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/lnwallet/chainfee"
        "github.com/lightningnetwork/lnd/tlv"
)

const (
        // DPDustLimitSatoshis is the TLV type number that identifies the record
        // for DynPropose.DustLimit.
        DPDustLimitSatoshis tlv.Type = 0

        // DPMaxHtlcValueInFlightMsat is the TLV type number that identifies the
        // record for DynPropose.MaxValueInFlight.
        DPMaxHtlcValueInFlightMsat tlv.Type = 1

        // DPChannelReserveSatoshis is the TLV type number that identifies the
        // for DynPropose.ChannelReserve.
        DPChannelReserveSatoshis tlv.Type = 2

        // DPToSelfDelay is the TLV type number that identifies the record for
        // DynPropose.CsvDelay.
        DPToSelfDelay tlv.Type = 3

        // DPMaxAcceptedHtlcs is the TLV type number that identifies the record
        // for DynPropose.MaxAcceptedHTLCs.
        DPMaxAcceptedHtlcs tlv.Type = 4

        // DPFundingPubkey is the TLV type number that identifies the record for
        // DynPropose.FundingKey.
        DPFundingPubkey tlv.Type = 5

        // DPChannelType is the TLV type number that identifies the record for
        // DynPropose.ChannelType.
        DPChannelType tlv.Type = 6

        // DPKickoffFeerate is the TLV type number that identifies the record
        // for DynPropose.KickoffFeerate.
        DPKickoffFeerate tlv.Type = 7
)

// DynPropose is a message that is sent during a dynamic commitments negotiation
// process. It is sent by both parties to propose new channel parameters.
type DynPropose struct {
        // ChanID identifies the channel whose parameters we are trying to
        // re-negotiate.
        ChanID ChannelID

        // Initiator is a byte that identifies whether this message was sent as
        // the initiator of a dynamic commitment negotiation or the responder
        // of a dynamic commitment negotiation. bool true indicates it is the
        // initiator
        Initiator bool

        // DustLimit, if not nil, proposes a change to the dust_limit_satoshis
        // for the sender's commitment transaction.
        DustLimit fn.Option[btcutil.Amount]

        // MaxValueInFlight, if not nil, proposes a change to the
        // max_htlc_value_in_flight_msat limit of the sender.
        MaxValueInFlight fn.Option[MilliSatoshi]

        // ChannelReserve, if not nil, proposes a change to the
        // channel_reserve_satoshis requirement of the recipient.
        ChannelReserve fn.Option[btcutil.Amount]

        // CsvDelay, if not nil, proposes a change to the to_self_delay
        // requirement of the recipient.
        CsvDelay fn.Option[uint16]

        // MaxAcceptedHTLCs, if not nil, proposes a change to the
        // max_accepted_htlcs limit of the sender.
        MaxAcceptedHTLCs fn.Option[uint16]

        // FundingKey, if not nil, proposes a change to the funding_pubkey
        // parameter of the sender.
        FundingKey fn.Option[btcec.PublicKey]

        // ChannelType, if not nil, proposes a change to the channel_type
        // parameter.
        ChannelType fn.Option[ChannelType]

        // KickoffFeerate proposes the fee rate in satoshis per kw that it
        // is offering for a ChannelType conversion that requires a kickoff
        // transaction.
        KickoffFeerate fn.Option[chainfee.SatPerKWeight]

        // 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.
        //
        // NOTE: Since the fields in this structure are part of the TLV stream,
        // ExtraData will contain all TLV records _except_ the ones that are
        // present in earlier parts of this structure.
        ExtraData ExtraOpaqueData
}

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

// Encode serializes the target DynPropose 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 (dp *DynPropose) Encode(w *bytes.Buffer, _ uint32) error {
        var tlvRecords []tlv.Record
        dp.DustLimit.WhenSome(func(dl btcutil.Amount) {
                protoSats := uint64(dl)
                tlvRecords = append(
                        tlvRecords, tlv.MakePrimitiveRecord(
                                DPDustLimitSatoshis, &protoSats,
                        ),
                )
        })
        dp.MaxValueInFlight.WhenSome(func(max MilliSatoshi) {
                protoSats := uint64(max)
                tlvRecords = append(
                        tlvRecords, tlv.MakePrimitiveRecord(
                                DPMaxHtlcValueInFlightMsat, &protoSats,
                        ),
                )
        })
        dp.ChannelReserve.WhenSome(func(min btcutil.Amount) {
                channelReserve := uint64(min)
                tlvRecords = append(
                        tlvRecords, tlv.MakePrimitiveRecord(
                                DPChannelReserveSatoshis, &channelReserve,
                        ),
                )
        })
        dp.CsvDelay.WhenSome(func(wait uint16) {
                tlvRecords = append(
                        tlvRecords, tlv.MakePrimitiveRecord(
                                DPToSelfDelay, &wait,
                        ),
                )
        })
        dp.MaxAcceptedHTLCs.WhenSome(func(max uint16) {
                tlvRecords = append(
                        tlvRecords, tlv.MakePrimitiveRecord(
                                DPMaxAcceptedHtlcs, &max,
                        ),
                )
        })
        dp.FundingKey.WhenSome(func(key btcec.PublicKey) {
                keyScratch := &key
                tlvRecords = append(
                        tlvRecords, tlv.MakePrimitiveRecord(
                                DPFundingPubkey, &keyScratch,
                        ),
                )
        })
        dp.ChannelType.WhenSome(func(ty ChannelType) {
                tlvRecords = append(
                        tlvRecords, tlv.MakeDynamicRecord(
                                DPChannelType, &ty,
                                ty.featureBitLen,
                                channelTypeEncoder, channelTypeDecoder,
                        ),
                )
        })
        dp.KickoffFeerate.WhenSome(func(kickoffFeerate chainfee.SatPerKWeight) {
                protoSats := uint32(kickoffFeerate)
                tlvRecords = append(
                        tlvRecords, tlv.MakePrimitiveRecord(
                                DPKickoffFeerate, &protoSats,
                        ),
                )
        })
        tlv.SortRecords(tlvRecords)

        tlvStream, err := tlv.NewStream(tlvRecords...)
        if err != nil {
                return err
        }

        var extraBytesWriter bytes.Buffer
        if err := tlvStream.Encode(&extraBytesWriter); err != nil {
                return err
        }
        dp.ExtraData = ExtraOpaqueData(extraBytesWriter.Bytes())

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

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

        return WriteBytes(w, dp.ExtraData)
}

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

        // Parse out TLV stream.
        var tlvRecords ExtraOpaqueData
        if err := ReadElements(r, &tlvRecords); err != nil {
                return err
        }

        // Prepare receiving buffers to be filled by TLV extraction.
        var dustLimitScratch uint64
        dustLimit := tlv.MakePrimitiveRecord(
                DPDustLimitSatoshis, &dustLimitScratch,
        )

        var maxValueScratch uint64
        maxValue := tlv.MakePrimitiveRecord(
                DPMaxHtlcValueInFlightMsat, &maxValueScratch,
        )

        var reserveScratch uint64
        reserve := tlv.MakePrimitiveRecord(
                DPChannelReserveSatoshis, &reserveScratch,
        )

        var csvDelayScratch uint16
        csvDelay := tlv.MakePrimitiveRecord(DPToSelfDelay, &csvDelayScratch)

        var maxHtlcsScratch uint16
        maxHtlcs := tlv.MakePrimitiveRecord(
                DPMaxAcceptedHtlcs, &maxHtlcsScratch,
        )

        var fundingKeyScratch *btcec.PublicKey
        fundingKey := tlv.MakePrimitiveRecord(
                DPFundingPubkey, &fundingKeyScratch,
        )

        var chanTypeScratch ChannelType
        chanType := tlv.MakeDynamicRecord(
                DPChannelType, &chanTypeScratch, chanTypeScratch.featureBitLen,
                channelTypeEncoder, channelTypeDecoder,
        )

        var kickoffFeerateScratch uint32
        kickoffFeerate := tlv.MakePrimitiveRecord(
                DPKickoffFeerate, &kickoffFeerateScratch,
        )

        // Create set of Records to read TLV bytestream into.
        records := []tlv.Record{
                dustLimit, maxValue, reserve, csvDelay, maxHtlcs, fundingKey,
                chanType, kickoffFeerate,
        }
        tlv.SortRecords(records)

        // Read TLV stream into record set.
        extraBytesReader := bytes.NewReader(tlvRecords)
        tlvStream, err := tlv.NewStream(records...)
        if err != nil {
                return err
        }

        typeMap, err := tlvStream.DecodeWithParsedTypesP2P(extraBytesReader)
        if err != nil {
                return err
        }

        // Check the results of the TLV Stream decoding and appropriately set
        // message fields.
        if val, ok := typeMap[DPDustLimitSatoshis]; ok && val == nil {
                dp.DustLimit = fn.Some(btcutil.Amount(dustLimitScratch))
        }
        if val, ok := typeMap[DPMaxHtlcValueInFlightMsat]; ok && val == nil {
                dp.MaxValueInFlight = fn.Some(MilliSatoshi(maxValueScratch))
        }
        if val, ok := typeMap[DPChannelReserveSatoshis]; ok && val == nil {
                dp.ChannelReserve = fn.Some(btcutil.Amount(reserveScratch))
        }
        if val, ok := typeMap[DPToSelfDelay]; ok && val == nil {
                dp.CsvDelay = fn.Some(csvDelayScratch)
        }
        if val, ok := typeMap[DPMaxAcceptedHtlcs]; ok && val == nil {
                dp.MaxAcceptedHTLCs = fn.Some(maxHtlcsScratch)
        }
        if val, ok := typeMap[DPFundingPubkey]; ok && val == nil {
                dp.FundingKey = fn.Some(*fundingKeyScratch)
        }
        if val, ok := typeMap[DPChannelType]; ok && val == nil {
                dp.ChannelType = fn.Some(chanTypeScratch)
        }
        if val, ok := typeMap[DPKickoffFeerate]; ok && val == nil {
                dp.KickoffFeerate = fn.Some(
                        chainfee.SatPerKWeight(kickoffFeerateScratch),
                )
        }

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

        return nil
}

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

1	package lnwire
2
3	import (
4	"bytes"
5	"io"
6
7	"github.com/btcsuite/btcd/btcec/v2"
8	"github.com/btcsuite/btcd/btcutil"
9	"github.com/lightningnetwork/lnd/fn/v2"
10	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
11	"github.com/lightningnetwork/lnd/tlv"
12	)
13
14	const (
15	// DPDustLimitSatoshis is the TLV type number that identifies the record
16	// for DynPropose.DustLimit.
17	DPDustLimitSatoshis tlv.Type = 0
18
19	// DPMaxHtlcValueInFlightMsat is the TLV type number that identifies the
20	// record for DynPropose.MaxValueInFlight.
21	DPMaxHtlcValueInFlightMsat tlv.Type = 1
22
23	// DPChannelReserveSatoshis is the TLV type number that identifies the
24	// for DynPropose.ChannelReserve.
25	DPChannelReserveSatoshis tlv.Type = 2
26
27	// DPToSelfDelay is the TLV type number that identifies the record for
28	// DynPropose.CsvDelay.
29	DPToSelfDelay tlv.Type = 3
30
31	// DPMaxAcceptedHtlcs is the TLV type number that identifies the record
32	// for DynPropose.MaxAcceptedHTLCs.
33	DPMaxAcceptedHtlcs tlv.Type = 4
34
35	// DPFundingPubkey is the TLV type number that identifies the record for
36	// DynPropose.FundingKey.
37	DPFundingPubkey tlv.Type = 5
38
39	// DPChannelType is the TLV type number that identifies the record for
40	// DynPropose.ChannelType.
41	DPChannelType tlv.Type = 6
42
43	// DPKickoffFeerate is the TLV type number that identifies the record
44	// for DynPropose.KickoffFeerate.
45	DPKickoffFeerate tlv.Type = 7
46	)
47
48	// DynPropose is a message that is sent during a dynamic commitments negotiation
49	// process. It is sent by both parties to propose new channel parameters.
50	type DynPropose struct {
51	// ChanID identifies the channel whose parameters we are trying to
52	// re-negotiate.
53	ChanID ChannelID
54
55	// Initiator is a byte that identifies whether this message was sent as
56	// the initiator of a dynamic commitment negotiation or the responder
57	// of a dynamic commitment negotiation. bool true indicates it is the
58	// initiator
59	Initiator bool
60
61	// DustLimit, if not nil, proposes a change to the dust_limit_satoshis
62	// for the sender's commitment transaction.
63	DustLimit fn.Option[btcutil.Amount]
64
65	// MaxValueInFlight, if not nil, proposes a change to the
66	// max_htlc_value_in_flight_msat limit of the sender.
67	MaxValueInFlight fn.Option[MilliSatoshi]
68
69	// ChannelReserve, if not nil, proposes a change to the
70	// channel_reserve_satoshis requirement of the recipient.
71	ChannelReserve fn.Option[btcutil.Amount]
72
73	// CsvDelay, if not nil, proposes a change to the to_self_delay
74	// requirement of the recipient.
75	CsvDelay fn.Option[uint16]
76
77	// MaxAcceptedHTLCs, if not nil, proposes a change to the
78	// max_accepted_htlcs limit of the sender.
79	MaxAcceptedHTLCs fn.Option[uint16]
80
81	// FundingKey, if not nil, proposes a change to the funding_pubkey
82	// parameter of the sender.
83	FundingKey fn.Option[btcec.PublicKey]
84
85	// ChannelType, if not nil, proposes a change to the channel_type
86	// parameter.
87	ChannelType fn.Option[ChannelType]
88
89	// KickoffFeerate proposes the fee rate in satoshis per kw that it
90	// is offering for a ChannelType conversion that requires a kickoff
91	// transaction.
92	KickoffFeerate fn.Option[chainfee.SatPerKWeight]
93
94	// ExtraData is the set of data that was appended to this message to
95	// fill out the full maximum transport message size. These fields can
96	// be used to specify optional data such as custom TLV fields.
97	//
98	// NOTE: Since the fields in this structure are part of the TLV stream,
99	// ExtraData will contain all TLV records _except_ the ones that are
100	// present in earlier parts of this structure.
101	ExtraData ExtraOpaqueData
102	}
103
104	// A compile time check to ensure DynPropose implements the lnwire.Message
105	// interface.
106	var _ Message = (*DynPropose)(nil)
107
108	// Encode serializes the target DynPropose into the passed io.Writer.
109	// Serialization will observe the rules defined by the passed protocol version.
110	//
111	// This is a part of the lnwire.Message interface.
112	func (dp DynPropose) Encode(w bytes.Buffer, _ uint32) error {	×
113	var tlvRecords []tlv.Record	×
114	dp.DustLimit.WhenSome(func(dl btcutil.Amount) {	×
115	protoSats := uint64(dl)	×
116	tlvRecords = append(	×
117	tlvRecords, tlv.MakePrimitiveRecord(	×
118	DPDustLimitSatoshis, &protoSats,	×
119	),	×
120	)	×
121	})	×
122	dp.MaxValueInFlight.WhenSome(func(max MilliSatoshi) {	×
123	protoSats := uint64(max)	×
124	tlvRecords = append(	×
125	tlvRecords, tlv.MakePrimitiveRecord(	×
126	DPMaxHtlcValueInFlightMsat, &protoSats,	×
127	),	×
128	)	×
129	})	×
130	dp.ChannelReserve.WhenSome(func(min btcutil.Amount) {	×
131	channelReserve := uint64(min)	×
132	tlvRecords = append(	×
133	tlvRecords, tlv.MakePrimitiveRecord(	×
134	DPChannelReserveSatoshis, &channelReserve,	×
135	),	×
136	)	×
137	})	×
138	dp.CsvDelay.WhenSome(func(wait uint16) {	×
139	tlvRecords = append(	×
140	tlvRecords, tlv.MakePrimitiveRecord(	×
141	DPToSelfDelay, &wait,	×
142	),	×
143	)	×
144	})	×
145	dp.MaxAcceptedHTLCs.WhenSome(func(max uint16) {	×
146	tlvRecords = append(	×
147	tlvRecords, tlv.MakePrimitiveRecord(	×
148	DPMaxAcceptedHtlcs, &max,	×
149	),	×
150	)	×
151	})	×
152	dp.FundingKey.WhenSome(func(key btcec.PublicKey) {	×
153	keyScratch := &key	×
154	tlvRecords = append(	×
155	tlvRecords, tlv.MakePrimitiveRecord(	×
156	DPFundingPubkey, &keyScratch,	×
157	),	×
158	)	×
159	})	×
160	dp.ChannelType.WhenSome(func(ty ChannelType) {	×
161	tlvRecords = append(	×
162	tlvRecords, tlv.MakeDynamicRecord(	×
163	DPChannelType, &ty,	×
164	ty.featureBitLen,	×
165	channelTypeEncoder, channelTypeDecoder,	×
166	),	×
167	)	×
168	})	×
169	dp.KickoffFeerate.WhenSome(func(kickoffFeerate chainfee.SatPerKWeight) {	×
170	protoSats := uint32(kickoffFeerate)	×
171	tlvRecords = append(	×
172	tlvRecords, tlv.MakePrimitiveRecord(	×
173	DPKickoffFeerate, &protoSats,	×
174	),	×
175	)	×
176	})	×
177	tlv.SortRecords(tlvRecords)	×
178		×
179	tlvStream, err := tlv.NewStream(tlvRecords...)	×
180	if err != nil {	×
181	return err	×
182	}	×
183
184	var extraBytesWriter bytes.Buffer	×
185	if err := tlvStream.Encode(&extraBytesWriter); err != nil {	×
186	return err	×
187	}	×
188	dp.ExtraData = ExtraOpaqueData(extraBytesWriter.Bytes())	×
189		×
190	if err := WriteChannelID(w, dp.ChanID); err != nil {	×
191	return err	×
192	}	×
193
194	if err := WriteBool(w, dp.Initiator); err != nil {	×
195	return err	×
196	}	×
197
198	return WriteBytes(w, dp.ExtraData)	×
199	}
200
201	// Decode deserializes the serialized DynPropose stored in the passed io.Reader
202	// into the target DynPropose using the deserialization rules defined by the
203	// passed protocol version.
204	//
205	// This is a part of the lnwire.Message interface.
206	func (dp *DynPropose) Decode(r io.Reader, _ uint32) error {	×
207	// Parse out the only required field.	×
208	if err := ReadElements(r, &dp.ChanID, &dp.Initiator); err != nil {	×
209	return err	×
210	}	×
211
212	// Parse out TLV stream.
213	var tlvRecords ExtraOpaqueData	×
214	if err := ReadElements(r, &tlvRecords); err != nil {	×
215	return err	×
216	}	×
217
218	// Prepare receiving buffers to be filled by TLV extraction.
219	var dustLimitScratch uint64	×
220	dustLimit := tlv.MakePrimitiveRecord(	×
221	DPDustLimitSatoshis, &dustLimitScratch,	×
222	)	×
223		×
224	var maxValueScratch uint64	×
225	maxValue := tlv.MakePrimitiveRecord(	×
226	DPMaxHtlcValueInFlightMsat, &maxValueScratch,	×
227	)	×
228		×
229	var reserveScratch uint64	×
230	reserve := tlv.MakePrimitiveRecord(	×
231	DPChannelReserveSatoshis, &reserveScratch,	×
232	)	×
233		×
234	var csvDelayScratch uint16	×
235	csvDelay := tlv.MakePrimitiveRecord(DPToSelfDelay, &csvDelayScratch)	×
236		×
237	var maxHtlcsScratch uint16	×
238	maxHtlcs := tlv.MakePrimitiveRecord(	×
239	DPMaxAcceptedHtlcs, &maxHtlcsScratch,	×
240	)	×
241		×
242	var fundingKeyScratch *btcec.PublicKey	×
243	fundingKey := tlv.MakePrimitiveRecord(	×
244	DPFundingPubkey, &fundingKeyScratch,	×
245	)	×
246		×
247	var chanTypeScratch ChannelType	×
248	chanType := tlv.MakeDynamicRecord(	×
249	DPChannelType, &chanTypeScratch, chanTypeScratch.featureBitLen,	×
250	channelTypeEncoder, channelTypeDecoder,	×
251	)	×
252		×
253	var kickoffFeerateScratch uint32	×
254	kickoffFeerate := tlv.MakePrimitiveRecord(	×
255	DPKickoffFeerate, &kickoffFeerateScratch,	×
256	)	×
257		×
258	// Create set of Records to read TLV bytestream into.	×
259	records := []tlv.Record{	×
260	dustLimit, maxValue, reserve, csvDelay, maxHtlcs, fundingKey,	×
261	chanType, kickoffFeerate,	×
262	}	×
263	tlv.SortRecords(records)	×
264		×
265	// Read TLV stream into record set.	×
266	extraBytesReader := bytes.NewReader(tlvRecords)	×
267	tlvStream, err := tlv.NewStream(records...)	×
268	if err != nil {	×
269	return err	×
270	}	×
271
272	typeMap, err := tlvStream.DecodeWithParsedTypesP2P(extraBytesReader)	×
273	if err != nil {	×
274	return err	×
275	}	×
276
277	// Check the results of the TLV Stream decoding and appropriately set
278	// message fields.
279	if val, ok := typeMap[DPDustLimitSatoshis]; ok && val == nil {	×
280	dp.DustLimit = fn.Some(btcutil.Amount(dustLimitScratch))	×
281	}	×
282	if val, ok := typeMap[DPMaxHtlcValueInFlightMsat]; ok && val == nil {	×
283	dp.MaxValueInFlight = fn.Some(MilliSatoshi(maxValueScratch))	×
284	}	×
285	if val, ok := typeMap[DPChannelReserveSatoshis]; ok && val == nil {	×
286	dp.ChannelReserve = fn.Some(btcutil.Amount(reserveScratch))	×
287	}	×
288	if val, ok := typeMap[DPToSelfDelay]; ok && val == nil {	×
289	dp.CsvDelay = fn.Some(csvDelayScratch)	×
290	}	×
291	if val, ok := typeMap[DPMaxAcceptedHtlcs]; ok && val == nil {	×
292	dp.MaxAcceptedHTLCs = fn.Some(maxHtlcsScratch)	×
293	}	×
294	if val, ok := typeMap[DPFundingPubkey]; ok && val == nil {	×
295	dp.FundingKey = fn.Some(*fundingKeyScratch)	×
296	}	×
297	if val, ok := typeMap[DPChannelType]; ok && val == nil {	×
298	dp.ChannelType = fn.Some(chanTypeScratch)	×
299	}	×
300	if val, ok := typeMap[DPKickoffFeerate]; ok && val == nil {	×
301	dp.KickoffFeerate = fn.Some(	×
302	chainfee.SatPerKWeight(kickoffFeerateScratch),	×
303	)	×
304	}	×
305
306	if len(tlvRecords) != 0 {	×
307	dp.ExtraData = tlvRecords	×
308	}	×
309
310	return nil	×
311	}
312
313	// MsgType returns the MessageType code which uniquely identifies this message
314	// as a DynPropose on the wire.
315	//
316	// This is part of the lnwire.Message interface.
317	func (dp *DynPropose) MsgType() MessageType {	×
318	return MsgDynPropose	×
319	}	×

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