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

/channeldb/migration_01_to_11/migration_11_invoices.go

package migration_01_to_11

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

        bitcoinCfg "github.com/btcsuite/btcd/chaincfg"
        "github.com/btcsuite/btcd/wire"
        lnwire "github.com/lightningnetwork/lnd/channeldb/migration/lnwire21"
        "github.com/lightningnetwork/lnd/channeldb/migration_01_to_11/zpay32"
        "github.com/lightningnetwork/lnd/kvdb"
        litecoinCfg "github.com/ltcsuite/ltcd/chaincfg"
)

// MigrateInvoices adds invoice htlcs and a separate cltv delta field to the
// invoices.
func MigrateInvoices(tx kvdb.RwTx) error {
        log.Infof("Migrating invoices to new invoice format")

        invoiceB := tx.ReadWriteBucket(invoiceBucket)
        if invoiceB == nil {
                return nil
        }

        // Iterate through the entire key space of the top-level invoice bucket.
        // If key with a non-nil value stores the next invoice ID which maps to
        // the corresponding invoice. Store those keys first, because it isn't
        // safe to modify the bucket inside a ForEach loop.
        var invoiceKeys [][]byte
        err := invoiceB.ForEach(func(k, v []byte) error {
                if v == nil {
                        return nil
                }

                invoiceKeys = append(invoiceKeys, k)

                return nil
        })
        if err != nil {
                return err
        }

        nets := []*bitcoinCfg.Params{
                &bitcoinCfg.MainNetParams, &bitcoinCfg.SimNetParams,
                &bitcoinCfg.RegressionNetParams, &bitcoinCfg.TestNet3Params,
        }

        ltcNets := []*litecoinCfg.Params{
                &litecoinCfg.MainNetParams, &litecoinCfg.SimNetParams,
                &litecoinCfg.RegressionNetParams, &litecoinCfg.TestNet4Params,
        }
        for _, net := range ltcNets {
                var convertedNet bitcoinCfg.Params
                convertedNet.Bech32HRPSegwit = net.Bech32HRPSegwit
                nets = append(nets, &convertedNet)
        }

        // Iterate over all stored keys and migrate the invoices.
        for _, k := range invoiceKeys {
                v := invoiceB.Get(k)

                // Deserialize the invoice with the deserializing function that
                // was in use for this version of the database.
                invoiceReader := bytes.NewReader(v)
                invoice, err := deserializeInvoiceLegacy(invoiceReader)
                if err != nil {
                        return err
                }

                if invoice.Terms.State == ContractAccepted {
                        return fmt.Errorf("cannot upgrade with invoice(s) " +
                                "in accepted state, see release notes")
                }

                // Try to decode the payment request for every possible net to
                // avoid passing a the active network to channeldb. This would
                // be a layering violation, while this migration is only running
                // once and will likely be removed in the future.
                var payReq *zpay32.Invoice
                for _, net := range nets {
                        payReq, err = zpay32.Decode(
                                string(invoice.PaymentRequest), net,
                        )
                        if err == nil {
                                break
                        }
                }
                if payReq == nil {
                        return fmt.Errorf("cannot decode payreq")
                }
                invoice.FinalCltvDelta = int32(payReq.MinFinalCLTVExpiry())
                invoice.Expiry = payReq.Expiry()

                // Serialize the invoice in the new format and use it to replace
                // the old invoice in the database.
                var buf bytes.Buffer
                if err := serializeInvoice(&buf, &invoice); err != nil {
                        return err
                }

                err = invoiceB.Put(k, buf.Bytes())
                if err != nil {
                        return err
                }
        }

        log.Infof("Migration of invoices completed!")
        return nil
}

