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

83.08

/record/blinded_data.go

package record

import (
        "bytes"
        "encoding/binary"
        "io"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/tlv"
)

// AverageDummyHopPayloadSize is the size of a standard blinded path dummy hop
// payload. In most cases, this is larger than the other payload types and so
// to make sure that a sender cannot use this fact to know if a dummy hop is
// present or not, we'll make sure to always pad all payloads to at least this
// size.
const AverageDummyHopPayloadSize = 51

// BlindedRouteData contains the information that is included in a blinded
// route encrypted data blob that is created by the recipient to provide
// forwarding information.
type BlindedRouteData struct {
        // Padding is an optional set of bytes that a recipient can use to pad
        // the data so that the encrypted recipient data blobs are all the same
        // length.
        Padding tlv.OptionalRecordT[tlv.TlvType1, []byte]

        // ShortChannelID is the channel ID of the next hop.
        ShortChannelID tlv.OptionalRecordT[tlv.TlvType2, lnwire.ShortChannelID]

        // NextNodeID is the node ID of the next node on the path. In the
        // context of blinded path payments, this is used to indicate the
        // presence of dummy hops that need to be peeled from the onion.
        NextNodeID tlv.OptionalRecordT[tlv.TlvType4, *btcec.PublicKey]

        // PathID is a secret set of bytes that the blinded path creator will
        // set so that they can check the value on decryption to ensure that the
        // path they created was used for the intended purpose.
        PathID tlv.OptionalRecordT[tlv.TlvType6, []byte]

        // NextBlindingOverride is a blinding point that should be switched
        // in for the next hop. This is used to combine two blinded paths into
        // one (which primarily is used in onion messaging, but in theory
        // could be used for payments as well).
        NextBlindingOverride tlv.OptionalRecordT[tlv.TlvType8, *btcec.PublicKey]

        // RelayInfo provides the relay parameters for the hop.
        RelayInfo tlv.OptionalRecordT[tlv.TlvType10, PaymentRelayInfo]

        // Constraints provides the payment relay constraints for the hop.
        Constraints tlv.OptionalRecordT[tlv.TlvType12, PaymentConstraints]

        // Features is the set of features the payment requires.
        Features tlv.OptionalRecordT[tlv.TlvType14, lnwire.FeatureVector]
}

// NewNonFinalBlindedRouteData creates the data that's provided for hops within
// a blinded route.
func NewNonFinalBlindedRouteData(chanID lnwire.ShortChannelID,
        blindingOverride *btcec.PublicKey, relayInfo PaymentRelayInfo,
        constraints *PaymentConstraints,
        features *lnwire.FeatureVector) *BlindedRouteData {

        info := &BlindedRouteData{
                ShortChannelID: tlv.SomeRecordT(
                        tlv.NewRecordT[tlv.TlvType2](chanID),
                ),
                RelayInfo: tlv.SomeRecordT(
                        tlv.NewRecordT[tlv.TlvType10](relayInfo),
                ),
        }

        if blindingOverride != nil {
                info.NextBlindingOverride = tlv.SomeRecordT(
                        tlv.NewPrimitiveRecord[tlv.TlvType8](blindingOverride))
        }

        if constraints != nil {
                info.Constraints = tlv.SomeRecordT(
                        tlv.NewRecordT[tlv.TlvType12](*constraints))
        }

        if features != nil {
                info.Features = tlv.SomeRecordT(
                        tlv.NewRecordT[tlv.TlvType14](*features),
                )
        }

        return info
}

// NewFinalHopBlindedRouteData creates the data that's provided for the final
// hop in a blinded route.
func NewFinalHopBlindedRouteData(constraints *PaymentConstraints,
        pathID []byte) *BlindedRouteData {

        var data BlindedRouteData
        if pathID != nil {
                data.PathID = tlv.SomeRecordT(
                        tlv.NewPrimitiveRecord[tlv.TlvType6](pathID),
                )
        }

        if constraints != nil {
                data.Constraints = tlv.SomeRecordT(
                        tlv.NewRecordT[tlv.TlvType12](*constraints))
        }

        return &data
}

