Added fetch_add_nonce method for NodeInteraction trait. Added extra logging. (#25)

* added logging

* added fetch_add_nonce method

* Added nonce for legacy transaction also

* Addressed PR comments

crates/node-interaction/src/lib.rs

@@ -1,9 +1,11 @@
 //! This crate implements all node interactions.
 
+use alloy::primitives::Address;
 use alloy::rpc::types::trace::geth::{DiffMode, GethTrace};
 use alloy::rpc::types::{TransactionReceipt, TransactionRequest};
 use tokio_runtime::TO_TOKIO;
 
+pub mod nonce;
 mod tokio_runtime;
 pub mod trace;
 pub mod transaction;
@@ -21,4 +23,7 @@ pub trait EthereumNode {
 
     /// Returns the state diff of the transaction hash in the [TransactionReceipt].
     fn state_diff(&self, transaction: TransactionReceipt) -> anyhow::Result<DiffMode>;
+
+    /// Returns the next available nonce for the given [Address].
+    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64>;
 }

crates/node-interaction/src/nonce.rs

@@ -0,0 +1,55 @@
+use std::pin::Pin;
+
+use alloy::{
+    primitives::Address,
+    providers::{Provider, ProviderBuilder},
+};
+use tokio::sync::oneshot;
+
+use crate::{TO_TOKIO, tokio_runtime::AsyncNodeInteraction};
+
+pub type Task = Pin<Box<dyn Future<Output = anyhow::Result<u64>> + Send>>;
+
+pub(crate) struct Nonce {
+    sender: oneshot::Sender<anyhow::Result<u64>>,
+    task: Task,
+}
+
+impl AsyncNodeInteraction for Nonce {
+    type Output = anyhow::Result<u64>;
+
+    fn split(
+        self,
+    ) -> (
+        std::pin::Pin<Box<dyn Future<Output = Self::Output> + Send>>,
+        oneshot::Sender<Self::Output>,
+    ) {
+        (self.task, self.sender)
+    }
+}
+
+/// This is like `trace_transaction`, just for nonces.
+pub fn fetch_onchain_nonce(
+    connection: String,
+    wallet: alloy::network::EthereumWallet,
+    address: Address,
+) -> anyhow::Result<u64> {
+    let sender = TO_TOKIO.lock().unwrap().nonce_sender.clone();
+
+    let (tx, rx) = oneshot::channel();
+    let task: Task = Box::pin(async move {
+        let provider = ProviderBuilder::new()
+            .wallet(wallet)
+            .connect(&connection)
+            .await?;
+        let onchain = provider.get_transaction_count(address).await?;
+        Ok(onchain)
+    });
+
+    sender
+        .blocking_send(Nonce { task, sender: tx })
+        .expect("not in async context");
+
+    rx.blocking_recv()
+        .unwrap_or_else(|err| anyhow::bail!("nonce fetch failed: {err}"))
+}

crates/node-interaction/src/tokio_runtime.rs

@@ -10,6 +10,7 @@ use tokio::spawn;
 use tokio::sync::{mpsc, oneshot};
 use tokio::task::JoinError;
 
+use crate::nonce::Nonce;
 use crate::trace::Trace;
 use crate::transaction::Transaction;
 
@@ -33,6 +34,7 @@ pub(crate) trait AsyncNodeInteraction: Send + 'static {
 pub(crate) struct TokioRuntime {
     pub(crate) transaction_sender: mpsc::Sender<Transaction>,
     pub(crate) trace_sender: mpsc::Sender<Trace>,
+    pub(crate) nonce_sender: mpsc::Sender<Nonce>,
 }
 
 impl TokioRuntime {
@@ -40,11 +42,13 @@ impl TokioRuntime {
         let rt = Runtime::new().expect("should be able to create the tokio runtime");
         let (transaction_sender, transaction_receiver) = mpsc::channel::<Transaction>(1024);
         let (trace_sender, trace_receiver) = mpsc::channel::<Trace>(1024);
+        let (nonce_sender, nonce_receiver) = mpsc::channel::<Nonce>(1024);
 
         thread::spawn(move || {
             rt.block_on(async move {
                 let transaction_task = spawn(interaction::<Transaction>(transaction_receiver));
                 let trace_task = spawn(interaction::<Trace>(trace_receiver));
+                let nonce_task = spawn(interaction::<Nonce>(nonce_receiver));
 
                 if let Err(error) = transaction_task.await {
                     log::error!("tokio transaction task failed: {error}");
@@ -52,12 +56,16 @@ impl TokioRuntime {
                 if let Err(error) = trace_task.await {
                     log::error!("tokio trace transaction task failed: {error}");
                 }
+                if let Err(error) = nonce_task.await {
+                    log::error!("tokio nonce task failed: {error}");
+                }
             });
         });
 
         Self {
             transaction_sender,
             trace_sender,
+            nonce_sender,
         }
     }
 }