12343072627

Committed 15 Dec 2024 11:09PM UTC coverage: 57.504% (-1.1%) from 58.636%

Build # 12343072627

Build Type

Pull #9315

github

Committed by

yyforyongyu

Commit Message

contractcourt: offer outgoing htlc one block earlier before its expiry

We need to offer the outgoing htlc one block earlier to make sure when
the expiry height hits, the sweeper will not miss sweeping it in the
same block. This also means the outgoing contest resolver now only does
one thing - watch for preimage spend till height expiry-1, which can
easily be moved into the timeout resolver instead in the future.

Pull Request Pull Request #9315: Implement `blockbeat`

Run Details

1445 of 2007 new or added lines in 26 files covered. (72.0%)

19246 existing lines in 249 files now uncovered.

102342 of 177975 relevant lines covered (57.5%)

24772.24 hits per line

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

72.34

/graph/db/models/node.go

package models

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

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

// LightningNode represents an individual vertex/node within the channel graph.
// A node is connected to other nodes by one or more channel edges emanating
// from it. As the graph is directed, a node will also have an incoming edge
// attached to it for each outgoing edge.
type LightningNode struct {
        // PubKeyBytes is the raw bytes of the public key of the target node.
        PubKeyBytes [33]byte
        pubKey      *btcec.PublicKey

        // HaveNodeAnnouncement indicates whether we received a node
        // announcement for this particular node. If true, the remaining fields
        // will be set, if false only the PubKey is known for this node.
        HaveNodeAnnouncement bool

        // LastUpdate is the last time the vertex information for this node has
        // been updated.
        LastUpdate time.Time

        // Address is the TCP address this node is reachable over.
        Addresses []net.Addr

        // Color is the selected color for the node.
        Color color.RGBA

        // Alias is a nick-name for the node. The alias can be used to confirm
        // a node's identity or to serve as a short ID for an address book.
        Alias string

        // AuthSigBytes is the raw signature under the advertised public key
        // which serves to authenticate the attributes announced by this node.
        AuthSigBytes []byte

        // Features is the list of protocol features supported by this node.
        Features *lnwire.FeatureVector

        // ExtraOpaqueData is the set of data that was appended to this
        // message, some of which we may not actually know how to iterate or
        // parse. By holding onto this data, we ensure that we're able to
        // properly validate the set of signatures that cover these new fields,
        // and ensure we're able to make upgrades to the network in a forwards
        // compatible manner.
        ExtraOpaqueData []byte

        // TODO(roasbeef): discovery will need storage to keep it's last IP
        // address and re-announce if interface changes?

        // TODO(roasbeef): add update method and fetch?
}

// PubKey is the node's long-term identity public key. This key will be used to
// authenticated any advertisements/updates sent by the node.
//
// NOTE: By having this method to access an attribute, we ensure we only need
// to fully deserialize the pubkey if absolutely necessary.
func (l *LightningNode) PubKey() (*btcec.PublicKey, error) {
        if l.pubKey != nil {
                return l.pubKey, nil
        }

        key, err := btcec.ParsePubKey(l.PubKeyBytes[:])
        if err != nil {
                return nil, err
        }
        l.pubKey = key

        return key, nil
}

// AuthSig is a signature under the advertised public key which serves to
// authenticate the attributes announced by this node.
//
// NOTE: By having this method to access an attribute, we ensure we only need
// to fully deserialize the signature if absolutely necessary.
func (l *LightningNode) AuthSig() (*ecdsa.Signature, error) {
        return ecdsa.ParseSignature(l.AuthSigBytes)
}

// AddPubKey is a setter-link method that can be used to swap out the public
// key for a node.
func (l *LightningNode) AddPubKey(key *btcec.PublicKey) {
        l.pubKey = key
        copy(l.PubKeyBytes[:], key.SerializeCompressed())
}

// NodeAnnouncement retrieves the latest node announcement of the node.
func (l *LightningNode) NodeAnnouncement(signed bool) (*lnwire.NodeAnnouncement,
        error) {

        if !l.HaveNodeAnnouncement {
                return nil, fmt.Errorf("node does not have node announcement")
        }

        alias, err := lnwire.NewNodeAlias(l.Alias)
        if err != nil {
                return nil, err
        }

        nodeAnn := &lnwire.NodeAnnouncement{
                Features:        l.Features.RawFeatureVector,
                NodeID:          l.PubKeyBytes,
                RGBColor:        l.Color,
                Alias:           alias,
                Addresses:       l.Addresses,
                Timestamp:       uint32(l.LastUpdate.Unix()),
                ExtraOpaqueData: l.ExtraOpaqueData,
        }

        if !signed {
                return nodeAnn, nil
        }

        sig, err := lnwire.NewSigFromECDSARawSignature(l.AuthSigBytes)
        if err != nil {
                return nil, err
        }

        nodeAnn.Signature = sig

        return nodeAnn, nil
}

