fix & clippy

bus-mapping/src/circuit_input_builder/protocol_instance.rs

@@ -1,14 +1,13 @@
 #![allow(missing_docs)]
 
-use alloy_dyn_abi::DynSolValue;
-use alloy_primitives::{B256, U160, U256};
-use alloy_primitives::Address as SolAddress;
+use alloy_primitives::{B256, U256};
+
 use alloy_sol_types::{sol, SolValue};
-use eth_types::{Address, Bytes, ToBigEndian, ToWord};
+use eth_types::Address;
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
 use sha3::{Digest, Keccak256};
-use std::{iter, str::FromStr};
+use std::str::FromStr;
 
 /// L1 signal service
 pub static L1_SIGNAL_SERVICE: Lazy<Address> = Lazy::new(|| {
@@ -100,11 +99,11 @@ impl ProtocolInstance {
     // return keccak256(abi.encode(tran, prover, metaHash, txListHash, pointValue));
     pub fn hash(&self, evidence_type: EvidenceType) -> B256 {
         match evidence_type {
-            EvidenceType::Sgx { new_pubkey } => todo!(),
-            EvidenceType::PseZk  => {
+            EvidenceType::Sgx { new_pubkey: _ } => todo!(),
+            EvidenceType::PseZk => {
                 // keccak256(abi.encode(tran, prover, metaHash, txListHash, pointValue));
                 keccak(self.abi_encode()).into()
-            },
+            }
         }
     }
 
@@ -119,48 +118,46 @@ impl ProtocolInstance {
             prover: self.prover.as_fixed_bytes().into(),
             txListHash: self.block_metadata.blobHash,
             pointValue: U256::from(0),
-
-        }.abi_encode()
-        .into()
+        }
+        .abi_encode()
     }
 
     pub fn parentHash(&self) -> Vec<u8> {
-        self.transition.parentHash.abi_encode().into()
+        self.transition.parentHash.abi_encode()
     }
 
     pub fn blockHash(&self) -> Vec<u8> {
-        self.transition.blockHash.abi_encode().into()
+        self.transition.blockHash.abi_encode()
     }
 
     pub fn signalRoot(&self) -> Vec<u8> {
-        self.transition.signalRoot.abi_encode().into()
+        self.transition.signalRoot.abi_encode()
     }
 
     pub fn graffiti(&self) -> Vec<u8> {
-        self.transition.graffiti.abi_encode().into()
+        self.transition.graffiti.abi_encode()
     }
 
     pub fn prover(&self) -> Vec<u8> {
-        self.prover.as_fixed_bytes().abi_encode().into()
+        self.prover.as_fixed_bytes().abi_encode()
     }
 
     pub fn meta_hash(&self) -> Vec<u8> {
         keccak(self.block_metadata.abi_encode()).into()
     }
 
     pub fn tx_list_hash(&self) -> Vec<u8> {
-        self.block_metadata.blobHash.abi_encode().into()
+        self.block_metadata.blobHash.abi_encode()
     }
 
     pub fn point_value(&self) -> Vec<u8> {
-        U256::from(0).abi_encode().into()
+        U256::from(0).abi_encode()
     }
-
 }
 
 #[inline]
 pub fn keccak(data: impl AsRef<[u8]>) -> [u8; 32] {
     // TODO: Remove this benchmarking code once performance testing is complete.
     // std::hint::black_box(sha2::Sha256::digest(&data));
     Keccak256::digest(data).into()
-}
+}

integration-tests/src/integration_public_data_circuits.rs

