fix timeouts (?)

Author: vmarkushin

Cargo.lock

@@ -50,7 +50,7 @@ members = [
     "utils/subxt/generated",
     "utils/parachain-node",
     "utils/parachain-node/runtime",
-    "utils/calldata-compression",
+    "utils/compress",
 #     "utils/simnode"
 
     "hyperspace/ethereum/evm-indexer"

Cargo.toml

@@ -7,42 +7,42 @@ name = "ethereum-client"
 client_id = "07-tendermint-0"
 channel_whitelist = []
 commitment_prefix = "696263"
-diamond_address = "0xa99cd5fb8b1742a9cee7b73f06adeeffe3877512"
-tendermint_address = "0x08563ca7c14985101fb012374e7d0c0b4210553b"
-ics20_transfer_bank_address = "0xb8964e5938e1b1898bfbcfc1299cdb8f2e592bbf"
-ics20_bank_address = "0x3f98a1c3022628a11aa27d0c315472b319a0e669"
+diamond_address = "0xf4c29c09b793ec0832580f0291e25dda4bf7fc92"
+tendermint_address = "0xb9a11502bfdddf44eaf78745af8f509e4902fa24"
+ics20_transfer_bank_address = "0xe9ed9766bd7c85cc9914be8c890600517bf73a47"
+ics20_bank_address = "0x70654c67b997d277c8b589d0a3ded77f5966cf46"
 diamond_facets = [
     [
     "IBCClient",
-    "0xbc9098af79b4a35defef8a16098b94454849a540",
+    "0xa0d94305e4508bc3db169248968707421f9f5d4a",
 ],
     [
     "IBCConnection",
-    "0x3a105a567a677cfb049d96b4103ed08ad66c80da",
+    "0x774e3038f91732f689d8cda201857d891105d73f",
 ],
     [
     "IBCChannelHandshake",
-    "0xcf4210c1f5e1558f58300fea9b8398ab74f8900a",
+    "0x13a43fd4982cd2e18ac572c90fc2c3d058cfa9c2",
 ],
     [
     "IBCPacket",
-    "0x481796b2a6cf91a68e18b42dedc98c035734043f",
+    "0x2ab116a110ea6eacb6fc28b76d57719d68648e26",
 ],
     [
     "IBCQuerier",
-    "0xec509da1cb1284f6b3899fcf33c3f208dd4e1f72",
+    "0x414e2dbd344a507d0a85e284111efdd3cb8405b9",
 ],
     [
     "DiamondCutFacet",
-    "0xa1dfcc1c574eace5458900a3690f9c559dc98478",
+    "0x3ea11052b9f9ac3147fd665903895594b2867831",
 ],
     [
     "DiamondLoupeFacet",
-    "0xa702cb28df2fb6642c46c32e8ab8d826a21083aa",
+    "0xd06efe520063a4a1036d4f0d70b87b80919da7ea",
 ],
     [
     "OwnershipFacet",
-    "0x2de2ce2858096a4a3e0ce01cab750293b51d4b0a",
+    "0x5a7746c9d20797f91d6f397a32a27869a36861cd",
 ],
 ]
 client_type = "07-tendermint"

config/ethereum-local.toml

@@ -235,15 +235,12 @@ pub async fn query_ready_and_timed_out_packets(
 						Error::Custom(format!("Packet height not found for packet {packet:?}"))
 					})?;
 
-
-				    log::info!("sink_height = {sink_height:?}, timeout_height = {:?}", packet.timeout_height);
+				    log::info!("sink_height = {sink_height:?}, timeout_height = {:?}, timeout_timestamp = {}, seq = {}", packet.timeout_height, packet.timeout_timestamp, packet.sequence);
 
 					if packet.timed_out(&sink_timestamp, sink_height) {
 						source.common_state().ignored_timeouted_sequences.lock().await.insert(
 							packet.sequence.0
 						);
-						return Ok(None)
-						/*
 						timeout_packets_count.fetch_add(1, Ordering::SeqCst);
 						// so we know this packet has timed out on the sink, we need to find the maximum
 						// consensus state height at which we can generate a non-membership proof of the
@@ -253,6 +250,7 @@ pub async fn query_ready_and_timed_out_packets(
 								&**source,
 								&**sink,
 								source_height,
+								source_timestamp,
 								sink_height,
 								sink_timestamp,
 								latest_sink_height_on_source,
@@ -296,7 +294,6 @@ pub async fn query_ready_and_timed_out_packets(
 						)
 							.await?;
 						return Ok(Some(Left(msg)))
-						 */
 					} else {
 						log::trace!(target: "hyperspace", "The packet has not timed out yet: {:?}", packet);
 					}
@@ -369,6 +366,7 @@ pub async fn query_ready_and_timed_out_packets(
 
 					let msg = construct_recv_message(&**source, &**sink, packet, proof_height).await?;
 					Ok(Some(Right(msg)))
+					// return Ok(None)
 				});
 			}
 		}