1	package models
2
3	import (
4	"fmt"
5	"image/color"
6	"net"
7	"time"
8
9	"github.com/btcsuite/btcd/btcec/v2"
10	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
11	"github.com/lightningnetwork/lnd/lnwire"
12	)
13
14	// LightningNode represents an individual vertex/node within the channel graph.
15	// A node is connected to other nodes by one or more channel edges emanating
16	// from it. As the graph is directed, a node will also have an incoming edge
17	// attached to it for each outgoing edge.
18	type LightningNode struct {
19	// PubKeyBytes is the raw bytes of the public key of the target node.
20	PubKeyBytes [33]byte
21	pubKey *btcec.PublicKey
22
23	// HaveNodeAnnouncement indicates whether we received a node
24	// announcement for this particular node. If true, the remaining fields
25	// will be set, if false only the PubKey is known for this node.
26	HaveNodeAnnouncement bool
27
28	// LastUpdate is the last time the vertex information for this node has
29	// been updated.
30	LastUpdate time.Time
31
32	// Address is the TCP address this node is reachable over.
33	Addresses []net.Addr
34
35	// Color is the selected color for the node.
36	Color color.RGBA
37
38	// Alias is a nick-name for the node. The alias can be used to confirm
39	// a node's identity or to serve as a short ID for an address book.
40	Alias string
41
42	// AuthSigBytes is the raw signature under the advertised public key
43	// which serves to authenticate the attributes announced by this node.
44	AuthSigBytes []byte
45
46	// Features is the list of protocol features supported by this node.
47	Features *lnwire.FeatureVector
48
49	// ExtraOpaqueData is the set of data that was appended to this
50	// message, some of which we may not actually know how to iterate or
51	// parse. By holding onto this data, we ensure that we're able to
52	// properly validate the set of signatures that cover these new fields,
53	// and ensure we're able to make upgrades to the network in a forwards
54	// compatible manner.
55	ExtraOpaqueData []byte
56
57	// TODO(roasbeef): discovery will need storage to keep it's last IP
58	// address and re-announce if interface changes?
59
60	// TODO(roasbeef): add update method and fetch?
61	}
62
63	// PubKey is the node's long-term identity public key. This key will be used to
64	// authenticated any advertisements/updates sent by the node.
65	//
66	// NOTE: By having this method to access an attribute, we ensure we only need
67	// to fully deserialize the pubkey if absolutely necessary.
68	func (l LightningNode) PubKey() (btcec.PublicKey, error) {	1,478✔
69	if l.pubKey != nil {	1,967✔
70	return l.pubKey, nil	489✔
71	}	489✔
72
73	key, err := btcec.ParsePubKey(l.PubKeyBytes[:])	989✔
74	if err != nil {	989✔
75	return nil, err	×
76	}	×
77	l.pubKey = key	989✔
78		989✔
79	return key, nil	989✔
80	}
81
82	// AuthSig is a signature under the advertised public key which serves to
83	// authenticate the attributes announced by this node.
84	//
85	// NOTE: By having this method to access an attribute, we ensure we only need
86	// to fully deserialize the signature if absolutely necessary.
87	func (l LightningNode) AuthSig() (ecdsa.Signature, error) {	×
88	return ecdsa.ParseSignature(l.AuthSigBytes)	×
89	}	×
90
91	// AddPubKey is a setter-link method that can be used to swap out the public
92	// key for a node.
93	func (l LightningNode) AddPubKey(key btcec.PublicKey) {	60✔
94	l.pubKey = key	60✔
95	copy(l.PubKeyBytes[:], key.SerializeCompressed())	60✔
96	}	60✔
97
98	// NodeAnnouncement retrieves the latest node announcement of the node.
99	func (l LightningNode) NodeAnnouncement(signed bool) (lnwire.NodeAnnouncement,
100	error) {	14✔
101		14✔
102	if !l.HaveNodeAnnouncement {	14✔
UNCOV 103	return nil, fmt.Errorf("node does not have node announcement")	×
UNCOV 104	}	×
105
106	alias, err := lnwire.NewNodeAlias(l.Alias)	14✔
107	if err != nil {	14✔
108	return nil, err	×
109	}	×
110
111	nodeAnn := &lnwire.NodeAnnouncement{	14✔
112	Features: l.Features.RawFeatureVector,	14✔
113	NodeID: l.PubKeyBytes,	14✔
114	RGBColor: l.Color,	14✔
115	Alias: alias,	14✔
116	Addresses: l.Addresses,	14✔
117	Timestamp: uint32(l.LastUpdate.Unix()),	14✔
118	ExtraOpaqueData: l.ExtraOpaqueData,	14✔
119	}	14✔
120		14✔
121	if !signed {	14✔
UNCOV 122	return nodeAnn, nil	×
UNCOV 123	}	×
124
125	sig, err := lnwire.NewSigFromECDSARawSignature(l.AuthSigBytes)	14✔
126	if err != nil {	14✔
127	return nil, err	×
128	}	×
129
130	nodeAnn.Signature = sig	14✔
131		14✔
132	return nodeAnn, nil	14✔
133	}

lightningnetwork / lnd / 12343072627

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