// NewDummyHopRouteData creates the data that's provided for any hop preceding
// a dummy hop. The presence of such a payload indicates to the reader that
// they are the intended recipient and should peel the remainder of the onion.
func NewDummyHopRouteData(ourPubKey *btcec.PublicKey,
        relayInfo PaymentRelayInfo,
        constraints PaymentConstraints) *BlindedRouteData {

        return &BlindedRouteData{
                NextNodeID: tlv.SomeRecordT(
                        tlv.NewPrimitiveRecord[tlv.TlvType4](ourPubKey),
                ),
                RelayInfo: tlv.SomeRecordT(
                        tlv.NewRecordT[tlv.TlvType10](relayInfo),
                ),
                Constraints: tlv.SomeRecordT(
                        tlv.NewRecordT[tlv.TlvType12](constraints),
                ),
        }
}

// DecodeBlindedRouteData decodes the data provided within a blinded route.
func DecodeBlindedRouteData(r io.Reader) (*BlindedRouteData, error) {
        var (
                d BlindedRouteData

                padding          = d.Padding.Zero()
                scid             = d.ShortChannelID.Zero()
                nextNodeID       = d.NextNodeID.Zero()
                pathID           = d.PathID.Zero()
                blindingOverride = d.NextBlindingOverride.Zero()
                relayInfo        = d.RelayInfo.Zero()
                constraints      = d.Constraints.Zero()
                features         = d.Features.Zero()
        )

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

        typeMap, err := tlvRecords.ExtractRecords(
                &padding, &scid, &nextNodeID, &pathID, &blindingOverride,
                &relayInfo, &constraints, &features,
        )
        if err != nil {
                return nil, err
        }

        val, ok := typeMap[d.Padding.TlvType()]
        if ok && val == nil {
                d.Padding = tlv.SomeRecordT(padding)
        }

        if val, ok := typeMap[d.ShortChannelID.TlvType()]; ok && val == nil {
                d.ShortChannelID = tlv.SomeRecordT(scid)
        }

        if val, ok := typeMap[d.NextNodeID.TlvType()]; ok && val == nil {
                d.NextNodeID = tlv.SomeRecordT(nextNodeID)
        }

        if val, ok := typeMap[d.PathID.TlvType()]; ok && val == nil {
                d.PathID = tlv.SomeRecordT(pathID)
        }

        val, ok = typeMap[d.NextBlindingOverride.TlvType()]
        if ok && val == nil {
                d.NextBlindingOverride = tlv.SomeRecordT(blindingOverride)
        }

        if val, ok := typeMap[d.RelayInfo.TlvType()]; ok && val == nil {
                d.RelayInfo = tlv.SomeRecordT(relayInfo)
        }

        if val, ok := typeMap[d.Constraints.TlvType()]; ok && val == nil {
                d.Constraints = tlv.SomeRecordT(constraints)
        }

        if val, ok := typeMap[d.Features.TlvType()]; ok && val == nil {
                d.Features = tlv.SomeRecordT(features)
        }

        return &d, nil
}

// EncodeBlindedRouteData encodes the blinded route data provided.
func EncodeBlindedRouteData(data *BlindedRouteData) ([]byte, error) {
        var (
                e               lnwire.ExtraOpaqueData
                recordProducers = make([]tlv.RecordProducer, 0, 5)
        )

        data.Padding.WhenSome(func(p tlv.RecordT[tlv.TlvType1, []byte]) {
                recordProducers = append(recordProducers, &p)
        })

        data.ShortChannelID.WhenSome(func(scid tlv.RecordT[tlv.TlvType2,
                lnwire.ShortChannelID]) {

                recordProducers = append(recordProducers, &scid)
        })

        data.NextNodeID.WhenSome(func(f tlv.RecordT[tlv.TlvType4,
                *btcec.PublicKey]) {

                recordProducers = append(recordProducers, &f)
        })

        data.PathID.WhenSome(func(pathID tlv.RecordT[tlv.TlvType6, []byte]) {
                recordProducers = append(recordProducers, &pathID)
        })

        data.NextBlindingOverride.WhenSome(func(pk tlv.RecordT[tlv.TlvType8,
                *btcec.PublicKey]) {

                recordProducers = append(recordProducers, &pk)
        })

        data.RelayInfo.WhenSome(func(r tlv.RecordT[tlv.TlvType10,
                PaymentRelayInfo]) {

                recordProducers = append(recordProducers, &r)
        })

        data.Constraints.WhenSome(func(cs tlv.RecordT[tlv.TlvType12,
                PaymentConstraints]) {

                recordProducers = append(recordProducers, &cs)
        })

        data.Features.WhenSome(func(f tlv.RecordT[tlv.TlvType14,
                lnwire.FeatureVector]) {

                recordProducers = append(recordProducers, &f)
        })

        if err := e.PackRecords(recordProducers...); err != nil {
                return nil, err
        }

        return e[:], nil
}

