13211764208

Committed 08 Feb 2025 03:08AM UTC coverage: 49.288% (-9.5%) from 58.815%

Build # 13211764208

Build Type

Pull #9489

github

Committed by

calvinrzachman

Commit Message

itest: verify switchrpc server enforces send then track

We prevent the rpc server from allowing onion dispatches for
attempt IDs which have already been tracked by rpc clients.

This helps protect the client from leaking a duplicate onion
attempt. NOTE: This is not the only method for solving this
issue! The issue could be addressed via careful client side
programming which accounts for the uncertainty and async
nature of dispatching onions to a remote process via RPC.
This would require some lnd ChannelRouter changes for how
we intend to use these RPCs though.

Pull Request Pull Request #9489: multi: add BuildOnion, SendOnion, and TrackOnion RPCs

Run Details

474 of 990 new or added lines in 11 files covered. (47.88%)

27321 existing lines in 435 files now uncovered.

101192 of 205306 relevant lines covered (49.29%)

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_09_legacy_serialization.go

package migration_01_to_11

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

        lnwire "github.com/lightningnetwork/lnd/channeldb/migration/lnwire21"
        "github.com/lightningnetwork/lnd/kvdb"
        "github.com/lightningnetwork/lnd/lntypes"
)

var (
        // paymentBucket is the name of the bucket within the database that
        // stores all data related to payments.
        //
        // Within the payments bucket, each invoice is keyed by its invoice ID
        // which is a monotonically increasing uint64.  BoltDB's sequence
        // feature is used for generating monotonically increasing id.
        //
        // NOTE: Deprecated. Kept around for migration purposes.
        paymentBucket = []byte("payments")

        // paymentStatusBucket is the name of the bucket within the database
        // that stores the status of a payment indexed by the payment's
        // preimage.
        //
        // NOTE: Deprecated. Kept around for migration purposes.
        paymentStatusBucket = []byte("payment-status")
)

// outgoingPayment represents a successful payment between the daemon and a
// remote node. Details such as the total fee paid, and the time of the payment
// are stored.
//
// NOTE: Deprecated. Kept around for migration purposes.
type outgoingPayment struct {
        Invoice

        // Fee is the total fee paid for the payment in milli-satoshis.
        Fee lnwire.MilliSatoshi

        // TotalTimeLock is the total cumulative time-lock in the HTLC extended
        // from the second-to-last hop to the destination.
        TimeLockLength uint32

        // Path encodes the path the payment took through the network. The path
        // excludes the outgoing node and consists of the hex-encoded
        // compressed public key of each of the nodes involved in the payment.
        Path [][33]byte

        // PaymentPreimage is the preImage of a successful payment. This is used
        // to calculate the PaymentHash as well as serve as a proof of payment.
        PaymentPreimage [32]byte
}

// addPayment saves a successful payment to the database. It is assumed that
// all payment are sent using unique payment hashes.
//
// NOTE: Deprecated. Kept around for migration purposes.
func (db *DB) addPayment(payment *outgoingPayment) error {
        // Validate the field of the inner voice within the outgoing payment,
        // these must also adhere to the same constraints as regular invoices.
        if err := validateInvoice(&payment.Invoice); err != nil {
                return err
        }

        // We first serialize the payment before starting the database
        // transaction so we can avoid creating a DB payment in the case of a
        // serialization error.
        var b bytes.Buffer
        if err := serializeOutgoingPayment(&b, payment); err != nil {
                return err
        }
        paymentBytes := b.Bytes()

        return kvdb.Update(db, func(tx kvdb.RwTx) error {
                payments, err := tx.CreateTopLevelBucket(paymentBucket)
                if err != nil {
                        return err
                }

                // Obtain the new unique sequence number for this payment.
                paymentID, err := payments.NextSequence()
                if err != nil {
                        return err
                }

                // We use BigEndian for keys as it orders keys in
                // ascending order. This allows bucket scans to order payments
                // in the order in which they were created.
                paymentIDBytes := make([]byte, 8)
                binary.BigEndian.PutUint64(paymentIDBytes, paymentID)

                return payments.Put(paymentIDBytes, paymentBytes)
        }, func() {})
}

