15736109134

Committed 18 Jun 2025 02:46PM UTC coverage: 58.197% (-10.1%) from 68.248%

Build # 15736109134

Build Type

Pull #9752

github

Committed by

web-flow

Commit Message

Merge d2634a68c into 31c74f20f

Pull Request Pull Request #9752: routerrpc: reject payment to invoice that don't have payment secret or blinded paths

Run Details

6 of 13 new or added lines in 2 files covered. (46.15%)

28331 existing lines in 455 files now uncovered.

97860 of 168153 relevant lines covered (58.2%)

1.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.67

/watchtower/wtdb/tower.go

package wtdb

import (
        "encoding/hex"
        "fmt"
        "io"
        "net"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/lightningnetwork/lnd/tlv"
)

// TowerStatus represents the state of the tower as set by the tower client.
type TowerStatus uint8

const (
        // TowerStatusActive is the default state of the tower, and it indicates
        // that this tower should be used to attempt session creation.
        TowerStatusActive TowerStatus = 0

        // TowerStatusInactive indicates that the tower should not be used to
        // attempt session creation.
        TowerStatusInactive TowerStatus = 1
)

const (
        // TowerStatusTLVType is the TLV type number that will be used to store
        // the tower's status.
        TowerStatusTLVType = tlv.Type(0)
)

// TowerID is a unique 64-bit identifier allocated to each unique watchtower.
// This allows the client to conserve on-disk space by not needing to always
// reference towers by their pubkey.
type TowerID uint64

// TowerIDFromBytes constructs a TowerID from the provided byte slice. The
// argument must have at least 8 bytes, and should contain the TowerID in
// big-endian byte order.
func TowerIDFromBytes(towerIDBytes []byte) TowerID {
        return TowerID(byteOrder.Uint64(towerIDBytes))
}

// Bytes encodes a TowerID into an 8-byte slice in big-endian byte order.
func (id TowerID) Bytes() []byte {
        var buf [8]byte
        byteOrder.PutUint64(buf[:], uint64(id))
        return buf[:]
}

// Tower holds the necessary components required to connect to a remote tower.
// Communication is handled by brontide, and requires both a public key and an
// address.
type Tower struct {
        // ID is a unique ID for this record assigned by the database.
        ID TowerID

        // IdentityKey is the public key of the remote node, used to
        // authenticate the brontide transport.
        IdentityKey *btcec.PublicKey

        // Addresses is a list of possible addresses to reach the tower.
        Addresses []net.Addr

        // Status is the status of this tower as set by the client.
        Status TowerStatus
}

// AddAddress adds the given address to the tower's in-memory list of addresses.
// If the address's string is already present, the Tower will be left
// unmodified. Otherwise, the address is prepended to the beginning of the
// Tower's addresses, on the assumption that it is fresher than the others.
//
// NOTE: This method is NOT safe for concurrent use.
func (t *Tower) AddAddress(addr net.Addr) {
        // Ensure we don't add a duplicate address.
        addrStr := addr.String()
        for _, existingAddr := range t.Addresses {
                if existingAddr.String() == addrStr {
                        return
                }
        }

        // Add this address to the front of the list, on the assumption that it
        // is a fresher address and will be tried first.
        t.Addresses = append([]net.Addr{addr}, t.Addresses...)
}

// RemoveAddress removes the given address from the tower's in-memory list of
// addresses. If the address doesn't exist, then this will act as a NOP.
func (t *Tower) RemoveAddress(addr net.Addr) {
        addrStr := addr.String()
        for i, address := range t.Addresses {
                if address.String() != addrStr {
                        continue
                }
                t.Addresses = append(t.Addresses[:i], t.Addresses[i+1:]...)
                return
        }
}

// String returns a user-friendly identifier of the tower.
func (t *Tower) String() string {
        pubKey := hex.EncodeToString(t.IdentityKey.SerializeCompressed())
        if len(t.Addresses) == 0 {
                return pubKey
        }
        return fmt.Sprintf("%v@%v", pubKey, t.Addresses[0])
}

