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

BlockId removal: &Hash to Hash (#12626)

Browse Source 
It changes &Block::Hash argument to Block::Hash.

This PR is part of BlockId::Number refactoring analysis (paritytech/substrate#11292)
This commit is contained in:
Michal Kucharczyk
2022-11-07 22:42:16 +01:00
committed by GitHub
parent 7c4bfc9749
commit 1ed70004e7
49 changed files with 428 additions and 441 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/bin/node/bench/src/import.rs
+1 -1
View File
@@ -135,7 +135,7 @@ impl core::Benchmark for ImportBenchmark {
// Sanity checks.
context
.client
.state_at(&hash)
.state_at(hash)
.expect("state_at failed for block#1")
.inspect_state(|| {
match self.block_type {
substrate/bin/node/inspect/src/lib.rs
+2 -2
View File
@@ -144,7 +144,7 @@ impl<TBlock: Block, TPrinter: PrettyPrinter<TBlock>> Inspector<TBlock, TPrinter>
let not_found = format!("Could not find block {:?}", id);
let body = self
.chain
.block_body(&hash)?
.block_body(hash)?
.ok_or_else(|| Error::NotFound(not_found.clone()))?;
let header =
self.chain.header(id)?.ok_or_else(|| Error::NotFound(not_found.clone()))?;
@@ -155,7 +155,7 @@ impl<TBlock: Block, TPrinter: PrettyPrinter<TBlock>> Inspector<TBlock, TPrinter>
let not_found = format!("Could not find block {:?}", id);
let body = self
.chain
.block_body(&hash)?
.block_body(hash)?
.ok_or_else(|| Error::NotFound(not_found.clone()))?;
let header =
self.chain.header(id)?.ok_or_else(|| Error::NotFound(not_found.clone()))?;
substrate/client/api/src/backend.rs
+19 -19
View File
@@ -215,13 +215,13 @@ pub trait BlockImportOperation<Block: BlockT> {
/// Mark a block as finalized.
fn mark_finalized(
&mut self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
) -> sp_blockchain::Result<()>;
/// Mark a block as new head. If both block import and set head are specified, set head
/// overrides block import's best block rule.
fn mark_head(&mut self, hash: &Block::Hash) -> sp_blockchain::Result<()>;
fn mark_head(&mut self, hash: Block::Hash) -> sp_blockchain::Result<()>;
/// Add a transaction index operation.
fn update_transaction_index(&mut self, index: Vec<IndexOperation>)
@@ -251,7 +251,7 @@ pub trait Finalizer<Block: BlockT, B: Backend<Block>> {
fn apply_finality(
&self,
operation: &mut ClientImportOperation<Block, B>,
block: &Block::Hash,
block: Block::Hash,
justification: Option<Justification>,
notify: bool,
) -> sp_blockchain::Result<()>;
@@ -271,7 +271,7 @@ pub trait Finalizer<Block: BlockT, B: Backend<Block>> {
/// while performing major synchronization work.
fn finalize_block(
&self,
block: &Block::Hash,
block: Block::Hash,
justification: Option<Justification>,
notify: bool,
) -> sp_blockchain::Result<()>;
@@ -359,21 +359,21 @@ pub trait StorageProvider<Block: BlockT, B: Backend<Block>> {
/// Given a block's `Hash` and a key, return the value under the key in that block.
fn storage(
&self,
hash: &Block::Hash,
hash: Block::Hash,
key: &StorageKey,
) -> sp_blockchain::Result<Option<StorageData>>;
/// Given a block's `Hash` and a key prefix, return the matching storage keys in that block.
fn storage_keys(
&self,
hash: &Block::Hash,
hash: Block::Hash,
key_prefix: &StorageKey,
) -> sp_blockchain::Result<Vec<StorageKey>>;
/// Given a block's `Hash` and a key, return the value under the hash in that block.
fn storage_hash(
&self,
hash: &Block::Hash,
hash: Block::Hash,
key: &StorageKey,
) -> sp_blockchain::Result<Option<Block::Hash>>;
@@ -381,7 +381,7 @@ pub trait StorageProvider<Block: BlockT, B: Backend<Block>> {
/// in that block.
fn storage_pairs(
&self,
hash: &Block::Hash,
hash: Block::Hash,
key_prefix: &StorageKey,
) -> sp_blockchain::Result<Vec<(StorageKey, StorageData)>>;
@@ -389,7 +389,7 @@ pub trait StorageProvider<Block: BlockT, B: Backend<Block>> {
/// keys in that block.
fn storage_keys_iter<'a>(
&self,
hash: &Block::Hash,
hash: Block::Hash,
prefix: Option<&'a StorageKey>,
start_key: Option<&StorageKey>,
) -> sp_blockchain::Result<KeyIterator<'a, B::State, Block>>;
@@ -398,7 +398,7 @@ pub trait StorageProvider<Block: BlockT, B: Backend<Block>> {
/// that block.
fn child_storage(
&self,
hash: &Block::Hash,
hash: Block::Hash,
child_info: &ChildInfo,
key: &StorageKey,
) -> sp_blockchain::Result<Option<StorageData>>;
@@ -407,7 +407,7 @@ pub trait StorageProvider<Block: BlockT, B: Backend<Block>> {
/// storage keys.
fn child_storage_keys(
&self,
hash: &Block::Hash,
hash: Block::Hash,
child_info: &ChildInfo,
key_prefix: &StorageKey,
) -> sp_blockchain::Result<Vec<StorageKey>>;
@@ -416,7 +416,7 @@ pub trait StorageProvider<Block: BlockT, B: Backend<Block>> {
/// return a `KeyIterator` that iterates matching storage keys in that block.
fn child_storage_keys_iter<'a>(
&self,
hash: &Block::Hash,
hash: Block::Hash,
child_info: ChildInfo,
prefix: Option<&'a StorageKey>,
start_key: Option<&StorageKey>,
@@ -426,7 +426,7 @@ pub trait StorageProvider<Block: BlockT, B: Backend<Block>> {
/// block.
fn child_storage_hash(
&self,
hash: &Block::Hash,
hash: Block::Hash,
child_info: &ChildInfo,
key: &StorageKey,
) -> sp_blockchain::Result<Option<Block::Hash>>;
@@ -466,7 +466,7 @@ pub trait Backend<Block: BlockT>: AuxStore + Send + Sync {
fn begin_state_operation(
&self,
operation: &mut Self::BlockImportOperation,
block: &Block::Hash,
block: Block::Hash,
) -> sp_blockchain::Result<()>;
/// Commit block insertion.
@@ -480,7 +480,7 @@ pub trait Backend<Block: BlockT>: AuxStore + Send + Sync {
/// This should only be called if the parent of the given block has been finalized.
fn finalize_block(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
) -> sp_blockchain::Result<()>;
@@ -489,7 +489,7 @@ pub trait Backend<Block: BlockT>: AuxStore + Send + Sync {
/// This should only be called for blocks that are already finalized.
fn append_justification(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Justification,
) -> sp_blockchain::Result<()>;
@@ -503,12 +503,12 @@ pub trait Backend<Block: BlockT>: AuxStore + Send + Sync {
fn offchain_storage(&self) -> Option<Self::OffchainStorage>;
/// Returns true if state for given block is available.
fn have_state_at(&self, hash: &Block::Hash, _number: NumberFor<Block>) -> bool {
fn have_state_at(&self, hash: Block::Hash, _number: NumberFor<Block>) -> bool {
self.state_at(hash).is_ok()
}
/// Returns state backend with post-state of given block.
fn state_at(&self, hash: &Block::Hash) -> sp_blockchain::Result<Self::State>;
fn state_at(&self, hash: Block::Hash) -> sp_blockchain::Result<Self::State>;
/// Attempts to revert the chain by `n` blocks. If `revert_finalized` is set it will attempt to
/// revert past any finalized block, this is unsafe and can potentially leave the node in an
@@ -524,7 +524,7 @@ pub trait Backend<Block: BlockT>: AuxStore + Send + Sync {
) -> sp_blockchain::Result<(NumberFor<Block>, HashSet<Block::Hash>)>;
/// Discard non-best, unfinalized leaf block.
fn remove_leaf_block(&self, hash: &Block::Hash) -> sp_blockchain::Result<()>;
fn remove_leaf_block(&self, hash: Block::Hash) -> sp_blockchain::Result<()>;
/// Insert auxiliary data into key-value store.
fn insert_aux<
substrate/client/api/src/client.rs
+5 -6
View File
@@ -110,7 +110,7 @@ pub trait BlockBackend<Block: BlockT> {
/// Get block body by ID. Returns `None` if the body is not stored.
fn block_body(
&self,
hash: &Block::Hash,
hash: Block::Hash,
) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>>;
/// Get all indexed transactions for a block,
@@ -118,8 +118,7 @@ pub trait BlockBackend<Block: BlockT> {
///
/// Note that this will only fetch transactions
/// that are indexed by the runtime with `storage_index_transaction`.
fn block_indexed_body(&self, hash: &Block::Hash)
-> sp_blockchain::Result<Option<Vec<Vec<u8>>>>;
fn block_indexed_body(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<Vec<u8>>>>;
/// Get full block by id.
fn block(&self, id: &BlockId<Block>) -> sp_blockchain::Result<Option<SignedBlock<Block>>>;
@@ -129,7 +128,7 @@ pub trait BlockBackend<Block: BlockT> {
-> sp_blockchain::Result<sp_consensus::BlockStatus>;
/// Get block justifications for the block with the given id.
fn justifications(&self, hash: &Block::Hash) -> sp_blockchain::Result<Option<Justifications>>;
fn justifications(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Justifications>>;
/// Get block hash by number.
fn block_hash(&self, number: NumberFor<Block>) -> sp_blockchain::Result<Option<Block::Hash>>;
@@ -138,10 +137,10 @@ pub trait BlockBackend<Block: BlockT> {
///
/// Note that this will only fetch transactions
/// that are indexed by the runtime with `storage_index_transaction`.
fn indexed_transaction(&self, hash: &Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>>;
fn indexed_transaction(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>>;
/// Check if transaction index exists.
fn has_indexed_transaction(&self, hash: &Block::Hash) -> sp_blockchain::Result<bool> {
fn has_indexed_transaction(&self, hash: Block::Hash) -> sp_blockchain::Result<bool> {
Ok(self.indexed_transaction(hash)?.is_some())
}
substrate/client/api/src/in_mem.rs
+26 -26
View File
@@ -271,16 +271,16 @@ impl<Block: BlockT> Blockchain<Block> {
fn finalize_header(
&self,
block: &Block::Hash,
block: Block::Hash,
justification: Option<Justification>,
) -> sp_blockchain::Result<()> {
let mut storage = self.storage.write();
storage.finalized_hash = *block;
storage.finalized_hash = block;
if justification.is_some() {
let block = storage
.blocks
.get_mut(block)
.get_mut(&block)
.expect("hash was fetched from a block in the db; qed");
let block_justifications = match block {
@@ -295,7 +295,7 @@ impl<Block: BlockT> Blockchain<Block> {
fn append_justification(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Justification,
) -> sp_blockchain::Result<()> {
let mut storage = self.storage.write();
@@ -405,17 +405,17 @@ impl<Block: BlockT> HeaderMetadata<Block> for Blockchain<Block> {
impl<Block: BlockT> blockchain::Backend<Block> for Blockchain<Block> {
fn body(
&self,
hash: &Block::Hash,
hash: Block::Hash,
) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>> {
Ok(self
.storage
.read()
.blocks
.get(hash)
.get(&hash)
.and_then(|b| b.extrinsics().map(|x| x.to_vec())))
}
fn justifications(&self, hash: &Block::Hash) -> sp_blockchain::Result<Option<Justifications>> {
fn justifications(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Justifications>> {
Ok(self.storage.read().blocks.get(&hash).and_then(|b| b.justifications().cloned()))
}
@@ -445,13 +445,13 @@ impl<Block: BlockT> blockchain::Backend<Block> for Blockchain<Block> {
unimplemented!()
}
fn indexed_transaction(&self, _hash: &Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>> {
fn indexed_transaction(&self, _hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>> {
unimplemented!("Not supported by the in-mem backend.")
}
fn block_indexed_body(
&self,
_hash: &Block::Hash,
_hash: Block::Hash,
) -> sp_blockchain::Result<Option<Vec<Vec<u8>>>> {
unimplemented!("Not supported by the in-mem backend.")
}
@@ -596,16 +596,16 @@ where
fn mark_finalized(
&mut self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
) -> sp_blockchain::Result<()> {
self.finalized_blocks.push((*hash, justification));
self.finalized_blocks.push((hash, justification));
Ok(())
}
fn mark_head(&mut self, hash: &Block::Hash) -> sp_blockchain::Result<()> {
fn mark_head(&mut self, hash: Block::Hash) -> sp_blockchain::Result<()> {
assert!(self.pending_block.is_none(), "Only one set block per operation is allowed");
self.set_head = Some(*hash);
self.set_head = Some(hash);
Ok(())
}
@@ -677,7 +677,7 @@ where
type OffchainStorage = OffchainStorage;
fn begin_operation(&self) -> sp_blockchain::Result<Self::BlockImportOperation> {
let old_state = self.state_at(&Default::default())?;
let old_state = self.state_at(Default::default())?;
Ok(BlockImportOperation {
pending_block: None,
old_state,
@@ -691,7 +691,7 @@ where
fn begin_state_operation(
&self,
operation: &mut Self::BlockImportOperation,
block: &Block::Hash,
block: Block::Hash,
) -> sp_blockchain::Result<()> {
operation.old_state = self.state_at(block)?;
Ok(())
@@ -700,7 +700,7 @@ where
fn commit_operation(&self, operation: Self::BlockImportOperation) -> sp_blockchain::Result<()> {
if !operation.finalized_blocks.is_empty() {
for (block, justification) in operation.finalized_blocks {
self.blockchain.finalize_header(&block, justification)?;
self.blockchain.finalize_header(block, justification)?;
}
}
@@ -733,7 +733,7 @@ where
fn finalize_block(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
) -> sp_blockchain::Result<()> {
self.blockchain.finalize_header(hash, justification)
@@ -741,7 +741,7 @@ where
fn append_justification(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Justification,
) -> sp_blockchain::Result<()> {
self.blockchain.append_justification(hash, justification)
@@ -759,14 +759,14 @@ where
None
}
fn state_at(&self, hash: &Block::Hash) -> sp_blockchain::Result<Self::State> {
if *hash == Default::default() {
fn state_at(&self, hash: Block::Hash) -> sp_blockchain::Result<Self::State> {
if hash == Default::default() {
return Ok(Self::State::default())
}
self.states
.read()
.get(hash)
.get(&hash)
.cloned()
.ok_or_else(|| sp_blockchain::Error::UnknownBlock(format!("{}", hash)))
}
@@ -779,7 +779,7 @@ where
Ok((Zero::zero(), HashSet::new()))
}
fn remove_leaf_block(&self, _hash: &Block::Hash) -> sp_blockchain::Result<()> {
fn remove_leaf_block(&self, _hash: Block::Hash) -> sp_blockchain::Result<()> {
Ok(())
}
@@ -862,13 +862,13 @@ mod tests {
let blockchain = test_blockchain();
let last_finalized = blockchain.last_finalized().unwrap();
blockchain.append_justification(&last_finalized, (ID2, vec![4])).unwrap();
blockchain.append_justification(last_finalized, (ID2, vec![4])).unwrap();
let justifications = {
let mut just = Justifications::from((ID1, vec![3]));
just.append((ID2, vec![4]));
just
};
assert_eq!(blockchain.justifications(&last_finalized).unwrap(), Some(justifications));
assert_eq!(blockchain.justifications(last_finalized).unwrap(), Some(justifications));
}
#[test]
@@ -876,9 +876,9 @@ mod tests {
let blockchain = test_blockchain();
let last_finalized = blockchain.last_finalized().unwrap();
blockchain.append_justification(&last_finalized, (ID2, vec![0])).unwrap();
blockchain.append_justification(last_finalized, (ID2, vec![0])).unwrap();
assert!(matches!(
blockchain.append_justification(&last_finalized, (ID2, vec![1])),
blockchain.append_justification(last_finalized, (ID2, vec![1])),
Err(sp_blockchain::Error::BadJustification(_)),
));
}
substrate/client/api/src/proof_provider.rs
+5 -5
View File
@@ -27,7 +27,7 @@ pub trait ProofProvider<Block: BlockT> {
/// Reads storage value at a given block + key, returning read proof.
fn read_proof(
&self,
hash: &Block::Hash,
hash: Block::Hash,
keys: &mut dyn Iterator<Item = &[u8]>,
) -> sp_blockchain::Result<StorageProof>;
@@ -35,7 +35,7 @@ pub trait ProofProvider<Block: BlockT> {
/// read proof.
fn read_child_proof(
&self,
hash: &Block::Hash,
hash: Block::Hash,
child_info: &ChildInfo,
keys: &mut dyn Iterator<Item = &[u8]>,
) -> sp_blockchain::Result<StorageProof>;
@@ -46,7 +46,7 @@ pub trait ProofProvider<Block: BlockT> {
/// No changes are made.
fn execution_proof(
&self,
hash: &Block::Hash,
hash: Block::Hash,
method: &str,
call_data: &[u8],
) -> sp_blockchain::Result<(Vec<u8>, StorageProof)>;
@@ -61,7 +61,7 @@ pub trait ProofProvider<Block: BlockT> {
/// Returns combined proof and the numbers of collected keys.
fn read_proof_collection(
&self,
hash: &Block::Hash,
hash: Block::Hash,
start_keys: &[Vec<u8>],
size_limit: usize,
) -> sp_blockchain::Result<(CompactProof, u32)>;
@@ -76,7 +76,7 @@ pub trait ProofProvider<Block: BlockT> {
/// end.
fn storage_collection(
&self,
hash: &Block::Hash,
hash: Block::Hash,
start_key: &[Vec<u8>],
size_limit: usize,
) -> sp_blockchain::Result<Vec<(KeyValueStorageLevel, bool)>>;
substrate/client/basic-authorship/src/basic_authorship.rs
+1 -1
View File
@@ -736,7 +736,7 @@ mod tests {
let api = client.runtime_api();
api.execute_block(&block_id, proposal.block).unwrap();
let state = backend.state_at(&genesis_hash).unwrap();
let state = backend.state_at(genesis_hash).unwrap();
let storage_changes = api.into_storage_changes(&state, genesis_hash).unwrap();
substrate/client/beefy/src/communication/request_response/incoming_requests_handler.rs
+1 -1
View File
@@ -153,7 +153,7 @@ where
self.client.block_hash(request.payload.begin).map_err(Error::Client)?
{
self.client
.justifications(&hash)
.justifications(hash)
.map_err(Error::Client)?
.and_then(|justifs| justifs.get(BEEFY_ENGINE_ID).cloned())
// No BEEFY justification present.
substrate/client/beefy/src/tests.rs
+13 -13
View File
@@ -512,7 +512,7 @@ fn finalize_block_and_wait_for_beefy(
peers.clone().for_each(|(index, _)| {
let client = net.lock().peer(index).client().as_client();
let finalize = client.expect_block_hash_from_id(&BlockId::number(*block)).unwrap();
client.finalize_block(&finalize, None).unwrap();
client.finalize_block(finalize, None).unwrap();
})
}
@@ -608,7 +608,7 @@ fn lagging_validators() {
.expect_block_hash_from_id(&BlockId::number(25))
.unwrap();
let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone());
net.lock().peer(0).client().as_client().finalize_block(&finalize, None).unwrap();
net.lock().peer(0).client().as_client().finalize_block(finalize, None).unwrap();
// verify nothing gets finalized by BEEFY
let timeout = Some(Duration::from_millis(250));
streams_empty_after_timeout(best_blocks, &net, &mut runtime, timeout);
@@ -616,7 +616,7 @@ fn lagging_validators() {
// Bob catches up and also finalizes #25
let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone());
net.lock().peer(1).client().as_client().finalize_block(&finalize, None).unwrap();
net.lock().peer(1).client().as_client().finalize_block(finalize, None).unwrap();
// expected beefy finalizes block #17 from diff-power-of-two
wait_for_best_beefy_blocks(best_blocks, &net, &mut runtime, &[23, 24, 25]);
wait_for_beefy_signed_commitments(versioned_finality_proof, &net, &mut runtime, &[23, 24, 25]);
@@ -637,7 +637,7 @@ fn lagging_validators() {
.as_client()
.expect_block_hash_from_id(&BlockId::number(60))
.unwrap();
net.lock().peer(0).client().as_client().finalize_block(&finalize, None).unwrap();
net.lock().peer(0).client().as_client().finalize_block(finalize, None).unwrap();
// verify nothing gets finalized by BEEFY
let timeout = Some(Duration::from_millis(250));
streams_empty_after_timeout(best_blocks, &net, &mut runtime, timeout);
@@ -645,7 +645,7 @@ fn lagging_validators() {
// Bob catches up and also finalizes #60 (and should have buffered Alice's vote on #60)
let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers);
net.lock().peer(1).client().as_client().finalize_block(&finalize, None).unwrap();
net.lock().peer(1).client().as_client().finalize_block(finalize, None).unwrap();
// verify beefy skips intermediary votes, and successfully finalizes mandatory block #60
wait_for_best_beefy_blocks(best_blocks, &net, &mut runtime, &[60]);
wait_for_beefy_signed_commitments(versioned_finality_proof, &net, &mut runtime, &[60]);
@@ -696,9 +696,9 @@ fn correct_beefy_payload() {
.as_client()
.expect_block_hash_from_id(&BlockId::number(11))
.unwrap();
net.lock().peer(0).client().as_client().finalize_block(&hashof11, None).unwrap();
net.lock().peer(1).client().as_client().finalize_block(&hashof11, None).unwrap();
net.lock().peer(3).client().as_client().finalize_block(&hashof11, None).unwrap();
net.lock().peer(0).client().as_client().finalize_block(hashof11, None).unwrap();
net.lock().peer(1).client().as_client().finalize_block(hashof11, None).unwrap();
net.lock().peer(3).client().as_client().finalize_block(hashof11, None).unwrap();
// verify consensus is _not_ reached
let timeout = Some(Duration::from_millis(250));
@@ -708,7 +708,7 @@ fn correct_beefy_payload() {
// 3rd good validator catches up and votes as well
let (best_blocks, versioned_finality_proof) =
get_beefy_streams(&mut net.lock(), [(0, BeefyKeyring::Alice)].into_iter());
net.lock().peer(2).client().as_client().finalize_block(&hashof11, None).unwrap();
net.lock().peer(2).client().as_client().finalize_block(hashof11, None).unwrap();
// verify consensus is reached
wait_for_best_beefy_blocks(best_blocks, &net, &mut runtime, &[11]);
@@ -760,7 +760,7 @@ fn beefy_importing_blocks() {
// none in backend,
assert_eq!(
full_client
.justifications(&hashof1)
.justifications(hashof1)
.unwrap()
.and_then(|j| j.get(BEEFY_ENGINE_ID).cloned()),
None
@@ -799,7 +799,7 @@ fn beefy_importing_blocks() {
// still not in backend (worker is responsible for appending to backend),
assert_eq!(
full_client
.justifications(&hashof2)
.justifications(hashof2)
.unwrap()
.and_then(|j| j.get(BEEFY_ENGINE_ID).cloned()),
None
@@ -843,7 +843,7 @@ fn beefy_importing_blocks() {
// none in backend,
assert_eq!(
full_client
.justifications(&hashof3)
.justifications(hashof3)
.unwrap()
.and_then(|j| j.get(BEEFY_ENGINE_ID).cloned()),
None
@@ -941,7 +941,7 @@ fn on_demand_beefy_justification_sync() {
get_beefy_streams(&mut net.lock(), [(dave_index, BeefyKeyring::Dave)].into_iter());
let client = net.lock().peer(dave_index).client().as_client();
let hashof1 = client.expect_block_hash_from_id(&BlockId::number(1)).unwrap();
client.finalize_block(&hashof1, None).unwrap();
client.finalize_block(hashof1, None).unwrap();
// Give Dave task some cpu cycles to process the finality notification,
run_for(Duration::from_millis(100), &net, &mut runtime);
// freshly spun up Dave now needs to listen for gossip to figure out the state of his peers.
substrate/client/beefy/src/worker.rs
+8 -8
View File
@@ -511,7 +511,7 @@ where
.expect("forwards closure result; the closure always returns Ok; qed.");
self.backend
.append_justification(&hash, (BEEFY_ENGINE_ID, finality_proof.encode()))
.append_justification(hash, (BEEFY_ENGINE_ID, finality_proof.encode()))
}) {
error!(target: "beefy", "🥩 Error {:?} on appending justification: {:?}", e, finality_proof);
}
@@ -709,7 +709,7 @@ where
// a BEEFY justification, or at this session's boundary; voter will resume from there.
loop {
if let Some(true) = blockchain
.justifications(&header.hash())
.justifications(header.hash())
.ok()
.flatten()
.map(|justifs| justifs.get(BEEFY_ENGINE_ID).is_some())
@@ -1375,8 +1375,8 @@ pub(crate) mod tests {
// finalize 1 and 2 without justifications
let hashof1 = backend.blockchain().expect_block_hash_from_id(&BlockId::Number(1)).unwrap();
let hashof2 = backend.blockchain().expect_block_hash_from_id(&BlockId::Number(2)).unwrap();
backend.finalize_block(&hashof1, None).unwrap();
backend.finalize_block(&hashof2, None).unwrap();
backend.finalize_block(hashof1, None).unwrap();
backend.finalize_block(hashof2, None).unwrap();
let justif = create_finality_proof(2);
// create new session at block #2
@@ -1401,7 +1401,7 @@ pub(crate) mod tests {
}));
// check BEEFY justifications are also appended to backend
let justifs = backend.blockchain().justifications(&hashof2).unwrap().unwrap();
let justifs = backend.blockchain().justifications(hashof2).unwrap().unwrap();
assert!(justifs.get(BEEFY_ENGINE_ID).is_some())
}
@@ -1512,7 +1512,7 @@ pub(crate) mod tests {
// finalize 13 without justifications
let hashof13 =
backend.blockchain().expect_block_hash_from_id(&BlockId::Number(13)).unwrap();
net.peer(0).client().as_client().finalize_block(&hashof13, None).unwrap();
net.peer(0).client().as_client().finalize_block(hashof13, None).unwrap();
// Test initialization at session boundary.
{
@@ -1551,7 +1551,7 @@ pub(crate) mod tests {
let hashof10 =
backend.blockchain().expect_block_hash_from_id(&BlockId::Number(10)).unwrap();
backend
.append_justification(&hashof10, (BEEFY_ENGINE_ID, justif.encode()))
.append_justification(hashof10, (BEEFY_ENGINE_ID, justif.encode()))
.unwrap();
// initialize voter at block 13, expect rounds initialized at last beefy finalized 10
@@ -1587,7 +1587,7 @@ pub(crate) mod tests {
let hashof12 =
backend.blockchain().expect_block_hash_from_id(&BlockId::Number(12)).unwrap();
backend
.append_justification(&hashof12, (BEEFY_ENGINE_ID, justif.encode()))
.append_justification(hashof12, (BEEFY_ENGINE_ID, justif.encode()))
.unwrap();
// initialize voter at block 13, expect rounds initialized at last beefy finalized 12
substrate/client/block-builder/src/lib.rs
+1 -1
View File
@@ -258,7 +258,7 @@ where
let proof = self.api.extract_proof();
let state = self.backend.state_at(&self.parent_hash)?;
let state = self.backend.state_at(self.parent_hash)?;
let storage_changes = self
.api
substrate/client/cli/src/commands/export_state_cmd.rs
+1 -1
View File
@@ -69,7 +69,7 @@ impl ExportStateCmd {
Some(id) => client.expect_block_hash_from_id(&id)?,
None => client.usage_info().chain.best_hash,
};
let raw_state = sc_service::chain_ops::export_raw_state(client, &hash)?;
let raw_state = sc_service::chain_ops::export_raw_state(client, hash)?;
input_spec.set_storage(raw_state);
info!("Generating new chain spec...");
substrate/client/consensus/babe/src/tests.rs
+5 -5
View File
@@ -822,7 +822,7 @@ fn revert_not_allowed_for_finalized() {
let canon = propose_and_import_blocks_wrap(BlockId::Number(0), 3);
// Finalize best block
client.finalize_block(&canon[2], None, false).unwrap();
client.finalize_block(canon[2], None, false).unwrap();
// Revert canon chain to last finalized block
revert(client.clone(), backend, 100).expect("revert should work for baked test scenario");
@@ -884,7 +884,7 @@ fn importing_epoch_change_block_prunes_tree() {
// We finalize block #13 from the canon chain, so on the next epoch
// change the tree should be pruned, to not contain F (#7).
client.finalize_block(&canon_hashes[12], None, false).unwrap();
client.finalize_block(canon_hashes[12], None, false).unwrap();
propose_and_import_blocks_wrap(BlockId::Hash(client.chain_info().best_hash), 7);
// at this point no hashes from the first fork must exist on the tree
@@ -911,7 +911,7 @@ fn importing_epoch_change_block_prunes_tree() {
.any(|h| fork_3.contains(h)),);
// finalizing block #25 from the canon chain should prune out the second fork
client.finalize_block(&canon_hashes[24], None, false).unwrap();
client.finalize_block(canon_hashes[24], None, false).unwrap();
propose_and_import_blocks_wrap(BlockId::Hash(client.chain_info().best_hash), 8);
// at this point no hashes from the second fork must exist on the tree
@@ -1049,7 +1049,7 @@ fn obsolete_blocks_aux_data_cleanup() {
assert!(aux_data_check(&fork3_hashes, true));
// Finalize A3
client.finalize_block(&fork1_hashes[2], None, true).unwrap();
client.finalize_block(fork1_hashes[2], None, true).unwrap();
// Wiped: A1, A2
assert!(aux_data_check(&fork1_hashes[..2], false));
@@ -1060,7 +1060,7 @@ fn obsolete_blocks_aux_data_cleanup() {
// Present C4, C5
assert!(aux_data_check(&fork3_hashes, true));
client.finalize_block(&fork1_hashes[3], None, true).unwrap();
client.finalize_block(fork1_hashes[3], None, true).unwrap();
// Wiped: A3
assert!(aux_data_check(&fork1_hashes[2..3], false));
substrate/client/consensus/manual-seal/src/finalize_block.rs
+1 -1
View File
@@ -46,7 +46,7 @@ where
{
let FinalizeBlockParams { hash, mut sender, justification, finalizer, .. } = params;
match finalizer.finalize_block(&hash, justification, true) {
match finalizer.finalize_block(hash, justification, true) {
Err(e) => {
log::warn!("Failed to finalize block {}", e);
rpc::send_result(&mut sender, Err(e.into()))
substrate/client/db/benches/state_access.rs
+6 -6
View File
@@ -66,7 +66,7 @@ fn insert_blocks(db: &Backend<Block>, storage: Vec<(Vec<u8>, Vec<u8>)>) -> H256
for i in 0..10 {
let mut op = db.begin_operation().unwrap();
db.begin_state_operation(&mut op, &parent_hash).unwrap();
db.begin_state_operation(&mut op, parent_hash).unwrap();
let mut header = Header {
number,
@@ -83,7 +83,7 @@ fn insert_blocks(db: &Backend<Block>, storage: Vec<(Vec<u8>, Vec<u8>)>) -> H256
.map(|(k, v)| (k.clone(), Some(v.clone())))
.collect::<Vec<_>>();
let (state_root, tx) = db.state_at(&parent_hash).unwrap().storage_root(
let (state_root, tx) = db.state_at(parent_hash).unwrap().storage_root(
changes.iter().map(|(k, v)| (k.as_slice(), v.as_deref())),
StateVersion::V1,
);
@@ -175,7 +175,7 @@ fn state_access_benchmarks(c: &mut Criterion) {
group.bench_function(desc, |b| {
b.iter_batched(
|| backend.state_at(&block_hash).expect("Creates state"),
|| backend.state_at(block_hash).expect("Creates state"),
|state| {
for key in keys.iter().cycle().take(keys.len() * multiplier) {
let _ = state.storage(&key).expect("Doesn't fail").unwrap();
@@ -213,7 +213,7 @@ fn state_access_benchmarks(c: &mut Criterion) {
group.bench_function(desc, |b| {
b.iter_batched(
|| backend.state_at(&block_hash).expect("Creates state"),
|| backend.state_at(block_hash).expect("Creates state"),
|state| {
for key in keys.iter().take(1).cycle().take(multiplier) {
let _ = state.storage(&key).expect("Doesn't fail").unwrap();
@@ -251,7 +251,7 @@ fn state_access_benchmarks(c: &mut Criterion) {
group.bench_function(desc, |b| {
b.iter_batched(
|| backend.state_at(&block_hash).expect("Creates state"),
|| backend.state_at(block_hash).expect("Creates state"),
|state| {
for key in keys.iter().take(1).cycle().take(multiplier) {
let _ = state.storage_hash(&key).expect("Doesn't fail").unwrap();
@@ -289,7 +289,7 @@ fn state_access_benchmarks(c: &mut Criterion) {
group.bench_function(desc, |b| {
b.iter_batched(
|| backend.state_at(&block_hash).expect("Creates state"),
|| backend.state_at(block_hash).expect("Creates state"),
|state| {
let _ = state
.storage_hash(sp_core::storage::well_known_keys::CODE)
substrate/client/db/src/lib.rs
+150 -150
View File
@@ -577,9 +577,9 @@ impl<Block: BlockT> sc_client_api::blockchain::HeaderBackend<Block> for Blockcha
}
impl<Block: BlockT> sc_client_api::blockchain::Backend<Block> for BlockchainDb<Block> {
fn body(&self, hash: &Block::Hash) -> ClientResult<Option<Vec<Block::Extrinsic>>> {
fn body(&self, hash: Block::Hash) -> ClientResult<Option<Vec<Block::Extrinsic>>> {
if let Some(body) =
read_db(&*self.db, columns::KEY_LOOKUP, columns::BODY, BlockId::Hash::<Block>(*hash))?
read_db(&*self.db, columns::KEY_LOOKUP, columns::BODY, BlockId::Hash::<Block>(hash))?
{
// Plain body
match Decode::decode(&mut &body[..]) {
@@ -596,7 +596,7 @@ impl<Block: BlockT> sc_client_api::blockchain::Backend<Block> for BlockchainDb<B
&*self.db,
columns::KEY_LOOKUP,
columns::BODY_INDEX,
BlockId::Hash::<Block>(*hash),
BlockId::Hash::<Block>(hash),
)? {
match Vec::<DbExtrinsic<Block>>::decode(&mut &index[..]) {
Ok(index) => {
@@ -642,12 +642,12 @@ impl<Block: BlockT> sc_client_api::blockchain::Backend<Block> for BlockchainDb<B
Ok(None)
}
fn justifications(&self, hash: &Block::Hash) -> ClientResult<Option<Justifications>> {
fn justifications(&self, hash: Block::Hash) -> ClientResult<Option<Justifications>> {
match read_db(
&*self.db,
columns::KEY_LOOKUP,
columns::JUSTIFICATIONS,
BlockId::<Block>::Hash(*hash),
BlockId::<Block>::Hash(hash),
)? {
Some(justifications) => match Decode::decode(&mut &justifications[..]) {
Ok(justifications) => Ok(Some(justifications)),
@@ -686,20 +686,20 @@ impl<Block: BlockT> sc_client_api::blockchain::Backend<Block> for BlockchainDb<B
children::read_children(&*self.db, columns::META, meta_keys::CHILDREN_PREFIX, parent_hash)
}
fn indexed_transaction(&self, hash: &Block::Hash) -> ClientResult<Option<Vec<u8>>> {
fn indexed_transaction(&self, hash: Block::Hash) -> ClientResult<Option<Vec<u8>>> {
Ok(self.db.get(columns::TRANSACTION, hash.as_ref()))
}
fn has_indexed_transaction(&self, hash: &Block::Hash) -> ClientResult<bool> {
fn has_indexed_transaction(&self, hash: Block::Hash) -> ClientResult<bool> {
Ok(self.db.contains(columns::TRANSACTION, hash.as_ref()))
}
fn block_indexed_body(&self, hash: &Block::Hash) -> ClientResult<Option<Vec<Vec<u8>>>> {
fn block_indexed_body(&self, hash: Block::Hash) -> ClientResult<Option<Vec<Vec<u8>>>> {
let body = match read_db(
&*self.db,
columns::KEY_LOOKUP,
columns::BODY_INDEX,
BlockId::<Block>::Hash(*hash),
BlockId::<Block>::Hash(hash),
)? {
Some(body) => body,
None => return Ok(None),
@@ -914,16 +914,16 @@ impl<Block: BlockT> sc_client_api::backend::BlockImportOperation<Block>
fn mark_finalized(
&mut self,
block: &Block::Hash,
block: Block::Hash,
justification: Option<Justification>,
) -> ClientResult<()> {
self.finalized_blocks.push((*block, justification));
self.finalized_blocks.push((block, justification));
Ok(())
}
fn mark_head(&mut self, hash: &Block::Hash) -> ClientResult<()> {
fn mark_head(&mut self, hash: Block::Hash) -> ClientResult<()> {
assert!(self.set_head.is_none(), "Only one set head per operation is allowed");
self.set_head = Some(*hash);
self.set_head = Some(hash);
Ok(())
}
@@ -1176,7 +1176,7 @@ impl<Block: BlockT> Backend<Block> {
info.finalized_hash != Default::default() &&
sc_client_api::Backend::have_state_at(
&backend,
&info.finalized_hash,
info.finalized_hash,
info.finalized_number,
) {
backend.blockchain.update_meta(MetaUpdate {
@@ -1289,7 +1289,7 @@ impl<Block: BlockT> Backend<Block> {
fn finalize_block_with_transaction(
&self,
transaction: &mut Transaction<DbHash>,
hash: &Block::Hash,
hash: Block::Hash,
header: &Block::Header,
last_finalized: Option<Block::Hash>,
justification: Option<Justification>,
@@ -1300,7 +1300,7 @@ impl<Block: BlockT> Backend<Block> {
self.ensure_sequential_finalization(header, last_finalized)?;
let with_state = sc_client_api::Backend::have_state_at(self, hash, number);
self.note_finalized(transaction, header, *hash, finalization_displaced, with_state)?;
self.note_finalized(transaction, header, hash, finalization_displaced, with_state)?;
if let Some(justification) = justification {
transaction.set_from_vec(
@@ -1309,7 +1309,7 @@ impl<Block: BlockT> Backend<Block> {
Justifications::from(justification).encode(),
);
}
Ok(MetaUpdate { hash: *hash, number, is_best: false, is_finalized: true, with_state })
Ok(MetaUpdate { hash, number, is_best: false, is_finalized: true, with_state })
}
// performs forced canonicalization with a delay after importing a non-finalized block.
@@ -1340,7 +1340,7 @@ impl<Block: BlockT> Backend<Block> {
))
})?
};
if !sc_client_api::Backend::have_state_at(self, &hash, new_canonical.saturated_into()) {
if !sc_client_api::Backend::have_state_at(self, hash, new_canonical.saturated_into()) {
return Ok(())
}
@@ -1372,7 +1372,7 @@ impl<Block: BlockT> Backend<Block> {
let block_header = self.blockchain.expect_header(BlockId::Hash(block_hash))?;
meta_updates.push(self.finalize_block_with_transaction(
&mut transaction,
&block_hash,
block_hash,
&block_header,
Some(last_finalized_hash),
justification,
@@ -1703,7 +1703,7 @@ impl<Block: BlockT> Backend<Block> {
}
transaction.set_from_vec(columns::META, meta_keys::FINALIZED_BLOCK, lookup_key);
if sc_client_api::Backend::have_state_at(self, &f_hash, f_num) &&
if sc_client_api::Backend::have_state_at(self, f_hash, f_num) &&
self.storage
.state_db
.best_canonical()
@@ -1978,9 +1978,9 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
fn begin_state_operation(
&self,
operation: &mut Self::BlockImportOperation,
block: &Block::Hash,
block: Block::Hash,
) -> ClientResult<()> {
if *block == Default::default() {
if block == Default::default() {
operation.old_state = self.empty_state()?;
} else {
operation.old_state = self.state_at(block)?;
@@ -2008,11 +2008,11 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
fn finalize_block(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
) -> ClientResult<()> {
let mut transaction = Transaction::new();
let header = self.blockchain.expect_header(BlockId::Hash(*hash))?;
let header = self.blockchain.expect_header(BlockId::Hash(hash))?;
let mut displaced = None;
let m = self.finalize_block_with_transaction(
@@ -2030,11 +2030,11 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
fn append_justification(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Justification,
) -> ClientResult<()> {
let mut transaction: Transaction<DbHash> = Transaction::new();
let header = self.blockchain.expect_header(BlockId::Hash(*hash))?;
let header = self.blockchain.expect_header(BlockId::Hash(hash))?;
let number = *header.number();
// Check if the block is finalized first.
@@ -2043,7 +2043,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
// We can do a quick check first, before doing a proper but more expensive check
if number > self.blockchain.info().finalized_number ||
(*hash != last_finalized && !is_descendent_of(hash, &last_finalized)?)
(hash != last_finalized && !is_descendent_of(&hash, &last_finalized)?)
{
return Err(ClientError::NotInFinalizedChain)
}
@@ -2061,7 +2061,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
transaction.set_from_vec(
columns::JUSTIFICATIONS,
&utils::number_and_hash_to_lookup_key(number, *hash)?,
&utils::number_and_hash_to_lookup_key(number, hash)?,
justifications.encode(),
);
@@ -2154,7 +2154,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
let prev_hash =
if prev_number == best_number { best_hash } else { *removed.parent_hash() };
if !self.have_state_at(&prev_hash, prev_number) {
if !self.have_state_at(prev_hash, prev_number) {
return Ok(c.saturated_into::<NumberFor<Block>>())
}
@@ -2183,7 +2183,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
if hash == hash_to_revert {
if !number_to_revert.is_zero() &&
self.have_state_at(
&prev_hash,
prev_hash,
number_to_revert - One::one(),
) {
let lookup_key = utils::number_and_hash_to_lookup_key(
@@ -2247,14 +2247,14 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
Ok((reverted, reverted_finalized))
}
fn remove_leaf_block(&self, hash: &Block::Hash) -> ClientResult<()> {
fn remove_leaf_block(&self, hash: Block::Hash) -> ClientResult<()> {
let best_hash = self.blockchain.info().best_hash;
if best_hash == *hash {
if best_hash == hash {
return Err(sp_blockchain::Error::Backend(format!("Can't remove best block {:?}", hash)))
}
let hdr = self.blockchain.header_metadata(*hash)?;
let hdr = self.blockchain.header_metadata(hash)?;
if !self.have_state_at(hash, hdr.number) {
return Err(sp_blockchain::Error::UnknownBlock(format!(
"State already discarded for {:?}",
@@ -2263,7 +2263,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
}
let mut leaves = self.blockchain.leaves.write();
if !leaves.contains(hdr.number, *hash) {
if !leaves.contains(hdr.number, hash) {
return Err(sp_blockchain::Error::Backend(format!(
"Can't remove non-leaf block {:?}",
hash
@@ -2271,7 +2271,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
}
let mut transaction = Transaction::new();
if let Some(commit) = self.storage.state_db.remove(hash) {
if let Some(commit) = self.storage.state_db.remove(&hash) {
apply_state_commit(&mut transaction, commit);
}
transaction.remove(columns::KEY_LOOKUP, hash.as_ref());
@@ -2280,7 +2280,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
.blockchain()
.children(hdr.parent)?
.into_iter()
.filter(|child_hash| child_hash != hash)
.filter(|child_hash| *child_hash != hash)
.collect();
let parent_leaf = if children.is_empty() {
children::remove_children(
@@ -2301,7 +2301,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
None
};
let remove_outcome = leaves.remove(*hash, hdr.number, parent_leaf);
let remove_outcome = leaves.remove(hash, hdr.number, parent_leaf);
leaves.prepare_transaction(&mut transaction, columns::META, meta_keys::LEAF_PREFIX);
if let Err(e) = self.storage.db.commit(transaction) {
if let Some(outcome) = remove_outcome {
@@ -2309,7 +2309,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
}
return Err(e.into())
}
self.blockchain().remove_header_metadata(*hash);
self.blockchain().remove_header_metadata(hash);
Ok(())
}
@@ -2317,8 +2317,8 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
&self.blockchain
}
fn state_at(&self, hash: &Block::Hash) -> ClientResult<Self::State> {
if hash == &self.blockchain.meta.read().genesis_hash {
fn state_at(&self, hash: Block::Hash) -> ClientResult<Self::State> {
if hash == self.blockchain.meta.read().genesis_hash {
if let Some(genesis_state) = &*self.genesis_state.read() {
let root = genesis_state.root;
let db_state = DbStateBuilder::<Block>::new(genesis_state.clone(), root)
@@ -2330,7 +2330,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
}
}
match self.blockchain.header_metadata(*hash) {
match self.blockchain.header_metadata(hash) {
Ok(ref hdr) => {
let hint = || {
sc_state_db::NodeDb::get(self.storage.as_ref(), hdr.state_root.as_ref())
@@ -2338,7 +2338,7 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
.is_some()
};
if let Ok(()) =
self.storage.state_db.pin(hash, hdr.number.saturated_into::<u64>(), hint)
self.storage.state_db.pin(&hash, hdr.number.saturated_into::<u64>(), hint)
{
let root = hdr.state_root;
let db_state = DbStateBuilder::<Block>::new(self.storage.clone(), root)
@@ -2346,8 +2346,8 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
self.shared_trie_cache.as_ref().map(|c| c.local_cache()),
)
.build();
let state = RefTrackingState::new(db_state, self.storage.clone(), Some(*hash));
Ok(RecordStatsState::new(state, Some(*hash), self.state_usage.clone()))
let state = RefTrackingState::new(db_state, self.storage.clone(), Some(hash));
Ok(RecordStatsState::new(state, Some(hash), self.state_usage.clone()))
} else {
Err(sp_blockchain::Error::UnknownBlock(format!(
"State already discarded for {:?}",
@@ -2359,9 +2359,9 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
}
}
fn have_state_at(&self, hash: &Block::Hash, number: NumberFor<Block>) -> bool {
fn have_state_at(&self, hash: Block::Hash, number: NumberFor<Block>) -> bool {
if self.is_archive {
match self.blockchain.header_metadata(*hash) {
match self.blockchain.header_metadata(hash) {
Ok(header) => sp_state_machine::Storage::get(
self.storage.as_ref(),
&header.state_root,
@@ -2372,10 +2372,10 @@ impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
_ => false,
}
} else {
match self.storage.state_db.is_pruned(hash, number.saturated_into::<u64>()) {
match self.storage.state_db.is_pruned(&hash, number.saturated_into::<u64>()) {
IsPruned::Pruned => false,
IsPruned::NotPruned => true,
IsPruned::MaybePruned => match self.blockchain.header_metadata(*hash) {
IsPruned::MaybePruned => match self.blockchain.header_metadata(hash) {
Ok(header) => sp_state_machine::Storage::get(
self.storage.as_ref(),
&header.state_root,
@@ -2459,7 +2459,7 @@ pub(crate) mod tests {
let block_hash = if number == 0 { Default::default() } else { parent_hash };
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &block_hash).unwrap();
backend.begin_state_operation(&mut op, block_hash).unwrap();
op.set_block_data(header, Some(body), None, None, NewBlockState::Best).unwrap();
if let Some(index) = transaction_index {
op.update_transaction_index(index).unwrap();
@@ -2507,7 +2507,7 @@ pub(crate) mod tests {
};
let mut op = db.begin_operation().unwrap();
db.begin_state_operation(&mut op, &hash).unwrap();
db.begin_state_operation(&mut op, hash).unwrap();
let header = Header {
number: i,
parent_hash: hash,
@@ -2581,7 +2581,7 @@ pub(crate) mod tests {
db.commit_operation(op).unwrap();
let state = db.state_at(&hash).unwrap();
let state = db.state_at(hash).unwrap();
assert_eq!(state.storage(&[1, 3, 5]).unwrap(), Some(vec![2, 4, 6]));
assert_eq!(state.storage(&[1, 2, 3]).unwrap(), Some(vec![9, 9, 9]));
@@ -2592,7 +2592,7 @@ pub(crate) mod tests {
{
let mut op = db.begin_operation().unwrap();
db.begin_state_operation(&mut op, &hash).unwrap();
db.begin_state_operation(&mut op, hash).unwrap();
let mut header = Header {
number: 1,
parent_hash: hash,
@@ -2616,7 +2616,7 @@ pub(crate) mod tests {
db.commit_operation(op).unwrap();
let state = db.state_at(&header.hash()).unwrap();
let state = db.state_at(header.hash()).unwrap();
assert_eq!(state.storage(&[1, 3, 5]).unwrap(), None);
assert_eq!(state.storage(&[1, 2, 3]).unwrap(), Some(vec![9, 9, 9]));
@@ -2633,7 +2633,7 @@ pub(crate) mod tests {
let hash = {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &Default::default()).unwrap();
backend.begin_state_operation(&mut op, Default::default()).unwrap();
let mut header = Header {
number: 0,
parent_hash: Default::default(),
@@ -2670,7 +2670,7 @@ pub(crate) mod tests {
let hashof1 = {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &hash).unwrap();
backend.begin_state_operation(&mut op, hash).unwrap();
let mut header = Header {
number: 1,
parent_hash: hash,
@@ -2707,7 +2707,7 @@ pub(crate) mod tests {
let hashof2 = {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &hashof1).unwrap();
backend.begin_state_operation(&mut op, hashof1).unwrap();
let mut header = Header {
number: 2,
parent_hash: hashof1,
@@ -2741,7 +2741,7 @@ pub(crate) mod tests {
let hashof3 = {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &hashof2).unwrap();
backend.begin_state_operation(&mut op, hashof2).unwrap();
let mut header = Header {
number: 3,
parent_hash: hashof2,
@@ -2771,9 +2771,9 @@ pub(crate) mod tests {
hash
};
backend.finalize_block(&hashof1, None).unwrap();
backend.finalize_block(&hashof2, None).unwrap();
backend.finalize_block(&hashof3, None).unwrap();
backend.finalize_block(hashof1, None).unwrap();
backend.finalize_block(hashof2, None).unwrap();
backend.finalize_block(hashof3, None).unwrap();
assert!(backend
.storage
.db
@@ -2996,8 +2996,8 @@ pub(crate) mod tests {
vec![block2_a, block2_b, block2_c, block1_c]
);
backend.finalize_block(&block1_a, None).unwrap();
backend.finalize_block(&block2_a, None).unwrap();
backend.finalize_block(block1_a, None).unwrap();
backend.finalize_block(block2_a, None).unwrap();
// leaves at same height stay. Leaves at lower heights pruned.
assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2_a, block2_b, block2_c]);
@@ -3024,10 +3024,10 @@ pub(crate) mod tests {
let block1 = insert_header(&backend, 1, block0, None, Default::default());
let justification = Some((CONS0_ENGINE_ID, vec![1, 2, 3]));
backend.finalize_block(&block1, justification.clone()).unwrap();
backend.finalize_block(block1, justification.clone()).unwrap();
assert_eq!(
backend.blockchain().justifications(&block1).unwrap(),
backend.blockchain().justifications(block1).unwrap(),
justification.map(Justifications::from),
);
}
@@ -3042,14 +3042,14 @@ pub(crate) mod tests {
let block1 = insert_header(&backend, 1, block0, None, Default::default());
let just0 = (CONS0_ENGINE_ID, vec![1, 2, 3]);
backend.finalize_block(&block1, Some(just0.clone().into())).unwrap();
backend.finalize_block(block1, Some(just0.clone().into())).unwrap();
let just1 = (CONS1_ENGINE_ID, vec![4, 5]);
backend.append_justification(&block1, just1.clone()).unwrap();
backend.append_justification(block1, just1.clone()).unwrap();
let just2 = (CONS1_ENGINE_ID, vec![6, 7]);
assert!(matches!(
backend.append_justification(&block1, just2),
backend.append_justification(block1, just2),
Err(ClientError::BadJustification(_))
));
@@ -3058,7 +3058,7 @@ pub(crate) mod tests {
just.append(just1);
just
};
assert_eq!(backend.blockchain().justifications(&block1).unwrap(), Some(justifications),);
assert_eq!(backend.blockchain().justifications(block1).unwrap(), Some(justifications),);
}
#[test]
@@ -3072,16 +3072,16 @@ pub(crate) mod tests {
let block4 = insert_header(&backend, 4, block3, None, Default::default());
{
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &block0).unwrap();
op.mark_finalized(&block1, None).unwrap();
op.mark_finalized(&block2, None).unwrap();
backend.begin_state_operation(&mut op, block0).unwrap();
op.mark_finalized(block1, None).unwrap();
op.mark_finalized(block2, None).unwrap();
backend.commit_operation(op).unwrap();
}
{
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &block2).unwrap();
op.mark_finalized(&block3, None).unwrap();
op.mark_finalized(&block4, None).unwrap();
backend.begin_state_operation(&mut op, block2).unwrap();
op.mark_finalized(block3, None).unwrap();
op.mark_finalized(block4, None).unwrap();
backend.commit_operation(op).unwrap();
}
}
@@ -3093,7 +3093,7 @@ pub(crate) mod tests {
let hash0 = {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &Default::default()).unwrap();
backend.begin_state_operation(&mut op, Default::default()).unwrap();
let mut header = Header {
number: 0,
parent_hash: Default::default(),
@@ -3127,11 +3127,11 @@ pub(crate) mod tests {
hash
};
let block0_hash = backend.state_at(&hash0).unwrap().storage_hash(&b"test"[..]).unwrap();
let block0_hash = backend.state_at(hash0).unwrap().storage_hash(&b"test"[..]).unwrap();
let hash1 = {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &hash0).unwrap();
backend.begin_state_operation(&mut op, hash0).unwrap();
let mut header = Header {
number: 1,
parent_hash: hash0,
@@ -3166,7 +3166,7 @@ pub(crate) mod tests {
backend.commit_operation(op).unwrap();
}
let block1_hash = backend.state_at(&hash1).unwrap().storage_hash(&b"test"[..]).unwrap();
let block1_hash = backend.state_at(hash1).unwrap().storage_hash(&b"test"[..]).unwrap();
assert_ne!(block0_hash, block1_hash);
}
@@ -3180,8 +3180,8 @@ pub(crate) mod tests {
let block2 = insert_header(&backend, 2, block1, None, Default::default());
{
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &block0).unwrap();
op.mark_finalized(&block2, None).unwrap();
backend.begin_state_operation(&mut op, block0).unwrap();
op.mark_finalized(block2, None).unwrap();
backend.commit_operation(op).unwrap_err();
}
}
@@ -3208,18 +3208,18 @@ pub(crate) mod tests {
{
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &blocks[4]).unwrap();
backend.begin_state_operation(&mut op, blocks[4]).unwrap();
for i in 1..5 {
op.mark_finalized(&blocks[i], None).unwrap();
op.mark_finalized(blocks[i], None).unwrap();
}
backend.commit_operation(op).unwrap();
}
let bc = backend.blockchain();
assert_eq!(None, bc.body(&blocks[0]).unwrap());
assert_eq!(None, bc.body(&blocks[1]).unwrap());
assert_eq!(None, bc.body(&blocks[2]).unwrap());
assert_eq!(Some(vec![3.into()]), bc.body(&blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(&blocks[4]).unwrap());
assert_eq!(None, bc.body(blocks[0]).unwrap());
assert_eq!(None, bc.body(blocks[1]).unwrap());
assert_eq!(None, bc.body(blocks[2]).unwrap());
assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
}
#[test]
@@ -3243,18 +3243,18 @@ pub(crate) mod tests {
}
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &blocks[4]).unwrap();
backend.begin_state_operation(&mut op, blocks[4]).unwrap();
for i in 1..3 {
op.mark_finalized(&blocks[i], None).unwrap();
op.mark_finalized(blocks[i], None).unwrap();
}
backend.commit_operation(op).unwrap();
let bc = backend.blockchain();
assert_eq!(Some(vec![0.into()]), bc.body(&blocks[0]).unwrap());
assert_eq!(Some(vec![1.into()]), bc.body(&blocks[1]).unwrap());
assert_eq!(Some(vec![2.into()]), bc.body(&blocks[2]).unwrap());
assert_eq!(Some(vec![3.into()]), bc.body(&blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(&blocks[4]).unwrap());
assert_eq!(Some(vec![0.into()]), bc.body(blocks[0]).unwrap());
assert_eq!(Some(vec![1.into()]), bc.body(blocks[1]).unwrap());
assert_eq!(Some(vec![2.into()]), bc.body(blocks[2]).unwrap());
assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
}
#[test]
@@ -3300,27 +3300,27 @@ pub(crate) mod tests {
.unwrap();
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &blocks[4]).unwrap();
op.mark_head(&blocks[4]).unwrap();
backend.begin_state_operation(&mut op, blocks[4]).unwrap();
op.mark_head(blocks[4]).unwrap();
backend.commit_operation(op).unwrap();
let bc = backend.blockchain();
assert_eq!(Some(vec![2.into()]), bc.body(&fork_hash_root).unwrap());
assert_eq!(Some(vec![2.into()]), bc.body(fork_hash_root).unwrap());
for i in 1..5 {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &blocks[i]).unwrap();
op.mark_finalized(&blocks[i], None).unwrap();
backend.begin_state_operation(&mut op, blocks[i]).unwrap();
op.mark_finalized(blocks[i], None).unwrap();
backend.commit_operation(op).unwrap();
}
assert_eq!(Some(vec![0.into()]), bc.body(&blocks[0]).unwrap());
assert_eq!(Some(vec![1.into()]), bc.body(&blocks[1]).unwrap());
assert_eq!(Some(vec![2.into()]), bc.body(&blocks[2]).unwrap());
assert_eq!(Some(vec![3.into()]), bc.body(&blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(&blocks[4]).unwrap());
assert_eq!(Some(vec![0.into()]), bc.body(blocks[0]).unwrap());
assert_eq!(Some(vec![1.into()]), bc.body(blocks[1]).unwrap());
assert_eq!(Some(vec![2.into()]), bc.body(blocks[2]).unwrap());
assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
assert_eq!(Some(vec![2.into()]), bc.body(&fork_hash_root).unwrap());
assert_eq!(Some(vec![2.into()]), bc.body(fork_hash_root).unwrap());
assert_eq!(bc.info().best_number, 4);
for i in 0..5 {
assert!(bc.hash(i).unwrap().is_some());
@@ -3369,23 +3369,23 @@ pub(crate) mod tests {
)
.unwrap();
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &blocks[4]).unwrap();
op.mark_head(&blocks[4]).unwrap();
backend.begin_state_operation(&mut op, blocks[4]).unwrap();
op.mark_head(blocks[4]).unwrap();
backend.commit_operation(op).unwrap();
for i in 1..5 {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &blocks[4]).unwrap();
op.mark_finalized(&blocks[i], None).unwrap();
backend.begin_state_operation(&mut op, blocks[4]).unwrap();
op.mark_finalized(blocks[i], None).unwrap();
backend.commit_operation(op).unwrap();
}
let bc = backend.blockchain();
assert_eq!(None, bc.body(&blocks[0]).unwrap());
assert_eq!(None, bc.body(&blocks[1]).unwrap());
assert_eq!(None, bc.body(&blocks[2]).unwrap());
assert_eq!(Some(vec![3.into()]), bc.body(&blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(&blocks[4]).unwrap());
assert_eq!(None, bc.body(blocks[0]).unwrap());
assert_eq!(None, bc.body(blocks[1]).unwrap());
assert_eq!(None, bc.body(blocks[2]).unwrap());
assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
}
#[test]
@@ -3419,17 +3419,17 @@ pub(crate) mod tests {
)
.unwrap();
let bc = backend.blockchain();
assert_eq!(bc.indexed_transaction(&x0_hash).unwrap().unwrap(), &x0[1..]);
assert_eq!(bc.indexed_transaction(&x1_hash).unwrap().unwrap(), &x1[1..]);
assert_eq!(bc.indexed_transaction(x0_hash).unwrap().unwrap(), &x0[1..]);
assert_eq!(bc.indexed_transaction(x1_hash).unwrap().unwrap(), &x1[1..]);
let hashof0 = bc.info().genesis_hash;
// Push one more blocks and make sure block is pruned and transaction index is cleared.
let block1 =
insert_block(&backend, 1, hash, None, Default::default(), vec![], None).unwrap();
backend.finalize_block(&block1, None).unwrap();
assert_eq!(bc.body(&hashof0).unwrap(), None);
assert_eq!(bc.indexed_transaction(&x0_hash).unwrap(), None);
assert_eq!(bc.indexed_transaction(&x1_hash).unwrap(), None);
backend.finalize_block(block1, None).unwrap();
assert_eq!(bc.body(hashof0).unwrap(), None);
assert_eq!(bc.indexed_transaction(x0_hash).unwrap(), None);
assert_eq!(bc.indexed_transaction(x1_hash).unwrap(), None);
}
#[test]
@@ -3463,8 +3463,8 @@ pub(crate) mod tests {
)
.unwrap();
let bc = backend.blockchain();
assert_eq!(bc.indexed_transaction(&x0_hash).unwrap().unwrap(), &x0[..]);
assert_eq!(bc.indexed_transaction(&x1_hash).unwrap(), None);
assert_eq!(bc.indexed_transaction(x0_hash).unwrap().unwrap(), &x0[..]);
assert_eq!(bc.indexed_transaction(x1_hash).unwrap(), None);
}
#[test]
@@ -3502,14 +3502,14 @@ pub(crate) mod tests {
for i in 1..10 {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &blocks[4]).unwrap();
op.mark_finalized(&blocks[i], None).unwrap();
backend.begin_state_operation(&mut op, blocks[4]).unwrap();
op.mark_finalized(blocks[i], None).unwrap();
backend.commit_operation(op).unwrap();
let bc = backend.blockchain();
if i < 6 {
assert!(bc.indexed_transaction(&x1_hash).unwrap().is_some());
assert!(bc.indexed_transaction(x1_hash).unwrap().is_some());
} else {
assert!(bc.indexed_transaction(&x1_hash).unwrap().is_none());
assert!(bc.indexed_transaction(x1_hash).unwrap().is_none());
}
}
}
@@ -3561,31 +3561,31 @@ pub(crate) mod tests {
.unwrap();
assert_eq!(backend.blockchain().info().best_hash, best_hash);
assert!(backend.remove_leaf_block(&best_hash).is_err());
assert!(backend.remove_leaf_block(best_hash).is_err());
assert_eq!(backend.blockchain().leaves().unwrap(), vec![blocks[2], blocks[3], best_hash]);
assert_eq!(backend.blockchain().children(blocks[1]).unwrap(), vec![blocks[2], blocks[3]]);
assert!(backend.have_state_at(&blocks[3], 2));
assert!(backend.have_state_at(blocks[3], 2));
assert!(backend.blockchain().header(BlockId::hash(blocks[3])).unwrap().is_some());
backend.remove_leaf_block(&blocks[3]).unwrap();
assert!(!backend.have_state_at(&blocks[3], 2));
backend.remove_leaf_block(blocks[3]).unwrap();
assert!(!backend.have_state_at(blocks[3], 2));
assert!(backend.blockchain().header(BlockId::hash(blocks[3])).unwrap().is_none());
assert_eq!(backend.blockchain().leaves().unwrap(), vec![blocks[2], best_hash]);
assert_eq!(backend.blockchain().children(blocks[1]).unwrap(), vec![blocks[2]]);
assert!(backend.have_state_at(&blocks[2], 2));
assert!(backend.have_state_at(blocks[2], 2));
assert!(backend.blockchain().header(BlockId::hash(blocks[2])).unwrap().is_some());
backend.remove_leaf_block(&blocks[2]).unwrap();
assert!(!backend.have_state_at(&blocks[2], 2));
backend.remove_leaf_block(blocks[2]).unwrap();
assert!(!backend.have_state_at(blocks[2], 2));
assert!(backend.blockchain().header(BlockId::hash(blocks[2])).unwrap().is_none());
assert_eq!(backend.blockchain().leaves().unwrap(), vec![best_hash, blocks[1]]);
assert_eq!(backend.blockchain().children(blocks[1]).unwrap(), vec![]);
assert!(backend.have_state_at(&blocks[1], 1));
assert!(backend.have_state_at(blocks[1], 1));
assert!(backend.blockchain().header(BlockId::hash(blocks[1])).unwrap().is_some());
backend.remove_leaf_block(&blocks[1]).unwrap();
assert!(!backend.have_state_at(&blocks[1], 1));
backend.remove_leaf_block(blocks[1]).unwrap();
assert!(!backend.have_state_at(blocks[1], 1));
assert!(backend.blockchain().header(BlockId::hash(blocks[1])).unwrap().is_none());
assert_eq!(backend.blockchain().leaves().unwrap(), vec![best_hash]);
assert_eq!(backend.blockchain().children(blocks[0]).unwrap(), vec![best_hash]);
@@ -3678,7 +3678,7 @@ pub(crate) mod tests {
let block1_a = insert_header(&backend, 1, block0, None, Default::default());
let block2_a = insert_header(&backend, 2, block1_a, None, Default::default());
backend.finalize_block(&block1_a, None).unwrap();
backend.finalize_block(block1_a, None).unwrap();
assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2_a]);
// Insert a fork prior to finalization point. Leave should not be created.
@@ -3702,7 +3702,7 @@ pub(crate) mod tests {
let block3 = {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &block1).unwrap();
backend.begin_state_operation(&mut op, block1).unwrap();
let header = Header {
number: 3,
parent_hash: block2,
@@ -3721,7 +3721,7 @@ pub(crate) mod tests {
let block4 = {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &block2).unwrap();
backend.begin_state_operation(&mut op, block2).unwrap();
let header = Header {
number: 4,
parent_hash: block3,
@@ -3740,7 +3740,7 @@ pub(crate) mod tests {
let block3_fork = {
let mut op = backend.begin_operation().unwrap();
backend.begin_state_operation(&mut op, &block2).unwrap();
backend.begin_state_operation(&mut op, block2).unwrap();
let header = Header {
number: 3,
parent_hash: block2,
@@ -3757,22 +3757,22 @@ pub(crate) mod tests {
header.hash()
};
assert!(backend.have_state_at(&block1, 1));
assert!(backend.have_state_at(&block2, 2));
assert!(backend.have_state_at(&block3, 3));
assert!(backend.have_state_at(&block4, 4));
assert!(backend.have_state_at(&block3_fork, 3));
assert!(backend.have_state_at(block1, 1));
assert!(backend.have_state_at(block2, 2));
assert!(backend.have_state_at(block3, 3));
assert!(backend.have_state_at(block4, 4));
assert!(backend.have_state_at(block3_fork, 3));
assert_eq!(backend.blockchain.leaves().unwrap(), vec![block4, block3_fork]);
assert_eq!(4, backend.blockchain.leaves.read().highest_leaf().unwrap().0);
assert_eq!(3, backend.revert(1, false).unwrap().0);
assert!(backend.have_state_at(&block1, 1));
assert!(!backend.have_state_at(&block2, 2));
assert!(!backend.have_state_at(&block3, 3));
assert!(!backend.have_state_at(&block4, 4));
assert!(!backend.have_state_at(&block3_fork, 3));
assert!(backend.have_state_at(block1, 1));
assert!(!backend.have_state_at(block2, 2));
assert!(!backend.have_state_at(block3, 3));
assert!(!backend.have_state_at(block4, 4));
assert!(!backend.have_state_at(block3_fork, 3));
assert_eq!(backend.blockchain.leaves().unwrap(), vec![block1]);
assert_eq!(1, backend.blockchain.leaves.read().highest_leaf().unwrap().0);
substrate/client/finality-grandpa/src/environment.rs
+1 -1
View File
@@ -1352,7 +1352,7 @@ where
// ideally some handle to a synchronization oracle would be used
// to avoid unconditionally notifying.
client
.apply_finality(import_op, &hash, persisted_justification, true)
.apply_finality(import_op, hash, persisted_justification, true)
.map_err(|e| {
warn!(target: "afg", "Error applying finality to block {:?}: {}", (hash, number), e);
e
substrate/client/finality-grandpa/src/finality_proof.rs
+3 -3
View File
@@ -188,7 +188,7 @@ where
.expect_block_hash_from_id(&BlockId::Number(last_block_for_set))?;
let justification = if let Some(grandpa_justification) = backend
.blockchain()
.justifications(&last_block_for_set_id)?
.justifications(last_block_for_set_id)?
.and_then(|justifications| justifications.into_justification(GRANDPA_ENGINE_ID))
{
grandpa_justification
@@ -312,7 +312,7 @@ mod tests {
for block in to_finalize {
let hash = blocks[*block as usize - 1].hash();
client.finalize_block(&hash, None).unwrap();
client.finalize_block(hash, None).unwrap();
}
(client, backend, blocks)
}
@@ -492,7 +492,7 @@ mod tests {
let grandpa_just8 = GrandpaJustification::from_commit(&client, round, commit).unwrap();
client
.finalize_block(&block8.hash(), Some((ID, grandpa_just8.encode().clone())))
.finalize_block(block8.hash(), Some((ID, grandpa_just8.encode().clone())))
.unwrap();
// Authority set change at block 8, so the justification stored there will be used in the
substrate/client/finality-grandpa/src/import.rs
+3 -3
View File
@@ -424,8 +424,8 @@ where
}
/// Read current set id form a given state.
fn current_set_id(&self, hash: &Block::Hash) -> Result<SetId, ConsensusError> {
let id = &BlockId::hash(*hash);
fn current_set_id(&self, hash: Block::Hash) -> Result<SetId, ConsensusError> {
let id = &BlockId::hash(hash);
let runtime_version = self.inner.runtime_api().version(id).map_err(|e| {
ConsensusError::ClientImport(format!(
"Unable to retrieve current runtime version. {}",
@@ -480,7 +480,7 @@ where
.runtime_api()
.grandpa_authorities(&BlockId::hash(hash))
.map_err(|e| ConsensusError::ClientImport(e.to_string()))?;
let set_id = self.current_set_id(&hash)?;
let set_id = self.current_set_id(hash)?;
let authority_set = AuthoritySet::new(
authorities.clone(),
set_id,
substrate/client/finality-grandpa/src/tests.rs
+7 -7
View File
@@ -375,7 +375,7 @@ fn finalize_3_voters_no_observers() {
// normally there's no justification for finalized blocks
assert!(
net.lock().peer(0).client().justifications(&hashof20).unwrap().is_none(),
net.lock().peer(0).client().justifications(hashof20).unwrap().is_none(),
"Extra justification for block#1",
);
}
@@ -621,7 +621,7 @@ fn justification_is_generated_periodically() {
// when block#32 (justification_period) is finalized, justification
// is required => generated
for i in 0..3 {
assert!(net.lock().peer(i).client().justifications(&hashof32).unwrap().is_some());
assert!(net.lock().peer(i).client().justifications(hashof32).unwrap().is_some());
}
}
@@ -665,12 +665,12 @@ fn sync_justifications_on_change_blocks() {
// the first 3 peers are grandpa voters and therefore have already finalized
// block 21 and stored a justification
for i in 0..3 {
assert!(net.lock().peer(i).client().justifications(&hashof21).unwrap().is_some());
assert!(net.lock().peer(i).client().justifications(hashof21).unwrap().is_some());
}
// the last peer should get the justification by syncing from other peers
futures::executor::block_on(futures::future::poll_fn(move |cx| {
if net.lock().peer(3).client().justifications(&hashof21).unwrap().is_none() {
if net.lock().peer(3).client().justifications(hashof21).unwrap().is_none() {
net.lock().poll(cx);
Poll::Pending
} else {
@@ -1428,7 +1428,7 @@ fn grandpa_environment_respects_voting_rules() {
.as_client()
.expect_block_hash_from_id(&BlockId::Number(19))
.unwrap();
peer.client().finalize_block(&hashof19, None, false).unwrap();
peer.client().finalize_block(hashof19, None, false).unwrap();
// the 3/4 environment should propose block 21 for voting
assert_eq!(
@@ -1455,7 +1455,7 @@ fn grandpa_environment_respects_voting_rules() {
.as_client()
.expect_block_hash_from_id(&BlockId::Number(21))
.unwrap();
peer.client().finalize_block(&hashof21, None, false).unwrap();
peer.client().finalize_block(hashof21, None, false).unwrap();
// even though the default environment will always try to not vote on the
// best block, there's a hard rule that we can't cast any votes lower than
@@ -1666,7 +1666,7 @@ fn imports_justification_for_regular_blocks_on_import() {
);
// the justification should be imported and available from the client
assert!(client.justifications(&block_hash).unwrap().is_some());
assert!(client.justifications(block_hash).unwrap().is_some());
}
#[test]
substrate/client/finality-grandpa/src/warp_proof.rs
+2 -2
View File
@@ -130,7 +130,7 @@ impl<Block: BlockT> WarpSyncProof<Block> {
}
let justification = blockchain
.justifications(&header.hash())?
.justifications(header.hash())?
.and_then(|just| just.into_justification(GRANDPA_ENGINE_ID))
.expect(
"header is last in set and contains standard change signal; \
@@ -412,7 +412,7 @@ mod tests {
let justification = GrandpaJustification::from_commit(&client, 42, commit).unwrap();
client
.finalize_block(&target_hash, Some((GRANDPA_ENGINE_ID, justification.encode())))
.finalize_block(target_hash, Some((GRANDPA_ENGINE_ID, justification.encode())))
.unwrap();
authority_set_changes.push((current_set_id, n));
substrate/client/network/bitswap/src/lib.rs
+1 -1
View File
@@ -203,7 +203,7 @@ impl<B: BlockT> BitswapRequestHandler<B> {
let mut hash = B::Hash::default();
hash.as_mut().copy_from_slice(&cid.hash().digest()[0..32]);
let transaction = match self.client.indexed_transaction(&hash) {
let transaction = match self.client.indexed_transaction(hash) {
Ok(ex) => ex,
Err(e) => {
error!(target: LOG_TARGET, "Error retrieving transaction {}: {}", hash, e);
substrate/client/network/light/src/light_client_requests/handler.rs
+3 -3
View File
@@ -172,7 +172,7 @@ where
let block = Decode::decode(&mut request.block.as_ref())?;
let response = match self.client.execution_proof(&block, &request.method, &request.data) {
let response = match self.client.execution_proof(block, &request.method, &request.data) {
Ok((_, proof)) => {
let r = schema::v1::light::RemoteCallResponse { proof: proof.encode() };
Some(schema::v1::light::response::Response::RemoteCallResponse(r))
@@ -212,7 +212,7 @@ where
let block = Decode::decode(&mut request.block.as_ref())?;
let response =
match self.client.read_proof(&block, &mut request.keys.iter().map(AsRef::as_ref)) {
match self.client.read_proof(block, &mut request.keys.iter().map(AsRef::as_ref)) {
Ok(proof) => {
let r = schema::v1::light::RemoteReadResponse { proof: proof.encode() };
Some(schema::v1::light::response::Response::RemoteReadResponse(r))
@@ -259,7 +259,7 @@ where
};
let response = match child_info.and_then(|child_info| {
self.client.read_child_proof(
&block,
block,
&child_info,
&mut request.keys.iter().map(AsRef::as_ref),
)
substrate/client/network/sync/src/block_request_handler.rs
+3 -3
View File
@@ -332,7 +332,7 @@ where
let hash = header.hash();
let parent_hash = *header.parent_hash();
let justifications =
if get_justification { self.client.justifications(&hash)? } else { None };
if get_justification { self.client.justifications(hash)? } else { None };
let (justifications, justification, is_empty_justification) =
if support_multiple_justifications {
@@ -361,7 +361,7 @@ where
};
let body = if get_body {
match self.client.block_body(&hash)? {
match self.client.block_body(hash)? {
Some(mut extrinsics) =>
extrinsics.iter_mut().map(|extrinsic| extrinsic.encode()).collect(),
None => {
@@ -374,7 +374,7 @@ where
};
let indexed_body = if get_indexed_body {
match self.client.block_indexed_body(&hash)? {
match self.client.block_indexed_body(hash)? {
Some(transactions) => transactions,
None => {
log::trace!(
substrate/client/network/sync/src/lib.rs
+2 -2
View File
@@ -3201,7 +3201,7 @@ mod test {
let finalized_block = blocks[MAX_BLOCKS_TO_LOOK_BACKWARDS as usize * 2 - 1].clone();
let just = (*b"TEST", Vec::new());
client.finalize_block(&finalized_block.hash(), Some(just)).unwrap();
client.finalize_block(finalized_block.hash(), Some(just)).unwrap();
sync.update_chain_info(&info.best_hash, info.best_number);
let peer_id1 = PeerId::random();
@@ -3333,7 +3333,7 @@ mod test {
let finalized_block = blocks[MAX_BLOCKS_TO_LOOK_BACKWARDS as usize * 2 - 1].clone();
let just = (*b"TEST", Vec::new());
client.finalize_block(&finalized_block.hash(), Some(just)).unwrap();
client.finalize_block(finalized_block.hash(), Some(just)).unwrap();
sync.update_chain_info(&info.best_hash, info.best_number);
let peer_id1 = PeerId::random();
substrate/client/network/sync/src/state_request_handler.rs
+2 -2
View File
@@ -205,14 +205,14 @@ where
if !request.no_proof {
let (proof, _count) = self.client.read_proof_collection(
&block,
block,
request.start.as_slice(),
MAX_RESPONSE_BYTES,
)?;
response.proof = proof.encode();
} else {
let entries = self.client.storage_collection(
&block,
block,
request.start.as_slice(),
MAX_RESPONSE_BYTES,
)?;
substrate/client/network/test/src/block_import.rs
+1 -1
View File
@@ -40,7 +40,7 @@ fn prepare_good_block() -> (TestClient, Hash, u64, PeerId, IncomingBlock<Block>)
let (hash, number) = (client.block_hash(1).unwrap().unwrap(), 1);
let header = client.header(&BlockId::Number(1)).unwrap();
let justifications = client.justifications(&hash).unwrap();
let justifications = client.justifications(hash).unwrap();
let peer_id = PeerId::random();
(
client,
substrate/client/network/test/src/lib.rs
+7 -7
View File
@@ -173,12 +173,12 @@ impl PeersClient {
Some(header) => header,
None => return false,
};
self.backend.have_state_at(&header.hash(), *header.number())
self.backend.have_state_at(header.hash(), *header.number())
}
pub fn justifications(
&self,
hash: &<Block as BlockT>::Hash,
hash: <Block as BlockT>::Hash,
) -> ClientResult<Option<Justifications>> {
self.client.justifications(hash)
}
@@ -193,7 +193,7 @@ impl PeersClient {
pub fn finalize_block(
&self,
hash: &<Block as BlockT>::Hash,
hash: <Block as BlockT>::Hash,
justification: Option<Justification>,
notify: bool,
) -> ClientResult<()> {
@@ -535,14 +535,14 @@ where
self.verifier.failed_verifications.lock().clone()
}
pub fn has_block(&self, hash: &H256) -> bool {
pub fn has_block(&self, hash: H256) -> bool {
self.backend
.as_ref()
.map(|backend| backend.blockchain().header(BlockId::hash(*hash)).unwrap().is_some())
.map(|backend| backend.blockchain().header(BlockId::hash(hash)).unwrap().is_some())
.unwrap_or(false)
}
pub fn has_body(&self, hash: &H256) -> bool {
pub fn has_body(&self, hash: H256) -> bool {
self.backend
.as_ref()
.map(|backend| backend.blockchain().body(hash).unwrap().is_some())
@@ -1124,7 +1124,7 @@ impl JustificationImport<Block> for ForceFinalized {
justification: Justification,
) -> Result<(), Self::Error> {
self.0
.finalize_block(&hash, Some(justification), true)
.finalize_block(hash, Some(justification), true)
.map_err(|_| ConsensusError::InvalidJustification)
}
}
substrate/client/network/test/src/sync.rs
+36 -45
View File
@@ -252,23 +252,14 @@ fn sync_justifications() {
let hashof20 = backend.blockchain().expect_block_hash_from_id(&BlockId::Number(20)).unwrap();
// there's currently no justification for block #10
assert_eq!(net.peer(0).client().justifications(&hashof10).unwrap(), None);
assert_eq!(net.peer(1).client().justifications(&hashof10).unwrap(), None);
assert_eq!(net.peer(0).client().justifications(hashof10).unwrap(), None);
assert_eq!(net.peer(1).client().justifications(hashof10).unwrap(), None);
// we finalize block #10, #15 and #20 for peer 0 with a justification
let just = (*b"FRNK", Vec::new());
net.peer(0)
.client()
.finalize_block(&hashof10, Some(just.clone()), true)
.unwrap();
net.peer(0)
.client()
.finalize_block(&hashof15, Some(just.clone()), true)
.unwrap();
net.peer(0)
.client()
.finalize_block(&hashof20, Some(just.clone()), true)
.unwrap();
net.peer(0).client().finalize_block(hashof10, Some(just.clone()), true).unwrap();
net.peer(0).client().finalize_block(hashof15, Some(just.clone()), true).unwrap();
net.peer(0).client().finalize_block(hashof20, Some(just.clone()), true).unwrap();
let hashof10 = net.peer(1).client().header(&BlockId::Number(10)).unwrap().unwrap().hash();
let hashof15 = net.peer(1).client().header(&BlockId::Number(15)).unwrap().unwrap().hash();
@@ -283,12 +274,12 @@ fn sync_justifications() {
net.poll(cx);
for hash in [hashof10, hashof15, hashof20] {
if net.peer(0).client().justifications(&hash).unwrap() !=
if net.peer(0).client().justifications(hash).unwrap() !=
Some(Justifications::from((*b"FRNK", Vec::new())))
{
return Poll::Pending
}
if net.peer(1).client().justifications(&hash).unwrap() !=
if net.peer(1).client().justifications(hash).unwrap() !=
Some(Justifications::from((*b"FRNK", Vec::new())))
{
return Poll::Pending
@@ -314,7 +305,7 @@ fn sync_justifications_across_forks() {
net.block_until_sync();
let just = (*b"FRNK", Vec::new());
net.peer(0).client().finalize_block(&f1_best, Some(just), true).unwrap();
net.peer(0).client().finalize_block(f1_best, Some(just), true).unwrap();
net.peer(1).request_justification(&f1_best, 10);
net.peer(1).request_justification(&f2_best, 11);
@@ -322,9 +313,9 @@ fn sync_justifications_across_forks() {
block_on(futures::future::poll_fn::<(), _>(|cx| {
net.poll(cx);
if net.peer(0).client().justifications(&f1_best).unwrap() ==
if net.peer(0).client().justifications(f1_best).unwrap() ==
Some(Justifications::from((*b"FRNK", Vec::new()))) &&
net.peer(1).client().justifications(&f1_best).unwrap() ==
net.peer(1).client().justifications(f1_best).unwrap() ==
Some(Justifications::from((*b"FRNK", Vec::new())))
{
Poll::Ready(())
@@ -369,10 +360,10 @@ fn syncs_all_forks() {
net.block_until_sync();
// Check that all peers have all of the branches.
assert!(net.peer(0).has_block(&b1));
assert!(net.peer(0).has_block(&b2));
assert!(net.peer(1).has_block(&b1));
assert!(net.peer(1).has_block(&b2));
assert!(net.peer(0).has_block(b1));
assert!(net.peer(0).has_block(b2));
assert!(net.peer(1).has_block(b1));
assert!(net.peer(1).has_block(b2));
}
#[test]
@@ -555,7 +546,7 @@ fn syncs_header_only_forks() {
net.peer(1).push_blocks(4, false);
// Peer 1 will sync the small fork even though common block state is missing
while !net.peer(1).has_block(&small_hash) {
while !net.peer(1).has_block(small_hash) {
net.block_until_idle();
}
}
@@ -657,13 +648,13 @@ fn can_sync_to_peers_with_wrong_common_block() {
// both peers re-org to the same fork without notifying each other
let just = Some((*b"FRNK", Vec::new()));
net.peer(0).client().finalize_block(&fork_hash, just.clone(), true).unwrap();
net.peer(1).client().finalize_block(&fork_hash, just, true).unwrap();
net.peer(0).client().finalize_block(fork_hash, just.clone(), true).unwrap();
net.peer(1).client().finalize_block(fork_hash, just, true).unwrap();
let final_hash = net.peer(0).push_blocks(1, false);
net.block_until_sync();
assert!(net.peer(1).has_block(&final_hash));
assert!(net.peer(1).has_block(final_hash));
}
/// Returns `is_new_best = true` for each validated announcement.
@@ -724,7 +715,7 @@ fn sync_blocks_when_block_announce_validator_says_it_is_new_best() {
ForkChoiceStrategy::Custom(false),
);
while !net.peer(2).has_block(&block_hash) {
while !net.peer(2).has_block(block_hash) {
net.block_until_idle();
}
}
@@ -767,7 +758,7 @@ fn wait_until_deferred_block_announce_validation_is_ready() {
ForkChoiceStrategy::Custom(false),
);
while !net.peer(1).has_block(&block_hash) {
while !net.peer(1).has_block(block_hash) {
net.block_until_idle();
}
}
@@ -788,7 +779,7 @@ fn sync_to_tip_requires_that_sync_protocol_is_informed_about_best_block() {
net.block_until_idle();
// The peer should not have synced the block.
assert!(!net.peer(1).has_block(&block_hash));
assert!(!net.peer(1).has_block(block_hash));
// Make sync protocol aware of the best block
net.peer(0).network_service().new_best_block_imported(block_hash, 3);
@@ -802,7 +793,7 @@ fn sync_to_tip_requires_that_sync_protocol_is_informed_about_best_block() {
block_on(futures::future::poll_fn::<(), _>(|cx| {
net.poll(cx);
if net.peer(2).has_block(&block_hash) {
if net.peer(2).has_block(block_hash) {
Poll::Ready(())
} else {
Poll::Pending
@@ -810,7 +801,7 @@ fn sync_to_tip_requires_that_sync_protocol_is_informed_about_best_block() {
}));
// However peer 1 should still not have the block.
assert!(!net.peer(1).has_block(&block_hash));
assert!(!net.peer(1).has_block(block_hash));
}
/// Ensures that if we as a syncing node sync to the tip while we are connected to another peer
@@ -831,10 +822,10 @@ fn sync_to_tip_when_we_sync_together_with_multiple_peers() {
net.block_until_connected();
net.block_until_idle();
assert!(!net.peer(2).has_block(&block_hash));
assert!(!net.peer(2).has_block(block_hash));
net.peer(0).network_service().new_best_block_imported(block_hash, 10_000);
while !net.peer(2).has_block(&block_hash) && !net.peer(1).has_block(&block_hash) {
while !net.peer(2).has_block(block_hash) && !net.peer(1).has_block(block_hash) {
net.block_until_idle();
}
}
@@ -895,7 +886,7 @@ fn block_announce_data_is_propagated() {
let block_hash = net.peer(0).push_blocks_at_without_announcing(BlockId::Number(0), 1, true);
net.peer(0).announce_block(block_hash, Some(vec![137]));
while !net.peer(1).has_block(&block_hash) || !net.peer(2).has_block(&block_hash) {
while !net.peer(1).has_block(block_hash) || !net.peer(2).has_block(block_hash) {
net.block_until_idle();
}
}
@@ -939,7 +930,7 @@ fn continue_to_sync_after_some_block_announcement_verifications_failed() {
let block_hash = net.peer(0).push_blocks(500, true);
net.block_until_sync();
assert!(net.peer(1).has_block(&block_hash));
assert!(net.peer(1).has_block(block_hash));
}
/// When being spammed by the same request of a peer, we ban this peer. However, we should only ban
@@ -956,8 +947,8 @@ fn multiple_requests_are_accepted_as_long_as_they_are_not_fulfilled() {
let hashof10 = net.peer(1).client().header(&BlockId::Number(10)).unwrap().unwrap().hash();
// there's currently no justification for block #10
assert_eq!(net.peer(0).client().justifications(&hashof10).unwrap(), None);
assert_eq!(net.peer(1).client().justifications(&hashof10).unwrap(), None);
assert_eq!(net.peer(0).client().justifications(hashof10).unwrap(), None);
assert_eq!(net.peer(1).client().justifications(hashof10).unwrap(), None);
// Let's assume block 10 was finalized, but we still need the justification from the network.
net.peer(1).request_justification(&hashof10, 10);
@@ -982,13 +973,13 @@ fn multiple_requests_are_accepted_as_long_as_they_are_not_fulfilled() {
// Finalize the block and make the justification available.
net.peer(0)
.client()
.finalize_block(&hashof10, Some((*b"FRNK", Vec::new())), true)
.finalize_block(hashof10, Some((*b"FRNK", Vec::new())), true)
.unwrap();
block_on(futures::future::poll_fn::<(), _>(|cx| {
net.poll(cx);
if net.peer(1).client().justifications(&hashof10).unwrap() !=
if net.peer(1).client().justifications(hashof10).unwrap() !=
Some(Justifications::from((*b"FRNK", Vec::new())))
{
return Poll::Pending
@@ -1110,7 +1101,7 @@ fn syncs_state() {
.blockchain()
.expect_block_hash_from_id(&BlockId::Number(60))
.unwrap();
net.peer(1).client().finalize_block(&hashof60, Some(just), true).unwrap();
net.peer(1).client().finalize_block(hashof60, Some(just), true).unwrap();
// Wait for state sync.
block_on(futures::future::poll_fn::<(), _>(|cx| {
net.poll(cx);
@@ -1165,14 +1156,14 @@ fn syncs_indexed_blocks() {
.peer(0)
.client()
.as_client()
.indexed_transaction(&indexed_key)
.indexed_transaction(indexed_key)
.unwrap()
.is_some());
assert!(net
.peer(1)
.client()
.as_client()
.indexed_transaction(&indexed_key)
.indexed_transaction(indexed_key)
.unwrap()
.is_none());
@@ -1181,7 +1172,7 @@ fn syncs_indexed_blocks() {
.peer(1)
.client()
.as_client()
.indexed_transaction(&indexed_key)
.indexed_transaction(indexed_key)
.unwrap()
.is_some());
}
@@ -1210,7 +1201,7 @@ fn warp_sync() {
// Wait for peer 1 download block history
block_on(futures::future::poll_fn::<(), _>(|cx| {
net.poll(cx);
if net.peer(3).has_body(&gap_end) && net.peer(3).has_body(&target) {
if net.peer(3).has_body(gap_end) && net.peer(3).has_body(target) {
Poll::Ready(())
} else {
Poll::Pending
substrate/client/rpc/src/chain/tests.rs
+2 -2
View File
@@ -206,7 +206,7 @@ async fn should_return_finalized_hash() {
assert_eq!(res, client.genesis_hash());
// finalize
client.finalize_block(&block_hash, None).unwrap();
client.finalize_block(block_hash, None).unwrap();
let res: H256 = api.call("chain_getFinalizedHead", EmptyParams::new()).await.unwrap();
assert_eq!(res, block_hash);
}
@@ -235,7 +235,7 @@ async fn test_head_subscription(method: &str) {
let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
let block_hash = block.hash();
client.import(BlockOrigin::Own, block).await.unwrap();
client.finalize_block(&block_hash, None).unwrap();
client.finalize_block(block_hash, None).unwrap();
sub
};
substrate/client/rpc/src/state/state_full.rs
+16 -16
View File
@@ -147,7 +147,7 @@ where
let mut block_changes = StorageChangeSet { block: *block_hash, changes: Vec::new() };
for key in keys {
let (has_changed, data) = {
let curr_data = self.client.storage(block_hash, key).map_err(client_err)?;
let curr_data = self.client.storage(*block_hash, key).map_err(client_err)?;
match last_values.get(key) {
Some(prev_data) => (curr_data != *prev_data, curr_data),
None => (true, curr_data),
@@ -213,7 +213,7 @@ where
prefix: StorageKey,
) -> std::result::Result<Vec<StorageKey>, Error> {
self.block_or_best(block)
.and_then(|block| self.client.storage_keys(&block, &prefix))
.and_then(|block| self.client.storage_keys(block, &prefix))
.map_err(client_err)
}
@@ -223,7 +223,7 @@ where
prefix: StorageKey,
) -> std::result::Result<Vec<(StorageKey, StorageData)>, Error> {
self.block_or_best(block)
.and_then(|block| self.client.storage_pairs(&block, &prefix))
.and_then(|block| self.client.storage_pairs(block, &prefix))
.map_err(client_err)
}
@@ -236,7 +236,7 @@ where
) -> std::result::Result<Vec<StorageKey>, Error> {
self.block_or_best(block)
.and_then(|block| {
self.client.storage_keys_iter(&block, prefix.as_ref(), start_key.as_ref())
self.client.storage_keys_iter(block, prefix.as_ref(), start_key.as_ref())
})
.map(|iter| iter.take(count as usize).collect())
.map_err(client_err)
@@ -248,7 +248,7 @@ where
key: StorageKey,
) -> std::result::Result<Option<StorageData>, Error> {
self.block_or_best(block)
.and_then(|block| self.client.storage(&block, &key))
.and_then(|block| self.client.storage(block, &key))
.map_err(client_err)
}
@@ -262,14 +262,14 @@ where
Err(e) => return Err(client_err(e)),
};
match self.client.storage(&block, &key) {
match self.client.storage(block, &key) {
Ok(Some(d)) => return Ok(Some(d.0.len() as u64)),
Err(e) => return Err(client_err(e)),
Ok(None) => {},
}
self.client
.storage_pairs(&block, &key)
.storage_pairs(block, &key)
.map(|kv| {
let item_sum = kv.iter().map(|(_, v)| v.0.len() as u64).sum::<u64>();
if item_sum > 0 {
@@ -287,7 +287,7 @@ where
key: StorageKey,
) -> std::result::Result<Option<Block::Hash>, Error> {
self.block_or_best(block)
.and_then(|block| self.client.storage_hash(&block, &key))
.and_then(|block| self.client.storage_hash(block, &key))
.map_err(client_err)
}
@@ -345,7 +345,7 @@ where
self.block_or_best(block)
.and_then(|block| {
self.client
.read_proof(&block, &mut keys.iter().map(|key| key.0.as_ref()))
.read_proof(block, &mut keys.iter().map(|key| key.0.as_ref()))
.map(|proof| proof.into_iter_nodes().map(|node| node.into()).collect())
.map(|proof| ReadProof { at: block, proof })
})
@@ -413,7 +413,7 @@ where
let changes = keys
.into_iter()
.map(|key| {
let v = self.client.storage(&block, &key).ok().flatten();
let v = self.client.storage(block, &key).ok().flatten();
(key, v)
})
.collect();
@@ -494,7 +494,7 @@ where
};
self.client
.read_child_proof(
&block,
block,
&child_info,
&mut keys.iter().map(|key| key.0.as_ref()),
)
@@ -517,7 +517,7 @@ where
ChildInfo::new_default(storage_key),
None => return Err(sp_blockchain::Error::InvalidChildStorageKey),
};
self.client.child_storage_keys(&block, &child_info, &prefix)
self.client.child_storage_keys(block, &child_info, &prefix)
})
.map_err(client_err)
}
@@ -538,7 +538,7 @@ where
None => return Err(sp_blockchain::Error::InvalidChildStorageKey),
};
self.client.child_storage_keys_iter(
&block,
block,
child_info,
prefix.as_ref(),
start_key.as_ref(),
@@ -561,7 +561,7 @@ where
ChildInfo::new_default(storage_key),
None => return Err(sp_blockchain::Error::InvalidChildStorageKey),
};
self.client.child_storage(&block, &child_info, &key)
self.client.child_storage(block, &child_info, &key)
})
.map_err(client_err)
}
@@ -584,7 +584,7 @@ where
keys.into_iter()
.map(move |key| {
client.clone().child_storage(&block, &child_info, &key).map_err(client_err)
client.clone().child_storage(block, &child_info, &key).map_err(client_err)
})
.collect()
}
@@ -602,7 +602,7 @@ where
ChildInfo::new_default(storage_key),
None => return Err(sp_blockchain::Error::InvalidChildStorageKey),
};
self.client.child_storage_hash(&block, &child_info, &key)
self.client.child_storage_hash(block, &child_info, &key)
})
.map_err(client_err)
}
substrate/client/service/src/chain_ops/export_raw_state.rs
+1 -1
View File
@@ -25,7 +25,7 @@ use std::{collections::HashMap, sync::Arc};
/// Export the raw state at the given `block`. If `block` is `None`, the
/// best block will be used.
pub fn export_raw_state<B, BA, C>(client: Arc<C>, hash: &B::Hash) -> Result<Storage, Error>
pub fn export_raw_state<B, BA, C>(client: Arc<C>, hash: B::Hash) -> Result<Storage, Error>
where
C: UsageProvider<B> + StorageProvider<B, BA>,
B: BlockT,
substrate/client/service/src/client/call_executor.rs
+4 -4
View File
@@ -148,7 +148,7 @@ where
) -> sp_blockchain::Result<Vec<u8>> {
let mut changes = OverlayedChanges::default();
let at_hash = self.backend.blockchain().expect_block_hash_from_id(at)?;
let state = self.backend.state_at(&at_hash)?;
let state = self.backend.state_at(at_hash)?;
let state_runtime_code = sp_state_machine::backend::BackendRuntimeCode::new(&state);
let runtime_code =
state_runtime_code.runtime_code().map_err(sp_blockchain::Error::RuntimeCode)?;
@@ -193,7 +193,7 @@ where
let mut storage_transaction_cache = storage_transaction_cache.map(|c| c.borrow_mut());
let at_hash = self.backend.blockchain().expect_block_hash_from_id(at)?;
let state = self.backend.state_at(&at_hash)?;
let state = self.backend.state_at(at_hash)?;
let changes = &mut *changes.borrow_mut();
@@ -251,7 +251,7 @@ where
let mut overlay = OverlayedChanges::default();
let at_hash = self.backend.blockchain().expect_block_hash_from_id(id)?;
let state = self.backend.state_at(&at_hash)?;
let state = self.backend.state_at(at_hash)?;
let mut cache = StorageTransactionCache::<Block, B::State>::default();
let mut ext = Ext::new(&mut overlay, &mut cache, &state, None);
let state_runtime_code = sp_state_machine::backend::BackendRuntimeCode::new(&state);
@@ -269,7 +269,7 @@ where
call_data: &[u8],
) -> sp_blockchain::Result<(Vec<u8>, StorageProof)> {
let at_hash = self.backend.blockchain().expect_block_hash_from_id(at)?;
let state = self.backend.state_at(&at_hash)?;
let state = self.backend.state_at(at_hash)?;
let trie_backend = state.as_trie_backend();
substrate/client/service/src/client/client.rs
+38 -41
View File
@@ -414,14 +414,14 @@ where
}
/// Get a reference to the state at a given block.
pub fn state_at(&self, hash: &Block::Hash) -> sp_blockchain::Result<B::State> {
pub fn state_at(&self, hash: Block::Hash) -> sp_blockchain::Result<B::State> {
self.backend.state_at(hash)
}
/// Get the code at a given block.
pub fn code_at(&self, id: &BlockId<Block>) -> sp_blockchain::Result<Vec<u8>> {
let hash = self.backend.blockchain().expect_block_hash_from_id(id)?;
Ok(StorageProvider::storage(self, &hash, &StorageKey(well_known_keys::CODE.to_vec()))?
Ok(StorageProvider::storage(self, hash, &StorageKey(well_known_keys::CODE.to_vec()))?
.expect(
"None is returned if there's no value stored for the given key;\
':code' key is always defined; qed",
@@ -586,7 +586,7 @@ where
Some(storage_changes) => {
let storage_changes = match storage_changes {
sc_consensus::StorageChanges::Changes(storage_changes) => {
self.backend.begin_state_operation(&mut operation.op, &parent_hash)?;
self.backend.begin_state_operation(&mut operation.op, parent_hash)?;
let (main_sc, child_sc, offchain_sc, tx, _, tx_index) =
storage_changes.into_inner();
@@ -813,7 +813,7 @@ where
Block::new(import_block.header.clone(), body.clone()),
)?;
let state = self.backend.state_at(parent_hash)?;
let state = self.backend.state_at(*parent_hash)?;
let gen_storage_changes = runtime_api
.into_storage_changes(&state, *parent_hash)
.map_err(sp_blockchain::Error::Storage)?;
@@ -877,17 +877,17 @@ where
// plugable we cannot make a better choice here. usages that need
// an accurate "best" block need to go through `SelectChain`
// instead.
operation.op.mark_head(&block)?;
operation.op.mark_head(block)?;
}
let enacted = route_from_finalized.enacted();
assert!(enacted.len() > 0);
for finalize_new in &enacted[..enacted.len() - 1] {
operation.op.mark_finalized(&finalize_new.hash, None)?;
operation.op.mark_finalized(finalize_new.hash, None)?;
}
assert_eq!(enacted.last().map(|e| e.hash), Some(block));
operation.op.mark_finalized(&block, justification)?;
operation.op.mark_finalized(block, justification)?;
if notify {
let finalized =
@@ -1033,7 +1033,7 @@ where
};
match hash_and_number {
Some((hash, number)) =>
if self.backend.have_state_at(&hash, number) {
if self.backend.have_state_at(hash, number) {
Ok(BlockStatus::InChainWithState)
} else {
Ok(BlockStatus::InChainPruned)
@@ -1053,7 +1053,7 @@ where
/// Get block body by id.
pub fn body(
&self,
hash: &Block::Hash,
hash: Block::Hash,
) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>> {
self.backend.blockchain().body(hash)
}
@@ -1151,7 +1151,7 @@ where
{
fn read_proof(
&self,
hash: &Block::Hash,
hash: Block::Hash,
keys: &mut dyn Iterator<Item = &[u8]>,
) -> sp_blockchain::Result<StorageProof> {
self.state_at(hash)
@@ -1160,7 +1160,7 @@ where
fn read_child_proof(
&self,
hash: &Block::Hash,
hash: Block::Hash,
child_info: &ChildInfo,
keys: &mut dyn Iterator<Item = &[u8]>,
) -> sp_blockchain::Result<StorageProof> {
@@ -1170,16 +1170,16 @@ where
fn execution_proof(
&self,
hash: &Block::Hash,
hash: Block::Hash,
method: &str,
call_data: &[u8],
) -> sp_blockchain::Result<(Vec<u8>, StorageProof)> {
self.executor.prove_execution(&BlockId::Hash(*hash), method, call_data)
self.executor.prove_execution(&BlockId::Hash(hash), method, call_data)
}
fn read_proof_collection(
&self,
hash: &Block::Hash,
hash: Block::Hash,
start_key: &[Vec<u8>],
size_limit: usize,
) -> sp_blockchain::Result<(CompactProof, u32)> {
@@ -1198,14 +1198,14 @@ where
fn storage_collection(
&self,
hash: &Block::Hash,
hash: Block::Hash,
start_key: &[Vec<u8>],
size_limit: usize,
) -> sp_blockchain::Result<Vec<(KeyValueStorageLevel, bool)>> {
if start_key.len() > MAX_NESTED_TRIE_DEPTH {
return Err(Error::Backend("Invalid start key.".to_string()))
}
let state = self.state_at(&hash)?;
let state = self.state_at(hash)?;
let child_info = |storage_key: &Vec<u8>| -> sp_blockchain::Result<ChildInfo> {
let storage_key = PrefixedStorageKey::new_ref(storage_key);
match ChildType::from_prefixed_key(storage_key) {
@@ -1398,7 +1398,7 @@ where
{
fn storage_keys(
&self,
hash: &Block::Hash,
hash: Block::Hash,
key_prefix: &StorageKey,
) -> sp_blockchain::Result<Vec<StorageKey>> {
let keys = self.state_at(hash)?.keys(&key_prefix.0).into_iter().map(StorageKey).collect();
@@ -1407,7 +1407,7 @@ where
fn storage_pairs(
&self,
hash: &<Block as BlockT>::Hash,
hash: <Block as BlockT>::Hash,
key_prefix: &StorageKey,
) -> sp_blockchain::Result<Vec<(StorageKey, StorageData)>> {
let state = self.state_at(hash)?;
@@ -1424,7 +1424,7 @@ where
fn storage_keys_iter<'a>(
&self,
hash: &<Block as BlockT>::Hash,
hash: <Block as BlockT>::Hash,
prefix: Option<&'a StorageKey>,
start_key: Option<&StorageKey>,
) -> sp_blockchain::Result<KeyIterator<'a, B::State, Block>> {
@@ -1435,7 +1435,7 @@ where
fn child_storage_keys_iter<'a>(
&self,
hash: &<Block as BlockT>::Hash,
hash: <Block as BlockT>::Hash,
child_info: ChildInfo,
prefix: Option<&'a StorageKey>,
start_key: Option<&StorageKey>,
@@ -1447,7 +1447,7 @@ where
fn storage(
&self,
hash: &Block::Hash,
hash: Block::Hash,
key: &StorageKey,
) -> sp_blockchain::Result<Option<StorageData>> {
Ok(self
@@ -1459,7 +1459,7 @@ where
fn storage_hash(
&self,
hash: &<Block as BlockT>::Hash,
hash: <Block as BlockT>::Hash,
key: &StorageKey,
) -> sp_blockchain::Result<Option<Block::Hash>> {
self.state_at(hash)?
@@ -1469,7 +1469,7 @@ where
fn child_storage_keys(
&self,
hash: &<Block as BlockT>::Hash,
hash: <Block as BlockT>::Hash,
child_info: &ChildInfo,
key_prefix: &StorageKey,
) -> sp_blockchain::Result<Vec<StorageKey>> {
@@ -1484,7 +1484,7 @@ where
fn child_storage(
&self,
hash: &<Block as BlockT>::Hash,
hash: <Block as BlockT>::Hash,
child_info: &ChildInfo,
key: &StorageKey,
) -> sp_blockchain::Result<Option<StorageData>> {
@@ -1497,7 +1497,7 @@ where
fn child_storage_hash(
&self,
hash: &<Block as BlockT>::Hash,
hash: <Block as BlockT>::Hash,
child_info: &ChildInfo,
key: &StorageKey,
) -> sp_blockchain::Result<Option<Block::Hash>> {
@@ -1683,7 +1683,7 @@ where
fn state_at(&self, at: &BlockId<Block>) -> Result<Self::StateBackend, sp_api::ApiError> {
let hash = self.backend.blockchain().expect_block_hash_from_id(at)?;
self.state_at(&hash).map_err(Into::into)
self.state_at(hash).map_err(Into::into)
}
}
@@ -1844,17 +1844,17 @@ where
fn apply_finality(
&self,
operation: &mut ClientImportOperation<Block, B>,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
notify: bool,
) -> sp_blockchain::Result<()> {
let last_best = self.backend.blockchain().info().best_hash;
self.apply_finality_with_block_hash(operation, *hash, justification, last_best, notify)
self.apply_finality_with_block_hash(operation, hash, justification, last_best, notify)
}
fn finalize_block(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
notify: bool,
) -> sp_blockchain::Result<()> {
@@ -1873,7 +1873,7 @@ where
fn apply_finality(
&self,
operation: &mut ClientImportOperation<Block, B>,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
notify: bool,
) -> sp_blockchain::Result<()> {
@@ -1882,7 +1882,7 @@ where
fn finalize_block(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
notify: bool,
) -> sp_blockchain::Result<()> {
@@ -1939,7 +1939,7 @@ where
{
fn block_body(
&self,
hash: &Block::Hash,
hash: Block::Hash,
) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>> {
self.body(hash)
}
@@ -1948,7 +1948,7 @@ where
Ok(match self.header(id)? {
Some(header) => {
let hash = header.hash();
match (self.body(&hash)?, self.justifications(&hash)?) {
match (self.body(hash)?, self.justifications(hash)?) {
(Some(extrinsics), justifications) =>
Some(SignedBlock { block: Block::new(header, extrinsics), justifications }),
_ => None,
@@ -1962,7 +1962,7 @@ where
Client::block_status(self, id)
}
fn justifications(&self, hash: &Block::Hash) -> sp_blockchain::Result<Option<Justifications>> {
fn justifications(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Justifications>> {
self.backend.blockchain().justifications(hash)
}
@@ -1970,18 +1970,15 @@ where
self.backend.blockchain().hash(number)
}
fn indexed_transaction(&self, hash: &Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>> {
fn indexed_transaction(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>> {
self.backend.blockchain().indexed_transaction(hash)
}
fn has_indexed_transaction(&self, hash: &Block::Hash) -> sp_blockchain::Result<bool> {
fn has_indexed_transaction(&self, hash: Block::Hash) -> sp_blockchain::Result<bool> {
self.backend.blockchain().has_indexed_transaction(hash)
}
fn block_indexed_body(
&self,
hash: &Block::Hash,
) -> sp_blockchain::Result<Option<Vec<Vec<u8>>>> {
fn block_indexed_body(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<Vec<u8>>>> {
self.backend.blockchain().block_indexed_body(hash)
}
@@ -2085,7 +2082,7 @@ where
self.backend
.blockchain()
.block_indexed_body(&hash)
.block_indexed_body(hash)
.map_err(|e| sp_transaction_storage_proof::Error::Application(Box::new(e)))
}
substrate/client/service/test/src/client/mod.rs
+21 -21
View File
@@ -346,7 +346,7 @@ fn block_builder_works_with_transactions() {
.expect("block 1 was just imported. qed");
assert_eq!(client.chain_info().best_number, 1);
assert_ne!(client.state_at(&hash1).unwrap().pairs(), client.state_at(&hash0).unwrap().pairs());
assert_ne!(client.state_at(hash1).unwrap().pairs(), client.state_at(hash0).unwrap().pairs());
assert_eq!(
client
.runtime_api()
@@ -405,10 +405,10 @@ fn block_builder_does_not_include_invalid() {
assert_eq!(client.chain_info().best_number, 1);
assert_ne!(
client.state_at(&hashof1).unwrap().pairs(),
client.state_at(&hashof0).unwrap().pairs()
client.state_at(hashof1).unwrap().pairs(),
client.state_at(hashof0).unwrap().pairs()
);
assert_eq!(client.body(&hashof1).unwrap().unwrap().len(), 1)
assert_eq!(client.body(hashof1).unwrap().unwrap().len(), 1)
}
#[test]
@@ -870,7 +870,7 @@ fn import_with_justification() {
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
client.finalize_block(&a2.hash(), None).unwrap();
client.finalize_block(a2.hash(), None).unwrap();
// A2 -> A3
let justification = Justifications::from((TEST_ENGINE_ID, vec![1, 2, 3]));
@@ -884,11 +884,11 @@ fn import_with_justification() {
assert_eq!(client.chain_info().finalized_hash, a3.hash());
assert_eq!(client.justifications(&a3.hash()).unwrap(), Some(justification));
assert_eq!(client.justifications(a3.hash()).unwrap(), Some(justification));
assert_eq!(client.justifications(&a1.hash()).unwrap(), None);
assert_eq!(client.justifications(a1.hash()).unwrap(), None);
assert_eq!(client.justifications(&a2.hash()).unwrap(), None);
assert_eq!(client.justifications(a2.hash()).unwrap(), None);
finality_notification_check(&mut finality_notifications, &[a1.hash(), a2.hash()], &[]);
finality_notification_check(&mut finality_notifications, &[a3.hash()], &[]);
@@ -999,7 +999,7 @@ fn finalizing_diverged_block_should_trigger_reorg() {
// we finalize block B1 which is on a different branch from current best
// which should trigger a re-org.
ClientExt::finalize_block(&client, &b1.hash(), None).unwrap();
ClientExt::finalize_block(&client, b1.hash(), None).unwrap();
// B1 should now be the latest finalized
assert_eq!(client.chain_info().finalized_hash, b1.hash());
@@ -1023,7 +1023,7 @@ fn finalizing_diverged_block_should_trigger_reorg() {
assert_eq!(client.chain_info().best_hash, b3.hash());
ClientExt::finalize_block(&client, &b3.hash(), None).unwrap();
ClientExt::finalize_block(&client, b3.hash(), None).unwrap();
finality_notification_check(&mut finality_notifications, &[b1.hash()], &[]);
finality_notification_check(&mut finality_notifications, &[b2.hash(), b3.hash()], &[a2.hash()]);
@@ -1121,7 +1121,7 @@ fn finality_notifications_content() {
// Postpone import to test behavior of import of finalized block.
ClientExt::finalize_block(&client, &a2.hash(), None).unwrap();
ClientExt::finalize_block(&client, a2.hash(), None).unwrap();
// Import and finalize D4
block_on(client.import_as_final(BlockOrigin::Own, d4.clone())).unwrap();
@@ -1285,7 +1285,7 @@ fn doesnt_import_blocks_that_revert_finality() {
// we will finalize A2 which should make it impossible to import a new
// B3 at the same height but that doesn't include it
ClientExt::finalize_block(&client, &a2.hash(), None).unwrap();
ClientExt::finalize_block(&client, a2.hash(), None).unwrap();
let import_err = block_on(client.import(BlockOrigin::Own, b3)).err().unwrap();
let expected_err =
@@ -1320,7 +1320,7 @@ fn doesnt_import_blocks_that_revert_finality() {
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
ClientExt::finalize_block(&client, &a3.hash(), None).unwrap();
ClientExt::finalize_block(&client, a3.hash(), None).unwrap();
finality_notification_check(&mut finality_notifications, &[a1.hash(), a2.hash()], &[]);
@@ -1620,7 +1620,7 @@ fn storage_keys_iter_prefix_and_start_key_works() {
let child_prefix = StorageKey(b"sec".to_vec());
let res: Vec<_> = client
.storage_keys_iter(&block_hash, Some(&prefix), None)
.storage_keys_iter(block_hash, Some(&prefix), None)
.unwrap()
.map(|x| x.0)
.collect();
@@ -1635,7 +1635,7 @@ fn storage_keys_iter_prefix_and_start_key_works() {
let res: Vec<_> = client
.storage_keys_iter(
&block_hash,
block_hash,
Some(&prefix),
Some(&StorageKey(array_bytes::hex2bytes_unchecked("3a636f6465"))),
)
@@ -1646,7 +1646,7 @@ fn storage_keys_iter_prefix_and_start_key_works() {
let res: Vec<_> = client
.storage_keys_iter(
&block_hash,
block_hash,
Some(&prefix),
Some(&StorageKey(array_bytes::hex2bytes_unchecked("3a686561707061676573"))),
)
@@ -1656,7 +1656,7 @@ fn storage_keys_iter_prefix_and_start_key_works() {
assert_eq!(res, Vec::<Vec<u8>>::new());
let res: Vec<_> = client
.child_storage_keys_iter(&block_hash, child_info.clone(), Some(&child_prefix), None)
.child_storage_keys_iter(block_hash, child_info.clone(), Some(&child_prefix), None)
.unwrap()
.map(|x| x.0)
.collect();
@@ -1664,7 +1664,7 @@ fn storage_keys_iter_prefix_and_start_key_works() {
let res: Vec<_> = client
.child_storage_keys_iter(
&block_hash,
block_hash,
child_info,
None,
Some(&StorageKey(b"second".to_vec())),
@@ -1684,7 +1684,7 @@ fn storage_keys_iter_works() {
let prefix = StorageKey(array_bytes::hex2bytes_unchecked(""));
let res: Vec<_> = client
.storage_keys_iter(&block_hash, Some(&prefix), None)
.storage_keys_iter(block_hash, Some(&prefix), None)
.unwrap()
.take(9)
.map(|x| array_bytes::bytes2hex("", &x.0))
@@ -1706,7 +1706,7 @@ fn storage_keys_iter_works() {
let res: Vec<_> = client
.storage_keys_iter(
&block_hash,
block_hash,
Some(&prefix),
Some(&StorageKey(array_bytes::hex2bytes_unchecked("3a636f6465"))),
)
@@ -1729,7 +1729,7 @@ fn storage_keys_iter_works() {
let res: Vec<_> = client
.storage_keys_iter(
&block_hash,
block_hash,
Some(&prefix),
Some(&StorageKey(array_bytes::hex2bytes_unchecked(
"7d5007603a7f5dd729d51d93cf695d6465789443bb967c0d1fe270e388c96eaa",
substrate/client/tracing/src/block/mod.rs
+1 -1
View File
@@ -225,7 +225,7 @@ where
.ok_or_else(|| Error::MissingBlockComponent("Header not found".to_string()))?;
let extrinsics = self
.client
.block_body(&self.block)
.block_body(self.block)
.map_err(Error::InvalidBlockId)?
.ok_or_else(|| Error::MissingBlockComponent("Extrinsics not found".to_string()))?;
tracing::debug!(target: "state_tracing", "Found {} extrinsics", extrinsics.len());
substrate/client/transaction-pool/benches/basics.rs
+1 -1
View File
@@ -111,7 +111,7 @@ impl ChainApi for TestApi {
(blake2_256(&encoded).into(), encoded.len())
}
fn block_body(&self, _id: &<Self::Block as BlockT>::Hash) -> Self::BodyFuture {
fn block_body(&self, _id: <Self::Block as BlockT>::Hash) -> Self::BodyFuture {
ready(Ok(None))
}
substrate/client/transaction-pool/src/api.rs
+1 -1
View File
@@ -126,7 +126,7 @@ where
Pin<Box<dyn Future<Output = error::Result<TransactionValidity>> + Send>>;
type BodyFuture = Ready<error::Result<Option<Vec<<Self::Block as BlockT>::Extrinsic>>>>;
fn block_body(&self, hash: &Block::Hash) -> Self::BodyFuture {
fn block_body(&self, hash: Block::Hash) -> Self::BodyFuture {
ready(self.client.block_body(hash).map_err(error::Error::from))
}
substrate/client/transaction-pool/src/graph/pool.rs
+1 -1
View File
@@ -91,7 +91,7 @@ pub trait ChainApi: Send + Sync {
fn hash_and_length(&self, uxt: &ExtrinsicFor<Self>) -> (ExtrinsicHash<Self>, usize);
/// Returns a block body given the block.
fn block_body(&self, at: &<Self::Block as BlockT>::Hash) -> Self::BodyFuture;
fn block_body(&self, at: <Self::Block as BlockT>::Hash) -> Self::BodyFuture;
/// Returns a block header given the block id.
fn block_header(
substrate/client/transaction-pool/src/lib.rs
+6 -6
View File
@@ -550,12 +550,12 @@ impl<N: Clone + Copy + AtLeast32Bit> RevalidationStatus<N> {
/// Prune the known txs for the given block.
async fn prune_known_txs_for_block<Block: BlockT, Api: graph::ChainApi<Block = Block>>(
block_hash: &Block::Hash,
block_hash: Block::Hash,
api: &Api,
pool: &graph::Pool<Api>,
) -> Vec<ExtrinsicHash<Api>> {
let extrinsics = api
.block_body(&block_hash)
.block_body(block_hash)
.await
.unwrap_or_else(|e| {
log::warn!("Prune known transactions: error request: {}", e);
@@ -567,7 +567,7 @@ async fn prune_known_txs_for_block<Block: BlockT, Api: graph::ChainApi<Block = B
log::trace!(target: "txpool", "Pruning transactions: {:?}", hashes);
let header = match api.block_header(&BlockId::Hash(*block_hash)) {
let header = match api.block_header(&BlockId::Hash(block_hash)) {
Ok(Some(h)) => h,
Ok(None) => {
log::debug!(target: "txpool", "Could not find header for {:?}.", block_hash);
@@ -580,7 +580,7 @@ async fn prune_known_txs_for_block<Block: BlockT, Api: graph::ChainApi<Block = B
};
if let Err(e) = pool
.prune(&BlockId::Hash(*block_hash), &BlockId::hash(*header.parent_hash()), &extrinsics)
.prune(&BlockId::Hash(block_hash), &BlockId::hash(*header.parent_hash()), &extrinsics)
.await
{
log::error!("Cannot prune known in the pool: {}", e);
@@ -638,7 +638,7 @@ where
tree_route
.enacted()
.iter()
.map(|h| prune_known_txs_for_block(&h.hash, &*api, &*pool)),
.map(|h| prune_known_txs_for_block(h.hash, &*api, &*pool)),
)
.await
.into_iter()
@@ -656,7 +656,7 @@ where
let hash = retracted.hash;
let block_transactions = api
.block_body(&hash)
.block_body(hash)
.await
.unwrap_or_else(|e| {
log::warn!("Failed to fetch block body: {}", e);
substrate/client/transaction-pool/src/tests.rs
+1 -1
View File
@@ -164,7 +164,7 @@ impl ChainApi for TestApi {
(Hashing::hash(&encoded), len)
}
fn block_body(&self, _id: &<Self::Block as BlockT>::Hash) -> Self::BodyFuture {
fn block_body(&self, _id: <Self::Block as BlockT>::Hash) -> Self::BodyFuture {
futures::future::ready(Ok(None))
}
substrate/primitives/blockchain/src/backend.rs
+5 -5
View File
@@ -89,9 +89,9 @@ pub trait Backend<Block: BlockT>:
HeaderBackend<Block> + HeaderMetadata<Block, Error = Error>
{
/// Get block body. Returns `None` if block is not found.
fn body(&self, hash: &Block::Hash) -> Result<Option<Vec<<Block as BlockT>::Extrinsic>>>;
fn body(&self, hash: Block::Hash) -> Result<Option<Vec<<Block as BlockT>::Extrinsic>>>;
/// Get block justifications. Returns `None` if no justification exists.
fn justifications(&self, hash: &Block::Hash) -> Result<Option<Justifications>>;
fn justifications(&self, hash: Block::Hash) -> Result<Option<Justifications>>;
/// Get last finalized block hash.
fn last_finalized(&self) -> Result<Block::Hash>;
@@ -231,14 +231,14 @@ pub trait Backend<Block: BlockT>:
/// Get single indexed transaction by content hash. Note that this will only fetch transactions
/// that are indexed by the runtime with `storage_index_transaction`.
fn indexed_transaction(&self, hash: &Block::Hash) -> Result<Option<Vec<u8>>>;
fn indexed_transaction(&self, hash: Block::Hash) -> Result<Option<Vec<u8>>>;
/// Check if indexed transaction exists.
fn has_indexed_transaction(&self, hash: &Block::Hash) -> Result<bool> {
fn has_indexed_transaction(&self, hash: Block::Hash) -> Result<bool> {
Ok(self.indexed_transaction(hash)?.is_some())
}
fn block_indexed_body(&self, hash: &Block::Hash) -> Result<Option<Vec<Vec<u8>>>>;
fn block_indexed_body(&self, hash: Block::Hash) -> Result<Option<Vec<Vec<u8>>>>;
}
/// Blockchain info
substrate/test-utils/client/src/client_ext.rs
+2 -2
View File
@@ -29,7 +29,7 @@ pub trait ClientExt<Block: BlockT>: Sized {
/// Finalize a block.
fn finalize_block(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
) -> sp_blockchain::Result<()>;
@@ -75,7 +75,7 @@ where
{
fn finalize_block(
&self,
hash: &Block::Hash,
hash: Block::Hash,
justification: Option<Justification>,
) -> sp_blockchain::Result<()> {
Finalizer::finalize_block(self, hash, justification, true)
substrate/test-utils/runtime/transaction-pool/src/lib.rs
+2 -2
View File
@@ -315,12 +315,12 @@ impl sc_transaction_pool::ChainApi for TestApi {
Self::hash_and_length_inner(ex)
}
fn block_body(&self, hash: &<Self::Block as BlockT>::Hash) -> Self::BodyFuture {
fn block_body(&self, hash: <Self::Block as BlockT>::Hash) -> Self::BodyFuture {
futures::future::ready(Ok(self
.chain
.read()
.block_by_hash
.get(hash)
.get(&hash)
.map(|b| b.extrinsics().to_vec())))
}
substrate/utils/frame/benchmarking-cli/src/block/bench.rs
+1 -1
View File
@@ -142,7 +142,7 @@ where
let block_hash = self.client.expect_block_hash_from_id(block)?;
let mut raw_weight = &self
.client
.storage(&block_hash, &key)?
.storage(block_hash, &key)?
.ok_or(format!("Could not find System::BlockWeight for block: {}", block))?
.0[..];
substrate/utils/frame/benchmarking-cli/src/storage/cmd.rs
+2 -2
View File
@@ -193,7 +193,7 @@ impl StorageCmd {
{
let hash = client.usage_info().chain.best_hash;
let empty_prefix = StorageKey(Vec::new());
let mut keys = client.storage_keys(&hash, &empty_prefix)?;
let mut keys = client.storage_keys(hash, &empty_prefix)?;
let (mut rng, _) = new_rng(None);
keys.shuffle(&mut rng);
@@ -201,7 +201,7 @@ impl StorageCmd {
info!("Warmup round {}/{}", i + 1, self.params.warmups);
for key in keys.as_slice() {
let _ = client
.storage(&hash, &key)
.storage(hash, &key)
.expect("Checked above to exist")
.ok_or("Value unexpectedly empty");
}
substrate/utils/frame/benchmarking-cli/src/storage/read.rs
+4 -4
View File
@@ -43,7 +43,7 @@ impl StorageCmd {
info!("Preparing keys from block {}", best_hash);
// Load all keys and randomly shuffle them.
let empty_prefix = StorageKey(Vec::new());
let mut keys = client.storage_keys(&best_hash, &empty_prefix)?;
let mut keys = client.storage_keys(best_hash, &empty_prefix)?;
let (mut rng, _) = new_rng(None);
keys.shuffle(&mut rng);
@@ -55,7 +55,7 @@ impl StorageCmd {
match (self.params.include_child_trees, self.is_child_key(key.clone().0)) {
(true, Some(info)) => {
// child tree key
let child_keys = client.child_storage_keys(&best_hash, &info, &empty_prefix)?;
let child_keys = client.child_storage_keys(best_hash, &info, &empty_prefix)?;
for ck in child_keys {
child_nodes.push((ck.clone(), info.clone()));
}
@@ -64,7 +64,7 @@ impl StorageCmd {
// regular key
let start = Instant::now();
let v = client
.storage(&best_hash, &key)
.storage(best_hash, &key)
.expect("Checked above to exist")
.ok_or("Value unexpectedly empty")?;
record.append(v.0.len(), start.elapsed())?;
@@ -79,7 +79,7 @@ impl StorageCmd {
for (key, info) in child_nodes.as_slice() {
let start = Instant::now();
let v = client
.child_storage(&best_hash, info, key)
.child_storage(best_hash, info, key)
.expect("Checked above to exist")
.ok_or("Value unexpectedly empty")?;
record.append(v.0.len(), start.elapsed())?;
substrate/utils/frame/benchmarking-cli/src/storage/write.rs
+2 -2
View File
@@ -77,7 +77,7 @@ impl StorageCmd {
match (self.params.include_child_trees, self.is_child_key(k.to_vec())) {
(true, Some(info)) => {
let child_keys =
client.child_storage_keys_iter(&best_hash, info.clone(), None, None)?;
client.child_storage_keys_iter(best_hash, info.clone(), None, None)?;
for ck in child_keys {
child_nodes.push((ck.clone(), info.clone()));
}
@@ -124,7 +124,7 @@ impl StorageCmd {
for (key, info) in child_nodes {
if let Some(original_v) = client
.child_storage(&best_hash, &info.clone(), &key)
.child_storage(best_hash, &info.clone(), &key)
.expect("Checked above to exist")
{
let mut new_v = vec![0; original_v.0.len()];
substrate/utils/frame/rpc/state-trie-migration-rpc/src/lib.rs
+1 -1
View File
@@ -145,7 +145,7 @@ where
self.deny_unsafe.check_if_safe()?;
let hash = at.unwrap_or_else(|| self.client.info().best_hash);
let state = self.backend.state_at(&hash).map_err(error_into_rpc_err)?;
let state = self.backend.state_at(hash).map_err(error_into_rpc_err)?;
let (top, child) = migration_status(&state).map_err(error_into_rpc_err)?;
Ok(MigrationStatusResult {