impl: new packet structure for eureka

ibc-eureka-core/ics03-connection/src/handler/conn_open_ack.rs

@@ -8,7 +8,9 @@
 use ibc_eureka_core_connection_types::{ConnectionEnd, Counterparty, State};
 use ibc_eureka_core_handler_types::events::{IbcEvent, MessageEvent};
 use ibc_eureka_core_host::types::identifiers::ClientId;
-use ibc_eureka_core_host::types::path::{ClientConsensusStatePath, ClientStatePath, ConnectionPath, Path};
+use ibc_eureka_core_host::types::path::{
+    ClientConsensusStatePath, ClientStatePath, ConnectionPath, Path,
+};
 use ibc_eureka_core_host::{ExecutionContext, ValidationContext};
 use ibc_primitives::prelude::*;
 use ibc_primitives::proto::{Any, Protobuf};
@@ -16,189 +18,189 @@
 
 use crate::handler::{pack_host_consensus_state, unpack_host_client_state};
 
 pub fn validate<Ctx>(ctx_a: &Ctx, msg: MsgConnectionOpenAck) -> Result<(), ConnectionError>
 where
     Ctx: ValidationContext,
     <Ctx::HostClientState as TryFrom<Any>>::Error: Into<ClientError>,
 {
     let vars = LocalVars::new(ctx_a, &msg)?;
     validate_impl(ctx_a, &msg, &vars)
 }
 
 fn validate_impl<Ctx>(
     ctx_a: &Ctx,
     msg: &MsgConnectionOpenAck,
     vars: &LocalVars,
 ) -> Result<(), ConnectionError>
 where
     Ctx: ValidationContext,
     <Ctx::HostClientState as TryFrom<Any>>::Error: Into<ClientError>,
 {
     ctx_a.validate_message_signer(&msg.signer)?;
 
     let host_height = ctx_a.host_height()?;
 
     if msg.consensus_height_of_a_on_b > host_height {
         return Err(ConnectionError::InsufficientConsensusHeight {
             target_height: msg.consensus_height_of_a_on_b,
             current_height: host_height,
         });
     }
 
     let client_val_ctx_a = ctx_a.get_client_validation_context();
 
     let client_state_of_a_on_b = unpack_host_client_state::<Ctx::HostClientState>(
         msg.client_state_of_a_on_b.clone(),
         vars.client_id_on_b(),
     )?;
 
     ctx_a.validate_self_client(client_state_of_a_on_b)?;
 
     msg.version
         .verify_is_supported(vars.conn_end_on_a.versions())?;
 
     vars.conn_end_on_a.verify_state_matches(&State::Init)?;
 
     // Proof verification.
     {
         let client_state_of_b_on_a = client_val_ctx_a.client_state(vars.client_id_on_a())?;
 
         client_state_of_b_on_a
             .status(client_val_ctx_a, vars.client_id_on_a())?
             .verify_is_active()?;
 
         client_state_of_b_on_a.validate_proof_height(msg.proofs_height_on_b)?;
 
         let client_cons_state_path_on_a = ClientConsensusStatePath::new(
             vars.client_id_on_a().clone(),
             msg.proofs_height_on_b.revision_number(),
             msg.proofs_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 prefix_on_a = ctx_a.commitment_prefix();
         let prefix_on_b = vars.conn_end_on_a.counterparty().prefix();
 
         {
             let expected_conn_end_on_b = ConnectionEnd::new(
                 State::TryOpen,
                 vars.client_id_on_b().clone(),
                 Counterparty::new(
                     vars.client_id_on_a().clone(),
                     Some(msg.conn_id_on_a.clone()),
                     prefix_on_a,
                 ),
                 vec![msg.version.clone()],
                 vars.conn_end_on_a.delay_period(),
             )?;
 
             client_state_of_b_on_a.verify_membership(
                 prefix_on_b,
                 &msg.proof_conn_end_on_b,
                 consensus_state_of_b_on_a.root(),
                 Path::Connection(ConnectionPath::new(&msg.conn_id_on_b)),
                 expected_conn_end_on_b.encode_vec(),
             )?;
         }
 
         client_state_of_b_on_a.verify_membership(
             prefix_on_b,
             &msg.proof_client_state_of_a_on_b,
             consensus_state_of_b_on_a.root(),
             Path::ClientState(ClientStatePath::new(vars.client_id_on_b().clone())),
             msg.client_state_of_a_on_b.to_vec(),
         )?;
 
         let expected_consensus_state_of_a_on_b =
             ctx_a.host_consensus_state(&msg.consensus_height_of_a_on_b)?;
 
         let stored_consensus_state_of_a_on_b =
             pack_host_consensus_state(expected_consensus_state_of_a_on_b, vars.client_id_on_b());
 
         let client_cons_state_path_on_b = ClientConsensusStatePath::new(
             vars.client_id_on_b().clone(),
             msg.consensus_height_of_a_on_b.revision_number(),
             msg.consensus_height_of_a_on_b.revision_height(),
         );
 
         client_state_of_b_on_a.verify_membership(
             prefix_on_b,
             &msg.proof_consensus_state_of_a_on_b,
             consensus_state_of_b_on_a.root(),
             Path::ClientConsensusState(client_cons_state_path_on_b),
             stored_consensus_state_of_a_on_b.to_vec(),
         )?;
     }
 
     Ok(())
 }
 
 pub fn execute<Ctx>(ctx_a: &mut Ctx, msg: MsgConnectionOpenAck) -> Result<(), ConnectionError>
 where
     Ctx: ExecutionContext,
 {
     let vars = LocalVars::new(ctx_a, &msg)?;
     execute_impl(ctx_a, msg, vars)
 }
 
 fn execute_impl<Ctx>(
     ctx_a: &mut Ctx,
     msg: MsgConnectionOpenAck,
     vars: LocalVars,
 ) -> Result<(), ConnectionError>
 where
     Ctx: ExecutionContext,
 {
     let event = IbcEvent::OpenAckConnection(OpenAck::new(
         msg.conn_id_on_a.clone(),
         vars.client_id_on_a().clone(),
         msg.conn_id_on_b.clone(),
         vars.client_id_on_b().clone(),
     ));
     ctx_a.emit_ibc_event(IbcEvent::Message(MessageEvent::Connection))?;
     ctx_a.emit_ibc_event(event)?;
 
     ctx_a.log_message("success: conn_open_ack verification passed".to_string())?;
 
     {
         let new_conn_end_on_a = {
             let mut counterparty = vars.conn_end_on_a.counterparty().clone();
             counterparty.connection_id = Some(msg.conn_id_on_b.clone());
 
             let mut new_conn_end_on_a = vars.conn_end_on_a;
             new_conn_end_on_a.set_state(State::Open);
             new_conn_end_on_a.set_version(msg.version.clone());
             new_conn_end_on_a.set_counterparty(counterparty);
             new_conn_end_on_a
         };
 
         ctx_a.store_connection(&ConnectionPath::new(&msg.conn_id_on_a), new_conn_end_on_a)?;
     }
 
     Ok(())
 }
 
 struct LocalVars {
     conn_end_on_a: ConnectionEnd,
 }
 
 impl LocalVars {
     fn new<Ctx>(ctx_a: &Ctx, msg: &MsgConnectionOpenAck) -> Result<Self, ConnectionError>
     where
         Ctx: ValidationContext,
     {
         Ok(LocalVars {
             conn_end_on_a: ctx_a.connection_end(&msg.conn_id_on_a)?,
         })
     }
 
     fn client_id_on_a(&self) -> &ClientId {
         self.conn_end_on_a.client_id()
     }
 
     fn client_id_on_b(&self) -> &ClientId {
         self.conn_end_on_a.counterparty().client_id()
     }
 }

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

@@ -16,188 +16,193 @@
 use ibc_eureka_core_router::module::Module;
 use ibc_primitives::prelude::*;
 
 pub fn acknowledgement_packet_validate<ValCtx>(
     ctx_a: &ValCtx,
     module: &dyn Module,
     msg: MsgAcknowledgement,
 ) -> Result<(), ChannelError>
 where
     ValCtx: ValidationContext,
 {
     validate(ctx_a, &msg)?;
 
     module.on_acknowledgement_packet_validate(&msg.packet, &msg.acknowledgement, &msg.signer)
 }
 
 pub fn acknowledgement_packet_execute<ExecCtx>(
     ctx_a: &mut ExecCtx,
     module: &mut dyn Module,
     msg: MsgAcknowledgement,
 ) -> Result<(), ChannelError>
 where
     ExecCtx: ExecutionContext,
 {
-    let chan_end_path_on_a =
-        ChannelEndPath::new(&msg.packet.port_id_on_a, &msg.packet.chan_id_on_a);
+    let payload = &msg.packet.payloads[0];
+
+    let port_id_on_a = &payload.header.source_port.1;
+    let channel_id_on_a = &msg.packet.header.source_client;
+    let seq_on_a = &msg.packet.header.seq_on_a;
+
+    let chan_end_path_on_a = ChannelEndPath::new(port_id_on_a, channel_id_on_a);
     let chan_end_on_a = ctx_a.channel_end(&chan_end_path_on_a)?;
     let conn_id_on_a = &chan_end_on_a.connection_hops()[0];
 
     // In all cases, this event is emitted
     let event = IbcEvent::AcknowledgePacket(AcknowledgePacket::new(
         msg.packet.clone(),
         chan_end_on_a.ordering,
         conn_id_on_a.clone(),
     ));
     ctx_a.emit_ibc_event(IbcEvent::Message(MessageEvent::Channel))?;
     ctx_a.emit_ibc_event(event)?;
 
-    let commitment_path_on_a = CommitmentPath::new(
-        &msg.packet.port_id_on_a,
-        &msg.packet.chan_id_on_a,
-        msg.packet.seq_on_a,
-    );
+    let commitment_path_on_a =
+        CommitmentPath::new(port_id_on_a, channel_id_on_a, msg.packet.header.seq_on_a);
 
     // check if we're in the NO-OP case
     if ctx_a.get_packet_commitment(&commitment_path_on_a).is_err() {
         // This error indicates that the timeout has already been relayed
         // or there is a misconfigured relayer attempting to prove a timeout
         // for a packet never sent. Core IBC will treat this error as a no-op in order to
         // prevent an entire relay transaction from failing and consuming unnecessary fees.
         return Ok(());
     };
 
     let (extras, cb_result) =
         module.on_acknowledgement_packet_execute(&msg.packet, &msg.acknowledgement, &msg.signer);
 
     cb_result?;
 
     // apply state changes
     {
         ctx_a.delete_packet_commitment(&commitment_path_on_a)?;
 
         if let Order::Ordered = chan_end_on_a.ordering {
             // Note: in validation, we verified that `msg.packet.sequence == nextSeqRecv`
             // (where `nextSeqRecv` is the value in the store)
-            let seq_ack_path_on_a =
-                SeqAckPath::new(&msg.packet.port_id_on_a, &msg.packet.chan_id_on_a);
-            ctx_a.store_next_sequence_ack(&seq_ack_path_on_a, msg.packet.seq_on_a.increment())?;
+            let seq_ack_path_on_a = SeqAckPath::new(port_id_on_a, channel_id_on_a);
+            ctx_a.store_next_sequence_ack(&seq_ack_path_on_a, (*seq_on_a).increment())?;
         }
     }
 
     // emit events and logs
     {
         ctx_a.log_message("success: packet acknowledgement".to_string())?;
 
         // Note: Acknowledgement event was emitted at the beginning
 
         for module_event in extras.events {
             ctx_a.emit_ibc_event(IbcEvent::Module(module_event))?
         }
 
         for log_message in extras.log {
             ctx_a.log_message(log_message)?;
         }
     }
 
     Ok(())
 }
 
 fn validate<Ctx>(ctx_a: &Ctx, msg: &MsgAcknowledgement) -> Result<(), ChannelError>
 where
     Ctx: ValidationContext,
 {
     ctx_a.validate_message_signer(&msg.signer)?;
 
     let packet = &msg.packet;
-    let chan_end_path_on_a = ChannelEndPath::new(&packet.port_id_on_a, &packet.chan_id_on_a);
+    let payload = &packet.payloads[0];
+
+    let port_id_on_a = &payload.header.source_port.1;
+    let channel_id_on_a = &packet.header.source_client;
+    let port_id_on_b = &payload.header.target_port.1;
+    let channel_id_on_b = &packet.header.target_client;
+    let seq_on_a = &packet.header.seq_on_a;
+    let data = &payload.data;
+
+    let chan_end_path_on_a = ChannelEndPath::new(port_id_on_a, channel_id_on_a);
     let chan_end_on_a = ctx_a.channel_end(&chan_end_path_on_a)?;
 
     chan_end_on_a.verify_state_matches(&ChannelState::Open)?;
 
-    let counterparty = Counterparty::new(
-        packet.port_id_on_b.clone(),
-        Some(packet.chan_id_on_b.clone()),
-    );
+    let counterparty = Counterparty::new(port_id_on_b.clone(), Some(channel_id_on_b.clone()));
 
     chan_end_on_a.verify_counterparty_matches(&counterparty)?;
 
     let conn_id_on_a = &chan_end_on_a.connection_hops()[0];
     let conn_end_on_a = ctx_a.connection_end(conn_id_on_a)?;
 
     conn_end_on_a.verify_state_matches(&ConnectionState::Open)?;
 
-    let commitment_path_on_a =
-        CommitmentPath::new(&packet.port_id_on_a, &packet.chan_id_on_a, packet.seq_on_a);
+    let commitment_path_on_a = CommitmentPath::new(port_id_on_a, channel_id_on_a, *seq_on_a);
 
     // Verify packet commitment
     let Ok(commitment_on_a) = ctx_a.get_packet_commitment(&commitment_path_on_a) else {
         // This error indicates that the timeout has already been relayed
         // or there is a misconfigured relayer attempting to prove a timeout
         // for a packet never sent. Core IBC will treat this error as a no-op in order to
         // prevent an entire relay transaction from failing and consuming unnecessary fees.
         return Ok(());
     };
 
     let expected_commitment_on_a = compute_packet_commitment(
-        &packet.data,
-        &packet.timeout_height_on_b,
-        &packet.timeout_timestamp_on_b,
+        data,
+        &packet.header.timeout_height_on_b,
+        &packet.header.timeout_timestamp_on_b,
     );
 
     if commitment_on_a != expected_commitment_on_a {
         return Err(ChannelError::MismatchedPacketCommitment {
             actual: commitment_on_a,
             expected: expected_commitment_on_a,
         });
     }
 
     if let Order::Ordered = chan_end_on_a.ordering {
-        let seq_ack_path_on_a = SeqAckPath::new(&packet.port_id_on_a, &packet.chan_id_on_a);
+        let seq_ack_path_on_a = SeqAckPath::new(port_id_on_a, channel_id_on_a);
         let next_seq_ack = ctx_a.get_next_sequence_ack(&seq_ack_path_on_a)?;
-        if packet.seq_on_a != next_seq_ack {
+        if seq_on_a != &next_seq_ack {
             return Err(ChannelError::MismatchedPacketSequence {
-                actual: packet.seq_on_a,
+                actual: *seq_on_a,
                 expected: next_seq_ack,
             });
         }
     }
 
     // Verify proofs
     {
         let client_id_on_a = conn_end_on_a.client_id();
 
         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)?;
 
         client_state_of_b_on_a
             .status(ctx_a.get_client_validation_context(), client_id_on_a)?
             .verify_is_active()?;
 
         client_state_of_b_on_a.validate_proof_height(msg.proof_height_on_b)?;
 
         let client_cons_state_path_on_a = ClientConsensusStatePath::new(
             client_id_on_a.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(&packet.port_id_on_b, &packet.chan_id_on_b, packet.seq_on_a);
+        let ack_path_on_b = AckPath::new(port_id_on_b, channel_id_on_b, *seq_on_a);
 
         verify_conn_delay_passed(ctx_a, msg.proof_height_on_b, &conn_end_on_a)?;
 
         // Verify the proof for the packet against the chain store.
         client_state_of_b_on_a.verify_membership(
             conn_end_on_a.counterparty().prefix(),
             &msg.proof_acked_on_b,
             consensus_state_of_b_on_a.root(),
             Path::Ack(ack_path_on_b),
             ack_commitment.into_vec(),
         )?;
     }
 
     Ok(())
 }

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

@@ -1,5 +1,7 @@
 //! Protocol logic specific to ICS4 messages of type `MsgChannelOpenAck`.
-use ibc_eureka_core_channel_types::channel::{ChannelEnd, Counterparty, State, State as ChannelState};
+use ibc_eureka_core_channel_types::channel::{
+    ChannelEnd, Counterparty, State, State as ChannelState,
+};
 use ibc_eureka_core_channel_types::error::ChannelError;
 use ibc_eureka_core_channel_types::events::OpenAck;
 use ibc_eureka_core_channel_types::msgs::MsgChannelOpenAck;
@@ -13,145 +15,145 @@
 use ibc_primitives::prelude::*;
 use ibc_primitives::proto::Protobuf;
 
 pub fn chan_open_ack_validate<ValCtx>(
     ctx_a: &ValCtx,
     module: &dyn Module,
     msg: MsgChannelOpenAck,
 ) -> Result<(), ChannelError>
 where
     ValCtx: ValidationContext,
 {
     validate(ctx_a, &msg)?;
 
     module.on_chan_open_ack_validate(&msg.port_id_on_a, &msg.chan_id_on_a, &msg.version_on_b)?;
 
     Ok(())
 }
 
 pub fn chan_open_ack_execute<ExecCtx>(
     ctx_a: &mut ExecCtx,
     module: &mut dyn Module,
     msg: MsgChannelOpenAck,
 ) -> Result<(), ChannelError>
 where
     ExecCtx: ExecutionContext,
 {
     let extras =
         module.on_chan_open_ack_execute(&msg.port_id_on_a, &msg.chan_id_on_a, &msg.version_on_b)?;
     let chan_end_path_on_a = ChannelEndPath::new(&msg.port_id_on_a, &msg.chan_id_on_a);
     let chan_end_on_a = ctx_a.channel_end(&chan_end_path_on_a)?;
 
     // state changes
     {
         let chan_end_on_a = {
             let mut chan_end_on_a = chan_end_on_a.clone();
 
             chan_end_on_a.set_state(State::Open);
             chan_end_on_a.set_version(msg.version_on_b.clone());
             chan_end_on_a.set_counterparty_channel_id(msg.chan_id_on_b.clone());
 
             chan_end_on_a
         };
         ctx_a.store_channel(&chan_end_path_on_a, chan_end_on_a)?;
     }
 
     // emit events and logs
     {
         ctx_a.log_message("success: channel open ack".to_string())?;
 
         let core_event = {
             let port_id_on_b = chan_end_on_a.counterparty().port_id.clone();
             let conn_id_on_a = chan_end_on_a.connection_hops[0].clone();
 
             IbcEvent::OpenAckChannel(OpenAck::new(
                 msg.port_id_on_a.clone(),
                 msg.chan_id_on_a.clone(),
                 port_id_on_b,
                 msg.chan_id_on_b,
                 conn_id_on_a,
             ))
         };
         ctx_a.emit_ibc_event(IbcEvent::Message(MessageEvent::Channel))?;
         ctx_a.emit_ibc_event(core_event)?;
 
         for module_event in extras.events {
             ctx_a.emit_ibc_event(IbcEvent::Module(module_event))?;
         }
 
         for log_message in extras.log {
             ctx_a.log_message(log_message)?;
         }
     }
 
     Ok(())
 }
 
 fn validate<Ctx>(ctx_a: &Ctx, msg: &MsgChannelOpenAck) -> Result<(), ChannelError>
 where
     Ctx: ValidationContext,
 {
     ctx_a.validate_message_signer(&msg.signer)?;
 
     let chan_end_path_on_a = ChannelEndPath::new(&msg.port_id_on_a, &msg.chan_id_on_a);
     let chan_end_on_a = ctx_a.channel_end(&chan_end_path_on_a)?;
 
     // Validate that the channel end is in a state where it can be ack.
     chan_end_on_a.verify_state_matches(&ChannelState::Init)?;
 
     // An OPEN IBC connection running on the local (host) chain should exist.
     chan_end_on_a.verify_connection_hops_length()?;
 
     let conn_end_on_a = ctx_a.connection_end(&chan_end_on_a.connection_hops()[0])?;
 
     conn_end_on_a.verify_state_matches(&ConnectionState::Open)?;
 
     // Verify proofs
     {
         let client_id_on_a = conn_end_on_a.client_id();
         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)?;
 
         client_state_of_b_on_a
             .status(ctx_a.get_client_validation_context(), client_id_on_a)?
             .verify_is_active()?;
 
         client_state_of_b_on_a.validate_proof_height(msg.proof_height_on_b)?;
 
         let client_cons_state_path_on_a = ClientConsensusStatePath::new(
             client_id_on_a.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 prefix_on_b = conn_end_on_a.counterparty().prefix();
         let port_id_on_b = &chan_end_on_a.counterparty().port_id;
         let conn_id_on_b = conn_end_on_a
             .counterparty()
             .connection_id()
             .ok_or(ConnectionError::MissingCounterparty)?;
 
         let expected_chan_end_on_b = ChannelEnd::new(
             ChannelState::TryOpen,
             // Note: Both ends of a channel must have the same ordering, so it's
             // fine to use A's ordering here
             *chan_end_on_a.ordering(),
             Counterparty::new(msg.port_id_on_a.clone(), Some(msg.chan_id_on_a.clone())),
             vec![conn_id_on_b.clone()],
             msg.version_on_b.clone(),
         )?;
         let chan_end_path_on_b = ChannelEndPath::new(port_id_on_b, &msg.chan_id_on_b);
 
         // Verify the proof for the channel state against the expected channel end.
         // A counterparty channel id of None in not possible, and is checked by validate_basic in msg.
         client_state_of_b_on_a.verify_membership(
             prefix_on_b,
             &msg.proof_chan_end_on_b,
             consensus_state_of_b_on_a.root(),
             Path::ChannelEnd(chan_end_path_on_b),
             expected_chan_end_on_b.encode_vec(),
         )?;
     }
 
     Ok(())
 }

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

@@ -1,6 +1,8 @@
 //! Protocol logic specific to ICS4 messages of type `MsgChannelOpenConfirm`.
 
-use ibc_eureka_core_channel_types::channel::{ChannelEnd, Counterparty, State, State as ChannelState};
+use ibc_eureka_core_channel_types::channel::{
+    ChannelEnd, Counterparty, State, State as ChannelState,
+};
 use ibc_eureka_core_channel_types::error::ChannelError;
 use ibc_eureka_core_channel_types::events::OpenConfirm;
 use ibc_eureka_core_channel_types::msgs::MsgChannelOpenConfirm;
@@ -14,147 +16,147 @@
 use ibc_primitives::prelude::*;
 use ibc_primitives::proto::Protobuf;
 
 pub fn chan_open_confirm_validate<ValCtx>(
     ctx_b: &ValCtx,
     module: &dyn Module,
     msg: MsgChannelOpenConfirm,
 ) -> Result<(), ChannelError>
 where
     ValCtx: ValidationContext,
 {
     validate(ctx_b, &msg)?;
 
     module.on_chan_open_confirm_validate(&msg.port_id_on_b, &msg.chan_id_on_b)?;
 
     Ok(())
 }
 
 pub fn chan_open_confirm_execute<ExecCtx>(
     ctx_b: &mut ExecCtx,
     module: &mut dyn Module,
     msg: MsgChannelOpenConfirm,
 ) -> Result<(), ChannelError>
 where
     ExecCtx: ExecutionContext,
 {
     let extras = module.on_chan_open_confirm_execute(&msg.port_id_on_b, &msg.chan_id_on_b)?;
     let chan_end_path_on_b = ChannelEndPath::new(&msg.port_id_on_b, &msg.chan_id_on_b);
     let chan_end_on_b = ctx_b.channel_end(&chan_end_path_on_b)?;
 
     // state changes
     {
         let chan_end_on_b = {
             let mut chan_end_on_b = chan_end_on_b.clone();
             chan_end_on_b.set_state(State::Open);
 
             chan_end_on_b
         };
         ctx_b.store_channel(&chan_end_path_on_b, chan_end_on_b)?;
     }
 
     // emit events and logs
     {
         ctx_b.log_message("success: channel open confirm".to_string())?;
 
         let conn_id_on_b = chan_end_on_b.connection_hops[0].clone();
         let port_id_on_a = chan_end_on_b.counterparty().port_id.clone();
         let chan_id_on_a = chan_end_on_b
             .counterparty()
             .channel_id
             .clone()
             .ok_or(ChannelError::MissingCounterparty)?;
 
         let core_event = IbcEvent::OpenConfirmChannel(OpenConfirm::new(
             msg.port_id_on_b.clone(),
             msg.chan_id_on_b.clone(),
             port_id_on_a,
             chan_id_on_a,
             conn_id_on_b,
         ));
         ctx_b.emit_ibc_event(IbcEvent::Message(MessageEvent::Channel))?;
         ctx_b.emit_ibc_event(core_event)?;
 
         for module_event in extras.events {
             ctx_b.emit_ibc_event(IbcEvent::Module(module_event))?;
         }
 
         for log_message in extras.log {
             ctx_b.log_message(log_message)?;
         }
     }
 
     Ok(())
 }
 
 fn validate<Ctx>(ctx_b: &Ctx, msg: &MsgChannelOpenConfirm) -> Result<(), ChannelError>
 where
     Ctx: ValidationContext,
 {
     ctx_b.validate_message_signer(&msg.signer)?;
 
     // Unwrap the old channel end and validate it against the message.
     let chan_end_path_on_b = ChannelEndPath::new(&msg.port_id_on_b, &msg.chan_id_on_b);
     let chan_end_on_b = ctx_b.channel_end(&chan_end_path_on_b)?;
 
     // Validate that the channel end is in a state where it can be confirmed.
     chan_end_on_b.verify_state_matches(&ChannelState::TryOpen)?;
 
     // An OPEN IBC connection running on the local (host) chain should exist.
     chan_end_on_b.verify_connection_hops_length()?;
 
     let conn_end_on_b = ctx_b.connection_end(&chan_end_on_b.connection_hops()[0])?;
 
     conn_end_on_b.verify_state_matches(&ConnectionState::Open)?;
 
     // Verify proofs
     {
         let client_id_on_b = conn_end_on_b.client_id();
         let client_val_ctx_b = ctx_b.get_client_validation_context();
         let client_state_of_a_on_b = client_val_ctx_b.client_state(client_id_on_b)?;
 
         client_state_of_a_on_b
             .status(ctx_b.get_client_validation_context(), client_id_on_b)?
             .verify_is_active()?;
 
         client_state_of_a_on_b.validate_proof_height(msg.proof_height_on_a)?;
 
         let client_cons_state_path_on_b = ClientConsensusStatePath::new(
             client_id_on_b.clone(),
             msg.proof_height_on_a.revision_number(),
             msg.proof_height_on_a.revision_height(),
         );
         let consensus_state_of_a_on_b =
             client_val_ctx_b.consensus_state(&client_cons_state_path_on_b)?;
         let prefix_on_a = conn_end_on_b.counterparty().prefix();
         let port_id_on_a = &chan_end_on_b.counterparty().port_id;
         let chan_id_on_a = chan_end_on_b
             .counterparty()
             .channel_id()
             .ok_or(ChannelError::MissingCounterparty)?;
         let conn_id_on_a = conn_end_on_b
             .counterparty()
             .connection_id()
             .ok_or(ConnectionError::MissingCounterparty)?;
 
         let expected_chan_end_on_a = ChannelEnd::new(
             ChannelState::Open,
             *chan_end_on_b.ordering(),
             Counterparty::new(msg.port_id_on_b.clone(), Some(msg.chan_id_on_b.clone())),
             vec![conn_id_on_a.clone()],
             chan_end_on_b.version.clone(),
         )?;
         let chan_end_path_on_a = ChannelEndPath::new(port_id_on_a, chan_id_on_a);
 
         // Verify the proof for the channel state against the expected channel end.
         // A counterparty channel id of None in not possible, and is checked in msg.
         client_state_of_a_on_b.verify_membership(
             prefix_on_a,
             &msg.proof_chan_end_on_a,
             consensus_state_of_a_on_b.root(),
             Path::ChannelEnd(chan_end_path_on_a),
             expected_chan_end_on_a.encode_vec(),
         )?;
     }
 
     Ok(())
 }

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

@@ -1,5 +1,7 @@
 //! Protocol logic specific to ICS4 messages of type `MsgChannelOpenInit`.
 
+use core::str::FromStr;
+
 use ibc_eureka_core_channel_types::channel::{ChannelEnd, Counterparty, State};
 use ibc_eureka_core_channel_types::error::ChannelError;
 use ibc_eureka_core_channel_types::events::OpenInit;
@@ -12,124 +14,126 @@
 use ibc_eureka_core_router::module::Module;
 use ibc_primitives::prelude::*;
 
 pub fn chan_open_init_validate<ValCtx>(
     ctx_a: &ValCtx,
     module: &dyn Module,
     msg: MsgChannelOpenInit,
 ) -> Result<(), ChannelError>
 where
     ValCtx: ValidationContext,
 {
     validate(ctx_a, &msg)?;
-    let chan_id_on_a = ChannelId::new(ctx_a.channel_counter()?);
+    // todo(rano): hack
+    let chan_id_on_a = ChannelId::from_str("00-dummy-0")?;
 
     module.on_chan_open_init_validate(
         msg.ordering,
         &msg.connection_hops_on_a,
         &msg.port_id_on_a,
         &chan_id_on_a,
         &Counterparty::new(msg.port_id_on_b.clone(), None),
         &msg.version_proposal,
     )?;
 
     Ok(())
 }
 
 pub fn chan_open_init_execute<ExecCtx>(
     ctx_a: &mut ExecCtx,
     module: &mut dyn Module,
     msg: MsgChannelOpenInit,
 ) -> Result<(), ChannelError>
 where
     ExecCtx: ExecutionContext,
 {
-    let chan_id_on_a = ChannelId::new(ctx_a.channel_counter()?);
+    // todo(rano): hack
+    let chan_id_on_a = ChannelId::from_str("00-dummy-0")?;
     let (extras, version) = module.on_chan_open_init_execute(
         msg.ordering,
         &msg.connection_hops_on_a,
         &msg.port_id_on_a,
         &chan_id_on_a,
         &Counterparty::new(msg.port_id_on_b.clone(), None),
         &msg.version_proposal,
     )?;
 
     let conn_id_on_a = msg.connection_hops_on_a[0].clone();
 
     // state changes
     {
         let chan_end_on_a = ChannelEnd::new(
             State::Init,
             msg.ordering,
             Counterparty::new(msg.port_id_on_b.clone(), None),
             msg.connection_hops_on_a.clone(),
             msg.version_proposal.clone(),
         )?;
         let chan_end_path_on_a = ChannelEndPath::new(&msg.port_id_on_a, &chan_id_on_a);
         ctx_a.store_channel(&chan_end_path_on_a, chan_end_on_a)?;
 
         ctx_a.increase_channel_counter()?;
 
         // Initialize send, recv, and ack sequence numbers.
         let seq_send_path = SeqSendPath::new(&msg.port_id_on_a, &chan_id_on_a);
         ctx_a.store_next_sequence_send(&seq_send_path, 1.into())?;
 
         let seq_recv_path = SeqRecvPath::new(&msg.port_id_on_a, &chan_id_on_a);
         ctx_a.store_next_sequence_recv(&seq_recv_path, 1.into())?;
 
         let seq_ack_path = SeqAckPath::new(&msg.port_id_on_a, &chan_id_on_a);
         ctx_a.store_next_sequence_ack(&seq_ack_path, 1.into())?;
     }
 
     // emit events and logs
     {
         ctx_a.log_message(format!(
             "success: channel open init with channel identifier: {chan_id_on_a}"
         ))?;
         let core_event = IbcEvent::OpenInitChannel(OpenInit::new(
             msg.port_id_on_a.clone(),
             chan_id_on_a.clone(),
             msg.port_id_on_b,
             conn_id_on_a,
             version,
         ));
         ctx_a.emit_ibc_event(IbcEvent::Message(MessageEvent::Channel))?;
         ctx_a.emit_ibc_event(core_event)?;
 
         for module_event in extras.events {
             ctx_a.emit_ibc_event(IbcEvent::Module(module_event))?;
         }
 
         for log_message in extras.log {
             ctx_a.log_message(log_message)?;
         }
     }
 
     Ok(())
 }
 
 fn validate<Ctx>(ctx_a: &Ctx, msg: &MsgChannelOpenInit) -> Result<(), ChannelError>
 where
     Ctx: ValidationContext,
 {
     ctx_a.validate_message_signer(&msg.signer)?;
 
     msg.verify_connection_hops_length()?;
     // An IBC connection running on the local (host) chain should exist.
     let conn_end_on_a = ctx_a.connection_end(&msg.connection_hops_on_a[0])?;
 
     // Note: Not needed check if the connection end is OPEN. Optimistic channel handshake is allowed.
 
     let client_id_on_a = conn_end_on_a.client_id();
     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)?;
 
     client_state_of_b_on_a
         .status(ctx_a.get_client_validation_context(), client_id_on_a)?
         .verify_is_active()?;
 
     let conn_version = conn_end_on_a.versions();
 
     conn_version[0].verify_feature_supported(msg.ordering.to_string())?;
 
     Ok(())
 }

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

@@ -1,5 +1,7 @@
 //! Protocol logic specific to ICS4 messages of type `MsgChannelOpenTry`.
 
+use core::str::FromStr;
+
 use ibc_eureka_core_channel_types::channel::{ChannelEnd, Counterparty, State as ChannelState};
 use ibc_eureka_core_channel_types::error::ChannelError;
 use ibc_eureka_core_channel_types::events::OpenTry;
@@ -17,166 +19,168 @@
 use ibc_primitives::prelude::*;
 use ibc_primitives::proto::Protobuf;
 
 pub fn chan_open_try_validate<ValCtx>(
     ctx_b: &ValCtx,
     module: &dyn Module,
     msg: MsgChannelOpenTry,
 ) -> Result<(), ChannelError>
 where
     ValCtx: ValidationContext,
 {
     validate(ctx_b, &msg)?;
 
-    let chan_id_on_b = ChannelId::new(ctx_b.channel_counter()?);
+    // todo(rano): hack
+    let chan_id_on_b = ChannelId::from_str("00-dummy-0")?;
 
     module.on_chan_open_try_validate(
         msg.ordering,
         &msg.connection_hops_on_b,
         &msg.port_id_on_b,
         &chan_id_on_b,
         &Counterparty::new(msg.port_id_on_a.clone(), Some(msg.chan_id_on_a.clone())),
         &msg.version_supported_on_a,
     )?;
 
     Ok(())
 }
 
 pub fn chan_open_try_execute<ExecCtx>(
     ctx_b: &mut ExecCtx,
     module: &mut dyn Module,
     msg: MsgChannelOpenTry,
 ) -> Result<(), ChannelError>
 where
     ExecCtx: ExecutionContext,
 {
-    let chan_id_on_b = ChannelId::new(ctx_b.channel_counter()?);
+    // todo(rano): hack
+    let chan_id_on_b = ChannelId::from_str("00-dummy-0")?;
     let (extras, version) = module.on_chan_open_try_execute(
         msg.ordering,
         &msg.connection_hops_on_b,
         &msg.port_id_on_b,
         &chan_id_on_b,
         &Counterparty::new(msg.port_id_on_a.clone(), Some(msg.chan_id_on_a.clone())),
         &msg.version_supported_on_a,
     )?;
 
     let conn_id_on_b = msg.connection_hops_on_b[0].clone();
 
     // state changes
     {
         let chan_end_on_b = ChannelEnd::new(
             ChannelState::TryOpen,
             msg.ordering,
             Counterparty::new(msg.port_id_on_a.clone(), Some(msg.chan_id_on_a.clone())),
             msg.connection_hops_on_b.clone(),
             version.clone(),
         )?;
 
         let chan_end_path_on_b = ChannelEndPath::new(&msg.port_id_on_b, &chan_id_on_b);
         ctx_b.store_channel(&chan_end_path_on_b, chan_end_on_b)?;
         ctx_b.increase_channel_counter()?;
 
         // Initialize send, recv, and ack sequence numbers.
         let seq_send_path = SeqSendPath::new(&msg.port_id_on_b, &chan_id_on_b);
         ctx_b.store_next_sequence_send(&seq_send_path, 1.into())?;
 
         let seq_recv_path = SeqRecvPath::new(&msg.port_id_on_b, &chan_id_on_b);
         ctx_b.store_next_sequence_recv(&seq_recv_path, 1.into())?;
 
         let seq_ack_path = SeqAckPath::new(&msg.port_id_on_b, &chan_id_on_b);
         ctx_b.store_next_sequence_ack(&seq_ack_path, 1.into())?;
     }
 
     // emit events and logs
     {
         ctx_b.log_message(format!(
             "success: channel open try with channel identifier: {chan_id_on_b}"
         ))?;
 
         let core_event = IbcEvent::OpenTryChannel(OpenTry::new(
             msg.port_id_on_b.clone(),
             chan_id_on_b.clone(),
             msg.port_id_on_a.clone(),
             msg.chan_id_on_a.clone(),
             conn_id_on_b,
             version,
         ));
         ctx_b.emit_ibc_event(IbcEvent::Message(MessageEvent::Channel))?;
         ctx_b.emit_ibc_event(core_event)?;
 
         for module_event in extras.events {
             ctx_b.emit_ibc_event(IbcEvent::Module(module_event))?;
         }
 
         for log_message in extras.log {
             ctx_b.log_message(log_message)?;
         }
     }
 
     Ok(())
 }
 
 fn validate<Ctx>(ctx_b: &Ctx, msg: &MsgChannelOpenTry) -> Result<(), ChannelError>
 where
     Ctx: ValidationContext,
 {
     ctx_b.validate_message_signer(&msg.signer)?;
 
     msg.verify_connection_hops_length()?;
 
     let conn_end_on_b = ctx_b.connection_end(&msg.connection_hops_on_b[0])?;
 
     conn_end_on_b.verify_state_matches(&ConnectionState::Open)?;
 
     let conn_version = conn_end_on_b.versions();
 
     conn_version[0].verify_feature_supported(msg.ordering.to_string())?;
 
     // Verify proofs
     {
         let client_id_on_b = conn_end_on_b.client_id();
         let client_val_ctx_b = ctx_b.get_client_validation_context();
         let client_state_of_a_on_b = client_val_ctx_b.client_state(client_id_on_b)?;
 
         client_state_of_a_on_b
             .status(ctx_b.get_client_validation_context(), client_id_on_b)?
             .verify_is_active()?;
 
         client_state_of_a_on_b.validate_proof_height(msg.proof_height_on_a)?;
 
         let client_cons_state_path_on_b = ClientConsensusStatePath::new(
             client_id_on_b.clone(),
             msg.proof_height_on_a.revision_number(),
             msg.proof_height_on_a.revision_height(),
         );
         let consensus_state_of_a_on_b =
             client_val_ctx_b.consensus_state(&client_cons_state_path_on_b)?;
         let prefix_on_a = conn_end_on_b.counterparty().prefix();
         let port_id_on_a = msg.port_id_on_a.clone();
         let chan_id_on_a = msg.chan_id_on_a.clone();
         let conn_id_on_a = conn_end_on_b
             .counterparty()
             .connection_id()
             .ok_or(ConnectionError::MissingCounterparty)?;
 
         let expected_chan_end_on_a = ChannelEnd::new(
             ChannelState::Init,
             msg.ordering,
             Counterparty::new(msg.port_id_on_b.clone(), None),
             vec![conn_id_on_a.clone()],
             msg.version_supported_on_a.clone(),
         )?;
         let chan_end_path_on_a = ChannelEndPath::new(&port_id_on_a, &chan_id_on_a);
 
         // Verify the proof for the channel state against the expected channel end.
         // A counterparty channel id of None in not possible, and is checked by validate_basic in msg.
         client_state_of_a_on_b.verify_membership(
             prefix_on_a,
             &msg.proof_chan_end_on_a,
             consensus_state_of_a_on_b.root(),
             Path::ChannelEnd(chan_end_path_on_a),
             expected_chan_end_on_a.encode_vec(),
         )?;
     }
 
     Ok(())
 }

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

@@ -18,227 +18,226 @@
 use ibc_eureka_core_router::module::Module;
 use ibc_primitives::prelude::*;
 
 pub fn recv_packet_validate<ValCtx>(ctx_b: &ValCtx, msg: MsgRecvPacket) -> Result<(), ChannelError>
 where
     ValCtx: ValidationContext,
 {
     // Note: this contains the validation for `write_acknowledgement` as well.
     validate(ctx_b, &msg)
 
     // nothing to validate with the module, since `onRecvPacket` cannot fail.
     // If any error occurs, then an "error acknowledgement" must be returned.
 }
 
 pub fn recv_packet_execute<ExecCtx>(
     ctx_b: &mut ExecCtx,
     module: &mut dyn Module,
     msg: MsgRecvPacket,
 ) -> Result<(), ChannelError>
 where
     ExecCtx: ExecutionContext,
 {
-    let chan_end_path_on_b =
-        ChannelEndPath::new(&msg.packet.port_id_on_b, &msg.packet.chan_id_on_b);
+    let packet = &msg.packet;
+    let payload = &packet.payloads[0];
+
+    let port_id_on_b = &payload.header.target_port.1;
+    let channel_id_on_b = &packet.header.target_client;
+    let seq_on_a = &packet.header.seq_on_a;
+
+    let chan_end_path_on_b = ChannelEndPath::new(port_id_on_b, channel_id_on_b);
     let chan_end_on_b = ctx_b.channel_end(&chan_end_path_on_b)?;
 
     // Check if another relayer already relayed the packet.
     // We don't want to fail the transaction in this case.
     {
         let packet_already_received = match chan_end_on_b.ordering {
             // Note: ibc-go doesn't make the check for `Order::None` channels
             Order::None => false,
             Order::Unordered => {
-                let packet = &msg.packet;
-                let receipt_path_on_b =
-                    ReceiptPath::new(&packet.port_id_on_b, &packet.chan_id_on_b, packet.seq_on_a);
+                let receipt_path_on_b = ReceiptPath::new(port_id_on_b, channel_id_on_b, *seq_on_a);
                 ctx_b.get_packet_receipt(&receipt_path_on_b)?.is_ok()
             }
             Order::Ordered => {
-                let seq_recv_path_on_b =
-                    SeqRecvPath::new(&msg.packet.port_id_on_b, &msg.packet.chan_id_on_b);
+                let seq_recv_path_on_b = SeqRecvPath::new(port_id_on_b, channel_id_on_b);
                 let next_seq_recv = ctx_b.get_next_sequence_recv(&seq_recv_path_on_b)?;
 
                 // the sequence number has already been incremented, so
                 // another relayer already relayed the packet
-                msg.packet.seq_on_a < next_seq_recv
+                seq_on_a < &next_seq_recv
             }
         };
 
         if packet_already_received {
             return Ok(());
         }
     }
 
     let (extras, acknowledgement) = module.on_recv_packet_execute(&msg.packet, &msg.signer);
 
     // state changes
     {
         // `recvPacket` core handler state changes
         match chan_end_on_b.ordering {
             Order::Unordered => {
                 let receipt_path_on_b = ReceiptPath {
-                    port_id: msg.packet.port_id_on_b.clone(),
-                    channel_id: msg.packet.chan_id_on_b.clone(),
-                    sequence: msg.packet.seq_on_a,
+                    port_id: port_id_on_b.clone(),
+                    channel_id: channel_id_on_b.clone(),
+                    sequence: *seq_on_a,
                 };
 
                 ctx_b.store_packet_receipt(&receipt_path_on_b, Receipt::Ok)?;
             }
             Order::Ordered => {
-                let seq_recv_path_on_b =
-                    SeqRecvPath::new(&msg.packet.port_id_on_b, &msg.packet.chan_id_on_b);
+                let seq_recv_path_on_b = SeqRecvPath::new(port_id_on_b, channel_id_on_b);
                 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(
-            &msg.packet.port_id_on_b,
-            &msg.packet.chan_id_on_b,
-            msg.packet.seq_on_a,
-        );
+        let ack_path_on_b = AckPath::new(port_id_on_b, channel_id_on_b, *seq_on_a);
         // `writeAcknowledgement` handler state changes
         ctx_b.store_packet_acknowledgement(
             &ack_path_on_b,
             compute_ack_commitment(&acknowledgement),
         )?;
     }
 
     // emit events and logs
     {
         ctx_b.log_message("success: packet receive".to_string())?;
         ctx_b.log_message("success: packet write acknowledgement".to_string())?;
 
         let conn_id_on_b = &chan_end_on_b.connection_hops()[0];
         let event = IbcEvent::ReceivePacket(ReceivePacket::new(
             msg.packet.clone(),
             chan_end_on_b.ordering,
             conn_id_on_b.clone(),
         ));
         ctx_b.emit_ibc_event(IbcEvent::Message(MessageEvent::Channel))?;
         ctx_b.emit_ibc_event(event)?;
         let event = IbcEvent::WriteAcknowledgement(WriteAcknowledgement::new(
             msg.packet,
             acknowledgement,
             conn_id_on_b.clone(),
         ));
         ctx_b.emit_ibc_event(IbcEvent::Message(MessageEvent::Channel))?;
         ctx_b.emit_ibc_event(event)?;
 
         for module_event in extras.events {
             ctx_b.emit_ibc_event(IbcEvent::Module(module_event))?;
         }
 
         for log_message in extras.log {
             ctx_b.log_message(log_message)?;
         }
     }
 
     Ok(())
 }
 
 fn validate<Ctx>(ctx_b: &Ctx, msg: &MsgRecvPacket) -> Result<(), ChannelError>
 where
     Ctx: ValidationContext,
 {
     ctx_b.validate_message_signer(&msg.signer)?;
 
-    let chan_end_path_on_b =
-        ChannelEndPath::new(&msg.packet.port_id_on_b, &msg.packet.chan_id_on_b);
+    let packet = &msg.packet;
+    let payload = &packet.payloads[0];
+
+    let port_id_on_a = &payload.header.source_port.1;
+    let channel_id_on_a = &packet.header.source_client;
+    let port_id_on_b = &payload.header.target_port.1;
+    let channel_id_on_b = &packet.header.target_client;
+    let seq_on_a = &packet.header.seq_on_a;
+    let data = &payload.data;
+
+    let chan_end_path_on_b = ChannelEndPath::new(port_id_on_b, channel_id_on_b);
     let chan_end_on_b = ctx_b.channel_end(&chan_end_path_on_b)?;
 
     chan_end_on_b.verify_state_matches(&ChannelState::Open)?;
 
-    let counterparty = Counterparty::new(
-        msg.packet.port_id_on_a.clone(),
-        Some(msg.packet.chan_id_on_a.clone()),
-    );
+    let counterparty = Counterparty::new(port_id_on_a.clone(), Some(channel_id_on_a.clone()));
 
     chan_end_on_b.verify_counterparty_matches(&counterparty)?;
 
     let conn_id_on_b = &chan_end_on_b.connection_hops()[0];
     let conn_end_on_b = ctx_b.connection_end(conn_id_on_b)?;
 
     conn_end_on_b.verify_state_matches(&ConnectionState::Open)?;
 
     let latest_height = ctx_b.host_height()?;
-    if msg.packet.timeout_height_on_b.has_expired(latest_height) {
+    if packet.header.timeout_height_on_b.has_expired(latest_height) {
         return Err(ChannelError::InsufficientPacketHeight {
             chain_height: latest_height,
-            timeout_height: msg.packet.timeout_height_on_b,
+            timeout_height: packet.header.timeout_height_on_b,
         });
     }
 
     let latest_timestamp = ctx_b.host_timestamp()?;
-    if msg
-        .packet
+    if packet
+        .header
         .timeout_timestamp_on_b
         .has_expired(&latest_timestamp)
     {
         return Err(ChannelError::ExpiredPacketTimestamp);
     }
 
     // Verify proofs
     {
         let client_id_on_b = conn_end_on_b.client_id();
         let client_val_ctx_b = ctx_b.get_client_validation_context();
         let client_state_of_a_on_b = client_val_ctx_b.client_state(client_id_on_b)?;
 
         client_state_of_a_on_b
             .status(ctx_b.get_client_validation_context(), client_id_on_b)?
             .verify_is_active()?;
 
         client_state_of_a_on_b.validate_proof_height(msg.proof_height_on_a)?;
 
         let client_cons_state_path_on_b = ClientConsensusStatePath::new(
             client_id_on_b.clone(),
             msg.proof_height_on_a.revision_number(),
             msg.proof_height_on_a.revision_height(),
         );
 
         let consensus_state_of_a_on_b =
             client_val_ctx_b.consensus_state(&client_cons_state_path_on_b)?;
 
         let expected_commitment_on_a = compute_packet_commitment(
-            &msg.packet.data,
-            &msg.packet.timeout_height_on_b,
-            &msg.packet.timeout_timestamp_on_b,
-        );
-        let commitment_path_on_a = CommitmentPath::new(
-            &msg.packet.port_id_on_a,
-            &msg.packet.chan_id_on_a,
-            msg.packet.seq_on_a,
+            data,
+            &packet.header.timeout_height_on_b,
+            &packet.header.timeout_timestamp_on_b,
         );
+        let commitment_path_on_a = CommitmentPath::new(port_id_on_a, channel_id_on_a, *seq_on_a);
 
         verify_conn_delay_passed(ctx_b, msg.proof_height_on_a, &conn_end_on_b)?;
 
         // Verify the proof for the packet against the chain store.
         client_state_of_a_on_b.verify_membership(
             conn_end_on_b.counterparty().prefix(),
             &msg.proof_commitment_on_a,
             consensus_state_of_a_on_b.root(),
             Path::Commitment(commitment_path_on_a),
             expected_commitment_on_a.into_vec(),
         )?;
     }
 
     match chan_end_on_b.ordering {
         Order::Ordered => {
-            let seq_recv_path_on_b =
-                SeqRecvPath::new(&msg.packet.port_id_on_b, &msg.packet.chan_id_on_b);
+            let seq_recv_path_on_b = SeqRecvPath::new(port_id_on_b, channel_id_on_b);
             let next_seq_recv = ctx_b.get_next_sequence_recv(&seq_recv_path_on_b)?;
-            if msg.packet.seq_on_a > next_seq_recv {
+            if seq_on_a > &next_seq_recv {
                 return Err(ChannelError::MismatchedPacketSequence {
-                    actual: msg.packet.seq_on_a,
+                    actual: *seq_on_a,
                     expected: next_seq_recv,
                 });
             }
 
-            if msg.packet.seq_on_a == next_seq_recv {
+            if seq_on_a == &next_seq_recv {
                 // Case where the recvPacket is successful and an
                 // acknowledgement will be written (not a no-op)
                 validate_write_acknowledgement(ctx_b, msg)?;
             }
         }
         Order::Unordered => {
             // Note: We don't check for the packet receipt here because another
@@ -248,28 +247,34 @@
 
             // Case where the recvPacket is successful and an
             // acknowledgement will be written (not a no-op)
             validate_write_acknowledgement(ctx_b, msg)?;
         }
         Order::None => {
             return Err(ChannelError::InvalidState {
                 expected: "Channel ordering to not be None".to_string(),
                 actual: chan_end_on_b.ordering.to_string(),
             })
         }
     }
 
     Ok(())
 }
 
 fn validate_write_acknowledgement<Ctx>(ctx_b: &Ctx, msg: &MsgRecvPacket) -> Result<(), ChannelError>
 where
     Ctx: ValidationContext,
 {
-    let packet = msg.packet.clone();
-    let ack_path_on_b = AckPath::new(&packet.port_id_on_b, &packet.chan_id_on_b, packet.seq_on_a);
+    let packet = &msg.packet;
+    let payload = &packet.payloads[0];
+
+    let port_id_on_b = &payload.header.target_port.1;
+    let channel_id_on_b = &packet.header.target_client;
+    let seq_on_a = &packet.header.seq_on_a;
+
+    let ack_path_on_b = AckPath::new(port_id_on_b, channel_id_on_b, *seq_on_a);
     if ctx_b.get_packet_acknowledgement(&ack_path_on_b).is_ok() {
-        return Err(ChannelError::DuplicateAcknowledgment(msg.packet.seq_on_a));
+        return Err(ChannelError::DuplicateAcknowledgment(*seq_on_a));
     }
 
     Ok(())
 }