chore: undo import and iter changes

starknet-accounts/src/account/declaration.rs

@@ -3,6 +3,7 @@ use super::{
     LegacyDeclaration, PreparedDeclaration, PreparedLegacyDeclaration, RawDeclaration,
     RawLegacyDeclaration,
 };
+
 use starknet_core::{
     crypto::compute_hash_on_elements,
     types::{

starknet-accounts/src/account/execution.rs

@@ -3,6 +3,7 @@ use super::{
     RawExecution,
 };
 use crate::{Call, ExecutionEncoder};
+
 use starknet_core::{
     crypto::compute_hash_on_elements,
     types::{

starknet-accounts/src/account/mod.rs

@@ -1,4 +1,5 @@
 use crate::Call;
+
 use async_trait::async_trait;
 use auto_impl::auto_impl;
 use starknet_core::types::{

starknet-accounts/src/factory/argent.rs

@@ -1,4 +1,5 @@
 use crate::{AccountFactory, PreparedAccountDeployment, RawAccountDeployment};
+
 use async_trait::async_trait;
 use starknet_core::types::{BlockId, BlockTag, FieldElement};
 use starknet_providers::Provider;

starknet-accounts/src/factory/mod.rs

@@ -1,4 +1,5 @@
 use super::NotPreparedError;
+
 use async_trait::async_trait;
 use starknet_core::{
     crypto::compute_hash_on_elements,

starknet-accounts/src/factory/open_zeppelin.rs

@@ -1,4 +1,5 @@
 use crate::{AccountFactory, PreparedAccountDeployment, RawAccountDeployment};
+
 use async_trait::async_trait;
 use starknet_core::types::{BlockId, BlockTag, FieldElement};
 use starknet_providers::Provider;

starknet-accounts/src/single_owner.rs

@@ -2,6 +2,7 @@ use crate::{
     Account, Call, ConnectedAccount, ExecutionEncoder, RawDeclaration, RawExecution,
     RawLegacyDeclaration,
 };
+
 use async_trait::async_trait;
 use starknet_core::types::{contract::ComputeClassHashError, BlockId, BlockTag, FieldElement};
 use starknet_providers::Provider;

starknet-core/src/crypto.rs

@@ -1,6 +1,6 @@
 use crate::types::FieldElement;
-pub use starknet_crypto::{pedersen_hash, ExtendedSignature, Signature};
 
+pub use starknet_crypto::{pedersen_hash, ExtendedSignature, Signature};
 use starknet_crypto::{rfc6979_generate_k, sign, verify, SignError, VerifyError};
 
 mod errors {

starknet-core/src/serde/byte_array.rs

@@ -1,5 +1,6 @@
 pub mod base64 {
     use alloc::{fmt::Formatter, format, vec::Vec};
+
     use base64::{engine::general_purpose::STANDARD, Engine};
     use serde::{de::Visitor, Deserializer, Serializer};
 

starknet-core/src/serde/num_hex.rs

@@ -1,5 +1,6 @@
 pub mod u64 {
     use alloc::{fmt::Formatter, format};
+
     use serde::{de::Visitor, Deserializer, Serializer};
 
     struct NumHexVisitor;

starknet-core/src/serde/unsigned_field_element.rs

@@ -1,11 +1,13 @@
-use crate::types::FieldElement;
 use alloc::{fmt::Formatter, format};
+
 use serde::{
     de::{Error as DeError, Visitor},
     Deserializer, Serializer,
 };
 use serde_with::{DeserializeAs, SerializeAs};
 
+use crate::types::FieldElement;
+
 pub struct UfeHex;
 
 pub struct UfeHexOption;

starknet-core/src/types/codegen.rs

@@ -22,13 +22,15 @@
 // - `TXN`
 // - `TXN_RECEIPT`
 
+use alloc::{format, string::String, vec::Vec};
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_with::serde_as;
+
 use crate::{
     serde::{byte_array::base64, unsigned_field_element::UfeHex},
     types::FieldElement,
 };
-use alloc::{format, string::String, vec::Vec};
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use serde_with::serde_as;
 
 use super::{serde_impls::NumAsHex, *};
 

starknet-core/src/types/eth_address.rs

@@ -1,5 +1,6 @@
 use alloc::{fmt::Formatter, format};
 use core::str::FromStr;
+
 use serde::{de::Visitor, Deserialize, Serialize};
 use starknet_ff::FieldElement;
 

starknet-core/src/types/execution_result.rs

@@ -1,7 +1,9 @@
-use super::TransactionExecutionStatus;
 use alloc::string::String;
+
 use serde::{Deserialize, Serialize};
 
+use super::TransactionExecutionStatus;
+
 /// A more idiomatic way to access `execution_status` and `revert_reason`.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ExecutionResult {

starknet-core/src/types/hash_256.rs

@@ -3,6 +3,7 @@ use alloc::{
     format,
     str::FromStr,
 };
+
 use serde::{de::Visitor, Deserialize, Serialize};
 use starknet_ff::FieldElement;
 

starknet-core/src/types/mod.rs

@@ -1,8 +1,10 @@
-use crate::serde::unsigned_field_element::UfeHex;
 use alloc::{string::String, vec::Vec};
+
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
 
+use crate::serde::unsigned_field_element::UfeHex;
+
 pub use starknet_ff::*;
 
 mod conversions;

starknet-core/src/types/msg.rs

@@ -1,8 +1,10 @@
-use super::{EthAddress, Hash256, MsgToL1};
 use alloc::vec::Vec;
+
 use sha3::{Digest, Keccak256};
 use starknet_ff::FieldElement;
 
+use super::{EthAddress, Hash256, MsgToL1};
+
 #[derive(Debug, Clone)]
 pub struct MsgToL2 {
     pub from_address: EthAddress,

starknet-core/src/types/serde_impls.rs

@@ -1,8 +1,10 @@
-use super::{SyncStatus, SyncStatusType};
 use alloc::{fmt::Formatter, format};
+
 use serde::{de::Visitor, Deserialize, Deserializer, Serialize};
 use serde_with::{DeserializeAs, SerializeAs};
 
+use super::{SyncStatus, SyncStatusType};
+
 pub(crate) struct NumAsHex;
 
 struct NumAsHexVisitorU64;

starknet-core/src/utils.rs

@@ -1,5 +1,7 @@
-use crate::{crypto::compute_hash_on_elements, types::FieldElement};
 use alloc::string::String;
+
+use crate::{crypto::compute_hash_on_elements, types::FieldElement};
+
 use sha3::{Digest, Keccak256};
 use starknet_crypto::pedersen_hash;
 

starknet-crypto-codegen/src/pedersen.rs

@@ -1,12 +1,13 @@
 // Code ported from the build.rs script here:
 //   https://github.com/eqlabs/pathfinder/blob/7f9a6bb0264943f93a633f61fc4e0bc9237f68a0/crates/stark_hash/build.rs
 
+use std::fmt::Write;
+
 use proc_macro::TokenStream;
 use starknet_curve::{
     curve_params::{PEDERSEN_P0, PEDERSEN_P1, PEDERSEN_P2, PEDERSEN_P3},
     AffinePoint,
 };
-use std::fmt::Write;
 use syn::{parse_macro_input, LitInt};
 
 pub fn lookup_table(input: TokenStream) -> TokenStream {

starknet-crypto-codegen/src/poseidon/mod.rs

@@ -1,9 +1,10 @@
 // Code ported from the build.rs script here:
 //   https://github.com/eqlabs/pathfinder/blob/00a1a74a90a7b8a7f1d07ac3e616be1cb39cf8f1/crates/stark_poseidon/build.rs
 
+use std::fmt::Write;
+
 use proc_macro::TokenStream;
 use starknet_ff::FieldElement;
-use std::fmt::Write;
 
 mod params;
 

starknet-crypto/src/ecdsa.rs

@@ -1,12 +1,13 @@
-use crate::{
-    fe_utils::{add_unbounded, bigint_mul_mod_floor, mod_inverse, mul_mod_floor},
-    FieldElement, RecoverError, SignError, VerifyError,
-};
 use starknet_curve::{
     curve_params::{EC_ORDER, GENERATOR},
     AffinePoint, ProjectivePoint,
 };
 
+use crate::{
+    fe_utils::{add_unbounded, bigint_mul_mod_floor, mod_inverse, mul_mod_floor},
+    FieldElement, RecoverError, SignError, VerifyError,
+};
+
 const ELEMENT_UPPER_BOUND: FieldElement = FieldElement::from_mont([
     18446743986131435553,
     160989183,

starknet-crypto/src/fe_utils.rs

@@ -1,9 +1,11 @@
-use crate::FieldElement;
 use core::ops::{Add, Mul};
+
 use num_bigint::BigInt;
 use num_integer::Integer;
 use num_traits::{One, Zero};
 
+use crate::FieldElement;
+
 // These are inefficient and crappy implementations of crypto math operations because I have
 // absolutely no idea how to do them without using `num-bigint`. But hey it works!!!
 //

starknet-crypto/src/pedersen_hash.rs

@@ -1,7 +1,8 @@
-use crate::pedersen_points::*;
 use starknet_curve::{curve_params, AffinePoint, ProjectivePoint};
 use starknet_ff::FieldElement;
 
+use crate::pedersen_points::*;
+
 const SHIFT_POINT: ProjectivePoint = ProjectivePoint::from_affine_point(&curve_params::SHIFT_POINT);
 
 /// Computes the Starkware version of the Pedersen hash of x and y. All inputs are little-endian.

starknet-crypto/src/rfc6979.rs

@@ -1,9 +1,10 @@
-use crate::FieldElement;
 use crypto_bigint::{ArrayEncoding, ByteArray, Integer, U256};
 use hmac::digest::Digest;
 use sha2::digest::{crypto_common::BlockSizeUser, FixedOutputReset, HashMarker};
 use zeroize::{Zeroize, Zeroizing};
 
+use crate::FieldElement;
+
 const EC_ORDER: U256 =
     U256::from_be_hex("0800000000000010ffffffffffffffffb781126dcae7b2321e66a241adc64d2f");
 

starknet-crypto/src/test_utils.rs

@@ -1,4 +1,5 @@
 #![cfg(test)]
+
 use crate::FieldElement;
 
 pub fn field_element_from_be_hex(hex: &str) -> FieldElement {

starknet-curve/src/curve_params.rs

@@ -1,6 +1,7 @@
-use crate::ec_point::AffinePoint;
 use starknet_ff::FieldElement;
 
+use crate::ec_point::AffinePoint;
+
 pub const EC_ORDER: FieldElement = FieldElement::from_mont([
     8939893405601011193,
     1143265896874747514,

starknet-curve/src/ec_point.rs

@@ -1,6 +1,8 @@
+use starknet_ff::FieldElement;
+
 use crate::curve_params::{ALPHA, BETA};
+
 use core::ops;
-use starknet_ff::FieldElement;
 
 /// A point on an elliptic curve over [FieldElement].
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -133,16 +135,17 @@ impl ops::SubAssign<&AffinePoint> for AffinePoint {
 impl ops::Mul<&[bool]> for &AffinePoint {
     type Output = AffinePoint;
 
+    #[allow(clippy::suspicious_arithmetic_impl)]
     fn mul(self, rhs: &[bool]) -> Self::Output {
-        rhs.iter()
-            .rev()
-            .fold(AffinePoint::identity(), |mut acc, &bit| {
-                acc.double_assign();
-                if bit {
-                    acc += self;
-                }
-                acc
-            })
+        let mut product = AffinePoint::identity();
+        for b in rhs.iter().rev() {
+            product.double_assign();
+            if *b {
+                product += self;
+            }
+        }
+
+        product
     }
 }
 
@@ -278,15 +281,16 @@ impl ops::AddAssign<&ProjectivePoint> for ProjectivePoint {
 impl ops::Mul<&[bool]> for &ProjectivePoint {
     type Output = ProjectivePoint;
 
+    #[allow(clippy::suspicious_arithmetic_impl)]
     fn mul(self, rhs: &[bool]) -> Self::Output {
-        rhs.iter()
-            .rev()
-            .fold(ProjectivePoint::identity(), |mut acc, &bit| {
-                acc.double_assign();
-                if bit {
-                    acc += self;
-                }
-                acc
-            })
+        let mut product = ProjectivePoint::identity();
+        for b in rhs.iter().rev() {
+            product.double_assign();
+            if *b {
+                product += self;
+            }
+        }
+
+        product
     }
 }

starknet-ff/src/lib.rs

@@ -5,15 +5,17 @@
 #[cfg_attr(test, macro_use)]
 extern crate alloc;
 
+use core::{
+    fmt, ops,
+    str::{self, FromStr},
+};
+
 use crate::fr::Fr;
+
 use ark_ff::{
     fields::{Field, Fp256, PrimeField},
     BigInteger, BigInteger256,
 };
-use core::{
-    fmt, ops,
-    str::{self, FromStr},
-};
 use crypto_bigint::{CheckedAdd, CheckedMul, NonZero, Zero, U256};
 
 mod fr;

starknet-providers/src/any.rs

@@ -1,7 +1,3 @@
-use crate::{
-    jsonrpc::{HttpTransport, JsonRpcClient},
-    Provider, ProviderError, SequencerGatewayProvider,
-};
 use async_trait::async_trait;
 use starknet_core::types::{
     BlockHashAndNumber, BlockId, BroadcastedDeclareTransaction,
@@ -14,6 +10,11 @@ use starknet_core::types::{
     TransactionTraceWithHash,
 };
 
+use crate::{
+    jsonrpc::{HttpTransport, JsonRpcClient},
+    Provider, ProviderError, SequencerGatewayProvider,
+};
+
 /// A convenient Box-able type that implements the [Provider] trait. This can be useful when you
 /// want to accept any built-in provider implementation from the library in your appliation, since
 /// the [Provider] trait itself cannot be Box-ed due to the use of associated type.

starknet-providers/src/jsonrpc/mod.rs

@@ -1,3 +1,5 @@
+use std::{any::Any, error::Error, fmt::Display};
+
 use async_trait::async_trait;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use serde_with::serde_as;
@@ -16,7 +18,6 @@ use starknet_core::{
         TransactionTraceWithHash,
     },
 };
-use std::{any::Any, error::Error, fmt::Display};
 
 use crate::{provider::ProviderImplError, Provider, ProviderError};
 

starknet-providers/src/sequencer/mod.rs

@@ -1,4 +1,5 @@
 use crate::provider::ProviderError;
+
 use log::trace;
 use reqwest::{Client, Error as ReqwestError, StatusCode};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};