// PadBy adds "n" padding bytes to the BlindedRouteData using the Padding field.
// Callers should be aware that the total payload size will change by more than
// "n" since the "n" bytes will be prefixed by BigSize type and length fields.
// Callers may need to call PadBy iteratively until each encrypted data packet
// is the same size and so each call will overwrite the Padding record.
// Note that calling PadBy with an n value of 0 will still result in a zero
// length TLV entry being added.
func (b *BlindedRouteData) PadBy(n int) {
        b.Padding = tlv.SomeRecordT(
                tlv.NewPrimitiveRecord[tlv.TlvType1](make([]byte, n)),
        )
}

// PaymentRelayInfo describes the relay policy for a blinded path.
type PaymentRelayInfo struct {
        // CltvExpiryDelta is the expiry delta for the payment.
        CltvExpiryDelta uint16

        // FeeRate is the fee rate that will be charged per millionth of a
        // satoshi.
        FeeRate uint32

        // BaseFee is the per-htlc fee charged in milli-satoshis.
        BaseFee lnwire.MilliSatoshi
}

// Record creates a tlv.Record that encodes the payment relay (type 10) type for
// an encrypted blob payload.
func (i *PaymentRelayInfo) Record() tlv.Record {
        return tlv.MakeDynamicRecord(
                10, &i, func() uint64 {
                        // uint16 + uint32 + tuint32
                        return 2 + 4 + tlv.SizeTUint32(uint32(i.BaseFee))
                }, encodePaymentRelay, decodePaymentRelay,
        )
}

func encodePaymentRelay(w io.Writer, val interface{}, buf *[8]byte) error {
        if t, ok := val.(**PaymentRelayInfo); ok {
                relayInfo := *t

                // Just write our first 6 bytes directly.
                binary.BigEndian.PutUint16(buf[:2], relayInfo.CltvExpiryDelta)
                binary.BigEndian.PutUint32(buf[2:6], relayInfo.FeeRate)
                if _, err := w.Write(buf[0:6]); err != nil {
                        return err
                }

                baseFee := uint32(relayInfo.BaseFee)

                // We can safely reuse buf here because we overwrite its
                // contents.
                return tlv.ETUint32(w, &baseFee, buf)
        }

        return tlv.NewTypeForEncodingErr(val, "**hop.PaymentRelayInfo")
}

func decodePaymentRelay(r io.Reader, val interface{}, buf *[8]byte,
        l uint64) error {

        if t, ok := val.(**PaymentRelayInfo); ok && l <= 10 {
                scratch := make([]byte, l)

                n, err := io.ReadFull(r, scratch)
                if err != nil {
                        return err
                }

                // We expect at least 6 bytes, because we have 2 bytes for
                // cltv delta and 4 bytes for fee rate.
                if n < 6 {
                        return tlv.NewTypeForDecodingErr(val,
                                "*hop.paymentRelayInfo", uint64(n), 6)
                }

                relayInfo := *t

                relayInfo.CltvExpiryDelta = binary.BigEndian.Uint16(
                        scratch[0:2],
                )
                relayInfo.FeeRate = binary.BigEndian.Uint32(scratch[2:6])

                // To be able to re-use the DTUint32 function we create a
                // buffer with just the bytes holding the variable length u32.
                // If the base fee is zero, this will be an empty buffer, which
                // is okay.
                b := bytes.NewBuffer(scratch[6:])

                var baseFee uint32
                err = tlv.DTUint32(b, &baseFee, buf, l-6)
                if err != nil {
                        return err
                }

                relayInfo.BaseFee = lnwire.MilliSatoshi(baseFee)

                return nil
        }

        return tlv.NewTypeForDecodingErr(val, "*hop.paymentRelayInfo", l, 10)
}

// PaymentConstraints is a set of restrictions on a payment.
type PaymentConstraints struct {
        // MaxCltvExpiry is the maximum expiry height for the payment.
        MaxCltvExpiry uint32

        // HtlcMinimumMsat is the minimum htlc size for the payment.
        HtlcMinimumMsat lnwire.MilliSatoshi
}

