fix(fortuna): Reset nonce manager if receipt is not available (#1774)

* Reset nonce manager if receipt is not available

apps/fortuna/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fortuna"
-version = "6.4.1"
+version = "6.4.2"
 edition = "2021"
 
 [dependencies]
@@ -37,6 +37,7 @@ url = "2.5.0"
 chrono = { version = "0.4.38", features = ["clock", "std"] , default-features = false}
 backoff = { version = "0.4.0", features = ["futures", "tokio"] }
 thiserror = "1.0.61"
+futures-locks = "0.7.1"
 
 
 [dev-dependencies]

apps/fortuna/src/chain.rs

@@ -1,4 +1,5 @@
 pub(crate) mod eth_gas_oracle;
 pub(crate) mod ethereum;
+mod nonce_manager;
 pub(crate) mod reader;
 pub(crate) mod traced_client;

apps/fortuna/src/chain/ethereum.rs

@@ -3,6 +3,7 @@ use {
  api::ChainId,
  chain::{
  eth_gas_oracle::EthProviderOracle,
+ nonce_manager::NonceManagerMiddleware,
  reader::{
  self,
  BlockNumber,
@@ -33,7 +34,6 @@ use {
  middleware::{
  gas_oracle::GasOracleMiddleware,
  MiddlewareError,
- NonceManagerMiddleware,
  SignerMiddleware,
  },
  prelude::{

apps/fortuna/src/chain/nonce_manager.rs

@@ -0,0 +1,199 @@
+// This is a copy of the NonceManagerMiddleware from ethers-rs, with an additional reset method.
+// Copied from: https://github.com/gakonst/ethers-rs/blob/34ed9e372e66235aed7074bc3f5c14922b139242/ethers-middleware/src/nonce_manager.rs
+
+use {
+ axum::async_trait,
+ ethers::{
+ providers::{
+ Middleware,
+ MiddlewareError,
+ PendingTransaction,
+ },
+ types::{
+ transaction::eip2718::TypedTransaction,
+ *,
+ },
+ },
+ std::sync::atomic::{
+ AtomicBool,
+ AtomicU64,
+ Ordering,
+ },
+ thiserror::Error,
+};
+
+#[derive(Debug)]
+/// Middleware used for calculating nonces locally, useful for signing multiple
+/// consecutive transactions without waiting for them to hit the mempool
+pub struct NonceManagerMiddleware<M> {
+ inner: M,
+ init_guard: futures_locks::Mutex<()>,
+ initialized: AtomicBool,
+ nonce: AtomicU64,
+ address: Address,
+}
+
+impl<M> NonceManagerMiddleware<M>
+where
+ M: Middleware,
+{
+ /// Instantiates the nonce manager with a 0 nonce. The `address` should be the
+ /// address which you'll be sending transactions from
+ pub fn new(inner: M, address: Address) -> Self {
+ Self {
+ inner,
+ init_guard: Default::default(),
+ initialized: Default::default(),
+ nonce: Default::default(),
+ address,
+ }
+ }
+
+ /// Returns the next nonce to be used
+ pub fn next(&self) -> U256 {
+ let nonce = self.nonce.fetch_add(1, Ordering::SeqCst);
+ nonce.into()
+ }
+
+ pub async fn initialize_nonce(
+ &self,
+ block: Option<BlockId>,
+ ) -> Result<U256, NonceManagerError<M>> {
+ if self.initialized.load(Ordering::SeqCst) {
+ // return current nonce
+ return Ok(self.nonce.load(Ordering::SeqCst).into());
+ }
+
+ let _guard = self.init_guard.lock().await;
+
+ // do this again in case multiple tasks enter this codepath
+ if self.initialized.load(Ordering::SeqCst) {
+ // return current nonce
+ return Ok(self.nonce.load(Ordering::SeqCst).into());
+ }
+
+ // initialize the nonce the first time the manager is called
+ let nonce = self
+ .inner
+ .get_transaction_count(self.address, block)
+ .await
+ .map_err(MiddlewareError::from_err)?;
+ self.nonce.store(nonce.as_u64(), Ordering::SeqCst);
+ self.initialized.store(true, Ordering::SeqCst);
+ Ok(nonce)
+ } // guard dropped here
+
+ /// Resets the initialized flag so the next usage of the manager will reinitialize the nonce
+ /// based on the chain state.
+ /// This is useful when the RPC does not return an error if the transaction is submitted with
+ /// an incorrect nonce.
+ /// This is the only new method compared to the original NonceManagerMiddleware.
+ pub fn reset(&self) {
+ self.initialized.store(false, Ordering::SeqCst);
+ }
+
+ async fn get_transaction_count_with_manager(
+ &self,
+ block: Option<BlockId>,
+ ) -> Result<U256, NonceManagerError<M>> {
+ // initialize the nonce the first time the manager is called
+ if !self.initialized.load(Ordering::SeqCst) {
+ let nonce = self
+ .inner
+ .get_transaction_count(self.address, block)
+ .await
+ .map_err(MiddlewareError::from_err)?;
+ self.nonce.store(nonce.as_u64(), Ordering::SeqCst);
+ self.initialized.store(true, Ordering::SeqCst);
+ }
+
+ Ok(self.next())
+ }
+}
+
+#[derive(Error, Debug)]
+/// Thrown when an error happens at the Nonce Manager
+pub enum NonceManagerError<M: Middleware> {
+ /// Thrown when the internal middleware errors
+ #[error("{0}")]
+ MiddlewareError(M::Error),
+}
+
+impl<M: Middleware> MiddlewareError for NonceManagerError<M> {
+ type Inner = M::Error;
+
+ fn from_err(src: M::Error) -> Self {
+ NonceManagerError::MiddlewareError(src)
+ }
+
+ fn as_inner(&self) -> Option<&Self::Inner> {
+ match self {
+ NonceManagerError::MiddlewareError(e) => Some(e),
+ }
+ }
+}
+
+#[async_trait]
+impl<M> Middleware for NonceManagerMiddleware<M>
+where
+ M: Middleware,
+{
+ type Error = NonceManagerError<M>;
+ type Provider = M::Provider;
+ type Inner = M;
+
+ fn inner(&self) -> &M {
+ &self.inner
+ }
+
+ async fn fill_transaction(
+ &self,
+ tx: &mut TypedTransaction,
+ block: Option<BlockId>,
+ ) -> Result<(), Self::Error> {
+ if tx.nonce().is_none() {
+ tx.set_nonce(self.get_transaction_count_with_manager(block).await?);
+ }
+
+ Ok(self
+ .inner()
+ .fill_transaction(tx, block)
+ .await
+ .map_err(MiddlewareError::from_err)?)
+ }
+
+ /// Signs and broadcasts the transaction. The optional parameter `block` can be passed so that
+ /// gas cost and nonce calculations take it into account. For simple transactions this can be
+ /// left to `None`.
+ async fn send_transaction<T: Into<TypedTransaction> + Send + Sync>(
+ &self,
+ tx: T,
+ block: Option<BlockId>,
+ ) -> Result<PendingTransaction<'_, Self::Provider>, Self::Error> {
+ let mut tx = tx.into();
+
+ if tx.nonce().is_none() {
+ tx.set_nonce(self.get_transaction_count_with_manager(block).await?);
+ }
+
+ match self.inner.send_transaction(tx.clone(), block).await {
+ Ok(tx_hash) => Ok(tx_hash),
+ Err(err) => {
+ let nonce = self.get_transaction_count(self.address, block).await?;
+ if nonce != self.nonce.load(Ordering::SeqCst).into() {
+ // try re-submitting the transaction with the correct nonce if there
+ // was a nonce mismatch
+ self.nonce.store(nonce.as_u64(), Ordering::SeqCst);
+ tx.set_nonce(nonce);
+ self.inner
+ .send_transaction(tx, block)
+ .await
+ .map_err(MiddlewareError::from_err)
+ } else {
+ // propagate the error otherwise
+ Err(MiddlewareError::from_err(err))
+ }
+ }
+ }
+ }
+}

apps/fortuna/src/keeper.rs

@@ -503,6 +503,10 @@ pub async fn process_event(
  ))
  })?
  .ok_or_else(|| {
+ // RPC may not return an error on tx submission if the nonce is too high.
+ // But we will never get a receipt. So we reset the nonce manager to get the correct nonce.
+ let nonce_manager = contract.client_ref().inner().inner();
+ nonce_manager.reset();
  backoff::Error::transient(anyhow!(
  "Can't verify the reveal, probably dropped from mempool Tx:{:?}",
  transaction