From 992d1770e2633e8cf9a7fe96cf97e434778a52b8 Mon Sep 17 00:00:00 2001 From: Maksim Greshnyakov Date: Mon, 6 May 2024 17:42:47 +0200 Subject: [PATCH 1/2] ref(block-strider-adapter): refactor buffer --- Cargo.lock | 12 ++ Cargo.toml | 1 + cli/src/node/mod.rs | 4 +- collator/Cargo.toml | 3 +- collator/src/collator/build_block.rs | 3 - .../persistent/persistent_state.rs | 3 +- collator/src/internal_queue/queue.rs | 16 +- .../internal_queue/session/session_state.rs | 3 +- .../session/session_state_snapshot.rs | 3 +- collator/src/internal_queue/snapshot.rs | 2 +- collator/src/manager/mod.rs | 9 +- collator/src/msg_queue/mod.rs | 7 +- collator/src/msg_queue/state_persistent.rs | 4 +- collator/src/state_node.rs | 203 ++++++++++-------- collator/src/validator/state.rs | 2 +- collator/tests/adapter_tests.rs | 30 +-- collator/tests/collation_tests.rs | 2 +- 17 files changed, 175 insertions(+), 132 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d5254ac6b..646b5a171 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2448,6 +2448,17 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "trait-variant" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70977707304198400eb4835a78f6a9f928bf41bba420deb8fdb175cd965d77a7" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.60", +] + [[package]] name = "triomphe" version = "0.1.11" @@ -2577,6 +2588,7 @@ dependencies = [ "tracing", "tracing-subscriber", "tracing-test", + "trait-variant", "tycho-block-util", "tycho-collator", "tycho-core", diff --git a/Cargo.toml b/Cargo.toml index 4d39c6d1f..6080c17aa 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -83,6 +83,7 @@ tracing = "0.1" tracing-appender = "0.2.3" tracing-subscriber = { version = "0.3", features = ["env-filter"] } tracing-test = "0.2" +trait-variant = "0.1.2" triomphe = "0.1.11" weedb = "0.1.1" x509-parser = "0.15" diff --git a/cli/src/node/mod.rs b/cli/src/node/mod.rs index c3c293fd2..4080d8f24 100644 --- a/cli/src/node/mod.rs +++ b/cli/src/node/mod.rs @@ -494,7 +494,7 @@ impl Node { let collation_manager = CollationManager::start( collation_config, - Arc::new(MessageQueueAdapterStdImpl::new()), + Arc::new(MessageQueueAdapterStdImpl::default()), |listener| StateNodeAdapterStdImpl::new(listener, self.storage.clone()), MempoolAdapterStdImpl::new, ValidatorStdImplFactory { @@ -591,7 +591,7 @@ impl BlockProvider for CollatorBlockProvider { type GetBlockFut<'a> = BoxFuture<'a, OptionalBlockStuff>; fn get_next_block<'a>(&'a self, prev_block_id: &'a BlockId) -> Self::GetNextBlockFut<'a> { - self.adapter.wait_for_block(prev_block_id) + self.adapter.wait_for_block_next(prev_block_id) } fn get_block<'a>(&'a self, block_id: &'a BlockId) -> Self::GetBlockFut<'a> { diff --git a/collator/Cargo.toml b/collator/Cargo.toml index ecb7ad10f..795c71a68 100644 --- a/collator/Cargo.toml +++ b/collator/Cargo.toml @@ -22,7 +22,7 @@ tokio = { workspace = true, features = ["macros", "rt", "signal"] } tokio-util = { workspace = true } tracing = { workspace = true } tracing-subscriber = { workspace = true } - +trait-variant = { workspace = true } everscale-types = { workspace = true } everscale-crypto = { workspace = true } @@ -33,6 +33,7 @@ tycho-storage = { workspace = true } tycho-util = { workspace = true } tycho-block-util = { workspace = true } + [dev-dependencies] tempfile = { workspace = true } tokio = { version = "1", features = ["rt-multi-thread"] } diff --git a/collator/src/collator/build_block.rs b/collator/src/collator/build_block.rs index 4e5fcba5b..59304f2d5 100644 --- a/collator/src/collator/build_block.rs +++ b/collator/src/collator/build_block.rs @@ -4,7 +4,6 @@ use anyhow::{bail, Result}; use everscale_types::merkle::*; use everscale_types::models::*; use everscale_types::prelude::*; -use sha2::digest::typenum::private::IsGreaterPrivate; use sha2::Digest; use tycho_block_util::config::BlockchainConfigExt; use tycho_block_util::state::ShardStateStuff; @@ -434,8 +433,6 @@ impl CollatorStdImpl { timer.elapsed().as_millis(), ); - // do not need to calc out_queue_updates - Ok(state_update) } } diff --git a/collator/src/internal_queue/persistent/persistent_state.rs b/collator/src/internal_queue/persistent/persistent_state.rs index f1da22f68..ac24f1977 100644 --- a/collator/src/internal_queue/persistent/persistent_state.rs +++ b/collator/src/internal_queue/persistent/persistent_state.rs @@ -4,7 +4,8 @@ use crate::internal_queue::types::ext_types_stubs::EnqueuedMessage; use everscale_types::models::BlockIdShort; use std::sync::Arc; -pub trait PersistentState +#[trait_variant::make(PersistentState: Send)] +pub trait LocalPersistentState where S: StateSnapshot, { diff --git a/collator/src/internal_queue/queue.rs b/collator/src/internal_queue/queue.rs index caaf46a42..c03d94bb8 100644 --- a/collator/src/internal_queue/queue.rs +++ b/collator/src/internal_queue/queue.rs @@ -8,7 +8,8 @@ use std::marker::PhantomData; use std::sync::Arc; use tokio::sync::{Mutex, RwLock}; -pub trait Queue +#[trait_variant::make(Queue: Send)] +pub trait LocalQueue where SS: StateSnapshot + 'static, PS: StateSnapshot + 'static, @@ -24,6 +25,7 @@ where diff_id: &BlockIdShort, ) -> Result>, QueueError>; } + pub struct QueueImpl where S: SessionState, @@ -39,10 +41,10 @@ where impl Queue for QueueImpl where - S: SessionState, - P: PersistentState, - SS: StateSnapshot + 'static, - PS: StateSnapshot + 'static, + S: SessionState + Send, + P: PersistentState + Send + Sync, + SS: StateSnapshot + 'static + Send + Sync, + PS: StateSnapshot + 'static + Send + Sync, { fn new(base_shard: ShardIdent) -> Self { let session_state = Mutex::new(S::new(base_shard)); @@ -106,8 +108,8 @@ mod tests { PersistentStateImpl, SessionStateSnapshot, PersistentStateSnapshot, - > = QueueImpl::new(base_shard); + > = as Queue<_, _>>::new(base_shard); - queue.split_shard(&base_shard).await.unwrap(); + Queue::split_shard(&queue, &base_shard).await.unwrap(); } } diff --git a/collator/src/internal_queue/session/session_state.rs b/collator/src/internal_queue/session/session_state.rs index e9aa8086a..13302f2eb 100644 --- a/collator/src/internal_queue/session/session_state.rs +++ b/collator/src/internal_queue/session/session_state.rs @@ -8,7 +8,8 @@ use std::collections::HashMap; use std::sync::Arc; use tokio::sync::RwLock; -pub trait SessionState +#[trait_variant::make(SessionState: Send)] +pub trait LocalSessionState where S: StateSnapshot, { diff --git a/collator/src/internal_queue/session/session_state_snapshot.rs b/collator/src/internal_queue/session/session_state_snapshot.rs index ad4f1bc67..38e14e1e1 100644 --- a/collator/src/internal_queue/session/session_state_snapshot.rs +++ b/collator/src/internal_queue/session/session_state_snapshot.rs @@ -6,6 +6,7 @@ use everscale_types::models::ShardIdent; use std::collections::HashMap; use std::str::FromStr; use std::sync::Arc; +use tracing::error; pub struct SessionStateSnapshot { pub flat_shards: HashMap, @@ -39,7 +40,7 @@ impl StateSnapshot for SessionStateSnapshot { } } Err(e) => { - println!("failed to convert account to hashbytes {e:?}"); + error!("failed to convert account to hashbytes {e:?}"); return false; } } diff --git a/collator/src/internal_queue/snapshot.rs b/collator/src/internal_queue/snapshot.rs index 663029a59..82dd879cb 100644 --- a/collator/src/internal_queue/snapshot.rs +++ b/collator/src/internal_queue/snapshot.rs @@ -40,7 +40,7 @@ pub struct ShardRange { pub to_lt: Option, } -pub trait StateSnapshot { +pub trait StateSnapshot: Send { fn get_outgoing_messages_by_shard( &self, shards: &mut HashMap, diff --git a/collator/src/manager/mod.rs b/collator/src/manager/mod.rs index 798e08970..52e400c84 100644 --- a/collator/src/manager/mod.rs +++ b/collator/src/manager/mod.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use anyhow::{anyhow, bail, Result}; use async_trait::async_trait; -use everscale_types::models::{BlockId, BlockInfo, ShardIdent, ValidatorDescription, ValueFlow}; +use everscale_types::models::{BlockId, BlockInfo, ShardIdent, ValueFlow}; use tycho_block_util::block::ValidatorSubsetInfo; use tycho_block_util::state::{MinRefMcStateTracker, ShardStateStuff}; @@ -112,7 +112,7 @@ where CF: CollatorFactory, V: Validator, { - async fn on_block_accepted(&self, block_id: &BlockId) -> Result<()> { + async fn on_block_accepted(&self, _block_id: &BlockId) -> Result<()> { //TODO: remove accepted block from cache //STUB: do nothing, currently we remove block from cache when it sent to state node Ok(()) @@ -453,7 +453,7 @@ where /// * TRUE - provided `mc_block_id` is before or equal to last processed /// * FALSE - provided `mc_block_id` is ahead of last processed - fn check_if_mc_block_not_ahead_last_processed(&self, mc_block_id: &BlockId) -> bool { + fn _check_if_mc_block_not_ahead_last_processed(&self, mc_block_id: &BlockId) -> bool { //TODO: consider block shard? let last_processed_mc_block_id_opt = self.last_processed_mc_block_id(); let is_not_ahead = matches!(last_processed_mc_block_id_opt, Some(last_processed_mc_block_id) @@ -858,8 +858,7 @@ where candidate_id.as_short_id(), candidate_chain_time, ); - let _handle = self - .validator + self.validator .validate(candidate_id, session_info.seqno()) .await?; diff --git a/collator/src/msg_queue/mod.rs b/collator/src/msg_queue/mod.rs index e6cba9a85..90e85fb55 100644 --- a/collator/src/msg_queue/mod.rs +++ b/collator/src/msg_queue/mod.rs @@ -1,3 +1,6 @@ +#![allow(warnings)] +#![allow(clippy::all)] + use std::sync::Arc; use anyhow::Result; @@ -56,8 +59,8 @@ pub struct MessageQueueAdapterStdImpl { msg_queue: MsgQueueStdImpl, } -impl MessageQueueAdapterStdImpl { - pub fn new() -> Self { +impl Default for MessageQueueAdapterStdImpl { + fn default() -> Self { let base_shard = ShardIdent::new_full(0); Self { msg_queue: MsgQueueStdImpl::new(base_shard), diff --git a/collator/src/msg_queue/state_persistent.rs b/collator/src/msg_queue/state_persistent.rs index 9448c0834..8d31bd733 100644 --- a/collator/src/msg_queue/state_persistent.rs +++ b/collator/src/msg_queue/state_persistent.rs @@ -20,10 +20,10 @@ where ST: PersistentStateService, DB: StorageService, { - fn some_internal_method_for_persistent_state(&mut self) -> Result<()> { + fn _some_internal_method_for_persistent_state(&mut self) -> Result<()> { todo!() } - pub(super) fn some_module_internal_method_for_persistent_state(&mut self) -> Result<()> { + pub(super) fn _some_module_internal_method_for_persistent_state(&mut self) -> Result<()> { todo!() } } diff --git a/collator/src/state_node.rs b/collator/src/state_node.rs index a74304494..b72eb93f9 100644 --- a/collator/src/state_node.rs +++ b/collator/src/state_node.rs @@ -1,10 +1,10 @@ use std::collections::{BTreeMap, HashMap}; use std::sync::Arc; -use anyhow::{anyhow, Context, Result}; +use anyhow::{Context, Result}; use async_trait::async_trait; -use everscale_types::models::{BlockId, ShardIdent}; +use everscale_types::models::{BlockId, BlockIdShort, ShardIdent}; use tokio::sync::{broadcast, Mutex}; use tycho_block_util::block::BlockStuffAug; @@ -58,6 +58,8 @@ pub trait StateNodeAdapter: Send + Sync + 'static { async fn accept_block(&self, block: BlockStuffForSync) -> Result<()>; /// Waits for the specified block to be received and returns it async fn wait_for_block(&self, block_id: &BlockId) -> Option>; + /// Waits for the specified block by prev_id to be received and returns it + async fn wait_for_block_next(&self, block_id: &BlockId) -> Option>; /// Handle state after block was applied async fn handle_state(&self, state: &ShardStateStuff) -> Result<()>; } @@ -125,45 +127,99 @@ impl StateNodeAdapter for StateNodeAdapterStdImpl { async fn accept_block(&self, block: BlockStuffForSync) -> Result<()> { tracing::info!(target: tracing_targets::STATE_NODE_ADAPTER, "Block accepted: {:?}", block.block_id); let mut blocks = self.blocks.lock().await; - let block_id = match block.block_id.shard.is_masterchain() { - true => { - let prev_block_id = *block - .prev_blocks_ids - .last() - .ok_or(anyhow!("no prev block"))?; - - self.blocks_mapping - .lock() - .await - .insert(block.block_id, prev_block_id); - - blocks - .entry(block.block_id.shard) - .or_insert_with(BTreeMap::new) - .insert(prev_block_id.seqno, block); - - prev_block_id - } - false => { - let block_id = block.block_id; - blocks - .entry(block.block_id.shard) - .or_insert_with(BTreeMap::new) - .insert(block.block_id.seqno, block); - block_id - } - }; + let block_id = block.block_id; + blocks + .entry(block.block_id.shard) + .or_insert_with(BTreeMap::new) + .insert(block.block_id.seqno, block); + let broadcast_result = self.broadcaster.send(block_id).ok(); tracing::trace!(target: tracing_targets::STATE_NODE_ADAPTER, "Block broadcast_result: {:?}", broadcast_result); Ok(()) } async fn wait_for_block(&self, block_id: &BlockId) -> Option> { + let block_id = BlockIdToWait::Full(block_id); + self.wait_for_block_ext(block_id).await + } + + async fn wait_for_block_next(&self, prev_block_id: &BlockId) -> Option> { + let next_block_id_short = + BlockIdShort::from((prev_block_id.shard, prev_block_id.seqno + 1)); + let block_id = BlockIdToWait::Short(&next_block_id_short); + self.wait_for_block_ext(block_id).await + } + + async fn handle_state(&self, state: &ShardStateStuff) -> Result<()> { + tracing::info!(target: tracing_targets::STATE_NODE_ADAPTER, "Handle block: {:?}", state.block_id()); + let block_id = *state.block_id(); + + let mut to_split = Vec::new(); + + let mut block_mapping_guard = self.blocks_mapping.lock().await; + let block_id = block_mapping_guard.remove(&block_id).unwrap_or(block_id); + + let shard = block_id.shard; + let seqno = block_id.seqno; + + { + let blocks_guard = self.blocks.lock().await; + if let Some(shard_blocks) = blocks_guard.get(&shard) { + let block = shard_blocks.get(&seqno); + + if shard.is_masterchain() { + let prev_mc_block = shard_blocks + .range(..=seqno) + .rev() + .find_map(|(&key, value)| if key < seqno { Some(value) } else { None }); + + if let Some(prev_mc_block) = prev_mc_block { + for id in &prev_mc_block.top_shard_blocks_ids { + to_split.push((id.shard, id.seqno + 1)); + } + to_split.push((shard, prev_mc_block.block_id.seqno + 1)); + } + } + + match block { + None => { + tracing::info!(target: tracing_targets::STATE_NODE_ADAPTER, "Block handled external: {:?}", block_id); + self.listener.on_block_accepted_external(state).await?; + } + Some(block) => { + tracing::info!(target: tracing_targets::STATE_NODE_ADAPTER, "Block handled: {:?}", block_id); + self.listener.on_block_accepted(&block.block_id).await?; + } + } + } else { + tracing::info!(target: tracing_targets::STATE_NODE_ADAPTER, "Block handled external. Shard ID not found in blocks buffer: {:?}", block_id); + self.listener.on_block_accepted_external(state).await?; + } + } + + { + let mut blocks_guard = self.blocks.lock().await; + for (shard, seqno) in &to_split { + if let Some(shard_blocks) = blocks_guard.get_mut(shard) { + *shard_blocks = shard_blocks.split_off(seqno); + } + } + } + + Ok(()) + } +} + +impl StateNodeAdapterStdImpl { + async fn wait_for_block_ext( + &self, + block_id: BlockIdToWait<'_>, + ) -> Option> { let mut receiver = self.broadcaster.subscribe(); loop { let blocks = self.blocks.lock().await; - if let Some(shard_blocks) = blocks.get(&block_id.shard) { - if let Some(block) = shard_blocks.get(&block_id.seqno) { + if let Some(shard_blocks) = blocks.get(&block_id.shard()) { + if let Some(block) = shard_blocks.get(&block_id.seqno()) { return Some(Ok(block.block_stuff_aug.clone())); } } @@ -171,7 +227,7 @@ impl StateNodeAdapter for StateNodeAdapterStdImpl { loop { match receiver.recv().await { - Ok(received_block_id) if received_block_id == *block_id => { + Ok(received_block_id) if block_id == received_block_id => { break; } Ok(_) => continue, @@ -187,69 +243,34 @@ impl StateNodeAdapter for StateNodeAdapterStdImpl { } } } +} - async fn handle_state(&self, state: &ShardStateStuff) -> Result<()> { - tracing::info!(target: tracing_targets::STATE_NODE_ADAPTER, "Handle block: {:?}", state.block_id()); - let block_id = *state.block_id(); - - let mut to_split = Vec::new(); - let mut to_remove = Vec::new(); - - let mut block_mapping_guard = self.blocks_mapping.lock().await; - let block_id = match block_mapping_guard.remove(&block_id) { - None => block_id, - Some(some) => some.clone(), - }; - - let shard = block_id.shard; - let seqno = block_id.seqno; - - let mut blocks_guard = self.blocks.lock().await; - - let result_future = if let Some(shard_blocks) = blocks_guard.get(&shard) { - if let Some(block_data) = shard_blocks.get(&seqno) { - if shard.is_masterchain() { - let prev_seqno = block_data - .prev_blocks_ids - .last() - .ok_or(anyhow!("no prev block"))? - .seqno; - for id in &block_data.top_shard_blocks_ids { - to_split.push((id.shard, id.seqno)); - to_remove.push((id.shard, id.seqno)); - } - to_split.push((shard, prev_seqno)); - to_remove.push((shard, prev_seqno)); - } else { - to_remove.push((shard, seqno)); - } - tracing::info!(target: tracing_targets::STATE_NODE_ADAPTER, "Block handled: {:?}", block_id); - self.listener.on_block_accepted(&block_id) - } else { - tracing::info!(target: tracing_targets::STATE_NODE_ADAPTER, "Block handled external: {:?}", block_id); - self.listener.on_block_accepted_external(state) - } - } else { - tracing::info!(target: tracing_targets::STATE_NODE_ADAPTER, "Block handled external: {:?}", block_id); - self.listener.on_block_accepted_external(state) - }; +enum BlockIdToWait<'a> { + Short(&'a BlockIdShort), + Full(&'a BlockId), +} - for (shard, seqno) in &to_split { - if let Some(shard_blocks) = blocks_guard.get_mut(shard) { - shard_blocks.split_off(seqno); - } +impl BlockIdToWait<'_> { + fn shard(&self) -> ShardIdent { + match self { + Self::Short(id) => id.shard, + Self::Full(id) => id.shard, } + } - for (shard, seqno) in &to_remove { - if let Some(shard_blocks) = blocks_guard.get_mut(shard) { - shard_blocks.remove(seqno); - } + fn seqno(&self) -> u32 { + match self { + Self::Short(id) => id.seqno, + Self::Full(id) => id.seqno, } + } +} - drop(blocks_guard); - - result_future.await?; - - Ok(()) +impl PartialEq for BlockIdToWait<'_> { + fn eq(&self, other: &BlockId) -> bool { + match *self { + BlockIdToWait::Short(short) => &other.as_short_id() == short, + BlockIdToWait::Full(full) => full == other, + } } } diff --git a/collator/src/validator/state.rs b/collator/src/validator/state.rs index 6eac7a3a7..d47a2a870 100644 --- a/collator/src/validator/state.rs +++ b/collator/src/validator/state.rs @@ -5,7 +5,7 @@ use anyhow::{bail, Context}; use everscale_types::cell::HashBytes; use everscale_types::models::{BlockId, BlockIdShort, Signature}; use tokio::sync::{Mutex, RwLock}; -use tracing::{debug, trace, warn}; +use tracing::{debug, trace}; use crate::tracing_targets; use crate::types::{BlockSignatures, OnValidatedBlockEvent}; diff --git a/collator/tests/adapter_tests.rs b/collator/tests/adapter_tests.rs index 4bae5ec86..b772c2a7b 100644 --- a/collator/tests/adapter_tests.rs +++ b/collator/tests/adapter_tests.rs @@ -3,7 +3,8 @@ use std::sync::Arc; use anyhow::Result; use async_trait::async_trait; -use everscale_types::models::{BlockId, ShardIdent}; +use everscale_types::cell::Cell; +use everscale_types::models::{BlockId, ShardIdent, ShardStateUnsplit}; use tycho_block_util::block::{BlockStuff, BlockStuffAug}; use tycho_block_util::state::{MinRefMcStateTracker, ShardStateStuff}; use tycho_collator::state_node::{ @@ -124,8 +125,7 @@ async fn test_add_and_get_next_block() { }; adapter.accept_block(block).await.unwrap(); - // TOOD: Incorrect!!! Should be waiting for the next block, not the previous one - let next_block = adapter.wait_for_block(prev_block_id).await; + let next_block = adapter.wait_for_block_next(prev_block_id).await; assert!( next_block.is_some(), "Block should be retrieved after being added" @@ -210,22 +210,26 @@ async fn test_add_read_handle_1000_blocks_parallel() { let next_block = adapter.wait_for_block(&block_id).await; assert!( next_block.is_some(), - "Block {} should be retrieved after being added", - i + "Block {i} should be retrieved after being added", ); - let last_mc_block_id = adapter.load_last_applied_mc_block_id().await.unwrap(); - let state = storage - .shard_state_storage() - .load_state(&last_mc_block_id) - .await - .unwrap(); + let mcstate_tracker = MinRefMcStateTracker::new(); + let mut shard_state = ShardStateUnsplit::default(); + shard_state.shard_ident = block_id.shard; + shard_state.seqno = block_id.seqno; + + let state = ShardStateStuff::from_state_and_root( + block_id, + shard_state, + Cell::default(), + &mcstate_tracker, + ) + .unwrap(); let handle_block = adapter.handle_state(&state).await; assert!( handle_block.is_ok(), - "Block {} should be handled after being added", - i + "Block {i} should be handled after being added", ); } }) diff --git a/collator/tests/collation_tests.rs b/collator/tests/collation_tests.rs index a702de285..bd031559d 100644 --- a/collator/tests/collation_tests.rs +++ b/collator/tests/collation_tests.rs @@ -96,7 +96,7 @@ async fn test_collation_process_on_stubs() { let manager = CollationManager::start( config, - Arc::new(MessageQueueAdapterStdImpl::new()), + Arc::new(MessageQueueAdapterStdImpl::default()), |listener| StateNodeAdapterStdImpl::new(listener, storage.clone()), |listener| MempoolAdapterStdImpl::new(listener), ValidatorStdImplFactory { From a5aba25986b6fad5d26c3335205dfb0b934ae42b Mon Sep 17 00:00:00 2001 From: Maksim Greshnyakov Date: Mon, 6 May 2024 20:00:52 +0200 Subject: [PATCH 2/2] ref(block-strider-adapter): refactoring handle_block --- collator/src/lib.rs | 2 -- collator/src/state_node.rs | 3 --- 2 files changed, 5 deletions(-) diff --git a/collator/src/lib.rs b/collator/src/lib.rs index d486fa2a6..3474ba309 100644 --- a/collator/src/lib.rs +++ b/collator/src/lib.rs @@ -12,5 +12,3 @@ pub mod test_utils; mod tracing_targets; mod utils; - -// pub use validator::test_impl as validator_test_impl; diff --git a/collator/src/state_node.rs b/collator/src/state_node.rs index b72eb93f9..90c7e67d1 100644 --- a/collator/src/state_node.rs +++ b/collator/src/state_node.rs @@ -156,9 +156,6 @@ impl StateNodeAdapter for StateNodeAdapterStdImpl { let mut to_split = Vec::new(); - let mut block_mapping_guard = self.blocks_mapping.lock().await; - let block_id = block_mapping_guard.remove(&block_id).unwrap_or(block_id); - let shard = block_id.shard; let seqno = block_id.seqno;