use new v2 paths for commit ack receipt

Author: rnbguy

ibc-eureka-core/ics04-channel/src/context.rs

@@ -5,7 +5,9 @@ use ibc_eureka_core_client::context::prelude::*;
 use ibc_eureka_core_handler_types::events::IbcEvent;
 use ibc_eureka_core_host::types::error::HostError;
 use ibc_eureka_core_host::types::identifiers::Sequence;
-use ibc_eureka_core_host::types::path::{CommitmentPath, SeqSendPath};
+use ibc_eureka_core_host::types::path::{
+    CommitmentPathV2 as CommitmentPath, SeqSendPathV2 as SeqSendPath,
+};
 use ibc_eureka_core_host::{ExecutionContext, ValidationContext};
 use ibc_primitives::prelude::*;
 

ibc-eureka-core/ics04-channel/src/handler/acknowledgement.rs

@@ -6,7 +6,9 @@ use ibc_eureka_core_channel_types::events::AcknowledgePacket;
 use ibc_eureka_core_channel_types::msgs::MsgAcknowledgement;
 use ibc_eureka_core_client::context::prelude::*;
 use ibc_eureka_core_handler_types::events::{IbcEvent, MessageEvent};
-use ibc_eureka_core_host::types::path::{AckPath, ClientConsensusStatePath, CommitmentPath, Path};
+use ibc_eureka_core_host::types::path::{
+    AckPathV2 as AckPath, ClientConsensusStatePath, CommitmentPathV2 as CommitmentPath, Path,
+};
 use ibc_eureka_core_host::{ExecutionContext, ValidationContext};
 use ibc_eureka_core_router::module::Module;
 use ibc_primitives::prelude::*;
@@ -35,16 +37,24 @@ where
     let packet = &msg.packet;
     let payload = &packet.payloads[0];
 
-    let (_, port_id_on_a) = &payload.header.source_port;
-    let channel_id_on_a = &packet.header.target_client_on_source;
+    let (source_prefix, _source_port) = &payload.header.source_port;
+    let channel_target_client_on_source = &packet.header.target_client_on_source;
+    let (target_prefix, _target_port) = &payload.header.target_port;
+    let channel_source_client_on_target = &packet.header.source_client_on_target;
     let seq_on_a = &packet.header.seq_on_a;
 
     // In all cases, this event is emitted
     let event = IbcEvent::AcknowledgePacket(AcknowledgePacket::new(packet.clone()));
     ctx_a.emit_ibc_event(IbcEvent::Message(MessageEvent::Channel))?;
     ctx_a.emit_ibc_event(event)?;
 
