rusk: add tests for sequential nonce ordering

Author: herr-seppia

rusk/tests/common/wallet/test_wallet/imp.rs

@@ -743,6 +743,7 @@ where
             gas_limit,
             gas_price,
             data,
+            None,
         )
     }
 
@@ -757,23 +758,26 @@ where
         gas_limit: u64,
         gas_price: u64,
         data: Option<impl Into<TransactionData>>,
+        nonce: Option<u64>,
     ) -> Result<Transaction, Error<S, SC>> {
         let mut seed = self.store.get_seed().map_err(Error::from_store_err)?;
         let mut sender_sk = derive_bls_sk(&seed, sender_index);
         let sender_account = BlsPublicKey::from(&sender_sk);
 
+        println!("before fetch_account");
         let account = self
             .state
             .fetch_account(&sender_account)
             .map_err(Error::from_state_err)?;
+        println!("after fetch_account");
 
         // technically this check is not necessary, but it's nice to not spam
         // the network with transactions that are unspendable.
         let max_value = value + deposit + gas_limit * gas_price;
         if max_value > account.balance {
             return Err(ExecutionError::InsufficientBalance.into());
         }
-        let nonce = account.nonce + 1;
+        let nonce = nonce.unwrap_or(account.nonce + 1);
 
         let chain_id =
             self.state.fetch_chain_id().map_err(Error::from_state_err)?;

rusk/tests/config/sequential_nonce.toml

@@ -0,0 +1,13 @@
+[[moonlight_account]]
+address = "qe1FbZxf6YaCAeFNSvL1G82cBhG4Q4gBf4vKYo527Vws3b23jdbBuzKSFsdUHnZeBgsTnyNJLkApEpRyJw87sdzR9g9iESJrG5ZgpCs9jq88m6d4qMY5txGpaXskRQmkzE3"
+balance = 10_000_000_000
+
+
+[[moonlight_account]]
+address = "25omWWRyfcMjYNbQZVyc3rypYLi8UqZuthoJHqbCEriRX3z2EmnBaXWZLFL2NvzvDnkoYoHLGiSYQpmupNJj1sSdWNstqzfFEpiqvSNYw7gqvoEiU9FsEHUMG1ZyG3XgL8Rv"
+balance = 10_000_000_000
+
+
+[[moonlight_account]]
+address = "mqL8WTruQUzafU8Q4bSFqTLMhHmB97DAGow73KRpDkDik5vqMD9EpGvyZc2j3TFaEh8hc6g3LJ5X3ox18HDDoVDj8MKaHPzphvdgyG4XmsFEafAiym6kqRPmB14QNRvkEK4"
+balance = 10_000_000_000

rusk/tests/services/init.rs

@@ -48,10 +48,7 @@ const OWNER: [u8; 32] = [1; 32];
 const DEPLOYER_INDEX: u8 = 0;
 const SENDER_INDEX: u8 = 1;
 
-async fn initial_state<P: AsRef<Path>>(
-    dir: P,
-    owner: impl AsRef<[u8]>,
-) -> Result<Rusk> {
+async fn initial_state<P: AsRef<Path>>(dir: P) -> Result<Rusk> {
     let dir = dir.as_ref();
 
     let snapshot = toml::from_str(include_str!("../config/init.toml"))
@@ -181,7 +178,7 @@ pub async fn calling_init_via_tx_fails() -> Result<()> {
     logger();
 
     let tmp = tempdir().expect("Should be able to create temporary directory");
-    let rusk = initial_state(&tmp, OWNER).await?;
+    let rusk = initial_state(&tmp).await?;
 
     let cache = Arc::new(RwLock::new(HashMap::new()));
 

rusk/tests/services/mod.rs

@@ -16,5 +16,6 @@ pub mod moonlight_stake;
 pub mod multi_transfer;
 pub mod owner_calls;
 pub mod phoenix_stake;
+pub mod sequential_nonce;
 pub mod transfer;
 pub mod unspendable;

rusk/tests/services/sequential_nonce.rs

@@ -0,0 +1,204 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// Copyright (c) DUSK NETWORK. All rights reserved.
+
+use std::collections::HashMap;
+use std::path::Path;
+use std::sync::{Arc, RwLock};
+
+use dusk_bytes::Serializable;
+use dusk_core::transfer::data::TransactionData;
+use rand::prelude::*;
+use rand::rngs::StdRng;
+use rusk::node::RuskVmConfig;
+use rusk::{Result, Rusk};
+use tempfile::tempdir;
+use tracing::info;
+
+use crate::common::logger;
+use crate::common::state::{generator_procedure, new_state, ExecuteResult};
+use crate::common::wallet::{
+    test_wallet as wallet, TestStateClient, TestStore,
+};
+
+const BLOCK_HEIGHT: u64 = 1;
+// This is purposefully chosen to be low to trigger the discarding of a
+// perfectly good transaction.
+const BLOCK_GAS_LIMIT: u64 = 24_000_000;
+
+const GAS_LIMIT: u64 = 12_000_000; // Lowest value for a transfer
+const INITIAL_BALANCE: u64 = 10_000_000_000;
+
+// Creates the Rusk initial state for the tests below
+async fn initial_state<P: AsRef<Path>>(dir: P) -> Result<Rusk> {
+    let snapshot =
+        toml::from_str(include_str!("../config/sequential_nonce.toml"))
+            .expect("Cannot deserialize config");
+    let vm_config = RuskVmConfig::new().with_block_gas_limit(BLOCK_GAS_LIMIT);
+
+    new_state(dir, &snapshot, vm_config).await
+}
+
+/// Executes three different transactions in the same block, expecting only two
+/// to be included due to exceeding the block gas limit
+fn wallet_transfer(
+    rusk: &Rusk,
+    wallet: &wallet::Wallet<TestStore, TestStateClient>,
+    amount: u64,
+) {
+    for i in 0..3 {
+        let account = wallet
+            .account_public_key(i)
+            .expect("Failed to get the account");
+        info!(
+            "Account {i}: {}",
+            bs58::encode(account.to_bytes()).into_string()
+        );
+    }
+    // Generate a receiver pk
+    let receiver = wallet
+        .account_public_key(3)
+        .expect("Failed to get public key");
+
+    let initial_balance_0 = wallet
+        .get_account(0)
+        .expect("Failed to get the balance")
+        .balance;
+    let initial_balance_1 = wallet
+        .get_account(1)
+        .expect("Failed to get the balance")
+        .balance;
+    let initial_balance_2 = wallet
+        .get_account(2)
+        .expect("Failed to get the balance")
+        .balance;
+
+    // Check the senders initial balance is correct
+    assert_eq!(
+        initial_balance_0, INITIAL_BALANCE,
+        "Wrong initial balance for the sender"
+    );
+    assert_eq!(
+        initial_balance_1, INITIAL_BALANCE,
+        "Wrong initial balance for the sender"
+    );
+    assert_eq!(
+        initial_balance_2, INITIAL_BALANCE,
+        "Wrong initial balance for the sender"
+    );
+
+    // Check the receiver initial balance is zero
+    assert_eq!(
+        wallet
+            .get_balance(3)
+            .expect("Failed to get the balance")
+            .value,
+        0,
+        "Wrong initial balance for the receiver"
+    );
+
+    const TOTAL_TX: u64 = 50;
+    let mut idxs: Vec<u64> = (1..=TOTAL_TX).collect();
+    let mut rng = thread_rng(); // Get a random number generator
+    idxs.shuffle(&mut rng);
+
+    let mut txs = Vec::with_capacity(TOTAL_TX as usize);
+    for i in idxs {
+        let tx = wallet
+            .moonlight_transaction(
+                0,
+                Some(receiver),
+                amount,
+                0,
+                GAS_LIMIT,
+                1,
+                None::<TransactionData>,
+                Some(i),
+            )
+            .expect("Failed to transfer");
+
+        txs.push(tx);
+    }
+
+    let expected = ExecuteResult {
+        discarded: 0,
+        executed: TOTAL_TX as usize,
+    };
+
+    generator_procedure(
+        rusk,
+        &txs[..],
+        BLOCK_HEIGHT,
+        BLOCK_GAS_LIMIT,
+        vec![],
+        Some(expected),
+    )
+    .expect("generator procedure to succeed");
+
+    // Check the receiver's balance is changed accordingly
+    assert_eq!(
+        wallet
+            .get_account(3)
+            .expect("Failed to get the balance")
+            .balance,
+        TOTAL_TX * amount,
+        "Wrong resulting balance for the receiver"
+    );
+
+    let final_balance_0 = wallet
+        .get_account(0)
+        .expect("Failed to get the balance")
+        .balance;
+    let gas_limit_0 = txs[0].gas_limit();
+    let gas_price_0 = txs[0].gas_price();
+    let fee_0 = gas_limit_0 * gas_price_0;
+
+    assert!(
+        initial_balance_0 - (amount + fee_0) * TOTAL_TX <= final_balance_0,
+        "Final sender balance {} should be greater or equal than {}",
+        final_balance_0,
+        initial_balance_0 - (amount + fee_0) * TOTAL_TX
+    );
+
+    assert!(
+        initial_balance_0 - amount * TOTAL_TX >= final_balance_0,
+        "Final sender balance {} should be lesser or equal than {}",
+        final_balance_0,
+        initial_balance_0 - amount * TOTAL_TX
+    );
+}
+
+#[tokio::test(flavor = "multi_thread")]
+pub async fn multi_transfer() -> Result<()> {
+    // Setup the logger
+    logger();
+
+    let tmp = tempdir().expect("Should be able to create temporary directory");
+    let rusk = initial_state(&tmp).await?;
+
+    let cache = Arc::new(RwLock::new(HashMap::new()));
+
+    // Create a wallet
+    let wallet = wallet::Wallet::new(
+        TestStore,
+        TestStateClient {
+            rusk: rusk.clone(),
+            cache,
+        },
+    );
+
+    let original_root = rusk.state_root();
+
+    info!("Original Root: {}", hex::encode(original_root));
+
+    wallet_transfer(&rusk, &wallet, 1_000);
+
+    // Check the state's root is changed from the original one
+    let new_root = rusk.state_root();
+    info!("New root after the 1st transfer: {}", hex::encode(new_root));
+    assert_ne!(original_root, new_root, "Root should have changed");
+
+    Ok(())
+}