fix(relayer): resync nonce only on errors (#504)

* fix(relayer): resync nonce only on errors

* chore: bumped version

* chore: do not resync if batch is empty

* refactor: resync only evm nonce

* chore: keep same var name

* feat: resync polygon nonce

* chore: cleanup

* refactor: use `is_evm_chain` instead

* fix: use fast nonce for initiating fast transfer

Author: frolvanya

omni-relayer/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "omni-relayer"
-version = "0.5.5"
+version = "0.5.6"
 edition = "2024"
 resolver = "2"
 repository = "https://github.com/Near-One/omni-bridge"

omni-relayer/Cargo.toml

@@ -202,6 +202,9 @@ impl EvmNonceManagers {
         if let Some(bnb) = self.bnb.as_ref() {
             bnb.resync_nonce().await?;
         }
+        if let Some(pol) = self.pol.as_ref() {
+            pol.resync_nonce().await?;
+        }
 
         Ok(())
     }

omni-relayer/src/utils/nonce.rs

@@ -1,6 +1,9 @@
-use std::sync::Arc;
+use std::sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering},
+};
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use bridge_indexer_types::documents_types::DepositMsg;
 use futures::future::join_all;
 use rust_decimal::MathematicalOps;
@@ -151,6 +154,20 @@ pub async fn process_events(
         .near_bridge_client()
         .and_then(near_bridge_client::NearBridgeClient::account_id)?;
 
+    near_omni_nonce
+        .resync_nonce()
+        .await
+        .context("Failed to resync near nonce")?;
+
+    if let Some(near_fast_nonce) = near_fast_nonce.clone() {
+        near_fast_nonce
+            .resync_nonce()
+            .await
+            .context("Failed to resync near fast nonce")?;
+    }
+
+    let is_evm_nonce_resync_needed = Arc::new(AtomicBool::new(true));
+
     loop {
         let mut redis_connection_manager_clone = redis_connection_manager.clone();
 
@@ -176,18 +193,13 @@ pub async fn process_events(
             continue;
         }
 
-        if let Err(err) = near_omni_nonce.resync_nonce().await {
-            warn!("Failed to resync near nonce: {err:?}");
-        }
-
-        if let Some(near_fast_nonce) = near_fast_nonce.clone() {
-            if let Err(err) = near_fast_nonce.resync_nonce().await {
-                warn!("Failed to resync near fast nonce: {err:?}");
+        if is_evm_nonce_resync_needed.load(Ordering::Relaxed) {
+            if let Err(err) = evm_nonces.resync_nonces().await {
+                warn!("Failed to resync evm nonces: {err:?}");
+                continue;
             }
-        }
 
-        if let Err(err) = evm_nonces.resync_nonces().await {
-            warn!("Failed to resync evm nonces: {err:?}");
+            is_evm_nonce_resync_needed.store(false, Ordering::Relaxed);
         }
 
         let current_timestamp = chrono::Utc::now().timestamp();
@@ -552,13 +564,16 @@ pub async fn process_events(
                         let config = config.clone();
                         let mut redis_connection_manager = redis_connection_manager.clone();
                         let fast_connector = fast_connector.clone();
-                        let near_omni_nonce = near_omni_nonce.clone();
+                        let Some(near_fast_nonce) = near_fast_nonce.clone() else {
+                                warn!("Fast transfer event found but near fast nonce manager is not configured");
+                                continue;
+                        };
 
                         async move {
                             match near::initiate_fast_transfer(
                                 fast_connector,
                                 transfer,
-                                near_omni_nonce,
+                                near_fast_nonce,
                             )
                             .await
                             {
@@ -599,6 +614,7 @@ pub async fn process_events(
                         let omni_connector = omni_connector.clone();
                         let signer = signer.clone();
                         let evm_nonces = evm_nonces.clone();
+                        let is_evm_nonce_resync_needed = is_evm_nonce_resync_needed.clone();
 
                         async move {
                             match near::process_sign_transfer_event(
@@ -611,7 +627,11 @@ pub async fn process_events(
                             )
                             .await
                             {
-                                Ok(EventAction::Retry) => {}
+                                Ok(EventAction::Retry) => {
+                                    if message_payload.recipient.get_chain().is_evm_chain() {
+                                        is_evm_nonce_resync_needed.store(true, Ordering::Relaxed);
+                                    }
+                                }
                                 Ok(EventAction::Remove) => {
                                     utils::redis::remove_event(
                                         &config,
@@ -630,6 +650,9 @@ pub async fn process_events(
                                     .await;
                                 }
                                 Err(err) => {
+                                    if message_payload.recipient.get_chain().is_evm_chain() {
+                                        is_evm_nonce_resync_needed.store(true, Ordering::Relaxed);
+                                    }
                                     warn!("{err:?}");
                                     utils::redis::remove_event(
                                         &config,

omni-relayer/src/workers/mod.rs

@@ -600,7 +600,7 @@ pub async fn process_unverified_transfer_event(
 pub async fn initiate_fast_transfer(
     fast_connector: Arc<OmniConnector>,
     transfer: Transfer,
-    near_omni_nonce: Arc<utils::nonce::NonceManager>,
+    near_fast_nonce: Arc<utils::nonce::NonceManager>,
 ) -> Result<EventAction> {
     let Ok(near_bridge_client) = fast_connector.near_bridge_client() else {
         anyhow::bail!("Near bridge client is not configured");
@@ -690,7 +690,7 @@ pub async fn initiate_fast_transfer(
     }
 
     let mut nonce = Some(
-        near_omni_nonce
+        near_fast_nonce
             .reserve_nonce()
             .await
             .context("Failed to reserve nonce for near transaction")?,
@@ -717,7 +717,7 @@ pub async fn initiate_fast_transfer(
     {
         Ok(true) => {
             nonce = Some(
-                near_omni_nonce
+                near_fast_nonce
                     .reserve_nonce()
                     .await
                     .context("Failed to reserve nonce for near transaction")?,