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

36.76

/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"
)

// 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 an opaque byte slice that encodes the set of channel
        // specific features that this channel edge supports.
        Features []byte

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

        // TapscriptRoot is the optional Merkle root of the tapscript tree if
        // this channel is a taproot channel that also commits to a tapscript
        // tree (custom channel).
        TapscriptRoot fn.Option[chainhash.Hash]

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

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