@@ -470,8 +468,8 @@ pub async fn query_ready_and_timed_out_packets(
 						log::trace!(target: "hyperspace", "Using proof height: {}", proof_height);
 						proof_height
 					} else {
-						log::trace!(target: "hyperspace", "Skipping acknowledgement for packet {:?} as no proof height could be found", packet);
-						return Ok(None)
+						log::trace!(target: "hyperspace", "Skipping acknowledgement for packet {:?}
+					as no proof height could be found", packet); 	return Ok(None)
 					};
 
 					if !verify_delay_passed(

hyperspace/core/src/packets.rs

@@ -36,14 +36,15 @@ use ibc::{
 };
 use ibc_proto::google::protobuf::Any;
 use primitives::{find_suitable_proof_height_for_client, Chain};
-use std::time::Duration;
+use std::{ops::Sub, time::Duration};
 use tendermint_proto::Protobuf;
 
 #[allow(clippy::too_many_arguments)]
 pub async fn get_timeout_proof_height(
 	source: &impl Chain,
 	sink: &impl Chain,
 	source_height: Height,
+	source_timestamp: Timestamp,
 	sink_height: Height,
 	sink_timestamp: Timestamp,
 	latest_client_height_on_source: Height,
@@ -74,17 +75,44 @@ pub async fn get_timeout_proof_height(
 			// bound for where to start our search
 			// We offset the sink height when this packet was created with the approximate number of
 			// blocks contained in the difference in timestamp at packet creation until timeout
+
+			/*
+			1. Calculate packet creation time on A.
+			2. Calculate time difference between the current time and the packet creation time (dTa)
+			3. Calculate the number of blocks contained in dTb (nTb)
+			4. Calculate the height of the packet on B (Hb) by subtracting nTb from the current height of B (Tb = Hb - nTb)
+			5. Calculate timeout block on B (TOb) by adding the timeout duration (dTO) in B blocks to Hb
+			 */
+
 			let timeout_ns = packet.timeout_timestamp.nanoseconds();
 			let sink_ns = sink_timestamp.nanoseconds();
 			if timeout_ns > sink_ns {
 				return None
 			}
-			let period = sink_ns.saturating_sub(timeout_ns);
-			let period = Duration::from_nanos(period);
-			let timeout_height = (sink_height.revision_height -
-				calculate_block_delay(period, sink.expected_block_time()))
-			.saturating_sub(1);
-			let start_height = Height::new(sink_height.revision_number, timeout_height);
+
+			let packet_lifetime_blocks_on_a =
+				source_height.revision_height.saturating_sub(packet_creation_height);
+			let packet_timestamp = (source_timestamp -
+				source.expected_block_time() * packet_lifetime_blocks_on_a as u32)
+				.ok()?;
+			let timeout_timestamp_relative = Duration::from_nanos(
+				packet
+					.timeout_timestamp
+					.nanoseconds()
+					.saturating_sub(packet_timestamp.nanoseconds()),
+			);
+			let packet_lifetime_timestamp =
+				source.expected_block_time() * (packet_lifetime_blocks_on_a as u32);
+			let packet_lifetime_blocks_on_b = (packet_lifetime_timestamp.as_nanos() /
+				sink.expected_block_time().as_nanos()) as u64;
+			let packet_height_on_b =
+				sink_height.revision_height.saturating_sub(packet_lifetime_blocks_on_b);
+			let timeout_block_on_b = (packet_height_on_b +
+				(timeout_timestamp_relative.as_nanos() / sink.expected_block_time().as_nanos())
+					as u64)
+				.saturating_sub(1);
+
+			let start_height = Height::new(sink_height.revision_number, timeout_block_on_b);
 			find_suitable_proof_height_for_client(
 				sink,
 				source,
@@ -105,13 +133,30 @@ pub async fn get_timeout_proof_height(
 			if timeout_ns > sink_ns {
 				return None
 			}
-			let period = sink_ns.saturating_sub(timeout_ns);
-			let period = Duration::from_nanos(period);
-			let timeout_height = (sink_height.revision_height -
-				calculate_block_delay(period, sink.expected_block_time()))
-			.saturating_sub(1);
-			let start_height =
-				Height::new(sink_height.revision_number, timeout_height).min(packet.timeout_height);
+
+			let packet_lifetime_blocks_on_a =
+				source_height.revision_height.saturating_sub(packet_creation_height);
+			let packet_timestamp = (source_timestamp -
+				source.expected_block_time() * packet_lifetime_blocks_on_a as u32)
+				.ok()?;
+			let timeout_timestamp_relative = Duration::from_nanos(
+				packet
+					.timeout_timestamp
+					.nanoseconds()
+					.saturating_sub(packet_timestamp.nanoseconds()),
+			);
+			let packet_lifetime_timestamp =
+				source.expected_block_time() * (packet_lifetime_blocks_on_a as u32);
+			let packet_lifetime_blocks_on_b = (packet_lifetime_timestamp.as_nanos() /
+				sink.expected_block_time().as_nanos()) as u64;
+			let packet_height_on_b =
+				sink_height.revision_height.saturating_sub(packet_lifetime_blocks_on_b);
+			let timeout_block_on_b = (packet_height_on_b +
+				(timeout_timestamp_relative.as_nanos() / sink.expected_block_time().as_nanos())
+					as u64)
+				.saturating_sub(1);
+			let start_height = Height::new(sink_height.revision_number, timeout_block_on_b)
+				.min(packet.timeout_height);
 
 			find_suitable_proof_height_for_client(
 				sink,

hyperspace/core/src/packets/utils.rs

@@ -59,14 +59,15 @@ itertools = "0.11.0"
 
 redis = "0.22"
 sqlx = { version = "0.6", features = [ "runtime-tokio-native-tls" , "postgres" ] }
+ics23 = { git = "https://github.com/cosmos/ics23", rev = "74ce807b7be39a7e0afb4e2efb8e28a57965f57b", default-features = false }
 
 [dev-dependencies]
 toml = "0.7.3"
 git2 = "0.17.1"
 tendermint = { git = "https://github.com/informalsystems/tendermint-rs", rev = "e81f7bf23d63ffbcd242381d1ce5e35da3515ff1", default-features = false }
 
 [features]
-default = ["testnet", "no_beacon"]
+default = ["testnet"]
 testnet = [
     "sync-committee-primitives/testnet",
     "sync-committee-verifier/testnet",

hyperspace/ethereum/Cargo.toml

@@ -54,7 +54,7 @@ async fn main() {
 
 		loop {
 			sync_chain(&rpc, &db, &mut config, &mut indexed_blocks).await;
-			sleep(Duration::from_millis(500)).await;
+			sleep(Duration::from_millis(50)).await;
 		}
 	} else {
 		db.delete_indexed_blocks().await.unwrap();
@@ -177,6 +177,9 @@ async fn sync_chain(
 		)
 		.await;
 
+		// for number in missing_blocks_chunk.into_iter() {
+		// 	indexed_blocks.insert(*number);
+		// }
 		for block in db_blocks.into_iter() {
 			indexed_blocks.insert(block.number);
 		}

hyperspace/ethereum/evm-indexer/bin/indexer.rs

@@ -33,7 +33,10 @@ use ibc::{
 			conn_open_init::MsgConnectionOpenInit, conn_open_try::MsgConnectionOpenTry,
 		},
 		ics04_channel::msgs as channel_msgs,
-		ics23_commitment::commitment::{CommitmentProofBytes, CommitmentRoot},
+		ics23_commitment::{
+			commitment::{CommitmentProofBytes, CommitmentRoot},
+			merkle::MerkleProof,
+		},
 		ics24_host::identifier::{ChainId, ClientId},
 	},
 	proofs::ConsensusProof,
@@ -45,11 +48,14 @@ use ics07_tendermint::{
 	client_state::ClientState,
 	consensus_state::ConsensusState,
 };
+use ics23::commitment_proof::Proof;
 use icsxx_ethereum::{
 	abi::EthereumClientAbi::EthereumClientPrimitivesConsensusStateProof, utils::keccak256,
 };
 use log::{error, info};
-use pallet_ibc::light_clients::{AnyClientMessage, AnyClientState, AnyConsensusState};
+use pallet_ibc::light_clients::{
+	AnyClientMessage, AnyClientState, AnyConsensusState, HostFunctionsManager,
+};
 use primitives::{
 	mock::LocalClientTypes, Chain, CommonClientState, IbcProvider, LightClientSync,
 	MisbehaviourHandler,
@@ -1346,6 +1352,33 @@ impl Chain for EthereumClient {
 					)
 					.expect("proof can't be empty"),
 				);
+				let cs_proof = msg.proofs.client_proof().as_ref().expect("no proof").as_bytes();
+				use ibc_proto::ibc::core::commitment::v1::MerkleProof as RawMerkleProof;
+				let merkle_proof: MerkleProof<HostFunctionsManager> = RawMerkleProof::try_from(
+					CommitmentProofBytes::try_from(cs_proof.to_vec()).unwrap(),
+				)
+				.unwrap()
+				.into();
+				merkle_proof.clone().proofs.iter_mut().enumerate().for_each(|(i, proof)| {
+					proof.proof.as_mut().map(|proof| match proof {
+						Proof::Exist(p) =>
+							if i == 0 {
+								p.value.clear();
+							},
+						Proof::Nonexist(_) => {
+							unimplemented!()
+						},
+						Proof::Batch(batch) => {
+							todo!("1")
+						},
+						Proof::Compressed(compressed) => {
+							todo!("2")
+						},
+					});
+				});
+				let new_raw_proof = RawMerkleProof::from(merkle_proof.clone());
+				let new_proof = CommitmentProofBytes::try_from(new_raw_proof).unwrap();
+				msg.proofs.client_proof = Some(new_proof);
 
 				let mut token = msg_connection_open_ack_token(msg)?;
 				let Token::Tuple(ref mut tokens) = token else {