Expand work done in provide_batch

substrate/serai/client/src/serai/mod.rs

@@ -189,6 +189,15 @@ impl Serai {
     self.get_block(hash.into()).await
   }
 
+  pub async fn get_nonce(&self, address: &SeraiAddress) -> Result<u32, SeraiError> {
+    self
+      .0
+      .rpc()
+      .system_account_next_index(&sp_core::sr25519::Public(address.0).to_string())
+      .await
+      .map_err(SeraiError::RpcError)
+  }
+
   pub fn unsigned(&self, payload: &DynamicTxPayload<'static>) -> Result<Encoded, SeraiError> {
     TxClient::new(self.0.offline())
       .create_unsigned(payload)

substrate/serai/client/tests/batch.rs

@@ -1,24 +1,17 @@
 use rand_core::{RngCore, OsRng};
 
-use scale::Encode;
-
-use sp_core::Pair;
-
 use serai_client::{
-  primitives::{
+  primitives::{BITCOIN_NET_ID, BITCOIN, BlockHash, SeraiAddress, Amount, Balance},
-    BITCOIN_NET_ID, BITCOIN, BlockHash, SeraiAddress, Amount, Balance, insecure_pair_from_name,
-  },
-  tokens::TokensEvent,
-  validator_sets::primitives::{Session, ValidatorSet},
   in_instructions::{
-    primitives::{InInstruction, InInstructionWithBalance, Batch, SignedBatch},
+    primitives::{InInstruction, InInstructionWithBalance, Batch},
     InInstructionsEvent,
   },
+  tokens::TokensEvent,
   Serai,
 };
 
 mod common;
-use common::{serai, validator_sets::vote_in_key, in_instructions::provide_batch};
+use common::{serai, in_instructions::provide_batch};
 
 serai_test!(
   async fn publish_batch() {
@@ -45,12 +38,7 @@ serai_test!(
       }],
     };
 
-    let batch_pair = insecure_pair_from_name("Bitcoin");
+    let block = provide_batch(batch).await;
-    let key_pair = (batch_pair.public(), vec![].try_into().unwrap());
-    vote_in_key(ValidatorSet { session: Session(0), network: BITCOIN_NET_ID }, key_pair).await;
-    let signature = batch_pair.sign(&batch.encode());
-    let signed = SignedBatch { batch, signature };
-    let block = provide_batch(signed).await;
 
     let serai = serai().await;
     let batches = serai.get_batch_events(block).await.unwrap();

substrate/serai/client/tests/burn.rs

@@ -1,7 +1,5 @@
 use rand_core::{RngCore, OsRng};
 
-use scale::Encode;
-
 use sp_core::Pair;
 
 use serai_client::{
@@ -10,17 +8,16 @@ use serai_client::{
     BITCOIN_NET_ID, BITCOIN, BlockHash, SeraiAddress, Amount, Balance, Data, ExternalAddress,
     insecure_pair_from_name,
   },
-  validator_sets::primitives::{Session, ValidatorSet},
   in_instructions::{
     InInstructionsEvent,
-    primitives::{InInstruction, InInstructionWithBalance, Batch, SignedBatch},
+    primitives::{InInstruction, InInstructionWithBalance, Batch},
   },
   tokens::{primitives::OutInstruction, TokensEvent},
   PairSigner, Serai,
 };
 
 mod common;
-use common::{serai, tx::publish_tx, validator_sets::vote_in_key, in_instructions::provide_batch};
+use common::{serai, tx::publish_tx, in_instructions::provide_batch};
 
 serai_test!(
   async fn burn() {
@@ -48,12 +45,7 @@ serai_test!(
       }],
     };
 
-    let batch_pair = insecure_pair_from_name("Bitcoin");
+    let block = provide_batch(batch).await;
-    let key_pair = (batch_pair.public(), vec![].try_into().unwrap());
-    vote_in_key(ValidatorSet { session: Session(0), network }, key_pair).await;
-    let signature = batch_pair.sign(&batch.encode());
-    let signed = SignedBatch { batch, signature };
-    let block = provide_batch(signed).await;
 
     let serai = serai().await;
     let batches = serai.get_batch_events(block).await.unwrap();

substrate/serai/client/tests/common/in_instructions.rs

@@ -1,23 +1,46 @@
-use serai_client::in_instructions::{primitives::SignedBatch, InInstructionsEvent};
+use scale::Encode;
 
-use crate::common::{serai, tx::publish_tx};
+use sp_core::Pair;
+
+use serai_client::{
+  primitives::insecure_pair_from_name,
+  validator_sets::primitives::{Session, ValidatorSet},
+  in_instructions::{
+    primitives::{Batch, SignedBatch},
+    InInstructionsEvent,
+  },
+};
+
+use crate::common::{serai, tx::publish_tx, validator_sets::vote_in_keys};
 
 #[allow(dead_code)]
-pub async fn provide_batch(batch: SignedBatch) -> [u8; 32] {
+pub async fn provide_batch(batch: Batch) -> [u8; 32] {
   let serai = serai().await;
 
-  let execution = serai.execute_batch(batch.clone()).unwrap();
+  // TODO: Get the latest session
-  let block = publish_tx(&execution).await;
+  let set = ValidatorSet { session: Session(0), network: batch.network };
+  let pair = insecure_pair_from_name(&format!("ValidatorSet {:?}", set));
+  let keys = if let Some(keys) = serai.get_keys(set).await.unwrap() {
+    keys
+  } else {
+    let keys = (pair.public(), vec![].try_into().unwrap());
+    vote_in_keys(set, keys.clone()).await;
+    keys
+  };
+  assert_eq!(keys.0, pair.public());
+
+  let block = publish_tx(
+    &serai
+      .execute_batch(SignedBatch { batch: batch.clone(), signature: pair.sign(&batch.encode()) })
+      .unwrap(),
+  )
+  .await;
 
   let batches = serai.get_batch_events(block).await.unwrap();
   // TODO: impl From<Batch> for BatchEvent?
   assert_eq!(
     batches,
-    vec![InInstructionsEvent::Batch {
+    vec![InInstructionsEvent::Batch { network: batch.network, id: batch.id, block: batch.block }],
-      network: batch.batch.network,
-      id: batch.batch.id,
-      block: batch.batch.block,
-    }],
   );
 
   // TODO: Check the tokens events

substrate/serai/client/tests/common/validator_sets.rs

@@ -2,7 +2,7 @@ use sp_core::Pair;
 
 use serai_client::{
   subxt::config::extrinsic_params::BaseExtrinsicParamsBuilder,
-  primitives::insecure_pair_from_name,
+  primitives::{SeraiAddress, insecure_pair_from_name},
   validator_sets::{
     primitives::{ValidatorSet, KeyPair},
     ValidatorSetsEvent,
@@ -13,19 +13,20 @@ use serai_client::{
 use crate::common::{serai, tx::publish_tx};
 
 #[allow(dead_code)]
-pub async fn vote_in_key(set: ValidatorSet, key_pair: KeyPair) -> [u8; 32] {
+pub async fn vote_in_keys(set: ValidatorSet, key_pair: KeyPair) -> [u8; 32] {
   let pair = insecure_pair_from_name("Alice");
   let public = pair.public();
 
   let serai = serai().await;
 
   // Vote in a key pair
+  let address = SeraiAddress::from(pair.public());
   let block = publish_tx(
     &serai
       .sign(
         &PairSigner::new(pair),
         &Serai::vote(set.network, key_pair.clone()),
-        0,
+        serai.get_nonce(&address).await.unwrap(),
         BaseExtrinsicParamsBuilder::new(),
       )
       .unwrap(),

substrate/serai/client/tests/validator_sets.rs

@@ -12,7 +12,7 @@ use serai_client::{
 };
 
 mod common;
-use common::{serai, validator_sets::vote_in_key};
+use common::{serai, validator_sets::vote_in_keys};
 
 serai_test!(
   async fn vote_keys() {
@@ -38,9 +38,9 @@ serai_test!(
     let participants_ref: &[_] = set_data.participants.as_ref();
     assert_eq!(participants_ref, [(public, set_data.bond)].as_ref());
 
-    let block = vote_in_key(set, key_pair.clone()).await;
+    let block = vote_in_keys(set, key_pair.clone()).await;
 
-    // While the vote_in_key function should handle this, it's beneficial to independently test it
+    // While the vote_in_keys function should handle this, it's beneficial to independently test it
     assert_eq!(
       serai.get_vote_events(block).await.unwrap(),
       vec![ValidatorSetsEvent::Vote { voter: public, set, key_pair: key_pair.clone(), votes: 1 }]

substrate/serai/primitives/src/account.rs

@@ -53,7 +53,7 @@ impl std::fmt::Display for SeraiAddress {
 }
 
 #[cfg(feature = "std")]
-pub fn insecure_pair_from_name(name: &'static str) -> Pair {
+pub fn insecure_pair_from_name(name: &str) -> Pair {
   Pair::from_string(&format!("//{name}"), None).unwrap()
 }