func deserializeInvoiceLegacy(r io.Reader) (Invoice, error) {
        var err error
        invoice := Invoice{}

        // TODO(roasbeef): use read full everywhere
        invoice.Memo, err = wire.ReadVarBytes(r, 0, MaxMemoSize, "")
        if err != nil {
                return invoice, err
        }
        invoice.Receipt, err = wire.ReadVarBytes(r, 0, MaxReceiptSize, "")
        if err != nil {
                return invoice, err
        }

        invoice.PaymentRequest, err = wire.ReadVarBytes(r, 0, MaxPaymentRequestSize, "")
        if err != nil {
                return invoice, err
        }

        birthBytes, err := wire.ReadVarBytes(r, 0, 300, "birth")
        if err != nil {
                return invoice, err
        }
        if err := invoice.CreationDate.UnmarshalBinary(birthBytes); err != nil {
                return invoice, err
        }

        settledBytes, err := wire.ReadVarBytes(r, 0, 300, "settled")
        if err != nil {
                return invoice, err
        }
        if err := invoice.SettleDate.UnmarshalBinary(settledBytes); err != nil {
                return invoice, err
        }

        if _, err := io.ReadFull(r, invoice.Terms.PaymentPreimage[:]); err != nil {
                return invoice, err
        }
        var scratch [8]byte
        if _, err := io.ReadFull(r, scratch[:]); err != nil {
                return invoice, err
        }
        invoice.Terms.Value = lnwire.MilliSatoshi(byteOrder.Uint64(scratch[:]))

        if err := binary.Read(r, byteOrder, &invoice.Terms.State); err != nil {
                return invoice, err
        }

        if err := binary.Read(r, byteOrder, &invoice.AddIndex); err != nil {
                return invoice, err
        }
        if err := binary.Read(r, byteOrder, &invoice.SettleIndex); err != nil {
                return invoice, err
        }
        if err := binary.Read(r, byteOrder, &invoice.AmtPaid); err != nil {
                return invoice, err
        }

        return invoice, nil
}

// serializeInvoiceLegacy serializes an invoice in the format of the previous db
// version.
func serializeInvoiceLegacy(w io.Writer, i *Invoice) error {
        if err := wire.WriteVarBytes(w, 0, i.Memo[:]); err != nil {
                return err
        }
        if err := wire.WriteVarBytes(w, 0, i.Receipt[:]); err != nil {
                return err
        }
        if err := wire.WriteVarBytes(w, 0, i.PaymentRequest[:]); err != nil {
                return err
        }

        birthBytes, err := i.CreationDate.MarshalBinary()
        if err != nil {
                return err
        }

        if err := wire.WriteVarBytes(w, 0, birthBytes); err != nil {
                return err
        }

        settleBytes, err := i.SettleDate.MarshalBinary()
        if err != nil {
                return err
        }

        if err := wire.WriteVarBytes(w, 0, settleBytes); err != nil {
                return err
        }

        if _, err := w.Write(i.Terms.PaymentPreimage[:]); err != nil {
                return err
        }

        var scratch [8]byte
        byteOrder.PutUint64(scratch[:], uint64(i.Terms.Value))
        if _, err := w.Write(scratch[:]); err != nil {
                return err
        }

        if err := binary.Write(w, byteOrder, i.Terms.State); err != nil {
                return err
        }

        if err := binary.Write(w, byteOrder, i.AddIndex); err != nil {
                return err
        }
        if err := binary.Write(w, byteOrder, i.SettleIndex); err != nil {
                return err
        }
        if err := binary.Write(w, byteOrder, int64(i.AmtPaid)); err != nil {
                return err
        }

        return nil
}