// fetchAllPayments returns all outgoing payments in DB.
//
// NOTE: Deprecated. Kept around for migration purposes.
func (db *DB) fetchAllPayments() ([]*outgoingPayment, error) {
        var payments []*outgoingPayment

        err := kvdb.View(db, func(tx kvdb.RTx) error {
                bucket := tx.ReadBucket(paymentBucket)
                if bucket == nil {
                        return ErrNoPaymentsCreated
                }

                return bucket.ForEach(func(k, v []byte) error {
                        // If the value is nil, then we ignore it as it may be
                        // a sub-bucket.
                        if v == nil {
                                return nil
                        }

                        r := bytes.NewReader(v)
                        payment, err := deserializeOutgoingPayment(r)
                        if err != nil {
                                return err
                        }

                        payments = append(payments, payment)
                        return nil
                })
        }, func() {
                payments = nil
        })
        if err != nil {
                return nil, err
        }

        return payments, nil
}

// fetchPaymentStatus returns the payment status for outgoing payment.
// If status of the payment isn't found, it will default to "StatusUnknown".
//
// NOTE: Deprecated. Kept around for migration purposes.
func (db *DB) fetchPaymentStatus(paymentHash [32]byte) (PaymentStatus, error) {
        var paymentStatus = StatusUnknown
        err := kvdb.View(db, func(tx kvdb.RTx) error {
                var err error
                paymentStatus, err = fetchPaymentStatusTx(tx, paymentHash)
                return err
        }, func() {
                paymentStatus = StatusUnknown
        })
        if err != nil {
                return StatusUnknown, err
        }

        return paymentStatus, nil
}

// fetchPaymentStatusTx is a helper method that returns the payment status for
// outgoing payment.  If status of the payment isn't found, it will default to
// "StatusUnknown". It accepts the boltdb transactions such that this method
// can be composed into other atomic operations.
//
// NOTE: Deprecated. Kept around for migration purposes.
func fetchPaymentStatusTx(tx kvdb.RTx, paymentHash [32]byte) (PaymentStatus, error) {
        // The default status for all payments that aren't recorded in database.
        var paymentStatus = StatusUnknown

        bucket := tx.ReadBucket(paymentStatusBucket)
        if bucket == nil {
                return paymentStatus, nil
        }

        paymentStatusBytes := bucket.Get(paymentHash[:])
        if paymentStatusBytes == nil {
                return paymentStatus, nil
        }

        paymentStatus.FromBytes(paymentStatusBytes)

        return paymentStatus, nil
}

func serializeOutgoingPayment(w io.Writer, p *outgoingPayment) error {
        var scratch [8]byte

        if err := serializeInvoiceLegacy(w, &p.Invoice); err != nil {
                return err
        }

        byteOrder.PutUint64(scratch[:], uint64(p.Fee))
        if _, err := w.Write(scratch[:]); err != nil {
                return err
        }

        // First write out the length of the bytes to prefix the value.
        pathLen := uint32(len(p.Path))
        byteOrder.PutUint32(scratch[:4], pathLen)
        if _, err := w.Write(scratch[:4]); err != nil {
                return err
        }

        // Then with the path written, we write out the series of public keys
        // involved in the path.
        for _, hop := range p.Path {
                if _, err := w.Write(hop[:]); err != nil {
                        return err
                }
        }

        byteOrder.PutUint32(scratch[:4], p.TimeLockLength)
        if _, err := w.Write(scratch[:4]); err != nil {
                return err
        }

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

        return nil
}

func deserializeOutgoingPayment(r io.Reader) (*outgoingPayment, error) {
        var scratch [8]byte

        p := &outgoingPayment{}

        inv, err := deserializeInvoiceLegacy(r)
        if err != nil {
                return nil, err
        }
        p.Invoice = inv

        if _, err := r.Read(scratch[:]); err != nil {
                return nil, err
        }
        p.Fee = lnwire.MilliSatoshi(byteOrder.Uint64(scratch[:]))

        if _, err = r.Read(scratch[:4]); err != nil {
                return nil, err
        }
        pathLen := byteOrder.Uint32(scratch[:4])

        path := make([][33]byte, pathLen)
        for i := uint32(0); i < pathLen; i++ {
                if _, err := r.Read(path[i][:]); err != nil {
                        return nil, err
                }
        }
        p.Path = path

        if _, err = r.Read(scratch[:4]); err != nil {
                return nil, err
        }
        p.TimeLockLength = byteOrder.Uint32(scratch[:4])

        if _, err := r.Read(p.PaymentPreimage[:]); err != nil {
                return nil, err
        }

        return p, nil
}

// serializePaymentAttemptInfoMigration9 is the serializePaymentAttemptInfo
// version as existed when migration #9 was created. We keep this around, along
// with the methods below to ensure that clients that upgrade will use the
// correct version of this method.
func serializePaymentAttemptInfoMigration9(w io.Writer, a *PaymentAttemptInfo) error {
        if err := WriteElements(w, a.PaymentID, a.SessionKey); err != nil {
                return err
        }

        if err := serializeRouteMigration9(w, a.Route); err != nil {
                return err
        }

        return nil
}

