19155841408

Committed 07 Nov 2025 02:03AM UTC coverage: 66.675% (-0.04%) from 66.712%

Build # 19155841408

Build Type

Pull #10352

github

Committed by

web-flow

Commit Message

Merge e4313eba8 into 096ab65b1

Pull Request Pull Request #10352: [WIP] chainrpc: return Unavailable while notifier starts

Run Details

137328 of 205965 relevant lines covered (66.68%)

21333.36 hits per line

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

57.35

/graph/db/models/channel_edge_info.go

package models

import (
        "bytes"
        "fmt"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/btcsuite/btcd/wire"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/lnwire"
)

// ChannelEdgeInfo represents a fully authenticated channel along with all its
// unique attributes. Once an authenticated channel announcement has been
// processed on the network, then an instance of ChannelEdgeInfo encapsulating
// the channels attributes is stored. The other portions relevant to routing
// policy of a channel are stored within a ChannelEdgePolicy for each direction
// of the channel.
type ChannelEdgeInfo struct {
        // ChannelID is the unique channel ID for the channel. The first 3
        // bytes are the block height, the next 3 the index within the block,
        // and the last 2 bytes are the output index for the channel.
        ChannelID uint64

        // ChainHash is the hash that uniquely identifies the chain that this
        // channel was opened within.
        //
        // TODO(roasbeef): need to modify db keying for multi-chain
        //  * must add chain hash to prefix as well
        ChainHash chainhash.Hash

        // NodeKey1Bytes is the raw public key of the first node.
        NodeKey1Bytes [33]byte
        nodeKey1      *btcec.PublicKey

        // NodeKey2Bytes is the raw public key of the first node.
        NodeKey2Bytes [33]byte
        nodeKey2      *btcec.PublicKey

        // BitcoinKey1Bytes is the raw public key of the first node.
        BitcoinKey1Bytes [33]byte
        bitcoinKey1      *btcec.PublicKey

        // BitcoinKey2Bytes is the raw public key of the first node.
        BitcoinKey2Bytes [33]byte
        bitcoinKey2      *btcec.PublicKey

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

        // AuthProof is the authentication proof for this channel. This proof
        // contains a set of signatures binding four identities, which attests
        // to the legitimacy of the advertised channel.
        AuthProof *ChannelAuthProof

        // ChannelPoint is the funding outpoint of the channel. This can be
        // used to uniquely identify the channel within the channel graph.
        ChannelPoint wire.OutPoint

        // Capacity is the total capacity of the channel, this is determined by
        // the value output in the outpoint that created this channel.
        Capacity btcutil.Amount

        // FundingScript holds the script of the channel's funding transaction.
        //
        // NOTE: this is not currently persisted and so will not be present if
        // the edge object is loaded from the database.
        FundingScript fn.Option[[]byte]

        // 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
}

// AddNodeKeys is a setter-like method that can be used to replace the set of
// keys for the target ChannelEdgeInfo.
func (c *ChannelEdgeInfo) AddNodeKeys(nodeKey1, nodeKey2, bitcoinKey1,
        bitcoinKey2 *btcec.PublicKey) {

        c.nodeKey1 = nodeKey1
        copy(c.NodeKey1Bytes[:], c.nodeKey1.SerializeCompressed())

        c.nodeKey2 = nodeKey2
        copy(c.NodeKey2Bytes[:], nodeKey2.SerializeCompressed())

        c.bitcoinKey1 = bitcoinKey1
        copy(c.BitcoinKey1Bytes[:], c.bitcoinKey1.SerializeCompressed())

        c.bitcoinKey2 = bitcoinKey2
        copy(c.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed())
}

