diff --git a/src/data.rs b/src/data.rs
index d727da7a3..bd57b91a5 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -104,17 +104,6 @@ pub fn get_block_header_from_db(db: Arc<DB>, block_number: u32) -> Result<Option
 		.transpose()
 }
 
-/// Checks if block header for given block number is in database
-pub fn is_block_header_in_db(db: Arc<DB>, block_number: u32) -> Result<bool> {
-	let handle = db
-		.cf_handle(BLOCK_HEADER_CF)
-		.context("Failed to get cf handle")?;
-
-	db.get_pinned_cf(&handle, block_number.to_be_bytes())
-		.context("Failed to get block header")
-		.map(|value| value.is_some())
-}
-
 /// Stores block header into database under the given block number key
 pub fn store_block_header_in_db(db: Arc<DB>, block_number: u32, header: &DaHeader) -> Result<()> {
 	let handle = db
diff --git a/src/network/rpc/client.rs b/src/network/rpc/client.rs
index f37da42b9..bc0129b06 100644
--- a/src/network/rpc/client.rs
+++ b/src/network/rpc/client.rs
@@ -734,11 +734,6 @@ impl Client {
 			.map(|header| (header, hash))
 	}
 
-	// pub async fn get_connected_node(&self) -> Result<Node> {
-	// 	self.execute_sync(|response_sender| GetConnectedNode { response_sender })
-	// 		.await
-	// }
-
 	pub async fn get_validator_set_at(&self, block_hash: H256) -> Result<Option<Vec<AccountId32>>> {
 		self.execute_sync(|response_sender| {
 			Box::new(GetValidatorSetAt {
diff --git a/src/network/rpc/event_loop.rs b/src/network/rpc/event_loop.rs
index af0fe4d80..60a0ed73f 100644
--- a/src/network/rpc/event_loop.rs
+++ b/src/network/rpc/event_loop.rs
@@ -517,7 +517,7 @@ mod tests {
 	use hex::FromHex;
 	use sp_core::{
 		ed25519::{self, Public, Signature},
-		Pair, H256,
+		Pair,
 	};
 	use test_case::test_case;
 
@@ -558,7 +558,6 @@ mod tests {
 			&set_id,
 		));
 
-		let is_ok = <ed25519::Pair as Pair>::verify(&sig, &signed_message, &id);
-		is_ok
+		<ed25519::Pair as Pair>::verify(&sig, signed_message, &id)
 	}
 }
diff --git a/src/sync_client.rs b/src/sync_client.rs
index 712dda029..9b3ba5f6f 100644
--- a/src/sync_client.rs
+++ b/src/sync_client.rs
@@ -17,7 +17,7 @@
 
 use crate::{
 	data::{
-		is_block_header_in_db, is_confidence_in_db, store_block_header_in_db,
+		get_block_header_from_db, is_confidence_in_db, store_block_header_in_db,
 		store_confidence_in_db,
 	},
 	network::{
@@ -31,11 +31,13 @@ use crate::{
 use anyhow::{anyhow, Context, Result};
 use async_trait::async_trait;
 use avail_subxt::{primitives::Header as DaHeader, utils::H256};
+use codec::Encode;
 use dusk_plonk::commitment_scheme::kzg10::PublicParameters;
 use kate_recovery::{commitments, matrix::Dimensions};
 use kate_recovery::{data::Cell, matrix::Position};
 use mockall::automock;
 use rocksdb::DB;
+use sp_core::blake2_256;
 use std::{
 	ops::Range,
 	sync::{Arc, Mutex},
@@ -47,9 +49,7 @@ use tracing::{error, info, warn};
 #[async_trait]
 #[automock]
 pub trait SyncClient {
-	fn block_header_in_db(&self, block_number: u32) -> Result<bool>;
 	async fn get_header_by_block_number(&self, block_number: u32) -> Result<(DaHeader, H256)>;
-	fn store_block_header_in_db(&self, header: DaHeader, block_number: u32) -> Result<()>;
 	fn is_confidence_in_db(&self, block_number: u32) -> Result<bool>;
 	fn store_confidence_in_db(&self, count: u32, block_number: u32) -> Result<()>;
 	async fn get_kate_proof(&self, hash: H256, positions: &[Position]) -> Result<Vec<Cell>>;
@@ -77,21 +77,28 @@ pub fn new(db: Arc<DB>, network_client: P2pClient, rpc_client: RpcClient) -> imp
 
 #[async_trait]
 impl SyncClient for SyncClientImpl {
-	fn block_header_in_db(&self, block_number: u32) -> Result<bool> {
-		is_block_header_in_db(self.db.clone(), block_number)
-			.context("Failed to check if block header is in DB")
-	}
-
 	async fn get_header_by_block_number(&self, block_number: u32) -> Result<(DaHeader, H256)> {
-		self.rpc_client
+		if let Some(header) = get_block_header_from_db(self.db.clone(), block_number)
+			.context("Failed to check if block header is in DB")?
+		{
+			let hash: H256 = Encode::using_encoded(&header, blake2_256).into();
+			return Ok((header, hash));
+		}
+
+		let (header, hash) = match self
+			.rpc_client
 			.get_header_by_block_number(block_number)
 			.await
 			.with_context(|| format!("Failed to get block {block_number} by block number"))
-	}
+		{
+			Ok(value) => value,
+			Err(error) => return Err(error),
+		};
 
-	fn store_block_header_in_db(&self, header: DaHeader, block_number: u32) -> Result<()> {
 		store_block_header_in_db(self.db.clone(), block_number, &header)
-			.context("Failed to store block header in DB")
+			.context("Failed to store block header in DB")?;
+
+		Ok((header, hash))
 	}
 
 	fn is_confidence_in_db(&self, block_number: u32) -> Result<bool> {
@@ -126,47 +133,20 @@ impl SyncClient for SyncClientImpl {
 
 async fn process_block(
 	sync_client: &impl SyncClient,
-	block_number: u32,
+	header: DaHeader,
+	header_hash: H256,
 	cfg: &SyncClientConfig,
 	pp: Arc<PublicParameters>,
 	block_verified_sender: Option<broadcast::Sender<BlockVerified>>,
 ) -> Result<()> {
-	if sync_client
-		.block_header_in_db(block_number)
-		.context("Failed to check if block header is in DB")?
-	{
-		// TODO: If block header storing fails, that block will be skipped upon restart
-		// Better option would be to check for confidence
-		info!("Block header {block_number} already in DB");
-		return Ok(());
-	};
-
-	// if block header look up fails, only then comes here for
-	// fetching and storing block header as part of (light weight)
-	// syncing process
+	let block_number = header.number;
 	let begin = Instant::now();
 
-	let (header, header_hash) = sync_client.get_header_by_block_number(block_number).await?;
-
 	let app_lookup = extract_app_lookup(&header.extension);
 
 	info!(block_number, "App index {:?}", app_lookup);
-
-	sync_client
-		.store_block_header_in_db(header.clone(), block_number)
-		.context("Failed to store block header in DB")?;
-
 	info!(block_number, elapsed = ?begin.elapsed(), "Synced block header");
 
-	// If it's found that this certain block is not verified
-	// then it'll be verified now
-	if sync_client
-		.is_confidence_in_db(block_number)
-		.context("Failed to check if confidence is in DB")?
-	{
-		return Ok(());
-	};
-
 	let begin = Instant::now();
 
 	let (rows, cols, _, commitment) = extract_kate(&header.extension);
@@ -272,18 +252,44 @@ pub async fn run(
 
 	info!("Syncing block headers for {sync_range:?}");
 	for block_number in sync_range {
+		match &sync_client.is_confidence_in_db(block_number) {
+			Ok(false) => (),
+			Ok(true) => continue,
+			Err(error) => {
+				// TODO: Is it valid to have skipped block?
+				error!(block_number, "Cannot process block: {error:#}");
+				continue;
+			},
+		};
+
+		let (header, header_hash) = match sync_client.get_header_by_block_number(block_number).await
+		{
+			Ok(value) => value,
+			Err(error) => {
+				error!(block_number, "Cannot process block: {error:#}");
+				continue;
+			},
+		};
+
 		{
 			let mut state = state.lock().unwrap();
 			state.sync_latest.replace(block_number);
-			// TODO: Add proper header verification on sync
+			// TODO: Add proper header verification on sync?
 			state.sync_header_verified.set(block_number);
 		}
 
 		// TODO: Should we handle unprocessed blocks differently?
 		let block_verified_sender = block_verified_sender.clone();
 		let pp = pp.clone();
-		if let Err(error) =
-			process_block(&sync_client, block_number, &cfg, pp, block_verified_sender).await
+		if let Err(error) = process_block(
+			&sync_client,
+			header,
+			header_hash,
+			&cfg,
+			pp,
+			block_verified_sender,
+		)
+		.await
 		{
 			error!(block_number, "Cannot process block: {error:#}");
 		} else {
@@ -314,14 +320,8 @@ mod tests {
 	use kate_recovery::couscous;
 	use mockall::predicate::eq;
 
-	#[tokio::test]
-	pub async fn test_process_blocks_without_rpc() {
-		let (block_tx, _) = broadcast::channel::<types::BlockVerified>(10);
-		let pp = Arc::new(couscous::public_params());
-		let mut cfg = SyncClientConfig::from(&RuntimeConfig::default());
-		cfg.disable_rpc = true;
-		let mut mock_client = MockSyncClient::new();
-		let header: DaHeader = DaHeader {
+	fn default_header() -> DaHeader {
+		DaHeader {
 			parent_hash: hex!("2a75ea712b4b2c360cb7c0cdd806de4e9363ff7e37ce30788d487a258604dba3")
 				.into(),
 			number: 2,
@@ -354,33 +354,23 @@ mod tests {
 					index: vec![],
 				},
 			}),
-		};
+		}
+	}
+
+	#[tokio::test]
+	pub async fn test_process_blocks_without_rpc() {
+		let (block_tx, _) = broadcast::channel::<types::BlockVerified>(10);
+		let pp = Arc::new(couscous::public_params());
+		let mut cfg = SyncClientConfig::from(&RuntimeConfig::default());
+		cfg.disable_rpc = true;
+		let mut mock_client = MockSyncClient::new();
+		let header = default_header();
 		let header_hash: H256 =
 			hex!("3767f8955d6f7306b1e55701b6316fa1163daa8d4cffdb05c3b25db5f5da1723").into();
-		mock_client
-			.expect_block_header_in_db()
-			.with(eq(42))
-			.returning(|_| Ok(false));
 
-		mock_client
-			.expect_get_header_by_block_number()
-			.with(eq(42))
-			.returning(move |_| {
-				let header = header.clone();
-
-				Box::pin(async move { Ok((header, header_hash)) })
-			});
-		mock_client
-			.expect_store_block_header_in_db()
-			.withf(|_, x| *x == 42)
-			.returning(|_, _| Ok(()));
-		mock_client
-			.expect_is_confidence_in_db()
-			.with(eq(42))
-			.returning(|_| Ok(true));
 		mock_client
 			.expect_fetch_cells_from_dht()
-			.withf(|_, x: &u32| *x == 42)
+			.withf(|_, x: &u32| *x == 2)
 			.returning(|_, _| {
 				let dht = vec![];
 				let fetch: Vec<Cell> = vec![
@@ -435,14 +425,18 @@ mod tests {
 		}
 		mock_client
 			.expect_is_confidence_in_db()
-			.with(eq(42))
+			.with(eq(2))
 			.returning(|_| Ok(true));
 
 		mock_client
 			.expect_insert_cells_into_dht()
-			.withf(move |x, _| *x == 42)
+			.withf(move |x, _| *x == 2)
 			.returning(move |_, _| Box::pin(async move { 1f32 }));
-		process_block(&mock_client, 42, &cfg, pp, Some(block_tx))
+		mock_client
+			.expect_store_confidence_in_db()
+			.withf(move |_, block_number| *block_number == 2)
+			.returning(move |_, _| Ok(()));
+		process_block(&mock_client, header, header_hash, &cfg, pp, Some(block_tx))
 			.await
 			.unwrap();
 	}
@@ -453,40 +447,7 @@ mod tests {
 		let pp = Arc::new(couscous::public_params());
 		let cfg = SyncClientConfig::from(&RuntimeConfig::default());
 		let mut mock_client = MockSyncClient::new();
-		let header: DaHeader = DaHeader {
-			parent_hash: hex!("2a75ea712b4b2c360cb7c0cdd806de4e9363ff7e37ce30788d487a258604dba3")
-				.into(),
-			number: 2,
-			state_root: hex!("6f41d5a26a34f7bc3a09d4811b444c09daaebbd5c5d67c4525f42b3ed11bef86")
-				.into(),
-			extrinsics_root: hex!(
-				"3027e34c2c75756c22770e6a3650ad68f3c9e44eed3c5ab4471742fe96678dae"
-			)
-			.into(),
-			digest: Digest { logs: vec![] },
-			extension: V1(HeaderExtension {
-				commitment: KateCommitment {
-					rows: 1,
-					cols: 4,
-					data_root: hex!(
-						"0000000000000000000000000000000000000000000000000000000000000000"
-					)
-					.into(),
-					commitment: vec![
-						181, 10, 104, 251, 33, 171, 87, 192, 13, 195, 93, 127, 215, 78, 114, 192,
-						95, 92, 167, 10, 49, 17, 20, 204, 222, 102, 70, 218, 173, 18, 30, 49, 232,
-						10, 137, 187, 186, 216, 97, 140, 16, 33, 52, 56, 170, 208, 118, 242, 181,
-						10, 104, 251, 33, 171, 87, 192, 13, 195, 93, 127, 215, 78, 114, 192, 95,
-						92, 167, 10, 49, 17, 20, 204, 222, 102, 70, 218, 173, 18, 30, 49, 232, 10,
-						137, 187, 186, 216, 97, 140, 16, 33, 52, 56, 170, 208, 118, 242,
-					],
-				},
-				app_lookup: CompactDataLookup {
-					size: 1,
-					index: vec![],
-				},
-			}),
-		};
+		let header = default_header();
 		let header_hash: H256 =
 			hex!("3767f8955d6f7306b1e55701b6316fa1163daa8d4cffdb05c3b25db5f5da1723").into();
 		let unfetched: Vec<Cell> = vec![Cell {
@@ -499,30 +460,10 @@ mod tests {
 				59, 170, 52, 243, 140, 237, 0,
 			],
 		}];
-		mock_client
-			.expect_block_header_in_db()
-			.with(eq(42))
-			.returning(|_| Ok(false));
 
-		mock_client
-			.expect_get_header_by_block_number()
-			.with(eq(42))
-			.returning(move |_| {
-				let header = header.clone();
-
-				Box::pin(async move { Ok((header, header_hash)) })
-			});
-		mock_client
-			.expect_store_block_header_in_db()
-			.withf(|_, x| *x == 42)
-			.returning(|_, _| Ok(()));
-		mock_client
-			.expect_is_confidence_in_db()
-			.with(eq(42))
-			.returning(|_| Ok(true));
 		mock_client
 			.expect_fetch_cells_from_dht()
-			.withf(|_, x: &u32| *x == 42)
+			.withf(|_, x: &u32| *x == 2)
 			.returning(|_, _| {
 				let dht = vec![Position { row: 0, col: 3 }];
 				let fetch: Vec<Cell> = vec![
@@ -569,31 +510,16 @@ mod tests {
 				Box::pin(async move { Ok(unfetched) })
 			});
 		}
-		mock_client
-			.expect_is_confidence_in_db()
-			.with(eq(42))
-			.returning(|_| Ok(true));
 		mock_client
 			.expect_insert_cells_into_dht()
-			.withf(move |x, _| *x == 42)
+			.withf(move |x, _| *x == 2)
 			.returning(move |_, _| Box::pin(async move { 1f32 }));
-		process_block(&mock_client, 42, &cfg, pp, Some(block_tx))
-			.await
-			.unwrap();
-	}
-	#[tokio::test]
-	pub async fn test_header_in_dbstore() {
-		let (block_tx, _) = broadcast::channel::<types::BlockVerified>(10);
-		let pp = Arc::new(couscous::public_params());
-		let cfg = SyncClientConfig::from(&RuntimeConfig::default());
-		let mut mock_client = MockSyncClient::new();
+
 		mock_client
-			.expect_block_header_in_db()
-			.withf(|block: &u32| *block == 42)
-			.returning(|_| Ok(true));
-		mock_client.expect_get_header_by_block_number().never();
-		mock_client.block_header_in_db(42).unwrap();
-		process_block(&mock_client, 42, &cfg, pp, Some(block_tx))
+			.expect_store_confidence_in_db()
+			.withf(move |_, block_number| *block_number == 2)
+			.returning(move |_, _| Ok(()));
+		process_block(&mock_client, header, header_hash, &cfg, pp, Some(block_tx))
 			.await
 			.unwrap();
 	}