diff --git a/crates/pathfinder/src/sync/track.rs b/crates/pathfinder/src/sync/track.rs index 62d4dd80e7..0b69f909ee 100644 --- a/crates/pathfinder/src/sync/track.rs +++ b/crates/pathfinder/src/sync/track.rs @@ -886,241 +886,3 @@ impl ProcessStage for StoreBlock { result } } - -#[cfg(test)] -mod tests { - use futures::{stream, Stream, StreamExt}; - use p2p::client::types::{ - ClassDefinition, - ClassDefinitionsError, - EventsResponseStreamFailure, - Receipt as P2PReceipt, - StateDiffsError, - }; - use pathfinder_storage::fake::{self, Block, Config}; - use starknet_gateway_types::error::SequencerError; - - use super::*; - use crate::sync::tests::generate_fake_blocks; - - #[tokio::test] - async fn happy_path() { - let (public_key, blocks) = generate_fake_blocks(10); - - let BlockHeader { hash, number, .. } = blocks.last().unwrap().header.header; - let latest = (number, hash); - - let p2p: FakeP2PClient = FakeP2PClient { - blocks: blocks.clone(), - }; - - let storage = pathfinder_storage::StorageBuilder::in_tempdir().unwrap(); - - let sync = Sync { - latest: futures::stream::iter(vec![latest]), - p2p, - storage: storage.clone(), - chain_id: ChainId::SEPOLIA_TESTNET, - public_key, - block_hash_db: None, - verify_tree_hashes: true, - }; - - let mut start_number = BlockNumber::GENESIS; - let mut parent_hash = BlockHash::default(); - - sync.run(&mut start_number, &mut parent_hash, FakeFgw) - .await - .unwrap(); - - assert_eq!(start_number, number + 1); - assert_eq!(parent_hash, hash); - - let mut db = storage.connection().unwrap(); - let db = db.transaction().unwrap(); - for mut expected in blocks { - let block_number = expected.header.header.number; - let block_id = block_number.into(); - let header = db.block_header(block_id).unwrap().unwrap(); - let signature = db.signature(block_id).unwrap().unwrap(); - let transaction_data = db.transaction_data_for_block(block_id).unwrap().unwrap(); - let state_update_data: StateUpdateData = - db.state_update(block_id).unwrap().unwrap().into(); - let declared = db.declared_classes_at(block_id).unwrap().unwrap(); - - let mut cairo_defs = HashMap::new(); - let mut sierra_defs = HashMap::new(); - - for class_hash in declared { - let class = db.class_definition(class_hash).unwrap().unwrap(); - match db.casm_hash(class_hash).unwrap() { - Some(casm_hash) => { - let casm = db.casm_definition(class_hash).unwrap().unwrap(); - sierra_defs.insert(SierraHash(class_hash.0), (class, casm)); - } - None => { - cairo_defs.insert(class_hash, class); - } - } - } - - pretty_assertions_sorted::assert_eq!(header, expected.header.header); - pretty_assertions_sorted::assert_eq!(signature, expected.header.signature); - pretty_assertions_sorted::assert_eq!( - header.state_diff_commitment, - expected.header.header.state_diff_commitment - ); - pretty_assertions_sorted::assert_eq!( - header.state_diff_length, - expected.header.header.state_diff_length - ); - pretty_assertions_sorted::assert_eq!(transaction_data, expected.transaction_data); - pretty_assertions_sorted::assert_eq!( - state_update_data, - expected.state_update.unwrap().into() - ); - pretty_assertions_sorted::assert_eq!( - cairo_defs, - expected.cairo_defs.into_iter().collect::>() - ); - pretty_assertions_sorted::assert_eq!( - sierra_defs, - expected - .sierra_defs - .into_iter() - // All sierra fixtures are not compile-able - .map(|(h, s, _)| (h, (s, b"I'm from the fgw!".to_vec()))) - .collect::>() - ); - } - } - - #[derive(Clone)] - struct FakeP2PClient { - pub blocks: Vec, - } - - impl HeaderStream for FakeP2PClient { - fn header_stream( - self, - start: BlockNumber, - stop: BlockNumber, - reverse: bool, - ) -> impl Stream> + Send { - assert!(!reverse); - assert_eq!(start, self.blocks.first().unwrap().header.header.number); - assert_eq!(stop, self.blocks.last().unwrap().header.header.number); - - stream::iter( - self.blocks - .into_iter() - .map(|block| PeerData::for_tests(block.header)), - ) - } - } - - impl BlockClient for FakeP2PClient { - async fn transactions_for_block( - self, - block: BlockNumber, - ) -> Option<( - PeerId, - impl Stream> + Send, - )> { - let tr = self - .blocks - .iter() - .find(|b| b.header.header.number == block) - .unwrap() - .transaction_data - .iter() - .map(|(t, r, e)| Ok((t.clone(), P2PReceipt::from(r.clone())))) - .collect::>>(); - - Some((PeerId::random(), stream::iter(tr))) - } - - async fn state_diff_for_block( - self, - block: BlockNumber, - state_diff_length: u64, - ) -> Result, StateDiffsError> { - let sd: StateUpdateData = self - .blocks - .iter() - .find(|b| b.header.header.number == block) - .unwrap() - .state_update - .clone() - .unwrap() - .into(); - - assert_eq!(sd.state_diff_length() as u64, state_diff_length); - - Ok(Some((PeerId::random(), sd))) - } - - async fn class_definitions_for_block( - self, - block: BlockNumber, - declared_classes_count: u64, - ) -> Result)>, ClassDefinitionsError> { - let b = self - .blocks - .iter() - .find(|b| b.header.header.number == block) - .unwrap(); - let defs = b - .cairo_defs - .iter() - .map(|(h, x)| ClassDefinition::Cairo { - block_number: block, - definition: x.clone(), - hash: *h, - }) - .chain( - b.sierra_defs - .iter() - .map(|(h, x, _)| ClassDefinition::Sierra { - block_number: block, - sierra_definition: x.clone(), - hash: *h, - }), - ) - .collect::>(); - - Ok(Some((PeerId::random(), defs))) - } - - async fn events_for_block( - self, - block: BlockNumber, - ) -> Option<( - PeerId, - impl Stream> + Send, - )> { - let e = self - .blocks - .iter() - .find(|b| b.header.header.number == block) - .unwrap() - .transaction_data - .iter() - .flat_map(|(t, _, e)| e.iter().map(move |e| (t.hash, e.clone()))) - .map(Ok) - .collect::>(); - - Some((PeerId::random(), stream::iter(e))) - } - } - - #[derive(Clone)] - struct FakeFgw; - - #[async_trait::async_trait] - impl GatewayApi for FakeFgw { - async fn pending_casm_by_hash(&self, _: ClassHash) -> Result { - Ok(bytes::Bytes::from_static(b"I'm from the fgw!")) - } - } -}