// Encode writes the Tower to the passed io.Writer. The TowerID is not
// serialized, since it acts as the key.
func (t *Tower) Encode(w io.Writer) error {
        err := WriteElements(w,
                t.IdentityKey,
                t.Addresses,
        )
        if err != nil {
                return err
        }

        status := uint8(t.Status)
        tlvRecords := []tlv.Record{
                tlv.MakePrimitiveRecord(TowerStatusTLVType, &status),
        }

        tlvStream, err := tlv.NewStream(tlvRecords...)
        if err != nil {
                return err
        }

        return tlvStream.Encode(w)
}

// Decode reads a Tower from the passed io.Reader. The TowerID is meant to be
// decoded from the key.
func (t *Tower) Decode(r io.Reader) error {
        err := ReadElements(r,
                &t.IdentityKey,
                &t.Addresses,
        )
        if err != nil {
                return err
        }

        var status uint8
        tlvRecords := []tlv.Record{
                tlv.MakePrimitiveRecord(TowerStatusTLVType, &status),
        }

        tlvStream, err := tlv.NewStream(tlvRecords...)
        if err != nil {
                return err
        }

        typeMap, err := tlvStream.DecodeWithParsedTypes(r)
        if err != nil {
                return err
        }

        if _, ok := typeMap[TowerStatusTLVType]; ok {
                t.Status = TowerStatus(status)
        }

        return nil
}