-    let commitment_path_on_a = CommitmentPath::new(port_id_on_a, channel_id_on_a, *seq_on_a);
+    let commitment_path_on_a = CommitmentPath::new(
+        channel_source_client_on_target.as_ref(),
+        &format!("{source_prefix:?}"),
+        channel_target_client_on_source.as_ref(),
+        &format!("{target_prefix:?}"),
+        seq_on_a,
+    );
 
     // check if we're in the NO-OP case
     if ctx_a.get_packet_commitment(&commitment_path_on_a).is_err() {
@@ -92,14 +102,20 @@ where
     let packet = &msg.packet;
     let payload = &packet.payloads[0];
 
-    let (prefix_on_a, port_id_on_a) = &payload.header.source_port;
-    let channel_id_on_a = &packet.header.target_client_on_source;
-    let (_, port_id_on_b) = &payload.header.target_port;
-    let channel_id_on_b = &packet.header.source_client_on_target;
+    let (source_prefix, _source_port) = &payload.header.source_port;
+    let channel_target_client_on_source = &packet.header.target_client_on_source;
+    let (target_prefix, _target_port) = &payload.header.target_port;
+    let channel_source_client_on_target = &packet.header.source_client_on_target;
     let seq_on_a = &packet.header.seq_on_a;
     let data = &payload.data;
 
-    let commitment_path_on_a = CommitmentPath::new(port_id_on_a, channel_id_on_a, *seq_on_a);
+    let commitment_path_on_a = CommitmentPath::new(
+        channel_source_client_on_target.as_ref(),
+        &format!("{source_prefix:?}"),
+        channel_target_client_on_source.as_ref(),
+        &format!("{target_prefix:?}"),
+        seq_on_a,
+    );
 
     // Verify packet commitment
     let Ok(commitment_on_a) = ctx_a.get_packet_commitment(&commitment_path_on_a) else {
@@ -126,34 +142,43 @@ where
     // Verify proofs
     {
         // TODO(rano): avoid a vs b confusion
-        let client_id_on_a = channel_id_on_b.as_ref();
+        let id_target_client_on_source = channel_target_client_on_source.as_ref();
 
         let client_val_ctx_a = ctx_a.get_client_validation_context();
 
-        let client_state_of_b_on_a = client_val_ctx_a.client_state(client_id_on_a)?;
+        let target_client_on_source = client_val_ctx_a.client_state(id_target_client_on_source)?;
 
-        client_state_of_b_on_a
-            .status(ctx_a.get_client_validation_context(), client_id_on_a)?
+        target_client_on_source
+            .status(
+                ctx_a.get_client_validation_context(),
+                id_target_client_on_source,
+            )?
             .verify_is_active()?;
 
-        client_state_of_b_on_a.validate_proof_height(msg.proof_height_on_b)?;
+        target_client_on_source.validate_proof_height(msg.proof_height_on_b)?;
 
         let client_cons_state_path_on_a = ClientConsensusStatePath::new(
-            client_id_on_a.clone(),
+            id_target_client_on_source.clone(),
             msg.proof_height_on_b.revision_number(),
             msg.proof_height_on_b.revision_height(),
         );
         let consensus_state_of_b_on_a =
             client_val_ctx_a.consensus_state(&client_cons_state_path_on_a)?;
         let ack_commitment = compute_ack_commitment(&msg.acknowledgement);
-        let ack_path_on_b = AckPath::new(port_id_on_b, channel_id_on_b, *seq_on_a);
+        let ack_path_on_b = AckPath::new(
+            channel_source_client_on_target.as_ref(),
+            &format!("{source_prefix:?}"),
+            channel_target_client_on_source.as_ref(),
+            &format!("{target_prefix:?}"),
+            seq_on_a,
+        );
 
         // Verify the proof for the packet against the chain store.
-        client_state_of_b_on_a.verify_membership(
-            prefix_on_a,
+        target_client_on_source.verify_membership(
+            target_prefix,
             &msg.proof_acked_on_b,
             consensus_state_of_b_on_a.root(),
-            Path::Ack(ack_path_on_b),
+            Path::AckV2(ack_path_on_b),
             ack_commitment.into_vec(),
         )?;
     }

ibc-eureka-core/ics04-channel/src/handler/recv_packet.rs

@@ -7,7 +7,8 @@ use ibc_eureka_core_channel_types::msgs::MsgRecvPacket;
 use ibc_eureka_core_client::context::prelude::*;
 use ibc_eureka_core_handler_types::events::{IbcEvent, MessageEvent};
 use ibc_eureka_core_host::types::path::{
-    AckPath, ClientConsensusStatePath, CommitmentPath, Path, ReceiptPath, SeqRecvPath,
+    AckPathV2 as AckPath, ClientConsensusStatePath, CommitmentPathV2 as CommitmentPath, Path,
+    ReceiptPathV2 as ReceiptPath, SeqRecvPathV2 as SeqRecvPath,
 };
 use ibc_eureka_core_host::{ExecutionContext, ValidationContext};
 use ibc_eureka_core_router::module::Module;
@@ -35,16 +36,23 @@ where
     let packet = &msg.packet;
     let payload = &packet.payloads[0];
 
-    let (_, target_port) = &payload.header.target_port;
+    let (source_prefix, _source_port) = &payload.header.source_port;
     let channel_source_client_on_target = &packet.header.source_client_on_target;
+    let (target_prefix, _target_port) = &payload.header.target_port;
+    let channel_target_client_on_source = &packet.header.target_client_on_source;
     let seq_on_a = &packet.header.seq_on_a;
 
     // Check if another relayer already relayed the packet.
     // We don't want to fail the transaction in this case.
     {
         let packet_already_received = {
-            let receipt_path_on_b =
-                ReceiptPath::new(target_port, channel_source_client_on_target, *seq_on_a);
+            let receipt_path_on_b = ReceiptPath::new(
+                channel_source_client_on_target.as_ref(),
+                &format!("{source_prefix:?}"),
+                channel_target_client_on_source.as_ref(),
+                &format!("{target_prefix:?}"),
+                seq_on_a,
+            );
             ctx_b.get_packet_receipt(&receipt_path_on_b)?.is_ok()
         };
 
@@ -59,11 +67,22 @@ where
     {
         // `recvPacket` core handler state changes
         {
-            let seq_recv_path_on_b = SeqRecvPath::new(target_port, channel_source_client_on_target);
+            let seq_recv_path_on_b = SeqRecvPath::new(
+                channel_source_client_on_target.as_ref(),
+                &format!("{source_prefix:?}"),
+                channel_target_client_on_source.as_ref(),
+                &format!("{target_prefix:?}"),
+            );
             let next_seq_recv = ctx_b.get_next_sequence_recv(&seq_recv_path_on_b)?;
             ctx_b.store_next_sequence_recv(&seq_recv_path_on_b, next_seq_recv.increment())?;
         }
-        let ack_path_on_b = AckPath::new(target_port, channel_source_client_on_target, *seq_on_a);
+        let ack_path_on_b = AckPath::new(
+            channel_source_client_on_target.as_ref(),
+            &format!("{source_prefix:?}"),
+            channel_target_client_on_source.as_ref(),
+            &format!("{target_prefix:?}"),
+            seq_on_a,
+        );
         // `writeAcknowledgement` handler state changes
         ctx_b.store_packet_acknowledgement(
             &ack_path_on_b,
@@ -105,8 +124,9 @@ where
     let packet = &msg.packet;
     let payload = &packet.payloads[0];
 
-    let (prefix_source, source_port) = &payload.header.source_port;
+    let (source_prefix, _source_port) = &payload.header.source_port;
     let channel_target_client_on_source = &packet.header.target_client_on_source;
+    let (target_prefix, _target_port) = &payload.header.target_port;
     let channel_source_client_on_target = &packet.header.source_client_on_target;
     let seq_on_a = &packet.header.seq_on_a;
     let data = &payload.data;
@@ -157,15 +177,20 @@ where
             &packet.header.timeout_height_on_b,
             &packet.header.timeout_timestamp_on_b,
         );
-        let commitment_path_on_a =
-            CommitmentPath::new(source_port, channel_target_client_on_source, *seq_on_a);
+        let commitment_path_on_a = CommitmentPath::new(
+            channel_source_client_on_target.as_ref(),
+            &format!("{source_prefix:?}"),
+            channel_target_client_on_source.as_ref(),
+            &format!("{target_prefix:?}"),
+            seq_on_a,
+        );
 
         // Verify the proof for the packet against the chain store.
         source_client_on_target.verify_membership(
-            prefix_source,
+            source_prefix,
             &msg.proof_commitment_on_a,
             consensus_state_of_a_on_b.root(),
-            Path::Commitment(commitment_path_on_a),
+            Path::CommitmentV2(commitment_path_on_a),
             expected_commitment_on_a.into_vec(),
         )?;
     }
@@ -191,11 +216,19 @@ where
     let packet = &msg.packet;
     let payload = &packet.payloads[0];
 
-    let (_, target_port) = &payload.header.target_port;
     let channel_source_client_on_target = &packet.header.source_client_on_target;
+    let (target_prefix, _target_port) = &payload.header.target_port;
+    let channel_target_client_on_source = &packet.header.target_client_on_source;
+    let (source_prefix, _source_port) = &payload.header.source_port;
     let seq_on_a = &packet.header.seq_on_a;
 
-    let ack_path_on_b = AckPath::new(target_port, channel_source_client_on_target, *seq_on_a);
+    let ack_path_on_b = AckPath::new(
+        channel_source_client_on_target.as_ref(),
+        &format!("{source_prefix:?}"),
+        channel_target_client_on_source.as_ref(),
+        &format!("{target_prefix:?}"),
+        seq_on_a,
+    );
     if ctx_b.get_packet_acknowledgement(&ack_path_on_b).is_ok() {
         return Err(ChannelError::DuplicateAcknowledgment(*seq_on_a));
     }

ibc-eureka-core/ics04-channel/src/handler/send_packet.rs

@@ -4,7 +4,9 @@ use ibc_eureka_core_channel_types::events::SendPacket;
 use ibc_eureka_core_channel_types::packet::Packet;
 use ibc_eureka_core_client::context::prelude::*;
 use ibc_eureka_core_handler_types::events::{IbcEvent, MessageEvent};
-use ibc_eureka_core_host::types::path::{ClientConsensusStatePath, CommitmentPath, SeqSendPath};
+use ibc_eureka_core_host::types::path::{
+    ClientConsensusStatePath, CommitmentPathV2 as CommitmentPath, SeqSendPathV2 as SeqSendPath,
+};
 use ibc_primitives::prelude::*;
 
 use crate::context::{SendPacketExecutionContext, SendPacketValidationContext};
@@ -32,8 +34,10 @@ pub fn send_packet_validate(
 
     let payload = &packet.payloads[0];
 
-    let (_, source_port) = &payload.header.source_port;
+    let (source_prefix, _source_port) = &payload.header.source_port;
     let channel_target_client_on_source = &packet.header.target_client_on_source;
+    let (target_prefix, _target_port) = &payload.header.target_port;
+    let channel_source_client_on_target = &packet.header.source_client_on_target;
     let seq_on_a = &packet.header.seq_on_a;
 
     let id_target_client_on_source = channel_target_client_on_source.as_ref();
@@ -75,7 +79,12 @@ pub fn send_packet_validate(
     }
 
     // TODO(rano): include full channel identifier in the path
-    let seq_send_path_on_a = SeqSendPath::new(source_port, channel_target_client_on_source);
+    let seq_send_path_on_a = SeqSendPath::new(
+        channel_source_client_on_target.as_ref(),
+        &format!("{source_prefix:?}"),
+        channel_target_client_on_source.as_ref(),
+        &format!("{target_prefix:?}"),
+    );
     let next_seq_send_on_a = ctx_a.get_next_sequence_send(&seq_send_path_on_a)?;
 
     if seq_on_a != &next_seq_send_on_a {
@@ -97,20 +106,33 @@ pub fn send_packet_execute(
 ) -> Result<(), ChannelError> {
     let payload = &packet.payloads[0];
 
-    let (_, source_port) = &payload.header.source_port;
+    let (source_prefix, _source_port) = &payload.header.source_port;
     let channel_target_client_on_source = &packet.header.target_client_on_source;
+    let (target_prefix, _target_port) = &payload.header.target_port;
+    let channel_source_client_on_target = &packet.header.source_client_on_target;
     let seq_on_a = &packet.header.seq_on_a;
     let data = &payload.data;
 
     {
-        let seq_send_path_on_a = SeqSendPath::new(source_port, channel_target_client_on_source);
+        let seq_send_path_on_a = SeqSendPath::new(
+            channel_source_client_on_target.as_ref(),
+            &format!("{source_prefix:?}"),
+            channel_target_client_on_source.as_ref(),
+            &format!("{target_prefix:?}"),
+        );
         let next_seq_send_on_a = ctx_a.get_next_sequence_send(&seq_send_path_on_a)?;
 
         ctx_a.store_next_sequence_send(&seq_send_path_on_a, next_seq_send_on_a.increment())?;
     }
 
     ctx_a.store_packet_commitment(
-        &CommitmentPath::new(source_port, channel_target_client_on_source, *seq_on_a),
+        &CommitmentPath::new(
+            channel_source_client_on_target.as_ref(),
+            &format!("{source_prefix:?}"),
+            channel_target_client_on_source.as_ref(),
+            &format!("{target_prefix:?}"),
+            seq_on_a,
+        ),
         compute_packet_commitment(
             data,
             &packet.header.timeout_height_on_b,