diff --git a/primitives/src/v1/signed.rs b/primitives/src/v1/signed.rs index 42f3680e6594..4d1d732b79e2 100644 --- a/primitives/src/v1/signed.rs +++ b/primitives/src/v1/signed.rs @@ -257,14 +257,20 @@ impl, RealPayload: Encode> UncheckedSigned( - pair: &crate::v0::ValidatorPair, + public: &crate::v0::ValidatorId, payload: Payload, context: &SigningContext, validator_index: ValidatorIndex, ) -> Self { - use application_crypto::Pair; + // use application_crypto::Pair; + use application_crypto::RuntimeAppPublic; let data = Self::payload_data(&payload, context); - let signature = pair.sign(&data); + + // let debug_res = public.sign(&data); + // // println!("debug_res benchmark sign {:?}", debug_res); + // let signature = debug_res.unwrap(); + let signature = public.sign(&data).unwrap(); + // let signature = pair.sign(&data); Self { payload, validator_index, signature, real_payload: sp_std::marker::PhantomData } } diff --git a/runtime/parachains/src/mock.rs b/runtime/parachains/src/mock.rs index df34d4cef336..e23931587046 100644 --- a/runtime/parachains/src/mock.rs +++ b/runtime/parachains/src/mock.rs @@ -301,6 +301,8 @@ impl inclusion::RewardValidators for TestRewardValidators { /// Create a new set of test externalities. pub fn new_test_ext(state: MockGenesisConfig) -> TestExternalities { + use sp_keystore::{testing::KeyStore, KeystoreExt, SyncCryptoStorePtr}; + use sp_std::sync::Arc; BACKING_REWARDS.with(|r| r.borrow_mut().clear()); AVAILABILITY_REWARDS.with(|r| r.borrow_mut().clear()); @@ -308,7 +310,10 @@ pub fn new_test_ext(state: MockGenesisConfig) -> TestExternalities { state.configuration.assimilate_storage(&mut t).unwrap(); GenesisBuild::::assimilate_storage(&state.paras, &mut t).unwrap(); - t.into() + let mut ext: TestExternalities = t.into(); + ext.register_extension(KeystoreExt(Arc::new(KeyStore::new()) as SyncCryptoStorePtr)); + + ext } #[derive(Default)] diff --git a/runtime/parachains/src/paras_inherent/benchmarking.rs b/runtime/parachains/src/paras_inherent/benchmarking.rs index 41a9d01cb523..a54984a36d22 100644 --- a/runtime/parachains/src/paras_inherent/benchmarking.rs +++ b/runtime/parachains/src/paras_inherent/benchmarking.rs @@ -19,23 +19,20 @@ use crate::{configuration, inclusion, initializer, paras, scheduler, session_inf use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec}; use frame_benchmarking::{account, benchmarks, impl_benchmark_test_suite}; use frame_system::RawOrigin; -use primitives::{ - v0::{CollatorPair, ValidatorPair}, - v1::{ - byzantine_threshold, collator_signature_payload, AvailabilityBitfield, - CandidateCommitments, CandidateDescriptor, CandidateHash, CommittedCandidateReceipt, - CompactStatement, CoreIndex, CoreOccupied, DisputeStatement, DisputeStatementSet, - GroupIndex, HeadData, Id as ParaId, InvalidDisputeStatementKind, PersistedValidationData, - SigningContext, UncheckedSigned, ValidDisputeStatementKind, ValidatorId, ValidatorIndex, - ValidityAttestation, - }, +use primitives::v1::{ + byzantine_threshold, collator_signature_payload, AvailabilityBitfield, CandidateCommitments, + CandidateDescriptor, CandidateHash, CollatorId, CommittedCandidateReceipt, CompactStatement, + CoreIndex, CoreOccupied, DisputeStatement, DisputeStatementSet, GroupIndex, HeadData, + Id as ParaId, InvalidDisputeStatementKind, PersistedValidationData, SigningContext, + UncheckedSigned, ValidDisputeStatementKind, ValidatorId, ValidatorIndex, ValidityAttestation, }; -use sp_core::{Pair, H256}; +use sp_core::H256; use sp_runtime::{ generic::Digest, traits::{One, Zero}, + RuntimeAppPublic, }; -use sp_std::{collections::btree_map::BTreeMap as HashMap, convert::TryInto}; +use sp_std::convert::TryInto; fn byte32_slice_from(n: u32) -> [u8; 32] { let mut slice = [0u8; 32]; @@ -51,13 +48,12 @@ fn byte32_slice_from(n: u32) -> [u8; 32] { // // - there are many fresh disputes, where the disputes have just been initiated. // - create a new `DisputeState` with blank bitfields. -// - make sure spam slotes is incremented by have DisputeStatementSet U DisputeState < byzantize_thresh -// - force one side to have a super majority, so we enable slashing +// - make sure spam slots is maxed out without being cleared +// - force one side to have a super majority, so we enable slashing <-- TODO +// /// Paras inherent `enter` benchmark scenario builder. struct BenchBuilder { - current_session: u32, - validators: Option>, - validators_map: Option>, + validators: Option>, _phantom: sp_std::marker::PhantomData, } @@ -69,9 +65,7 @@ struct Bench { impl BenchBuilder { fn new() -> Self { BenchBuilder { - current_session: 0, validators: None, - validators_map: None, _phantom: sp_std::marker::PhantomData::, } } @@ -175,16 +169,15 @@ impl BenchBuilder { } /// Generate validator key pairs and account ids. - fn generate_validator_pairs(validator_count: u32) -> Vec<(T::AccountId, ValidatorPair)> { + fn generate_validator_pairs(validator_count: u32) -> Vec<(T::AccountId, ValidatorId)> { (0..validator_count) .map(|i| { - let seed = byte32_slice_from(i); - let pair = ValidatorPair::from_seed_slice(&seed).unwrap(); + let public = ValidatorId::generate_pair(None); // this account is not actually used anywhere, just necessary to fulfill expected type // `validators` param of `test_trigger_on_new_session`. let account: T::AccountId = account("validator", i, i); - (account, pair) + (account, public) }) .collect() } @@ -195,7 +188,6 @@ impl BenchBuilder { fn max_validators() -> u32 { let config_max = configuration::Pallet::::config().max_validators.unwrap_or(200); - // self.validator_count.and_then(|c| Some(c.max(config_max))).unwrap_or(config_max) config_max } @@ -222,13 +214,12 @@ impl BenchBuilder { } /// Setup session 1 and create `self.validators_map` and `self.validators`. - fn setup_session_1(mut self, validators: Vec<(T::AccountId, ValidatorPair)>) -> Self { - assert_eq!(self.current_session, 0); + fn setup_session_1(mut self, validators: Vec<(T::AccountId, ValidatorId)>) -> Self { // initialize session 1. initializer::Pallet::::test_trigger_on_new_session( true, // indicate the validator set has changed 1, // session index - validators.clone().iter().map(|(a, v)| (a, v.public())), // validators + validators.clone().iter().map(|(a, v)| (a, v.clone())), // validators None, // queued - when this is None validators are considered queued ); @@ -246,26 +237,21 @@ impl BenchBuilder { // confirm setup at session change. // assert_eq!(scheduler::AvailabilityCores::::get().len(), Self::cores() as usize); assert_eq!(scheduler::ValidatorGroups::::get().len(), Self::cores() as usize); + assert_eq!(>::session_index(), 1); - // assert the current session is 0. - self.current_session = 1; - assert_eq!(self.current_session, self.current_session); - - assert_eq!(>::session_index(), self.current_session); - - // create map of validator public id => signing pair. - let validators_map: HashMap<_, _> = - validators.iter().map(|(_, pair)| (pair.public(), pair.clone())).collect(); + log::info!(target: LOG_TARGET, "b"); // get validators from session info. We need to refetch them since they have been shuffled. let validators_shuffled: Vec<_> = - session_info::Pallet::::session_info(self.current_session) + session_info::Pallet::::session_info(1) .unwrap() .validators .clone() .into_iter() .enumerate() .map(|(val_idx, public)| { + // TODO we don't actually need to map here anymore, can just to a for loop to + // sanity check things. { // sanity check that the validator keys line up as expected. let active_val_keys = shared::Pallet::::active_validator_keys(); @@ -273,13 +259,10 @@ impl BenchBuilder { assert_eq!(public, *public_check); } - let pair = validators_map.get(&public).unwrap().clone(); - - (public, pair) + public }) .collect(); - self.validators_map = Some(validators_map); self.validators = Some(validators_shuffled); self @@ -292,10 +275,6 @@ impl BenchBuilder { ) -> (Vec>, Vec>) { let validators = self.validators.as_ref().expect("must have some validators prior to calling"); - let validator_map = self - .validators_map - .as_ref() - .expect("must have some validator map prior to calling"); let config = configuration::Pallet::::config(); let backed_rng = first..last; @@ -306,18 +285,21 @@ impl BenchBuilder { let bitfields: Vec> = validators .iter() .enumerate() - .map(|(i, (_public, pair))| { + .map(|(i, public)| { let unchecked_signed = UncheckedSigned::::benchmark_sign( - pair, + public, availability_bitvec.clone(), &Self::signing_context(), ValidatorIndex(i as u32), ); + unchecked_signed }) .collect(); + log::info!(target: LOG_TARGET, "c"); + for seed in backed_rng.clone() { // make sure the candidates that are concluding by becoming available are marked as // pending availability. @@ -335,13 +317,17 @@ impl BenchBuilder { }); } + log::info!(target: LOG_TARGET, "d"); + + let backed_candidates: Vec> = backed_rng .clone() .map(|seed| { - let rng_seed = byte32_slice_from(seed); let (para_id, _core_idx, group_idx) = Self::create_indexes(seed); - let collator_pair = CollatorPair::from_seed_slice(&rng_seed).unwrap(); + // generate a pair and add it to the keystore. + let collator_public = CollatorId::generate_pair(None); + let relay_parent = Self::header().hash(); let head_data: HeadData = Default::default(); let persisted_validation_data_hash = PersistedValidationData:: { @@ -357,13 +343,14 @@ impl BenchBuilder { let pov_hash = Default::default(); let validation_code_hash = Default::default(); - let signature = collator_pair.sign(&collator_signature_payload( + let payload = collator_signature_payload( &relay_parent, ¶_id, &persisted_validation_data_hash, &pov_hash, &validation_code_hash, - )); + ); + let signature = collator_public.sign(&payload).unwrap(); // set the head data so it can be used while validating the signatures on the candidate // receipt. @@ -385,7 +372,8 @@ impl BenchBuilder { descriptor: CandidateDescriptor:: { para_id, relay_parent, - collator: collator_pair.public(), + // collator: collator_pair.public(), + collator: collator_public, persisted_validation_data_hash, pov_hash, erasure_root: Default::default(), @@ -408,11 +396,11 @@ impl BenchBuilder { let validity_votes: Vec<_> = group_validators .iter() .map(|val_idx| { - let (public, _) = validators.get(val_idx.0 as usize).unwrap(); + let public = validators.get(val_idx.0 as usize).unwrap(); - let pair = validator_map.get(public).unwrap(); + // let pair = validator_map.get(public).unwrap(); let sig = UncheckedSigned::::benchmark_sign( - pair, + public, CompactStatement::Valid(candidate_hash.clone()), &Self::signing_context(), *val_idx, @@ -431,6 +419,8 @@ impl BenchBuilder { }) .collect(); + log::info!(target: LOG_TARGET, "e"); + (backed_candidates, bitfields) } @@ -439,6 +429,10 @@ impl BenchBuilder { self.validators.as_ref().expect("must have some validators prior to calling"); let config = configuration::Pallet::::config(); + + log::info!(target: LOG_TARGET, "f"); + log::info!(target: LOG_TARGET, "disputes with spam start {}, last {}", start, last); + let mut spam_count = 0; (start..last) .map(|seed| { @@ -469,9 +463,11 @@ impl BenchBuilder { // threshold and thus these statements will not be counted as potential spam. 0..Self::max_statements() }; + log::info!(target: LOG_TARGET, "g"); + let statements = statement_range .map(|validator_index| { - let validator_pair = &validators.get(validator_index as usize).unwrap().1; + let validator_public = &validators.get(validator_index as usize).unwrap(); // we need dispute statements on each side. let dispute_statement = if validator_index % 2 == 0 { @@ -480,8 +476,11 @@ impl BenchBuilder { DisputeStatement::Valid(ValidDisputeStatementKind::Explicit) }; let data = dispute_statement - .payload_data(candidate_hash.clone(), self.current_session); - let statement_sig = validator_pair.sign(&data); + .payload_data(candidate_hash.clone(), 1); + + // let debug_res = validator_pair.public().sign(&data); + // println!("debug res validator sign {}", debug_res); + let statement_sig = validator_public.sign(&data).unwrap(); (dispute_statement, ValidatorIndex(validator_index), statement_sig) }) @@ -494,7 +493,7 @@ impl BenchBuilder { // return dispute statements with metadata. DisputeStatementSet { candidate_hash: candidate_hash.clone(), - session: self.current_session, + session: 1, statements, } }) @@ -502,14 +501,15 @@ impl BenchBuilder { } fn build(self, backed_and_concluding: u32, disputed: u32) -> Bench { - // make sure relevant storage is cleared. TODO + // make sure relevant storage is cleared. TODO this is just to get the asserts to work when + // running tests because it seems the storage is not cleared in between. inclusion::PendingAvailabilityCommitments::::remove_all(None); inclusion::PendingAvailability::::remove_all(None); Self::setup_para_ids(Self::cores()); - let validator_pairs = Self::generate_validator_pairs(Self::max_validators()); - let builder = self.setup_session_1(validator_pairs); + let validator_ids = Self::generate_validator_pairs(Self::max_validators()); + let builder = self.setup_session_1(validator_ids); let (backed_candidates, bitfields) = builder.create_fully_available_and_new_backed(0, backed_and_concluding); @@ -517,6 +517,7 @@ impl BenchBuilder { let last_disputed = backed_and_concluding + disputed; assert!(last_disputed <= Self::cores()); let disputes = builder.create_disputes_with_some_spam(backed_and_concluding, last_disputed); + log::info!(target: LOG_TARGET, "i"); // spam slots are empty prior. // TODO @@ -530,6 +531,9 @@ impl BenchBuilder { (disputed + backed_and_concluding) as usize ); + log::info!(target: LOG_TARGET, "k"); + + Bench:: { data: ParachainsInherentData { bitfields, @@ -596,13 +600,17 @@ benchmarks! { enter_disputes_only { let d in 0..BenchBuilder::::cores(); + log::info!(target: LOG_TARGET, "a"); let backed_and_concluding = 0; let config = configuration::Pallet::::config(); let scenario = BenchBuilder::::new() .build(backed_and_concluding, d); + log::info!(target: LOG_TARGET, "x"); + }: enter(RawOrigin::None, scenario.data.clone()) verify { + log::warn!(target: LOG_TARGET, "y"); // check that the disputes storage has updated as expected. // TODO @@ -623,6 +631,7 @@ benchmarks! { // ); // } + // pending availability data is removed when disputes are collected. assert_eq!( inclusion::PendingAvailabilityCommitments::::iter().count(),