refactor(l2): use deposit hash as the tx hash for l2 txs (#2562)

**Motivation**

Here we want to not process the same deposit to the L2 as two different
transactions.

**Description**

* Change the transaction hash of the `PrivilegedL2Transaction` to the
deposit hash (instead of the hash of the entire tx) . The one that is
emitted when the deposit is done
* In the `l1_watcher` skip transactions that are already on the store.

Closes #2552

Author: tomip01

crates/common/types/transaction.rs

@@ -1265,6 +1265,9 @@ impl Transaction {
     }
 
     pub fn compute_hash(&self) -> H256 {
+        if let Transaction::PrivilegedL2Transaction(tx) = self {
+            return tx.get_deposit_hash().unwrap_or_default();
+        }
         keccak_hash::keccak(self.encode_canonical_to_vec())
     }
 

crates/l2/sequencer/errors.rs

@@ -25,6 +25,8 @@ pub enum L1WatcherError {
     FailedToRetrieveChainConfig(String),
     #[error("L1Watcher failed to get config: {0}")]
     FailedToGetConfig(#[from] ConfigError),
+    #[error("L1Watcher failed to access Store: {0}")]
+    FailedAccessingStore(#[from] StoreError),
     #[error("{0}")]
     Custom(String),
 }

crates/l2/sequencer/l1_watcher.rs

@@ -83,42 +83,10 @@ impl L1Watcher {
                 continue;
             }
 
-            let pending_deposit_logs = self.get_pending_deposit_logs().await?;
-            let _deposit_txs = self
-                .process_logs(logs, &pending_deposit_logs, store, blockchain)
-                .await?;
+            let _deposit_txs = self.process_logs(logs, store, blockchain).await?;
         }
     }
 
-    pub async fn get_pending_deposit_logs(&self) -> Result<Vec<H256>, L1WatcherError> {
-        let selector = keccak(b"getPendingDepositLogs()")
-            .as_bytes()
-            .get(..4)
-            .ok_or(EthClientError::Custom("Failed to get selector.".to_owned()))?
-            .to_vec();
-
-        Ok(hex::decode(
-            self.eth_client
-                .call(
-                    self.address,
-                    Bytes::copy_from_slice(&selector),
-                    Overrides::default(),
-                )
-                .await?
-                .get(2..)
-                .ok_or(L1WatcherError::FailedToDeserializeLog(
-                    "Not a valid hex string".to_string(),
-                ))?,
-        )
-        .map_err(|_| L1WatcherError::FailedToDeserializeLog("Not a valid hex string".to_string()))?
-        .chunks(32)
-        .map(H256::from_slice)
-        .collect::<Vec<H256>>()
-        .split_at(2) // Two first words are index and length abi encode
-        .1
-        .to_vec())
-    }
-
     pub async fn get_logs(&mut self) -> Result<Vec<RpcLog>, L1WatcherError> {
         if self.last_block_fetched.is_zero() {
             self.last_block_fetched =
@@ -176,7 +144,6 @@ impl L1Watcher {
     pub async fn process_logs(
         &self,
         logs: Vec<RpcLog>,
-        pending_deposit_logs: &[H256],
         store: &Store,
         blockchain: &Blockchain,
     ) -> Result<Vec<H256>, L1WatcherError> {
@@ -189,7 +156,7 @@ impl L1Watcher {
             let value_bytes = mint_value.to_big_endian();
             let id_bytes = deposit_id.to_big_endian();
             let gas_limit_bytes = gas_limit.to_big_endian();
-            if !pending_deposit_logs.contains(&keccak(
+            let deposit_hash = keccak(
                 [
                     to_address.as_bytes(),
                     &value_bytes,
@@ -200,7 +167,15 @@ impl L1Watcher {
                     keccak(&calldata).as_bytes(),
                 ]
                 .concat(),
-            )) {
+            );
+
+            let deposit_already_processed = store
+                .get_transaction_by_hash(deposit_hash)
+                .await
+                .map_err(L1WatcherError::FailedAccessingStore)?
+                .is_some();
+
+            if deposit_already_processed {
                 warn!("Deposit already processed (to: {recipient:#x}, value: {mint_value}, depositId: {deposit_id}), skipping.");
                 continue;
             }