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

66.22

/graph/db/addr.go

package graphdb

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

        "github.com/lightningnetwork/lnd/tor"
)

// addressType specifies the network protocol and version that should be used
// when connecting to a node at a particular address.
type addressType uint8

const (
        // tcp4Addr denotes an IPv4 TCP address.
        tcp4Addr addressType = 0

        // tcp6Addr denotes an IPv6 TCP address.
        tcp6Addr addressType = 1

        // v2OnionAddr denotes a version 2 Tor onion service address.
        v2OnionAddr addressType = 2

        // v3OnionAddr denotes a version 3 Tor (prop224) onion service address.
        v3OnionAddr addressType = 3
)

// encodeTCPAddr serializes a TCP address into its compact raw bytes
// representation.
func encodeTCPAddr(w io.Writer, addr *net.TCPAddr) error {
        var (
                addrType byte
                ip       []byte
        )

        if addr.IP.To4() != nil {
                addrType = byte(tcp4Addr)
                ip = addr.IP.To4()
        } else {
                addrType = byte(tcp6Addr)
                ip = addr.IP.To16()
        }

        if ip == nil {
                return fmt.Errorf("unable to encode IP %v", addr.IP)
        }

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

        if _, err := w.Write(ip); err != nil {
                return err
        }

        var port [2]byte
        byteOrder.PutUint16(port[:], uint16(addr.Port))
        if _, err := w.Write(port[:]); err != nil {
                return err
        }

        return nil
}

// encodeOnionAddr serializes an onion address into its compact raw bytes
// representation.
func encodeOnionAddr(w io.Writer, addr *tor.OnionAddr) error {
        var suffixIndex int
        hostLen := len(addr.OnionService)
        switch hostLen {
        case tor.V2Len:
                if _, err := w.Write([]byte{byte(v2OnionAddr)}); err != nil {
                        return err
                }
                suffixIndex = tor.V2Len - tor.OnionSuffixLen
        case tor.V3Len:
                if _, err := w.Write([]byte{byte(v3OnionAddr)}); err != nil {
                        return err
                }
                suffixIndex = tor.V3Len - tor.OnionSuffixLen
        default:
                return errors.New("unknown onion service length")
        }

        suffix := addr.OnionService[suffixIndex:]
        if suffix != tor.OnionSuffix {
                return fmt.Errorf("invalid suffix \"%v\"", suffix)
        }

        host, err := tor.Base32Encoding.DecodeString(
                addr.OnionService[:suffixIndex],
        )
        if err != nil {
                return err
        }

        // Sanity check the decoded length.
        switch {
        case hostLen == tor.V2Len && len(host) != tor.V2DecodedLen:
                return fmt.Errorf("onion service %v decoded to invalid host %x",
                        addr.OnionService, host)

        case hostLen == tor.V3Len && len(host) != tor.V3DecodedLen:
                return fmt.Errorf("onion service %v decoded to invalid host %x",
                        addr.OnionService, host)
        }

        if _, err := w.Write(host); err != nil {
                return err
        }

        var port [2]byte
        byteOrder.PutUint16(port[:], uint16(addr.Port))
        if _, err := w.Write(port[:]); err != nil {
                return err
        }

        return nil
}

// DeserializeAddr reads the serialized raw representation of an address and
// deserializes it into the actual address. This allows us to avoid address
// resolution within the channeldb package.
func DeserializeAddr(r io.Reader) (net.Addr, error) {
        var addrType [1]byte
        if _, err := r.Read(addrType[:]); err != nil {
                return nil, err
        }

        var address net.Addr
        switch addressType(addrType[0]) {
        case tcp4Addr:
                var ip [4]byte
                if _, err := r.Read(ip[:]); err != nil {
                        return nil, err
                }

                var port [2]byte
                if _, err := r.Read(port[:]); err != nil {
                        return nil, err
                }

                address = &net.TCPAddr{
                        IP:   net.IP(ip[:]),
                        Port: int(binary.BigEndian.Uint16(port[:])),
                }
        case tcp6Addr:
                var ip [16]byte
                if _, err := r.Read(ip[:]); err != nil {
                        return nil, err
                }

                var port [2]byte
                if _, err := r.Read(port[:]); err != nil {
                        return nil, err
                }

                address = &net.TCPAddr{
                        IP:   net.IP(ip[:]),
                        Port: int(binary.BigEndian.Uint16(port[:])),
                }
        case v2OnionAddr:
                var h [tor.V2DecodedLen]byte
                if _, err := r.Read(h[:]); err != nil {
                        return nil, err
                }

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

                onionService := tor.Base32Encoding.EncodeToString(h[:])
                onionService += tor.OnionSuffix
                port := int(binary.BigEndian.Uint16(p[:]))

                address = &tor.OnionAddr{
                        OnionService: onionService,
                        Port:         port,
                }
        case v3OnionAddr:
                var h [tor.V3DecodedLen]byte
                if _, err := r.Read(h[:]); err != nil {
                        return nil, err
                }

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

                onionService := tor.Base32Encoding.EncodeToString(h[:])
                onionService += tor.OnionSuffix
                port := int(binary.BigEndian.Uint16(p[:]))

                address = &tor.OnionAddr{
                        OnionService: onionService,
                        Port:         port,
                }
        default:
                return nil, ErrUnknownAddressType
        }

        return address, nil
}