func (p *PaymentConstraints) Record() tlv.Record {
        return tlv.MakeDynamicRecord(
                12, &p, func() uint64 {
                        // uint32 + tuint64.
                        return 4 + tlv.SizeTUint64(uint64(
                                p.HtlcMinimumMsat,
                        ))
                },
                encodePaymentConstraints, decodePaymentConstraints,
        )
}

func encodePaymentConstraints(w io.Writer, val interface{},
        buf *[8]byte) error {

        if c, ok := val.(**PaymentConstraints); ok {
                constraints := *c

                binary.BigEndian.PutUint32(buf[:4], constraints.MaxCltvExpiry)
                if _, err := w.Write(buf[:4]); err != nil {
                        return err
                }

                // We can safely re-use buf here because we overwrite its
                // contents.
                htlcMsat := uint64(constraints.HtlcMinimumMsat)

                return tlv.ETUint64(w, &htlcMsat, buf)
        }

        return tlv.NewTypeForEncodingErr(val, "**PaymentConstraints")
}

func decodePaymentConstraints(r io.Reader, val interface{}, buf *[8]byte,
        l uint64) error {

        if c, ok := val.(**PaymentConstraints); ok && l <= 12 {
                scratch := make([]byte, l)

                n, err := io.ReadFull(r, scratch)
                if err != nil {
                        return err
                }

                // We expect at least 4 bytes for our uint32.
                if n < 4 {
                        return tlv.NewTypeForDecodingErr(val,
                                "*paymentConstraints", uint64(n), 4)
                }

                payConstraints := *c

                payConstraints.MaxCltvExpiry = binary.BigEndian.Uint32(
                        scratch[:4],
                )

                // This could be empty if our minimum is zero, that's okay.
                var (
                        b       = bytes.NewBuffer(scratch[4:])
                        minHtlc uint64
                )

                err = tlv.DTUint64(b, &minHtlc, buf, l-4)
                if err != nil {
                        return err
                }
                payConstraints.HtlcMinimumMsat = lnwire.MilliSatoshi(minHtlc)

                return nil
        }

        return tlv.NewTypeForDecodingErr(val, "**PaymentConstraints", l, l)
}