1	package wtdb
2
3	import (
4	"encoding/hex"
5	"fmt"
6	"io"
7	"net"
8
9	"github.com/btcsuite/btcd/btcec/v2"
10	"github.com/lightningnetwork/lnd/tlv"
11	)
12
13	// TowerStatus represents the state of the tower as set by the tower client.
14	type TowerStatus uint8
15
16	const (
17	// TowerStatusActive is the default state of the tower, and it indicates
18	// that this tower should be used to attempt session creation.
19	TowerStatusActive TowerStatus = 0
20
21	// TowerStatusInactive indicates that the tower should not be used to
22	// attempt session creation.
23	TowerStatusInactive TowerStatus = 1
24	)
25
26	const (
27	// TowerStatusTLVType is the TLV type number that will be used to store
28	// the tower's status.
29	TowerStatusTLVType = tlv.Type(0)
30	)
31
32	// TowerID is a unique 64-bit identifier allocated to each unique watchtower.
33	// This allows the client to conserve on-disk space by not needing to always
34	// reference towers by their pubkey.
35	type TowerID uint64
36
37	// TowerIDFromBytes constructs a TowerID from the provided byte slice. The
38	// argument must have at least 8 bytes, and should contain the TowerID in
39	// big-endian byte order.
40	func TowerIDFromBytes(towerIDBytes []byte) TowerID {	3✔
41	return TowerID(byteOrder.Uint64(towerIDBytes))	3✔
42	}	3✔
43
44	// Bytes encodes a TowerID into an 8-byte slice in big-endian byte order.
45	func (id TowerID) Bytes() []byte {	3✔
46	var buf [8]byte	3✔
47	byteOrder.PutUint64(buf[:], uint64(id))	3✔
48	return buf[:]	3✔
49	}	3✔
50
51	// Tower holds the necessary components required to connect to a remote tower.
52	// Communication is handled by brontide, and requires both a public key and an
53	// address.
54	type Tower struct {
55	// ID is a unique ID for this record assigned by the database.
56	ID TowerID
57
58	// IdentityKey is the public key of the remote node, used to
59	// authenticate the brontide transport.
60	IdentityKey *btcec.PublicKey
61
62	// Addresses is a list of possible addresses to reach the tower.
63	Addresses []net.Addr
64
65	// Status is the status of this tower as set by the client.
66	Status TowerStatus
67	}
68
69	// AddAddress adds the given address to the tower's in-memory list of addresses.
70	// If the address's string is already present, the Tower will be left
71	// unmodified. Otherwise, the address is prepended to the beginning of the
72	// Tower's addresses, on the assumption that it is fresher than the others.
73	//
74	// NOTE: This method is NOT safe for concurrent use.
75	func (t *Tower) AddAddress(addr net.Addr) {	3✔
76	// Ensure we don't add a duplicate address.	3✔
77	addrStr := addr.String()	3✔
78	for _, existingAddr := range t.Addresses {	6✔
79	if existingAddr.String() == addrStr {	6✔
80	return	3✔
81	}	3✔
82	}
83
84	// Add this address to the front of the list, on the assumption that it
85	// is a fresher address and will be tried first.
UNCOV 86	t.Addresses = append([]net.Addr{addr}, t.Addresses...)	×
87	}
88
89	// RemoveAddress removes the given address from the tower's in-memory list of
90	// addresses. If the address doesn't exist, then this will act as a NOP.
UNCOV 91	func (t *Tower) RemoveAddress(addr net.Addr) {	×
UNCOV 92	addrStr := addr.String()	×
UNCOV 93	for i, address := range t.Addresses {	×
UNCOV 94	if address.String() != addrStr {	×
UNCOV 95	continue	×
96	}
UNCOV 97	t.Addresses = append(t.Addresses[:i], t.Addresses[i+1:]...)	×
UNCOV 98	return	×
99	}
100	}
101
102	// String returns a user-friendly identifier of the tower.
103	func (t *Tower) String() string {	×
104	pubKey := hex.EncodeToString(t.IdentityKey.SerializeCompressed())	×
105	if len(t.Addresses) == 0 {	×
106	return pubKey	×
107	}	×
108	return fmt.Sprintf("%v@%v", pubKey, t.Addresses[0])	×
109	}
110
111	// Encode writes the Tower to the passed io.Writer. The TowerID is not
112	// serialized, since it acts as the key.
113	func (t *Tower) Encode(w io.Writer) error {	3✔
114	err := WriteElements(w,	3✔
115	t.IdentityKey,	3✔
116	t.Addresses,	3✔
117	)	3✔
118	if err != nil {	3✔
119	return err	×
120	}	×
121
122	status := uint8(t.Status)	3✔
123	tlvRecords := []tlv.Record{	3✔
124	tlv.MakePrimitiveRecord(TowerStatusTLVType, &status),	3✔
125	}	3✔
126		3✔
127	tlvStream, err := tlv.NewStream(tlvRecords...)	3✔
128	if err != nil {	3✔
129	return err	×
130	}	×
131
132	return tlvStream.Encode(w)	3✔
133	}
134
135	// Decode reads a Tower from the passed io.Reader. The TowerID is meant to be
136	// decoded from the key.
137	func (t *Tower) Decode(r io.Reader) error {	3✔
138	err := ReadElements(r,	3✔
139	&t.IdentityKey,	3✔
140	&t.Addresses,	3✔
141	)	3✔
142	if err != nil {	3✔
143	return err	×
144	}	×
145
146	var status uint8	3✔
147	tlvRecords := []tlv.Record{	3✔
148	tlv.MakePrimitiveRecord(TowerStatusTLVType, &status),	3✔
149	}	3✔
150		3✔
151	tlvStream, err := tlv.NewStream(tlvRecords...)	3✔
152	if err != nil {	3✔
153	return err	×
154	}	×
155
156	typeMap, err := tlvStream.DecodeWithParsedTypes(r)	3✔
157	if err != nil {	3✔
158	return err	×
159	}	×
160
161	if _, ok := typeMap[TowerStatusTLVType]; ok {	6✔
162	t.Status = TowerStatus(status)	3✔
163	}	3✔
164
165	return nil	3✔
166	}

lightningnetwork / lnd / 15736109134

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