// NodeKey1 is the identity public key of the "first" node that was involved in
// the creation of this channel. A node is considered "first" if the
// lexicographical ordering the its serialized public key is "smaller" than
// that of the other node involved in channel creation.
//
// NOTE: By having this method to access an attribute, we ensure we only need
// to fully deserialize the pubkey if absolutely necessary.
func (c *ChannelEdgeInfo) NodeKey1() (*btcec.PublicKey, error) {
        if c.nodeKey1 != nil {
                return c.nodeKey1, nil
        }

        key, err := btcec.ParsePubKey(c.NodeKey1Bytes[:])
        if err != nil {
                return nil, err
        }
        c.nodeKey1 = key

        return key, nil
}

// NodeKey2 is the identity public key of the "second" node that was involved in
// the creation of this channel. A node is considered "second" if the
// lexicographical ordering the its serialized public key is "larger" than that
// of the other node involved in channel creation.
//
// NOTE: By having this method to access an attribute, we ensure we only need
// to fully deserialize the pubkey if absolutely necessary.
func (c *ChannelEdgeInfo) NodeKey2() (*btcec.PublicKey, error) {
        if c.nodeKey2 != nil {
                return c.nodeKey2, nil
        }

        key, err := btcec.ParsePubKey(c.NodeKey2Bytes[:])
        if err != nil {
                return nil, err
        }
        c.nodeKey2 = key

        return key, nil
}

// BitcoinKey1 is the Bitcoin multi-sig key belonging to the first node, that
// was involved in the funding transaction that originally created the channel
// that this struct represents.
//
// NOTE: By having this method to access an attribute, we ensure we only need
// to fully deserialize the pubkey if absolutely necessary.
func (c *ChannelEdgeInfo) BitcoinKey1() (*btcec.PublicKey, error) {
        if c.bitcoinKey1 != nil {
                return c.bitcoinKey1, nil
        }

        key, err := btcec.ParsePubKey(c.BitcoinKey1Bytes[:])
        if err != nil {
                return nil, err
        }
        c.bitcoinKey1 = key

        return key, nil
}

// BitcoinKey2 is the Bitcoin multi-sig key belonging to the second node, that
// was involved in the funding transaction that originally created the channel
// that this struct represents.
//
// NOTE: By having this method to access an attribute, we ensure we only need
// to fully deserialize the pubkey if absolutely necessary.
func (c *ChannelEdgeInfo) BitcoinKey2() (*btcec.PublicKey, error) {
        if c.bitcoinKey2 != nil {
                return c.bitcoinKey2, nil
        }

        key, err := btcec.ParsePubKey(c.BitcoinKey2Bytes[:])
        if err != nil {
                return nil, err
        }
        c.bitcoinKey2 = key

        return key, nil
}

// OtherNodeKeyBytes returns the node key bytes of the other end of the channel.
func (c *ChannelEdgeInfo) OtherNodeKeyBytes(thisNodeKey []byte) (
        [33]byte, error) {

        switch {
        case bytes.Equal(c.NodeKey1Bytes[:], thisNodeKey):
                return c.NodeKey2Bytes, nil
        case bytes.Equal(c.NodeKey2Bytes[:], thisNodeKey):
                return c.NodeKey1Bytes, nil
        default:
                return [33]byte{}, fmt.Errorf("node not participating in " +
                        "this channel")
        }
}