func serializeHopMigration9(w io.Writer, h *Hop) error {
        if err := WriteElements(w,
                h.PubKeyBytes[:], h.ChannelID, h.OutgoingTimeLock,
                h.AmtToForward,
        ); err != nil {
                return err
        }

        return nil
}

func serializeRouteMigration9(w io.Writer, r Route) error {
        if err := WriteElements(w,
                r.TotalTimeLock, r.TotalAmount, r.SourcePubKey[:],
        ); err != nil {
                return err
        }

        if err := WriteElements(w, uint32(len(r.Hops))); err != nil {
                return err
        }

        for _, h := range r.Hops {
                if err := serializeHopMigration9(w, h); err != nil {
                        return err
                }
        }

        return nil
}

func deserializePaymentAttemptInfoMigration9(r io.Reader) (*PaymentAttemptInfo, error) {
        a := &PaymentAttemptInfo{}
        err := ReadElements(r, &a.PaymentID, &a.SessionKey)
        if err != nil {
                return nil, err
        }
        a.Route, err = deserializeRouteMigration9(r)
        if err != nil {
                return nil, err
        }
        return a, nil
}

func deserializeRouteMigration9(r io.Reader) (Route, error) {
        rt := Route{}
        if err := ReadElements(r,
                &rt.TotalTimeLock, &rt.TotalAmount,
        ); err != nil {
                return rt, err
        }

        var pub []byte
        if err := ReadElements(r, &pub); err != nil {
                return rt, err
        }
        copy(rt.SourcePubKey[:], pub)

        var numHops uint32
        if err := ReadElements(r, &numHops); err != nil {
                return rt, err
        }

        var hops []*Hop
        for i := uint32(0); i < numHops; i++ {
                hop, err := deserializeHopMigration9(r)
                if err != nil {
                        return rt, err
                }
                hops = append(hops, hop)
        }
        rt.Hops = hops

        return rt, nil
}

func deserializeHopMigration9(r io.Reader) (*Hop, error) {
        h := &Hop{}

        var pub []byte
        if err := ReadElements(r, &pub); err != nil {
                return nil, err
        }
        copy(h.PubKeyBytes[:], pub)

        if err := ReadElements(r,
                &h.ChannelID, &h.OutgoingTimeLock, &h.AmtToForward,
        ); err != nil {
                return nil, err
        }

        return h, nil
}

// fetchPaymentsMigration9 returns all sent payments found in the DB using the
// payment attempt info format that was present as of migration #9. We need
// this as otherwise, the current FetchPayments version will use the latest
// decoding format. Note that we only need this for the
// TestOutgoingPaymentsMigration migration test case.
func (db *DB) fetchPaymentsMigration9() ([]*Payment, error) {
        var payments []*Payment

        err := kvdb.View(db, func(tx kvdb.RTx) error {
                paymentsBucket := tx.ReadBucket(paymentsRootBucket)
                if paymentsBucket == nil {
                        return nil
                }

                return paymentsBucket.ForEach(func(k, v []byte) error {
                        bucket := paymentsBucket.NestedReadBucket(k)
                        if bucket == nil {
                                // We only expect sub-buckets to be found in
                                // this top-level bucket.
                                return fmt.Errorf("non bucket element in " +
                                        "payments bucket")
                        }

                        p, err := fetchPaymentMigration9(bucket)
                        if err != nil {
                                return err
                        }

                        payments = append(payments, p)

                        // For older versions of lnd, duplicate payments to a
                        // payment has was possible. These will be found in a
                        // sub-bucket indexed by their sequence number if
                        // available.
                        dup := bucket.NestedReadBucket(paymentDuplicateBucket)
                        if dup == nil {
                                return nil
                        }

                        return dup.ForEach(func(k, v []byte) error {
                                subBucket := dup.NestedReadBucket(k)
                                if subBucket == nil {
                                        // We one bucket for each duplicate to
                                        // be found.
                                        return fmt.Errorf("non bucket element" +
                                                "in duplicate bucket")
                                }

                                p, err := fetchPaymentMigration9(subBucket)
                                if err != nil {
                                        return err
                                }

                                payments = append(payments, p)
                                return nil
                        })
                })
        }, func() {
                payments = nil
        })
        if err != nil {
                return nil, err
        }

        // Before returning, sort the payments by their sequence number.
        sort.Slice(payments, func(i, j int) bool {
                return payments[i].sequenceNum < payments[j].sequenceNum
        })

        return payments, nil
}

