Apply an initial set of rustfmt rules

coins/monero/src/serialize.rs

@@ -1,6 +1,9 @@
 use std::io;
 
-use curve25519_dalek::{scalar::Scalar, edwards::{EdwardsPoint, CompressedEdwardsY}};
+use curve25519_dalek::{
+  scalar::Scalar,
+  edwards::{EdwardsPoint, CompressedEdwardsY},
+};
 
 pub const VARINT_CONTINUATION_MASK: u8 = 0b1000_0000;
 
@@ -30,22 +33,22 @@ pub fn write_point<W: io::Write>(point: &EdwardsPoint, w: &mut W) -> io::Result<
   w.write_all(&point.compress().to_bytes())
 }
 
-pub fn write_raw_vec<
-  T,
-  W: io::Write,
-  F: Fn(&T, &mut W) -> io::Result<()>
->(f: F, values: &[T], w: &mut W) -> io::Result<()> {
+pub fn write_raw_vec<T, W: io::Write, F: Fn(&T, &mut W) -> io::Result<()>>(
+  f: F,
+  values: &[T],
+  w: &mut W,
+) -> io::Result<()> {
   for value in values {
     f(value, w)?;
   }
   Ok(())
 }
 
-pub fn write_vec<
-  T,
-  W: io::Write,
-  F: Fn(&T, &mut W) -> io::Result<()>
->(f: F, values: &[T], w: &mut W) -> io::Result<()> {
+pub fn write_vec<T, W: io::Write, F: Fn(&T, &mut W) -> io::Result<()>>(
+  f: F,
+  values: &[T],
+  w: &mut W,
+) -> io::Result<()> {
   write_varint(&values.len().try_into().unwrap(), w)?;
   write_raw_vec(f, &values, w)
 }
@@ -75,23 +78,26 @@ pub fn read_32<R: io::Read>(r: &mut R) -> io::Result<[u8; 32]> {
   Ok(res)
 }
 
-// TODO: Potentially update to Monero's parsing rules on scalars/points, which should be any arbitrary 32-bytes
-// We may be able to consider such transactions as malformed and accordingly be opinionated in ignoring them
+// TODO: https://github.com/serai-dex/serai/issues/25
 pub fn read_scalar<R: io::Read>(r: &mut R) -> io::Result<Scalar> {
-  Scalar::from_canonical_bytes(
-    read_32(r)?
-  ).ok_or(io::Error::new(io::ErrorKind::Other, "unreduced scalar"))
+  Scalar::from_canonical_bytes(read_32(r)?)
+    .ok_or(io::Error::new(io::ErrorKind::Other, "unreduced scalar"))
 }
 
 pub fn read_point<R: io::Read>(r: &mut R) -> io::Result<EdwardsPoint> {
-  CompressedEdwardsY(
-    read_32(r)?
-  ).decompress().filter(|point| point.is_torsion_free()).ok_or(io::Error::new(io::ErrorKind::Other, "invalid point"))
+  CompressedEdwardsY(read_32(r)?)
+    .decompress()
+    .filter(|point| point.is_torsion_free())
+    .ok_or(io::Error::new(io::ErrorKind::Other, "invalid point"))
 }
 
-pub fn read_raw_vec<R: io::Read, T, F: Fn(&mut R) -> io::Result<T>>(f: F, len: usize, r: &mut R) -> io::Result<Vec<T>> {
+pub fn read_raw_vec<R: io::Read, T, F: Fn(&mut R) -> io::Result<T>>(
+  f: F,
+  len: usize,
+  r: &mut R,
+) -> io::Result<Vec<T>> {
   let mut res = Vec::with_capacity(
-    len.try_into().map_err(|_| io::Error::new(io::ErrorKind::Other, "length exceeds usize"))?
+    len.try_into().map_err(|_| io::Error::new(io::ErrorKind::Other, "length exceeds usize"))?,
   );
   for _ in 0 .. len {
     res.push(f(r)?);
@@ -99,6 +105,9 @@ pub fn read_raw_vec<R: io::Read, T, F: Fn(&mut R) -> io::Result<T>>(f: F, len: u
   Ok(res)
 }
 
-pub fn read_vec<R: io::Read, T, F: Fn(&mut R) -> io::Result<T>>(f: F, r: &mut R) -> io::Result<Vec<T>> {
+pub fn read_vec<R: io::Read, T, F: Fn(&mut R) -> io::Result<T>>(
+  f: F,
+  r: &mut R,
+) -> io::Result<Vec<T>> {
   read_raw_vec(f, read_varint(r)?.try_into().unwrap(), r)
 }