Implement Connection OpenTry relaying (#135)

* Initial wiring for connection open try

* Finish implementing ConnectionOpenTryMessageBuilder

* Should return ConnectionOpenTry message, not OpenInit

* Implement HasConnectionOpenTryEvent

* Implement HasConnectionOpenTryEvent

* Implement CanRelayConnectionOpenTry

* Fix cairo contracts

* Revert changes to scarb.nix

* Fix Cairo formatting

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

@@ -43,16 +43,20 @@ pub mod ConnectionHandlerComponent {
         impl EventEmitter: ConnectionEventEmitterComponent::HasComponent<TContractState>,
         impl ClientHandler: ClientHandlerComponent::HasComponent<TContractState>
     > of IConnectionHandler<ComponentState<TContractState>> {
-        fn conn_open_init(ref self: ComponentState<TContractState>, msg: MsgConnOpenInit) {
+        fn conn_open_init(
+            ref self: ComponentState<TContractState>, msg: MsgConnOpenInit
+        ) -> ConnectionId {
             let connection_sequence = self.read_next_connection_sequence();
             self.conn_open_init_validate(connection_sequence, msg.clone());
-            self.conn_open_init_execute(connection_sequence, msg);
+            self.conn_open_init_execute(connection_sequence, msg)
         }
 
-        fn conn_open_try(ref self: ComponentState<TContractState>, msg: MsgConnOpenTry) {
+        fn conn_open_try(
+            ref self: ComponentState<TContractState>, msg: MsgConnOpenTry
+        ) -> ConnectionId {
             let connection_sequence = self.read_next_connection_sequence();
             self.conn_open_try_validate(connection_sequence, msg.clone());
-            self.conn_open_try_execute(connection_sequence, msg);
+            self.conn_open_try_execute(connection_sequence, msg)
         }
 
         fn conn_open_ack(ref self: ComponentState<TContractState>, msg: MsgConnOpenAck) {
@@ -109,7 +113,7 @@ pub mod ConnectionHandlerComponent {
 
         fn conn_open_init_execute(
             ref self: ComponentState<TContractState>, connection_sequence: u64, msg: MsgConnOpenInit
-        ) {
+        ) -> ConnectionId {
             let conn_end_on_a = ConnectionEndTrait::init(
                 msg.client_id_on_a.clone(),
                 msg.client_id_on_b.clone(),
@@ -129,6 +133,8 @@ pub mod ConnectionHandlerComponent {
                 .emit_conn_open_init_event(
                     msg.client_id_on_a.clone(), conn_id_on_a.clone(), msg.client_id_on_b,
                 );
+
+            conn_id_on_a
         }
     }
 
@@ -177,7 +183,7 @@ pub mod ConnectionHandlerComponent {
 
         fn conn_open_try_execute(
             ref self: ComponentState<TContractState>, connection_sequence: u64, msg: MsgConnOpenTry
-        ) {
+        ) -> ConnectionId {
             let chan_end_on_b = ConnectionEndTrait::try_open(
                 msg.client_id_on_b.clone(),
                 msg.client_id_on_a.clone(),
@@ -201,6 +207,8 @@ pub mod ConnectionHandlerComponent {
                     msg.client_id_on_a.clone(),
                     msg.conn_id_on_a
                 );
+
+            conn_id_on_b
         }
     }
 
@@ -513,4 +521,3 @@ pub mod ConnectionHandlerComponent {
         }
     }
 }
-

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

@@ -5,9 +5,9 @@ use starknet_ibc_core::host::ConnectionId;
 
 #[starknet::interface]
 pub trait IConnectionHandler<TContractState> {
-    fn conn_open_init(ref self: TContractState, msg: MsgConnOpenInit);
+    fn conn_open_init(ref self: TContractState, msg: MsgConnOpenInit) -> ConnectionId;
 
-    fn conn_open_try(ref self: TContractState, msg: MsgConnOpenTry);
+    fn conn_open_try(ref self: TContractState, msg: MsgConnOpenTry) -> ConnectionId;
 
     fn conn_open_ack(ref self: TContractState, msg: MsgConnOpenAck);
 

cairo-contracts/packages/testkit/src/handles/core.cairo

@@ -78,11 +78,11 @@ pub impl CoreHandleImpl of CoreHandle {
         self.router_dispatcher().bind_port_id(port_id, app_address)
     }
 
-    fn conn_open_init(self: @CoreContract, msg: MsgConnOpenInit) {
+    fn conn_open_init(self: @CoreContract, msg: MsgConnOpenInit) -> ConnectionId {
         self.connecion_handler_dispatcher().conn_open_init(msg)
     }
 
-    fn conn_open_try(self: @CoreContract, msg: MsgConnOpenTry) {
+    fn conn_open_try(self: @CoreContract, msg: MsgConnOpenTry) -> ConnectionId {
         self.connecion_handler_dispatcher().conn_open_try(msg)
     }