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/migration32/codec.go

package migration32

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

        "github.com/btcsuite/btcd/wire"
        lnwire "github.com/lightningnetwork/lnd/channeldb/migration/lnwire21"
)

var (
        // Big endian is the preferred byte order, due to cursor scans over
        // integer keys iterating in order.
        byteOrder = binary.BigEndian
)

// ReadElement is a one-stop utility function to deserialize any datastructure
// encoded using the serialization format of the database.
func ReadElement(r io.Reader, element interface{}) error {
        switch e := element.(type) {
        case *uint32:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *lnwire.MilliSatoshi:
                var a uint64
                if err := binary.Read(r, byteOrder, &a); err != nil {
                        return err
                }

                *e = lnwire.MilliSatoshi(a)

        case *[]byte:
                bytes, err := wire.ReadVarBytes(r, 0, 66000, "[]byte")
                if err != nil {
                        return err
                }

                *e = bytes

        case *int64, *uint64:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *bool:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        case *int32:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        default:
                return UnknownElementType{"ReadElement", e}
        }

        return nil
}

// ReadElements deserializes a variable number of elements into the passed
// io.Reader, with each element being deserialized according to the ReadElement
// function.
func ReadElements(r io.Reader, elements ...interface{}) error {
        for _, element := range elements {
                err := ReadElement(r, element)
                if err != nil {
                        return err
                }
        }

        return nil
}

// UnknownElementType is an error returned when the codec is unable to encode or
// decode a particular type.
type UnknownElementType struct {
        method  string
        element interface{}
}

// Error returns the name of the method that encountered the error, as well as
// the type that was unsupported.
func (e UnknownElementType) Error() string {
        return fmt.Sprintf("Unknown type in %s: %T", e.method, e.element)
}

// WriteElement is a one-stop shop to write the big endian representation of
// any element which is to be serialized for storage on disk. The passed
// io.Writer should be backed by an appropriately sized byte slice, or be able
// to dynamically expand to accommodate additional data.
func WriteElement(w io.Writer, element interface{}) error {
        switch e := element.(type) {
        case int64, uint64:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case uint32:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case int32:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case bool:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        case lnwire.MilliSatoshi:
                if err := binary.Write(w, byteOrder, uint64(e)); err != nil {
                        return err
                }

        case []byte:
                if err := wire.WriteVarBytes(w, 0, e); err != nil {
                        return err
                }

        default:
                return UnknownElementType{"WriteElement", e}
        }

        return nil
}

// WriteElements is writes each element in the elements slice to the passed
// io.Writer using WriteElement.
func WriteElements(w io.Writer, elements ...interface{}) error {
        for _, element := range elements {
                err := WriteElement(w, element)
                if err != nil {
                        return err
                }
        }

        return nil
}

1	package migration32
2
3	import (
4	"encoding/binary"
5	"fmt"
6	"io"
7
8	"github.com/btcsuite/btcd/wire"
9	lnwire "github.com/lightningnetwork/lnd/channeldb/migration/lnwire21"
10	)
11
12	var (
13	// Big endian is the preferred byte order, due to cursor scans over
14	// integer keys iterating in order.
15	byteOrder = binary.BigEndian
16	)
17
18	// ReadElement is a one-stop utility function to deserialize any datastructure
19	// encoded using the serialization format of the database.
20	func ReadElement(r io.Reader, element interface{}) error {	×
21	switch e := element.(type) {	×
22	case *uint32:	×
23	if err := binary.Read(r, byteOrder, e); err != nil {	×
24	return err	×
25	}	×
26
27	case *lnwire.MilliSatoshi:	×
28	var a uint64	×
29	if err := binary.Read(r, byteOrder, &a); err != nil {	×
30	return err	×
31	}	×
32
33	*e = lnwire.MilliSatoshi(a)	×
34
35	case *[]byte:	×
36	bytes, err := wire.ReadVarBytes(r, 0, 66000, "[]byte")	×
37	if err != nil {	×
38	return err	×
39	}	×
40
41	*e = bytes	×
42
43	case int64, uint64:	×
44	if err := binary.Read(r, byteOrder, e); err != nil {	×
45	return err	×
46	}	×
47
48	case *bool:	×
49	if err := binary.Read(r, byteOrder, e); err != nil {	×
50	return err	×
51	}	×
52
53	case *int32:	×
54	if err := binary.Read(r, byteOrder, e); err != nil {	×
55	return err	×
56	}	×
57
58	default:	×
59	return UnknownElementType{"ReadElement", e}	×
60	}
61
62	return nil	×
63	}
64
65	// ReadElements deserializes a variable number of elements into the passed
66	// io.Reader, with each element being deserialized according to the ReadElement
67	// function.
68	func ReadElements(r io.Reader, elements ...interface{}) error {	×
69	for _, element := range elements {	×
70	err := ReadElement(r, element)	×
71	if err != nil {	×
72	return err	×
73	}	×
74	}
75
76	return nil	×
77	}
78
79	// UnknownElementType is an error returned when the codec is unable to encode or
80	// decode a particular type.
81	type UnknownElementType struct {
82	method string
83	element interface{}
84	}
85
86	// Error returns the name of the method that encountered the error, as well as
87	// the type that was unsupported.
88	func (e UnknownElementType) Error() string {	×
89	return fmt.Sprintf("Unknown type in %s: %T", e.method, e.element)	×
90	}	×
91
92	// WriteElement is a one-stop shop to write the big endian representation of
93	// any element which is to be serialized for storage on disk. The passed
94	// io.Writer should be backed by an appropriately sized byte slice, or be able
95	// to dynamically expand to accommodate additional data.
96	func WriteElement(w io.Writer, element interface{}) error {	×
97	switch e := element.(type) {	×
98	case int64, uint64:	×
99	if err := binary.Write(w, byteOrder, e); err != nil {	×
100	return err	×
101	}	×
102
103	case uint32:	×
104	if err := binary.Write(w, byteOrder, e); err != nil {	×
105	return err	×
106	}	×
107
108	case int32:	×
109	if err := binary.Write(w, byteOrder, e); err != nil {	×
110	return err	×
111	}	×
112
113	case bool:	×
114	if err := binary.Write(w, byteOrder, e); err != nil {	×
115	return err	×
116	}	×
117
118	case lnwire.MilliSatoshi:	×
119	if err := binary.Write(w, byteOrder, uint64(e)); err != nil {	×
120	return err	×
121	}	×
122
123	case []byte:	×
124	if err := wire.WriteVarBytes(w, 0, e); err != nil {	×
125	return err	×
126	}	×
127
128	default:	×
129	return UnknownElementType{"WriteElement", e}	×
130	}
131
132	return nil	×
133	}
134
135	// WriteElements is writes each element in the elements slice to the passed
136	// io.Writer using WriteElement.
137	func WriteElements(w io.Writer, elements ...interface{}) error {	×
138	for _, element := range elements {	×
139	err := WriteElement(w, element)	×
140	if err != nil {	×
141	return err	×
142	}	×
143	}
144
145	return nil	×
146	}

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