shielding from target_a worked

cli/src/trusted_operation.rs

@@ -161,36 +161,42 @@ fn send_indirect_request(
 	info!("Waiting for execution confirmation from enclave...");
 	let mut subscription = chain_api.subscribe_events().unwrap();
 	loop {
-		let event_records = subscription.next_events::<RuntimeEvent, Hash>().unwrap().unwrap();
-		for event_record in event_records {
-			if let RuntimeEvent::EnclaveBridge(EnclaveBridgeEvent::ProcessedParentchainBlock {
-				shard,
-				block_hash: confirmed_block_hash,
-				trusted_calls_merkle_root,
-				block_number: confirmed_block_number,
-			}) = event_record.event
-			{
-				info!("Confirmation of ProcessedParentchainBlock received");
-				debug!("shard: {:?}", shard);
-				debug!("confirmed parentchain block Hash: {:?}", block_hash);
-				debug!("trusted calls merkle root: {:?}", trusted_calls_merkle_root);
-				debug!("Confirmed stf block Hash: {:?}", confirmed_block_hash);
-				if let Err(e) = check_if_received_event_exceeds_expected(
-					&chain_api,
-					block_hash,
-					confirmed_block_hash,
-					confirmed_block_number,
-				) {
-					error!("ProcessedParentchainBlock event: {:?}", e);
-					return Err(TrustedOperationError::Default {
-						msg: format!("ProcessedParentchainBlock event: {:?}", e),
-					})
-				};
+		let event_result = subscription.next_events::<RuntimeEvent, Hash>();
+		if let Some(Ok(event_records)) = event_result {
+			for event_record in event_records {
+				if let RuntimeEvent::EnclaveBridge(
+					EnclaveBridgeEvent::ProcessedParentchainBlock {
+						shard,
+						block_hash: confirmed_block_hash,
+						trusted_calls_merkle_root,
+						block_number: confirmed_block_number,
+					},
+				) = event_record.event
+				{
+					info!("Confirmation of ProcessedParentchainBlock received");
+					debug!("shard: {:?}", shard);
+					debug!("confirmed parentchain block Hash: {:?}", block_hash);
+					debug!("trusted calls merkle root: {:?}", trusted_calls_merkle_root);
+					debug!("Confirmed stf block Hash: {:?}", confirmed_block_hash);
+					if let Err(e) = check_if_received_event_exceeds_expected(
+						&chain_api,
+						block_hash,
+						confirmed_block_hash,
+						confirmed_block_number,
+					) {
+						error!("ProcessedParentchainBlock event: {:?}", e);
+						return Err(TrustedOperationError::Default {
+							msg: format!("ProcessedParentchainBlock event: {:?}", e),
+						})
+					};
 
-				if confirmed_block_hash == block_hash {
-					return Ok(Some(block_hash.encode()))
+					if confirmed_block_hash == block_hash {
+						return Ok(Some(block_hash.encode()))
+					}
 				}
 			}
+		} else {
+			warn!("Error in event subscription: {:?}", event_result)
 		}
 	}
 }

sidechain/consensus/aura/src/lib.rs

@@ -29,11 +29,13 @@ compile_error!("feature \"std\" and feature \"sgx\" cannot be enabled at the sam
 #[macro_use]
 extern crate sgx_tstd as std;
 
+use codec::Encode;
 use core::marker::PhantomData;
 use itc_parentchain_block_import_dispatcher::triggered_dispatcher::TriggerParentchainBlockImport;
 use itp_ocall_api::EnclaveOnChainOCallApi;
 use itp_time_utils::duration_now;
 use itp_types::parentchain::ParentchainId;
+use itp_utils::hex::hex_encode;
 use its_block_verification::slot::slot_author;
 use its_consensus_common::{Environment, Error as ConsensusError, Proposer};
 use its_consensus_slots::{SimpleSlotWorker, Slot, SlotInfo};
@@ -252,6 +254,7 @@ impl<
 		&self,
 		parentchain_header_hash: &<ParentchainBlock::Header as ParentchainHeaderTrait>::Hash,
 	) -> Result<Option<ParentchainBlock::Header>, ConsensusError> {
+		log::trace!(target: self.logging_target(), "import Integritee blocks until {}", hex_encode(parentchain_header_hash.encode().as_ref()));
 		let maybe_parentchain_block = self
 			.parentchain_integritee_import_trigger
 			.import_until(|parentchain_block| {
@@ -266,6 +269,7 @@ impl<
 		&self,
 		parentchain_header_hash: &<ParentchainBlock::Header as ParentchainHeaderTrait>::Hash,
 	) -> Result<Option<ParentchainBlock::Header>, ConsensusError> {
+		log::trace!(target: self.logging_target(), "import TargetA blocks until {}", hex_encode(parentchain_header_hash.encode().as_ref()));
 		let maybe_parentchain_block = self
 			.maybe_parentchain_target_a_import_trigger
 			.clone()
@@ -282,6 +286,7 @@ impl<
 		&self,
 		parentchain_header_hash: &<ParentchainBlock::Header as ParentchainHeaderTrait>::Hash,
 	) -> Result<Option<ParentchainBlock::Header>, ConsensusError> {
+		log::trace!(target: self.logging_target(), "import TargetB blocks until {}", hex_encode(parentchain_header_hash.encode().as_ref()));
 		let maybe_parentchain_block = self
 			.maybe_parentchain_target_b_import_trigger
 			.clone()

sidechain/consensus/aura/src/slot_proposer.rs

@@ -148,7 +148,7 @@ where
 			.map_err(|e| ConsensusError::Other(e.to_string().into()))?;
 
 		info!(
-			"Queue/Timeslot/Transactions: {:?};{};{}",
+			"Queue/Timeslot/Transactions: {:?};{}ms;{}",
 			trusted_calls.len(),
 			max_duration.as_millis(),
 			number_executed_transactions

sidechain/consensus/slots/src/lib.rs

@@ -234,6 +234,11 @@ pub trait SimpleSlotWorker<ParentchainBlock: ParentchainBlockTrait> {
 					return None
 				},
 			};
+		trace!(
+			target: logging_target,
+			"on_slot: a priori latest Integritee block number: {:?}",
+			latest_integritee_parentchain_header.number()
+		);
 		// fixme: we need proper error handling here. we just assume there is no target_a if there is an error here, which is very brittle
 		let maybe_latest_target_a_parentchain_header =
 			match self.peek_latest_target_a_parentchain_header() {
@@ -247,6 +252,12 @@ pub trait SimpleSlotWorker<ParentchainBlock: ParentchainBlockTrait> {
 					None
 				},
 			};
+		trace!(
+			target: logging_target,
+			"on_slot: a priori latest TargetA block number: {:?}",
+			maybe_latest_target_a_parentchain_header.clone().map(|h| h.number().clone())
+		);
+
 		let maybe_latest_target_b_parentchain_header =
 			match self.peek_latest_target_b_parentchain_header() {
 				Ok(Some(peeked_header)) => Some(peeked_header),
@@ -259,6 +270,11 @@ pub trait SimpleSlotWorker<ParentchainBlock: ParentchainBlockTrait> {
 					None
 				},
 			};
+		trace!(
+			target: logging_target,
+			"on_slot: a priori latest TargetB block number: {:?}",
+			maybe_latest_target_b_parentchain_header.clone().map(|h| h.number().clone())
+		);
 
 		let epoch_data = match self.epoch_data(&latest_integritee_parentchain_header, shard, slot) {
 			Ok(epoch_data) => epoch_data,
@@ -290,40 +306,70 @@ pub trait SimpleSlotWorker<ParentchainBlock: ParentchainBlockTrait> {
 			&latest_integritee_parentchain_header.hash(),
 		) {
 			Ok(h) => h,
-			Err(e) => {
-				warn!(
-					target: logging_target,
-					"Failed to import and retrieve Integritee parentchain block header: {:?}", e
-				);
-				return None
-			},
-		};
-
-		let maybe_last_imported_target_a_header = match self
-			.import_target_a_parentchain_blocks_until(&latest_integritee_parentchain_header.hash())
-		{
-			Ok(h) => Some(h),
 			Err(e) => {
 				debug!(
 					target: logging_target,
-					"Failed to import and retrieve parentchain block header: {:?}", e
+					"Failed to import Integritee blocks until nr{:?}: {:?}",
+					latest_integritee_parentchain_header.number(),
+					e
 				);
 				None
 			},
 		};
+		trace!(
+			target: logging_target,
+			"on_slot: a posteriori latest Integritee block number: {:?}",
+			last_imported_integritee_header.clone().map(|h| h.number().clone())
+		);
 
-		let maybe_last_imported_target_b_header = match self
-			.import_target_b_parentchain_blocks_until(&latest_integritee_parentchain_header.hash())
-		{
-			Ok(h) => Some(h),
-			Err(e) => {
-				debug!(
-					target: logging_target,
-					"Failed to import and retrieve parentchain block header: {:?}", e
-				);
+		let maybe_last_imported_target_a_header =
+			if let Some(ref header) = maybe_latest_target_a_parentchain_header {
+				match self.import_target_a_parentchain_blocks_until(&header.hash()) {
+					Ok(Some(h)) => Some(h),
+					Ok(None) => None,
+					Err(e) => {
+						debug!(
+							target: logging_target,
+							"Failed to import TargetA blocks until nr{:?}: {:?}",
+							header.number(),
+							e
+						);
+						None
+					},
+				}
+			} else {
 				None
-			},
-		};
+			};
+		trace!(
+			target: logging_target,
+			"on_slot: a posteriori latest TargetA block number: {:?}",
+			maybe_last_imported_target_a_header.map(|h| h.number().clone())
+		);
+
+		let maybe_last_imported_target_b_header =
+			if let Some(ref header) = maybe_latest_target_b_parentchain_header {
+				match self.import_target_b_parentchain_blocks_until(&header.hash()) {
+					Ok(Some(h)) => Some(h),
+					Ok(None) => None,
+					Err(e) => {
+						debug!(
+							target: logging_target,
+							"Failed to import TargetB blocks until nr{:?}: {:?}",
+							header.number(),
+							e
+						);
+						None
+					},
+				}
+			} else {
+				None
+			};
+
+		trace!(
+			target: logging_target,
+			"on_slot: a posteriori latest TargetB block number: {:?}",
+			maybe_last_imported_target_b_header.map(|h| h.number().clone())
+		);
 
 		let proposer = match self.proposer(latest_integritee_parentchain_header.clone(), shard) {
 			Ok(p) => p,
@@ -432,8 +478,14 @@ impl<ParentchainBlock: ParentchainBlockTrait, T: SimpleSlotWorker<ParentchainBlo
 				slot_info.maybe_last_imported_target_b_parentchain_head.clone(),
 			);
 
-			match SimpleSlotWorker::on_slot(self, shard_slot, shard) {
-				Some(res) => slot_results.push(res),
+			match SimpleSlotWorker::on_slot(self, shard_slot.clone(), shard) {
+				Some(res) => {
+					slot_results.push(res);
+					debug!(
+						target: logging_target,
+						"on_slot: produced block for slot: {:?} in shard {:?}", shard_slot, shard
+					)
+				},
 				None => info!(
 					target: logging_target,
 					"Did not produce a block for slot {} in shard {:?}", *slot_info.slot, shard