// SerializeAddr serializes an address into its raw bytes representation so that
// it can be deserialized without requiring address resolution.
func SerializeAddr(w io.Writer, address net.Addr) error {
        switch addr := address.(type) {
        case *net.TCPAddr:
                return encodeTCPAddr(w, addr)
        case *tor.OnionAddr:
                return encodeOnionAddr(w, addr)
        default:
                return ErrUnknownAddressType
        }
}

1	package graphdb
2
3	import (
4	"encoding/binary"
5	"errors"
6	"fmt"
7	"io"
8	"net"
9
10	"github.com/lightningnetwork/lnd/tor"
11	)
12
13	// addressType specifies the network protocol and version that should be used
14	// when connecting to a node at a particular address.
15	type addressType uint8
16
17	const (
18	// tcp4Addr denotes an IPv4 TCP address.
19	tcp4Addr addressType = 0
20
21	// tcp6Addr denotes an IPv6 TCP address.
22	tcp6Addr addressType = 1
23
24	// v2OnionAddr denotes a version 2 Tor onion service address.
25	v2OnionAddr addressType = 2
26
27	// v3OnionAddr denotes a version 3 Tor (prop224) onion service address.
28	v3OnionAddr addressType = 3
29	)
30
31	// encodeTCPAddr serializes a TCP address into its compact raw bytes
32	// representation.
33	func encodeTCPAddr(w io.Writer, addr *net.TCPAddr) error {	3✔
34	var (	3✔
35	addrType byte	3✔
36	ip []byte	3✔
37	)	3✔
38		3✔
39	if addr.IP.To4() != nil {	6✔
40	addrType = byte(tcp4Addr)	3✔
41	ip = addr.IP.To4()	3✔
42	} else {	6✔
43	addrType = byte(tcp6Addr)	3✔
44	ip = addr.IP.To16()	3✔
45	}	3✔
46
47	if ip == nil {	3✔
48	return fmt.Errorf("unable to encode IP %v", addr.IP)	×
49	}	×
50
51	if _, err := w.Write([]byte{addrType}); err != nil {	3✔
52	return err	×
53	}	×
54
55	if _, err := w.Write(ip); err != nil {	3✔
56	return err	×
57	}	×
58
59	var port [2]byte	3✔
60	byteOrder.PutUint16(port[:], uint16(addr.Port))	3✔
61	if _, err := w.Write(port[:]); err != nil {	3✔
62	return err	×
63	}	×
64
65	return nil	3✔
66	}
67
68	// encodeOnionAddr serializes an onion address into its compact raw bytes
69	// representation.
70	func encodeOnionAddr(w io.Writer, addr *tor.OnionAddr) error {	3✔
71	var suffixIndex int	3✔
72	hostLen := len(addr.OnionService)	3✔
73	switch hostLen {	3✔
74	case tor.V2Len:	3✔
75	if _, err := w.Write([]byte{byte(v2OnionAddr)}); err != nil {	3✔
76	return err	×
77	}	×
78	suffixIndex = tor.V2Len - tor.OnionSuffixLen	3✔
79	case tor.V3Len:	3✔
80	if _, err := w.Write([]byte{byte(v3OnionAddr)}); err != nil {	3✔
81	return err	×
82	}	×
83	suffixIndex = tor.V3Len - tor.OnionSuffixLen	3✔
84	default:	×
85	return errors.New("unknown onion service length")	×
86	}
87
88	suffix := addr.OnionService[suffixIndex:]	3✔
89	if suffix != tor.OnionSuffix {	3✔
90	return fmt.Errorf("invalid suffix \"%v\"", suffix)	×
91	}	×
92
93	host, err := tor.Base32Encoding.DecodeString(	3✔
94	addr.OnionService[:suffixIndex],	3✔
95	)	3✔
96	if err != nil {	3✔
97	return err	×
98	}	×
99
100	// Sanity check the decoded length.
101	switch {	3✔
102	case hostLen == tor.V2Len && len(host) != tor.V2DecodedLen:	×
103	return fmt.Errorf("onion service %v decoded to invalid host %x",	×
104	addr.OnionService, host)	×
105
106	case hostLen == tor.V3Len && len(host) != tor.V3DecodedLen:	×
107	return fmt.Errorf("onion service %v decoded to invalid host %x",	×
108	addr.OnionService, host)	×
109	}
110
111	if _, err := w.Write(host); err != nil {	3✔
112	return err	×
113	}	×
114
115	var port [2]byte	3✔
116	byteOrder.PutUint16(port[:], uint16(addr.Port))	3✔
117	if _, err := w.Write(port[:]); err != nil {	3✔
118	return err	×
119	}	×
120
121	return nil	3✔
122	}
123
124	// DeserializeAddr reads the serialized raw representation of an address and
125	// deserializes it into the actual address. This allows us to avoid address
126	// resolution within the channeldb package.
127	func DeserializeAddr(r io.Reader) (net.Addr, error) {	3✔
128	var addrType [1]byte	3✔
129	if _, err := r.Read(addrType[:]); err != nil {	3✔
130	return nil, err	×
131	}	×
132
133	var address net.Addr	3✔
134	switch addressType(addrType[0]) {	3✔
135	case tcp4Addr:	3✔
136	var ip [4]byte	3✔
137	if _, err := r.Read(ip[:]); err != nil {	3✔
138	return nil, err	×
139	}	×
140
141	var port [2]byte	3✔
142	if _, err := r.Read(port[:]); err != nil {	3✔
143	return nil, err	×
144	}	×
145
146	address = &net.TCPAddr{	3✔
147	IP: net.IP(ip[:]),	3✔
148	Port: int(binary.BigEndian.Uint16(port[:])),	3✔
149	}	3✔
150	case tcp6Addr:	3✔
151	var ip [16]byte	3✔
152	if _, err := r.Read(ip[:]); err != nil {	3✔
153	return nil, err	×
154	}	×
155
156	var port [2]byte	3✔
157	if _, err := r.Read(port[:]); err != nil {	3✔
158	return nil, err	×
159	}	×
160
161	address = &net.TCPAddr{	3✔
162	IP: net.IP(ip[:]),	3✔
163	Port: int(binary.BigEndian.Uint16(port[:])),	3✔
164	}	3✔
165	case v2OnionAddr:	3✔
166	var h [tor.V2DecodedLen]byte	3✔
167	if _, err := r.Read(h[:]); err != nil {	3✔
168	return nil, err	×
169	}	×
170
171	var p [2]byte	3✔
172	if _, err := r.Read(p[:]); err != nil {	3✔
173	return nil, err	×
174	}	×
175
176	onionService := tor.Base32Encoding.EncodeToString(h[:])	3✔
177	onionService += tor.OnionSuffix	3✔
178	port := int(binary.BigEndian.Uint16(p[:]))	3✔
179		3✔
180	address = &tor.OnionAddr{	3✔
181	OnionService: onionService,	3✔
182	Port: port,	3✔
183	}	3✔
184	case v3OnionAddr:	3✔
185	var h [tor.V3DecodedLen]byte	3✔
186	if _, err := r.Read(h[:]); err != nil {	3✔
187	return nil, err	×
188	}	×
189
190	var p [2]byte	3✔
191	if _, err := r.Read(p[:]); err != nil {	3✔
192	return nil, err	×
193	}	×
194
195	onionService := tor.Base32Encoding.EncodeToString(h[:])	3✔
196	onionService += tor.OnionSuffix	3✔
197	port := int(binary.BigEndian.Uint16(p[:]))	3✔
198		3✔
199	address = &tor.OnionAddr{	3✔
200	OnionService: onionService,	3✔
201	Port: port,	3✔
202	}	3✔
203	default:	×
204	return nil, ErrUnknownAddressType	×
205	}
206
207	return address, nil	3✔
208	}
209
210	// SerializeAddr serializes an address into its raw bytes representation so that
211	// it can be deserialized without requiring address resolution.
212	func SerializeAddr(w io.Writer, address net.Addr) error {	3✔
213	switch addr := address.(type) {	3✔
214	case *net.TCPAddr:	3✔
215	return encodeTCPAddr(w, addr)	3✔
216	case *tor.OnionAddr:	3✔
217	return encodeOnionAddr(w, addr)	3✔
218	default:	×
219	return ErrUnknownAddressType	×
220	}
221	}

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