13536249039

Committed 26 Feb 2025 03:42AM UTC coverage: 57.462% (-1.4%) from 58.835%

Build # 13536249039

Build Type

Pull #8453

github

Committed by

Roasbeef

Commit Message

peer: update chooseDeliveryScript to gen script if needed

In this commit, we update `chooseDeliveryScript` to generate a new
script if needed. This allows us to fold in a few other lines that
always followed this function into this expanded function.

The tests have been updated accordingly.

Pull Request Pull Request #8453: [4/4] - multi: integrate new rbf coop close FSM into the existing peer flow

Run Details

275 of 1318 new or added lines in 22 files covered. (20.86%)

19521 existing lines in 257 files now uncovered.

103858 of 180741 relevant lines covered (57.46%)

24750.23 hits per line

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

69.57

/zpay32/invoice.go

package zpay32

import (
        "errors"
        "fmt"
        "time"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/chaincfg"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/lnwire"
)

const (
        // mSatPerBtc is the number of millisatoshis in 1 BTC.
        mSatPerBtc = 100000000000

        // signatureBase32Len is the number of 5-bit groups needed to encode
        // the 512 bit signature + 8 bit recovery ID.
        signatureBase32Len = 104

        // timestampBase32Len is the number of 5-bit groups needed to encode
        // the 35-bit timestamp.
        timestampBase32Len = 7

        // hashBase32Len is the number of 5-bit groups needed to encode a
        // 256-bit hash. Note that the last group will be padded with zeroes.
        hashBase32Len = 52

        // pubKeyBase32Len is the number of 5-bit groups needed to encode a
        // 33-byte compressed pubkey. Note that the last group will be padded
        // with zeroes.
        pubKeyBase32Len = 53

        // hopHintLen is the number of bytes needed to encode the hop hint of a
        // single private route.
        hopHintLen = 51

        // The following byte values correspond to the supported field types.
        // The field name is the character representing that 5-bit value in the
        // bech32 string.

        // fieldTypeP is the field containing the payment hash.
        fieldTypeP = 1

        // fieldTypeD contains a short description of the payment.
        fieldTypeD = 13

        // fieldTypeM contains the payment metadata.
        fieldTypeM = 27

        // fieldTypeN contains the pubkey of the target node.
        fieldTypeN = 19

        // fieldTypeH contains the hash of a description of the payment.
        fieldTypeH = 23

        // fieldTypeX contains the expiry in seconds of the invoice.
        fieldTypeX = 6

        // fieldTypeF contains a fallback on-chain address.
        fieldTypeF = 9

        // fieldTypeR contains extra routing information.
        fieldTypeR = 3

        // fieldTypeC contains an optional requested final CLTV delta.
        fieldTypeC = 24

        // fieldType9 contains one or more bytes for signaling features
        // supported or required by the receiver.
        fieldType9 = 5

        // fieldTypeS contains a 32-byte payment address, which is a nonce
        // included in the final hop's payload to prevent intermediaries from
        // probing the recipient.
        fieldTypeS = 16

        // fieldTypeB contains blinded payment path information. This field may
        // be repeated to include multiple blinded payment paths in the invoice.
        fieldTypeB = 20

        // maxInvoiceLength is the maximum total length an invoice can have.
        // This is chosen to be the maximum number of bytes that can fit into a
        // single QR code: https://en.wikipedia.org/wiki/QR_code#Storage
        maxInvoiceLength = 7089

        // DefaultInvoiceExpiry is the default expiry duration from the creation
        // timestamp if expiry is set to zero.
        DefaultInvoiceExpiry = time.Hour
)

var (
        // ErrInvoiceTooLarge is returned when an invoice exceeds
        // maxInvoiceLength.
        ErrInvoiceTooLarge = errors.New("invoice is too large")

        // ErrInvalidFieldLength is returned when a tagged field was specified
        // with a length larger than the left over bytes of the data field.
        ErrInvalidFieldLength = errors.New("invalid field length")

        // ErrBrokenTaggedField is returned when the last tagged field is
        // incorrectly formatted and doesn't have enough bytes to be read.
        ErrBrokenTaggedField = errors.New("last tagged field is broken")
)