1	package models
2
3	import (
4	"bytes"
5	"fmt"
6
7	"github.com/btcsuite/btcd/btcec/v2"
8	"github.com/btcsuite/btcd/btcutil"
9	"github.com/btcsuite/btcd/chaincfg/chainhash"
10	"github.com/btcsuite/btcd/wire"
11	"github.com/lightningnetwork/lnd/fn/v2"
12	"github.com/lightningnetwork/lnd/lnwire"
13	)
14
15	// ChannelEdgeInfo represents a fully authenticated channel along with all its
16	// unique attributes. Once an authenticated channel announcement has been
17	// processed on the network, then an instance of ChannelEdgeInfo encapsulating
18	// the channels attributes is stored. The other portions relevant to routing
19	// policy of a channel are stored within a ChannelEdgePolicy for each direction
20	// of the channel.
21	type ChannelEdgeInfo struct {
22	// ChannelID is the unique channel ID for the channel. The first 3
23	// bytes are the block height, the next 3 the index within the block,
24	// and the last 2 bytes are the output index for the channel.
25	ChannelID uint64
26
27	// ChainHash is the hash that uniquely identifies the chain that this
28	// channel was opened within.
29	//
30	// TODO(roasbeef): need to modify db keying for multi-chain
31	// * must add chain hash to prefix as well
32	ChainHash chainhash.Hash
33
34	// NodeKey1Bytes is the raw public key of the first node.
35	NodeKey1Bytes [33]byte
36	nodeKey1 *btcec.PublicKey
37
38	// NodeKey2Bytes is the raw public key of the first node.
39	NodeKey2Bytes [33]byte
40	nodeKey2 *btcec.PublicKey
41
42	// BitcoinKey1Bytes is the raw public key of the first node.
43	BitcoinKey1Bytes [33]byte
44	bitcoinKey1 *btcec.PublicKey
45
46	// BitcoinKey2Bytes is the raw public key of the first node.
47	BitcoinKey2Bytes [33]byte
48	bitcoinKey2 *btcec.PublicKey
49
50	// Features is the list of protocol features supported by this channel
51	// edge.
52	Features *lnwire.FeatureVector
53
54	// AuthProof is the authentication proof for this channel. This proof
55	// contains a set of signatures binding four identities, which attests
56	// to the legitimacy of the advertised channel.
57	AuthProof *ChannelAuthProof
58
59	// ChannelPoint is the funding outpoint of the channel. This can be
60	// used to uniquely identify the channel within the channel graph.
61	ChannelPoint wire.OutPoint
62
63	// Capacity is the total capacity of the channel, this is determined by
64	// the value output in the outpoint that created this channel.
65	Capacity btcutil.Amount
66
67	// FundingScript holds the script of the channel's funding transaction.
68	//
69	// NOTE: this is not currently persisted and so will not be present if
70	// the edge object is loaded from the database.
71	FundingScript fn.Option[[]byte]
72
73	// ExtraOpaqueData is the set of data that was appended to this
74	// message, some of which we may not actually know how to iterate or
75	// parse. By holding onto this data, we ensure that we're able to
76	// properly validate the set of signatures that cover these new fields,
77	// and ensure we're able to make upgrades to the network in a forwards
78	// compatible manner.
79	ExtraOpaqueData []byte
80	}
81
82	// AddNodeKeys is a setter-like method that can be used to replace the set of
83	// keys for the target ChannelEdgeInfo.
84	func (c *ChannelEdgeInfo) AddNodeKeys(nodeKey1, nodeKey2, bitcoinKey1,
85	bitcoinKey2 *btcec.PublicKey) {	74✔
86		74✔
87	c.nodeKey1 = nodeKey1	74✔
88	copy(c.NodeKey1Bytes[:], c.nodeKey1.SerializeCompressed())	74✔
89		74✔
90	c.nodeKey2 = nodeKey2	74✔
91	copy(c.NodeKey2Bytes[:], nodeKey2.SerializeCompressed())	74✔
92		74✔
93	c.bitcoinKey1 = bitcoinKey1	74✔
94	copy(c.BitcoinKey1Bytes[:], c.bitcoinKey1.SerializeCompressed())	74✔
95		74✔
96	c.bitcoinKey2 = bitcoinKey2	74✔
97	copy(c.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed())	74✔
98	}	74✔
99
100	// NodeKey1 is the identity public key of the "first" node that was involved in
101	// the creation of this channel. A node is considered "first" if the
102	// lexicographical ordering the its serialized public key is "smaller" than
103	// that of the other node involved in channel creation.
104	//
105	// NOTE: By having this method to access an attribute, we ensure we only need
106	// to fully deserialize the pubkey if absolutely necessary.
107	func (c ChannelEdgeInfo) NodeKey1() (btcec.PublicKey, error) {	3,242✔
108	if c.nodeKey1 != nil {	3,383✔
109	return c.nodeKey1, nil	141✔
110	}	141✔
111
112	key, err := btcec.ParsePubKey(c.NodeKey1Bytes[:])	3,104✔
113	if err != nil {	3,104✔
114	return nil, err	×
115	}	×
116	c.nodeKey1 = key	3,104✔
117		3,104✔
118	return key, nil	3,104✔
119	}
120
121	// NodeKey2 is the identity public key of the "second" node that was involved in
122	// the creation of this channel. A node is considered "second" if the
123	// lexicographical ordering the its serialized public key is "larger" than that
124	// of the other node involved in channel creation.
125	//
126	// NOTE: By having this method to access an attribute, we ensure we only need
127	// to fully deserialize the pubkey if absolutely necessary.
128	func (c ChannelEdgeInfo) NodeKey2() (btcec.PublicKey, error) {	3,094✔
129	if c.nodeKey2 != nil {	3,181✔
130	return c.nodeKey2, nil	87✔
131	}	87✔
132
133	key, err := btcec.ParsePubKey(c.NodeKey2Bytes[:])	3,010✔
134	if err != nil {	3,010✔
135	return nil, err	×
136	}	×
137	c.nodeKey2 = key	3,010✔
138		3,010✔
139	return key, nil	3,010✔
140	}
141
142	// BitcoinKey1 is the Bitcoin multi-sig key belonging to the first node, that
143	// was involved in the funding transaction that originally created the channel
144	// that this struct represents.
145	//
146	// NOTE: By having this method to access an attribute, we ensure we only need
147	// to fully deserialize the pubkey if absolutely necessary.
148	func (c ChannelEdgeInfo) BitcoinKey1() (btcec.PublicKey, error) {	×
149	if c.bitcoinKey1 != nil {	×
150	return c.bitcoinKey1, nil	×
151	}	×
152
153	key, err := btcec.ParsePubKey(c.BitcoinKey1Bytes[:])	×
154	if err != nil {	×
155	return nil, err	×
156	}	×
157	c.bitcoinKey1 = key	×
158		×
159	return key, nil	×
160	}
161
162	// BitcoinKey2 is the Bitcoin multi-sig key belonging to the second node, that
163	// was involved in the funding transaction that originally created the channel
164	// that this struct represents.
165	//
166	// NOTE: By having this method to access an attribute, we ensure we only need
167	// to fully deserialize the pubkey if absolutely necessary.
168	func (c ChannelEdgeInfo) BitcoinKey2() (btcec.PublicKey, error) {	×
169	if c.bitcoinKey2 != nil {	×
170	return c.bitcoinKey2, nil	×
171	}	×
172
173	key, err := btcec.ParsePubKey(c.BitcoinKey2Bytes[:])	×
174	if err != nil {	×
175	return nil, err	×
176	}	×
177	c.bitcoinKey2 = key	×
178		×
179	return key, nil	×
180	}
181
182	// OtherNodeKeyBytes returns the node key bytes of the other end of the channel.
183	func (c *ChannelEdgeInfo) OtherNodeKeyBytes(thisNodeKey []byte) (
184	[33]byte, error) {	3,845✔
185		3,845✔
186	switch {	3,845✔
187	case bytes.Equal(c.NodeKey1Bytes[:], thisNodeKey):	1,926✔
188	return c.NodeKey2Bytes, nil	1,926✔
189	case bytes.Equal(c.NodeKey2Bytes[:], thisNodeKey):	1,922✔
190	return c.NodeKey1Bytes, nil	1,922✔
191	default:	×
192	return [33]byte{}, fmt.Errorf("node not participating in " +	×
193	"this channel")	×
194	}
195	}

lightningnetwork / lnd / 19155841408

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