pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-13 14:01:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

core: import equivocated aura and babe blocks (#2709)

Browse Source 
* core: import equivocated aura and babe blocks

* core: cleanup check_equivocation handling

* fix: use map_err on Aura

* core: slots: remove unneeded Arc and minimize cloning

* core: fix slots equivocation tests

* core: slots: remove unused import

* core: remove unnecessary comments
This commit is contained in:
André Silva
2019-05-29 15:25:02 +02:00
committed by Gavin Wood
parent fccc55160a
commit 7e591a8f4d
5 changed files with 161 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/core/consensus/babe/src/lib.rs
+20 -103
View File
@@ -461,7 +461,7 @@ fn find_pre_digest<B: Block>(header: &B::Header) -> Result<BabePreDigest, String
// FIXME #1018 needs misbehavior types
#[forbid(warnings)]
fn check_header<B: Block + Sized, C: AuxStore>(
client: &Arc<C>,
client: &C,
slot_now: u64,
mut header: B::Header,
hash: B::Hash,
@@ -508,28 +508,27 @@ fn check_header<B: Block + Sized, C: AuxStore>(
if !check(&inout, threshold) {
return Err(babe_err!("VRF verification of block by author {:?} failed: \
threshold {} exceeded", author, threshold))
threshold {} exceeded", author, threshold));
}
match check_equivocation(&client, slot_now, slot_num, header.clone(), author.clone()) {
Ok(Some(equivocation_proof)) => {
let log_str = format!(
"Slot author {:?} is equivocating at slot {} with headers {:?} and {:?}",
author,
slot_num,
equivocation_proof.fst_header().hash(),
equivocation_proof.snd_header().hash(),
);
info!(target: "babe", "{}", log_str);
Err(log_str)
},
Ok(None) => {
let pre_digest = CompatibleDigestItem::babe_pre_digest(pre_digest);
Ok(CheckedHeader::Checked(header, (pre_digest, seal)))
},
Err(e) => {
Err(e.to_string())
},
if let Some(equivocation_proof) = check_equivocation(
client,
slot_now,
slot_num,
&header,
author,
).map_err(|e| e.to_string())? {
info!(
"Slot author {:?} is equivocating at slot {} with headers {:?} and {:?}",
author,
slot_num,
equivocation_proof.fst_header().hash(),
equivocation_proof.snd_header().hash(),
);
}
let pre_digest = CompatibleDigestItem::babe_pre_digest(pre_digest);
Ok(CheckedHeader::Checked(header, (pre_digest, seal)))
} else {
Err(babe_err!("Bad signature on {:?}", hash))
}
@@ -823,9 +822,6 @@ mod tests {
use std::time::Duration;
type Item = generic::DigestItem<Hash, Public, Signature>;
use test_client::AuthorityKeyring;
use primitives::hash::H256;
use runtime_primitives::testing::{Header as HeaderTest, Digest as DigestTest, Block as RawBlock, ExtrinsicWrapper};
use slots::{MAX_SLOT_CAPACITY, PRUNING_BOUND};
type Error = client::error::Error;
@@ -934,44 +930,6 @@ mod tests {
}
}
fn create_header(slot_num: u64, number: u64, pair: &sr25519::Pair) -> (HeaderTest, H256) {
let mut header = HeaderTest {
parent_hash: Default::default(),
number,
state_root: Default::default(),
extrinsics_root: Default::default(),
digest: DigestTest { logs: vec![], },
};
let transcript = make_transcript(
Default::default(),
slot_num,
Default::default(),
0,
);
let (inout, proof, _batchable_proof) = get_keypair(&pair).vrf_sign_n_check(transcript, |inout| check(inout, u64::MAX)).unwrap();
let pre_hash: H256 = header.hash();
let pre_digest = BabePreDigest {
proof,
author: pair.public(),
slot_num,
vrf_output: inout.to_output(),
};
assert_eq!(
Decode::decode(&mut &pre_digest.encode()[..]).as_ref(),
Some(&pre_digest),
"Pre-digest encoding and decoding did not round-trip",
);
let item = generic::DigestItem::babe_pre_digest(pre_digest);
header.digest_mut().push(item);
let to_sign = header.hash();
let signature = pair.sign(&to_sign[..]);
header.digest_mut().push(generic::DigestItem::babe_seal(signature));
(header, pre_hash)
}
#[test]
fn can_serialize_block() {
drop(env_logger::try_init());
@@ -1107,45 +1065,4 @@ mod tests {
Keyring::Charlie.into()
]);
}
#[test]
fn check_header_works_with_equivocation() {
drop(env_logger::try_init());
let client = test_client::new();
let pair = sr25519::Pair::generate();
let public = pair.public();
let authorities = vec![public.clone(), sr25519::Pair::generate().public()];
let (header1, header1_hash) = create_header(2, 1, &pair);
let (header2, header2_hash) = create_header(2, 2, &pair);
let (header3, header3_hash) = create_header(4, 2, &pair);
let (header4, header4_hash) = create_header(MAX_SLOT_CAPACITY + 4, 3, &pair);
let (header5, header5_hash) = create_header(MAX_SLOT_CAPACITY + 4, 4, &pair);
let (header6, header6_hash) = create_header(4, 3, &pair);
let c = Arc::new(client);
let max = u64::MAX;
type B = RawBlock<ExtrinsicWrapper<u64>>;
type P = sr25519::Pair;
// It's ok to sign same headers.
assert!(check_header::<B, _>(&c, 2, header1.clone(), header1_hash, &authorities, max).is_ok());
assert!(check_header::<B, _>(&c, 3, header1, header1_hash, &authorities, max).is_ok());
// But not two different headers at the same slot.
assert!(check_header::<B, _>(&c, 4, header2, header2_hash, &authorities, max).is_err());
// Different slot is ok.
assert!(check_header::<B, _>(&c, 5, header3, header3_hash, &authorities, max).is_ok());
// Here we trigger pruning and save header 4.
assert!(check_header::<B, _>(&c, PRUNING_BOUND + 2, header4, header4_hash, &authorities, max).is_ok());
// This fails because header 5 is an equivocation of header 4.
assert!(check_header::<B, _>(&c, PRUNING_BOUND + 3, header5, header5_hash, &authorities, max).is_err());
// This is ok because we pruned the corresponding header. Shows that we are pruning.
assert!(check_header::<B, _>(&c, PRUNING_BOUND + 4, header6, header6_hash, &authorities, max).is_ok());
}
}