chores

Author: hlgltvnnk

Cargo.toml

@@ -50,7 +50,7 @@ secp256k1 = { version = "0.27.0", default-features = false, features = [
     "alloc",
 ] }
 
-near-account-id = { version = "2.0.0", features = ["serde", "borsh", "abi"] }
+near-account-id = { version = "2.0.0", features = ["serde", "borsh"] }
 near-gas = { version = "0.3", features = ["serde", "borsh"] }
 near-token = { version = "0.3", features = ["serde", "borsh"] }
 near-abi = "0.4.2"

api/src/signer/mod.rs

@@ -141,7 +141,7 @@ pub mod keystore;
 #[cfg(feature = "ledger")]
 pub mod ledger;
 pub mod secret_key;
-pub mod sequential;
+mod sequential;
 
 const SIGNER_TARGET: &str = "near_api::signer";
 /// Default HD path for seed phrases and secret keys generation
@@ -407,8 +407,8 @@ pub type TransactionGroupKey = (String, AccountId, PublicKey);
 /// adding more keys to the signer pool
 pub struct Signer {
     pool: tokio::sync::RwLock<HashMap<PublicKey, Box<dyn SignerTrait + Send + Sync + 'static>>>,
+    nonce_cache: Mutex<HashMap<TransactionGroupKey, Arc<Mutex<u64>>>>,
     current_public_key: AtomicUsize,
-    sequential_nonces: Mutex<HashMap<TransactionGroupKey, Arc<Mutex<u64>>>>,
 }
 
 impl Signer {
@@ -423,8 +423,8 @@ impl Signer {
                 public_key,
                 Box::new(signer) as Box<dyn SignerTrait + Send + Sync + 'static>,
             )])),
+            nonce_cache: Mutex::new(HashMap::new()),
             current_public_key: AtomicUsize::new(0),
-            sequential_nonces: Mutex::new(HashMap::new()),
         }))
     }
 

api/src/signer/sequential.rs

@@ -39,8 +39,8 @@ impl Signer {
         ))
     }
 
-    async fn get_sequential_nonce(&self, key: TransactionGroupKey) -> Arc<Mutex<u64>> {
-        self.sequential_nonces
+    async fn get_nonce_cache(&self, key: TransactionGroupKey) -> Arc<Mutex<u64>> {
+        self.nonce_cache
             .lock()
             .await
             .entry(key)
@@ -67,14 +67,14 @@ impl Signer {
         debug!(target: SIGNER_TARGET, "Fetching transaction nonce");
 
         let key = (network.network_name.clone(), account_id.clone(), public_key);
-        let lock = self.get_sequential_nonce(key).await;
+        let lock = self.get_nonce_cache(key).await;
         let mut nonce = lock.lock().await;
 
         // It is important to fetch the nonce data after lock to get fresh block hash
-        let (cached_nonce, block_hash, block_height) =
+        let (fetched_nonce, block_hash, block_height) =
             Self::fetch_nonce_data(account_id, public_key, network).await?;
 
-        *nonce = (*nonce).max(cached_nonce) + 1;
+        *nonce = (*nonce).max(fetched_nonce) + 1;
 
         Ok((*nonce, block_hash, block_height))
     }
@@ -109,7 +109,7 @@ impl Signer {
             .await?;
 
         match wait_until {
-            TxExecutionStatus::Included => Ok(result),
+            TxExecutionStatus::None | TxExecutionStatus::Included => Ok(result),
             _ => {
                 ExecuteSignedTransaction::fetch_tx(
                     network,
@@ -163,15 +163,16 @@ impl Signer {
 
         // Locking until the transaction is sent
         let key = (network.network_name.clone(), account_id.clone(), public_key);
-        let lock = self.get_sequential_nonce(key).await;
+        let lock = self.get_nonce_cache(key).await;
         let mut nonce = lock.lock().await;
 
         // It is important to fetch the nonce data after lock to get fresh block hash
-        let (cached_nonce, block_hash, _) = Self::fetch_nonce_data(account_id, public_key, network)
-            .await
-            .map_err(MetaSignError::from)?;
+        let (fetched_nonce, block_hash, _) =
+            Self::fetch_nonce_data(account_id, public_key, network)
+                .await
+                .map_err(MetaSignError::from)?;
 
-        *nonce = (*nonce).max(cached_nonce) + 1;
+        *nonce = (*nonce).max(fetched_nonce) + 1;
 
         let signed = self
             .sign(transaction, public_key, *nonce, block_hash)
@@ -198,16 +199,16 @@ impl Signer {
 
         // Locking until the transaction is sent
         let key = (network.network_name.clone(), account_id.clone(), public_key);
-        let lock = self.get_sequential_nonce(key).await;
+        let lock = self.get_nonce_cache(key).await;
         let mut nonce = lock.lock().await;
 
         // It is important to fetch the nonce data after lock to get fresh block hash
-        let (cached_nonce, block_hash, block_height) =
+        let (fetched_nonce, block_hash, block_height) =
             Self::fetch_nonce_data(account_id, public_key, network)
                 .await
                 .map_err(MetaSignError::from)?;
 
-        *nonce = (*nonce).max(cached_nonce) + 1;
+        *nonce = (*nonce).max(fetched_nonce) + 1;
 
         let signed = self
             .sign_meta(