Formatting

dannywillems · dannywillems · commit ef85a8b6faf7 · 2025-11-14T20:27:58.000+01:00
diff --git a/core/src/block/genesis.rs b/core/src/block/genesis.rs
@@ -1,10 +1,9 @@
+use crate::constants::{constraint_constants, slots_per_window};
 use mina_p2p_messages::{
     bigint::InvalidBigInt,
     v2::{self, StateHash},
 };
 
-use crate::constants::{constraint_constants, slots_per_window};
-
 #[allow(clippy::too_many_arguments)]
 pub fn genesis_and_negative_one_protocol_states(
     constants: v2::MinaBaseProtocolConstantsCheckedValueStableV1,
diff --git a/core/src/block/mod.rs b/core/src/block/mod.rs
@@ -1,18 +1,14 @@
-mod block_with_hash;
-pub use block_with_hash::{BlockHeaderWithHash, BlockWithHash};
-
 mod applied_block;
-pub use applied_block::AppliedBlock;
-
-pub mod prevalidate;
-
+mod block_with_hash;
 pub mod genesis;
+pub mod prevalidate;
 
-use std::sync::Arc;
-
+pub use applied_block::AppliedBlock;
+pub use block_with_hash::{BlockHeaderWithHash, BlockWithHash};
 pub use mina_p2p_messages::v2::{
     MinaBlockBlockStableV2 as Block, MinaBlockHeaderStableV2 as BlockHeader, StateHash as BlockHash,
 };
 
+use std::sync::Arc;
 pub type ArcBlock = Arc<Block>;
 pub type ArcBlockWithHash = BlockWithHash<Arc<Block>>;
diff --git a/core/src/block/prevalidate.rs b/core/src/block/prevalidate.rs
@@ -1,7 +1,6 @@
-use serde::{Deserialize, Serialize};
-
 use super::ArcBlockWithHash;
 use crate::constants::PROTOCOL_VERSION;
+use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub enum BlockPrevalidationError {
diff --git a/ledger/src/account/account.rs b/ledger/src/account/account.rs
@@ -1,17 +1,3 @@
-use std::{io::Cursor, str::FromStr, sync::Arc};
-
-use ark_ff::{BigInteger256, One, UniformRand, Zero};
-use mina_core::constants::PROTOCOL_VERSION;
-use mina_curves::pasta::Fp;
-use mina_p2p_messages::{
-    binprot::{BinProtRead, BinProtWrite},
-    v2,
-};
-use mina_signer::CompressedPubKey;
-use once_cell::sync::{Lazy, OnceCell};
-use rand::{prelude::ThreadRng, seq::SliceRandom, Rng};
-use serde::{Deserialize, Serialize};
-
 use crate::{
     gen_compressed,
     proofs::{
@@ -31,6 +17,15 @@ use crate::{
     zkapps::snark::FlaggedOption,
     AppendToInputs as _, MerklePath, MyCow, ToInputs,
 };
+use ark_ff::{BigInteger256, One, UniformRand, Zero};
+use mina_core::constants::PROTOCOL_VERSION;
+use mina_curves::pasta::Fp;
+use mina_p2p_messages::{
+    binprot::{BinProtRead, BinProtWrite},
+    v2,
+};
+use mina_signer::CompressedPubKey;
+use once_cell::sync::{Lazy, OnceCell};
 use poseidon::hash::{
     hash_noinputs, hash_with_kimchi,
     params::{
@@ -39,6 +34,9 @@ use poseidon::hash::{
     },
     Inputs,
 };
+use rand::{prelude::ThreadRng, seq::SliceRandom, Rng};
+use serde::{Deserialize, Serialize};
+use std::{io::Cursor, str::FromStr, sync::Arc};
 
 use super::common::*;
 
@@ -424,12 +422,6 @@ pub struct VerificationKey {
     pub wrap_vk: Option<()>,
 }
 
-// impl From<VerificationKey> for MinaBaseVerificationKeyWireStableV1Base64 {
-//     fn from(value: VerificationKey) -> Self {
-//         MinaBaseVerificationKeyWireStableV1Base64((&value).into())
-//     }
-// }
-
 impl Check<Fp> for VerificationKey {
     fn check(&self, w: &mut Witness<Fp>) {
         let Self {
diff --git a/ledger/src/account/common.rs b/ledger/src/account/common.rs
@@ -1,10 +1,3 @@
-use std::str::FromStr;
-
-use ark_ff::{UniformRand, Zero};
-use mina_curves::pasta::Fp;
-use o1_utils::{field_helpers::FieldHelpersError, FieldHelpers};
-use serde::{Deserialize, Serialize};
-
 use crate::{
     proofs::{
         field::{Boolean, FieldWitness, ToBoolean},
@@ -17,6 +10,11 @@ use crate::{
     scan_state::currency::{Amount, Balance, Magnitude, Slot, SlotSpan},
     ControlTag, ToInputs,
 };
+use ark_ff::{UniformRand, Zero};
+use mina_curves::pasta::Fp;
+use o1_utils::{field_helpers::FieldHelpersError, FieldHelpers};
+use serde::{Deserialize, Serialize};
+use std::str::FromStr;
 
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct VotingFor(pub Fp);
diff --git a/ledger/src/account/conv.rs b/ledger/src/account/conv.rs
@@ -1,5 +1,15 @@
 #![allow(clippy::type_complexity)]
 
+use super::{Account, AccountId, AuthRequired, TokenId, VerificationKeyWire};
+use crate::{
+    proofs::{
+        field::FieldWitness,
+        transaction::{make_group, InnerCurve, PlonkVerificationKeyEvals},
+    },
+    scan_state::currency::{Amount, Balance, Nonce, Slot, SlotSpan, TxnVersion},
+    AccountIndex, Permissions, ProofVerified, ReceiptChainHash, SetVerificationKey, Timing,
+    TokenSymbol, VerificationKey, VotingFor, ZkAppAccount,
+};
 use ark_ec::short_weierstrass::Affine;
 use ark_ff::{Field, PrimeField};
 use mina_curves::pasta::Fp;
@@ -17,18 +27,6 @@ use mina_p2p_messages::{
     },
 };
 
-use crate::{
-    proofs::{
-        field::FieldWitness,
-        transaction::{make_group, InnerCurve, PlonkVerificationKeyEvals},
-    },
-    scan_state::currency::{Amount, Balance, Nonce, Slot, SlotSpan, TxnVersion},
-    AccountIndex, Permissions, ProofVerified, ReceiptChainHash, SetVerificationKey, Timing,
-    TokenSymbol, VerificationKey, VotingFor, ZkAppAccount,
-};
-
-use super::{Account, AccountId, AuthRequired, TokenId, VerificationKeyWire};
-
 impl binprot::BinProtRead for TokenId {
     fn binprot_read<R: std::io::Read + ?Sized>(r: &mut R) -> Result<Self, binprot::Error>
     where
diff --git a/ledger/src/account/legacy.rs b/ledger/src/account/legacy.rs
@@ -1,13 +1,10 @@
-use std::borrow::Cow;
-
+use super::common::*;
+use crate::scan_state::currency::{Balance, Magnitude, Nonce};
 use ark_ff::Zero;
 use mina_hasher::{create_legacy, Fp, Hashable, Hasher, ROInput};
 use mina_signer::CompressedPubKey;
 use o1_utils::FieldHelpers;
-
-use crate::scan_state::currency::{Balance, Magnitude, Nonce};
-
-use super::common::*;
+use std::borrow::Cow;
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct TokenIdLegacy(pub u64);
diff --git a/ledger/src/address/raw.rs b/ledger/src/address/raw.rs
@@ -261,15 +261,6 @@ impl<const NBYTES: usize> Address<NBYTES> {
 
     pub fn nused_bytes(&self) -> usize {
         self.length.saturating_sub(1) / 8 + 1
-
-        // let length_div = self.length / 8;
-        // let length_mod = self.length % 8;
-
-        // if length_mod == 0 {
-        //     length_div
-        // } else {
-        //     length_div + 1
-        // }
     }
 
     pub fn used_bytes(&self) -> &[u8] {
diff --git a/ledger/src/lib.rs b/ledger/src/lib.rs
@@ -129,9 +129,6 @@ mod wasm {
 #[macro_use]
 mod cache;
 
-#[cfg(all(not(target_family = "wasm"), feature = "ocaml-interop"))]
-mod ffi;
-
 #[cfg(any(test, feature = "fuzzing"))]
 pub mod generators;
 
diff --git a/mina-p2p-messages/src/array.rs b/mina-p2p-messages/src/array.rs
@@ -1,9 +1,8 @@
-use std::ops::Deref;
-
 use binprot::{BinProtRead, BinProtWrite, Nat0};
 use malloc_size_of_derive::MallocSizeOf;
 use rsexp::OfSexp;
 use serde::{Deserialize, Serialize};
+use std::ops::Deref;
 
 /// Mina array bounded to specific length. Note that the length is only checked
 /// when performing binprot operations.
diff --git a/mina-p2p-messages/src/b58.rs b/mina-p2p-messages/src/b58.rs
@@ -1,12 +1,11 @@
 //! Base58check encoding/decoding.
 
-use std::{fmt, marker::PhantomData, str::FromStr};
-
 use binprot::{BinProtRead, BinProtWrite};
 use binprot_derive::{BinProtRead, BinProtWrite};
 use derive_more::From;
 use malloc_size_of_derive::MallocSizeOf;
 use serde::{Deserialize, Serialize};
+use std::{fmt, marker::PhantomData, str::FromStr};
 
 /// Before encoding, data is prepended with the version byte.
 pub fn encode(b: &[u8], v: u8) -> String {
@@ -373,7 +372,6 @@ mod tests {
     }
 
     #[test]
-    #[ignore = "fix or remove"]
     fn binable_base58check() {
         #[derive(Clone, BinProtRead, BinProtWrite)]
         struct Binable(BigInt);
diff --git a/mina-p2p-messages/src/bigint.rs b/mina-p2p-messages/src/bigint.rs
@@ -1,4 +1,4 @@
-use ark_ff::BigInteger256;
+use ark_ff::{BigInteger256, PrimeField};
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use malloc_size_of::MallocSizeOf;
 use rsexp::{OfSexp, SexpOf};
@@ -100,55 +100,55 @@ impl AsRef<BigInteger256> for BigInt {
 
 impl From<mina_curves::pasta::Fp> for BigInt {
     fn from(field: mina_curves::pasta::Fp) -> Self {
-        use ark_ff::PrimeField;
         Self(field.into_bigint())
     }
 }
 
 impl From<mina_curves::pasta::Fq> for BigInt {
     fn from(field: mina_curves::pasta::Fq) -> Self {
-        use ark_ff::PrimeField;
         Self(field.into_bigint())
     }
 }
 
 impl From<&mina_curves::pasta::Fp> for BigInt {
     fn from(field: &mina_curves::pasta::Fp) -> Self {
-        use ark_ff::PrimeField;
         Self(field.into_bigint())
     }
 }
 
 impl From<&mina_curves::pasta::Fq> for BigInt {
     fn from(field: &mina_curves::pasta::Fq) -> Self {
-        use ark_ff::PrimeField;
         Self(field.into_bigint())
     }
 }
 
 impl TryFrom<BigInt> for mina_curves::pasta::Fp {
     type Error = InvalidBigInt;
+
     fn try_from(bigint: BigInt) -> Result<Self, Self::Error> {
         bigint.to_field()
     }
 }
 
 impl TryFrom<BigInt> for mina_curves::pasta::Fq {
     type Error = InvalidBigInt;
+
     fn try_from(bigint: BigInt) -> Result<Self, Self::Error> {
         bigint.to_field()
     }
 }
 
 impl TryFrom<&BigInt> for mina_curves::pasta::Fp {
     type Error = InvalidBigInt;
+
     fn try_from(bigint: &BigInt) -> Result<Self, Self::Error> {
         bigint.to_field()
     }
 }
 
 impl TryFrom<&BigInt> for mina_curves::pasta::Fq {
     type Error = InvalidBigInt;
+
     fn try_from(bigint: &BigInt) -> Result<Self, Self::Error> {
         bigint.to_field()
     }
@@ -333,9 +333,8 @@ impl mina_hasher::Hashable for BigInt {
 
 #[cfg(test)]
 mod tests {
-    use binprot::{BinProtRead, BinProtWrite};
-
     use super::BigInt;
+    use binprot::{BinProtRead, BinProtWrite};
 
     fn to_binprot(v: &BigInt) -> Vec<u8> {
         let mut w = Vec::new();
@@ -347,10 +346,9 @@ mod tests {
         BigInt::binprot_read(&mut b).unwrap()
     }
 
-    fn from_byte(b: u8) -> BigInt {
-        BigInt::from_bytes([b; 32])
-    }
-
+    /// Build a BigInt from a sequence of bytes.
+    /// If the input contains less than 32 bytes, the sequence is repeated until reaching 32 bytes
+    /// and filling the BigInt buffer.
     fn from_bytes<'a, I>(it: I) -> BigInt
     where
         I: IntoIterator<Item = &'a u8>,
@@ -365,9 +363,9 @@ mod tests {
     #[test]
     fn serialize_bigint() {
         let bigints = [
-            from_byte(0),
-            from_byte(1),
-            from_byte(0xff),
+            BigInt::from_bytes([0; 32]),
+            BigInt::from_bytes([1; 32]),
+            BigInt::from_bytes([0xff; 32]),
             from_bytes(&[0, 1, 2, 3, 4]),
         ];
 
@@ -380,9 +378,9 @@ mod tests {
     #[test]
     fn deserialize_bigint() {
         let bigints = [
-            from_byte(0),
-            from_byte(1),
-            from_byte(0xff),
+            BigInt::from_bytes([0; 32]),
+            BigInt::from_bytes([1; 32]),
+            BigInt::from_bytes([0xff; 32]),
             from_bytes(&[0, 1, 2, 3, 4]),
         ];
 
@@ -395,9 +393,9 @@ mod tests {
     #[test]
     fn to_json() {
         let bigints = [
-            from_byte(0),
-            from_byte(1),
-            from_byte(0xff),
+            BigInt::from_bytes([0; 32]),
+            BigInt::from_bytes([1; 32]),
+            BigInt::from_bytes([0xff; 32]),
             from_bytes(&[0, 1, 2, 3, 4]),
         ];
 
@@ -413,9 +411,9 @@ mod tests {
     #[test]
     fn from_json() {
         let bigints = [
-            from_byte(0),
-            from_byte(1),
-            from_byte(0xff),
+            BigInt::from_bytes([0; 32]),
+            BigInt::from_bytes([1; 32]),
+            BigInt::from_bytes([0xff; 32]),
             from_bytes(&[0, 1, 2, 3, 4]),
         ];
 
diff --git a/mina-p2p-messages/src/core.rs b/mina-p2p-messages/src/core.rs
@@ -1,13 +1,12 @@
 //! Types from Janestreet's Core library.
 
-use std::net::IpAddr;
-
 use crate::{
     string::{ByteString, CharString},
     versioned::Versioned,
 };
 use binprot_derive::{BinProtRead, BinProtWrite};
 use serde::{Deserialize, Serialize};
+use std::net::IpAddr;
 
 /// This type corresponds to `Bounded_types.Wrapped_error` OCaml type, but the
 /// structure is different. It only refrects the data that is passed over the
diff --git a/mina-p2p-messages/src/gossip.rs b/mina-p2p-messages/src/gossip.rs
diff --git a/mina-p2p-messages/src/hash.rs b/mina-p2p-messages/src/hash.rs
diff --git a/mina-p2p-messages/src/hash_input.rs b/mina-p2p-messages/src/hash_input.rs
diff --git a/mina-p2p-messages/src/v2/dummy/mod.rs b/mina-p2p-messages/src/v2/dummy/mod.rs
diff --git a/mina-p2p-messages/src/v2/generated.rs b/mina-p2p-messages/src/v2/generated.rs
diff --git a/mina-p2p-messages/src/v2/manual.rs b/mina-p2p-messages/src/v2/manual.rs
