akovalenko/lnd.xprv
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

gossiper_test: split keys into self/remote

Browse Source 
To make it more clear what is local and remote messages, we change to
use `selfKey` only for local messages.
This commit is contained in:
Johan T. Halseth 2021-01-18 13:58:06 +01:00
parent 4268bcc9f9
commit e8f7a11470
No known key found for this signature in database
GPG Key ID: 15BAADA29DA20D26
1 changed files with 100 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

186
discovery/gossiper_test.go
View File

@ -48,17 +48,19 @@ var (
_, _ = testSig.R.SetString("63724406601629180062774974542967536251589935445068131219452686511677818569431", 10) _, _ = testSig.R.SetString("63724406601629180062774974542967536251589935445068131219452686511677818569431", 10)
_, _ = testSig.S.SetString("18801056069249825825291287104931333862866033135609736119018462340006816851118", 10) _, _ = testSig.S.SetString("18801056069249825825291287104931333862866033135609736119018462340006816851118", 10)
selfKeyPriv, _ = btcec.NewPrivateKey(btcec.S256())
selfKeyPub = selfKeyPriv.PubKey()
bitcoinKeyPriv1, _ = btcec.NewPrivateKey(btcec.S256()) bitcoinKeyPriv1, _ = btcec.NewPrivateKey(btcec.S256())
bitcoinKeyPub1 = bitcoinKeyPriv1.PubKey() bitcoinKeyPub1 = bitcoinKeyPriv1.PubKey()
nodeKeyPriv1, _ = btcec.NewPrivateKey(btcec.S256()) remoteKeyPriv1, _ = btcec.NewPrivateKey(btcec.S256())
nodeKeyPub1 = nodeKeyPriv1.PubKey() remoteKeyPub1 = remoteKeyPriv1.PubKey()
bitcoinKeyPriv2, _ = btcec.NewPrivateKey(btcec.S256()) bitcoinKeyPriv2, _ = btcec.NewPrivateKey(btcec.S256())
bitcoinKeyPub2 = bitcoinKeyPriv2.PubKey() bitcoinKeyPub2 = bitcoinKeyPriv2.PubKey()
nodeKeyPriv2, _ = btcec.NewPrivateKey(btcec.S256()) remoteKeyPriv2, _ = btcec.NewPrivateKey(btcec.S256())
nodeKeyPub2 = nodeKeyPriv2.PubKey()
trickleDelay = time.Millisecond * 100 trickleDelay = time.Millisecond * 100
retransmitDelay = time.Hour * 1 retransmitDelay = time.Hour * 1
@ -463,22 +465,30 @@ type annBatch struct {
remoteProofAnn *lnwire.AnnounceSignatures remoteProofAnn *lnwire.AnnounceSignatures
} }
func createAnnouncements(blockHeight uint32) (*annBatch, error) { func createLocalAnnouncements(blockHeight uint32) (*annBatch, error) {
return createAnnouncements(blockHeight, selfKeyPriv, remoteKeyPriv1)
}
func createRemoteAnnouncements(blockHeight uint32) (*annBatch, error) {
return createAnnouncements(blockHeight, remoteKeyPriv1, remoteKeyPriv2)
}
func createAnnouncements(blockHeight uint32, key1, key2 *btcec.PrivateKey) (*annBatch, error) {
var err error var err error
var batch annBatch var batch annBatch
timestamp := testTimestamp timestamp := testTimestamp
batch.nodeAnn1, err = createNodeAnnouncement(nodeKeyPriv1, timestamp) batch.nodeAnn1, err = createNodeAnnouncement(key1, timestamp)
if err != nil { if err != nil {
return nil, err return nil, err
} }
batch.nodeAnn2, err = createNodeAnnouncement(nodeKeyPriv2, timestamp) batch.nodeAnn2, err = createNodeAnnouncement(key2, timestamp)
if err != nil { if err != nil {
return nil, err return nil, err
} }
batch.chanAnn, err = createRemoteChannelAnnouncement(blockHeight) batch.chanAnn, err = createChannelAnnouncement(blockHeight, key1, key2)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -500,14 +510,14 @@ func createAnnouncements(blockHeight uint32) (*annBatch, error) {
} }
batch.chanUpdAnn1, err = createUpdateAnnouncement( batch.chanUpdAnn1, err = createUpdateAnnouncement(
blockHeight, 0, nodeKeyPriv1, timestamp, blockHeight, 0, key1, timestamp,
) )
if err != nil { if err != nil {
return nil, err return nil, err
} }
batch.chanUpdAnn2, err = createUpdateAnnouncement( batch.chanUpdAnn2, err = createUpdateAnnouncement(
blockHeight, 1, nodeKeyPriv2, timestamp, blockHeight, 1, key2, timestamp,
) )
if err != nil { if err != nil {
return nil, err return nil, err
@ -605,6 +615,7 @@ func signUpdate(nodeKey *btcec.PrivateKey, a *lnwire.ChannelUpdate) error {
} }
func createAnnouncementWithoutProof(blockHeight uint32, func createAnnouncementWithoutProof(blockHeight uint32,
key1, key2 *btcec.PublicKey,
extraBytes ...[]byte) *lnwire.ChannelAnnouncement { extraBytes ...[]byte) *lnwire.ChannelAnnouncement {
a := &lnwire.ChannelAnnouncement{ a := &lnwire.ChannelAnnouncement{
@ -615,8 +626,8 @@ func createAnnouncementWithoutProof(blockHeight uint32,
}, },
Features: testFeatures, Features: testFeatures,
} }
copy(a.NodeID1[:], nodeKeyPub1.SerializeCompressed()) copy(a.NodeID1[:], key1.SerializeCompressed())
copy(a.NodeID2[:], nodeKeyPub2.SerializeCompressed()) copy(a.NodeID2[:], key2.SerializeCompressed())
copy(a.BitcoinKey1[:], bitcoinKeyPub1.SerializeCompressed()) copy(a.BitcoinKey1[:], bitcoinKeyPub1.SerializeCompressed())
copy(a.BitcoinKey2[:], bitcoinKeyPub2.SerializeCompressed()) copy(a.BitcoinKey2[:], bitcoinKeyPub2.SerializeCompressed())
if len(extraBytes) == 1 { if len(extraBytes) == 1 {
@ -629,10 +640,16 @@ func createAnnouncementWithoutProof(blockHeight uint32,
func createRemoteChannelAnnouncement(blockHeight uint32, func createRemoteChannelAnnouncement(blockHeight uint32,
extraBytes ...[]byte) (*lnwire.ChannelAnnouncement, error) { extraBytes ...[]byte) (*lnwire.ChannelAnnouncement, error) {
a := createAnnouncementWithoutProof(blockHeight, extraBytes...) return createChannelAnnouncement(blockHeight, remoteKeyPriv1, remoteKeyPriv2, extraBytes...)
}
pub := nodeKeyPriv1.PubKey() func createChannelAnnouncement(blockHeight uint32, key1, key2 *btcec.PrivateKey,
signer := mock.SingleSigner{Privkey: nodeKeyPriv1} extraBytes ...[]byte) (*lnwire.ChannelAnnouncement, error) {
a := createAnnouncementWithoutProof(blockHeight, key1.PubKey(), key2.PubKey(), extraBytes...)
pub := key1.PubKey()
signer := mock.SingleSigner{Privkey: key1}
sig, err := netann.SignAnnouncement(&signer, pub, a) sig, err := netann.SignAnnouncement(&signer, pub, a)
if err != nil { if err != nil {
return nil, err return nil, err
@ -642,8 +659,8 @@ func createRemoteChannelAnnouncement(blockHeight uint32,
return nil, err return nil, err
} }
pub = nodeKeyPriv2.PubKey() pub = key2.PubKey()
signer = mock.SingleSigner{Privkey: nodeKeyPriv2} signer = mock.SingleSigner{Privkey: key2}
sig, err = netann.SignAnnouncement(&signer, pub, a) sig, err = netann.SignAnnouncement(&signer, pub, a)
if err != nil { if err != nil {
return nil, err return nil, err
@ -744,12 +761,12 @@ func createTestCtx(startHeight uint32) (*testCtx, func(), error) {
RotateTicker: ticker.NewForce(DefaultSyncerRotationInterval), RotateTicker: ticker.NewForce(DefaultSyncerRotationInterval),
HistoricalSyncTicker: ticker.NewForce(DefaultHistoricalSyncInterval), HistoricalSyncTicker: ticker.NewForce(DefaultHistoricalSyncInterval),
NumActiveSyncers: 3, NumActiveSyncers: 3,
AnnSigner: &mock.SingleSigner{Privkey: nodeKeyPriv1}, AnnSigner: &mock.SingleSigner{Privkey: selfKeyPriv},
SubBatchDelay: time.Second * 5, SubBatchDelay: time.Second * 5,
MinimumBatchSize: 10, MinimumBatchSize: 10,
MaxChannelUpdateBurst: DefaultMaxChannelUpdateBurst, MaxChannelUpdateBurst: DefaultMaxChannelUpdateBurst,
ChannelUpdateInterval: DefaultChannelUpdateInterval, ChannelUpdateInterval: DefaultChannelUpdateInterval,
}, nodeKeyPub1) }, selfKeyPub)
if err := gossiper.Start(); err != nil { if err := gossiper.Start(); err != nil {
cleanUpDb() cleanUpDb()
@ -792,7 +809,7 @@ func TestProcessAnnouncement(t *testing.T) {
} }
} }
nodePeer := &mockPeer{nodeKeyPriv1.PubKey(), nil, nil} nodePeer := &mockPeer{remoteKeyPriv1.PubKey(), nil, nil}
// First, we'll craft a valid remote channel announcement and send it to // First, we'll craft a valid remote channel announcement and send it to
// the gossiper so that it can be processed. // the gossiper so that it can be processed.
@ -825,7 +842,7 @@ func TestProcessAnnouncement(t *testing.T) {
// We'll then craft the channel policy of the remote party and also send // We'll then craft the channel policy of the remote party and also send
// it to the gossiper. // it to the gossiper.
ua, err := createUpdateAnnouncement(0, 0, nodeKeyPriv1, timestamp) ua, err := createUpdateAnnouncement(0, 0, remoteKeyPriv1, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create update announcement: %v", err) t.Fatalf("can't create update announcement: %v", err)
} }
@ -852,7 +869,7 @@ func TestProcessAnnouncement(t *testing.T) {
} }
// Finally, we'll craft the remote party's node announcement. // Finally, we'll craft the remote party's node announcement.
na, err := createNodeAnnouncement(nodeKeyPriv1, timestamp) na, err := createNodeAnnouncement(remoteKeyPriv1, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create node announcement: %v", err) t.Fatalf("can't create node announcement: %v", err)
} }
@ -894,12 +911,12 @@ func TestPrematureAnnouncement(t *testing.T) {
} }
defer cleanup() defer cleanup()
_, err = createNodeAnnouncement(nodeKeyPriv1, timestamp) _, err = createNodeAnnouncement(remoteKeyPriv1, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create node announcement: %v", err) t.Fatalf("can't create node announcement: %v", err)
} }
nodePeer := &mockPeer{nodeKeyPriv1.PubKey(), nil, nil} nodePeer := &mockPeer{remoteKeyPriv1.PubKey(), nil, nil}
// Pretending that we receive the valid channel announcement from // Pretending that we receive the valid channel announcement from
// remote side, but block height of this announcement is greater than // remote side, but block height of this announcement is greater than
@ -923,7 +940,7 @@ func TestPrematureAnnouncement(t *testing.T) {
// Pretending that we receive the valid channel update announcement from // Pretending that we receive the valid channel update announcement from
// remote side, but block height of this announcement is greater than // remote side, but block height of this announcement is greater than
// highest known to us, so it should be rejected. // highest known to us, so it should be rejected.
ua, err := createUpdateAnnouncement(1, 0, nodeKeyPriv1, timestamp) ua, err := createUpdateAnnouncement(1, 0, remoteKeyPriv1, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create update announcement: %v", err) t.Fatalf("can't create update announcement: %v", err)
} }
@ -964,7 +981,7 @@ func TestSignatureAnnouncementLocalFirst(t *testing.T) {
} }
} }
batch, err := createAnnouncements(0) batch, err := createLocalAnnouncements(0)
if err != nil { if err != nil {
t.Fatalf("can't generate announcements: %v", err) t.Fatalf("can't generate announcements: %v", err)
} }
@ -1157,7 +1174,7 @@ func TestOrphanSignatureAnnouncement(t *testing.T) {
} }
} }
batch, err := createAnnouncements(0) batch, err := createLocalAnnouncements(0)
if err != nil { if err != nil {
t.Fatalf("can't generate announcements: %v", err) t.Fatalf("can't generate announcements: %v", err)
} }
@ -1347,7 +1364,7 @@ func TestSignatureAnnouncementRetryAtStartup(t *testing.T) {
} }
defer cleanup() defer cleanup()
batch, err := createAnnouncements(0) batch, err := createLocalAnnouncements(0)
if err != nil { if err != nil {
t.Fatalf("can't generate announcements: %v", err) t.Fatalf("can't generate announcements: %v", err)
} }
@ -1561,7 +1578,7 @@ func TestSignatureAnnouncementFullProofWhenRemoteProof(t *testing.T) {
} }
defer cleanup() defer cleanup()
batch, err := createAnnouncements(0) batch, err := createLocalAnnouncements(0)
if err != nil { if err != nil {
t.Fatalf("can't generate announcements: %v", err) t.Fatalf("can't generate announcements: %v", err)
} }
@ -1813,7 +1830,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
// Next, we'll ensure that channel update announcements are properly // Next, we'll ensure that channel update announcements are properly
// stored and de-duplicated. We do this by creating two updates // stored and de-duplicated. We do this by creating two updates
// announcements with the same short ID and flag. // announcements with the same short ID and flag.
ua, err := createUpdateAnnouncement(0, 0, nodeKeyPriv1, timestamp) ua, err := createUpdateAnnouncement(0, 0, remoteKeyPriv1, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create update announcement: %v", err) t.Fatalf("can't create update announcement: %v", err)
} }
@ -1828,7 +1845,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
// Adding the very same announcement shouldn't cause an increase in the // Adding the very same announcement shouldn't cause an increase in the
// number of ChannelUpdate announcements stored. // number of ChannelUpdate announcements stored.
ua2, err := createUpdateAnnouncement(0, 0, nodeKeyPriv1, timestamp) ua2, err := createUpdateAnnouncement(0, 0, remoteKeyPriv1, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create update announcement: %v", err) t.Fatalf("can't create update announcement: %v", err)
} }
@ -1843,7 +1860,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
// Adding an announcement with a later timestamp should replace the // Adding an announcement with a later timestamp should replace the
// stored one. // stored one.
ua3, err := createUpdateAnnouncement(0, 0, nodeKeyPriv1, timestamp+1) ua3, err := createUpdateAnnouncement(0, 0, remoteKeyPriv1, timestamp+1)
if err != nil { if err != nil {
t.Fatalf("can't create update announcement: %v", err) t.Fatalf("can't create update announcement: %v", err)
} }
@ -1877,7 +1894,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
// Adding a channel update with an earlier timestamp should NOT // Adding a channel update with an earlier timestamp should NOT
// replace the one stored. // replace the one stored.
ua4, err := createUpdateAnnouncement(0, 0, nodeKeyPriv1, timestamp) ua4, err := createUpdateAnnouncement(0, 0, remoteKeyPriv1, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create update announcement: %v", err) t.Fatalf("can't create update announcement: %v", err)
} }
@ -1893,7 +1910,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
// Next well ensure that node announcements are properly de-duplicated. // Next well ensure that node announcements are properly de-duplicated.
// We'll first add a single instance with a node's private key. // We'll first add a single instance with a node's private key.
na, err := createNodeAnnouncement(nodeKeyPriv1, timestamp) na, err := createNodeAnnouncement(remoteKeyPriv1, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create node announcement: %v", err) t.Fatalf("can't create node announcement: %v", err)
} }
@ -1907,7 +1924,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
} }
// We'll now add another node to the batch. // We'll now add another node to the batch.
na2, err := createNodeAnnouncement(nodeKeyPriv2, timestamp) na2, err := createNodeAnnouncement(remoteKeyPriv2, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create node announcement: %v", err) t.Fatalf("can't create node announcement: %v", err)
} }
@ -1922,7 +1939,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
// Adding a new instance of the _same_ node shouldn't increase the size // Adding a new instance of the _same_ node shouldn't increase the size
// of the node ann batch. // of the node ann batch.
na3, err := createNodeAnnouncement(nodeKeyPriv2, timestamp) na3, err := createNodeAnnouncement(remoteKeyPriv2, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create node announcement: %v", err) t.Fatalf("can't create node announcement: %v", err)
} }
@ -1937,7 +1954,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
// Ensure that node announcement with different pointer to same public // Ensure that node announcement with different pointer to same public
// key is still de-duplicated. // key is still de-duplicated.
newNodeKeyPointer := nodeKeyPriv2 newNodeKeyPointer := remoteKeyPriv2
na4, err := createNodeAnnouncement(newNodeKeyPointer, timestamp) na4, err := createNodeAnnouncement(newNodeKeyPointer, timestamp)
if err != nil { if err != nil {
t.Fatalf("can't create node announcement: %v", err) t.Fatalf("can't create node announcement: %v", err)
@ -1953,7 +1970,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
// Ensure that node announcement with increased timestamp replaces // Ensure that node announcement with increased timestamp replaces
// what is currently stored. // what is currently stored.
na5, err := createNodeAnnouncement(nodeKeyPriv2, timestamp+1) na5, err := createNodeAnnouncement(remoteKeyPriv2, timestamp+1)
if err != nil { if err != nil {
t.Fatalf("can't create node announcement: %v", err) t.Fatalf("can't create node announcement: %v", err)
} }
@ -1965,7 +1982,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
if len(announcements.nodeAnnouncements) != 2 { if len(announcements.nodeAnnouncements) != 2 {
t.Fatal("node announcement not replaced in batch") t.Fatal("node announcement not replaced in batch")
} }
nodeID := route.NewVertex(nodeKeyPriv2.PubKey()) nodeID := route.NewVertex(remoteKeyPriv2.PubKey())
stored, ok := announcements.nodeAnnouncements[nodeID] stored, ok := announcements.nodeAnnouncements[nodeID]
if !ok { if !ok {
t.Fatalf("node announcement not found in batch") t.Fatalf("node announcement not found in batch")
@ -2039,8 +2056,8 @@ func TestForwardPrivateNodeAnnouncement(t *testing.T) {
// We'll start off by processing a channel announcement without a proof // We'll start off by processing a channel announcement without a proof
// (i.e., an unadvertised channel), followed by a node announcement for // (i.e., an unadvertised channel), followed by a node announcement for
// this same channel announcement. // this same channel announcement.
chanAnn := createAnnouncementWithoutProof(startingHeight - 2) chanAnn := createAnnouncementWithoutProof(startingHeight-2, selfKeyPub, remoteKeyPub1)
pubKey := nodeKeyPriv1.PubKey() pubKey := remoteKeyPriv1.PubKey()
select { select {
case err := <-ctx.gossiper.ProcessLocalAnnouncement(chanAnn): case err := <-ctx.gossiper.ProcessLocalAnnouncement(chanAnn):
@ -2059,7 +2076,7 @@ func TestForwardPrivateNodeAnnouncement(t *testing.T) {
case <-time.After(2 * trickleDelay): case <-time.After(2 * trickleDelay):
} }
nodeAnn, err := createNodeAnnouncement(nodeKeyPriv1, timestamp) nodeAnn, err := createNodeAnnouncement(remoteKeyPriv1, timestamp)
if err != nil { if err != nil {
t.Fatalf("unable to create node announcement: %v", err) t.Fatalf("unable to create node announcement: %v", err)
} }
@ -2108,7 +2125,7 @@ func TestForwardPrivateNodeAnnouncement(t *testing.T) {
// We'll recreate the NodeAnnouncement with an updated timestamp to // We'll recreate the NodeAnnouncement with an updated timestamp to
// prevent a stale update. The NodeAnnouncement should now be forwarded. // prevent a stale update. The NodeAnnouncement should now be forwarded.
nodeAnn, err = createNodeAnnouncement(nodeKeyPriv1, timestamp+1) nodeAnn, err = createNodeAnnouncement(remoteKeyPriv1, timestamp+1)
if err != nil { if err != nil {
t.Fatalf("unable to create node announcement: %v", err) t.Fatalf("unable to create node announcement: %v", err)
} }
@ -2142,11 +2159,11 @@ func TestRejectZombieEdge(t *testing.T) {
} }
defer cleanup() defer cleanup()
batch, err := createAnnouncements(0) batch, err := createRemoteAnnouncements(0)
if err != nil { if err != nil {
t.Fatalf("unable to create announcements: %v", err) t.Fatalf("unable to create announcements: %v", err)
} }
remotePeer := &mockPeer{pk: nodeKeyPriv2.PubKey()} remotePeer := &mockPeer{pk: remoteKeyPriv2.PubKey()}
// processAnnouncements is a helper closure we'll use to test that we // processAnnouncements is a helper closure we'll use to test that we
// properly process/reject announcements based on whether they're for a // properly process/reject announcements based on whether they're for a
@ -2248,15 +2265,12 @@ func TestProcessZombieEdgeNowLive(t *testing.T) {
} }
defer cleanup() defer cleanup()
batch, err := createAnnouncements(0) batch, err := createRemoteAnnouncements(0)
if err != nil { if err != nil {
t.Fatalf("unable to create announcements: %v", err) t.Fatalf("unable to create announcements: %v", err)
} }
localPrivKey := nodeKeyPriv1 remotePeer := &mockPeer{pk: remoteKeyPriv1.PubKey()}
remotePrivKey := nodeKeyPriv2
remotePeer := &mockPeer{pk: remotePrivKey.PubKey()}
// processAnnouncement is a helper closure we'll use to ensure an // processAnnouncement is a helper closure we'll use to ensure an
// announcement is properly processed/rejected based on whether the edge // announcement is properly processed/rejected based on whether the edge
@ -2305,7 +2319,7 @@ func TestProcessZombieEdgeNowLive(t *testing.T) {
// past to consider it a zombie. // past to consider it a zombie.
zombieTimestamp := time.Now().Add(-routing.DefaultChannelPruneExpiry) zombieTimestamp := time.Now().Add(-routing.DefaultChannelPruneExpiry)
batch.chanUpdAnn2.Timestamp = uint32(zombieTimestamp.Unix()) batch.chanUpdAnn2.Timestamp = uint32(zombieTimestamp.Unix())
if err := signUpdate(remotePrivKey, batch.chanUpdAnn2); err != nil { if err := signUpdate(remoteKeyPriv2, batch.chanUpdAnn2); err != nil {
t.Fatalf("unable to sign update with new timestamp: %v", err) t.Fatalf("unable to sign update with new timestamp: %v", err)
} }
@ -2328,9 +2342,9 @@ func TestProcessZombieEdgeNowLive(t *testing.T) {
// allow the channel update to be processed even though it is still // allow the channel update to be processed even though it is still
// marked as a zombie within the index, since it is a fresh new update. // marked as a zombie within the index, since it is a fresh new update.
// This won't work however since we'll sign it with the wrong private // This won't work however since we'll sign it with the wrong private
// key (local rather than remote). // key (remote key 1 rather than remote key 2).
batch.chanUpdAnn2.Timestamp = uint32(time.Now().Unix()) batch.chanUpdAnn2.Timestamp = uint32(time.Now().Unix())
if err := signUpdate(localPrivKey, batch.chanUpdAnn2); err != nil { if err := signUpdate(remoteKeyPriv1, batch.chanUpdAnn2); err != nil {
t.Fatalf("unable to sign update with new timestamp: %v", err) t.Fatalf("unable to sign update with new timestamp: %v", err)
} }
@ -2339,7 +2353,7 @@ func TestProcessZombieEdgeNowLive(t *testing.T) {
// Signing it with the correct private key should allow it to be // Signing it with the correct private key should allow it to be
// processed. // processed.
if err := signUpdate(remotePrivKey, batch.chanUpdAnn2); err != nil { if err := signUpdate(remoteKeyPriv2, batch.chanUpdAnn2); err != nil {
t.Fatalf("unable to sign update with new timestamp: %v", err) t.Fatalf("unable to sign update with new timestamp: %v", err)
} }
@ -2394,7 +2408,7 @@ func TestReceiveRemoteChannelUpdateFirst(t *testing.T) {
} }
defer cleanup() defer cleanup()
batch, err := createAnnouncements(0) batch, err := createLocalAnnouncements(0)
if err != nil { if err != nil {
t.Fatalf("can't generate announcements: %v", err) t.Fatalf("can't generate announcements: %v", err)
} }
@ -2602,7 +2616,7 @@ func TestExtraDataChannelAnnouncementValidation(t *testing.T) {
} }
defer cleanup() defer cleanup()
remotePeer := &mockPeer{nodeKeyPriv1.PubKey(), nil, nil} remotePeer := &mockPeer{remoteKeyPriv1.PubKey(), nil, nil}
// We'll now create an announcement that contains an extra set of bytes // We'll now create an announcement that contains an extra set of bytes
// that we don't know of ourselves, but should still include in the // that we don't know of ourselves, but should still include in the
@ -2638,7 +2652,7 @@ func TestExtraDataChannelUpdateValidation(t *testing.T) {
} }
defer cleanup() defer cleanup()
remotePeer := &mockPeer{nodeKeyPriv1.PubKey(), nil, nil} remotePeer := &mockPeer{remoteKeyPriv1.PubKey(), nil, nil}
// In this scenario, we'll create two announcements, one regular // In this scenario, we'll create two announcements, one regular
// channel announcement, and another channel update announcement, that // channel announcement, and another channel update announcement, that
@ -2648,14 +2662,14 @@ func TestExtraDataChannelUpdateValidation(t *testing.T) {
t.Fatalf("unable to create chan ann: %v", err) t.Fatalf("unable to create chan ann: %v", err)
} }
chanUpdAnn1, err := createUpdateAnnouncement( chanUpdAnn1, err := createUpdateAnnouncement(
0, 0, nodeKeyPriv1, timestamp, 0, 0, remoteKeyPriv1, timestamp,
[]byte("must also validate"), []byte("must also validate"),
) )
if err != nil { if err != nil {
t.Fatalf("unable to create chan up: %v", err) t.Fatalf("unable to create chan up: %v", err)
} }
chanUpdAnn2, err := createUpdateAnnouncement( chanUpdAnn2, err := createUpdateAnnouncement(
0, 1, nodeKeyPriv2, timestamp, 0, 1, remoteKeyPriv2, timestamp,
[]byte("must also validate"), []byte("must also validate"),
) )
if err != nil { if err != nil {
@ -2704,14 +2718,14 @@ func TestExtraDataNodeAnnouncementValidation(t *testing.T) {
} }
defer cleanup() defer cleanup()
remotePeer := &mockPeer{nodeKeyPriv1.PubKey(), nil, nil} remotePeer := &mockPeer{remoteKeyPriv1.PubKey(), nil, nil}
timestamp := testTimestamp timestamp := testTimestamp
// We'll create a node announcement that includes a set of opaque data // We'll create a node announcement that includes a set of opaque data
// which we don't know of, but will store anyway in order to ensure // which we don't know of, but will store anyway in order to ensure
// upgrades can flow smoothly in the future. // upgrades can flow smoothly in the future.
nodeAnn, err := createNodeAnnouncement( nodeAnn, err := createNodeAnnouncement(
nodeKeyPriv1, timestamp, []byte("gotta validate"), remoteKeyPriv1, timestamp, []byte("gotta validate"),
) )
if err != nil { if err != nil {
t.Fatalf("can't create node announcement: %v", err) t.Fatalf("can't create node announcement: %v", err)
@ -2779,7 +2793,7 @@ func TestRetransmit(t *testing.T) {
} }
defer cleanup() defer cleanup()
batch, err := createAnnouncements(0) batch, err := createLocalAnnouncements(0)
if err != nil { if err != nil {
t.Fatalf("can't generate announcements: %v", err) t.Fatalf("can't generate announcements: %v", err)
} }
@ -2891,7 +2905,7 @@ func TestNodeAnnouncementNoChannels(t *testing.T) {
} }
defer cleanup() defer cleanup()
batch, err := createAnnouncements(0) batch, err := createRemoteAnnouncements(0)
if err != nil { if err != nil {
t.Fatalf("can't generate announcements: %v", err) t.Fatalf("can't generate announcements: %v", err)
} }
@ -2996,7 +3010,7 @@ func TestOptionalFieldsChannelUpdateValidation(t *testing.T) {
chanUpdateHeight := uint32(0) chanUpdateHeight := uint32(0)
timestamp := uint32(123456) timestamp := uint32(123456)
nodePeer := &mockPeer{nodeKeyPriv1.PubKey(), nil, nil} nodePeer := &mockPeer{remoteKeyPriv1.PubKey(), nil, nil}
// In this scenario, we'll test whether the message flags field in a channel // In this scenario, we'll test whether the message flags field in a channel
// update is properly handled. // update is properly handled.
@ -3016,14 +3030,14 @@ func TestOptionalFieldsChannelUpdateValidation(t *testing.T) {
// The first update should fail from an invalid max HTLC field, which is // The first update should fail from an invalid max HTLC field, which is
// less than the min HTLC. // less than the min HTLC.
chanUpdAnn, err := createUpdateAnnouncement(0, 0, nodeKeyPriv1, timestamp) chanUpdAnn, err := createUpdateAnnouncement(0, 0, remoteKeyPriv1, timestamp)
if err != nil { if err != nil {
t.Fatalf("unable to create channel update: %v", err) t.Fatalf("unable to create channel update: %v", err)
} }
chanUpdAnn.HtlcMinimumMsat = 5000 chanUpdAnn.HtlcMinimumMsat = 5000
chanUpdAnn.HtlcMaximumMsat = 4000 chanUpdAnn.HtlcMaximumMsat = 4000
if err := signUpdate(nodeKeyPriv1, chanUpdAnn); err != nil { if err := signUpdate(remoteKeyPriv1, chanUpdAnn); err != nil {
t.Fatalf("unable to sign channel update: %v", err) t.Fatalf("unable to sign channel update: %v", err)
} }
@ -3040,7 +3054,7 @@ func TestOptionalFieldsChannelUpdateValidation(t *testing.T) {
// the max HTLC field is 0. // the max HTLC field is 0.
chanUpdAnn.HtlcMinimumMsat = 0 chanUpdAnn.HtlcMinimumMsat = 0
chanUpdAnn.HtlcMaximumMsat = 0 chanUpdAnn.HtlcMaximumMsat = 0
if err := signUpdate(nodeKeyPriv1, chanUpdAnn); err != nil { if err := signUpdate(remoteKeyPriv1, chanUpdAnn); err != nil {
t.Fatalf("unable to sign channel update: %v", err) t.Fatalf("unable to sign channel update: %v", err)
} }
@ -3056,7 +3070,7 @@ func TestOptionalFieldsChannelUpdateValidation(t *testing.T) {
// The final update should succeed, since setting the flag 0 means the // The final update should succeed, since setting the flag 0 means the
// nonsense max_htlc field will just be ignored. // nonsense max_htlc field will just be ignored.
chanUpdAnn.MessageFlags = 0 chanUpdAnn.MessageFlags = 0
if err := signUpdate(nodeKeyPriv1, chanUpdAnn); err != nil { if err := signUpdate(remoteKeyPriv1, chanUpdAnn); err != nil {
t.Fatalf("unable to sign channel update: %v", err) t.Fatalf("unable to sign channel update: %v", err)
} }
@ -3083,7 +3097,7 @@ func TestSendChannelUpdateReliably(t *testing.T) {
} }
defer cleanup() defer cleanup()
batch, err := createAnnouncements(0) batch, err := createLocalAnnouncements(0)
if err != nil { if err != nil {
t.Fatalf("can't generate announcements: %v", err) t.Fatalf("can't generate announcements: %v", err)
} }
@ -3208,7 +3222,7 @@ func TestSendChannelUpdateReliably(t *testing.T) {
// Now that the remote peer is offline, we'll send a new channel update. // Now that the remote peer is offline, we'll send a new channel update.
batch.chanUpdAnn1.Timestamp++ batch.chanUpdAnn1.Timestamp++
if err := signUpdate(nodeKeyPriv1, batch.chanUpdAnn1); err != nil { if err := signUpdate(selfKeyPriv, batch.chanUpdAnn1); err != nil {
t.Fatalf("unable to sign new channel update: %v", err) t.Fatalf("unable to sign new channel update: %v", err)
} }
@ -3304,7 +3318,7 @@ func TestSendChannelUpdateReliably(t *testing.T) {
newChannelUpdate := &lnwire.ChannelUpdate{} newChannelUpdate := &lnwire.ChannelUpdate{}
*newChannelUpdate = *staleChannelUpdate *newChannelUpdate = *staleChannelUpdate
newChannelUpdate.Timestamp++ newChannelUpdate.Timestamp++
if err := signUpdate(nodeKeyPriv1, newChannelUpdate); err != nil { if err := signUpdate(selfKeyPriv, newChannelUpdate); err != nil {
t.Fatalf("unable to sign new channel update: %v", err) t.Fatalf("unable to sign new channel update: %v", err)
} }
@ -3459,7 +3473,7 @@ func TestPropagateChanPolicyUpdate(t *testing.T) {
const numChannels = 3 const numChannels = 3
channelsToAnnounce := make([]*annBatch, 0, numChannels) channelsToAnnounce := make([]*annBatch, 0, numChannels)
for i := 0; i < numChannels; i++ { for i := 0; i < numChannels; i++ {
newChan, err := createAnnouncements(uint32(i + 1)) newChan, err := createLocalAnnouncements(uint32(i + 1))
if err != nil { if err != nil {
t.Fatalf("unable to make new channel ann: %v", err) t.Fatalf("unable to make new channel ann: %v", err)
} }
@ -3467,7 +3481,7 @@ func TestPropagateChanPolicyUpdate(t *testing.T) {
channelsToAnnounce = append(channelsToAnnounce, newChan) channelsToAnnounce = append(channelsToAnnounce, newChan)
} }
remoteKey := nodeKeyPriv2.PubKey() remoteKey := remoteKeyPriv1.PubKey()
sentMsgs := make(chan lnwire.Message, 10) sentMsgs := make(chan lnwire.Message, 10)
remotePeer := &mockPeer{remoteKey, sentMsgs, ctx.gossiper.quit} remotePeer := &mockPeer{remoteKey, sentMsgs, ctx.gossiper.quit}
@ -3637,8 +3651,8 @@ func TestProcessChannelAnnouncementOptionalMsgFields(t *testing.T) {
} }
defer cleanup() defer cleanup()
chanAnn1 := createAnnouncementWithoutProof(100) chanAnn1 := createAnnouncementWithoutProof(100, selfKeyPub, remoteKeyPub1)
chanAnn2 := createAnnouncementWithoutProof(101) chanAnn2 := createAnnouncementWithoutProof(101, selfKeyPub, remoteKeyPub1)
// assertOptionalMsgFields is a helper closure that ensures the optional // assertOptionalMsgFields is a helper closure that ensures the optional
// message fields were set as intended. // message fields were set as intended.
@ -3809,7 +3823,7 @@ func TestBroadcastAnnsAfterGraphSynced(t *testing.T) {
t.Helper() t.Helper()
nodePeer := &mockPeer{nodeKeyPriv1.PubKey(), nil, nil} nodePeer := &mockPeer{remoteKeyPriv1.PubKey(), nil, nil}
var errChan chan error var errChan chan error
if isRemote { if isRemote {
errChan = ctx.gossiper.ProcessRemoteAnnouncement( errChan = ctx.gossiper.ProcessRemoteAnnouncement(
@ -3851,7 +3865,7 @@ func TestBroadcastAnnsAfterGraphSynced(t *testing.T) {
// A local channel announcement should be broadcast though, regardless // A local channel announcement should be broadcast though, regardless
// of whether we've synced our graph or not. // of whether we've synced our graph or not.
chanUpd, err := createUpdateAnnouncement(0, 0, nodeKeyPriv1, 1) chanUpd, err := createUpdateAnnouncement(0, 0, remoteKeyPriv1, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create channel announcement: %v", err) t.Fatalf("unable to create channel announcement: %v", err)
} }
@ -3891,10 +3905,10 @@ func TestRateLimitChannelUpdates(t *testing.T) {
// We'll create a batch of signed announcements, including updates for // We'll create a batch of signed announcements, including updates for
// both sides, for a channel and process them. They should all be // both sides, for a channel and process them. They should all be
// forwarded as this is our first time learning about the channel. // forwarded as this is our first time learning about the channel.
batch, err := createAnnouncements(blockHeight) batch, err := createRemoteAnnouncements(blockHeight)
require.NoError(t, err) require.NoError(t, err)
nodePeer1 := &mockPeer{nodeKeyPriv1.PubKey(), nil, nil} nodePeer1 := &mockPeer{remoteKeyPriv1.PubKey(), nil, nil}
select { select {
case err := <-ctx.gossiper.ProcessRemoteAnnouncement( case err := <-ctx.gossiper.ProcessRemoteAnnouncement(
batch.chanAnn, nodePeer1, batch.chanAnn, nodePeer1,
@ -3913,7 +3927,7 @@ func TestRateLimitChannelUpdates(t *testing.T) {
t.Fatal("remote announcement not processed") t.Fatal("remote announcement not processed")
} }
nodePeer2 := &mockPeer{nodeKeyPriv2.PubKey(), nil, nil} nodePeer2 := &mockPeer{remoteKeyPriv2.PubKey(), nil, nil}
select { select {
case err := <-ctx.gossiper.ProcessRemoteAnnouncement( case err := <-ctx.gossiper.ProcessRemoteAnnouncement(
batch.chanUpdAnn2, nodePeer2, batch.chanUpdAnn2, nodePeer2,
@ -3968,7 +3982,7 @@ func TestRateLimitChannelUpdates(t *testing.T) {
// our rebroadcast interval. // our rebroadcast interval.
rateLimitKeepAliveUpdate := *batch.chanUpdAnn1 rateLimitKeepAliveUpdate := *batch.chanUpdAnn1
rateLimitKeepAliveUpdate.Timestamp++ rateLimitKeepAliveUpdate.Timestamp++
require.NoError(t, signUpdate(nodeKeyPriv1, &rateLimitKeepAliveUpdate)) require.NoError(t, signUpdate(remoteKeyPriv1, &rateLimitKeepAliveUpdate))
assertRateLimit(&rateLimitKeepAliveUpdate, nodePeer1, true) assertRateLimit(&rateLimitKeepAliveUpdate, nodePeer1, true)
keepAliveUpdate := *batch.chanUpdAnn1 keepAliveUpdate := *batch.chanUpdAnn1
@ -3976,7 +3990,7 @@ func TestRateLimitChannelUpdates(t *testing.T) {
time.Unix(int64(batch.chanUpdAnn1.Timestamp), 0). time.Unix(int64(batch.chanUpdAnn1.Timestamp), 0).
Add(ctx.gossiper.cfg.RebroadcastInterval).Unix(), Add(ctx.gossiper.cfg.RebroadcastInterval).Unix(),
) )
require.NoError(t, signUpdate(nodeKeyPriv1, &keepAliveUpdate)) require.NoError(t, signUpdate(remoteKeyPriv1, &keepAliveUpdate))
assertRateLimit(&keepAliveUpdate, nodePeer1, false) assertRateLimit(&keepAliveUpdate, nodePeer1, false)
// Then, we'll move on to the non keep alive cases. // Then, we'll move on to the non keep alive cases.
@ -3988,7 +4002,7 @@ func TestRateLimitChannelUpdates(t *testing.T) {
for i := uint32(0); i < uint32(ctx.gossiper.cfg.MaxChannelUpdateBurst); i++ { for i := uint32(0); i < uint32(ctx.gossiper.cfg.MaxChannelUpdateBurst); i++ {
updateSameDirection.Timestamp++ updateSameDirection.Timestamp++
updateSameDirection.BaseFee++ updateSameDirection.BaseFee++
require.NoError(t, signUpdate(nodeKeyPriv1, &updateSameDirection)) require.NoError(t, signUpdate(remoteKeyPriv1, &updateSameDirection))
assertRateLimit(&updateSameDirection, nodePeer1, false) assertRateLimit(&updateSameDirection, nodePeer1, false)
} }
@ -3996,14 +4010,14 @@ func TestRateLimitChannelUpdates(t *testing.T) {
// has been reached and we haven't ticked at the next interval yet. // has been reached and we haven't ticked at the next interval yet.
updateSameDirection.Timestamp++ updateSameDirection.Timestamp++
updateSameDirection.BaseFee++ updateSameDirection.BaseFee++
require.NoError(t, signUpdate(nodeKeyPriv1, &updateSameDirection)) require.NoError(t, signUpdate(remoteKeyPriv1, &updateSameDirection))
assertRateLimit(&updateSameDirection, nodePeer1, true) assertRateLimit(&updateSameDirection, nodePeer1, true)
// An update for the other direction should not be rate limited. // An update for the other direction should not be rate limited.
updateDiffDirection := *batch.chanUpdAnn2 updateDiffDirection := *batch.chanUpdAnn2
updateDiffDirection.Timestamp++ updateDiffDirection.Timestamp++
updateDiffDirection.BaseFee++ updateDiffDirection.BaseFee++
require.NoError(t, signUpdate(nodeKeyPriv2, &updateDiffDirection)) require.NoError(t, signUpdate(remoteKeyPriv2, &updateDiffDirection))
assertRateLimit(&updateDiffDirection, nodePeer2, false) assertRateLimit(&updateDiffDirection, nodePeer2, false)
// Wait for the next interval to tick. Since we've only waited for one, // Wait for the next interval to tick. Since we've only waited for one,
@ -4012,7 +4026,7 @@ func TestRateLimitChannelUpdates(t *testing.T) {
for i := 0; i < ctx.gossiper.cfg.MaxChannelUpdateBurst; i++ { for i := 0; i < ctx.gossiper.cfg.MaxChannelUpdateBurst; i++ {
updateSameDirection.Timestamp++ updateSameDirection.Timestamp++
updateSameDirection.BaseFee++ updateSameDirection.BaseFee++
require.NoError(t, signUpdate(nodeKeyPriv1, &updateSameDirection)) require.NoError(t, signUpdate(remoteKeyPriv1, &updateSameDirection))
shouldRateLimit := i != 0 shouldRateLimit := i != 0
assertRateLimit(&updateSameDirection, nodePeer1, shouldRateLimit) assertRateLimit(&updateSameDirection, nodePeer1, shouldRateLimit)