Merge pull request #3809 from dusk-network/mempool_nonce

Author: herr-seppia

rusk/CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Add support for `TransactionData::Blob`
+- Add `mempool_nonce` field to `/on/account/status` response
 
 ## [1.3.0] - 2025-04-17
 

rusk/src/lib/http/chain.rs

@@ -10,14 +10,16 @@ pub mod graphql;
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use dusk_bytes::DeserializableSlice;
+use dusk_core::signatures::bls::PublicKey as BlsPublicKey;
 use dusk_core::transfer::data::{BlobData, BlobSidecar};
 use dusk_core::transfer::Transaction as ProtocolTransaction;
 use dusk_vm::execute;
 use node::database::rocksdb::MD_HASH_KEY;
 use node::database::{self, Ledger, LightBlock, Mempool, Metadata, DB};
 use node::mempool::MempoolSrv;
 use node::vm::VMExecution;
-use node_data::ledger::Transaction;
+use node_data::ledger::{SpendingId, Transaction};
 
 use async_graphql::{
     EmptyMutation, EmptySubscription, Name, Schema, Variables,
@@ -62,6 +64,7 @@ impl HandleRequest for RuskNode {
             ("network", _, "peers") => true,
             ("network", _, "peers_location") => true,
             ("node", _, "info") => true,
+            ("account", Some(_), "status") => true,
             ("blocks", _, "gas-price") => true,
             ("blobs", Some(_), "commitment") => true,
             ("blobs", Some(_), "hash") => true,
@@ -93,6 +96,7 @@ impl HandleRequest for RuskNode {
 
             ("network", _, "peers_location") => self.peers_location().await,
             ("node", _, "info") => self.get_info().await,
+            ("account", Some(pk), "status") => self.get_account(pk).await,
             ("blocks", _, "gas-price") => {
                 let max_transactions = request
                     .data
@@ -333,6 +337,51 @@ impl RuskNode {
         };
         Ok(response)
     }
+
+    async fn get_account(&self, pk: &str) -> anyhow::Result<ResponseData> {
+        let pk = bs58::decode(pk)
+            .into_vec()
+            .map_err(|_| anyhow::anyhow!("Invalid bs58 account"))?;
+        let pk = BlsPublicKey::from_slice(&pk)
+            .map_err(|_| anyhow::anyhow!("Invalid bls account"))?;
+
+        let db = self.inner().database();
+        let vm = self.inner().vm_handler();
+
+        let account = vm
+            .read()
+            .await
+            .account(&pk)
+            .map_err(|e| anyhow::anyhow!("Cannot query the state {e:?}"))?;
+
+        // Determine the next available nonce not already used in the mempool.
+        // This ensures that any in-flight transactions using sequential nonces
+        // are accounted for.
+        // If the account has no transactions in the mempool, the mempool_nonce
+        // will be `None`, indicating that the next nonce is the same as the
+        // account's current nonce.
+        let mempool_nonce = db
+            .read()
+            .await
+            .view(|t| {
+                let mut next_nonce = account.nonce;
+                loop {
+                    let id = SpendingId::AccountNonce(pk, next_nonce);
+                    if t.mempool_txs_by_spendable_ids(&[id]).is_empty() {
+                        break;
+                    }
+                    next_nonce += 1;
+                }
+                anyhow::Ok((next_nonce > account.nonce).then_some(next_nonce))
+            })
+            .map_err(|e| anyhow::anyhow!("Cannot check the mempool {e}"))?;
+
+        Ok(ResponseData::new(json!({
+            "balance": account.balance,
+            "nonce": account.nonce,
+            "mempool_nonce": mempool_nonce,
+        })))
+    }
 }
 
 async fn load_tip<DB: database::DB>(

rusk/src/lib/http/rusk.rs

@@ -7,16 +7,14 @@
 use super::*;
 
 use anyhow::anyhow;
-use dusk_bytes::{DeserializableSlice, Serializable};
+use dusk_bytes::Serializable;
 use dusk_core::abi::ContractId;
-use dusk_core::signatures::bls::PublicKey as BlsPublicKey;
 use dusk_core::stake::{StakeFundOwner, STAKE_CONTRACT};
 use dusk_core::transfer::TRANSFER_CONTRACT;
 use dusk_data_driver::ConvertibleContract;
 use event::RequestData;
 use rusk_profile::CRS_17_HASH;
 use serde::Serialize;
-use serde_json::json;
 use std::sync::mpsc;
 use std::thread;
 
@@ -32,7 +30,6 @@ impl HandleRequest for Rusk {
             ("contracts", Some(_), _) => true,
             ("driver", Some(_), _) => true,
             ("node", _, "provisioners") => true,
-            ("account", Some(_), "status") => true,
             ("node", _, "crs") => true,
             _ => false,
         }
@@ -57,7 +54,6 @@ impl HandleRequest for Rusk {
             }
             ("node", _, "provisioners") => self.get_provisioners(),
 
-            ("account", Some(pk), "status") => self.get_account(pk),
             ("node", _, "crs") => self.get_crs(),
             _ => Err(anyhow::anyhow!("Unsupported")),
         }
@@ -228,24 +224,6 @@ impl Rusk {
         Ok(ResponseData::new(serde_json::to_value(prov)?))
     }
 
-    fn get_account(&self, pk: &str) -> anyhow::Result<ResponseData> {
-        let pk = bs58::decode(pk)
-            .into_vec()
-            .map_err(|_| anyhow::anyhow!("Invalid bs58 account"))?;
-        let pk = BlsPublicKey::from_slice(&pk)
-            .map_err(|_| anyhow::anyhow!("Invalid bls account"))?;
-        let account = self
-            .account(&pk)
-            .map(|account| {
-                json!({
-                    "balance": account.balance,
-                    "nonce": account.nonce,
-                })
-            })
-            .map_err(|e| anyhow::anyhow!("Cannot query the state {e:?}"))?;
-        Ok(ResponseData::new(account))
-    }
-
     fn get_crs(&self) -> anyhow::Result<ResponseData> {
         let crs = rusk_profile::get_common_reference_string()?;
         Ok(ResponseData::new(crs).with_header("crs-hash", CRS_17_HASH))