pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-07-20 22:05:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make BlockImport and Verifier async (#8472)

Browse Source 
* Make grandpa work

* Introduce `SharedData`

* Add test and fix bugs

* Switch to `SharedData`

* Make grandpa tests working

* More Babe work

* Make it async

* Fix fix

* Use `async_trait` in sc-consensus-slots

This makes the code a little bit easier to read and also expresses that
there can always only be one call at a time to `on_slot`.

* Make grandpa tests compile

* More Babe tests work

* Fix network test

* Start fixing service test

* Finish service-test

* Fix sc-consensus-aura

* Fix fix fix

* More fixes

* Make everything compile *yeah*

* Fix build when we have Rust 1.51

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/babe/src/tests.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/babe/src/tests.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Fix warning

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>
This commit is contained in:
Bastian Köcher
2021-03-30 11:19:49 +02:00
committed by GitHub
parent 2998b42311
commit 217c4be226
65 changed files with 1241 additions and 715 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/client/service/Cargo.toml
+1
View File
@@ -78,6 +78,7 @@ sp-tracing = { version = "3.0.0", path = "../../primitives/tracing" }
tracing = "0.1.25"
tracing-futures = { version = "0.2.4" }
parity-util-mem = { version = "0.9.0", default-features = false, features = ["primitive-types"] }
async-trait = "0.1.42"
[target.'cfg(not(target_os = "unknown"))'.dependencies]
tempfile = "3.1.0"
substrate/client/service/src/client/client.rs
+12 -6
View File
@@ -1698,6 +1698,7 @@ impl<B, E, Block, RA> CallApiAt<Block> for Client<B, E, Block, RA> where
/// NOTE: only use this implementation when you are sure there are NO consensus-level BlockImport
/// objects. Otherwise, importing blocks directly into the client would be bypassing
/// important verification work.
#[async_trait::async_trait]
impl<B, E, Block, RA> sp_consensus::BlockImport<Block> for &Client<B, E, Block, RA> where
B: backend::Backend<Block>,
E: CallExecutor<Block> + Send + Sync,
@@ -1705,6 +1706,8 @@ impl<B, E, Block, RA> sp_consensus::BlockImport<Block> for &Client<B, E, Block,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: CoreApi<Block> +
ApiExt<Block, StateBackend = B::State>,
RA: Sync + Send,
backend::TransactionFor<B, Block>: Send + 'static,
{
type Error = ConsensusError;
type Transaction = backend::TransactionFor<B, Block>;
@@ -1718,7 +1721,7 @@ impl<B, E, Block, RA> sp_consensus::BlockImport<Block> for &Client<B, E, Block,
///
/// If you are not sure that there are no BlockImport objects provided by the consensus
/// algorithm, don't use this function.
fn import_block(
async fn import_block(
&mut self,
mut import_block: BlockImportParams<Block, backend::TransactionFor<B, Block>>,
new_cache: HashMap<CacheKeyId, Vec<u8>>,
@@ -1742,7 +1745,7 @@ impl<B, E, Block, RA> sp_consensus::BlockImport<Block> for &Client<B, E, Block,
}
/// Check block preconditions.
fn check_block(
async fn check_block(
&mut self,
block: BlockCheckParams<Block>,
) -> Result<ImportResult, Self::Error> {
@@ -1798,6 +1801,7 @@ impl<B, E, Block, RA> sp_consensus::BlockImport<Block> for &Client<B, E, Block,
}
}
#[async_trait::async_trait]
impl<B, E, Block, RA> sp_consensus::BlockImport<Block> for Client<B, E, Block, RA> where
B: backend::Backend<Block>,
E: CallExecutor<Block> + Send + Sync,
@@ -1805,23 +1809,25 @@ impl<B, E, Block, RA> sp_consensus::BlockImport<Block> for Client<B, E, Block, R
Self: ProvideRuntimeApi<Block>,
<Self as ProvideRuntimeApi<Block>>::Api: CoreApi<Block> +
ApiExt<Block, StateBackend = B::State>,
RA: Sync + Send,
backend::TransactionFor<B, Block>: Send + 'static,
{
type Error = ConsensusError;
type Transaction = backend::TransactionFor<B, Block>;
fn import_block(
async fn import_block(
&mut self,
import_block: BlockImportParams<Block, Self::Transaction>,
new_cache: HashMap<CacheKeyId, Vec<u8>>,
) -> Result<ImportResult, Self::Error> {
(&*self).import_block(import_block, new_cache)
(&*self).import_block(import_block, new_cache).await
}
fn check_block(
async fn check_block(
&mut self,
block: BlockCheckParams<Block>,
) -> Result<ImportResult, Self::Error> {
(&*self).check_block(block)
(&*self).check_block(block).await
}
}
substrate/client/service/test/Cargo.toml
+1 -1
View File
@@ -28,7 +28,7 @@ sp-trie = { version = "3.0.0", path = "../../../primitives/trie" }
sp-storage = { version = "3.0.0", path = "../../../primitives/storage" }
sc-client-db = { version = "0.9.0", default-features = false, path = "../../db" }
futures = { version = "0.3.1", features = ["compat"] }
sc-service = { version = "0.9.0", default-features = false, features = ["test-helpers"], path = "../../service" }
sc-service = { version = "0.9.0", features = ["test-helpers"], path = "../../service" }
sc-network = { version = "0.9.0", path = "../../network" }
sp-consensus = { version = "0.9.0", path = "../../../primitives/consensus/common" }
sp-runtime = { version = "3.0.0", path = "../../../primitives/runtime" }
substrate/client/service/test/src/client/light.rs
+3 -3
View File
@@ -375,11 +375,11 @@ fn execution_proof_is_generated_and_checked() {
for i in 1u32..3u32 {
let mut digest = Digest::default();
digest.push(sp_runtime::generic::DigestItem::Other::<H256>(i.to_le_bytes().to_vec()));
remote_client.import_justified(
futures::executor::block_on(remote_client.import_justified(
BlockOrigin::Own,
remote_client.new_block(digest).unwrap().build().unwrap().block,
Justifications::from((*b"TEST", Default::default())),
).unwrap();
)).unwrap();
}
// check method that doesn't requires environment
@@ -540,7 +540,7 @@ fn prepare_for_header_proof_check(insert_cht: bool) -> (TestChecker, Hash, Heade
let mut local_headers_hashes = Vec::new();
for i in 0..4 {
let block = remote_client.new_block(Default::default()).unwrap().build().unwrap().block;
remote_client.import(BlockOrigin::Own, block).unwrap();
futures::executor::block_on(remote_client.import(BlockOrigin::Own, block)).unwrap();
local_headers_hashes.push(
remote_client.block_hash(i + 1)
.map_err(|_| ClientError::Backend("TestError".into()))
substrate/client/service/test/src/client/mod.rs
+170 -103
View File
@@ -54,6 +54,7 @@ use sp_storage::StorageKey;
use sp_trie::{TrieConfiguration, trie_types::Layout};
use sp_runtime::{generic::BlockId, DigestItem, Justifications};
use hex_literal::hex;
use futures::executor::block_on;
mod light;
mod db;
@@ -108,7 +109,7 @@ pub fn prepare_client_with_key_changes() -> (
}).unwrap();
}
let block = builder.build().unwrap().block;
remote_client.import(BlockOrigin::Own, block).unwrap();
block_on(remote_client.import(BlockOrigin::Own, block)).unwrap();
let header = remote_client.header(&BlockId::Number(i as u64 + 1)).unwrap().unwrap();
let trie_root = header.digest().log(DigestItem::as_changes_trie_root)
@@ -363,7 +364,7 @@ fn block_builder_works_with_no_transactions() {
let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
assert_eq!(client.chain_info().best_number, 1);
}
@@ -382,7 +383,7 @@ fn block_builder_works_with_transactions() {
}).unwrap();
let block = builder.build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
assert_eq!(client.chain_info().best_number, 1);
assert_ne!(
@@ -428,7 +429,7 @@ fn block_builder_does_not_include_invalid() {
);
let block = builder.build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
assert_eq!(client.chain_info().best_number, 1);
assert_ne!(
@@ -476,11 +477,11 @@ fn uncles_with_only_ancestors() {
// G -> A1
let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
// A1 -> A2
let a2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
let v: Vec<H256> = Vec::new();
assert_eq!(v, client.uncles(a2.hash(), 3).unwrap());
}
@@ -496,7 +497,7 @@ fn uncles_with_multiple_forks() {
// G -> A1
let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
// A1 -> A2
let a2 = client.new_block_at(
@@ -504,7 +505,7 @@ fn uncles_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
// A2 -> A3
let a3 = client.new_block_at(
@@ -512,7 +513,7 @@ fn uncles_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a3.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
// A3 -> A4
let a4 = client.new_block_at(
@@ -520,7 +521,7 @@ fn uncles_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a4.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
// A4 -> A5
let a5 = client.new_block_at(
@@ -528,7 +529,7 @@ fn uncles_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a5.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
// A1 -> B2
let mut builder = client.new_block_at(
@@ -544,7 +545,7 @@ fn uncles_with_multiple_forks() {
nonce: 0,
}).unwrap();
let b2 = builder.build().unwrap().block;
client.import(BlockOrigin::Own, b2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
// B2 -> B3
let b3 = client.new_block_at(
@@ -552,7 +553,7 @@ fn uncles_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, b3.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
// B3 -> B4
let b4 = client.new_block_at(
@@ -560,7 +561,7 @@ fn uncles_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, b4.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b4.clone())).unwrap();
// // B2 -> C3
let mut builder = client.new_block_at(
@@ -576,7 +577,7 @@ fn uncles_with_multiple_forks() {
nonce: 1,
}).unwrap();
let c3 = builder.build().unwrap().block;
client.import(BlockOrigin::Own, c3.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, c3.clone())).unwrap();
// A1 -> D2
let mut builder = client.new_block_at(
@@ -592,7 +593,7 @@ fn uncles_with_multiple_forks() {
nonce: 0,
}).unwrap();
let d2 = builder.build().unwrap().block;
client.import(BlockOrigin::Own, d2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, d2.clone())).unwrap();
let genesis_hash = client.chain_info().genesis_hash;
@@ -624,11 +625,11 @@ fn best_containing_on_longest_chain_with_single_chain_3_blocks() {
// G -> A1
let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
// A1 -> A2
let a2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
let genesis_hash = client.chain_info().genesis_hash;
@@ -648,7 +649,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
// G -> A1
let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
// A1 -> A2
let a2 = client.new_block_at(
@@ -656,7 +657,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
// A2 -> A3
let a3 = client.new_block_at(
@@ -664,7 +665,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a3.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
// A3 -> A4
let a4 = client.new_block_at(
@@ -672,7 +673,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a4.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
// A4 -> A5
let a5 = client.new_block_at(
@@ -680,7 +681,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a5.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
// A1 -> B2
let mut builder = client.new_block_at(
@@ -696,7 +697,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
nonce: 0,
}).unwrap();
let b2 = builder.build().unwrap().block;
client.import(BlockOrigin::Own, b2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
// B2 -> B3
let b3 = client.new_block_at(
@@ -704,7 +705,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, b3.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
// B3 -> B4
let b4 = client.new_block_at(
@@ -712,7 +713,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, b4.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b4.clone())).unwrap();
// // B2 -> C3
let mut builder = client.new_block_at(
@@ -728,7 +729,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
nonce: 1,
}).unwrap();
let c3 = builder.build().unwrap().block;
client.import(BlockOrigin::Own, c3.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, c3.clone())).unwrap();
// A1 -> D2
let mut builder = client.new_block_at(
@@ -744,7 +745,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
nonce: 0,
}).unwrap();
let d2 = builder.build().unwrap().block;
client.import(BlockOrigin::Own, d2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, d2.clone())).unwrap();
assert_eq!(client.chain_info().best_hash, a5.hash());
@@ -952,11 +953,15 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
assert_eq!(None, longest_chain_select.finality_target(
b4.hash(), Some(0)).unwrap());
assert_eq!(None, longest_chain_select.finality_target(
c3.hash().clone(), Some(0)).unwrap());
assert_eq!(
None,
longest_chain_select.finality_target(c3.hash().clone(), Some(0)).unwrap(),
);
assert_eq!(None, longest_chain_select.finality_target(
d2.hash().clone(), Some(0)).unwrap());
assert_eq!(
None,
longest_chain_select.finality_target(d2.hash().clone(), Some(0)).unwrap(),
);
}
#[test]
@@ -968,15 +973,18 @@ fn best_containing_on_longest_chain_with_max_depth_higher_than_best() {
// G -> A1
let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
// A1 -> A2
let a2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
let genesis_hash = client.chain_info().genesis_hash;
assert_eq!(a2.hash(), longest_chain_select.finality_target(genesis_hash, Some(10)).unwrap().unwrap());
assert_eq!(
a2.hash(),
longest_chain_select.finality_target(genesis_hash, Some(10)).unwrap().unwrap(),
);
}
#[test]
@@ -1008,7 +1016,7 @@ fn import_with_justification() {
// G -> A1
let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
// A1 -> A2
let a2 = client.new_block_at(
@@ -1016,7 +1024,7 @@ fn import_with_justification() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
// A2 -> A3
let justification = Justifications::from((TEST_ENGINE_ID, vec![1, 2, 3]));
@@ -1025,7 +1033,7 @@ fn import_with_justification() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import_justified(BlockOrigin::Own, a3.clone(), justification.clone()).unwrap();
block_on(client.import_justified(BlockOrigin::Own, a3.clone(), justification.clone())).unwrap();
assert_eq!(
client.chain_info().finalized_hash,
@@ -1060,14 +1068,14 @@ fn importing_diverged_finalized_block_should_trigger_reorg() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
let a2 = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
let mut b1 = client.new_block_at(
&BlockId::Number(0),
@@ -1092,7 +1100,7 @@ fn importing_diverged_finalized_block_should_trigger_reorg() {
// importing B1 as finalized should trigger a re-org and set it as new best
let justification = Justifications::from((TEST_ENGINE_ID, vec![1, 2, 3]));
client.import_justified(BlockOrigin::Own, b1.clone(), justification).unwrap();
block_on(client.import_justified(BlockOrigin::Own, b1.clone(), justification)).unwrap();
assert_eq!(
client.chain_info().best_hash,
@@ -1117,14 +1125,14 @@ fn finalizing_diverged_block_should_trigger_reorg() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
let a2 = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
let mut b1 = client.new_block_at(
&BlockId::Number(0),
@@ -1139,14 +1147,14 @@ fn finalizing_diverged_block_should_trigger_reorg() {
nonce: 0,
}).unwrap();
let b1 = b1.build().unwrap().block;
client.import(BlockOrigin::Own, b1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b1.clone())).unwrap();
let b2 = client.new_block_at(
&BlockId::Hash(b1.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, b2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
// A2 is the current best since it's the longest chain
assert_eq!(
@@ -1184,7 +1192,7 @@ fn finalizing_diverged_block_should_trigger_reorg() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, b3.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
assert_eq!(
client.chain_info().best_hash,
@@ -1227,7 +1235,7 @@ fn state_reverted_on_reorg() {
nonce: 0,
}).unwrap();
let a1 = a1.build().unwrap().block;
client.import(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
let mut b1 = client.new_block_at(
&BlockId::Number(0),
@@ -1242,7 +1250,7 @@ fn state_reverted_on_reorg() {
}).unwrap();
let b1 = b1.build().unwrap().block;
// Reorg to B1
client.import_as_best(BlockOrigin::Own, b1.clone()).unwrap();
block_on(client.import_as_best(BlockOrigin::Own, b1.clone())).unwrap();
assert_eq!(950, current_balance(&client));
let mut a2 = client.new_block_at(
@@ -1258,7 +1266,7 @@ fn state_reverted_on_reorg() {
}).unwrap();
let a2 = a2.build().unwrap().block;
// Re-org to A2
client.import_as_best(BlockOrigin::Own, a2).unwrap();
block_on(client.import_as_best(BlockOrigin::Own, a2)).unwrap();
assert_eq!(980, current_balance(&client));
}
@@ -1297,14 +1305,14 @@ fn doesnt_import_blocks_that_revert_finality() {
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
let a2 = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, a2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
let mut b1 = client.new_block_at(&BlockId::Number(0), Default::default(), false).unwrap();
@@ -1316,11 +1324,11 @@ fn doesnt_import_blocks_that_revert_finality() {
nonce: 0,
}).unwrap();
let b1 = b1.build().unwrap().block;
client.import(BlockOrigin::Own, b1.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b1.clone())).unwrap();
let b2 = client.new_block_at(&BlockId::Hash(b1.hash()), Default::default(), false)
.unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, b2.clone()).unwrap();
block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
// prepare B3 before we finalize A2, because otherwise we won't be able to
// read changes trie configuration after A2 is finalized
@@ -1331,7 +1339,7 @@ fn doesnt_import_blocks_that_revert_finality() {
// B3 at the same height but that doesn't include it
ClientExt::finalize_block(&client, BlockId::Hash(a2.hash()), None).unwrap();
let import_err = client.import(BlockOrigin::Own, b3).err().unwrap();
let import_err = block_on(client.import(BlockOrigin::Own, b3)).err().unwrap();
let expected_err = ConsensusError::ClientImport(
sp_blockchain::Error::RuntimeApiError(
sp_api::ApiError::Application(Box::new(sp_blockchain::Error::NotInFinalizedChain))
@@ -1356,7 +1364,7 @@ fn doesnt_import_blocks_that_revert_finality() {
}).unwrap();
let c1 = c1.build().unwrap().block;
let import_err = client.import(BlockOrigin::Own, c1).err().unwrap();
let import_err = block_on(client.import(BlockOrigin::Own, c1)).err().unwrap();
let expected_err = ConsensusError::ClientImport(
sp_blockchain::Error::NotInFinalizedChain.to_string()
);
@@ -1367,7 +1375,6 @@ fn doesnt_import_blocks_that_revert_finality() {
);
}
#[test]
fn respects_block_rules() {
fn run_test(
@@ -1396,7 +1403,7 @@ fn respects_block_rules() {
allow_missing_state: false,
import_existing: false,
};
assert_eq!(client.check_block(params).unwrap(), ImportResult::imported(false));
assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::imported(false));
// this is 0x0d6d6612a10485370d9e085aeea7ec427fb3f34d961c6a816cdbe5cde2278864
let mut block_not_ok = client.new_block_at(&BlockId::Number(0), Default::default(), false)
@@ -1414,11 +1421,11 @@ fn respects_block_rules() {
if record_only {
known_bad.insert(block_not_ok.hash());
} else {
assert_eq!(client.check_block(params).unwrap(), ImportResult::KnownBad);
assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::KnownBad);
}
// Now going to the fork
client.import_as_final(BlockOrigin::Own, block_ok).unwrap();
block_on(client.import_as_final(BlockOrigin::Own, block_ok)).unwrap();
// And check good fork
let mut block_ok = client.new_block_at(&BlockId::Number(1), Default::default(), false)
@@ -1436,7 +1443,7 @@ fn respects_block_rules() {
if record_only {
fork_rules.push((1, block_ok.hash().clone()));
}
assert_eq!(client.check_block(params).unwrap(), ImportResult::imported(false));
assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::imported(false));
// And now try bad fork
let mut block_not_ok = client.new_block_at(&BlockId::Number(1), Default::default(), false)
@@ -1453,7 +1460,7 @@ fn respects_block_rules() {
};
if !record_only {
assert_eq!(client.check_block(params).unwrap(), ImportResult::KnownBad);
assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::KnownBad);
}
}
@@ -1491,8 +1498,11 @@ fn returns_status_for_pruned_blocks() {
let mut client = TestClientBuilder::with_backend(backend).build();
let a1 = client.new_block_at(&BlockId::Number(0), Default::default(), false)
.unwrap().build().unwrap().block;
let a1 = client.new_block_at(
&BlockId::Number(0),
Default::default(),
false,
).unwrap().build().unwrap().block;
let mut b1 = client.new_block_at(&BlockId::Number(0), Default::default(), false).unwrap();
@@ -1513,17 +1523,32 @@ fn returns_status_for_pruned_blocks() {
import_existing: false,
};
assert_eq!(client.check_block(check_block_a1.clone()).unwrap(), ImportResult::imported(false));
assert_eq!(client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(), BlockStatus::Unknown);
assert_eq!(
block_on(client.check_block(check_block_a1.clone())).unwrap(),
ImportResult::imported(false),
);
assert_eq!(
client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(),
BlockStatus::Unknown,
);
client.import_as_final(BlockOrigin::Own, a1.clone()).unwrap();
block_on(client.import_as_final(BlockOrigin::Own, a1.clone())).unwrap();
assert_eq!(client.check_block(check_block_a1.clone()).unwrap(), ImportResult::AlreadyInChain);
assert_eq!(client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(), BlockStatus::InChainWithState);
assert_eq!(
block_on(client.check_block(check_block_a1.clone())).unwrap(),
ImportResult::AlreadyInChain,
);
assert_eq!(
client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(),
BlockStatus::InChainWithState,
);
let a2 = client.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
.unwrap().build().unwrap().block;
client.import_as_final(BlockOrigin::Own, a2.clone()).unwrap();
let a2 = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
block_on(client.import_as_final(BlockOrigin::Own, a2.clone())).unwrap();
let check_block_a2 = BlockCheckParams {
hash: a2.hash().clone(),
@@ -1533,15 +1558,30 @@ fn returns_status_for_pruned_blocks() {
import_existing: false,
};
assert_eq!(client.check_block(check_block_a1.clone()).unwrap(), ImportResult::AlreadyInChain);
assert_eq!(client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(), BlockStatus::InChainPruned);
assert_eq!(client.check_block(check_block_a2.clone()).unwrap(), ImportResult::AlreadyInChain);
assert_eq!(client.block_status(&BlockId::hash(check_block_a2.hash)).unwrap(), BlockStatus::InChainWithState);
assert_eq!(
block_on(client.check_block(check_block_a1.clone())).unwrap(),
ImportResult::AlreadyInChain,
);
assert_eq!(
client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(),
BlockStatus::InChainPruned,
);
assert_eq!(
block_on(client.check_block(check_block_a2.clone())).unwrap(),
ImportResult::AlreadyInChain,
);
assert_eq!(
client.block_status(&BlockId::hash(check_block_a2.hash)).unwrap(),
BlockStatus::InChainWithState,
);
let a3 = client.new_block_at(&BlockId::Hash(a2.hash()), Default::default(), false)
.unwrap().build().unwrap().block;
let a3 = client.new_block_at(
&BlockId::Hash(a2.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import_as_final(BlockOrigin::Own, a3.clone()).unwrap();
block_on(client.import_as_final(BlockOrigin::Own, a3.clone())).unwrap();
let check_block_a3 = BlockCheckParams {
hash: a3.hash().clone(),
number: 2,
@@ -1551,12 +1591,30 @@ fn returns_status_for_pruned_blocks() {
};
// a1 and a2 are both pruned at this point
assert_eq!(client.check_block(check_block_a1.clone()).unwrap(), ImportResult::AlreadyInChain);
assert_eq!(client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(), BlockStatus::InChainPruned);
assert_eq!(client.check_block(check_block_a2.clone()).unwrap(), ImportResult::AlreadyInChain);
assert_eq!(client.block_status(&BlockId::hash(check_block_a2.hash)).unwrap(), BlockStatus::InChainPruned);
assert_eq!(client.check_block(check_block_a3.clone()).unwrap(), ImportResult::AlreadyInChain);
assert_eq!(client.block_status(&BlockId::hash(check_block_a3.hash)).unwrap(), BlockStatus::InChainWithState);
assert_eq!(
block_on(client.check_block(check_block_a1.clone())).unwrap(),
ImportResult::AlreadyInChain,
);
assert_eq!(
client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(),
BlockStatus::InChainPruned,
);
assert_eq!(
block_on(client.check_block(check_block_a2.clone())).unwrap(),
ImportResult::AlreadyInChain,
);
assert_eq!(
client.block_status(&BlockId::hash(check_block_a2.hash)).unwrap(),
BlockStatus::InChainPruned,
);
assert_eq!(
block_on(client.check_block(check_block_a3.clone())).unwrap(),
ImportResult::AlreadyInChain,
);
assert_eq!(
client.block_status(&BlockId::hash(check_block_a3.hash)).unwrap(),
BlockStatus::InChainWithState,
);
let mut check_block_b1 = BlockCheckParams {
hash: b1.hash().clone(),
@@ -1565,11 +1623,20 @@ fn returns_status_for_pruned_blocks() {
allow_missing_state: false,
import_existing: false,
};
assert_eq!(client.check_block(check_block_b1.clone()).unwrap(), ImportResult::MissingState);
assert_eq!(
block_on(client.check_block(check_block_b1.clone())).unwrap(),
ImportResult::MissingState,
);
check_block_b1.allow_missing_state = true;
assert_eq!(client.check_block(check_block_b1.clone()).unwrap(), ImportResult::imported(false));
assert_eq!(
block_on(client.check_block(check_block_b1.clone())).unwrap(),
ImportResult::imported(false),
);
check_block_b1.parent_hash = H256::random();
assert_eq!(client.check_block(check_block_b1.clone()).unwrap(), ImportResult::UnknownParent);
assert_eq!(
block_on(client.check_block(check_block_b1.clone())).unwrap(),
ImportResult::UnknownParent,
);
}
#[test]
@@ -1600,18 +1667,18 @@ fn imports_blocks_with_changes_tries_config_change() {
(1..11).for_each(|number| {
let block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false)
.unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
(11..12).for_each(|number| {
let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
block.push_storage_change(vec![42], Some(number.to_le_bytes().to_vec())).unwrap();
let block = block.build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
(12..23).for_each(|number| {
let block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false)
.unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
(23..24).for_each(|number| {
let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
@@ -1620,24 +1687,24 @@ fn imports_blocks_with_changes_tries_config_change() {
digest_levels: 1,
})).unwrap();
let block = block.build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
(24..26).for_each(|number| {
let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
block.push_storage_change(vec![42], Some(number.to_le_bytes().to_vec())).unwrap();
let block = block.build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
(26..27).for_each(|number| {
let block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false)
.unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
(27..28).for_each(|number| {
let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
block.push_storage_change(vec![42], Some(number.to_le_bytes().to_vec())).unwrap();
let block = block.build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
(28..29).for_each(|number| {
let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
@@ -1646,23 +1713,23 @@ fn imports_blocks_with_changes_tries_config_change() {
digest_levels: 1,
})).unwrap();
let block = block.build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
(29..30).for_each(|number| {
let block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false)
.unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
(30..31).for_each(|number| {
let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
block.push_storage_change(vec![42], Some(number.to_le_bytes().to_vec())).unwrap();
let block = block.build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
(31..32).for_each(|number| {
let block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false)
.unwrap().build().unwrap().block;
client.import(BlockOrigin::Own, block).unwrap();
block_on(client.import(BlockOrigin::Own, block)).unwrap();
});
// now check that configuration cache works
@@ -1778,7 +1845,7 @@ fn cleans_up_closed_notification_sinks_on_block_import() {
let mut import = BlockImportParams::new(origin, header);
import.body = Some(extrinsics);
import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
client.import_block(import, Default::default()).unwrap();
block_on(client.import_block(import, Default::default())).unwrap();
};
// after importing a block we should still have 4 notification sinks
@@ -1821,14 +1888,14 @@ fn reorg_triggers_a_notification_even_for_sources_that_should_not_trigger_notifi
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::NetworkInitialSync, a1.clone()).unwrap();
block_on(client.import(BlockOrigin::NetworkInitialSync, a1.clone())).unwrap();
let a2 = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
client.import(BlockOrigin::NetworkInitialSync, a2.clone()).unwrap();
block_on(client.import(BlockOrigin::NetworkInitialSync, a2.clone())).unwrap();
let mut b1 = client.new_block_at(
&BlockId::Number(0),
@@ -1843,7 +1910,7 @@ fn reorg_triggers_a_notification_even_for_sources_that_should_not_trigger_notifi
nonce: 0,
}).unwrap();
let b1 = b1.build().unwrap().block;
client.import(BlockOrigin::NetworkInitialSync, b1.clone()).unwrap();
block_on(client.import(BlockOrigin::NetworkInitialSync, b1.clone())).unwrap();
let b2 = client.new_block_at(
&BlockId::Hash(b1.hash()),
@@ -1852,7 +1919,7 @@ fn reorg_triggers_a_notification_even_for_sources_that_should_not_trigger_notifi
).unwrap().build().unwrap().block;
// Should trigger a notification because we reorg
client.import_as_best(BlockOrigin::NetworkInitialSync, b2.clone()).unwrap();
block_on(client.import_as_best(BlockOrigin::NetworkInitialSync, b2.clone())).unwrap();
// There should be one notification
let notification = notification_stream.next().unwrap();