mirror of https://github.com/BTCPrivate/lnd.git
249 lines
5.3 KiB
Go
249 lines
5.3 KiB
Go
package channeldb
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"github.com/boltdb/bolt"
|
|
"github.com/roasbeef/btcd/wire"
|
|
"github.com/roasbeef/btcutil"
|
|
"io"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
// invoiceBucket 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 sequence feature is used for generating
|
|
// monotonically increasing id.
|
|
paymentBucket = []byte("payments")
|
|
)
|
|
|
|
// OutgoingPayment represents payment from given node.
|
|
type OutgoingPayment struct {
|
|
Invoice
|
|
|
|
// Total fee paid.
|
|
Fee btcutil.Amount
|
|
|
|
// Path including starting and ending nodes.
|
|
Path [][33]byte
|
|
|
|
// Timelock length.
|
|
TimeLockLength uint32
|
|
|
|
// RHash value used for payment.
|
|
// We need RHash because we start payment knowing only RHash
|
|
RHash [32]byte
|
|
|
|
// Timestamp is time when payment was created.
|
|
Timestamp time.Time
|
|
}
|
|
|
|
// AddPayment adds payment to DB.
|
|
// There is no checking that payment with the same hash already exist.
|
|
func (db *DB) AddPayment(p *OutgoingPayment) error {
|
|
err := validateInvoice(&p.Invoice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// We serialize before writing to database
|
|
// so no db access in the case of serialization errors
|
|
b := new(bytes.Buffer)
|
|
err = serializeOutgoingPayment(b, p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
paymentBytes := b.Bytes()
|
|
return db.Update(func(tx *bolt.Tx) error {
|
|
payments, err := tx.CreateBucketIfNotExists(paymentBucket)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
paymentId, err := payments.NextSequence()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// We use BigEndian for keys because
|
|
// it orders keys in ascending order
|
|
paymentIdBytes := make([]byte, 8)
|
|
binary.BigEndian.PutUint64(paymentIdBytes, paymentId)
|
|
err = payments.Put(paymentIdBytes, paymentBytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// FetchAllPayments returns all outgoing payments in DB.
|
|
func (db *DB) FetchAllPayments() ([]*OutgoingPayment, error) {
|
|
var payments []*OutgoingPayment
|
|
err := db.View(func(tx *bolt.Tx) error {
|
|
bucket := tx.Bucket(paymentBucket)
|
|
if bucket == nil {
|
|
return ErrNoPaymentsCreated
|
|
}
|
|
err := bucket.ForEach(func(k, v []byte) error {
|
|
// Value can be nil if it is a sub-backet
|
|
// so simply ignore it.
|
|
if v == nil {
|
|
return nil
|
|
}
|
|
r := bytes.NewReader(v)
|
|
payment, err := deserializeOutgoingPayment(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
payments = append(payments, payment)
|
|
return nil
|
|
})
|
|
return err
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return payments, nil
|
|
}
|
|
|
|
// DeleteAllPayments deletes all payments from DB.
|
|
// If payments bucket does not exist it will create
|
|
// new bucket without error.
|
|
func (db *DB) DeleteAllPayments() error {
|
|
return db.Update(func(tx *bolt.Tx) error {
|
|
err := tx.DeleteBucket(paymentBucket)
|
|
if err != nil && err != bolt.ErrBucketNotFound {
|
|
return err
|
|
}
|
|
|
|
_, err = tx.CreateBucket(paymentBucket)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return err
|
|
})
|
|
}
|
|
|
|
func serializeOutgoingPayment(w io.Writer, p *OutgoingPayment) error {
|
|
err := serializeInvoice(w, &p.Invoice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Serialize fee.
|
|
feeBytes := make([]byte, 8)
|
|
byteOrder.PutUint64(feeBytes, uint64(p.Fee))
|
|
_, err = w.Write(feeBytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Serialize path.
|
|
pathLen := uint32(len(p.Path))
|
|
pathLenBytes := make([]byte, 4)
|
|
// Write length of the path
|
|
byteOrder.PutUint32(pathLenBytes, pathLen)
|
|
_, err = w.Write(pathLenBytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Serialize each element of the path
|
|
for i := uint32(0); i < pathLen; i++ {
|
|
_, err := w.Write(p.Path[i][:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Serialize TimeLockLength
|
|
timeLockLengthBytes := make([]byte, 4)
|
|
byteOrder.PutUint32(timeLockLengthBytes, p.TimeLockLength)
|
|
_, err = w.Write(timeLockLengthBytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Serialize RHash
|
|
_, err = w.Write(p.RHash[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Serialize Timestamp.
|
|
tBytes, err := p.Timestamp.MarshalBinary()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = wire.WriteVarBytes(w, 0, tBytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func deserializeOutgoingPayment(r io.Reader) (*OutgoingPayment, error) {
|
|
p := &OutgoingPayment{}
|
|
|
|
// Deserialize invoice
|
|
inv, err := deserializeInvoice(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p.Invoice = *inv
|
|
|
|
// Deserialize fee
|
|
feeBytes := make([]byte, 8)
|
|
_, err = r.Read(feeBytes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p.Fee = btcutil.Amount(byteOrder.Uint64(feeBytes))
|
|
|
|
// Deserialize path
|
|
pathLenBytes := make([]byte, 4)
|
|
_, err = r.Read(pathLenBytes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pathLen := byteOrder.Uint32(pathLenBytes)
|
|
path := make([][33]byte, pathLen)
|
|
for i := uint32(0); i < pathLen; i++ {
|
|
_, err := r.Read(path[i][:])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
p.Path = path
|
|
|
|
// Deserialize TimeLockLength
|
|
timeLockLengthBytes := make([]byte, 4)
|
|
_, err = r.Read(timeLockLengthBytes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p.TimeLockLength = byteOrder.Uint32(timeLockLengthBytes)
|
|
|
|
// Deserialize RHash
|
|
_, err = r.Read(p.RHash[:])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Deserialize Timestamp
|
|
tBytes, err := wire.ReadVarBytes(r, 0, 100,
|
|
"OutgoingPayment.Timestamp")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = p.Timestamp.UnmarshalBinary(tBytes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return p, nil
|
|
}
|