Don't unnecessarily create async blocks

If our expression directly evaluates to a future, we don't need to
create an async block.

This requires us to have `EventLoopRun::run` consume the instance
instead of just taking a mutable reference (otherwise we run into
lifetime issues). However, that is better anyway because `run` is
an endless loop so you never get to use the handle afterwards
anyway.

swap/src/bin/asb.rs

@@ -100,7 +100,7 @@ async fn main() -> Result<()> {
 
             let rate_service = kraken::RateService::new().await?;
 
-            let (mut event_loop, _) = EventLoop::new(
+            let (event_loop, _) = EventLoop::new(
                 config.network.listen,
                 seed,
                 execution_params,

swap/src/bin/swap_cli.rs

@@ -149,7 +149,7 @@ async fn main() -> Result<()> {
             );
             let (swap, event_loop) = bob_factory.with_init_params(send_bitcoin).build().await?;
 
-            let handle = tokio::spawn(async move { event_loop.run().await });
+            let handle = tokio::spawn(event_loop.run());
             let swap = bob::run(swap);
             tokio::select! {
                 event_loop_result = handle => {
@@ -193,7 +193,7 @@ async fn main() -> Result<()> {
                 execution_params,
             );
             let (swap, event_loop) = bob_factory.build().await?;
-            let handle = tokio::spawn(async move { event_loop.run().await });
+            let handle = tokio::spawn(event_loop.run());
             let swap = bob::run(swap);
             tokio::select! {
                 event_loop_result = handle => {

swap/src/protocol/alice/event_loop.rs

@@ -158,7 +158,7 @@ where
         self.peer_id
     }
 
-    pub async fn run(&mut self) {
+    pub async fn run(mut self) {
         loop {
             tokio::select! {
                 swarm_event = self.swarm.next().fuse() => {