// MessageSigner is passed to the Encode method to provide a signature
// corresponding to the node's pubkey.
type MessageSigner struct {
        // SignCompact signs the hash of the passed msg with the node's privkey.
        // The returned signature should be 65 bytes, where the last 64 are the
        // compact signature, and the first one is a header byte. This is the
        // format returned by ecdsa.SignCompact.
        SignCompact func(msg []byte) ([]byte, error)
}

// Invoice represents a decoded invoice, or to-be-encoded invoice. Some of the
// fields are optional, and will only be non-nil if the invoice this was parsed
// from contains that field. When encoding, only the non-nil fields will be
// added to the encoded invoice.
type Invoice struct {
        // Net specifies what network this Lightning invoice is meant for.
        Net *chaincfg.Params

        // MilliSat specifies the amount of this invoice in millisatoshi.
        // Optional.
        MilliSat *lnwire.MilliSatoshi

        // Timestamp specifies the time this invoice was created.
        // Mandatory
        Timestamp time.Time

        // PaymentHash is the payment hash to be used for a payment to this
        // invoice.
        PaymentHash *[32]byte

        // PaymentAddr is the payment address to be used by payments to prevent
        // probing of the destination.
        PaymentAddr fn.Option[[32]byte]

        // Destination is the public key of the target node. This will always
        // be set after decoding, and can optionally be set before encoding to
        // include the pubkey as an 'n' field. If this is not set before
        // encoding then the destination pubkey won't be added as an 'n' field,
        // and the pubkey will be extracted from the signature during decoding.
        Destination *btcec.PublicKey

        // minFinalCLTVExpiry is the value that the creator of the invoice
        // expects to be used for the CLTV expiry of the HTLC extended to it in
        // the last hop.
        //
        // NOTE: This value is optional, and should be set to nil if the
        // invoice creator doesn't have a strong requirement on the CLTV expiry
        // of the final HTLC extended to it.
        //
        // This field is un-exported and can only be read by the
        // MinFinalCLTVExpiry() method. By forcing callers to read via this
        // method, we can easily enforce the default if not specified.
        //
        // NOTE: this field is ignored in the case that the invoice contains
        // blinded paths since then the final minimum cltv expiry delta is
        // expected to be included in the route's accumulated CLTV delta value.
        minFinalCLTVExpiry *uint64

        // Description is a short description of the purpose of this invoice.
        // Optional. Non-nil iff DescriptionHash is nil.
        Description *string

        // DescriptionHash is the SHA256 hash of a description of the purpose of
        // this invoice.
        // Optional. Non-nil iff Description is nil.
        DescriptionHash *[32]byte

        // expiry specifies the timespan this invoice will be valid.
        // Optional. If not set, a default expiry of 60 min will be implied.
        //
        // This field is unexported and can be read by the Expiry() method. This
        // method makes sure the default expiry time is returned in case the
        // field is not set.
        expiry *time.Duration

        // FallbackAddr is an on-chain address that can be used for payment in
        // case the Lightning payment fails.
        // Optional.
        FallbackAddr btcutil.Address

        // RouteHints represents one or more different route hints. Each route
        // hint can be individually used to reach the destination. These usually
        // represent private routes.
        //
        // NOTE: This is optional and should not be set at the same time as
        // BlindedPaymentPaths.
        RouteHints [][]HopHint

        // BlindedPaymentPaths is a set of blinded payment paths that can be
        // used to find the payment receiver.
        //
        // NOTE: This is optional and should not be set at the same time as
        // RouteHints.
        BlindedPaymentPaths []*BlindedPaymentPath

        // Features represents an optional field used to signal optional or
        // required support for features by the receiver.
        Features *lnwire.FeatureVector

        // Metadata is additional data that is sent along with the payment to
        // the payee.
        Metadata []byte
}