@@ -7,7 +7,7 @@ mod public_data_test {
     use crate::get_client;
     use bus_mapping::{
         circuit_input_builder::{
-            protocol_instance::{BlockEvidence, BlockMetadata},
+            protocol_instance::{BlockMetadata, Transition},
             BuilderClient, CircuitsParams, ProtocolInstance,
         },
         rpc::BlockNumber,
@@ -337,7 +337,7 @@ mod public_data_test {
     }
 
     fn gen_requests() -> Vec<ProtocolInstance> {
-        let metadata = BlockMetadata {
+        let block_metadata = BlockMetadata {
             l1Hash: parse_hash("6e3b781b2d9a04e21ecba49e67dc3fb0a8242408cc07fa6fed5d8bd0eca2c985")
                 .unwrap()
                 .as_fixed_bytes()
@@ -358,8 +358,7 @@ mod public_data_test {
             ..Default::default()
         };
 
-        let block_evidence = BlockEvidence {
-            blockMetadata: metadata,
+        let transition = Transition {
             parentHash: parse_hash(
                 "a534f7f74d155fa0575ccfd9dbb2a7c4f89baa0fb48c3a312f0d97e3fbff7c47",
             )
@@ -382,7 +381,8 @@ mod public_data_test {
         };
 
         let protocol_instance = ProtocolInstance {
-            block_evidence,
+            transition,
+            block_metadata,
             ..Default::default()
         };
         vec![protocol_instance]
@@ -392,7 +392,7 @@ mod public_data_test {
         circuits_params: CircuitsParams,
         protocol_instance: ProtocolInstance,
     ) -> Block<Fr> {
-        let block_num = protocol_instance.block_evidence.blockMetadata.id;
+        let block_num = protocol_instance.block_metadata.id;
         let cli = get_client();
 
         let cli = BuilderClient::new(cli, circuits_params, Some(protocol_instance.clone()))

zkevm-circuits/src/taiko_pi_circuit.rs

@@ -4,12 +4,12 @@ mod dev;
 mod param;
 #[cfg(any(test))]
 mod test;
-use bus_mapping::circuit_input_builder::{protocol_instance::{EvidenceType, self}, ProtocolInstance};
+use bus_mapping::circuit_input_builder::ProtocolInstance;
 
 use param::*;
 
 // use bus_mapping::circuit_input_builder::ProtocolInstance;
-use eth_types::{Field, ToBigEndian, ToWord, U256};
+use eth_types::{Field, U256};
 
 use ethers_core::utils::keccak256;
 use halo2_proofs::circuit::{AssignedCell, Layouter, SimpleFloorPlanner, Value};
@@ -30,7 +30,7 @@ use crate::{
     util::{Challenges, SubCircuit, SubCircuitConfig},
     witness::{self, BlockContext},
 };
-use alloy_dyn_abi::DynSolValue::FixedBytes;
+
 use core::result::Result;
 use halo2_proofs::plonk::Error;
 
@@ -386,7 +386,6 @@ impl<F: Field> TaikoPiCircuitConfig<F> {
         challenge: &Challenges<Value<F>>,
         public_data: &PublicData<F>,
     ) -> Result<(), Error> {
-
         let evm_word = challenge.evm_word();
         let keccak_r = challenge.keccak_input();
         let hi_lo_cells = layouter.assign_region(
@@ -420,7 +419,6 @@ impl<F: Field> TaikoPiCircuitConfig<F> {
                 self.keccak_bytes.assign(&mut region, 0, &public_data.keccak_assignment())
                     .expect("Keccak bytes assignment failed");                
                 assign!(region, self.total_acc, 0 => public_data.total_acc(keccak_r))?;
-
                 let hi_low_assignment = public_data.keccak_hi_low();
                 let hi = assign!(region, self.keccak_hi_lo[0], 0 => hi_low_assignment[0])?;
                 let lo = assign!(region, self.keccak_hi_lo[1], 0 => hi_low_assignment[1])?;

zkevm-circuits/src/taiko_pi_circuit/dev.rs

@@ -1,5 +1,3 @@
-use crate::witness::Block;
-
 use super::*;
 
 #[cfg(any(feature = "test", test))]
@@ -54,13 +52,11 @@ impl<F: Field> Circuit<F> for TaikoPiCircuit<F> {
             .block_table
             .load(&mut layouter, &evidance.block_context, randomness)?;
         // assign keccak table
-        config
-            .keccak_table
-            .dev_load(
-                &mut layouter, 
-                vec![&evidance.protocol_instance.abi_encode()], 
-                &challenges
-            )?;
+        config.keccak_table.dev_load(
+            &mut layouter,
+            vec![&evidance.protocol_instance.abi_encode()],
+            &challenges,
+        )?;
         config.byte_table.load(&mut layouter)?;
 
         self.synthesize_sub(&config, &challenges, &mut layouter)

zkevm-circuits/src/taiko_pi_circuit/test.rs

@@ -3,17 +3,18 @@ use super::{dev::*, param::*, *};
 use std::vec;
 
 use alloy_primitives::FixedBytes;
-use bus_mapping::circuit_input_builder::{protocol_instance::Transition, Transaction, BlockMetadata};
+use bus_mapping::circuit_input_builder::{
+    protocol_instance::Transition, BlockMetadata, Transaction,
+};
 use core::result::Result;
-use eth_types::{H160, H256};
+use eth_types::{ToWord, H160, H256};
 use halo2_proofs::{
     dev::{MockProver, VerifyFailure},
     halo2curves::bn256::Fr,
     plonk::{keygen_pk, keygen_vk},
 };
 use lazy_static::lazy_static;
 use snark_verifier_sdk::halo2::gen_srs;
-
 lazy_static! {
     static ref LAST_HASH: H256 = H256::from_slice(
         &hex::decode("1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347").unwrap(),

zkevm-circuits/src/taiko_super_circuit.rs

@@ -26,9 +26,7 @@ use crate::{
         BlockTable, ByteTable, BytecodeTable, CopyTable, ExpTable, KeccakTable, PiTable, RwTable,
         TxTable,
     },
-    taiko_pi_circuit::{
-        PublicData, TaikoPiCircuit, TaikoPiCircuitConfig, TaikoPiConfigArgs,
-    },
+    taiko_pi_circuit::{PublicData, TaikoPiCircuit, TaikoPiCircuitConfig, TaikoPiConfigArgs},
     util::{log2_ceil, Challenges, SubCircuit, SubCircuitConfig},
     witness::{block_convert, Block},
 };
@@ -395,7 +393,9 @@ impl<F: Field> Circuit<F> for SuperCircuit<F> {
             self.block
                 .sha3_inputs
                 .iter()
-                .chain(std::iter::once(&self.pi_circuit.public_data.protocol_instance.abi_encode()))
+                .chain(std::iter::once(
+                    &self.pi_circuit.public_data.protocol_instance.abi_encode(),
+                ))
                 .chain(
                     &self
                         .block

zkevm-circuits/src/witness/block.rs

@@ -75,10 +75,7 @@ pub fn protocol_instancetable_assignments<F: Field>(
         [
             Value::known(F::from(PiFieldTag::L1Hash as u64)),
             rlc_be_bytes(
-                protocol_instance
-                    .block_metadata
-                    .l1Hash
-                    .as_slice(),
+                protocol_instance.block_metadata.l1Hash.as_slice(),
                 randomness,
             ),
         ],