13566028875

Committed 27 Feb 2025 12:09PM UTC coverage: 49.396% (-9.4%) from 58.748%

Build # 13566028875

Build Type

Pull #9555

github

Committed by

ellemouton

Commit Message

graph/db: populate the graph cache in Start instead of during construction

In this commit, we move the graph cache population logic out of the
ChannelGraph constructor and into its Start method instead.

Pull Request Pull Request #9555: graph: extract cache from CRUD [6]

Run Details

34 of 54 new or added lines in 4 files covered. (62.96%)

27464 existing lines in 436 files now uncovered.

101095 of 204664 relevant lines covered (49.4%)

1.54 hits per line

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

74.58

/netann/node_announcement.go

package netann

import (
        "bytes"
        "image/color"
        "net"
        "time"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/go-errors/errors"
        "github.com/lightningnetwork/lnd/keychain"
        "github.com/lightningnetwork/lnd/lnwallet"
        "github.com/lightningnetwork/lnd/lnwire"
)

// NodeAnnModifier is a closure that makes in-place modifications to an
// lnwire.NodeAnnouncement.
type NodeAnnModifier func(*lnwire.NodeAnnouncement)

// NodeAnnSetAlias is a functional option that sets the alias of the
// given node announcement.
func NodeAnnSetAlias(alias lnwire.NodeAlias) func(*lnwire.NodeAnnouncement) {
        return func(nodeAnn *lnwire.NodeAnnouncement) {
                nodeAnn.Alias = alias
        }
}

// NodeAnnSetAddrs is a functional option that allows updating the addresses of
// the given node announcement.
func NodeAnnSetAddrs(addrs []net.Addr) func(*lnwire.NodeAnnouncement) {
        return func(nodeAnn *lnwire.NodeAnnouncement) {
                nodeAnn.Addresses = addrs
        }
}

// NodeAnnSetColor is a functional option that sets the color of the
// given node announcement.
func NodeAnnSetColor(newColor color.RGBA) func(*lnwire.NodeAnnouncement) {
        return func(nodeAnn *lnwire.NodeAnnouncement) {
                nodeAnn.RGBColor = newColor
        }
}

// NodeAnnSetFeatures is a functional option that allows updating the features of
// the given node announcement.
func NodeAnnSetFeatures(features *lnwire.RawFeatureVector) func(*lnwire.NodeAnnouncement) {
        return func(nodeAnn *lnwire.NodeAnnouncement) {
                nodeAnn.Features = features
        }
}

// NodeAnnSetTimestamp is a functional option that sets the timestamp of the
// announcement to the current time, or increments it if the timestamp is
// already in the future.
func NodeAnnSetTimestamp(nodeAnn *lnwire.NodeAnnouncement) {
        newTimestamp := uint32(time.Now().Unix())
        if newTimestamp <= nodeAnn.Timestamp {
                // Increment the prior value to  ensure the timestamp
                // monotonically increases, otherwise the announcement won't
                // propagate.
                newTimestamp = nodeAnn.Timestamp + 1
        }
        nodeAnn.Timestamp = newTimestamp
}

// SignNodeAnnouncement signs the lnwire.NodeAnnouncement provided, which
// should be the most recent, valid update, otherwise the timestamp may not
// monotonically increase from the prior.
func SignNodeAnnouncement(signer lnwallet.MessageSigner,
        keyLoc keychain.KeyLocator, nodeAnn *lnwire.NodeAnnouncement) error {

        // Create the DER-encoded ECDSA signature over the message digest.
        sig, err := SignAnnouncement(signer, keyLoc, nodeAnn)
        if err != nil {
                return err
        }

        // Parse the DER-encoded signature into a fixed-size 64-byte array.
        nodeAnn.Signature, err = lnwire.NewSigFromSignature(sig)
        return err
}

// ValidateNodeAnn validates the node announcement by ensuring that the
// attached signature is needed a signature of the node announcement under the
// specified node public key.
func ValidateNodeAnn(a *lnwire.NodeAnnouncement) error {
        // Reconstruct the data of announcement which should be covered by the
        // signature so we can verify the signature shortly below
        data, err := a.DataToSign()
        if err != nil {
                return err
        }

        nodeSig, err := a.Signature.ToSignature()
        if err != nil {
                return err
        }
        nodeKey, err := btcec.ParsePubKey(a.NodeID[:])
        if err != nil {
                return err
        }

        // Finally ensure that the passed signature is valid, if not we'll
        // return an error so this node announcement can be rejected.
        dataHash := chainhash.DoubleHashB(data)
        if !nodeSig.Verify(dataHash, nodeKey) {
                var msgBuf bytes.Buffer
                if _, err := lnwire.WriteMessage(&msgBuf, a, 0); err != nil {
                        return err
                }

                return errors.Errorf("signature on NodeAnnouncement(%x) is "+
                        "invalid: %x", nodeKey.SerializeCompressed(),
                        msgBuf.Bytes())
        }

        return nil
}

