bugfix: building MerkleTree history (#500)

* Update The logic for Merkle Tree building

* add dvc

crates/event-watcher-traits/src/evm/event_watcher.rs

@@ -275,7 +275,7 @@ pub trait EventHandler {
     /// Whether any of the events could be handled by the handler
     async fn can_handle_events(
         &self,
-        event: Self::Events,
+        (event, log): (Self::Events, contract::LogMeta),
         wrapper: &Self::Contract,
     ) -> webb_relayer_utils::Result<bool>;
 }
@@ -303,7 +303,10 @@ pub trait EventHandlerWithRetry: EventHandler {
         backoff: impl backoff::backoff::Backoff + Send + Sync + 'static,
         metrics: Arc<Mutex<metric::Metrics>>,
     ) -> webb_relayer_utils::Result<()> {
-        if !self.can_handle_events(event.clone(), contract).await? {
+        if !self
+            .can_handle_events((event.clone(), log.clone()), contract)
+            .await?
+        {
             return Ok(());
         };
 

event-watchers/evm/src/open_vanchor/open_vanchor_deposit_handler.rs

@@ -65,7 +65,7 @@ where
 
     async fn can_handle_events(
         &self,
-        events: Self::Events,
+        (events, _logs): (Self::Events, LogMeta),
         _wrapper: &Self::Contract,
     ) -> webb_relayer_utils::Result<bool> {
         use OpenVAnchorContractEvents::*;

event-watchers/evm/src/open_vanchor/open_vanchor_leaves_handler.rs

@@ -39,7 +39,7 @@ impl EventHandler for OpenVAnchorLeavesHandler {
 
     async fn can_handle_events(
         &self,
-        events: Self::Events,
+        (events, _meta): (Self::Events, LogMeta),
         _wrapper: &Self::Contract,
     ) -> webb_relayer_utils::Result<bool> {
         use OpenVAnchorContractEvents::*;

event-watchers/evm/src/signature_bridge_watcher.rs

@@ -121,7 +121,7 @@ impl EventHandler for SignatureBridgeGovernanceOwnershipTransferredHandler {
 
     async fn can_handle_events(
         &self,
-        events: Self::Events,
+        (events, _meta): (Self::Events, LogMeta),
         _wrapper: &Self::Contract,
     ) -> webb_relayer_utils::Result<bool> {
         use SignatureBridgeContractEvents::*;

event-watchers/evm/src/vanchor/vanchor_deposit_handler.rs

@@ -65,12 +65,20 @@ where
 
     async fn can_handle_events(
         &self,
-        events: Self::Events,
-        _wrapper: &Self::Contract,
+        (events, meta): (Self::Events, LogMeta),
+        wrapper: &Self::Contract,
     ) -> webb_relayer_utils::Result<bool> {
         use VAnchorContractEvents::*;
+        // only handle events if we fully synced.
+        let latest_block = wrapper.contract.client().get_block_number().await?;
+        let event_block = meta.block_number;
+        let allowed_margin = 10u64;
+        // Check if the event is in the latest block or within the allowed margin.
+        let fully_synced = event_block >= latest_block
+            || event_block.saturating_add(allowed_margin.into())
+                >= latest_block;
         let has_event = matches!(events, NewCommitmentFilter(_));
-        Ok(has_event)
+        Ok(has_event && fully_synced)
     }
 
     #[tracing::instrument(skip_all)]

event-watchers/evm/src/vanchor/vanchor_encrypted_outputs_handler.rs

@@ -40,7 +40,7 @@ impl EventHandler for VAnchorEncryptedOutputHandler {
 
     async fn can_handle_events(
         &self,
-        events: Self::Events,
+        (events, _meta): (Self::Events, LogMeta),
         _wrapper: &Self::Contract,
     ) -> webb_relayer_utils::Result<bool> {
         use VAnchorContractEvents::*;

event-watchers/evm/src/vanchor/vanchor_leaves_handler.rs

@@ -43,6 +43,7 @@ type MerkleTree = SparseMerkleTree<Bn254Fr, Poseidon<Bn254Fr>, 30>;
 pub struct VAnchorLeavesHandler {
     mt: Arc<Mutex<MerkleTree>>,
     storage: Arc<SledStore>,
+    hasher: Poseidon<Bn254Fr>,
 }
 impl VAnchorLeavesHandler {
     pub fn new(
@@ -62,6 +63,7 @@ impl VAnchorLeavesHandler {
 
         Ok(Self {
             mt: Arc::new(Mutex::new(mt)),
+            hasher: poseidon,
             storage,
         })
     }
@@ -77,7 +79,7 @@ impl EventHandler for VAnchorLeavesHandler {
 
     async fn can_handle_events(
         &self,
-        events: Self::Events,
+        (events, log): (Self::Events, LogMeta),
         wrapper: &Self::Contract,
     ) -> webb_relayer_utils::Result<bool> {
         use VAnchorContractEvents::*;
@@ -94,19 +96,24 @@ impl EventHandler for VAnchorLeavesHandler {
                 let leaf: Bn254Fr =
                     Bn254Fr::from_be_bytes_mod_order(commitment.as_slice());
                 let mut batch: BTreeMap<u32, Bn254Fr> = BTreeMap::new();
-                let params = setup_params::<Bn254Fr>(Curve::Bn254, 5, 3);
-                let poseidon = Poseidon::<Bn254Fr>::new(params);
                 batch.insert(leaf_index, leaf);
                 let mut mt = self.mt.lock().await;
-                mt.insert_batch(&batch, &poseidon)?;
+                mt.insert_batch(&batch, &self.hasher)?;
                 let root_bytes = mt.root().into_repr().to_bytes_be();
                 let root: U256 = U256::from_big_endian(root_bytes.as_slice());
-                let is_known_root =
-                    wrapper.contract.is_known_root(root).call().await?;
+                let is_known_root = wrapper
+                    .contract
+                    .is_known_root(root)
+                    .block(log.block_number)
+                    .call()
+                    .await?;
+
                 tracing::trace!("Is known root: {:?}", is_known_root);
+
                 if event_data.leaf_index.as_u32() % 2 == 0 {
                     return Ok(true);
                 }
+
                 if !is_known_root {
                     tracing::warn!("Invalid merkle root .. Restarting");
                     // In case of invalid merkle root, relayer should clear its storage and restart syncing.
@@ -142,7 +149,8 @@ impl EventHandler for VAnchorLeavesHandler {
                         history_store_key,
                         wrapper.config.common.deployed_at,
                     )?;
-                    return Ok(true);
+                    // Do not handle this event
+                    return Ok(false);
                 }
                 return Ok(true);
             }

flake.nix

@@ -33,6 +33,9 @@
             (lib.optionals pkgs.stdenv.isLinux pkgs.mold)
           ];
           buildInputs = [
+            # Used for DVC
+            pkgs.python311
+            pkgs.python311Packages.pipx
             # We want the unwrapped version, wrapped comes with nixpkgs' toolchain
             pkgs.rust-analyzer-unwrapped
             # Nodejs for test suite
@@ -43,6 +46,15 @@
             toolchain
           ];
           packages = [ ];
+
+          # Runs DVC pull in the fixtures
+          # we do not install dvc globally, since it
+          # is broken on nixos
+          shellHook = ''
+            ROOT=$(git rev-parse --show-toplevel)
+            cd $ROOT/tests && pipx run dvc pull
+            cd $ROOT
+          '';
         };
         # Environment variables
         RUST_SRC_PATH = "${toolchain}/lib/rustlib/src/rust/library";

services/webb-relayer/src/service/evm.rs

@@ -158,10 +158,6 @@ async fn start_vanchor_events_watcher(
     let contract_address = config.common.address;
     let my_ctx = ctx.clone();
     let my_config = config.clone();
-    let default_leaf = wrapper.contract.get_zero_hash(0).call().await?;
-
-    let mut default_leaf_bytes = [0u8; 32];
-    default_leaf.to_big_endian(&mut default_leaf_bytes);
     let task = async move {
         tracing::debug!(
             "VAnchor events watcher for ({}) Started.",
@@ -176,6 +172,10 @@ async fn start_vanchor_events_watcher(
             my_config.proposal_signing_backend,
         )
         .await?;
+
+        let default_leaf = wrapper.contract.get_zero_hash(0).call().await?;
+        let mut default_leaf_bytes = [0u8; 32];
+        default_leaf.to_big_endian(&mut default_leaf_bytes);
         match proposal_signing_backend {
             ProposalSigningBackendSelector::Dkg(backend) => {
                 let bridge_registry =