Reorganize serai-client

Instead of functions taking a block hash, has a scope to a block hash before
functions can be called.

Separates functions by pallets.

substrate/client/tests/batch.rs

@@ -13,7 +13,7 @@ use serai_client::{
     primitives::{InInstruction, InInstructionWithBalance, Batch},
     InInstructionsEvent,
   },
-  tokens::TokensEvent,
+  coins::TokensEvent,
   Serai,
 };
 
@@ -48,23 +48,25 @@ serai_test!(
     let block = provide_batch(batch.clone()).await;
 
     let serai = serai().await;
-    assert_eq!(serai.get_latest_block_for_network(block, network).await.unwrap(), Some(block_hash));
-    let batches = serai.get_batch_events(block).await.unwrap();
-    assert_eq!(
-      batches,
-      vec![InInstructionsEvent::Batch {
-        network,
-        id,
-        block: block_hash,
-        instructions_hash: Blake2b::<U32>::digest(batch.instructions.encode()).into(),
-      }]
-    );
+    let serai = serai.as_of(block);
+    {
+      let serai = serai.in_instructions();
+      assert_eq!(serai.latest_block_for_network(network).await.unwrap(), Some(block_hash));
+      let batches = serai.batch_events().await.unwrap();
+      assert_eq!(
+        batches,
+        vec![InInstructionsEvent::Batch {
+          network,
+          id,
+          block: block_hash,
+          instructions_hash: Blake2b::<U32>::digest(batch.instructions.encode()).into(),
+        }]
+      );
+    }
 
-    assert_eq!(
-      serai.get_mint_events(block).await.unwrap(),
-      vec![TokensEvent::Mint { address, balance }],
-    );
-    assert_eq!(serai.get_token_supply(block, coin).await.unwrap(), amount);
-    assert_eq!(serai.get_token_balance(block, coin, address).await.unwrap(), amount);
+    let serai = serai.coins();
+    assert_eq!(serai.mint_events().await.unwrap(), vec![TokensEvent::Mint { address, balance }],);
+    assert_eq!(serai.token_supply(coin).await.unwrap(), amount);
+    assert_eq!(serai.token_balance(coin, address).await.unwrap(), amount);
   }
 );

substrate/client/tests/burn.rs

@@ -19,8 +19,8 @@ use serai_client::{
     InInstructionsEvent,
     primitives::{InInstruction, InInstructionWithBalance, Batch},
   },
-  tokens::{primitives::OutInstruction, TokensEvent},
-  PairSigner, Serai,
+  coins::{primitives::OutInstruction, TokensEvent},
+  PairSigner, Serai, SeraiCoins,
 };
 
 mod common;