// Amount is a functional option that allows callers of NewInvoice to set the
// amount in millisatoshis that the Invoice should encode.
func Amount(milliSat lnwire.MilliSatoshi) func(*Invoice) {
        return func(i *Invoice) {
                i.MilliSat = &milliSat
        }
}

// Destination is a functional option that allows callers of NewInvoice to
// explicitly set the pubkey of the Invoice's destination node.
func Destination(destination *btcec.PublicKey) func(*Invoice) {
        return func(i *Invoice) {
                i.Destination = destination
        }
}

// Description is a functional option that allows callers of NewInvoice to set
// the payment description of the created Invoice.
//
// NOTE: Must be used if and only if DescriptionHash is not used.
func Description(description string) func(*Invoice) {
        return func(i *Invoice) {
                i.Description = &description
        }
}

// CLTVExpiry is an optional value which allows the receiver of the payment to
// specify the delta between the current height and the HTLC extended to the
// receiver.
func CLTVExpiry(delta uint64) func(*Invoice) {
        return func(i *Invoice) {
                i.minFinalCLTVExpiry = &delta
        }
}

// DescriptionHash is a functional option that allows callers of NewInvoice to
// set the payment description hash of the created Invoice.
//
// NOTE: Must be used if and only if Description is not used.
func DescriptionHash(descriptionHash [32]byte) func(*Invoice) {
        return func(i *Invoice) {
                i.DescriptionHash = &descriptionHash
        }
}

// Expiry is a functional option that allows callers of NewInvoice to set the
// expiry of the created Invoice. If not set, a default expiry of 60 min will
// be implied.
func Expiry(expiry time.Duration) func(*Invoice) {
        return func(i *Invoice) {
                i.expiry = &expiry
        }
}

// FallbackAddr is a functional option that allows callers of NewInvoice to set
// the Invoice's fallback on-chain address that can be used for payment in case
// the Lightning payment fails
func FallbackAddr(fallbackAddr btcutil.Address) func(*Invoice) {
        return func(i *Invoice) {
                i.FallbackAddr = fallbackAddr
        }
}

// RouteHint is a functional option that allows callers of NewInvoice to add
// one or more hop hints that represent a private route to the destination.
func RouteHint(routeHint []HopHint) func(*Invoice) {
        return func(i *Invoice) {
                i.RouteHints = append(i.RouteHints, routeHint)
        }
}

// WithBlindedPaymentPath is a functional option that allows a caller of
// NewInvoice to attach a blinded payment path to the invoice. The option can
// be used multiple times to attach multiple paths.
func WithBlindedPaymentPath(p *BlindedPaymentPath) func(*Invoice) {
        return func(i *Invoice) {
                i.BlindedPaymentPaths = append(i.BlindedPaymentPaths, p)
        }
}

// Features is a functional option that allows callers of NewInvoice to set the
// desired feature bits that are advertised on the invoice. If this option is
// not used, an empty feature vector will automatically be populated.
func Features(features *lnwire.FeatureVector) func(*Invoice) {
        return func(i *Invoice) {
                i.Features = features
        }
}

// PaymentAddr is a functional option that allows callers of NewInvoice to set
// the desired payment address that is advertised on the invoice.
func PaymentAddr(addr [32]byte) func(*Invoice) {
        return func(i *Invoice) {
                i.PaymentAddr = fn.Some(addr)
        }
}

// Metadata is a functional option that allows callers of NewInvoice to set
// the desired payment Metadata that is advertised on the invoice.
func Metadata(metadata []byte) func(*Invoice) {
        return func(i *Invoice) {
                i.Metadata = metadata
        }
}

// NewInvoice creates a new Invoice object. The last parameter is a set of
// variadic arguments for setting optional fields of the invoice.
//
// NOTE: Either Description  or DescriptionHash must be provided for the Invoice
// to be considered valid.
func NewInvoice(net *chaincfg.Params, paymentHash [32]byte,
        timestamp time.Time, options ...func(*Invoice)) (*Invoice, error) {

        invoice := &Invoice{
                Net:         net,
                PaymentHash: &paymentHash,
                Timestamp:   timestamp,
        }

        for _, option := range options {
                option(invoice)
        }

        // If no features were set, we'll populate an empty feature vector.
        if invoice.Features == nil {
                invoice.Features = lnwire.NewFeatureVector(
                        nil, lnwire.Features,
                )
        }

        if err := validateInvoice(invoice); err != nil {
                return nil, err
        }

        return invoice, nil
}

