chore: fix lint warnings and outdated tests (#475)

pallas-hardano/src/storage/immutable/mod.rs

@@ -102,7 +102,10 @@ fn iterate_till_point(
             if block.hash().as_ref().eq(block_hash) && block.slot() == slot {
                 Ok(iter)
             } else {
-                Err(Error::CannotFindBlock(Point::Specific(slot, block_hash.to_vec())).into())
+                Err(Error::CannotFindBlock(Point::Specific(
+                    slot,
+                    block_hash.to_vec(),
+                )))
             }
         }
         Some(Err(_)) | None => Ok(iter),
@@ -231,7 +234,7 @@ pub fn read_blocks_from_point(
                     if block.slot() == 0 && block.number() == 0 {
                         Ok(Box::new(iter))
                     } else {
-                        Err(Error::OriginMissing.into())
+                        Err(Error::OriginMissing)
                     }
                 }
                 Some(Err(_)) | None => Ok(Box::new(iter)),

pallas-hardano/src/storage/immutable/primary.rs

@@ -45,9 +45,7 @@ pub struct Reader {
 impl Reader {
     fn read_version(inner: &mut BufReader<File>) -> Result<u8, Error> {
         let mut buf = [0u8; 1];
-        inner
-            .read_exact(&mut buf)
-            .map_err(|e| Error::VersionMissing(e))?;
+        inner.read_exact(&mut buf).map_err(Error::VersionMissing)?;
         let version = buf[0];
 
         Ok(version)

pallas-hardano/src/storage/immutable/secondary.rs

@@ -156,12 +156,15 @@ mod tests {
     }
 
     #[test]
-    fn can_parse_inconsistent_entries() {
+    fn errors_on_inconsistent_entries() {
         let reader =
             super::read_entries(Path::new("../test_data/inconsistent_indexes"), "10366").unwrap();
 
         for entry in reader {
-            entry.unwrap();
+            match entry {
+                Ok(_) => continue,
+                Err(x) => assert!(matches!(x, super::Error::InconsistentState)),
+            }
         }
     }
 }

pallas-network/src/miniprotocols/localtxsubmission/client.rs

@@ -208,4 +208,4 @@ pub enum Error {
 pub enum Response<Reject> {
     Accepted,
     Rejected(Reject),
-}
+}

pallas-network/src/miniprotocols/localtxsubmission/codec.rs

@@ -38,15 +38,20 @@ where
 
 impl<'b, Tx: Decode<'b, ()>, Reject: Decode<'b, ()>> Decode<'b, ()> for Message<Tx, Reject> {
     fn decode(d: &mut Decoder<'b>, _ctx: &mut ()) -> Result<Self, decode::Error> {
-        if let Err(_) = d.array() {
+        if d.array().is_err() {
             // if the first element isn't an array, it's a plutus error
             // the node sends string data
             let rejection = d.decode()?;
-            // skip this data via setting the decoder position, because it doesn't recognize it with rejection decode
-            let _ = d.set_position(d.input().len());
+
+            // skip this data via setting the decoder position, because it doesn't recognize
+            // it with rejection decode
+            d.set_position(d.input().len());
+
             return Ok(Message::RejectTx(rejection));
         }
+
         let label = d.u16()?;
+
         match label {
             0 => {
                 let tx = d.decode()?;
@@ -55,8 +60,11 @@ impl<'b, Tx: Decode<'b, ()>, Reject: Decode<'b, ()>> Decode<'b, ()> for Message<
             1 => Ok(Message::AcceptTx),
             2 => {
                 let rejection = d.decode()?;
-                // skip this data via setting the decoder position, because it doesn't recognize it with rejection decode
-                let _ = d.set_position(d.input().len());
+
+                // skip this data via setting the decoder position, because it doesn't recognize
+                // it with rejection decode
+                d.set_position(d.input().len());
+
                 Ok(Message::RejectTx(rejection))
             }
             3 => Ok(Message::Done),

pallas-network/src/miniprotocols/txmonitor/codec.rs

@@ -81,18 +81,16 @@ impl<'b> Decode<'b, ()> for Message {
             4 => Ok(Message::AwaitAcquire),
             5 => Ok(Message::RequestNextTx),
             6 => match d.datatype() {
-                Ok(datatype) => {
-                    match datatype {
-                        pallas_codec::minicbor::data::Type::Array
-                        | pallas_codec::minicbor::data::Type::ArrayIndef => {
-                            let tx = d.decode()?;
-                            Ok(Message::ResponseNextTx(Some(tx)))
-                        }
-                        _ => Ok(Message::ResponseNextTx(None))
+                Ok(datatype) => match datatype {
+                    pallas_codec::minicbor::data::Type::Array
+                    | pallas_codec::minicbor::data::Type::ArrayIndef => {
+                        let tx = d.decode()?;
+                        Ok(Message::ResponseNextTx(Some(tx)))
                     }
+                    _ => Ok(Message::ResponseNextTx(None)),
                 },
-                Err(_) => Ok(Message::ResponseNextTx(None))
-            }
+                Err(_) => Ok(Message::ResponseNextTx(None)),
+            },
             7 => {
                 let id = d.decode()?;
                 Ok(Message::RequestHasTx(id))