@@ -55,7 +55,8 @@ serai_test!(
     let block = provide_batch(batch.clone()).await;
 
     let serai = serai().await;
-    let batches = serai.get_batch_events(block).await.unwrap();
+    let serai = serai.as_of(block);
+    let batches = serai.in_instructions().batch_events().await.unwrap();
     assert_eq!(
       batches,
       vec![InInstructionsEvent::Batch {
@@ -67,11 +68,11 @@ serai_test!(
     );
 
     assert_eq!(
-      serai.get_mint_events(block).await.unwrap(),
+      serai.coins().mint_events().await.unwrap(),
       vec![TokensEvent::Mint { address, balance }]
     );
-    assert_eq!(serai.get_token_supply(block, coin).await.unwrap(), amount);
-    assert_eq!(serai.get_token_balance(block, coin, address).await.unwrap(), amount);
+    assert_eq!(serai.coins().token_supply(coin).await.unwrap(), amount);
+    assert_eq!(serai.coins().token_balance(coin, address).await.unwrap(), amount);
 
     // Now burn it
     let mut rand_bytes = vec![0; 32];
@@ -83,11 +84,12 @@ serai_test!(
     let data = Data::new(rand_bytes).unwrap();
 
     let out = OutInstruction { address: external_address, data: Some(data) };
+    let serai = serai.into_inner();
     let block = publish_tx(
       &serai
         .sign(
           &PairSigner::new(pair),
-          &Serai::burn(balance, out.clone()),
+          &SeraiCoins::burn(balance, out.clone()),
           0,
           BaseExtrinsicParamsBuilder::new(),
         )
@@ -95,9 +97,10 @@ serai_test!(
     )
     .await;
 
-    let events = serai.get_burn_events(block).await.unwrap();
+    let serai = serai.as_of(block).coins();
+    let events = serai.burn_events().await.unwrap();
     assert_eq!(events, vec![TokensEvent::Burn { address, balance, instruction: out }]);
-    assert_eq!(serai.get_token_supply(block, coin).await.unwrap(), Amount(0));
-    assert_eq!(serai.get_token_balance(block, coin, address).await.unwrap(), Amount(0));
+    assert_eq!(serai.token_supply(coin).await.unwrap(), Amount(0));
+    assert_eq!(serai.token_balance(coin, address).await.unwrap(), Amount(0));
   }
 );

substrate/client/tests/common/in_instructions.rs

@@ -14,10 +14,10 @@ use serai_client::{
     primitives::{Batch, SignedBatch, batch_message},
     InInstructionsEvent,
   },
-  Serai,
+  SeraiInInstructions,
 };
 
-use crate::common::{serai, tx::publish_tx, validator_sets::set_validator_set_keys};
+use crate::common::{serai, tx::publish_tx, validator_sets::set_keys};
 
 #[allow(dead_code)]
 pub async fn provide_batch(batch: Batch) -> [u8; 32] {
@@ -27,23 +27,23 @@ pub async fn provide_batch(batch: Batch) -> [u8; 32] {
   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, serai.get_latest_block_hash().await.unwrap()).await.unwrap()
+    serai.with_current_latest_block().await.unwrap().validator_sets().keys(set).await.unwrap()
   {
     keys
   } else {
     let keys = (pair.public(), vec![].try_into().unwrap());
-    set_validator_set_keys(set, keys.clone()).await;
+    set_keys(set, keys.clone()).await;
     keys
   };
   assert_eq!(keys.0, pair.public());
 
-  let block = publish_tx(&Serai::execute_batch(SignedBatch {
+  let block = publish_tx(&SeraiInInstructions::execute_batch(SignedBatch {
     batch: batch.clone(),
     signature: pair.sign(&batch_message(&batch)),
   }))
   .await;
 
-  let batches = serai.get_batch_events(block).await.unwrap();
+  let batches = serai.as_of(block).in_instructions().batch_events().await.unwrap();
   // TODO: impl From<Batch> for BatchEvent?
   assert_eq!(
     batches,

substrate/client/tests/common/mod.rs

@@ -60,7 +60,7 @@ macro_rules! serai_test {
             tokio::time::sleep(Duration::from_secs(1)).await;
           }
           let serai = serai().await;
-          while serai.get_latest_block_hash().await.is_err() {
+          while serai.latest_block_hash().await.is_err() {
             tokio::time::sleep(Duration::from_secs(1)).await;
           }
           // TODO: https://github.com/serai-dex/serai/247

substrate/client/tests/common/tx.rs

@@ -11,7 +11,7 @@ pub async fn publish_tx(tx: &Encoded) -> [u8; 32] {
   let serai = serai().await;
 
   let mut latest =
-    serai.get_block(serai.get_latest_block_hash().await.unwrap()).await.unwrap().unwrap().number();
+    serai.block(serai.latest_block_hash().await.unwrap()).await.unwrap().unwrap().number();
 
   serai.publish(tx).await.unwrap();
 
@@ -24,7 +24,7 @@ pub async fn publish_tx(tx: &Encoded) -> [u8; 32] {
     let block = {
       let mut block;
       while {
-        block = serai.get_block_by_number(latest).await.unwrap();
+        block = serai.block_by_number(latest).await.unwrap();
         block.is_none()
       } {
         sleep(Duration::from_secs(1)).await;

substrate/client/tests/common/validator_sets.rs

@@ -15,13 +15,13 @@ use serai_client::{
     primitives::{ValidatorSet, KeyPair, musig_context, musig_key, set_keys_message},
     ValidatorSetsEvent,
   },
-  Serai,
+  SeraiValidatorSets,
 };
 
 use crate::common::{serai, tx::publish_tx};
 
 #[allow(dead_code)]
-pub async fn set_validator_set_keys(set: ValidatorSet, key_pair: KeyPair) -> [u8; 32] {
+pub async fn set_keys(set: ValidatorSet, key_pair: KeyPair) -> [u8; 32] {
   let pair = insecure_pair_from_name("Alice");
   let public = pair.public();
 
@@ -29,7 +29,11 @@ pub async fn set_validator_set_keys(set: ValidatorSet, key_pair: KeyPair) -> [u8
   let public_key = <Ristretto as Ciphersuite>::read_G::<&[u8]>(&mut public.0.as_ref()).unwrap();
   assert_eq!(
     serai
-      .get_validator_set_musig_key(set, serai.get_latest_block_hash().await.unwrap())
+      .with_current_latest_block()
+      .await
+      .unwrap()
+      .validator_sets()
+      .musig_key(set)
       .await
       .unwrap()
       .unwrap(),
@@ -45,7 +49,11 @@ pub async fn set_validator_set_keys(set: ValidatorSet, key_pair: KeyPair) -> [u8
     musig::<Ristretto>(&musig_context(set), &Zeroizing::new(secret_key), &[public_key]).unwrap();
   assert_eq!(
     serai
-      .get_validator_set_musig_key(set, serai.get_latest_block_hash().await.unwrap())
+      .with_current_latest_block()
+      .await
+      .unwrap()
+      .validator_sets()
+      .musig_key(set)
       .await
       .unwrap()
       .unwrap(),
@@ -63,7 +71,7 @@ pub async fn set_validator_set_keys(set: ValidatorSet, key_pair: KeyPair) -> [u8
   );
 
   // Vote in a key pair
-  let block = publish_tx(&Serai::set_validator_set_keys(
+  let block = publish_tx(&SeraiValidatorSets::set_keys(
     set.network,
     key_pair.clone(),
     Signature(sig.to_bytes()),
@@ -71,10 +79,10 @@ pub async fn set_validator_set_keys(set: ValidatorSet, key_pair: KeyPair) -> [u8
   .await;
 
   assert_eq!(
-    serai.get_key_gen_events(block).await.unwrap(),
+    serai.as_of(block).validator_sets().key_gen_events().await.unwrap(),
     vec![ValidatorSetsEvent::KeyGen { set, key_pair: key_pair.clone() }]
   );
-  assert_eq!(serai.get_keys(set, block).await.unwrap(), Some(key_pair));
+  assert_eq!(serai.as_of(block).validator_sets().keys(set).await.unwrap(), Some(key_pair));
 
   block
 }

substrate/client/tests/time.rs

@@ -11,11 +11,11 @@ serai_test!(
   async fn time() {
     let serai = serai().await;
 
-    let mut number = serai.get_latest_block().await.unwrap().number();
+    let mut number = serai.latest_block().await.unwrap().number();
     let mut done = 0;
     while done < 3 {
       // Wait for the next block
-      let block = serai.get_latest_block().await.unwrap();
+      let block = serai.latest_block().await.unwrap();
       if block.number() == number {
         sleep(Duration::from_secs(1)).await;
         continue;

substrate/client/tests/validator_sets.rs

@@ -12,10 +12,10 @@ use serai_client::{
 };
 
 mod common;
-use common::{serai, validator_sets::set_validator_set_keys};
+use common::{serai, validator_sets::set_keys};
 
 serai_test!(
-  async fn set_validator_set_keys_test() {
+  async fn set_keys_test() {
     let network = NetworkId::Bitcoin;
     let set = ValidatorSet { session: Session(0), network };
 
@@ -35,7 +35,9 @@ serai_test!(
     // Make sure the genesis is as expected
     assert_eq!(
       serai
-        .get_new_set_events(serai.get_block_by_number(0).await.unwrap().unwrap().hash())
+        .as_of(serai.block_by_number(0).await.unwrap().unwrap().hash())
+        .validator_sets()
+        .new_set_events()
         .await
         .unwrap(),
       NETWORKS
@@ -47,30 +49,23 @@ serai_test!(
         .collect::<Vec<_>>(),
     );
 
-    let participants = serai
-      .get_validator_set_participants(set.network, serai.get_latest_block_hash().await.unwrap())
-      .await
-      .unwrap()
-      .unwrap();
-    let participants_ref: &[_] = participants.as_ref();
-    assert_eq!(participants_ref, [public].as_ref());
-    assert_eq!(
-      serai
-        .get_validator_set_musig_key(set, serai.get_latest_block_hash().await.unwrap())
-        .await
-        .unwrap()
-        .unwrap(),
-      musig_key(set, &[public]).0
-    );
+    {
+      let vs_serai = serai.with_current_latest_block().await.unwrap().validator_sets();
+      let participants = vs_serai.participants(set.network).await.unwrap().unwrap();
+      let participants_ref: &[_] = participants.as_ref();
+      assert_eq!(participants_ref, [public].as_ref());
+      assert_eq!(vs_serai.musig_key(set).await.unwrap().unwrap(), musig_key(set, &[public]).0);
+    }
 
-    let block = set_validator_set_keys(set, key_pair.clone()).await;
+    let block = set_keys(set, key_pair.clone()).await;
 
-    // While the set_validator_set_keys function should handle this, it's beneficial to
+    // While the set_keys function should handle this, it's beneficial to
     // independently test it
+    let serai = serai.as_of(block).validator_sets();
     assert_eq!(
-      serai.get_key_gen_events(block).await.unwrap(),
+      serai.key_gen_events().await.unwrap(),
       vec![ValidatorSetsEvent::KeyGen { set, key_pair: key_pair.clone() }]
     );
-    assert_eq!(serai.get_keys(set, block).await.unwrap(), Some(key_pair));
+    assert_eq!(serai.keys(set).await.unwrap(), Some(key_pair));
   }
 );