style: fix clippy warnings

examples/verify_stone_proof.rs

@@ -2,16 +2,13 @@ use ethers::{
     contract::ContractError,
     core::k256::ecdsa::SigningKey,
     middleware::SignerMiddleware,
-    providers::{Http, Middleware, Provider, ProviderError},
+    providers::{Http, Middleware, Provider},
     signers::{LocalWallet, Signer, Wallet},
-    types::{Address, U256, U64},
+    types::{Address, U64},
     utils::{hex, Anvil},
 };
 use stark_evm_adapter::{
-    annotated_proof::AnnotatedProof,
-    annotation_parser::{split_fri_merkle_statements, SplitProofs},
-    oods_statement::FactTopology,
-    ContractFunctionCall,
+    annotation_parser::SplitProofs, oods_statement::FactTopology, ContractFunctionCall,
 };
 use std::{convert::TryFrom, env, str::FromStr, sync::Arc};
 
@@ -73,16 +70,18 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         "/tests/fixtures/madara_fibonacci_proof_topologies.json"
     ));
     let topology_json: serde_json::Value = serde_json::from_str(topologies_file).unwrap();
-
-    let fact_topologies: Vec<FactTopology> = serde_json::from_value(topology_json.get("fact_topologies").unwrap().clone()).unwrap();
+
+    let fact_topologies: Vec<FactTopology> =
+        serde_json::from_value(topology_json.get("fact_topologies").unwrap().clone()).unwrap();
 
     // split proof file from madara prover
     let split_proofs_file = include_str!(concat!(
         env!("CARGO_MANIFEST_DIR"),
         "/tests/fixtures/madara_fibonacci_proof.json"
     ));
     let split_proofs_json: serde_json::Value = serde_json::from_str(split_proofs_file).unwrap();
-    let split_proofs: SplitProofs = serde_json::from_value(split_proofs_json.get("split_proofs").unwrap().clone()).unwrap();
+    let split_proofs: SplitProofs =
+        serde_json::from_value(split_proofs_json.get("split_proofs").unwrap().clone()).unwrap();
 
     // start verifying all split proofs
     println!("Verifying trace decommitments:");
@@ -110,11 +109,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         Address::from_str("0xFD14567eaf9ba941cB8c8a94eEC14831ca7fD1b4").unwrap();
 
     for (index, page) in continuous_pages.iter().enumerate() {
-        let register_continuous_pages_call = split_proofs.main_proof.register_continuous_memory_page(
-            memory_fact_registry_address,
-            signer.clone(),
-            page.clone(),
-        );
+        let register_continuous_pages_call =
+            split_proofs.main_proof.register_continuous_memory_page(
+                memory_fact_registry_address,
+                signer.clone(),
+                page.clone(),
+            );
 
         let name = format!("register continuous page: {}", index);
 
@@ -134,7 +134,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let call = split_proofs
         .main_proof
         .verify(contract_address, signer, task_metadata);
-        // .gas(U256::from(5_000_000));
+    // .gas(U256::from(5_000_000));
 
     assert_call(call, "Main proof").await?;
 

src/oods_statement.rs

@@ -361,15 +361,15 @@ impl MainProof {
 
         let mut output = Vec::new();
         for addr in output_segment.begin_addr..stop_ptr {
-            let value = memory
+            let value = *memory
                 .get(&addr)
-                .ok_or(format!("Missing value for address: {}", addr))?
-                .clone();
+                .ok_or(format!("Missing value for address: {}", addr))?;
             output.push(value);
         }
         Ok(output)
     }
 
+    #[allow(dead_code)]
     fn get_trivial_topology(public_memory: &Vec<PublicMemory>) -> Vec<FactTopology> {
         let mut page_sizes = HashMap::new();
 
@@ -395,12 +395,11 @@ impl MainProof {
     fn keccak_ints(&self, values: &[U256]) -> Result<String, String> {
         let values_bytes = values
             .iter()
-            .map(|&value| {
+            .flat_map(|&value| {
                 let mut bytes = [0u8; 32]; // U256 is 32 bytes
                 value.to_big_endian(&mut bytes);
                 bytes
             })
-            .flatten()
             .collect::<Vec<u8>>();
 
         let result = keccak256(values_bytes.as_slice());
@@ -425,7 +424,7 @@ impl MainProof {
             }
 
             for _ in 0..n_pages {
-                let page_size = page_sizes.remove(0) as usize;
+                let page_size = page_sizes.remove(0);
                 let page_hash = self.keccak_ints(&program_output[offset..offset + page_size])?;
 
                 offset += page_size;
@@ -483,7 +482,7 @@ impl MainProof {
         fact_topology: &FactTopology,
     ) -> Result<String, String> {
         let output_root_node = self.generate_output_root(&program_output, fact_topology)?;
-        let hash = self.keccak_ints(&vec![program_hash, output_root_node.node_hash])?;
+        let hash = self.keccak_ints(&[program_hash, output_root_node.node_hash])?;
         Ok(hash)
     }
 
@@ -558,7 +557,6 @@ impl MainProof {
             expected_page_sizes.extend_from_slice(&fact_topology.page_sizes);
         }
 
-
         if ptr != output.len() {
             return Err(format!(
                 "Not all of the bootloader output was processed: {} != {}",

tests/annotation_parser.rs

@@ -52,7 +52,7 @@ mod tests {
 
         let fri_merkle_contract_args = split_proofs
             .fri_merkle_statements
-            .get(0)
+            .first()
             .unwrap()
             .contract_function_call();
         assert_eq!(split_proofs.fri_merkle_statements.len(), 6);