// Expiry returns the expiry time for this invoice. If expiry time is not set
// explicitly, the default 3600 second expiry will be returned.
func (invoice *Invoice) Expiry() time.Duration {
        if invoice.expiry != nil {
                return *invoice.expiry
        }

        // If no expiry is set for this invoice, default is 3600 seconds.
        return DefaultInvoiceExpiry
}

// MinFinalCLTVExpiry returns the minimum final CLTV expiry delta as specified
// by the creator of the invoice. This value specifies the delta between the
// current height and the expiry height of the HTLC extended in the last hop.
func (invoice *Invoice) MinFinalCLTVExpiry() uint64 {
        if invoice.minFinalCLTVExpiry != nil {
                return *invoice.minFinalCLTVExpiry
        }

        return DefaultAssumedFinalCLTVDelta
}

// validateInvoice does a sanity check of the provided Invoice, making sure it
// has all the necessary fields set for it to be considered valid by BOLT-0011.
func validateInvoice(invoice *Invoice) error {
        // The net must be set.
        if invoice.Net == nil {
                return fmt.Errorf("net params not set")
        }

        // The invoice must contain a payment hash.
        if invoice.PaymentHash == nil {
                return fmt.Errorf("no payment hash found")
        }

        if len(invoice.RouteHints) != 0 &&
                len(invoice.BlindedPaymentPaths) != 0 {

                return fmt.Errorf("cannot have both route hints and blinded " +
                        "payment paths")
        }

        // Either Description or DescriptionHash must be set, not both.
        if invoice.Description != nil && invoice.DescriptionHash != nil {
                return fmt.Errorf("both description and description hash set")
        }
        if invoice.Description == nil && invoice.DescriptionHash == nil {
                return fmt.Errorf("neither description nor description hash set")
        }

        // Check that we support the field lengths.
        if len(invoice.PaymentHash) != 32 {
                return fmt.Errorf("unsupported payment hash length: %d",
                        len(invoice.PaymentHash))
        }

        if invoice.DescriptionHash != nil && len(invoice.DescriptionHash) != 32 {
                return fmt.Errorf("unsupported description hash length: %d",
                        len(invoice.DescriptionHash))
        }

        if invoice.Destination != nil &&
                len(invoice.Destination.SerializeCompressed()) != 33 {
                return fmt.Errorf("unsupported pubkey length: %d",
                        len(invoice.Destination.SerializeCompressed()))
        }

        // Ensure that all invoices have feature vectors.
        if invoice.Features == nil {
                return fmt.Errorf("missing feature vector")
        }

        return nil
}

