Finish implementation of Validation/ExecutionContext

crates/ibc/src/applications/transfer/context.rs

@@ -530,6 +530,117 @@ mod val_exec_ctx {
 
         (extras, ack.into())
     }
+
+    pub fn on_acknowledgement_packet_validate(
+        _ctx: &impl TokenTransferContext,
+        packet: &Packet,
+        acknowledgement: &Acknowledgement,
+        _relayer: &Signer,
+    ) -> Result<(), TokenTransferError> {
+        let _data = serde_json::from_slice::<PacketData>(&packet.data)
+            .map_err(|_| TokenTransferError::PacketDataDeserialization)?;
+
+        let _acknowledgement =
+            serde_json::from_slice::<TokenTransferAcknowledgement>(acknowledgement.as_ref())
+                .map_err(|_| TokenTransferError::AckDeserialization)?;
+
+        // TODO: validate `refund_packet_token`
+
+        Ok(())
+    }
+
+    pub fn on_acknowledgement_packet_execute(
+        ctx: &mut impl TokenTransferContext,
+        packet: &Packet,
+        acknowledgement: &Acknowledgement,
+        _relayer: &Signer,
+    ) -> (ModuleExtras, Result<(), TokenTransferError>) {
+        let data = match serde_json::from_slice::<PacketData>(&packet.data) {
+            Ok(data) => data,
+            Err(_) => {
+                return (
+                    ModuleExtras::empty(),
+                    Err(TokenTransferError::PacketDataDeserialization),
+                );
+            }
+        };
+
+        let acknowledgement = match serde_json::from_slice::<TokenTransferAcknowledgement>(
+            acknowledgement.as_ref(),
+        ) {
+            Ok(ack) => ack,
+            Err(_) => {
+                return (
+                    ModuleExtras::empty(),
+                    Err(TokenTransferError::AckDeserialization),
+                );
+            }
+        };
+
+        if let Err(err) = process_ack_packet(ctx, packet, &data, &acknowledgement) {
+            return (ModuleExtras::empty(), Err(err));
+        }
+
+        let ack_event = AckEvent {
+            receiver: data.receiver,
+            denom: data.token.denom,
+            amount: data.token.amount,
+            acknowledgement: acknowledgement.clone(),
+        };
+
+        let extras = ModuleExtras {
+            events: vec![ack_event.into(), AckStatusEvent { acknowledgement }.into()],
+            log: Vec::new(),
+        };
+
+        (extras, Ok(()))
+    }
+
+    pub fn on_timeout_packet_validate(
+        _ctx: &impl TokenTransferContext,
+        packet: &Packet,
+        _relayer: &Signer,
+    ) -> Result<(), TokenTransferError> {
+        let _data = serde_json::from_slice::<PacketData>(&packet.data)
+            .map_err(|_| TokenTransferError::PacketDataDeserialization)?;
+
+        // TODO: validate `refund_packet_token`
+
+        Ok(())
+    }
+
+    pub fn on_timeout_packet_execute(
+        ctx: &mut impl TokenTransferContext,
+        packet: &Packet,
+        _relayer: &Signer,
+    ) -> (ModuleExtras, Result<(), TokenTransferError>) {
+        let data = match serde_json::from_slice::<PacketData>(&packet.data) {
+            Ok(data) => data,
+            Err(_) => {
+                return (
+                    ModuleExtras::empty(),
+                    Err(TokenTransferError::PacketDataDeserialization),
+                );
+            }
+        };
+
+        if let Err(err) = process_timeout_packet(ctx, packet, &data) {
+            return (ModuleExtras::empty(), Err(err));
+        }
+
+        let timeout_event = TimeoutEvent {
+            refund_receiver: data.sender,
+            refund_denom: data.token.denom,
+            refund_amount: data.token.amount,
+        };
+
+        let extras = ModuleExtras {
+            events: vec![timeout_event.into()],
+            log: Vec::new(),
+        };
+
+        (extras, Ok(()))
+    }
 }
 
 #[cfg(test)]

