Merge remote-tracking branch 'origin/ics07-tendermint-zk-wrapper' into vmarkushin/refactor-tendermint+zk

# Conflicts:
#	config/ethereum-local.toml
#	hyperspace/cosmos/src/client.rs
#	hyperspace/cosmos/src/provider.rs
#	hyperspace/ethereum/src/ibc_provider.rs
#	hyperspace/testsuite/tests/ethereum_cosmos.rs

Author: vmarkushin

Cargo.lock

@@ -42,6 +42,7 @@ ics08-wasm = { path = "../../light-clients/ics08-wasm", default-features = false
 ics10-grandpa = { path = "../../light-clients/ics10-grandpa", default-features = false }
 ics11-beefy = { path = "../../light-clients/ics11-beefy", default-features = false }
 ics07-tendermint = { path = "../../light-clients/ics07-tendermint", default-features = false }
+ics07-tendermint-zk = { path = "../../light-clients/ics07-tendermint-zk", default-features = false }
 icsxx-ethereum = { path = "../../light-clients/icsxx-ethereum", default-features = false, optional = true }
 hex = { version = "0.4.3", default-features = false }
 # local deps

contracts/pallet-ibc/Cargo.toml

@@ -24,6 +24,13 @@ use ics07_tendermint::{
 	client_state::TENDERMINT_CLIENT_STATE_TYPE_URL,
 	consensus_state::TENDERMINT_CONSENSUS_STATE_TYPE_URL,
 };
+use ics07_tendermint_zk::{
+	client_message::{
+		TENDERMINT_CLIENT_MESSAGE_TYPE_URL as TENDERMINT_CLIENT_MESSAGE_ZK_TYPE_URL,
+		TENDERMINT_HEADER_TYPE_URL as TENDERMINT_HEADER_ZK_TYPE_URL,
+		TENDERMINT_MISBEHAVIOUR_TYPE_URL as TENDERMINT_MISBEHAVIOUR_ZK_TYPE_URL,
+	},
+};
 use ics08_wasm::{
 	client_message::{
 		WASM_CLIENT_MESSAGE_TYPE_URL, WASM_HEADER_TYPE_URL, WASM_MISBEHAVIOUR_TYPE_URL,
@@ -349,7 +356,12 @@ pub enum AnyClientMessage {
 	#[ibc(proto_url = "BEEFY_CLIENT_MESSAGE_TYPE_URL")]
 	Beefy(ics11_beefy::client_message::ClientMessage),
 	#[ibc(proto_url = "TENDERMINT_CLIENT_MESSAGE_TYPE_URL")]
-	Tendermint(ics07_tendermint::client_message::ClientMessage),
+	Tendermint(ics07_tendermint::client_message::ClientMessage), // or use the new wrapper crate here 
+	#[ibc(proto_url = "TENDERMINT_CLIENT_MESSAGE_ZK_TYPE_URL")]
+	TendermintZk(ics07_tendermint_zk::client_message::ZkClientMessage), // or use the new wrapper crate here 
+	//todo probably need to add ethereum client message with zk  ^
+	// #[ibc(proto_url = "TENDERMINT_CLIENT_MESSAGE_TYPE_URL")]
+	// TendermintZk(ics07_new_blabla::client_message::ClientMessageWithZkProof),
 	#[cfg(feature = "ethereum")]
 	#[ibc(proto_url = "ETHEREUM_CLIENT_MESSAGE_TYPE_URL")]
 	Ethereum(icsxx_ethereum::client_message::ClientMessage),
@@ -367,6 +379,10 @@ impl AnyClientMessage {
 				ics07_tendermint::client_message::ClientMessage::Header(h) => Some(h.height()),
 				ics07_tendermint::client_message::ClientMessage::Misbehaviour(_) => None,
 			},
+			Self::TendermintZk(inner) => match inner {
+				ics07_tendermint_zk::client_message::ZkClientMessage::Header(h) => Some(h.height()),
+				ics07_tendermint_zk::client_message::ZkClientMessage::Misbehaviour(_) => None,
+			},
 			Self::Beefy(inner) => match inner {
 				ics11_beefy::client_message::ClientMessage::Header(_) =>
 					unimplemented!("beefy header height"),
@@ -475,6 +491,23 @@ impl TryFrom<Any> for AnyClientMessage {
 					ics07_tendermint::client_message::Misbehaviour::decode_vec(&value.value)
 						.map_err(ics02_client::error::Error::decode_raw_header)?,
 				))),
+
+			TENDERMINT_CLIENT_MESSAGE_ZK_TYPE_URL => Ok(Self::TendermintZk(
+				ics07_tendermint_zk::client_message::ZkClientMessage::decode_vec(&value.value)
+					.map_err(ics02_client::error::Error::decode_raw_header)?,
+			)),
+			TENDERMINT_HEADER_ZK_TYPE_URL =>
+				Ok(Self::TendermintZk(ics07_tendermint_zk::client_message::ZkClientMessage::Header(
+					ics07_tendermint_zk::client_message::ZkHeader::decode_vec(&value.value)
+						.map_err(ics02_client::error::Error::decode_raw_header)?,
+				))),
+			TENDERMINT_MISBEHAVIOUR_ZK_TYPE_URL =>
+				Ok(Self::TendermintZk(ics07_tendermint_zk::client_message::ZkClientMessage::Misbehaviour(
+					ics07_tendermint::client_message::Misbehaviour::decode_vec(&value.value)
+						.map_err(ics02_client::error::Error::decode_raw_header)?,
+				))),
+
+
 			#[cfg(feature = "ethereum")]
 			ETHEREUM_CLIENT_MESSAGE_TYPE_URL => Ok(Self::Ethereum(
 				icsxx_ethereum::client_message::ClientMessage::decode_vec(&value.value)
@@ -542,6 +575,10 @@ impl From<AnyClientMessage> for Any {
 				type_url: TENDERMINT_CLIENT_MESSAGE_TYPE_URL.to_string(),
 				value: msg.encode_vec().expect("encode_vec failed"),
 			},
+			AnyClientMessage::TendermintZk(msg) => Any {
+				type_url: TENDERMINT_CLIENT_MESSAGE_ZK_TYPE_URL.to_string(),
+				value: msg.encode_vec().expect("encode_vec failed"),
+			},
 			#[cfg(feature = "ethereum")]
 			AnyClientMessage::Ethereum(msg) => match msg {
 				icsxx_ethereum::client_message::ClientMessage::Header(h) => Any {

contracts/pallet-ibc/src/light_clients.rs

@@ -217,10 +217,11 @@ async fn process_some_finality_event<A: Chain, B: Chain>(
 	mode: Option<Mode>,
 	finality_event: <A as IbcProvider>::FinalityEvent,
 ) -> anyhow::Result<()> {
+	let name_n = source.name().to_string();
 	let updates = source
 		.query_latest_ibc_events(finality_event, &*sink)
 		.await
-		.map_err(|e| anyhow!("Failed to fetch IBC events for finality event {e}"))?;
+		.map_err(|e| anyhow!("Failed to fetch IBC events from {name_n} for finality event {e}"))?;
 	log::trace!(target: "hyperspace", "Received updates count: {}", updates.len());
 	// query packets that can now be sent, at this sink height because of connection
 	// delay.
@@ -272,20 +273,20 @@ async fn process_updates<A: Chain, B: Chain>(
 	msgs: &mut Vec<Any>,
 ) -> anyhow::Result<()> {
 	// for timeouts we need both chains to be up to date
-	let sink_has_undelivered_acks = sink.has_undelivered_sequences(UndeliveredType::Recvs) ||
+	let sink_has_undelivered_acks =  sink.has_undelivered_sequences(UndeliveredType::Recvs) || 
 		sink.has_undelivered_sequences(UndeliveredType::Acks) ||
 		sink.has_undelivered_sequences(UndeliveredType::Timeouts);
 
 	let need_to_update = sink_has_undelivered_acks;
-	log::info!(target: "hyperspace", "Received {} client updates from {}", updates.len(), source.name(),);
+	log::error!(target: "hyperspace", "Received {} client updates from {}", updates.len(), source.name(),);
 
 	let common_state = source.common_state();
 	let skip_optional_updates = common_state.skip_optional_client_updates;
 	let has_events = updates.iter().any(|(_, _, events, ..)| !events.is_empty());
 	let mut mandatory_updates = updates
 		.iter()
 		.filter(|(_, h, _, update_type)| {
-			log::info!(
+			log::error!(
 				"Received updated from {} at {}, is_mandatory: {}",
 				source.name(),
 				h.revision_height,
@@ -308,14 +309,14 @@ async fn process_updates<A: Chain, B: Chain>(
 	);
 	if let Some(not_updated_during) = Timestamp::now().duration_since(&update_time) {
 		if not_updated_during < source.common_state().client_update_interval {
-			log::debug!(target: "hyperspace", "Sending only mandatory updates, not updated during {} seconds, need {}", not_updated_during.as_secs(), sink.common_state().client_update_interval.as_secs());
+			log::error!(target: "hyperspace", "Sending only mandatory updates, not updated during {} seconds, need {}", not_updated_during.as_secs(), sink.common_state().client_update_interval.as_secs());
 			update_delay_passed = false;
 		}
 	} else {
-		log::warn!(target: "hyperspace", "Update time is from the future: {}", update_time);
+		log::error!(target: "hyperspace", "Update time is from the future: {}", update_time);
 	}
 
-	log::debug!(target: "hyperspace", "Received' {} client updates from {}", mandatory_updates.len(), source.name(),);
+	log::error!(target: "hyperspace", "Received' {} client updates from {}", mandatory_updates.len(), source.name(),);
 
 	let ibc_events = updates
 		.iter()
@@ -338,12 +339,11 @@ async fn process_updates<A: Chain, B: Chain>(
 		)
 	});
 
-	log::debug!(target: "hyperspace", "Received'' {}, has_instant_events = {has_instant_events}, update_delay_passed = {update_delay_passed}, need_to_update = {need_to_update}", mandatory_updates.len(), );
-
+	
 	if !updates.is_empty() &&
 		(mandatory_updates.is_empty() && update_delay_passed && need_to_update) ||
 		has_instant_events
-	{
+	{	
 		let (forced_update, height) = updates.last().map(|(msg, h, ..)| (msg.clone(), h)).unwrap();
 		if !mandatory_updates.is_empty() {
 			let (_, last_height) =
@@ -355,19 +355,21 @@ async fn process_updates<A: Chain, B: Chain>(
 			mandatory_updates.push((forced_update, *height));
 		}
 	}
+
+	log::error!(target: "hyperspace", "Received finalized events from: {} {event_types:#?}", source.name());
 	if mandatory_updates.is_empty() && !has_events {
-		log::info!(target: "hyperspace", "No messages to send");
+		log::error!(target: "hyperspace", "No messages to send");
 		return Ok(())
 	}
 
 	let latest_update_height = if !mandatory_updates.is_empty() {
 		mandatory_updates.last().map(|(_, height)| *height).unwrap()
 	} else {
-		log::warn!(target: "hyperspace", "Expected at least one update");
+		log::error!(target: "hyperspace", "Expected at least one update");
 		return Ok(())
 	};
 
-	log::info!(target: "hyperspace", "Received finalized events from: {} {event_types:#?}", source.name());
+	log::error!(target: "hyperspace", "Received finalized events from: {} {event_types:#?}", source.name());
 	let mut new_height = source.get_proof_height(latest_update_height).await;
 	if new_height != latest_update_height {
 		new_height.revision_height -=
@@ -380,7 +382,9 @@ async fn process_updates<A: Chain, B: Chain>(
 			.map_err(|e| anyhow!("Failed to parse events: {:?}", e))?;
 	let (latest_height, _) = source.latest_height_and_timestamp().await?;
 	for (msg_update_client, h) in mandatory_updates {
-		log::debug!(target: "hyperspace", "Received client update message for {}: {}, latest height: {latest_height}", source.name(), h);
+		log::error!(target: "hyperspace", "Received client update message for {}: {}, latest height: {latest_height}", source.name(), h);
+		// log::error!(target: "hyperspace", "___________________________________________________________________________________________");
+		// log::error!(target: "hyperspace", "Received client update message for {}: {}, latest height: {latest_height}", source.name(), h);
 		msgs.push(msg_update_client);
 	}
 

hyperspace/core/src/lib.rs

@@ -255,6 +255,7 @@ pub async fn query_ready_and_timed_out_packets(
 						{
 							proof_height
 						} else {
+							//todo!!! but with a loop zk relayer proably because of this
 							timeout_packets_count.fetch_add(1, Ordering::SeqCst);
 							log::trace!(target: "hyperspace", "Skipping packet as no timeout proof height could be found: {:?}", packet);
 							return Ok(None)
@@ -311,7 +312,8 @@ pub async fn query_ready_and_timed_out_packets(
 					// If sink does not have a client height that is equal to or greater than the packet
 					// creation height, we can't send it yet, packet_info.height should represent the packet
 					// creation height on source chain
-					if packet_height > latest_source_height_on_sink.revision_height {
+					
+					if source.get_proof_height(Height::new(source_height.revision_number, packet_height)).await.revision_height > latest_source_height_on_sink.revision_height {
 						// Sink does not have client update required to prove recv packet message
 						log::debug!(target: "hyperspace", "Skipping packet as sink does not have client update required to prove recv packet message: {:?}", packet);
 						recv_packets_count.fetch_add(1, Ordering::SeqCst);
@@ -439,7 +441,9 @@ pub async fn query_ready_and_timed_out_packets(
 					let ack_height = acknowledgement.height.ok_or_else(|| {
 						Error::Custom(format!("Packet height not found for packet {packet:?}"))
 					})?;
-					if ack_height > latest_source_height_on_sink.revision_height {
+
+					if source.get_proof_height(Height::new(source_height.revision_number, ack_height)).await.revision_height > latest_source_height_on_sink.revision_height {
+					// if ack_height > latest_source_height_on_sink.revision_height {
 						// Sink does not have client update required to prove acknowledgement packet message
 						log::trace!(target: "hyperspace", "Skipping acknowledgement for packet {:?} as sink does not have client update required to prove acknowledgement packet message", packet);
 						acks_packets_count.fetch_add(1, Ordering::SeqCst);

hyperspace/core/src/packets.rs

@@ -35,12 +35,14 @@ ripemd = "0.1.3"
 digest = "0.10.6"
 quick_cache = "0.3.0"
 rand = "0.8.5"
+ureq = {version = "2.9.1", features = ["json"] }
 
 # composable
 ibc = { path = "../../ibc/modules", features = [] }
 ibc-proto = { path = "../../ibc/proto" }
 ibc-primitives = { path = "../../contracts/pallet-ibc/primitives" }
 ics07-tendermint = { path = "../../light-clients/ics07-tendermint" }
+ics07-tendermint-zk = { path = "../../light-clients/ics07-tendermint-zk" }
 ics08-wasm = { path = "../../light-clients/ics08-wasm" }
 ibc-rpc = { path = "../../contracts/pallet-ibc/rpc" }
 pallet-ibc = { path = "../../contracts/pallet-ibc" }

hyperspace/cosmos/Cargo.toml

@@ -133,6 +133,8 @@ where
 	}
 
 	async fn submit(&self, messages: Vec<Any>) -> Result<Self::TransactionId, Error> {
+		log::error!(target: "hyperspace_cosmos", "all messages ____________________________________________");
+		log::error!(target: "hyperspace_cosmos", "Submitting messages to ethereum: {:?}", messages.iter().map(|x| x.type_url.clone()).collect::<Vec<_>>().join(", "));
 		let hash = self.submit_call(messages).await?;
 		log::debug!(target: "hyperspace_cosmos", "Submitted. Tx hash: {}", hash);
 		Ok(Self::TransactionId { hash })