feat(relayer): build packet messages, query packet status, extract pa…

…cket event (#169)

* dummy impl to convert from IbcPacket

* build_receive_packet_message for starknet

* build_ack_packet_message for starknet

* add trait bounds

* build_timeout_unordered_packet_message for starknet

* try_extract_write_ack_event

* add trait bounds

* query_packet_commitment for starknet

* query_packet_acknowledgement for starknet

* impl u32 array decode

* add trait bound

* query_packet_is_received for starknet

* query_packet_receipt for starknet

* query if ack exits

* impl IbcPacket to CairoPacket

* use CairoPacket::try_from

* add todo comment

* fix typo

---------

Co-authored-by: Farhad Shabani <farhad.shabani@gmail.com>

cairo-contracts/packages/core/src/channel/components/handler.cairo

@@ -21,7 +21,7 @@ pub mod ChannelHandlerComponent {
         ClientHandlerComponent, ClientContract, ClientContractTrait, Height, HeightImpl
     };
     use starknet_ibc_core::commitment::{
-        StateProof, Commitment, CommitmentZero, compute_packet_commtiment, compute_ack_commitment
+        StateProof, Commitment, CommitmentZero, compute_packet_commitment, compute_ack_commitment
     };
     use starknet_ibc_core::connection::{
         ConnectionHandlerComponent, ConnectionEnd, ConnectionEndTrait, VersionTrait,
@@ -164,6 +164,16 @@ pub mod ChannelHandlerComponent {
             self.read_packet_ack(@port_id, @channel_id, @sequence)
         }
 
+
+        fn is_packet_received(
+            self: @ComponentState<TContractState>,
+            port_id: PortId,
+            channel_id: ChannelId,
+            sequence: Sequence
+        ) -> bool {
+            self.packet_ack_exists(@port_id, @channel_id, @sequence)
+        }
+
         fn next_sequence_send(
             self: @ComponentState<TContractState>, port_id: PortId, channel_id: ChannelId
         ) -> Sequence {
@@ -551,7 +561,7 @@ pub mod ChannelHandlerComponent {
 
             let json_packet_data = app.json_packet_data(packet.data.clone());
 
-            let packet_commitment_on_a = compute_packet_commtiment(
+            let packet_commitment_on_a = compute_packet_commitment(
                 @json_packet_data,
                 packet.timeout_height_on_b.clone(),
                 packet.timeout_timestamp_on_b.clone()
@@ -888,7 +898,7 @@ pub mod ChannelHandlerComponent {
             let packet_commitment = self
                 .read_packet_commitment(packet.port_id_on_a, packet.chan_id_on_a, packet.seq_on_a);
 
-            let expected_packet_commitment = compute_packet_commtiment(
+            let expected_packet_commitment = compute_packet_commitment(
                 json_packet_data,
                 packet.timeout_height_on_b.clone(),
                 packet.timeout_timestamp_on_b.clone()
@@ -932,7 +942,7 @@ pub mod ChannelHandlerComponent {
                 msg.packet.seq_on_a.clone()
             );
 
-            let packet_commitment_on_a = compute_packet_commtiment(
+            let packet_commitment_on_a = compute_packet_commitment(
                 @json_packet_data,
                 msg.packet.timeout_height_on_b.clone(),
                 msg.packet.timeout_timestamp_on_b.clone()

cairo-contracts/packages/core/src/channel/interface.cairo

@@ -67,6 +67,9 @@ pub trait IChannelQuery<TContractState> {
     fn packet_acknowledgement(
         self: @TContractState, port_id: PortId, channel_id: ChannelId, sequence: Sequence
     ) -> Commitment;
+    fn is_packet_received(
+        self: @TContractState, port_id: PortId, channel_id: ChannelId, sequence: Sequence
+    ) -> bool;
     fn next_sequence_send(
         self: @TContractState, port_id: PortId, channel_id: ChannelId
     ) -> Sequence;

cairo-contracts/packages/core/src/commitment/types.cairo

@@ -48,7 +48,7 @@ pub impl CommitmentIntoStateValue of Into<Commitment, StateValue> {
     }
 }
 
-pub fn compute_packet_commtiment(
+pub fn compute_packet_commitment(
     json_packet_data: @ByteArray, timeout_height: Height, timeout_timestamp: Timestamp
 ) -> Commitment {
     let mut coll = U32CollectorImpl::init();

cairo-contracts/packages/core/src/lib.cairo

@@ -23,7 +23,7 @@ pub mod commitment {
 
     pub use types::{
         Commitment, CommitmentZero, StateValue, StateValueZero, StateProof, StateProofZero,
-        StateRoot, StateRootZero, compute_packet_commtiment, compute_ack_commitment,
+        StateRoot, StateRootZero, compute_packet_commitment, compute_ack_commitment,
     };
     pub use utils::{
         IntoArrayU32, U64IntoArrayU32, U32Collector, U32CollectorImpl, U32CollectorTrait,

cairo-contracts/packages/testkit/src/dummies/transfer.cairo

@@ -3,7 +3,7 @@ use starknet::contract_address_const;
 use starknet::{ContractAddress, ClassHash};
 use starknet_ibc_apps::transfer::ERC20Contract;
 use starknet_ibc_apps::transfer::types::{PacketData, Denom, Participant, PrefixedDenom, Memo};
-use starknet_ibc_core::commitment::{Commitment, compute_packet_commtiment};
+use starknet_ibc_core::commitment::{Commitment, compute_packet_commitment};
 use starknet_ibc_testkit::dummies::{TIMEOUT_HEIGHT, TIMEOUT_TIMESTAMP};
 
 pub const SUPPLY: u256 = 2000;
@@ -64,7 +64,7 @@ pub fn PACKET_DATA_FROM_SN(token: ERC20Contract) -> PacketData {
 }
 
 pub fn PACKET_COMMITMENT_ON_SN(token: ERC20Contract) -> Commitment {
-    compute_packet_commtiment(
+    compute_packet_commitment(
         @serde_json::to_byte_array(PACKET_DATA_FROM_SN(token)),
         TIMEOUT_HEIGHT(1000),
         TIMEOUT_TIMESTAMP(1000)

relayer/crates/cairo-encoding-components/src/components/encode_mut.rs

@@ -22,12 +22,14 @@ cgp_preset! {
         (ViaCairo, Vec<Felt>): EncodeList,
         (ViaCairo, bool): EncodeBool,
         (ViaCairo, u64): EncodeFromU128,
+        (ViaCairo, u32): EncodeFromU128,
         (ViaCairo, usize): EncodeFromU128,
         (ViaCairo, String): EncodeUtf8String,
         (ViaCairo, ()): EncodeNothing,
         (ViaCairo, Nil): EncodeNothing,
         (ViaCairo, Vec<String>): EncodeList,
         // TODO(rano): use <const N: usize>
         (ViaCairo, [String; 2]): EncodeArray,
+        (ViaCairo, [u32; 8]): EncodeArray,
     }
 }

relayer/crates/starknet-chain-components/src/impls/events/ack.rs

@@ -1,23 +1,63 @@
+use cgp::prelude::*;
+use hermes_cairo_encoding_components::strategy::ViaCairo;
+use hermes_cairo_encoding_components::types::as_felt::AsFelt;
 use hermes_chain_components::traits::types::event::HasEventType;
 use hermes_chain_components::traits::types::ibc_events::write_ack::ProvideWriteAckEvent;
 use hermes_chain_components::traits::types::packets::ack::HasAcknowledgementType;
+use hermes_encoding_components::traits::decode::CanDecode;
+use hermes_encoding_components::traits::has_encoding::HasDefaultEncoding;
+use hermes_encoding_components::traits::types::encoded::HasEncodedType;
+use starknet::core::types::Felt;
 
+use crate::types::channel_id::ChannelId;
 use crate::types::event::StarknetEvent;
+use crate::types::events::packet::WriteAcknowledgementEvent;
+use crate::types::messages::ibc::channel::PortId;
+use crate::types::messages::ibc::packet::{Acknowledgement, Sequence};
 
 pub struct UseStarknetWriteAckEvent;
 
-impl<Chain, Counterparty> ProvideWriteAckEvent<Chain, Counterparty> for UseStarknetWriteAckEvent
+impl<Chain, Counterparty, Encoding> ProvideWriteAckEvent<Chain, Counterparty>
+    for UseStarknetWriteAckEvent
 where
     Chain: HasEventType<Event = StarknetEvent>
-        + HasAcknowledgementType<Counterparty, Acknowledgement = Vec<u8>>,
+        + HasAcknowledgementType<Counterparty, Acknowledgement = Vec<u8>>
+        + HasDefaultEncoding<AsFelt, Encoding = Encoding>,
+    Encoding: HasEncodedType<Encoded = Vec<Felt>>
+        + CanDecode<ViaCairo, Product![Sequence, PortId, ChannelId, PortId, ChannelId]>
+        + CanDecode<ViaCairo, Product![Vec<Felt>, Acknowledgement]>,
 {
-    type WriteAckEvent = Vec<u8>;
+    type WriteAckEvent = WriteAcknowledgementEvent;
 
-    fn try_extract_write_ack_event(_event: &StarknetEvent) -> Option<Self::WriteAckEvent> {
-        todo!()
+    fn try_extract_write_ack_event(event: &StarknetEvent) -> Option<Self::WriteAckEvent> {
+        // TODO(rano): don't have access to the EventEncoding
+        // Ideally, EventEncoding to decode directly from StarknetEvent
+
+        let cairo_encoding = Chain::default_encoding();
+
+        let product![
+            sequence_on_a,
+            port_id_on_a,
+            channel_id_on_a,
+            port_id_on_b,
+            channel_id_on_b,
+        ] = cairo_encoding.decode(&event.keys).ok()?;
+
+        let product![packet_data, acknowledgement,] = cairo_encoding.decode(&event.data).ok()?;
+
+        Some(WriteAcknowledgementEvent {
+            sequence_on_a,
+            port_id_on_a,
+            channel_id_on_a,
+            port_id_on_b,
+            channel_id_on_b,
+            packet_data,
+            acknowledgement,
+        })
     }
 
-    fn write_acknowledgement(ack: &Vec<u8>) -> impl AsRef<Vec<u8>> + Send {
-        ack
+    fn write_acknowledgement(_ack: &WriteAcknowledgementEvent) -> impl AsRef<Vec<u8>> + Send {
+        // TODO(rano): ack.acknowledgement.ack is Vec<Felt>
+        vec![0x1]
     }
 }