1	package netann
2
3	import (
4	"bytes"
5	"image/color"
6	"net"
7	"time"
8
9	"github.com/btcsuite/btcd/btcec/v2"
10	"github.com/btcsuite/btcd/chaincfg/chainhash"
11	"github.com/go-errors/errors"
12	"github.com/lightningnetwork/lnd/keychain"
13	"github.com/lightningnetwork/lnd/lnwallet"
14	"github.com/lightningnetwork/lnd/lnwire"
15	)
16
17	// NodeAnnModifier is a closure that makes in-place modifications to an
18	// lnwire.NodeAnnouncement.
19	type NodeAnnModifier func(*lnwire.NodeAnnouncement)
20
21	// NodeAnnSetAlias is a functional option that sets the alias of the
22	// given node announcement.
23	func NodeAnnSetAlias(alias lnwire.NodeAlias) func(*lnwire.NodeAnnouncement) {	3✔
24	return func(nodeAnn *lnwire.NodeAnnouncement) {	6✔
25	nodeAnn.Alias = alias	3✔
26	}	3✔
27	}
28
29	// NodeAnnSetAddrs is a functional option that allows updating the addresses of
30	// the given node announcement.
31	func NodeAnnSetAddrs(addrs []net.Addr) func(*lnwire.NodeAnnouncement) {	3✔
32	return func(nodeAnn *lnwire.NodeAnnouncement) {	6✔
33	nodeAnn.Addresses = addrs	3✔
34	}	3✔
35	}
36
37	// NodeAnnSetColor is a functional option that sets the color of the
38	// given node announcement.
39	func NodeAnnSetColor(newColor color.RGBA) func(*lnwire.NodeAnnouncement) {	3✔
40	return func(nodeAnn *lnwire.NodeAnnouncement) {	6✔
41	nodeAnn.RGBColor = newColor	3✔
42	}	3✔
43	}
44
45	// NodeAnnSetFeatures is a functional option that allows updating the features of
46	// the given node announcement.
47	func NodeAnnSetFeatures(features lnwire.RawFeatureVector) func(lnwire.NodeAnnouncement) {	3✔
48	return func(nodeAnn *lnwire.NodeAnnouncement) {	6✔
49	nodeAnn.Features = features	3✔
50	}	3✔
51	}
52
53	// NodeAnnSetTimestamp is a functional option that sets the timestamp of the
54	// announcement to the current time, or increments it if the timestamp is
55	// already in the future.
56	func NodeAnnSetTimestamp(nodeAnn *lnwire.NodeAnnouncement) {	3✔
57	newTimestamp := uint32(time.Now().Unix())	3✔
58	if newTimestamp <= nodeAnn.Timestamp {	6✔
59	// Increment the prior value to ensure the timestamp	3✔
60	// monotonically increases, otherwise the announcement won't	3✔
61	// propagate.	3✔
62	newTimestamp = nodeAnn.Timestamp + 1	3✔
63	}	3✔
64	nodeAnn.Timestamp = newTimestamp	3✔
65	}
66
67	// SignNodeAnnouncement signs the lnwire.NodeAnnouncement provided, which
68	// should be the most recent, valid update, otherwise the timestamp may not
69	// monotonically increase from the prior.
70	func SignNodeAnnouncement(signer lnwallet.MessageSigner,
71	keyLoc keychain.KeyLocator, nodeAnn *lnwire.NodeAnnouncement) error {	3✔
72		3✔
73	// Create the DER-encoded ECDSA signature over the message digest.	3✔
74	sig, err := SignAnnouncement(signer, keyLoc, nodeAnn)	3✔
75	if err != nil {	3✔
76	return err	×
77	}	×
78
79	// Parse the DER-encoded signature into a fixed-size 64-byte array.
80	nodeAnn.Signature, err = lnwire.NewSigFromSignature(sig)	3✔
81	return err	3✔
82	}
83
84	// ValidateNodeAnn validates the node announcement by ensuring that the
85	// attached signature is needed a signature of the node announcement under the
86	// specified node public key.
87	func ValidateNodeAnn(a *lnwire.NodeAnnouncement) error {	3✔
88	// Reconstruct the data of announcement which should be covered by the	3✔
89	// signature so we can verify the signature shortly below	3✔
90	data, err := a.DataToSign()	3✔
91	if err != nil {	3✔
UNCOV 92	return err	×
UNCOV 93	}	×
94
95	nodeSig, err := a.Signature.ToSignature()	3✔
96	if err != nil {	3✔
97	return err	×
98	}	×
99	nodeKey, err := btcec.ParsePubKey(a.NodeID[:])	3✔
100	if err != nil {	3✔
101	return err	×
102	}	×
103
104	// Finally ensure that the passed signature is valid, if not we'll
105	// return an error so this node announcement can be rejected.
106	dataHash := chainhash.DoubleHashB(data)	3✔
107	if !nodeSig.Verify(dataHash, nodeKey) {	3✔
108	var msgBuf bytes.Buffer	×
109	if _, err := lnwire.WriteMessage(&msgBuf, a, 0); err != nil {	×
110	return err	×
111	}	×
112
113	return errors.Errorf("signature on NodeAnnouncement(%x) is "+	×
114	"invalid: %x", nodeKey.SerializeCompressed(),	×
115	msgBuf.Bytes())	×
116	}
117
118	return nil	3✔
119	}

lightningnetwork / lnd / 13566028875

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