func fetchPaymentMigration9(bucket kvdb.RBucket) (*Payment, error) {
        var (
                err error
                p   = &Payment{}
        )

        seqBytes := bucket.Get(paymentSequenceKey)
        if seqBytes == nil {
                return nil, fmt.Errorf("sequence number not found")
        }

        p.sequenceNum = binary.BigEndian.Uint64(seqBytes)

        // Get the payment status.
        p.Status = fetchPaymentStatus(bucket)

        // Get the PaymentCreationInfo.
        b := bucket.Get(paymentCreationInfoKey)
        if b == nil {
                return nil, fmt.Errorf("creation info not found")
        }

        r := bytes.NewReader(b)
        p.Info, err = deserializePaymentCreationInfo(r)
        if err != nil {
                return nil, err

        }

        // Get the PaymentAttemptInfo. This can be unset.
        b = bucket.Get(paymentAttemptInfoKey)
        if b != nil {
                r = bytes.NewReader(b)
                p.Attempt, err = deserializePaymentAttemptInfoMigration9(r)
                if err != nil {
                        return nil, err
                }
        }

        // Get the payment preimage. This is only found for
        // completed payments.
        b = bucket.Get(paymentSettleInfoKey)
        if b != nil {
                var preimg lntypes.Preimage
                copy(preimg[:], b[:])
                p.PaymentPreimage = &preimg
        }

        // Get failure reason if available.
        b = bucket.Get(paymentFailInfoKey)
        if b != nil {
                reason := FailureReason(b[0])
                p.Failure = &reason
        }

        return p, nil
}

