lint & clippy fixes

Author: azixus

crates/blocklock-warp/src/agent.rs

@@ -1,21 +1,19 @@
 //! Agent managing the state of the blocklock smart contract and forwarding fulfilled request to a
 //! fulfiller's request channel.
 
-use crate::condition_resolver::{
-    BlocklockConditionResolver, BlocklockConditionResolverError,
-};
+use crate::condition_resolver::{BlocklockConditionResolver, BlocklockConditionResolverError};
 use crate::metrics::Metrics;
 use crate::{BlockNumber, BlocklockConditionUpdate};
 use alloy::network::Ethereum;
-use alloy::primitives::ruint::FromUintError;
 use alloy::primitives::U256;
+use alloy::primitives::ruint::FromUintError;
 use alloy::providers::{Dynamic, MulticallBuilder, MulticallError, Provider};
-use contracts_core::blocklock::blocklock::decryption_sender::TypesLib as DecryptionSenderTypes;
+use contracts_core::blocklock::decryption_sender::TypesLib as DecryptionSenderTypes;
 
-use fulfiller_core::decryption_sender::contracts::DecryptionSender;
+use fulfiller_core::RequestId;
 use fulfiller_core::decryption_sender::DecryptionRequest;
+use fulfiller_core::decryption_sender::contracts::DecryptionSender;
 use fulfiller_core::fulfiller::RequestChannel;