1	package record
2
3	import (
4	"bytes"
5	"encoding/binary"
6	"io"
7
8	"github.com/btcsuite/btcd/btcec/v2"
9	"github.com/lightningnetwork/lnd/lnwire"
10	"github.com/lightningnetwork/lnd/tlv"
11	)
12
13	// AverageDummyHopPayloadSize is the size of a standard blinded path dummy hop
14	// payload. In most cases, this is larger than the other payload types and so
15	// to make sure that a sender cannot use this fact to know if a dummy hop is
16	// present or not, we'll make sure to always pad all payloads to at least this
17	// size.
18	const AverageDummyHopPayloadSize = 51
19
20	// BlindedRouteData contains the information that is included in a blinded
21	// route encrypted data blob that is created by the recipient to provide
22	// forwarding information.
23	type BlindedRouteData struct {
24	// Padding is an optional set of bytes that a recipient can use to pad
25	// the data so that the encrypted recipient data blobs are all the same
26	// length.
27	Padding tlv.OptionalRecordT[tlv.TlvType1, []byte]
28
29	// ShortChannelID is the channel ID of the next hop.
30	ShortChannelID tlv.OptionalRecordT[tlv.TlvType2, lnwire.ShortChannelID]
31
32	// NextNodeID is the node ID of the next node on the path. In the
33	// context of blinded path payments, this is used to indicate the
34	// presence of dummy hops that need to be peeled from the onion.
35	NextNodeID tlv.OptionalRecordT[tlv.TlvType4, *btcec.PublicKey]
36
37	// PathID is a secret set of bytes that the blinded path creator will
38	// set so that they can check the value on decryption to ensure that the
39	// path they created was used for the intended purpose.
40	PathID tlv.OptionalRecordT[tlv.TlvType6, []byte]
41
42	// NextBlindingOverride is a blinding point that should be switched
43	// in for the next hop. This is used to combine two blinded paths into
44	// one (which primarily is used in onion messaging, but in theory
45	// could be used for payments as well).
46	NextBlindingOverride tlv.OptionalRecordT[tlv.TlvType8, *btcec.PublicKey]
47
48	// RelayInfo provides the relay parameters for the hop.
49	RelayInfo tlv.OptionalRecordT[tlv.TlvType10, PaymentRelayInfo]
50
51	// Constraints provides the payment relay constraints for the hop.
52	Constraints tlv.OptionalRecordT[tlv.TlvType12, PaymentConstraints]
53
54	// Features is the set of features the payment requires.
55	Features tlv.OptionalRecordT[tlv.TlvType14, lnwire.FeatureVector]
56	}
57
58	// NewNonFinalBlindedRouteData creates the data that's provided for hops within
59	// a blinded route.
60	func NewNonFinalBlindedRouteData(chanID lnwire.ShortChannelID,
61	blindingOverride *btcec.PublicKey, relayInfo PaymentRelayInfo,
62	constraints *PaymentConstraints,
63	features lnwire.FeatureVector) BlindedRouteData {	3✔
64		3✔
65	info := &BlindedRouteData{	3✔
66	ShortChannelID: tlv.SomeRecordT(	3✔
67	tlv.NewRecordT[tlv.TlvType2](chanID),	3✔
68	),	3✔
69	RelayInfo: tlv.SomeRecordT(	3✔
70	tlv.NewRecordT[tlv.TlvType10](relayInfo),	3✔
71	),	3✔
72	}	3✔
73		3✔
74	if blindingOverride != nil {	3✔
75	info.NextBlindingOverride = tlv.SomeRecordT(	×
76	tlv.NewPrimitiveRecord[tlv.TlvType8](blindingOverride))	×
77	}	×
78
79	if constraints != nil {	6✔
80	info.Constraints = tlv.SomeRecordT(	3✔
81	tlv.NewRecordT[tlv.TlvType12](*constraints))	3✔
82	}	3✔
83
84	if features != nil {	3✔
85	info.Features = tlv.SomeRecordT(	×
86	tlv.NewRecordT[tlv.TlvType14](*features),	×
87	)	×
88	}	×
89
90	return info	3✔
91	}
92
93	// NewFinalHopBlindedRouteData creates the data that's provided for the final
94	// hop in a blinded route.
95	func NewFinalHopBlindedRouteData(constraints *PaymentConstraints,
96	pathID []byte) *BlindedRouteData {	3✔
97		3✔
98	var data BlindedRouteData	3✔
99	if pathID != nil {	6✔
100	data.PathID = tlv.SomeRecordT(	3✔
101	tlv.NewPrimitiveRecord[tlv.TlvType6](pathID),	3✔
102	)	3✔
103	}	3✔
104
105	if constraints != nil {	6✔
106	data.Constraints = tlv.SomeRecordT(	3✔
107	tlv.NewRecordT[tlv.TlvType12](*constraints))	3✔
108	}	3✔
109
110	return &data	3✔
111	}
112
113	// NewDummyHopRouteData creates the data that's provided for any hop preceding
114	// a dummy hop. The presence of such a payload indicates to the reader that
115	// they are the intended recipient and should peel the remainder of the onion.
116	func NewDummyHopRouteData(ourPubKey *btcec.PublicKey,
117	relayInfo PaymentRelayInfo,
118	constraints PaymentConstraints) *BlindedRouteData {	3✔
119		3✔
120	return &BlindedRouteData{	3✔
121	NextNodeID: tlv.SomeRecordT(	3✔
122	tlv.NewPrimitiveRecord[tlv.TlvType4](ourPubKey),	3✔
123	),	3✔
124	RelayInfo: tlv.SomeRecordT(	3✔
125	tlv.NewRecordT[tlv.TlvType10](relayInfo),	3✔
126	),	3✔
127	Constraints: tlv.SomeRecordT(	3✔
128	tlv.NewRecordT[tlv.TlvType12](constraints),	3✔
129	),	3✔
130	}	3✔
131	}	3✔
132
133	// DecodeBlindedRouteData decodes the data provided within a blinded route.
134	func DecodeBlindedRouteData(r io.Reader) (*BlindedRouteData, error) {	3✔
135	var (	3✔
136	d BlindedRouteData	3✔
137		3✔
138	padding = d.Padding.Zero()	3✔
139	scid = d.ShortChannelID.Zero()	3✔
140	nextNodeID = d.NextNodeID.Zero()	3✔
141	pathID = d.PathID.Zero()	3✔
142	blindingOverride = d.NextBlindingOverride.Zero()	3✔
143	relayInfo = d.RelayInfo.Zero()	3✔
144	constraints = d.Constraints.Zero()	3✔
145	features = d.Features.Zero()	3✔
146	)	3✔
147		3✔
148	var tlvRecords lnwire.ExtraOpaqueData	3✔
149	if err := lnwire.ReadElements(r, &tlvRecords); err != nil {	3✔
150	return nil, err	×
151	}	×
152
153	typeMap, err := tlvRecords.ExtractRecords(	3✔
154	&padding, &scid, &nextNodeID, &pathID, &blindingOverride,	3✔
155	&relayInfo, &constraints, &features,	3✔
156	)	3✔
157	if err != nil {	3✔
158	return nil, err	×
159	}	×
160
161	val, ok := typeMap[d.Padding.TlvType()]	3✔
162	if ok && val == nil {	6✔
163	d.Padding = tlv.SomeRecordT(padding)	3✔
164	}	3✔
165
166	if val, ok := typeMap[d.ShortChannelID.TlvType()]; ok && val == nil {	6✔
167	d.ShortChannelID = tlv.SomeRecordT(scid)	3✔
168	}	3✔
169
170	if val, ok := typeMap[d.NextNodeID.TlvType()]; ok && val == nil {	6✔
171	d.NextNodeID = tlv.SomeRecordT(nextNodeID)	3✔
172	}	3✔
173
174	if val, ok := typeMap[d.PathID.TlvType()]; ok && val == nil {	6✔
175	d.PathID = tlv.SomeRecordT(pathID)	3✔
176	}	3✔
177
178	val, ok = typeMap[d.NextBlindingOverride.TlvType()]	3✔
179	if ok && val == nil {	3✔
180	d.NextBlindingOverride = tlv.SomeRecordT(blindingOverride)	×
181	}	×
182
183	if val, ok := typeMap[d.RelayInfo.TlvType()]; ok && val == nil {	6✔
184	d.RelayInfo = tlv.SomeRecordT(relayInfo)	3✔
185	}	3✔
186
187	if val, ok := typeMap[d.Constraints.TlvType()]; ok && val == nil {	6✔
188	d.Constraints = tlv.SomeRecordT(constraints)	3✔
189	}	3✔
190
191	if val, ok := typeMap[d.Features.TlvType()]; ok && val == nil {	3✔
192	d.Features = tlv.SomeRecordT(features)	×
193	}	×
194
195	return &d, nil	3✔
196	}
197
198	// EncodeBlindedRouteData encodes the blinded route data provided.
199	func EncodeBlindedRouteData(data *BlindedRouteData) ([]byte, error) {	3✔
200	var (	3✔
201	e lnwire.ExtraOpaqueData	3✔
202	recordProducers = make([]tlv.RecordProducer, 0, 5)	3✔
203	)	3✔
204		3✔
205	data.Padding.WhenSome(func(p tlv.RecordT[tlv.TlvType1, []byte]) {	6✔
206	recordProducers = append(recordProducers, &p)	3✔
207	})	3✔
208
209	data.ShortChannelID.WhenSome(func(scid tlv.RecordT[tlv.TlvType2,	3✔
210	lnwire.ShortChannelID]) {	6✔
211		3✔
212	recordProducers = append(recordProducers, &scid)	3✔
213	})	3✔
214
215	data.NextNodeID.WhenSome(func(f tlv.RecordT[tlv.TlvType4,	3✔
216	*btcec.PublicKey]) {	6✔
217		3✔
218	recordProducers = append(recordProducers, &f)	3✔
219	})	3✔
220
221	data.PathID.WhenSome(func(pathID tlv.RecordT[tlv.TlvType6, []byte]) {	6✔
222	recordProducers = append(recordProducers, &pathID)	3✔
223	})	3✔
224
225	data.NextBlindingOverride.WhenSome(func(pk tlv.RecordT[tlv.TlvType8,	3✔
226	*btcec.PublicKey]) {	3✔
227		×
228	recordProducers = append(recordProducers, &pk)	×
229	})	×
230
231	data.RelayInfo.WhenSome(func(r tlv.RecordT[tlv.TlvType10,	3✔
232	PaymentRelayInfo]) {	6✔
233		3✔
234	recordProducers = append(recordProducers, &r)	3✔
235	})	3✔
236
237	data.Constraints.WhenSome(func(cs tlv.RecordT[tlv.TlvType12,	3✔
238	PaymentConstraints]) {	6✔
239		3✔
240	recordProducers = append(recordProducers, &cs)	3✔
241	})	3✔
242
243	data.Features.WhenSome(func(f tlv.RecordT[tlv.TlvType14,	3✔
244	lnwire.FeatureVector]) {	3✔
245		×
246	recordProducers = append(recordProducers, &f)	×
247	})	×
248
249	if err := e.PackRecords(recordProducers...); err != nil {	3✔
250	return nil, err	×
251	}	×
252
253	return e[:], nil	3✔
254	}
255
256	// PadBy adds "n" padding bytes to the BlindedRouteData using the Padding field.
257	// Callers should be aware that the total payload size will change by more than
258	// "n" since the "n" bytes will be prefixed by BigSize type and length fields.
259	// Callers may need to call PadBy iteratively until each encrypted data packet
260	// is the same size and so each call will overwrite the Padding record.
261	// Note that calling PadBy with an n value of 0 will still result in a zero
262	// length TLV entry being added.
263	func (b *BlindedRouteData) PadBy(n int) {	3✔
264	b.Padding = tlv.SomeRecordT(	3✔
265	tlv.NewPrimitiveRecord[tlv.TlvType1](make([]byte, n)),	3✔
266	)	3✔
267	}	3✔
268
269	// PaymentRelayInfo describes the relay policy for a blinded path.
270	type PaymentRelayInfo struct {
271	// CltvExpiryDelta is the expiry delta for the payment.
272	CltvExpiryDelta uint16
273
274	// FeeRate is the fee rate that will be charged per millionth of a
275	// satoshi.
276	FeeRate uint32
277
278	// BaseFee is the per-htlc fee charged in milli-satoshis.
279	BaseFee lnwire.MilliSatoshi
280	}
281
282	// Record creates a tlv.Record that encodes the payment relay (type 10) type for
283	// an encrypted blob payload.
284	func (i *PaymentRelayInfo) Record() tlv.Record {	3✔
285	return tlv.MakeDynamicRecord(	3✔
286	10, &i, func() uint64 {	6✔
287	// uint16 + uint32 + tuint32	3✔
288	return 2 + 4 + tlv.SizeTUint32(uint32(i.BaseFee))	3✔
289	}, encodePaymentRelay, decodePaymentRelay,	3✔
290	)
291	}
292
293	func encodePaymentRelay(w io.Writer, val interface{}, buf *[8]byte) error {	3✔
294	if t, ok := val.(**PaymentRelayInfo); ok {	6✔
295	relayInfo := *t	3✔
296		3✔
297	// Just write our first 6 bytes directly.	3✔
298	binary.BigEndian.PutUint16(buf[:2], relayInfo.CltvExpiryDelta)	3✔
299	binary.BigEndian.PutUint32(buf[2:6], relayInfo.FeeRate)	3✔
300	if _, err := w.Write(buf[0:6]); err != nil {	3✔
301	return err	×
302	}	×
303
304	baseFee := uint32(relayInfo.BaseFee)	3✔
305		3✔
306	// We can safely reuse buf here because we overwrite its	3✔
307	// contents.	3✔
308	return tlv.ETUint32(w, &baseFee, buf)	3✔
309	}
310
311	return tlv.NewTypeForEncodingErr(val, "**hop.PaymentRelayInfo")	×
312	}
313
314	func decodePaymentRelay(r io.Reader, val interface{}, buf *[8]byte,
315	l uint64) error {	3✔
316		3✔
317	if t, ok := val.(**PaymentRelayInfo); ok && l <= 10 {	6✔
318	scratch := make([]byte, l)	3✔
319		3✔
320	n, err := io.ReadFull(r, scratch)	3✔
321	if err != nil {	3✔
322	return err	×
323	}	×
324
325	// We expect at least 6 bytes, because we have 2 bytes for
326	// cltv delta and 4 bytes for fee rate.
327	if n < 6 {	3✔
328	return tlv.NewTypeForDecodingErr(val,	×
329	"*hop.paymentRelayInfo", uint64(n), 6)	×
330	}	×
331
332	relayInfo := *t	3✔
333		3✔
334	relayInfo.CltvExpiryDelta = binary.BigEndian.Uint16(	3✔
335	scratch[0:2],	3✔
336	)	3✔
337	relayInfo.FeeRate = binary.BigEndian.Uint32(scratch[2:6])	3✔
338		3✔
339	// To be able to re-use the DTUint32 function we create a	3✔
340	// buffer with just the bytes holding the variable length u32.	3✔
341	// If the base fee is zero, this will be an empty buffer, which	3✔
342	// is okay.	3✔
343	b := bytes.NewBuffer(scratch[6:])	3✔
344		3✔
345	var baseFee uint32	3✔
346	err = tlv.DTUint32(b, &baseFee, buf, l-6)	3✔
347	if err != nil {	3✔
348	return err	×
349	}	×
350
351	relayInfo.BaseFee = lnwire.MilliSatoshi(baseFee)	3✔
352		3✔
353	return nil	3✔
354	}
355
356	return tlv.NewTypeForDecodingErr(val, "*hop.paymentRelayInfo", l, 10)	×
357	}
358
359	// PaymentConstraints is a set of restrictions on a payment.
360	type PaymentConstraints struct {
361	// MaxCltvExpiry is the maximum expiry height for the payment.
362	MaxCltvExpiry uint32
363
364	// HtlcMinimumMsat is the minimum htlc size for the payment.
365	HtlcMinimumMsat lnwire.MilliSatoshi
366	}
367
368	func (p *PaymentConstraints) Record() tlv.Record {	3✔
369	return tlv.MakeDynamicRecord(	3✔
370	12, &p, func() uint64 {	6✔
371	// uint32 + tuint64.	3✔
372	return 4 + tlv.SizeTUint64(uint64(	3✔
373	p.HtlcMinimumMsat,	3✔
374	))	3✔
375	},	3✔
376	encodePaymentConstraints, decodePaymentConstraints,
377	)
378	}
379
380	func encodePaymentConstraints(w io.Writer, val interface{},
381	buf *[8]byte) error {	3✔
382		3✔
383	if c, ok := val.(**PaymentConstraints); ok {	6✔
384	constraints := *c	3✔
385		3✔
386	binary.BigEndian.PutUint32(buf[:4], constraints.MaxCltvExpiry)	3✔
387	if _, err := w.Write(buf[:4]); err != nil {	3✔
388	return err	×
389	}	×
390
391	// We can safely re-use buf here because we overwrite its
392	// contents.
393	htlcMsat := uint64(constraints.HtlcMinimumMsat)	3✔
394		3✔
395	return tlv.ETUint64(w, &htlcMsat, buf)	3✔
396	}
397
398	return tlv.NewTypeForEncodingErr(val, "**PaymentConstraints")	×
399	}
400
401	func decodePaymentConstraints(r io.Reader, val interface{}, buf *[8]byte,
402	l uint64) error {	3✔
403		3✔
404	if c, ok := val.(**PaymentConstraints); ok && l <= 12 {	6✔
405	scratch := make([]byte, l)	3✔
406		3✔
407	n, err := io.ReadFull(r, scratch)	3✔
408	if err != nil {	3✔
409	return err	×
410	}	×
411
412	// We expect at least 4 bytes for our uint32.
413	if n < 4 {	3✔
414	return tlv.NewTypeForDecodingErr(val,	×
415	"*paymentConstraints", uint64(n), 4)	×
416	}	×
417
418	payConstraints := *c	3✔
419		3✔
420	payConstraints.MaxCltvExpiry = binary.BigEndian.Uint32(	3✔
421	scratch[:4],	3✔
422	)	3✔
423		3✔
424	// This could be empty if our minimum is zero, that's okay.	3✔
425	var (	3✔
426	b = bytes.NewBuffer(scratch[4:])	3✔
427	minHtlc uint64	3✔
428	)	3✔
429		3✔
430	err = tlv.DTUint64(b, &minHtlc, buf, l-4)	3✔
431	if err != nil {	3✔
432	return err	×
433	}	×
434	payConstraints.HtlcMinimumMsat = lnwire.MilliSatoshi(minHtlc)	3✔
435		3✔
436	return nil	3✔
437	}
438
439	return tlv.NewTypeForDecodingErr(val, "**PaymentConstraints", l, l)	×
440	}

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