1	package zpay32
2
3	import (
4	"errors"
5	"fmt"
6	"time"
7
8	"github.com/btcsuite/btcd/btcec/v2"
9	"github.com/btcsuite/btcd/btcutil"
10	"github.com/btcsuite/btcd/chaincfg"
11	"github.com/lightningnetwork/lnd/fn/v2"
12	"github.com/lightningnetwork/lnd/lnwire"
13	)
14
15	const (
16	// mSatPerBtc is the number of millisatoshis in 1 BTC.
17	mSatPerBtc = 100000000000
18
19	// signatureBase32Len is the number of 5-bit groups needed to encode
20	// the 512 bit signature + 8 bit recovery ID.
21	signatureBase32Len = 104
22
23	// timestampBase32Len is the number of 5-bit groups needed to encode
24	// the 35-bit timestamp.
25	timestampBase32Len = 7
26
27	// hashBase32Len is the number of 5-bit groups needed to encode a
28	// 256-bit hash. Note that the last group will be padded with zeroes.
29	hashBase32Len = 52
30
31	// pubKeyBase32Len is the number of 5-bit groups needed to encode a
32	// 33-byte compressed pubkey. Note that the last group will be padded
33	// with zeroes.
34	pubKeyBase32Len = 53
35
36	// hopHintLen is the number of bytes needed to encode the hop hint of a
37	// single private route.
38	hopHintLen = 51
39
40	// The following byte values correspond to the supported field types.
41	// The field name is the character representing that 5-bit value in the
42	// bech32 string.
43
44	// fieldTypeP is the field containing the payment hash.
45	fieldTypeP = 1
46
47	// fieldTypeD contains a short description of the payment.
48	fieldTypeD = 13
49
50	// fieldTypeM contains the payment metadata.
51	fieldTypeM = 27
52
53	// fieldTypeN contains the pubkey of the target node.
54	fieldTypeN = 19
55
56	// fieldTypeH contains the hash of a description of the payment.
57	fieldTypeH = 23
58
59	// fieldTypeX contains the expiry in seconds of the invoice.
60	fieldTypeX = 6
61
62	// fieldTypeF contains a fallback on-chain address.
63	fieldTypeF = 9
64
65	// fieldTypeR contains extra routing information.
66	fieldTypeR = 3
67
68	// fieldTypeC contains an optional requested final CLTV delta.
69	fieldTypeC = 24
70
71	// fieldType9 contains one or more bytes for signaling features
72	// supported or required by the receiver.
73	fieldType9 = 5
74
75	// fieldTypeS contains a 32-byte payment address, which is a nonce
76	// included in the final hop's payload to prevent intermediaries from
77	// probing the recipient.
78	fieldTypeS = 16
79
80	// fieldTypeB contains blinded payment path information. This field may
81	// be repeated to include multiple blinded payment paths in the invoice.
82	fieldTypeB = 20
83
84	// maxInvoiceLength is the maximum total length an invoice can have.
85	// This is chosen to be the maximum number of bytes that can fit into a
86	// single QR code: https://en.wikipedia.org/wiki/QR_code#Storage
87	maxInvoiceLength = 7089
88
89	// DefaultInvoiceExpiry is the default expiry duration from the creation
90	// timestamp if expiry is set to zero.
91	DefaultInvoiceExpiry = time.Hour
92	)
93
94	var (
95	// ErrInvoiceTooLarge is returned when an invoice exceeds
96	// maxInvoiceLength.
97	ErrInvoiceTooLarge = errors.New("invoice is too large")
98
99	// ErrInvalidFieldLength is returned when a tagged field was specified
100	// with a length larger than the left over bytes of the data field.
101	ErrInvalidFieldLength = errors.New("invalid field length")
102
103	// ErrBrokenTaggedField is returned when the last tagged field is
104	// incorrectly formatted and doesn't have enough bytes to be read.
105	ErrBrokenTaggedField = errors.New("last tagged field is broken")
106	)
107
108	// MessageSigner is passed to the Encode method to provide a signature
109	// corresponding to the node's pubkey.
110	type MessageSigner struct {
111	// SignCompact signs the hash of the passed msg with the node's privkey.
112	// The returned signature should be 65 bytes, where the last 64 are the
113	// compact signature, and the first one is a header byte. This is the
114	// format returned by ecdsa.SignCompact.
115	SignCompact func(msg []byte) ([]byte, error)
116	}
117
118	// Invoice represents a decoded invoice, or to-be-encoded invoice. Some of the
119	// fields are optional, and will only be non-nil if the invoice this was parsed
120	// from contains that field. When encoding, only the non-nil fields will be
121	// added to the encoded invoice.
122	type Invoice struct {
123	// Net specifies what network this Lightning invoice is meant for.
124	Net *chaincfg.Params
125
126	// MilliSat specifies the amount of this invoice in millisatoshi.
127	// Optional.
128	MilliSat *lnwire.MilliSatoshi
129
130	// Timestamp specifies the time this invoice was created.
131	// Mandatory
132	Timestamp time.Time
133
134	// PaymentHash is the payment hash to be used for a payment to this
135	// invoice.
136	PaymentHash *[32]byte
137
138	// PaymentAddr is the payment address to be used by payments to prevent
139	// probing of the destination.
140	PaymentAddr fn.Option[[32]byte]
141
142	// Destination is the public key of the target node. This will always
143	// be set after decoding, and can optionally be set before encoding to
144	// include the pubkey as an 'n' field. If this is not set before
145	// encoding then the destination pubkey won't be added as an 'n' field,
146	// and the pubkey will be extracted from the signature during decoding.
147	Destination *btcec.PublicKey
148
149	// minFinalCLTVExpiry is the value that the creator of the invoice
150	// expects to be used for the CLTV expiry of the HTLC extended to it in
151	// the last hop.
152	//
153	// NOTE: This value is optional, and should be set to nil if the
154	// invoice creator doesn't have a strong requirement on the CLTV expiry
155	// of the final HTLC extended to it.
156	//
157	// This field is un-exported and can only be read by the
158	// MinFinalCLTVExpiry() method. By forcing callers to read via this
159	// method, we can easily enforce the default if not specified.
160	//
161	// NOTE: this field is ignored in the case that the invoice contains
162	// blinded paths since then the final minimum cltv expiry delta is
163	// expected to be included in the route's accumulated CLTV delta value.
164	minFinalCLTVExpiry *uint64
165
166	// Description is a short description of the purpose of this invoice.
167	// Optional. Non-nil iff DescriptionHash is nil.
168	Description *string
169
170	// DescriptionHash is the SHA256 hash of a description of the purpose of
171	// this invoice.
172	// Optional. Non-nil iff Description is nil.
173	DescriptionHash *[32]byte
174
175	// expiry specifies the timespan this invoice will be valid.
176	// Optional. If not set, a default expiry of 60 min will be implied.
177	//
178	// This field is unexported and can be read by the Expiry() method. This
179	// method makes sure the default expiry time is returned in case the
180	// field is not set.
181	expiry *time.Duration
182
183	// FallbackAddr is an on-chain address that can be used for payment in
184	// case the Lightning payment fails.
185	// Optional.
186	FallbackAddr btcutil.Address
187
188	// RouteHints represents one or more different route hints. Each route
189	// hint can be individually used to reach the destination. These usually
190	// represent private routes.
191	//
192	// NOTE: This is optional and should not be set at the same time as
193	// BlindedPaymentPaths.
194	RouteHints [][]HopHint
195
196	// BlindedPaymentPaths is a set of blinded payment paths that can be
197	// used to find the payment receiver.
198	//
199	// NOTE: This is optional and should not be set at the same time as
200	// RouteHints.
201	BlindedPaymentPaths []*BlindedPaymentPath
202
203	// Features represents an optional field used to signal optional or
204	// required support for features by the receiver.
205	Features *lnwire.FeatureVector
206
207	// Metadata is additional data that is sent along with the payment to
208	// the payee.
209	Metadata []byte
210	}
211
212	// Amount is a functional option that allows callers of NewInvoice to set the
213	// amount in millisatoshis that the Invoice should encode.
214	func Amount(milliSat lnwire.MilliSatoshi) func(*Invoice) {	98✔
215	return func(i *Invoice) {	196✔
216	i.MilliSat = &milliSat	98✔
217	}	98✔
218	}
219
220	// Destination is a functional option that allows callers of NewInvoice to
221	// explicitly set the pubkey of the Invoice's destination node.
222	func Destination(destination btcec.PublicKey) func(Invoice) {	7✔
223	return func(i *Invoice) {	14✔
224	i.Destination = destination	7✔
225	}	7✔
226	}
227
228	// Description is a functional option that allows callers of NewInvoice to set
229	// the payment description of the created Invoice.
230	//
231	// NOTE: Must be used if and only if DescriptionHash is not used.
232	func Description(description string) func(*Invoice) {	103✔
233	return func(i *Invoice) {	206✔
234	i.Description = &description	103✔
235	}	103✔
236	}
237
238	// CLTVExpiry is an optional value which allows the receiver of the payment to
239	// specify the delta between the current height and the HTLC extended to the
240	// receiver.
241	func CLTVExpiry(delta uint64) func(*Invoice) {	4✔
242	return func(i *Invoice) {	8✔
243	i.minFinalCLTVExpiry = &delta	4✔
244	}	4✔
245	}
246
247	// DescriptionHash is a functional option that allows callers of NewInvoice to
248	// set the payment description hash of the created Invoice.
249	//
250	// NOTE: Must be used if and only if Description is not used.
251	func DescriptionHash(descriptionHash [32]byte) func(*Invoice) {	2✔
252	return func(i *Invoice) {	4✔
253	i.DescriptionHash = &descriptionHash	2✔
254	}	2✔
255	}
256
257	// Expiry is a functional option that allows callers of NewInvoice to set the
258	// expiry of the created Invoice. If not set, a default expiry of 60 min will
259	// be implied.
260	func Expiry(expiry time.Duration) func(*Invoice) {	91✔
261	return func(i *Invoice) {	182✔
262	i.expiry = &expiry	91✔
263	}	91✔
264	}
265
266	// FallbackAddr is a functional option that allows callers of NewInvoice to set
267	// the Invoice's fallback on-chain address that can be used for payment in case
268	// the Lightning payment fails
269	func FallbackAddr(fallbackAddr btcutil.Address) func(*Invoice) {	1✔
270	return func(i *Invoice) {	2✔
271	i.FallbackAddr = fallbackAddr	1✔
272	}	1✔
273	}
274
275	// RouteHint is a functional option that allows callers of NewInvoice to add
276	// one or more hop hints that represent a private route to the destination.
277	func RouteHint(routeHint []HopHint) func(*Invoice) {	1✔
278	return func(i *Invoice) {	2✔
279	i.RouteHints = append(i.RouteHints, routeHint)	1✔
280	}	1✔
281	}
282
283	// WithBlindedPaymentPath is a functional option that allows a caller of
284	// NewInvoice to attach a blinded payment path to the invoice. The option can
285	// be used multiple times to attach multiple paths.
286	func WithBlindedPaymentPath(p BlindedPaymentPath) func(Invoice) {	2✔
287	return func(i *Invoice) {	4✔
288	i.BlindedPaymentPaths = append(i.BlindedPaymentPaths, p)	2✔
289	}	2✔
290	}
291
292	// Features is a functional option that allows callers of NewInvoice to set the
293	// desired feature bits that are advertised on the invoice. If this option is
294	// not used, an empty feature vector will automatically be populated.
UNCOV 295	func Features(features lnwire.FeatureVector) func(Invoice) {	×
UNCOV 296	return func(i *Invoice) {	×
UNCOV 297	i.Features = features	×
UNCOV 298	}	×
299	}
300
301	// PaymentAddr is a functional option that allows callers of NewInvoice to set
302	// the desired payment address that is advertised on the invoice.
303	func PaymentAddr(addr [32]byte) func(*Invoice) {	90✔
304	return func(i *Invoice) {	180✔
305	i.PaymentAddr = fn.Some(addr)	90✔
306	}	90✔
307	}
308
309	// Metadata is a functional option that allows callers of NewInvoice to set
310	// the desired payment Metadata that is advertised on the invoice.
311	func Metadata(metadata []byte) func(*Invoice) {	×
312	return func(i *Invoice) {	×
313	i.Metadata = metadata	×
314	}	×
315	}
316
317	// NewInvoice creates a new Invoice object. The last parameter is a set of
318	// variadic arguments for setting optional fields of the invoice.
319	//
320	// NOTE: Either Description or DescriptionHash must be provided for the Invoice
321	// to be considered valid.
322	func NewInvoice(net *chaincfg.Params, paymentHash [32]byte,
323	timestamp time.Time, options ...func(Invoice)) (Invoice, error) {	104✔
324		104✔
325	invoice := &Invoice{	104✔
326	Net: net,	104✔
327	PaymentHash: &paymentHash,	104✔
328	Timestamp: timestamp,	104✔
329	}	104✔
330		104✔
331	for _, option := range options {	503✔
332	option(invoice)	399✔
333	}	399✔
334
335	// If no features were set, we'll populate an empty feature vector.
336	if invoice.Features == nil {	208✔
337	invoice.Features = lnwire.NewFeatureVector(	104✔
338	nil, lnwire.Features,	104✔
339	)	104✔
340	}	104✔
341
342	if err := validateInvoice(invoice); err != nil {	105✔
343	return nil, err	1✔
344	}	1✔
345
346	return invoice, nil	103✔
347	}
348
349	// Expiry returns the expiry time for this invoice. If expiry time is not set
350	// explicitly, the default 3600 second expiry will be returned.
UNCOV 351	func (invoice *Invoice) Expiry() time.Duration {	×
UNCOV 352	if invoice.expiry != nil {	×
UNCOV 353	return *invoice.expiry	×
UNCOV 354	}	×
355
356	// If no expiry is set for this invoice, default is 3600 seconds.
357	return DefaultInvoiceExpiry	×
358	}
359
360	// MinFinalCLTVExpiry returns the minimum final CLTV expiry delta as specified
361	// by the creator of the invoice. This value specifies the delta between the
362	// current height and the expiry height of the HTLC extended in the last hop.
UNCOV 363	func (invoice *Invoice) MinFinalCLTVExpiry() uint64 {	×
UNCOV 364	if invoice.minFinalCLTVExpiry != nil {	×
UNCOV 365	return *invoice.minFinalCLTVExpiry	×
UNCOV 366	}	×
367
UNCOV 368	return DefaultAssumedFinalCLTVDelta	×
369	}
370
371	// validateInvoice does a sanity check of the provided Invoice, making sure it
372	// has all the necessary fields set for it to be considered valid by BOLT-0011.
373	func validateInvoice(invoice *Invoice) error {	509✔
374	// The net must be set.	509✔
375	if invoice.Net == nil {	509✔
376	return fmt.Errorf("net params not set")	×
377	}	×
378
379	// The invoice must contain a payment hash.
380	if invoice.PaymentHash == nil {	572✔
381	return fmt.Errorf("no payment hash found")	63✔
382	}	63✔
383
384	if len(invoice.RouteHints) != 0 &&	446✔
385	len(invoice.BlindedPaymentPaths) != 0 {	446✔
386		×
387	return fmt.Errorf("cannot have both route hints and blinded " +	×
388	"payment paths")	×
389	}	×
390
391	// Either Description or DescriptionHash must be set, not both.
392	if invoice.Description != nil && invoice.DescriptionHash != nil {	450✔
393	return fmt.Errorf("both description and description hash set")	4✔
394	}	4✔
395	if invoice.Description == nil && invoice.DescriptionHash == nil {	446✔
396	return fmt.Errorf("neither description nor description hash set")	4✔
397	}	4✔
398
399	// Check that we support the field lengths.
400	if len(invoice.PaymentHash) != 32 {	438✔
401	return fmt.Errorf("unsupported payment hash length: %d",	×
402	len(invoice.PaymentHash))	×
403	}	×
404
405	if invoice.DescriptionHash != nil && len(invoice.DescriptionHash) != 32 {	438✔
406	return fmt.Errorf("unsupported description hash length: %d",	×
407	len(invoice.DescriptionHash))	×
408	}	×
409
410	if invoice.Destination != nil &&	438✔
411	len(invoice.Destination.SerializeCompressed()) != 33 {	438✔
412	return fmt.Errorf("unsupported pubkey length: %d",	×
413	len(invoice.Destination.SerializeCompressed()))	×
414	}	×
415
416	// Ensure that all invoices have feature vectors.
417	if invoice.Features == nil {	438✔
418	return fmt.Errorf("missing feature vector")	×
419	}	×
420
421	return nil	438✔
422	}

lightningnetwork / lnd / 13536249039

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