1	package migration_01_to_11
2
3	import (
4	"bytes"
5	"encoding/binary"
6	"fmt"
7	"io"
8
9	bitcoinCfg "github.com/btcsuite/btcd/chaincfg"
10	"github.com/btcsuite/btcd/wire"
11	lnwire "github.com/lightningnetwork/lnd/channeldb/migration/lnwire21"
12	"github.com/lightningnetwork/lnd/channeldb/migration_01_to_11/zpay32"
13	"github.com/lightningnetwork/lnd/kvdb"
14	litecoinCfg "github.com/ltcsuite/ltcd/chaincfg"
15	)
16
17	// MigrateInvoices adds invoice htlcs and a separate cltv delta field to the
18	// invoices.
19	func MigrateInvoices(tx kvdb.RwTx) error {	×
20	log.Infof("Migrating invoices to new invoice format")	×
21		×
22	invoiceB := tx.ReadWriteBucket(invoiceBucket)	×
23	if invoiceB == nil {	×
24	return nil	×
25	}	×
26
27	// Iterate through the entire key space of the top-level invoice bucket.
28	// If key with a non-nil value stores the next invoice ID which maps to
29	// the corresponding invoice. Store those keys first, because it isn't
30	// safe to modify the bucket inside a ForEach loop.
31	var invoiceKeys [][]byte	×
32	err := invoiceB.ForEach(func(k, v []byte) error {	×
33	if v == nil {	×
34	return nil	×
35	}	×
36
37	invoiceKeys = append(invoiceKeys, k)	×
38		×
39	return nil	×
40	})
41	if err != nil {	×
42	return err	×
43	}	×
44
45	nets := []*bitcoinCfg.Params{	×
46	&bitcoinCfg.MainNetParams, &bitcoinCfg.SimNetParams,	×
47	&bitcoinCfg.RegressionNetParams, &bitcoinCfg.TestNet3Params,	×
48	}	×
49		×
50	ltcNets := []*litecoinCfg.Params{	×
51	&litecoinCfg.MainNetParams, &litecoinCfg.SimNetParams,	×
52	&litecoinCfg.RegressionNetParams, &litecoinCfg.TestNet4Params,	×
53	}	×
54	for _, net := range ltcNets {	×
55	var convertedNet bitcoinCfg.Params	×
56	convertedNet.Bech32HRPSegwit = net.Bech32HRPSegwit	×
57	nets = append(nets, &convertedNet)	×
58	}	×
59
60	// Iterate over all stored keys and migrate the invoices.
61	for _, k := range invoiceKeys {	×
62	v := invoiceB.Get(k)	×
63		×
64	// Deserialize the invoice with the deserializing function that	×
65	// was in use for this version of the database.	×
66	invoiceReader := bytes.NewReader(v)	×
67	invoice, err := deserializeInvoiceLegacy(invoiceReader)	×
68	if err != nil {	×
69	return err	×
70	}	×
71
72	if invoice.Terms.State == ContractAccepted {	×
73	return fmt.Errorf("cannot upgrade with invoice(s) " +	×
74	"in accepted state, see release notes")	×
75	}	×
76
77	// Try to decode the payment request for every possible net to
78	// avoid passing a the active network to channeldb. This would
79	// be a layering violation, while this migration is only running
80	// once and will likely be removed in the future.
81	var payReq *zpay32.Invoice	×
82	for _, net := range nets {	×
83	payReq, err = zpay32.Decode(	×
84	string(invoice.PaymentRequest), net,	×
85	)	×
86	if err == nil {	×
87	break	×
88	}
89	}
90	if payReq == nil {	×
91	return fmt.Errorf("cannot decode payreq")	×
92	}	×
93	invoice.FinalCltvDelta = int32(payReq.MinFinalCLTVExpiry())	×
94	invoice.Expiry = payReq.Expiry()	×
95		×
96	// Serialize the invoice in the new format and use it to replace	×
97	// the old invoice in the database.	×
98	var buf bytes.Buffer	×
99	if err := serializeInvoice(&buf, &invoice); err != nil {	×
100	return err	×
101	}	×
102
103	err = invoiceB.Put(k, buf.Bytes())	×
104	if err != nil {	×
105	return err	×
106	}	×
107	}
108
109	log.Infof("Migration of invoices completed!")	×
110	return nil	×
111	}
112
113	func deserializeInvoiceLegacy(r io.Reader) (Invoice, error) {	×
114	var err error	×
115	invoice := Invoice{}	×
116		×
117	// TODO(roasbeef): use read full everywhere	×
118	invoice.Memo, err = wire.ReadVarBytes(r, 0, MaxMemoSize, "")	×
119	if err != nil {	×
120	return invoice, err	×
121	}	×
122	invoice.Receipt, err = wire.ReadVarBytes(r, 0, MaxReceiptSize, "")	×
123	if err != nil {	×
124	return invoice, err	×
125	}	×
126
127	invoice.PaymentRequest, err = wire.ReadVarBytes(r, 0, MaxPaymentRequestSize, "")	×
128	if err != nil {	×
129	return invoice, err	×
130	}	×
131
132	birthBytes, err := wire.ReadVarBytes(r, 0, 300, "birth")	×
133	if err != nil {	×
134	return invoice, err	×
135	}	×
136	if err := invoice.CreationDate.UnmarshalBinary(birthBytes); err != nil {	×
137	return invoice, err	×
138	}	×
139
140	settledBytes, err := wire.ReadVarBytes(r, 0, 300, "settled")	×
141	if err != nil {	×
142	return invoice, err	×
143	}	×
144	if err := invoice.SettleDate.UnmarshalBinary(settledBytes); err != nil {	×
145	return invoice, err	×
146	}	×
147
148	if _, err := io.ReadFull(r, invoice.Terms.PaymentPreimage[:]); err != nil {	×
149	return invoice, err	×
150	}	×
151	var scratch [8]byte	×
152	if _, err := io.ReadFull(r, scratch[:]); err != nil {	×
153	return invoice, err	×
154	}	×
155	invoice.Terms.Value = lnwire.MilliSatoshi(byteOrder.Uint64(scratch[:]))	×
156		×
157	if err := binary.Read(r, byteOrder, &invoice.Terms.State); err != nil {	×
158	return invoice, err	×
159	}	×
160
161	if err := binary.Read(r, byteOrder, &invoice.AddIndex); err != nil {	×
162	return invoice, err	×
163	}	×
164	if err := binary.Read(r, byteOrder, &invoice.SettleIndex); err != nil {	×
165	return invoice, err	×
166	}	×
167	if err := binary.Read(r, byteOrder, &invoice.AmtPaid); err != nil {	×
168	return invoice, err	×
169	}	×
170
171	return invoice, nil	×
172	}
173
174	// serializeInvoiceLegacy serializes an invoice in the format of the previous db
175	// version.
176	func serializeInvoiceLegacy(w io.Writer, i *Invoice) error {	×
177	if err := wire.WriteVarBytes(w, 0, i.Memo[:]); err != nil {	×
178	return err	×
179	}	×
180	if err := wire.WriteVarBytes(w, 0, i.Receipt[:]); err != nil {	×
181	return err	×
182	}	×
183	if err := wire.WriteVarBytes(w, 0, i.PaymentRequest[:]); err != nil {	×
184	return err	×
185	}	×
186
187	birthBytes, err := i.CreationDate.MarshalBinary()	×
188	if err != nil {	×
189	return err	×
190	}	×
191
192	if err := wire.WriteVarBytes(w, 0, birthBytes); err != nil {	×
193	return err	×
194	}	×
195
196	settleBytes, err := i.SettleDate.MarshalBinary()	×
197	if err != nil {	×
198	return err	×
199	}	×
200
201	if err := wire.WriteVarBytes(w, 0, settleBytes); err != nil {	×
202	return err	×
203	}	×
204
205	if _, err := w.Write(i.Terms.PaymentPreimage[:]); err != nil {	×
206	return err	×
207	}	×
208
209	var scratch [8]byte	×
210	byteOrder.PutUint64(scratch[:], uint64(i.Terms.Value))	×
211	if _, err := w.Write(scratch[:]); err != nil {	×
212	return err	×
213	}	×
214
215	if err := binary.Write(w, byteOrder, i.Terms.State); err != nil {	×
216	return err	×
217	}	×
218
219	if err := binary.Write(w, byteOrder, i.AddIndex); err != nil {	×
220	return err	×
221	}	×
222	if err := binary.Write(w, byteOrder, i.SettleIndex); err != nil {	×
223	return err	×
224	}	×
225	if err := binary.Write(w, byteOrder, int64(i.AmtPaid)); err != nil {	×
226	return err	×
227	}	×
228
229	return nil	×
230	}

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