mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-11-19 17:16:09 +00:00
[litep2p](https://github.com/altonen/litep2p) is a libp2p-compatible P2P networking library. It supports all of the features of `rust-libp2p` that are currently being utilized by Polkadot SDK. Compared to `rust-libp2p`, `litep2p` has a quite different architecture which is why the new `litep2p` network backend is only able to use a little of the existing code in `sc-network`. The design has been mainly influenced by how we'd wish to structure our networking-related code in Polkadot SDK: independent higher-levels protocols directly communicating with the network over links that support bidirectional backpressure. A good example would be `NotificationHandle`/`RequestResponseHandle` abstractions which allow, e.g., `SyncingEngine` to directly communicate with peers to announce/request blocks. I've tried running `polkadot --network-backend litep2p` with a few different peer configurations and there is a noticeable reduction in networking CPU usage. For high load (`--out-peers 200`), networking CPU usage goes down from ~110% to ~30% (80 pp) and for normal load (`--out-peers 40`), the usage goes down from ~55% to ~18% (37 pp). These should not be taken as final numbers because: a) there are still some low-hanging optimization fruits, such as enabling [receive window auto-tuning](https://github.com/libp2p/rust-yamux/pull/176), integrating `Peerset` more closely with `litep2p` or improving memory usage of the WebSocket transport b) fixing bugs/instabilities that incorrectly cause `litep2p` to do less work will increase the networking CPU usage c) verification in a more diverse set of tests/conditions is needed Nevertheless, these numbers should give an early estimate for CPU usage of the new networking backend. This PR consists of three separate changes: * introduce a generic `PeerId` (wrapper around `Multihash`) so that we don't have use `NetworkService::PeerId` in every part of the code that uses a `PeerId` * introduce `NetworkBackend` trait, implement it for the libp2p network stack and make Polkadot SDK generic over `NetworkBackend` * implement `NetworkBackend` for litep2p The new library should be considered experimental which is why `rust-libp2p` will remain as the default option for the time being. This PR currently depends on the master branch of `litep2p` but I'll cut a new release for the library once all review comments have been addresses. --------- Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io> Co-authored-by: Dmitry Markin <dmitry@markin.tech> Co-authored-by: Alexandru Vasile <60601340+lexnv@users.noreply.github.com> Co-authored-by: Alexandru Vasile <alexandru.vasile@parity.io>
886 lines
29 KiB
Rust
886 lines
29 KiB
Rust
// This file is part of Substrate.
|
|
|
|
// Copyright (C) Parity Technologies (UK) Ltd.
|
|
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
use std::{collections::BTreeSet, sync::Arc, time::Duration};
|
|
|
|
use sc_network::{NetworkPeers, ReputationChange};
|
|
use sc_network_gossip::{MessageIntent, ValidationResult, Validator, ValidatorContext};
|
|
use sc_network_types::PeerId;
|
|
use sp_runtime::traits::{Block, Hash, Header, NumberFor};
|
|
|
|
use codec::{Decode, DecodeAll, Encode};
|
|
use log::{debug, trace};
|
|
use parking_lot::{Mutex, RwLock};
|
|
use wasm_timer::Instant;
|
|
|
|
use crate::{
|
|
communication::{benefit, cost, peers::KnownPeers},
|
|
justification::{
|
|
proof_block_num_and_set_id, verify_with_validator_set, BeefyVersionedFinalityProof,
|
|
},
|
|
keystore::BeefyKeystore,
|
|
LOG_TARGET,
|
|
};
|
|
use sp_consensus_beefy::{
|
|
ecdsa_crypto::{AuthorityId, Signature},
|
|
ValidatorSet, ValidatorSetId, VoteMessage,
|
|
};
|
|
|
|
// Timeout for rebroadcasting messages.
|
|
#[cfg(not(test))]
|
|
const REBROADCAST_AFTER: Duration = Duration::from_secs(60);
|
|
#[cfg(test)]
|
|
const REBROADCAST_AFTER: Duration = Duration::from_secs(5);
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub(super) enum Action<H> {
|
|
// repropagate under given topic, to the given peers, applying cost/benefit to originator.
|
|
Keep(H, ReputationChange),
|
|
// discard, applying cost/benefit to originator.
|
|
Discard(ReputationChange),
|
|
// ignore, no cost/benefit applied to originator.
|
|
DiscardNoReport,
|
|
}
|
|
|
|
/// An outcome of examining a message.
|
|
#[derive(Debug, PartialEq, Clone, Copy)]
|
|
enum Consider {
|
|
/// Accept the message.
|
|
Accept,
|
|
/// Message is too early. Reject.
|
|
RejectPast,
|
|
/// Message is from the future. Reject.
|
|
RejectFuture,
|
|
/// Message cannot be evaluated. Reject.
|
|
CannotEvaluate,
|
|
}
|
|
|
|
/// BEEFY gossip message type that gets encoded and sent on the network.
|
|
#[derive(Debug, Encode, Decode)]
|
|
pub(crate) enum GossipMessage<B: Block> {
|
|
/// BEEFY message with commitment and single signature.
|
|
Vote(VoteMessage<NumberFor<B>, AuthorityId, Signature>),
|
|
/// BEEFY justification with commitment and signatures.
|
|
FinalityProof(BeefyVersionedFinalityProof<B>),
|
|
}
|
|
|
|
impl<B: Block> GossipMessage<B> {
|
|
/// Return inner vote if this message is a Vote.
|
|
pub fn unwrap_vote(self) -> Option<VoteMessage<NumberFor<B>, AuthorityId, Signature>> {
|
|
match self {
|
|
GossipMessage::Vote(vote) => Some(vote),
|
|
GossipMessage::FinalityProof(_) => None,
|
|
}
|
|
}
|
|
|
|
/// Return inner finality proof if this message is a FinalityProof.
|
|
pub fn unwrap_finality_proof(self) -> Option<BeefyVersionedFinalityProof<B>> {
|
|
match self {
|
|
GossipMessage::Vote(_) => None,
|
|
GossipMessage::FinalityProof(proof) => Some(proof),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Gossip engine votes messages topic
|
|
pub(crate) fn votes_topic<B: Block>() -> B::Hash
|
|
where
|
|
B: Block,
|
|
{
|
|
<<B::Header as Header>::Hashing as Hash>::hash(b"beefy-votes")
|
|
}
|
|
|
|
/// Gossip engine justifications messages topic
|
|
pub(crate) fn proofs_topic<B: Block>() -> B::Hash
|
|
where
|
|
B: Block,
|
|
{
|
|
<<B::Header as Header>::Hashing as Hash>::hash(b"beefy-justifications")
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub(crate) struct GossipFilterCfg<'a, B: Block> {
|
|
pub start: NumberFor<B>,
|
|
pub end: NumberFor<B>,
|
|
pub validator_set: &'a ValidatorSet<AuthorityId>,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct FilterInner<B: Block> {
|
|
pub start: NumberFor<B>,
|
|
pub end: NumberFor<B>,
|
|
pub validator_set: ValidatorSet<AuthorityId>,
|
|
}
|
|
|
|
struct Filter<B: Block> {
|
|
// specifies live rounds
|
|
inner: Option<FilterInner<B>>,
|
|
// cache of seen valid justifications in active rounds
|
|
rounds_with_valid_proofs: BTreeSet<NumberFor<B>>,
|
|
}
|
|
|
|
impl<B: Block> Filter<B> {
|
|
pub fn new() -> Self {
|
|
Self { inner: None, rounds_with_valid_proofs: BTreeSet::new() }
|
|
}
|
|
|
|
/// Update filter to new `start` and `set_id`.
|
|
fn update(&mut self, cfg: GossipFilterCfg<B>) {
|
|
self.rounds_with_valid_proofs
|
|
.retain(|&round| round >= cfg.start && round <= cfg.end);
|
|
// only clone+overwrite big validator_set if set_id changed
|
|
match self.inner.as_mut() {
|
|
Some(f) if f.validator_set.id() == cfg.validator_set.id() => {
|
|
f.start = cfg.start;
|
|
f.end = cfg.end;
|
|
},
|
|
_ =>
|
|
self.inner = Some(FilterInner {
|
|
start: cfg.start,
|
|
end: cfg.end,
|
|
validator_set: cfg.validator_set.clone(),
|
|
}),
|
|
}
|
|
}
|
|
|
|
/// Accept if `max(session_start, best_beefy) <= round <= best_grandpa`,
|
|
/// and vote `set_id` matches session set id.
|
|
///
|
|
/// Latest concluded round is still considered alive to allow proper gossiping for it.
|
|
fn consider_vote(&self, round: NumberFor<B>, set_id: ValidatorSetId) -> Consider {
|
|
self.inner
|
|
.as_ref()
|
|
.map(|f|
|
|
// only from current set and only [filter.start, filter.end]
|
|
if set_id < f.validator_set.id() || round < f.start {
|
|
Consider::RejectPast
|
|
} else if set_id > f.validator_set.id() || round > f.end {
|
|
Consider::RejectFuture
|
|
} else {
|
|
Consider::Accept
|
|
})
|
|
.unwrap_or(Consider::CannotEvaluate)
|
|
}
|
|
|
|
/// Return true if `round` is >= than `max(session_start, best_beefy)`,
|
|
/// and proof `set_id` matches session set id.
|
|
///
|
|
/// Latest concluded round is still considered alive to allow proper gossiping for it.
|
|
fn consider_finality_proof(&self, round: NumberFor<B>, set_id: ValidatorSetId) -> Consider {
|
|
self.inner
|
|
.as_ref()
|
|
.map(|f|
|
|
// only from current set and only >= filter.start
|
|
if round < f.start || set_id < f.validator_set.id() {
|
|
Consider::RejectPast
|
|
} else if set_id > f.validator_set.id() {
|
|
Consider::RejectFuture
|
|
} else {
|
|
Consider::Accept
|
|
}
|
|
)
|
|
.unwrap_or(Consider::CannotEvaluate)
|
|
}
|
|
|
|
/// Add new _known_ `round` to the set of seen valid justifications.
|
|
fn mark_round_as_proven(&mut self, round: NumberFor<B>) {
|
|
self.rounds_with_valid_proofs.insert(round);
|
|
}
|
|
|
|
/// Check if `round` is already part of seen valid justifications.
|
|
fn is_already_proven(&self, round: NumberFor<B>) -> bool {
|
|
self.rounds_with_valid_proofs.contains(&round)
|
|
}
|
|
|
|
fn validator_set(&self) -> Option<&ValidatorSet<AuthorityId>> {
|
|
self.inner.as_ref().map(|f| &f.validator_set)
|
|
}
|
|
}
|
|
|
|
/// BEEFY gossip validator
|
|
///
|
|
/// Validate BEEFY gossip messages and limit the number of live BEEFY voting rounds.
|
|
///
|
|
/// Allows messages for 'rounds >= last concluded' to flow, everything else gets
|
|
/// rejected/expired.
|
|
///
|
|
///All messaging is handled in a single BEEFY global topic.
|
|
pub(crate) struct GossipValidator<B, N>
|
|
where
|
|
B: Block,
|
|
{
|
|
votes_topic: B::Hash,
|
|
justifs_topic: B::Hash,
|
|
gossip_filter: RwLock<Filter<B>>,
|
|
next_rebroadcast: Mutex<Instant>,
|
|
known_peers: Arc<Mutex<KnownPeers<B>>>,
|
|
network: Arc<N>,
|
|
}
|
|
|
|
impl<B, N> GossipValidator<B, N>
|
|
where
|
|
B: Block,
|
|
{
|
|
pub(crate) fn new(known_peers: Arc<Mutex<KnownPeers<B>>>, network: Arc<N>) -> Self {
|
|
Self {
|
|
votes_topic: votes_topic::<B>(),
|
|
justifs_topic: proofs_topic::<B>(),
|
|
gossip_filter: RwLock::new(Filter::new()),
|
|
next_rebroadcast: Mutex::new(Instant::now() + REBROADCAST_AFTER),
|
|
known_peers,
|
|
network,
|
|
}
|
|
}
|
|
|
|
/// Update gossip validator filter.
|
|
///
|
|
/// Only votes for `set_id` and rounds `start <= round <= end` will be accepted.
|
|
pub(crate) fn update_filter(&self, filter: GossipFilterCfg<B>) {
|
|
debug!(
|
|
target: LOG_TARGET,
|
|
"🥩 New gossip filter: start {:?}, end {:?}, validator set id {:?}",
|
|
filter.start, filter.end, filter.validator_set.id()
|
|
);
|
|
self.gossip_filter.write().update(filter);
|
|
}
|
|
}
|
|
|
|
impl<B, N> GossipValidator<B, N>
|
|
where
|
|
B: Block,
|
|
N: NetworkPeers,
|
|
{
|
|
fn report(&self, who: PeerId, cost_benefit: ReputationChange) {
|
|
self.network.report_peer(who, cost_benefit);
|
|
}
|
|
|
|
fn validate_vote(
|
|
&self,
|
|
vote: VoteMessage<NumberFor<B>, AuthorityId, Signature>,
|
|
sender: &PeerId,
|
|
) -> Action<B::Hash> {
|
|
let round = vote.commitment.block_number;
|
|
let set_id = vote.commitment.validator_set_id;
|
|
self.known_peers.lock().note_vote_for(*sender, round);
|
|
|
|
// Verify general usefulness of the message.
|
|
// We are going to discard old votes right away (without verification).
|
|
{
|
|
let filter = self.gossip_filter.read();
|
|
|
|
match filter.consider_vote(round, set_id) {
|
|
Consider::RejectPast => return Action::Discard(cost::OUTDATED_MESSAGE),
|
|
Consider::RejectFuture => return Action::Discard(cost::FUTURE_MESSAGE),
|
|
// When we can't evaluate, it's our fault (e.g. filter not initialized yet), we
|
|
// discard the vote without punishing or rewarding the sending peer.
|
|
Consider::CannotEvaluate => return Action::DiscardNoReport,
|
|
Consider::Accept => {},
|
|
}
|
|
|
|
// ensure authority is part of the set.
|
|
if !filter
|
|
.validator_set()
|
|
.map(|set| set.validators().contains(&vote.id))
|
|
.unwrap_or(false)
|
|
{
|
|
debug!(target: LOG_TARGET, "Message from voter not in validator set: {}", vote.id);
|
|
return Action::Discard(cost::UNKNOWN_VOTER)
|
|
}
|
|
}
|
|
|
|
if BeefyKeystore::verify(&vote.id, &vote.signature, &vote.commitment.encode()) {
|
|
Action::Keep(self.votes_topic, benefit::VOTE_MESSAGE)
|
|
} else {
|
|
debug!(
|
|
target: LOG_TARGET,
|
|
"🥩 Bad signature on message: {:?}, from: {:?}", vote, sender
|
|
);
|
|
Action::Discard(cost::BAD_SIGNATURE)
|
|
}
|
|
}
|
|
|
|
fn validate_finality_proof(
|
|
&self,
|
|
proof: BeefyVersionedFinalityProof<B>,
|
|
sender: &PeerId,
|
|
) -> Action<B::Hash> {
|
|
let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
|
|
self.known_peers.lock().note_vote_for(*sender, round);
|
|
|
|
let action = {
|
|
let guard = self.gossip_filter.read();
|
|
|
|
// Verify general usefulness of the justification.
|
|
match guard.consider_finality_proof(round, set_id) {
|
|
Consider::RejectPast => return Action::Discard(cost::OUTDATED_MESSAGE),
|
|
Consider::RejectFuture => return Action::Discard(cost::FUTURE_MESSAGE),
|
|
// When we can't evaluate, it's our fault (e.g. filter not initialized yet), we
|
|
// discard the proof without punishing or rewarding the sending peer.
|
|
Consider::CannotEvaluate => return Action::DiscardNoReport,
|
|
Consider::Accept => {},
|
|
}
|
|
|
|
if guard.is_already_proven(round) {
|
|
return Action::Discard(benefit::NOT_INTERESTED)
|
|
}
|
|
|
|
// Verify justification signatures.
|
|
guard
|
|
.validator_set()
|
|
.map(|validator_set| {
|
|
if let Err((_, signatures_checked)) =
|
|
verify_with_validator_set::<B>(round, validator_set, &proof)
|
|
{
|
|
debug!(
|
|
target: LOG_TARGET,
|
|
"🥩 Bad signatures on message: {:?}, from: {:?}", proof, sender
|
|
);
|
|
let mut cost = cost::INVALID_PROOF;
|
|
cost.value +=
|
|
cost::PER_SIGNATURE_CHECKED.saturating_mul(signatures_checked as i32);
|
|
Action::Discard(cost)
|
|
} else {
|
|
Action::Keep(self.justifs_topic, benefit::VALIDATED_PROOF)
|
|
}
|
|
})
|
|
// When we can't evaluate, it's our fault (e.g. filter not initialized yet), we
|
|
// discard the proof without punishing or rewarding the sending peer.
|
|
.unwrap_or(Action::DiscardNoReport)
|
|
};
|
|
if matches!(action, Action::Keep(_, _)) {
|
|
self.gossip_filter.write().mark_round_as_proven(round);
|
|
}
|
|
action
|
|
}
|
|
}
|
|
|
|
impl<B, N> Validator<B> for GossipValidator<B, N>
|
|
where
|
|
B: Block,
|
|
N: NetworkPeers + Send + Sync,
|
|
{
|
|
fn peer_disconnected(&self, _context: &mut dyn ValidatorContext<B>, who: &PeerId) {
|
|
self.known_peers.lock().remove(who);
|
|
}
|
|
|
|
fn validate(
|
|
&self,
|
|
context: &mut dyn ValidatorContext<B>,
|
|
sender: &PeerId,
|
|
mut data: &[u8],
|
|
) -> ValidationResult<B::Hash> {
|
|
let raw = data;
|
|
let action = match GossipMessage::<B>::decode_all(&mut data) {
|
|
Ok(GossipMessage::Vote(msg)) => self.validate_vote(msg, sender),
|
|
Ok(GossipMessage::FinalityProof(proof)) => self.validate_finality_proof(proof, sender),
|
|
Err(e) => {
|
|
debug!(target: LOG_TARGET, "Error decoding message: {}", e);
|
|
let bytes = raw.len().min(i32::MAX as usize) as i32;
|
|
let cost = ReputationChange::new(
|
|
bytes.saturating_mul(cost::PER_UNDECODABLE_BYTE),
|
|
"BEEFY: Bad packet",
|
|
);
|
|
Action::Discard(cost)
|
|
},
|
|
};
|
|
match action {
|
|
Action::Keep(topic, cb) => {
|
|
self.report(*sender, cb);
|
|
context.broadcast_message(topic, data.to_vec(), false);
|
|
ValidationResult::ProcessAndKeep(topic)
|
|
},
|
|
Action::Discard(cb) => {
|
|
self.report(*sender, cb);
|
|
ValidationResult::Discard
|
|
},
|
|
Action::DiscardNoReport => ValidationResult::Discard,
|
|
}
|
|
}
|
|
|
|
fn message_expired<'a>(&'a self) -> Box<dyn FnMut(B::Hash, &[u8]) -> bool + 'a> {
|
|
let filter = self.gossip_filter.read();
|
|
Box::new(move |_topic, mut data| match GossipMessage::<B>::decode_all(&mut data) {
|
|
Ok(GossipMessage::Vote(msg)) => {
|
|
let round = msg.commitment.block_number;
|
|
let set_id = msg.commitment.validator_set_id;
|
|
let expired = filter.consider_vote(round, set_id) != Consider::Accept;
|
|
trace!(target: LOG_TARGET, "🥩 Vote for round #{} expired: {}", round, expired);
|
|
expired
|
|
},
|
|
Ok(GossipMessage::FinalityProof(proof)) => {
|
|
let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
|
|
let expired = filter.consider_finality_proof(round, set_id) != Consider::Accept;
|
|
trace!(
|
|
target: LOG_TARGET,
|
|
"🥩 Finality proof for round #{} expired: {}",
|
|
round,
|
|
expired
|
|
);
|
|
expired
|
|
},
|
|
Err(_) => true,
|
|
})
|
|
}
|
|
|
|
fn message_allowed<'a>(
|
|
&'a self,
|
|
) -> Box<dyn FnMut(&PeerId, MessageIntent, &B::Hash, &[u8]) -> bool + 'a> {
|
|
let do_rebroadcast = {
|
|
let now = Instant::now();
|
|
let mut next_rebroadcast = self.next_rebroadcast.lock();
|
|
if now >= *next_rebroadcast {
|
|
trace!(target: LOG_TARGET, "🥩 Gossip rebroadcast");
|
|
*next_rebroadcast = now + REBROADCAST_AFTER;
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
};
|
|
|
|
let filter = self.gossip_filter.read();
|
|
Box::new(move |_who, intent, _topic, mut data| {
|
|
if let MessageIntent::PeriodicRebroadcast = intent {
|
|
return do_rebroadcast
|
|
}
|
|
|
|
match GossipMessage::<B>::decode_all(&mut data) {
|
|
Ok(GossipMessage::Vote(msg)) => {
|
|
let round = msg.commitment.block_number;
|
|
let set_id = msg.commitment.validator_set_id;
|
|
let allowed = filter.consider_vote(round, set_id) == Consider::Accept;
|
|
trace!(target: LOG_TARGET, "🥩 Vote for round #{} allowed: {}", round, allowed);
|
|
allowed
|
|
},
|
|
Ok(GossipMessage::FinalityProof(proof)) => {
|
|
let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
|
|
let allowed = filter.consider_finality_proof(round, set_id) == Consider::Accept;
|
|
trace!(
|
|
target: LOG_TARGET,
|
|
"🥩 Finality proof for round #{} allowed: {}",
|
|
round,
|
|
allowed
|
|
);
|
|
allowed
|
|
},
|
|
Err(_) => false,
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) mod tests {
|
|
use super::*;
|
|
use crate::{communication::peers::PeerReport, keystore::BeefyKeystore};
|
|
use sc_network_test::Block;
|
|
use sp_application_crypto::key_types::BEEFY as BEEFY_KEY_TYPE;
|
|
use sp_consensus_beefy::{
|
|
ecdsa_crypto::Signature, known_payloads, test_utils::Keyring, Commitment, MmrRootHash,
|
|
Payload, SignedCommitment, VoteMessage,
|
|
};
|
|
use sp_keystore::{testing::MemoryKeystore, Keystore};
|
|
|
|
pub(crate) struct TestNetwork {
|
|
report_sender: futures::channel::mpsc::UnboundedSender<PeerReport>,
|
|
}
|
|
|
|
impl TestNetwork {
|
|
pub fn new() -> (Self, futures::channel::mpsc::UnboundedReceiver<PeerReport>) {
|
|
let (tx, rx) = futures::channel::mpsc::unbounded();
|
|
|
|
(Self { report_sender: tx }, rx)
|
|
}
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl NetworkPeers for TestNetwork {
|
|
fn set_authorized_peers(&self, _: std::collections::HashSet<PeerId>) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn set_authorized_only(&self, _: bool) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn add_known_address(&self, _: PeerId, _: sc_network::Multiaddr) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn report_peer(&self, peer_id: PeerId, cost_benefit: ReputationChange) {
|
|
let _ = self.report_sender.unbounded_send(PeerReport { who: peer_id, cost_benefit });
|
|
}
|
|
|
|
fn peer_reputation(&self, _: &PeerId) -> i32 {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn disconnect_peer(&self, _: PeerId, _: sc_network::ProtocolName) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn accept_unreserved_peers(&self) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn deny_unreserved_peers(&self) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn add_reserved_peer(
|
|
&self,
|
|
_: sc_network::config::MultiaddrWithPeerId,
|
|
) -> Result<(), String> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn remove_reserved_peer(&self, _: PeerId) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn set_reserved_peers(
|
|
&self,
|
|
_: sc_network::ProtocolName,
|
|
_: std::collections::HashSet<sc_network::Multiaddr>,
|
|
) -> Result<(), String> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn add_peers_to_reserved_set(
|
|
&self,
|
|
_: sc_network::ProtocolName,
|
|
_: std::collections::HashSet<sc_network::Multiaddr>,
|
|
) -> Result<(), String> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn remove_peers_from_reserved_set(
|
|
&self,
|
|
_: sc_network::ProtocolName,
|
|
_: Vec<PeerId>,
|
|
) -> Result<(), String> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn sync_num_connected(&self) -> usize {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn peer_role(&self, _: PeerId, _: Vec<u8>) -> Option<sc_network::ObservedRole> {
|
|
unimplemented!()
|
|
}
|
|
|
|
async fn reserved_peers(&self) -> Result<Vec<PeerId>, ()> {
|
|
unimplemented!();
|
|
}
|
|
}
|
|
|
|
struct TestContext;
|
|
impl<B: sp_runtime::traits::Block> ValidatorContext<B> for TestContext {
|
|
fn broadcast_topic(&mut self, _topic: B::Hash, _force: bool) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn broadcast_message(&mut self, _topic: B::Hash, _message: Vec<u8>, _force: bool) {}
|
|
|
|
fn send_message(&mut self, _who: &sc_network_types::PeerId, _message: Vec<u8>) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn send_topic(&mut self, _who: &sc_network_types::PeerId, _topic: B::Hash, _force: bool) {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
|
|
pub fn sign_commitment<BN: Encode>(
|
|
who: &Keyring<AuthorityId>,
|
|
commitment: &Commitment<BN>,
|
|
) -> Signature {
|
|
let store = MemoryKeystore::new();
|
|
store.ecdsa_generate_new(BEEFY_KEY_TYPE, Some(&who.to_seed())).unwrap();
|
|
let beefy_keystore: BeefyKeystore<AuthorityId> = Some(store.into()).into();
|
|
beefy_keystore.sign(&who.public(), &commitment.encode()).unwrap()
|
|
}
|
|
|
|
fn dummy_vote(block_number: u64) -> VoteMessage<u64, AuthorityId, Signature> {
|
|
let payload = Payload::from_single_entry(
|
|
known_payloads::MMR_ROOT_ID,
|
|
MmrRootHash::default().encode(),
|
|
);
|
|
let commitment = Commitment { payload, block_number, validator_set_id: 0 };
|
|
let signature = sign_commitment(&Keyring::Alice, &commitment);
|
|
|
|
VoteMessage { commitment, id: Keyring::Alice.public(), signature }
|
|
}
|
|
|
|
pub fn dummy_proof(
|
|
block_number: u64,
|
|
validator_set: &ValidatorSet<AuthorityId>,
|
|
) -> BeefyVersionedFinalityProof<Block> {
|
|
let payload = Payload::from_single_entry(
|
|
known_payloads::MMR_ROOT_ID,
|
|
MmrRootHash::default().encode(),
|
|
);
|
|
let commitment = Commitment { payload, block_number, validator_set_id: validator_set.id() };
|
|
let signatures = validator_set
|
|
.validators()
|
|
.iter()
|
|
.map(|validator: &AuthorityId| {
|
|
Some(sign_commitment(
|
|
&Keyring::<AuthorityId>::from_public(validator).unwrap(),
|
|
&commitment,
|
|
))
|
|
})
|
|
.collect();
|
|
|
|
BeefyVersionedFinalityProof::<Block>::V1(SignedCommitment { commitment, signatures })
|
|
}
|
|
|
|
#[test]
|
|
fn should_validate_messages() {
|
|
let keys = vec![Keyring::<AuthorityId>::Alice.public()];
|
|
let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 0).unwrap();
|
|
|
|
let (network, mut report_stream) = TestNetwork::new();
|
|
|
|
let gv = GossipValidator::<Block, _>::new(
|
|
Arc::new(Mutex::new(KnownPeers::new())),
|
|
Arc::new(network),
|
|
);
|
|
let sender = PeerId::random();
|
|
let mut context = TestContext;
|
|
|
|
// reject message, decoding error
|
|
let bad_encoding = b"0000000000".as_slice();
|
|
let expected_cost = ReputationChange::new(
|
|
(bad_encoding.len() as i32).saturating_mul(cost::PER_UNDECODABLE_BYTE),
|
|
"BEEFY: Bad packet",
|
|
);
|
|
let mut expected_report = PeerReport { who: sender, cost_benefit: expected_cost };
|
|
let res = gv.validate(&mut context, &sender, bad_encoding);
|
|
assert!(matches!(res, ValidationResult::Discard));
|
|
assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
|
|
|
|
// verify votes validation
|
|
|
|
let vote = dummy_vote(3);
|
|
let encoded = GossipMessage::<Block>::Vote(vote.clone()).encode();
|
|
|
|
// filter not initialized
|
|
let res = gv.validate(&mut context, &sender, &encoded);
|
|
assert!(matches!(res, ValidationResult::Discard));
|
|
// nothing reported
|
|
assert!(report_stream.try_next().is_err());
|
|
|
|
gv.update_filter(GossipFilterCfg { start: 0, end: 10, validator_set: &validator_set });
|
|
// nothing in cache first time
|
|
let res = gv.validate(&mut context, &sender, &encoded);
|
|
assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
|
|
expected_report.cost_benefit = benefit::VOTE_MESSAGE;
|
|
assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
|
|
|
|
// reject vote, voter not in validator set
|
|
let mut bad_vote = vote.clone();
|
|
bad_vote.id = Keyring::Bob.public();
|
|
let bad_vote = GossipMessage::<Block>::Vote(bad_vote).encode();
|
|
let res = gv.validate(&mut context, &sender, &bad_vote);
|
|
assert!(matches!(res, ValidationResult::Discard));
|
|
expected_report.cost_benefit = cost::UNKNOWN_VOTER;
|
|
assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
|
|
|
|
// reject if the round is not GRANDPA finalized
|
|
gv.update_filter(GossipFilterCfg { start: 1, end: 2, validator_set: &validator_set });
|
|
let number = vote.commitment.block_number;
|
|
let set_id = vote.commitment.validator_set_id;
|
|
assert_eq!(gv.gossip_filter.read().consider_vote(number, set_id), Consider::RejectFuture);
|
|
let res = gv.validate(&mut context, &sender, &encoded);
|
|
assert!(matches!(res, ValidationResult::Discard));
|
|
expected_report.cost_benefit = cost::FUTURE_MESSAGE;
|
|
assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
|
|
|
|
// reject if the round is not live anymore
|
|
gv.update_filter(GossipFilterCfg { start: 7, end: 10, validator_set: &validator_set });
|
|
let number = vote.commitment.block_number;
|
|
let set_id = vote.commitment.validator_set_id;
|
|
assert_eq!(gv.gossip_filter.read().consider_vote(number, set_id), Consider::RejectPast);
|
|
let res = gv.validate(&mut context, &sender, &encoded);
|
|
assert!(matches!(res, ValidationResult::Discard));
|
|
expected_report.cost_benefit = cost::OUTDATED_MESSAGE;
|
|
assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
|
|
|
|
// now verify proofs validation
|
|
|
|
// reject old proof
|
|
let proof = dummy_proof(5, &validator_set);
|
|
let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
let res = gv.validate(&mut context, &sender, &encoded_proof);
|
|
assert!(matches!(res, ValidationResult::Discard));
|
|
expected_report.cost_benefit = cost::OUTDATED_MESSAGE;
|
|
assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
|
|
|
|
// accept next proof with good set_id
|
|
let proof = dummy_proof(7, &validator_set);
|
|
let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
let res = gv.validate(&mut context, &sender, &encoded_proof);
|
|
assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
|
|
expected_report.cost_benefit = benefit::VALIDATED_PROOF;
|
|
assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
|
|
|
|
// accept future proof with good set_id
|
|
let proof = dummy_proof(20, &validator_set);
|
|
let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
let res = gv.validate(&mut context, &sender, &encoded_proof);
|
|
assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
|
|
expected_report.cost_benefit = benefit::VALIDATED_PROOF;
|
|
assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
|
|
|
|
// reject proof, future set_id
|
|
let bad_validator_set = ValidatorSet::<AuthorityId>::new(keys, 1).unwrap();
|
|
let proof = dummy_proof(20, &bad_validator_set);
|
|
let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
let res = gv.validate(&mut context, &sender, &encoded_proof);
|
|
assert!(matches!(res, ValidationResult::Discard));
|
|
expected_report.cost_benefit = cost::FUTURE_MESSAGE;
|
|
assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
|
|
|
|
// reject proof, bad signatures (Bob instead of Alice)
|
|
let bad_validator_set =
|
|
ValidatorSet::<AuthorityId>::new(vec![Keyring::Bob.public()], 0).unwrap();
|
|
let proof = dummy_proof(21, &bad_validator_set);
|
|
let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
let res = gv.validate(&mut context, &sender, &encoded_proof);
|
|
assert!(matches!(res, ValidationResult::Discard));
|
|
expected_report.cost_benefit = cost::INVALID_PROOF;
|
|
expected_report.cost_benefit.value += cost::PER_SIGNATURE_CHECKED;
|
|
assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
|
|
}
|
|
|
|
#[test]
|
|
fn messages_allowed_and_expired() {
|
|
let keys = vec![Keyring::Alice.public()];
|
|
let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 0).unwrap();
|
|
let gv = GossipValidator::<Block, _>::new(
|
|
Arc::new(Mutex::new(KnownPeers::new())),
|
|
Arc::new(TestNetwork::new().0),
|
|
);
|
|
gv.update_filter(GossipFilterCfg { start: 0, end: 10, validator_set: &validator_set });
|
|
let sender = sc_network_types::PeerId::random();
|
|
let topic = Default::default();
|
|
let intent = MessageIntent::Broadcast;
|
|
|
|
// conclude 2
|
|
gv.update_filter(GossipFilterCfg { start: 2, end: 10, validator_set: &validator_set });
|
|
let mut allowed = gv.message_allowed();
|
|
let mut expired = gv.message_expired();
|
|
|
|
// check bad vote format
|
|
assert!(!allowed(&sender, intent, &topic, &mut [0u8; 16]));
|
|
assert!(expired(topic, &mut [0u8; 16]));
|
|
|
|
// inactive round 1 -> expired
|
|
let vote = dummy_vote(1);
|
|
let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
|
|
assert!(!allowed(&sender, intent, &topic, &mut encoded_vote));
|
|
assert!(expired(topic, &mut encoded_vote));
|
|
let proof = dummy_proof(1, &validator_set);
|
|
let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
assert!(!allowed(&sender, intent, &topic, &mut encoded_proof));
|
|
assert!(expired(topic, &mut encoded_proof));
|
|
|
|
// active round 2 -> !expired - concluded but still gossiped
|
|
let vote = dummy_vote(2);
|
|
let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
|
|
assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
|
|
assert!(!expired(topic, &mut encoded_vote));
|
|
let proof = dummy_proof(2, &validator_set);
|
|
let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
|
|
assert!(!expired(topic, &mut encoded_proof));
|
|
// using wrong set_id -> !allowed, expired
|
|
let bad_validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 1).unwrap();
|
|
let proof = dummy_proof(2, &bad_validator_set);
|
|
let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
assert!(!allowed(&sender, intent, &topic, &mut encoded_proof));
|
|
assert!(expired(topic, &mut encoded_proof));
|
|
|
|
// in progress round 3 -> !expired
|
|
let vote = dummy_vote(3);
|
|
let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
|
|
assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
|
|
assert!(!expired(topic, &mut encoded_vote));
|
|
let proof = dummy_proof(3, &validator_set);
|
|
let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
|
|
assert!(!expired(topic, &mut encoded_proof));
|
|
|
|
// unseen round 4 -> !expired
|
|
let vote = dummy_vote(4);
|
|
let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
|
|
assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
|
|
assert!(!expired(topic, &mut encoded_vote));
|
|
let proof = dummy_proof(4, &validator_set);
|
|
let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
|
|
assert!(!expired(topic, &mut encoded_proof));
|
|
|
|
// future round 11 -> expired
|
|
let vote = dummy_vote(11);
|
|
let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
|
|
assert!(!allowed(&sender, intent, &topic, &mut encoded_vote));
|
|
assert!(expired(topic, &mut encoded_vote));
|
|
// future proofs allowed while same set_id -> allowed
|
|
let proof = dummy_proof(11, &validator_set);
|
|
let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
|
|
assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
|
|
assert!(!expired(topic, &mut encoded_proof));
|
|
}
|
|
|
|
#[test]
|
|
fn messages_rebroadcast() {
|
|
let keys = vec![Keyring::Alice.public()];
|
|
let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 0).unwrap();
|
|
let gv = GossipValidator::<Block, _>::new(
|
|
Arc::new(Mutex::new(KnownPeers::new())),
|
|
Arc::new(TestNetwork::new().0),
|
|
);
|
|
gv.update_filter(GossipFilterCfg { start: 0, end: 10, validator_set: &validator_set });
|
|
let sender = sc_network_types::PeerId::random();
|
|
let topic = Default::default();
|
|
|
|
let vote = dummy_vote(1);
|
|
let mut encoded_vote = vote.encode();
|
|
|
|
// re-broadcasting only allowed at `REBROADCAST_AFTER` intervals
|
|
let intent = MessageIntent::PeriodicRebroadcast;
|
|
let mut allowed = gv.message_allowed();
|
|
|
|
// rebroadcast not allowed so soon after GossipValidator creation
|
|
assert!(!allowed(&sender, intent, &topic, &mut encoded_vote));
|
|
|
|
// hack the inner deadline to be `now`
|
|
*gv.next_rebroadcast.lock() = Instant::now();
|
|
|
|
// still not allowed on old `allowed` closure result
|
|
assert!(!allowed(&sender, intent, &topic, &mut encoded_vote));
|
|
|
|
// renew closure result
|
|
let mut allowed = gv.message_allowed();
|
|
// rebroadcast should be allowed now
|
|
assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
|
|
}
|
|
}
|