crates/ibc/src/clients/ics07_tendermint/client_state.rs

@@ -1150,6 +1150,38 @@ impl Ics2ClientState for ClientState {
         )
     }
 
+    #[cfg(feature = "val_exec_ctx")]
+    fn new_verify_packet_acknowledgement(
+        &self,
+        ctx: &dyn ValidationContext,
+        height: Height,
+        connection_end: &ConnectionEnd,
+        proof: &CommitmentProofBytes,
+        root: &CommitmentRoot,
+        port_id: &PortId,
+        channel_id: &ChannelId,
+        sequence: Sequence,
+        ack: AcknowledgementCommitment,
+    ) -> Result<(), ClientError> {
+        let client_state = downcast_tm_client_state(self)?;
+        client_state.verify_height(height)?;
+        new_verify_delay_passed(ctx, height, connection_end)?;
+
+        let ack_path = AcksPath {
+            port_id: port_id.clone(),
+            channel_id: channel_id.clone(),
+            sequence,
+        };
+        verify_membership(
+            client_state,
+            connection_end.counterparty().prefix(),
+            proof,
+            root,
+            ack_path,
+            ack.into_vec(),
+        )
+    }
+
     fn verify_packet_acknowledgement(
         &self,
         ctx: &dyn ChannelReader,
@@ -1181,6 +1213,40 @@ impl Ics2ClientState for ClientState {
         )
     }
 
+    #[cfg(feature = "val_exec_ctx")]
+    #[allow(clippy::too_many_arguments)]
+    fn new_verify_next_sequence_recv(
+        &self,
+        ctx: &dyn ValidationContext,
+        height: Height,
+        connection_end: &ConnectionEnd,
+        proof: &CommitmentProofBytes,
+        root: &CommitmentRoot,
+        port_id: &PortId,
+        channel_id: &ChannelId,
+        sequence: Sequence,
+    ) -> Result<(), ClientError> {
+        let client_state = downcast_tm_client_state(self)?;
+        client_state.verify_height(height)?;
+        new_verify_delay_passed(ctx, height, connection_end)?;
+
+        let mut seq_bytes = Vec::new();
+        u64::from(sequence)
+            .encode(&mut seq_bytes)
+            .expect("buffer size too small");
+
+        let seq_path = SeqRecvsPath(port_id.clone(), channel_id.clone());
+
+        verify_membership(
+            client_state,
+            connection_end.counterparty().prefix(),
+            proof,
+            root,
+            seq_path,
+            seq_bytes,
+        )
+    }
+
     fn verify_next_sequence_recv(
         &self,
         ctx: &dyn ChannelReader,
@@ -1213,6 +1279,37 @@ impl Ics2ClientState for ClientState {
         )
     }
 
+    #[cfg(feature = "val_exec_ctx")]
+    #[allow(clippy::too_many_arguments)]
+    fn new_verify_packet_receipt_absence(
+        &self,
+        ctx: &dyn ValidationContext,
+        height: Height,
+        connection_end: &ConnectionEnd,
+        proof: &CommitmentProofBytes,
+        root: &CommitmentRoot,
+        port_id: &PortId,
+        channel_id: &ChannelId,
+        sequence: Sequence,
+    ) -> Result<(), ClientError> {
+        let client_state = downcast_tm_client_state(self)?;
+        client_state.verify_height(height)?;
+        new_verify_delay_passed(ctx, height, connection_end)?;
+
+        let receipt_path = ReceiptsPath {
+            port_id: port_id.clone(),
+            channel_id: channel_id.clone(),
+            sequence,
+        };
+        verify_non_membership(
+            client_state,
+            connection_end.counterparty().prefix(),
+            proof,
+            root,
+            receipt_path,
+        )
+    }
+
     fn verify_packet_receipt_absence(
         &self,
         ctx: &dyn ChannelReader,