Seemingly fix broadcast hanging error.

EspressoSystems · Aug 22, 2023 · 70cb1eb · 70cb1eb
1 parent 183e642
commit 70cb1eb
Show file tree

Hide file tree

Showing 3 changed files with 31 additions and 26 deletions.
diff --git a/src/lib.rs b/src/lib.rs
@@ -324,29 +324,45 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>> SystemContext<TYPES, I> {
         };
     }
 
-    /// Publishes a transaction to the network
+    /// Publishes a transaction asynchronously to the network
     ///
     /// # Errors
     ///
-    /// Will generate an error if an underlying network error occurs
+    /// Always returns Ok; does not return an error if the transaction couldn't be published to the network
     #[instrument(skip(self), err)]
     pub async fn publish_transaction_async(
         &self,
         transaction: TYPES::Transaction,
     ) -> Result<(), HotShotError<TYPES>> {
-        // Add the transaction to our own queue first
         trace!("Adding transaction to our own queue");
         // Wrap up a message
         // TODO place a view number here that makes sense
         // we haven't worked out how this will work yet
-        // let message = DataMessage::SubmitTransaction(transaction, TYPES::Time::new(0));
-
-        // self.inner.exchanges.committee_exchange().network.broadcast(message).await;
-
-        // let api = self.clone();
-        // async_spawn(async move {
-        //     // let _result = self.inner.exchanges.committee_exchange().network.broadcast(message).await.is_err();
-        // });
+        let message = DataMessage::SubmitTransaction(transaction, TYPES::Time::new(0));
+        let api = self.clone();
+        // TODO We should have a function that can return a network error if there is one
+        // but first we'd need to ensure our network implementations can support that
+        // (and not hang instead)
+        async_spawn(async move {
+            let _result = api
+                .inner
+                .exchanges
+                .committee_exchange()
+                .network()
+                .broadcast_message(
+                    Message {
+                        sender: api.inner.public_key.clone(),
+                        kind: MessageKind::from(message),
+                        _phantom: PhantomData,
+                    },
+                    &api.inner
+                        .exchanges
+                        .committee_exchange()
+                        .membership()
+                        .clone(),
+                )
+                .await;
+        });
         Ok(())
     }
 

diff --git a/src/types/handle.rs b/src/types/handle.rs
@@ -167,10 +167,6 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES> + 'static> SystemContextHandl
     ///
     /// Will return a [`HotShotError`] if some error occurs in the underlying
     /// [`SystemContext`] instance.
-    ///
-    /// For now this function is deprecated.  Use `send_transaction` instead
-    /// This function will be updated with <https://github.com/EspressoSystems/HotShot/issues/1526>
-    #[deprecated]
     pub async fn submit_transaction(
         &self,
         tx: TYPES::Transaction,

diff --git a/testing/src/txn_task.rs b/testing/src/txn_task.rs
@@ -108,7 +108,6 @@ impl TxnTaskDescription {
                                     }
                                     Some(node) => {
                                         // use rand::seq::IteratorRandom;
-                                        // handle.submit_transaction()
                                         // we're assuming all nodes have the same leaf.
                                         // If they don't match, this is probably fine since
                                         // it should be caught by an assertion (and the txn will be rejected anyway)
@@ -118,16 +117,10 @@ impl TxnTaskDescription {
                                             &mut thread_rng(),
                                             0,
                                         );
-                                        // ED Shouldn't create this each time
-                                        let api = HotShotSequencingConsensusApi {
-                                            inner: node.handle.hotshot.inner.clone(),
-                                        };
-                                        api.send_transaction(DataMessage::SubmitTransaction(
-                                            txn.clone(),
-                                            TYPES::Time::new(0),
-                                        ))
-                                        .await
-                                        .expect("Could not send transaction");
+                                        node.handle
+                                            .submit_transaction(txn.clone())
+                                            .await
+                                            .expect("Could not send transaction");
                                         (None, state)
                                     }
                                 }