eth_client: fix get_address_from_secret_key

crates/l2/proposer/prover_server.rs

@@ -43,7 +43,6 @@ struct ProverServer {
     on_chain_proposer_address: Address,
     verifier_address: Address,
     verifier_private_key: SecretKey,
-    last_verified_block: u64,
 }
 
 /// Enum for the ProverServer <--> ProverClient Communication Protocol.
@@ -97,15 +96,6 @@ impl ProverServer {
         let eth_client = EthClient::new(&eth_config.rpc_url);
         let on_chain_proposer_address = committer_config.on_chain_proposer_address;
 
-        let last_verified_block =
-            EthClient::get_last_verified_block(&eth_client, on_chain_proposer_address).await?;
-
-        let last_verified_block = if last_verified_block == u64::MAX {
-            0
-        } else {
-            last_verified_block
-        };
-
         Ok(Self {
             ip: config.listen_ip,
             port: config.listen_port,
@@ -114,7 +104,6 @@ impl ProverServer {
             on_chain_proposer_address,
             verifier_address: config.verifier_address,
             verifier_private_key: config.verifier_private_key,
-            last_verified_block,
         })
     }
 
@@ -213,11 +202,21 @@ impl ProverServer {
     async fn handle_connection(&mut self, mut stream: TcpStream) -> Result<(), ProverServerError> {
         let buf_reader = BufReader::new(&stream);
 
+        let last_verified_block =
+            EthClient::get_last_verified_block(&self.eth_client, self.on_chain_proposer_address)
+                .await?;
+
+        let last_verified_block = if last_verified_block == u64::MAX {
+            0
+        } else {
+            last_verified_block
+        };
+
         let data: Result<ProofData, _> = serde_json::de::from_reader(buf_reader);
         match data {
             Ok(ProofData::Request) => {
                 if let Err(e) = self
-                    .handle_request(&mut stream, self.last_verified_block + 1)
+                    .handle_request(&mut stream, last_verified_block + 1)
                     .await
                 {
                     warn!("Failed to handle request: {e}");
@@ -231,10 +230,9 @@ impl ProverServer {
 
                 self.handle_proof_submission(block_number, receipt).await?;
 
-                if block_number != (self.last_verified_block + 1) {
-                    return Err(ProverServerError::Custom(format!("Prover Client submitted an invalid block_number: {block_number}. The last_proved_block is: {}", self.last_verified_block)));
+                if block_number != (last_verified_block + 1) {
+                    return Err(ProverServerError::Custom(format!("Prover Client submitted an invalid block_number: {block_number}. The last_proved_block is: {}", last_verified_block)));
                 }
-                self.last_verified_block = block_number;
             }
             Err(e) => {
                 warn!("Failed to parse request: {e}");

crates/l2/utils/eth_client/mod.rs

@@ -222,12 +222,15 @@ impl EthClient {
         tx: &mut EIP1559Transaction,
         private_key: &SecretKey,
     ) -> Result<H256, EthClientError> {
-        let from = get_address_from_secret_key(private_key);
+        let from = get_address_from_secret_key(private_key).map_err(|e| {
+            EthClientError::Custom(format!("Failed to get_address_from_secret_key: {e}"))
+        })?;
         // Sometimes the penalty is a 100%
         // Increase max fee per gas by 110% (set it to 210% of the original)
         self.bump_eip1559(tx, 1.1);
         let wrapped_tx = &mut WrappedTransaction::EIP1559(tx.clone());
         self.estimate_gas_for_wrapped_tx(wrapped_tx, from).await?;
+
         if let WrappedTransaction::EIP1559(eip1559) = wrapped_tx {
             tx.max_fee_per_gas = eip1559.max_fee_per_gas;
             tx.max_priority_fee_per_gas = eip1559.max_fee_per_gas;
@@ -249,13 +252,16 @@ impl EthClient {
         wrapped_tx: &mut WrappedEIP4844Transaction,
         private_key: &SecretKey,
     ) -> Result<H256, EthClientError> {
-        let from = get_address_from_secret_key(private_key);
+        let from = get_address_from_secret_key(private_key).map_err(|e| {
+            EthClientError::Custom(format!("Failed to get_address_from_secret_key: {e}"))
+        })?;
         // Sometimes the penalty is a 100%
         // Increase max fee per gas by 110% (set it to 210% of the original)
         self.bump_eip4844(wrapped_tx, 1.1);
         let wrapped_eip4844 = &mut WrappedTransaction::EIP4844(wrapped_tx.clone());
         self.estimate_gas_for_wrapped_tx(wrapped_eip4844, from)
             .await?;
+
         if let WrappedTransaction::EIP4844(eip4844) = wrapped_eip4844 {
             wrapped_tx.tx.max_fee_per_gas = eip4844.tx.max_fee_per_gas;
             wrapped_tx.tx.max_priority_fee_per_gas = eip4844.tx.max_fee_per_gas;
@@ -286,7 +292,9 @@ impl EthClient {
         tx: &mut PrivilegedL2Transaction,
         private_key: &SecretKey,
     ) -> Result<H256, EthClientError> {
-        let from = get_address_from_secret_key(private_key);
+        let from = get_address_from_secret_key(private_key).map_err(|e| {
+            EthClientError::Custom(format!("Failed to get_address_from_secret_key: {e}"))
+        })?;
         // Sometimes the penalty is a 100%
         // Increase max fee per gas by 110% (set it to 210% of the original)
         self.bump_privileged_l2(tx, 1.1);

crates/l2/utils/mod.rs

@@ -1,3 +1,5 @@
+use std::array::TryFromSliceError;
+
 use ethrex_core::Address;
 use keccak_hash::{keccak, H256};
 use secp256k1::SecretKey;
@@ -24,10 +26,14 @@ where
     hex.serialize(serializer)
 }
 
-pub fn get_address_from_secret_key(secret_key: &SecretKey) -> Address {
-    let mut buffer = [0u8; 32];
-    let public_key = secret_key.public_key(secp256k1::SECP256K1).serialize();
-    buffer.copy_from_slice(&public_key[1..]);
+pub fn get_address_from_secret_key(secret_key: &SecretKey) -> Result<Address, TryFromSliceError> {
+    let public_key = secret_key
+        .public_key(secp256k1::SECP256K1)
+        .serialize_uncompressed();
+    let hash = keccak(&public_key[1..]);
+
+    // Get the lat 20 bytes of the hash
+    let address_bytes: [u8; 20] = hash[12..32].try_into()?;
 
-    Address::from(keccak(buffer))
+    Ok(Address::from(address_bytes))
 }