feat(relayer): reuse ConnectionEnd and ChannelEnd from ibc-rs (#197)

* felt to string and back

* use ibc-rs client id

* refactor for ibc-rs client id

* use ibc-rs connection id

* refactor for conneciton id

* fixme comment

* use ibc-rs channel id

* fixme comment

* refactor for channel id

* use ibc-rs port id

* refactor for port id

* rename vars

* use ibc-rs channel counterparty

* use ibc-rs commitment prefix

* use ibc-rs connection counterparty

* refactor for commitment prefix and connection counterparty

* use Duration for delay_period

* use ibc-rs connection version

* refactor for connection version

* use ibc-rs connection state

* use ibc-rs connection end

* refactor for connection end

* update fixme comment

* use ibc-rs channel order

* refactor for channel order

* use ibc-rs channel state

* use ibc-rs channel version

* refactor for channel version

* fix error strings

* use ibc-rs channel end

* refactor for channel end

* rm redundant asserts

* fix channel open try message

Author: rnbguy

relayer/crates/starknet-chain-components/src/components/encoding/cairo.rs

@@ -1,3 +1,5 @@
+use core::time::Duration;
+
 use cgp::core::component::{UseContext, UseDelegate};
 use cgp::prelude::*;
 use hermes_cairo_encoding_components::components::encode_mut::*;
@@ -21,6 +23,7 @@ use crate::types::client_id::{ClientId, EncodeClientId};
 use crate::types::connection_id::{
     ConnectionCounterparty, ConnectionEnd, ConnectionId, ConnectionState,
     EncodeConnectionCounterparty, EncodeConnectionEnd, EncodeConnectionId, EncodeConnectionState,
+    EncodeDuration,
 };
 use crate::types::cosmos::client_state::{
     ClientStatus, CometClientState, EncodeChainId, EncodeClientStatus, EncodeCometClientState,
@@ -127,6 +130,7 @@ delegate_components! {
         (ViaCairo, ClientId): EncodeClientId,
         (ViaCairo, ChainId): EncodeChainId,
         (ViaCairo, ConnectionId): EncodeConnectionId,
+        (ViaCairo, Duration): EncodeDuration,
         (ViaCairo, ConnectionCounterparty): EncodeConnectionCounterparty,
         (ViaCairo, ConnectionState): EncodeConnectionState,
         (ViaCairo, ConnectionEnd): EncodeConnectionEnd,

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

@@ -64,27 +64,10 @@ where
     ) -> Result<Packet, Chain::Error> {
         let packet = Packet {
             seq_on_a: event.sequence_on_a.sequence.into(),
-            port_id_on_a: event
-                .port_id_on_a
-                .port_id
-                .parse()
-                .map_err(Chain::raise_error)?,
-            chan_id_on_a: event
-                .channel_id_on_a
-                .channel_id
-                .parse()
-                .map_err(Chain::raise_error)?,
-            port_id_on_b: event
-                .port_id_on_b
-                .port_id
-                .parse()
-                .map_err(Chain::raise_error)?,
-            chan_id_on_b: event
-                .channel_id_on_b
-                .channel_id
-                .parse()
-                .map_err(Chain::raise_error)?,
-
+            port_id_on_a: event.port_id_on_a.clone(),
+            chan_id_on_a: event.channel_id_on_a.clone(),
+            port_id_on_b: event.port_id_on_b.clone(),
+            chan_id_on_b: event.channel_id_on_b.clone(),
             // FIXME: make the Cairo contract include these fields in the event
             data: Vec::new(),
             timeout_height_on_b: TimeoutHeight::Never,

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

@@ -107,26 +107,10 @@ where
 
         let packet = Packet {
             seq_on_a: event.sequence_on_a.sequence.into(),
-            port_id_on_a: event
-                .port_id_on_a
-                .port_id
-                .parse()
-                .map_err(Chain::raise_error)?,
-            chan_id_on_a: event
-                .channel_id_on_a
-                .channel_id
-                .parse()
-                .map_err(Chain::raise_error)?,
-            port_id_on_b: event
-                .port_id_on_b
-                .port_id
-                .parse()
-                .map_err(Chain::raise_error)?,
-            chan_id_on_b: event
-                .channel_id_on_b
-                .channel_id
-                .parse()
-                .map_err(Chain::raise_error)?,
+            port_id_on_a: event.port_id_on_a.clone(),
+            chan_id_on_a: event.channel_id_on_a.clone(),
+            port_id_on_b: event.port_id_on_b.clone(),
+            chan_id_on_b: event.channel_id_on_b.clone(),
             data: cosmos_packet_data,
             timeout_height_on_b,
             timeout_timestamp_on_b,

relayer/crates/starknet-chain-components/src/impls/messages/channel.rs

@@ -33,11 +33,9 @@ use starknet::macros::selector;
 use crate::impls::types::message::StarknetMessage;
 use crate::traits::queries::address::CanQueryContractAddress;
 use crate::types::channel_id::ChannelId as StarknetChannelId;
-use crate::types::connection_id::ConnectionId as StarknetConnectionId;
 use crate::types::cosmos::height::Height as CairoHeight;
 use crate::types::messages::ibc::channel::{
-    AppVersion, ChannelOrdering, MsgChanOpenAck, MsgChanOpenConfirm, MsgChanOpenInit,
-    MsgChanOpenTry, PortId as StarknetPortId,
+    ChannelOrdering, MsgChanOpenAck, MsgChanOpenConfirm, MsgChanOpenInit, MsgChanOpenTry,
 };
 use crate::types::messages::ibc::packet::StateProof;
 pub struct BuildStarknetChannelHandshakeMessages;
@@ -62,27 +60,13 @@ where
         counterparty_port_id: &IbcPortId,
         init_channel_options: &CosmosInitChannelOptions,
     ) -> Result<Chain::Message, Chain::Error> {
-        let port_id_on_a = StarknetPortId {
-            port_id: port_id.to_string(),
-        };
-
-        let port_id_on_b = StarknetPortId {
-            port_id: counterparty_port_id.to_string(),
-        };
-
         if init_channel_options.connection_hops.len() != 1 {
             return Err(Chain::raise_error(
                 "Starknet only supports a single connection hop",
             ));
         }
 
-        let conn_id_on_a = StarknetConnectionId {
-            connection_id: init_channel_options.connection_hops[0].to_string(),
-        };
-
-        let version_proposal = AppVersion {
-            version: init_channel_options.channel_version.to_string(),
-        };
+        let conn_id_on_a = init_channel_options.connection_hops[0].clone();
 
         let ordering = match init_channel_options.ordering {
             IbcOrder::None => {
@@ -93,10 +77,10 @@ where
         };
 
         let chan_open_init_msg = MsgChanOpenInit {
-            port_id_on_a,
+            port_id_on_a: port_id.clone(),
             conn_id_on_a,
-            port_id_on_b,
-            version_proposal,
+            port_id_on_b: counterparty_port_id.clone(),
+            version_proposal: init_channel_options.channel_version.clone(),
             ordering,
         };
 
@@ -147,31 +131,13 @@ where
         counterparty_channel_id: &ChannelId,
         counterparty_payload: ChannelOpenTryPayload<Counterparty, Chain>,
     ) -> Result<Chain::Message, Chain::Error> {
-        let port_id_on_b = StarknetPortId {
-            port_id: port_id.to_string(),
-        };
-
         if counterparty_payload.channel_end.connection_hops.len() != 1 {
             return Err(Chain::raise_error(
                 "Starknet only supports a single connection hop",
             ));
         }
 
-        let conn_id_on_b = StarknetConnectionId {
-            connection_id: counterparty_payload.channel_end.connection_hops[0].to_string(),
-        };
-
-        let port_id_on_a = StarknetPortId {
-            port_id: counterparty_port_id.to_string(),
-        };
-
-        let chan_id_on_a = StarknetChannelId {
-            channel_id: counterparty_channel_id.to_string(),
-        };
-
-        let version_on_a = AppVersion {
-            version: counterparty_payload.channel_end.version.to_string(),
-        };
+        let conn_id_on_b = counterparty_payload.channel_end.connection_hops[0].clone();
 
         let proof_chan_end_on_a = StateProof {
             proof: vec![Felt::ONE],
@@ -191,11 +157,11 @@ where
         };
 
         let chan_open_try_msg = MsgChanOpenTry {
-            port_id_on_b,
+            port_id_on_b: port_id.clone(),
             conn_id_on_b,
-            port_id_on_a,
-            chan_id_on_a,
-            version_on_a,
+            port_id_on_a: counterparty_port_id.clone(),
+            chan_id_on_a: counterparty_channel_id.clone(),
+            version_on_a: counterparty_payload.channel_end.version.clone(),
             proof_chan_end_on_a,
             proof_height_on_a,
             ordering,
@@ -248,18 +214,6 @@ where
         counterparty_channel_id: &ChannelId,
         counterparty_payload: ChannelOpenAckPayload<Counterparty, Chain>,
     ) -> Result<Chain::Message, Chain::Error> {
-        let port_id_on_a = StarknetPortId {
-            port_id: port_id.to_string(),
-        };
-
-        let chan_id_on_b = StarknetChannelId {
-            channel_id: counterparty_channel_id.to_string(),
-        };
-
-        let version_on_b = AppVersion {
-            version: counterparty_payload.channel_end.version.to_string(),
-        };
-
         let proof_chan_end_on_b = StateProof {
             proof: vec![Felt::ONE],
         };
@@ -270,10 +224,10 @@ where
         };
 
         let chan_open_ack_msg = MsgChanOpenAck {
-            port_id_on_a,
+            port_id_on_a: port_id.clone(),
             chan_id_on_a: channel_id.clone(),
-            chan_id_on_b,
-            version_on_b,
+            chan_id_on_b: counterparty_channel_id.clone(),
+            version_on_b: counterparty_payload.channel_end.version.clone(),
             proof_chan_end_on_b,
             proof_height_on_b,
         };
@@ -322,10 +276,6 @@ where
         channel_id: &StarknetChannelId,
         counterparty_payload: ChannelOpenConfirmPayload<Counterparty>,
     ) -> Result<Chain::Message, Chain::Error> {
-        let port_id_on_b = StarknetPortId {
-            port_id: port_id.to_string(),
-        };
-
         let proof_chan_end_on_a = StateProof {
             proof: vec![Felt::ONE],
         };
@@ -336,7 +286,7 @@ where
         };
 
         let chan_open_confirm_msg = MsgChanOpenConfirm {
-            port_id_on_b,
+            port_id_on_b: port_id.clone(),
             chan_id_on_b: channel_id.clone(),
             proof_chan_end_on_a,
             proof_height_on_a,