chore: Apply code formatting

pallas-miniprotocols/src/handshake/n2c.rs

@@ -54,7 +54,6 @@ impl VersionTable {
             (PROTOCOL_V10, VersionData(network_magic)),
             (PROTOCOL_V11, VersionData(network_magic)),
             (PROTOCOL_V12, VersionData(network_magic)),
-
         ]
         .into_iter()
         .collect::<HashMap<u64, VersionData>>();

pallas-miniprotocols/src/lib.rs

@@ -5,8 +5,8 @@ pub mod blockfetch;
 pub mod chainsync;
 pub mod handshake;
 pub mod localstate;
-pub mod txsubmission;
 pub mod txmonitor;
+pub mod txsubmission;
 
 pub use common::*;
 pub use machines::*;

pallas-miniprotocols/src/txmonitor/codec.rs

@@ -1,9 +1,7 @@
-use super::{Message, MsgRequest, MsgResponse, MempoolSizeAndCapacity};
+use super::{MempoolSizeAndCapacity, Message, MsgRequest, MsgResponse};
 use pallas_codec::minicbor::{decode, encode, Decode, Encode, Encoder};
 
-impl Encode<()> for Message 
+impl Encode<()> for Message {
-    {
-
     fn encode<W: encode::Write>(
         &self,
         e: &mut Encoder<W>,
@@ -12,18 +10,17 @@ impl Encode<()> for Message
         match self {
             Message::MsgDone => {
                 e.array(1)?.u16(0)?;
-            },
+            }
             Message::MsgAcquire => {
                 e.array(1)?.u16(1)?;
-                
+            }
-            },
             Message::MsgAcquired(slot) => {
                 e.array(2)?.u16(2)?;
                 e.encode(slot)?;
-            },
+            }
             Message::MsgQuery(query) => {
                 query.encode(e, ctx)?;
-            },
+            }
             Message::MsgResponse(response) => {
                 response.encode(e, ctx)?;
             }
@@ -34,27 +31,22 @@ impl Encode<()> for Message
 }
 
 impl<'b> Decode<'b, ()> for Message {
-fn decode(d: &mut pallas_codec::minicbor::Decoder<'b>, _ctx: &mut ()) -> Result<Self, decode::Error> {
+    fn decode(
+        d: &mut pallas_codec::minicbor::Decoder<'b>,
+        _ctx: &mut (),
+    ) -> Result<Self, decode::Error> {
         d.array()?;
         let label = d.u16()?;
         log::debug!("decode message: {:?}", label);
         match label {
-            0 => {
+            0 => Ok(Message::MsgDone),
-                Ok(Message::MsgDone)
+            1 => Ok(Message::MsgAcquire),
-            },
-            1 => {
-                Ok(Message::MsgAcquire)
-            },
             2 => {
                 let slot = d.decode()?;
                 Ok(Message::MsgAcquired(slot))
-            },
+            }
-            3 => {
+            3 => Ok(Message::MsgQuery(MsgRequest::MsgRelease)),
-                Ok(Message::MsgQuery(MsgRequest::MsgRelease))
+            5 => Ok(Message::MsgQuery(MsgRequest::MsgNextTx)),
-            },
-            5 => {
-                Ok(Message::MsgQuery(MsgRequest::MsgNextTx))
-            },
             6 => {
                 log::trace!("Decoding 6, 1. Array: {:?}", d);
                 let de: Result<Option<u64>, pallas_codec::minicbor::decode::Error> = d.array();
@@ -68,10 +60,9 @@ fn decode(d: &mut pallas_codec::minicbor::Decoder<'b>, _ctx: &mut ()) -> Result<
                     let cbor = d.bytes()?;
                     tx = Some(hex::encode(cbor));
                     log::trace!("Decoding 6, Tx: {:?}", tx);
-    
                 }
                 Ok(Message::MsgResponse(MsgResponse::MsgReplyNextTx(tx)))
-            },
+            }
             7 => {
                 let txid = d.decode()?;
                 Ok(Message::MsgQuery(MsgRequest::MsgHasTx(txid)))
@@ -80,25 +71,21 @@ fn decode(d: &mut pallas_codec::minicbor::Decoder<'b>, _ctx: &mut ()) -> Result<
                 let has = d.decode()?;
                 Ok(Message::MsgResponse(MsgResponse::MsgReplyHasTx(has)))
             }
-            9 => {
+            9 => Ok(Message::MsgQuery(MsgRequest::MsgGetSizes)),
-                Ok(Message::MsgQuery(MsgRequest::MsgGetSizes))
-            }
             10 => {
                 d.array()?;
                 let capacity = d.decode()?;
                 let size_in_bytes = d.decode()?;
                 let number_of_tx = d.decode()?;
-                Ok(
+                Ok(Message::MsgResponse(MsgResponse::MsgReplyGetSizes(
-                    Message::MsgResponse(MsgResponse::MsgReplyGetSizes(MempoolSizeAndCapacity {
+                    MempoolSizeAndCapacity {
                         capacity_in_bytes: capacity,
                         size_in_bytes: size_in_bytes,
                         number_of_txs: number_of_tx,
-                    }))
+                    },
-                )
+                )))
             }
-            _ => Err(decode::Error::message(
+            _ => Err(decode::Error::message("can't decode Message")),
-                "can't decode Message",
-            ))
         }
     }
 
@@ -116,21 +103,20 @@ impl Encode<()> for MsgRequest {
         match self {
             MsgRequest::MsgAwaitAcquire => {
                 e.array(1)?.u16(1)?;
-            },
+            }
             MsgRequest::MsgGetSizes => {
                 e.array(1)?.u16(9)?;
-            },
+            }
             MsgRequest::MsgHasTx(tx) => {
                 e.array(2)?.u16(7)?;
                 e.encode(tx)?;
-            },
+            }
             MsgRequest::MsgNextTx => {
                 e.array(1)?.u16(5)?;
-            },
+            }
             MsgRequest::MsgRelease => {
                 e.array(1)?.u16(3)?;
-            },
+            }
-
         }
         log::debug!("encode message: {:?}", self);
         Ok(())