1	package migration_01_to_11
2
3	import (
4	"bytes"
5	"encoding/binary"
6	"fmt"
7	"io"
8	"sort"
9
10	lnwire "github.com/lightningnetwork/lnd/channeldb/migration/lnwire21"
11	"github.com/lightningnetwork/lnd/kvdb"
12	"github.com/lightningnetwork/lnd/lntypes"
13	)
14
15	var (
16	// paymentBucket is the name of the bucket within the database that
17	// stores all data related to payments.
18	//
19	// Within the payments bucket, each invoice is keyed by its invoice ID
20	// which is a monotonically increasing uint64. BoltDB's sequence
21	// feature is used for generating monotonically increasing id.
22	//
23	// NOTE: Deprecated. Kept around for migration purposes.
24	paymentBucket = []byte("payments")
25
26	// paymentStatusBucket is the name of the bucket within the database
27	// that stores the status of a payment indexed by the payment's
28	// preimage.
29	//
30	// NOTE: Deprecated. Kept around for migration purposes.
31	paymentStatusBucket = []byte("payment-status")
32	)
33
34	// outgoingPayment represents a successful payment between the daemon and a
35	// remote node. Details such as the total fee paid, and the time of the payment
36	// are stored.
37	//
38	// NOTE: Deprecated. Kept around for migration purposes.
39	type outgoingPayment struct {
40	Invoice
41
42	// Fee is the total fee paid for the payment in milli-satoshis.
43	Fee lnwire.MilliSatoshi
44
45	// TotalTimeLock is the total cumulative time-lock in the HTLC extended
46	// from the second-to-last hop to the destination.
47	TimeLockLength uint32
48
49	// Path encodes the path the payment took through the network. The path
50	// excludes the outgoing node and consists of the hex-encoded
51	// compressed public key of each of the nodes involved in the payment.
52	Path [][33]byte
53
54	// PaymentPreimage is the preImage of a successful payment. This is used
55	// to calculate the PaymentHash as well as serve as a proof of payment.
56	PaymentPreimage [32]byte
57	}
58
59	// addPayment saves a successful payment to the database. It is assumed that
60	// all payment are sent using unique payment hashes.
61	//
62	// NOTE: Deprecated. Kept around for migration purposes.
UNCOV 63	func (db DB) addPayment(payment outgoingPayment) error {	×
UNCOV 64	// Validate the field of the inner voice within the outgoing payment,	×
UNCOV 65	// these must also adhere to the same constraints as regular invoices.	×
UNCOV 66	if err := validateInvoice(&payment.Invoice); err != nil {	×
67	return err	×
68	}	×
69
70	// We first serialize the payment before starting the database
71	// transaction so we can avoid creating a DB payment in the case of a
72	// serialization error.
UNCOV 73	var b bytes.Buffer	×
UNCOV 74	if err := serializeOutgoingPayment(&b, payment); err != nil {	×
75	return err	×
76	}	×
UNCOV 77	paymentBytes := b.Bytes()	×
UNCOV 78		×
UNCOV 79	return kvdb.Update(db, func(tx kvdb.RwTx) error {	×
UNCOV 80	payments, err := tx.CreateTopLevelBucket(paymentBucket)	×
UNCOV 81	if err != nil {	×
82	return err	×
83	}	×
84
85	// Obtain the new unique sequence number for this payment.
UNCOV 86	paymentID, err := payments.NextSequence()	×
UNCOV 87	if err != nil {	×
88	return err	×
89	}	×
90
91	// We use BigEndian for keys as it orders keys in
92	// ascending order. This allows bucket scans to order payments
93	// in the order in which they were created.
UNCOV 94	paymentIDBytes := make([]byte, 8)	×
UNCOV 95	binary.BigEndian.PutUint64(paymentIDBytes, paymentID)	×
UNCOV 96		×
UNCOV 97	return payments.Put(paymentIDBytes, paymentBytes)	×
UNCOV 98	}, func() {})	×
99	}
100
101	// fetchAllPayments returns all outgoing payments in DB.
102	//
103	// NOTE: Deprecated. Kept around for migration purposes.
UNCOV 104	func (db DB) fetchAllPayments() ([]outgoingPayment, error) {	×
UNCOV 105	var payments []*outgoingPayment	×
UNCOV 106		×
UNCOV 107	err := kvdb.View(db, func(tx kvdb.RTx) error {	×
UNCOV 108	bucket := tx.ReadBucket(paymentBucket)	×
UNCOV 109	if bucket == nil {	×
110	return ErrNoPaymentsCreated	×
111	}	×
112
UNCOV 113	return bucket.ForEach(func(k, v []byte) error {	×
UNCOV 114	// If the value is nil, then we ignore it as it may be	×
UNCOV 115	// a sub-bucket.	×
UNCOV 116	if v == nil {	×
117	return nil	×
118	}	×
119
UNCOV 120	r := bytes.NewReader(v)	×
UNCOV 121	payment, err := deserializeOutgoingPayment(r)	×
UNCOV 122	if err != nil {	×
123	return err	×
124	}	×
125
UNCOV 126	payments = append(payments, payment)	×
UNCOV 127	return nil	×
128	})
UNCOV 129	}, func() {	×
UNCOV 130	payments = nil	×
UNCOV 131	})	×
UNCOV 132	if err != nil {	×
133	return nil, err	×
134	}	×
135
UNCOV 136	return payments, nil	×
137	}
138
139	// fetchPaymentStatus returns the payment status for outgoing payment.
140	// If status of the payment isn't found, it will default to "StatusUnknown".
141	//
142	// NOTE: Deprecated. Kept around for migration purposes.
UNCOV 143	func (db *DB) fetchPaymentStatus(paymentHash [32]byte) (PaymentStatus, error) {	×
UNCOV 144	var paymentStatus = StatusUnknown	×
UNCOV 145	err := kvdb.View(db, func(tx kvdb.RTx) error {	×
UNCOV 146	var err error	×
UNCOV 147	paymentStatus, err = fetchPaymentStatusTx(tx, paymentHash)	×
UNCOV 148	return err	×
UNCOV 149	}, func() {	×
UNCOV 150	paymentStatus = StatusUnknown	×
UNCOV 151	})	×
UNCOV 152	if err != nil {	×
153	return StatusUnknown, err	×
154	}	×
155
UNCOV 156	return paymentStatus, nil	×
157	}
158
159	// fetchPaymentStatusTx is a helper method that returns the payment status for
160	// outgoing payment. If status of the payment isn't found, it will default to
161	// "StatusUnknown". It accepts the boltdb transactions such that this method
162	// can be composed into other atomic operations.
163	//
164	// NOTE: Deprecated. Kept around for migration purposes.
UNCOV 165	func fetchPaymentStatusTx(tx kvdb.RTx, paymentHash [32]byte) (PaymentStatus, error) {	×
UNCOV 166	// The default status for all payments that aren't recorded in database.	×
UNCOV 167	var paymentStatus = StatusUnknown	×
UNCOV 168		×
UNCOV 169	bucket := tx.ReadBucket(paymentStatusBucket)	×
UNCOV 170	if bucket == nil {	×
UNCOV 171	return paymentStatus, nil	×
UNCOV 172	}	×
173
UNCOV 174	paymentStatusBytes := bucket.Get(paymentHash[:])	×
UNCOV 175	if paymentStatusBytes == nil {	×
UNCOV 176	return paymentStatus, nil	×
UNCOV 177	}	×
178
UNCOV 179	paymentStatus.FromBytes(paymentStatusBytes)	×
UNCOV 180		×
UNCOV 181	return paymentStatus, nil	×
182	}
183
UNCOV 184	func serializeOutgoingPayment(w io.Writer, p *outgoingPayment) error {	×
UNCOV 185	var scratch [8]byte	×
UNCOV 186		×
UNCOV 187	if err := serializeInvoiceLegacy(w, &p.Invoice); err != nil {	×
188	return err	×
189	}	×
190
UNCOV 191	byteOrder.PutUint64(scratch[:], uint64(p.Fee))	×
UNCOV 192	if _, err := w.Write(scratch[:]); err != nil {	×
193	return err	×
194	}	×
195
196	// First write out the length of the bytes to prefix the value.
UNCOV 197	pathLen := uint32(len(p.Path))	×
UNCOV 198	byteOrder.PutUint32(scratch[:4], pathLen)	×
UNCOV 199	if _, err := w.Write(scratch[:4]); err != nil {	×
200	return err	×
201	}	×
202
203	// Then with the path written, we write out the series of public keys
204	// involved in the path.
UNCOV 205	for _, hop := range p.Path {	×
UNCOV 206	if _, err := w.Write(hop[:]); err != nil {	×
207	return err	×
208	}	×
209	}
210
UNCOV 211	byteOrder.PutUint32(scratch[:4], p.TimeLockLength)	×
UNCOV 212	if _, err := w.Write(scratch[:4]); err != nil {	×
213	return err	×
214	}	×
215
UNCOV 216	if _, err := w.Write(p.PaymentPreimage[:]); err != nil {	×
217	return err	×
218	}	×
219
UNCOV 220	return nil	×
221	}
222
UNCOV 223	func deserializeOutgoingPayment(r io.Reader) (*outgoingPayment, error) {	×
UNCOV 224	var scratch [8]byte	×
UNCOV 225		×
UNCOV 226	p := &outgoingPayment{}	×
UNCOV 227		×
UNCOV 228	inv, err := deserializeInvoiceLegacy(r)	×
UNCOV 229	if err != nil {	×
230	return nil, err	×
231	}	×
UNCOV 232	p.Invoice = inv	×
UNCOV 233		×
UNCOV 234	if _, err := r.Read(scratch[:]); err != nil {	×
235	return nil, err	×
236	}	×
UNCOV 237	p.Fee = lnwire.MilliSatoshi(byteOrder.Uint64(scratch[:]))	×
UNCOV 238		×
UNCOV 239	if _, err = r.Read(scratch[:4]); err != nil {	×
240	return nil, err	×
241	}	×
UNCOV 242	pathLen := byteOrder.Uint32(scratch[:4])	×
UNCOV 243		×
UNCOV 244	path := make([][33]byte, pathLen)	×
UNCOV 245	for i := uint32(0); i < pathLen; i++ {	×
UNCOV 246	if _, err := r.Read(path[i][:]); err != nil {	×
247	return nil, err	×
248	}	×
249	}
UNCOV 250	p.Path = path	×
UNCOV 251		×
UNCOV 252	if _, err = r.Read(scratch[:4]); err != nil {	×
253	return nil, err	×
254	}	×
UNCOV 255	p.TimeLockLength = byteOrder.Uint32(scratch[:4])	×
UNCOV 256		×
UNCOV 257	if _, err := r.Read(p.PaymentPreimage[:]); err != nil {	×
258	return nil, err	×
259	}	×
260
UNCOV 261	return p, nil	×
262	}
263
264	// serializePaymentAttemptInfoMigration9 is the serializePaymentAttemptInfo
265	// version as existed when migration #9 was created. We keep this around, along
266	// with the methods below to ensure that clients that upgrade will use the
267	// correct version of this method.
UNCOV 268	func serializePaymentAttemptInfoMigration9(w io.Writer, a *PaymentAttemptInfo) error {	×
UNCOV 269	if err := WriteElements(w, a.PaymentID, a.SessionKey); err != nil {	×
270	return err	×
271	}	×
272
UNCOV 273	if err := serializeRouteMigration9(w, a.Route); err != nil {	×
274	return err	×
275	}	×
276
UNCOV 277	return nil	×
278	}
279
UNCOV 280	func serializeHopMigration9(w io.Writer, h *Hop) error {	×
UNCOV 281	if err := WriteElements(w,	×
UNCOV 282	h.PubKeyBytes[:], h.ChannelID, h.OutgoingTimeLock,	×
UNCOV 283	h.AmtToForward,	×
UNCOV 284	); err != nil {	×
285	return err	×
286	}	×
287
UNCOV 288	return nil	×
289	}
290
UNCOV 291	func serializeRouteMigration9(w io.Writer, r Route) error {	×
UNCOV 292	if err := WriteElements(w,	×
UNCOV 293	r.TotalTimeLock, r.TotalAmount, r.SourcePubKey[:],	×
UNCOV 294	); err != nil {	×
295	return err	×
296	}	×
297
UNCOV 298	if err := WriteElements(w, uint32(len(r.Hops))); err != nil {	×
299	return err	×
300	}	×
301
UNCOV 302	for _, h := range r.Hops {	×
UNCOV 303	if err := serializeHopMigration9(w, h); err != nil {	×
304	return err	×
305	}	×
306	}
307
UNCOV 308	return nil	×
309	}
310
UNCOV 311	func deserializePaymentAttemptInfoMigration9(r io.Reader) (*PaymentAttemptInfo, error) {	×
UNCOV 312	a := &PaymentAttemptInfo{}	×
UNCOV 313	err := ReadElements(r, &a.PaymentID, &a.SessionKey)	×
UNCOV 314	if err != nil {	×
315	return nil, err	×
316	}	×
UNCOV 317	a.Route, err = deserializeRouteMigration9(r)	×
UNCOV 318	if err != nil {	×
319	return nil, err	×
320	}	×
UNCOV 321	return a, nil	×
322	}
323
UNCOV 324	func deserializeRouteMigration9(r io.Reader) (Route, error) {	×
UNCOV 325	rt := Route{}	×
UNCOV 326	if err := ReadElements(r,	×
UNCOV 327	&rt.TotalTimeLock, &rt.TotalAmount,	×
UNCOV 328	); err != nil {	×
329	return rt, err	×
330	}	×
331
UNCOV 332	var pub []byte	×
UNCOV 333	if err := ReadElements(r, &pub); err != nil {	×
334	return rt, err	×
335	}	×
UNCOV 336	copy(rt.SourcePubKey[:], pub)	×
UNCOV 337		×
UNCOV 338	var numHops uint32	×
UNCOV 339	if err := ReadElements(r, &numHops); err != nil {	×
340	return rt, err	×
341	}	×
342
UNCOV 343	var hops []*Hop	×
UNCOV 344	for i := uint32(0); i < numHops; i++ {	×
UNCOV 345	hop, err := deserializeHopMigration9(r)	×
UNCOV 346	if err != nil {	×
347	return rt, err	×
348	}	×
UNCOV 349	hops = append(hops, hop)	×
350	}
UNCOV 351	rt.Hops = hops	×
UNCOV 352		×
UNCOV 353	return rt, nil	×
354	}
355
UNCOV 356	func deserializeHopMigration9(r io.Reader) (*Hop, error) {	×
UNCOV 357	h := &Hop{}	×
UNCOV 358		×
UNCOV 359	var pub []byte	×
UNCOV 360	if err := ReadElements(r, &pub); err != nil {	×
361	return nil, err	×
362	}	×
UNCOV 363	copy(h.PubKeyBytes[:], pub)	×
UNCOV 364		×
UNCOV 365	if err := ReadElements(r,	×
UNCOV 366	&h.ChannelID, &h.OutgoingTimeLock, &h.AmtToForward,	×
UNCOV 367	); err != nil {	×
368	return nil, err	×
369	}	×
370
UNCOV 371	return h, nil	×
372	}
373
374	// fetchPaymentsMigration9 returns all sent payments found in the DB using the
375	// payment attempt info format that was present as of migration #9. We need
376	// this as otherwise, the current FetchPayments version will use the latest
377	// decoding format. Note that we only need this for the
378	// TestOutgoingPaymentsMigration migration test case.
UNCOV 379	func (db DB) fetchPaymentsMigration9() ([]Payment, error) {	×
UNCOV 380	var payments []*Payment	×
UNCOV 381		×
UNCOV 382	err := kvdb.View(db, func(tx kvdb.RTx) error {	×
UNCOV 383	paymentsBucket := tx.ReadBucket(paymentsRootBucket)	×
UNCOV 384	if paymentsBucket == nil {	×
385	return nil	×
386	}	×
387
UNCOV 388	return paymentsBucket.ForEach(func(k, v []byte) error {	×
UNCOV 389	bucket := paymentsBucket.NestedReadBucket(k)	×
UNCOV 390	if bucket == nil {	×
391	// We only expect sub-buckets to be found in	×
392	// this top-level bucket.	×
393	return fmt.Errorf("non bucket element in " +	×
394	"payments bucket")	×
395	}	×
396
UNCOV 397	p, err := fetchPaymentMigration9(bucket)	×
UNCOV 398	if err != nil {	×
399	return err	×
400	}	×
401
UNCOV 402	payments = append(payments, p)	×
UNCOV 403		×
UNCOV 404	// For older versions of lnd, duplicate payments to a	×
UNCOV 405	// payment has was possible. These will be found in a	×
UNCOV 406	// sub-bucket indexed by their sequence number if	×
UNCOV 407	// available.	×
UNCOV 408	dup := bucket.NestedReadBucket(paymentDuplicateBucket)	×
UNCOV 409	if dup == nil {	×
UNCOV 410	return nil	×
UNCOV 411	}	×
412
UNCOV 413	return dup.ForEach(func(k, v []byte) error {	×
UNCOV 414	subBucket := dup.NestedReadBucket(k)	×
UNCOV 415	if subBucket == nil {	×
416	// We one bucket for each duplicate to	×
417	// be found.	×
418	return fmt.Errorf("non bucket element" +	×
419	"in duplicate bucket")	×
420	}	×
421
UNCOV 422	p, err := fetchPaymentMigration9(subBucket)	×
UNCOV 423	if err != nil {	×
424	return err	×
425	}	×
426
UNCOV 427	payments = append(payments, p)	×
UNCOV 428	return nil	×
429	})
430	})
UNCOV 431	}, func() {	×
UNCOV 432	payments = nil	×
UNCOV 433	})	×
UNCOV 434	if err != nil {	×
435	return nil, err	×
436	}	×
437
438	// Before returning, sort the payments by their sequence number.
UNCOV 439	sort.Slice(payments, func(i, j int) bool {	×
UNCOV 440	return payments[i].sequenceNum < payments[j].sequenceNum	×
UNCOV 441	})	×
442
UNCOV 443	return payments, nil	×
444	}
445
UNCOV 446	func fetchPaymentMigration9(bucket kvdb.RBucket) (*Payment, error) {	×
UNCOV 447	var (	×
UNCOV 448	err error	×
UNCOV 449	p = &Payment{}	×
UNCOV 450	)	×
UNCOV 451		×
UNCOV 452	seqBytes := bucket.Get(paymentSequenceKey)	×
UNCOV 453	if seqBytes == nil {	×
454	return nil, fmt.Errorf("sequence number not found")	×
455	}	×
456
UNCOV 457	p.sequenceNum = binary.BigEndian.Uint64(seqBytes)	×
UNCOV 458		×
UNCOV 459	// Get the payment status.	×
UNCOV 460	p.Status = fetchPaymentStatus(bucket)	×
UNCOV 461		×
UNCOV 462	// Get the PaymentCreationInfo.	×
UNCOV 463	b := bucket.Get(paymentCreationInfoKey)	×
UNCOV 464	if b == nil {	×
465	return nil, fmt.Errorf("creation info not found")	×
466	}	×
467
UNCOV 468	r := bytes.NewReader(b)	×
UNCOV 469	p.Info, err = deserializePaymentCreationInfo(r)	×
UNCOV 470	if err != nil {	×
471	return nil, err	×
472		×
473	}	×
474
475	// Get the PaymentAttemptInfo. This can be unset.
UNCOV 476	b = bucket.Get(paymentAttemptInfoKey)	×
UNCOV 477	if b != nil {	×
UNCOV 478	r = bytes.NewReader(b)	×
UNCOV 479	p.Attempt, err = deserializePaymentAttemptInfoMigration9(r)	×
UNCOV 480	if err != nil {	×
481	return nil, err	×
482	}	×
483	}
484
485	// Get the payment preimage. This is only found for
486	// completed payments.
UNCOV 487	b = bucket.Get(paymentSettleInfoKey)	×
UNCOV 488	if b != nil {	×
UNCOV 489	var preimg lntypes.Preimage	×
UNCOV 490	copy(preimg[:], b[:])	×
UNCOV 491	p.PaymentPreimage = &preimg	×
UNCOV 492	}	×
493
494	// Get failure reason if available.
UNCOV 495	b = bucket.Get(paymentFailInfoKey)	×
UNCOV 496	if b != nil {	×
497	reason := FailureReason(b[0])	×
498	p.Failure = &reason	×
499	}	×
500
UNCOV 501	return p, nil	×
502	}

lightningnetwork / lnd / 13211764208

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