-use fulfiller_core::RequestId;
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 use std::ops::{Add, Sub};
@@ -581,10 +579,10 @@ mod tests {
     use alloy::sol_types::{SolEvent, SolValue};
     use ark_ec::{AffineRepr, CurveGroup, Group};
     use ark_ff::{BigInteger, MontFp, PrimeField};
-    use ark_std::rand::thread_rng;
     use ark_std::UniformRand;
-    use futures_util::future::join_all;
+    use ark_std::rand::thread_rng;
     use futures_util::StreamExt;
+    use futures_util::future::join_all;
     use std::collections::VecDeque;
     use std::ops::AddAssign;
     use std::rc::Rc;
@@ -597,12 +595,14 @@ mod tests {
     use contracts_core::blocklock::decryption_sender::DecryptionSender::{
         DecryptionRequested, DecryptionSenderInstance,
     };
+    use contracts_core::blocklock::mock_blocklock_receiver::BLS as MockBlocklockReceiverBLS;
     use contracts_core::blocklock::mock_blocklock_receiver::MockBlocklockReceiver::MockBlocklockReceiverInstance;
     use contracts_core::blocklock::mock_blocklock_receiver::TypesLib as MockBlocklockReceiverTypes;
-    use contracts_core::blocklock::mock_blocklock_receiver::BLS as MockBlocklockReceiverBLS;
     use contracts_core::blocklock::signature_scheme_address_provider::SignatureSchemeAddressProvider;
     use contracts_core::blocklock::uups_proxy::UUPSProxy;
-    use contracts_core::ibe_helper::{IbeIdentityOnBn254G1Suite, PairingIbeCipherSuite, PairingIbeSigner};
+    use contracts_core::ibe_helper::{
+        IbeIdentityOnBn254G1Suite, PairingIbeCipherSuite, PairingIbeSigner,
+    };
     use contracts_core::ser::EvmSerialize;
 
     const SK: ark_bn254::Fr =

crates/blocklock-warp/src/condition_resolver/block_reached.rs

@@ -1,7 +1,7 @@
 //! Condition resolver for block numbers.
 
-use crate::condition_resolver::ChildResolver;
 use crate::BlockNumber;
+use crate::condition_resolver::ChildResolver;
 use std::collections::{BTreeMap, HashMap};
 use std::hash::Hash;
 
@@ -92,8 +92,8 @@ where
 mod tests {
     use super::*;
     use crate::condition_resolver::StandaloneResolver;
-    use std::sync::atomic::AtomicBool;
     use std::sync::Arc;
+    use std::sync::atomic::AtomicBool;
 
     #[test]
     fn should_resolve_when_block_reached() {

crates/blocklock-warp/src/fulfiller.rs

@@ -6,11 +6,11 @@ use crate::metrics::Metrics;
 use alloy::network::{Ethereum, Network};
 use alloy::providers::{Provider, WalletProvider};
 use fulfiller_core::contracts::BlocklockSender;
-use fulfiller_core::decryption_sender::contracts::DecryptionSender;
 use fulfiller_core::decryption_sender::SignedDecryptionRequest;
+use fulfiller_core::decryption_sender::contracts::DecryptionSender;
 use fulfiller_core::fulfiller::TransactionFulfiller;
-use futures_util::future::BoxFuture;
 use futures_util::FutureExt;
+use futures_util::future::BoxFuture;
 use payment_warp::estimator::{PaymentEstimatorCostError, RequestFulfillmentEstimator};
 use payment_warp::fulfiller::{GenericFulfiller, GenericFulfillerError};
 use std::time::Duration;

crates/blocklock-warp/src/lib.rs

@@ -34,15 +34,17 @@ impl TryFrom<&[u8]> for BlocklockCondition {
         if bytes.is_empty() {
             return Err(BlocklockConditionDecodeError::InvalidFormat);
         }
-        
+
         match bytes[0] {
             0 => {
                 if bytes.len() != 9 {
                     return Err(BlocklockConditionDecodeError::InvalidFormat);
                 }
                 let mut block_bytes = [0u8; 8];
                 block_bytes.copy_from_slice(&bytes[1..9]);
-                Ok(BlocklockCondition::BlockNumber(BlockNumber(u64::from_be_bytes(block_bytes))))
+                Ok(BlocklockCondition::BlockNumber(BlockNumber(
+                    u64::from_be_bytes(block_bytes),
+                )))
             }
             _ => Err(BlocklockConditionDecodeError::UnknownType),
         }

crates/blocklock-weft/examples/blocklock/arguments_parser.rs

@@ -3,8 +3,8 @@ use alloy::transports::http::reqwest;
 use anyhow::anyhow;
 use ark_ff::{BigInteger, PrimeField};
 use clap::Parser;
-use figment::providers::{Format, Serialized, Toml};
 use figment::Figment;
+use figment::providers::{Format, Serialized, Toml};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt::Formatter;
 use std::net::IpAddr;

crates/blocklock-weft/examples/blocklock/healthcheck.rs

@@ -1,12 +1,12 @@
 use anyhow::anyhow;
 use prometheus::{Encoder, TextEncoder};
 use std::net::IpAddr;
-use warp::http::StatusCode;
 use warp::Filter;
+use warp::http::StatusCode;
 
 use blocklock_warp::metrics::Metrics as BlocklockMetrics;
-use signer::threshold_signer::metrics::Metrics as ThresholdSignerMetrics;
 use dcipher_network::transports::libp2p::metrics::Metrics as Libp2pMetrics;
+use fulfiller_core::signer::threshold_signer::metrics::Metrics as ThresholdSignerMetrics;
 
 pub async fn start_api(listen_addr: IpAddr, port: u16) -> anyhow::Result<()> {
     let health = warp::path!("health")

crates/blocklock-weft/examples/blocklock/main.rs

@@ -8,7 +8,7 @@ use alloy::providers::{Provider, ProviderBuilder, WalletProvider};
 use alloy::signers::local::PrivateKeySigner;
 use ark_ec::{AffineRepr, CurveGroup};
 use blocklock_warp::{BlocklockAgent, BlocklockAgentSavedState, BlocklockFulfiller};
-use blocklock_weft::{run_agent, NotifyTicker, BLOCKLOCK_SCHEME_ID};
+use blocklock_weft::{BLOCKLOCK_SCHEME_ID, NotifyTicker, run_agent};
 use contracts_core::ibe_helper::IbeIdentityOnBn254G1Suite;
 use dcipher_network::transports::libp2p::{Libp2pNode, Libp2pNodeConfig};
 use fulfiller_core::contracts::BlocklockSender;
@@ -168,7 +168,7 @@ where
 
     // Add own pk to the list if required
     if pks.len() == usize::from(args.key_config.n.get() - 1) {
-        let pk = ark_bn254::G2Affine::generator() * &sk;
+        let pk = ark_bn254::G2Affine::generator() * sk;
         pks.insert(
             usize::from(args.key_config.node_id.get() - 1),
             pk.into_affine(),

crates/blocklock-weft/src/lib.rs

@@ -3,9 +3,9 @@
 use alloy::providers::Provider;
 use anyhow::anyhow;
 use blocklock_warp::BlocklockAgent;
+use fulfiller_core::decryption_sender::DecryptionRequest;
 use fulfiller_core::decryption_sender::contracts::DecryptionSender;
 use fulfiller_core::decryption_sender::contracts::DecryptionSender::DecryptionRequested;
-use fulfiller_core::decryption_sender::DecryptionRequest;
 use fulfiller_core::fulfiller::{RequestChannel, Ticker};
 use futures::Stream;
 use futures_util::StreamExt;

crates/contracts-core/Cargo.toml

@@ -24,7 +24,6 @@ thiserror = { workspace = true }
 default = []
 blocklock = []
 signer = ["dep:dcipher-signer"]
-testing = []
 
 [dev-dependencies]
 alloy = { workspace = true, features = ["default", "provider-ws", "provider-anvil-node"] }

crates/contracts-core/src/blocklock.rs

@@ -1,13 +1,12 @@
 //! Solidity imports for the blocklock contracts-core.
 
-// pub use blocklock_sender::*;
 #[cfg(feature = "blocklock")]
-pub mod blocklock {
-   pub mod blocklock_sender {
-       use crate::payment::{DefaultRequestDetails, PaymentConfig, PaymentContract};
-       use crate::{impl_payment_config, impl_payment_contract};
+mod contracts {
+    pub mod blocklock_sender {
+        use crate::payment::{DefaultRequestDetails, PaymentConfig, PaymentContract};
+        use crate::{impl_payment_config, impl_payment_contract};
 
-       alloy::sol!(
+        alloy::sol!(
             #[allow(clippy::too_many_arguments)]
             #[derive(Debug)]
             #[sol(rpc)]
@@ -19,61 +18,61 @@ pub mod blocklock {
         impl_payment_contract!(BlocklockSender, BlocklockSenderInstance);
     }
 
-   pub mod decryption_sender {
-       alloy::sol!(
-           #[derive(Debug)]
-           #[sol(rpc)]
-           DecryptionSender,
-           "../../blocklock-solidity/out/DecryptionSender.sol/DecryptionSender.json"
-       );
-   }
+    pub mod decryption_sender {
+        alloy::sol!(
+            #[derive(Debug)]
+            #[sol(rpc)]
+            DecryptionSender,
+            "../../blocklock-solidity/out/DecryptionSender.sol/DecryptionSender.json"
+        );
+    }
 
-   pub mod mock_blocklock_receiver {
-       alloy::sol!(
-           #[derive(Debug)]
-           #[sol(rpc)]
-           MockBlocklockReceiver,
-           "../../blocklock-solidity/out/MockBlocklockReceiver.sol/MockBlocklockReceiver.json"
-       );
-   }
+    pub mod mock_blocklock_receiver {
+        alloy::sol!(
+            #[derive(Debug)]
+            #[sol(rpc)]
+            MockBlocklockReceiver,
+            "../../blocklock-solidity/out/MockBlocklockReceiver.sol/MockBlocklockReceiver.json"
+        );
+    }
 
-   pub mod uups_proxy {
-       alloy::sol!(
-           #[derive(Debug)]
-           #[sol(rpc)]
-           UUPSProxy,
-           "../../blocklock-solidity/out/UUPSProxy.sol/UUPSProxy.json"
-       );
-   }
+    pub mod uups_proxy {
+        alloy::sol!(
+            #[derive(Debug)]
+            #[sol(rpc)]
+            UUPSProxy,
+            "../../blocklock-solidity/out/UUPSProxy.sol/UUPSProxy.json"
+        );
+    }
 
-   pub mod blocklock_signature_scheme {
-       alloy::sol!(
-           #[derive(Debug)]
-           #[sol(rpc)]
-           BlocklockSignatureScheme,
-           "../../blocklock-solidity/out/BlocklockSignatureScheme.sol/BlocklockSignatureScheme.json"
-       );
-   }
+    pub mod blocklock_signature_scheme {
+        alloy::sol!(
+            #[derive(Debug)]
+            #[sol(rpc)]
+            BlocklockSignatureScheme,
+            "../../blocklock-solidity/out/BlocklockSignatureScheme.sol/BlocklockSignatureScheme.json"
+        );
+    }
 
-   pub mod signature_scheme_address_provider {
-       alloy::sol!(
-           #[derive(Debug)]
-           #[sol(rpc)]
-           SignatureSchemeAddressProvider,
-           "../../blocklock-solidity/out/SignatureSchemeAddressProvider.sol/SignatureSchemeAddressProvider.json"
-       );
-   }
+    pub mod signature_scheme_address_provider {
+        alloy::sol!(
+            #[derive(Debug)]
+            #[sol(rpc)]
+            SignatureSchemeAddressProvider,
+            "../../blocklock-solidity/out/SignatureSchemeAddressProvider.sol/SignatureSchemeAddressProvider.json"
+        );
+    }
 
-   #[derive(thiserror::Error, Debug)]
-   pub enum IbeIdentityOnBn254G1CiphertextError {
-       #[error("abi decode error")]
-       AbiDecode(#[from] alloy::sol_types::Error),
+    #[derive(thiserror::Error, Debug)]
+    pub enum IbeIdentityOnBn254G1CiphertextError {
+        #[error("abi decode error")]
+        AbiDecode(#[from] alloy::sol_types::Error),
 
-       #[error("invalid ephemeral pk")]
-       InvalidEphemeralPk,
-   }
+        #[error("invalid ephemeral pk")]
+        InvalidEphemeralPk,
+    }
 }
 
 // Re-export the blocklock module contents when the feature is enabled
 #[cfg(feature = "blocklock")]
-pub use blocklock::*;
+pub use contracts::*;