@@ -150,18 +136,18 @@ impl Encode<()> for MsgResponse {
                 e.encode(sz.capacity_in_bytes)?;
                 e.encode(sz.size_in_bytes)?;
                 e.encode(sz.number_of_txs)?;
-            },
+            }
             MsgResponse::MsgReplyHasTx(tx) => {
                 e.array(2)?.u16(8)?;
                 e.encode(tx)?;
-            },
+            }
             MsgResponse::MsgReplyNextTx(None) => {
                 e.array(1)?.u16(6)?;
-            },
+            }
             MsgResponse::MsgReplyNextTx(Some(tx)) => {
                 e.array(2)?.u16(6)?;
                 e.encode(tx.to_string())?;
-            },
+            }
         }
         Ok(())
     }

pallas-miniprotocols/src/txmonitor/mod.rs

@@ -1,8 +1,8 @@
 mod codec;
 
-use std::{fmt::{Debug}};
-use pallas_codec::Fragment;
 use crate::machines::{Agent, MachineError, Transition};
+use pallas_codec::Fragment;
+use std::fmt::Debug;
 
 type Slot = u64;
 type TxId = String;
@@ -40,7 +40,6 @@ pub enum Message {
     MsgDone,
 }
 
-
 #[derive(Debug, Clone)]
 pub enum MsgRequest {
     MsgAwaitAcquire,
@@ -68,7 +67,6 @@ impl LocalTxMonitor
 where
     Message: Fragment,
 {
-    
     pub fn initial(state: State) -> Self {
         Self {
             state: state,
@@ -95,7 +93,6 @@ impl LocalTxMonitor
             output: Some(MsgResponse::MsgReplyNextTx(tx)),
             ..self
         })
-       
     }
 
     fn on_reply_has_tx(self, arg: bool) -> Transition<Self> {
@@ -118,7 +115,8 @@ impl LocalTxMonitor
 
 impl Agent for LocalTxMonitor
 where
-        Message: Fragment, {
+    Message: Fragment,
+{
     type Message = Message;
     type State = State;
 
@@ -128,14 +126,18 @@ impl Agent for LocalTxMonitor
     }
 
     fn is_done(&self) -> bool {
-        
         let done = self.state == State::StDone;
         log::debug!("is_done: {:?}", done);
         done
     }
 
     fn has_agency(&self) -> bool {
-        log::trace!("Hase Agency:  State: {:?}, Request: {:?}, Response: {:?}",self.state,self.request,self.output);
+        log::trace!(
+            "Hase Agency:  State: {:?}, Request: {:?}, Response: {:?}",
+            self.state,
+            self.request,
+            self.output
+        );
         match &self.state {
             State::StIdle => true,
             State::StAcquiring => false,
@@ -146,17 +148,28 @@ impl Agent for LocalTxMonitor
     }
 
     fn build_next(&self) -> Self::Message {
-        log::debug!("build next; State: {:?}, request: {:?}, output: {:?}",&self.state, &self.request, &self.output);
+        log::debug!(
+            "build next; State: {:?}, request: {:?}, output: {:?}",
+            &self.state,
+            &self.request,
+            &self.output
+        );
         match (&self.state, &self.request, &self.output) {
             (State::StIdle, None, None) => Message::MsgAcquire,
             (State::StAcquired, None, None) => Message::MsgAcquire,
             (State::StAcquired, Some(MsgRequest::MsgAwaitAcquire), None) => Message::MsgAcquire,
-            (State::StAcquired, Some(MsgRequest::MsgNextTx),None)           => Message::MsgQuery(MsgRequest::MsgNextTx),
+            (State::StAcquired, Some(MsgRequest::MsgNextTx), None) => {
-            (State::StAcquired, Some(MsgRequest::MsgHasTx(tx)),None) => Message::MsgQuery(MsgRequest::MsgHasTx(tx.clone())),
+                Message::MsgQuery(MsgRequest::MsgNextTx)
-            (State::StAcquired, Some(MsgRequest::MsgGetSizes),None)         => Message::MsgQuery(MsgRequest::MsgGetSizes),
+            }
+            (State::StAcquired, Some(MsgRequest::MsgHasTx(tx)), None) => {
+                Message::MsgQuery(MsgRequest::MsgHasTx(tx.clone()))
+            }
+            (State::StAcquired, Some(MsgRequest::MsgGetSizes), None) => {
+                Message::MsgQuery(MsgRequest::MsgGetSizes)
+            }
             (State::StAcquired, None, Some(_)) => Message::MsgAcquire,
             (State::StAcquired, Some(req), Some(_)) => Message::MsgQuery(req.to_owned()),
-            _ => panic!("I do not have agency, don't know what to do")
+            _ => panic!("I do not have agency, don't know what to do"),
         }
     }
 
@@ -168,13 +181,13 @@ impl Agent for LocalTxMonitor
     fn apply_outbound(self, msg: Self::Message) -> Transition<Self> {
         log::debug!("apply outbound");
         match (self.state, msg) {
-            
             (State::StIdle, Message::MsgAcquire) => {
                 log::debug!("apply outbound : MsgAcquire");
                 Ok(Self {
                     state: State::StAcquiring,
                     ..self
-            })},
+                })
+            }
             (State::StAcquired, Message::MsgQuery(MsgRequest::MsgNextTx)) => Ok(Self {
                 state: State::StBusy(StBusyKind::NextTx),
                 ..self
@@ -201,7 +214,7 @@ impl Agent for LocalTxMonitor
                 ..self
             }),
 
-            _ => panic!("PANIC! Cannot match outbound")
+            _ => panic!("PANIC! Cannot match outbound"),
         }
     }
 
@@ -209,12 +222,19 @@ impl Agent for LocalTxMonitor
         log::debug!("apply inbound");
         match (&self.state, msg) {
             (State::StAcquiring, Message::MsgAcquired(s)) => self.on_acquired(s),
-            (State::StBusy(StBusyKind::NextTx), Message::MsgResponse(MsgResponse::MsgReplyNextTx(tx)))               => self.on_reply_next_tx(tx),
+            (
-            (State::StBusy(StBusyKind::HasTx), Message::MsgResponse(MsgResponse::MsgReplyHasTx(arg)))                          => self.on_reply_has_tx(arg),
+                State::StBusy(StBusyKind::NextTx),
-            (State::StBusy(StBusyKind::GetSizes), Message::MsgResponse(MsgResponse::MsgReplyGetSizes(msc)))  => self.on_reply_get_size(msc),
+                Message::MsgResponse(MsgResponse::MsgReplyNextTx(tx)),
+            ) => self.on_reply_next_tx(tx),
+            (
+                State::StBusy(StBusyKind::HasTx),
+                Message::MsgResponse(MsgResponse::MsgReplyHasTx(arg)),
+            ) => self.on_reply_has_tx(arg),
+            (
+                State::StBusy(StBusyKind::GetSizes),
+                Message::MsgResponse(MsgResponse::MsgReplyGetSizes(msc)),
+            ) => self.on_reply_get_size(msc),
             (state, msg) => Err(MachineError::invalid_msg::<Self>(&state, &msg)),
-
         }
     }
-
 }