Move substrate/serai/* to substrate/*

substrate/client/tests/batch.rs

@@ -0,0 +1,54 @@
+use rand_core::{RngCore, OsRng};
+
+use serai_client::{
+  primitives::{BITCOIN_NET_ID, BITCOIN, BlockHash, SeraiAddress, Amount, Balance},
+  in_instructions::{
+    primitives::{InInstruction, InInstructionWithBalance, Batch},
+    InInstructionsEvent,
+  },
+  tokens::TokensEvent,
+  Serai,
+};
+
+mod common;
+use common::{serai, in_instructions::provide_batch};
+
+serai_test!(
+  async fn publish_batch() {
+    let network = BITCOIN_NET_ID;
+    let id = 0;
+
+    let mut block_hash = BlockHash([0; 32]);
+    OsRng.fill_bytes(&mut block_hash.0);
+
+    let mut address = SeraiAddress::new([0; 32]);
+    OsRng.fill_bytes(&mut address.0);
+
+    let coin = BITCOIN;
+    let amount = Amount(OsRng.next_u64().saturating_add(1));
+    let balance = Balance { coin, amount };
+
+    let batch = Batch {
+      network,
+      id,
+      block: block_hash,
+      instructions: vec![InInstructionWithBalance {
+        instruction: InInstruction::Transfer(address),
+        balance,
+      }],
+    };
+
+    let block = provide_batch(batch).await;
+
+    let serai = serai().await;
+    let batches = serai.get_batch_events(block).await.unwrap();
+    assert_eq!(batches, vec![InInstructionsEvent::Batch { network, id, block: block_hash }]);
+
+    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);
+  }
+);

substrate/client/tests/burn.rs

@@ -0,0 +1,88 @@
+use rand_core::{RngCore, OsRng};
+
+use sp_core::Pair;
+
+use serai_client::{
+  subxt::config::extrinsic_params::BaseExtrinsicParamsBuilder,
+  primitives::{
+    BITCOIN_NET_ID, BITCOIN, BlockHash, SeraiAddress, Amount, Balance, Data, ExternalAddress,
+    insecure_pair_from_name,
+  },
+  in_instructions::{
+    InInstructionsEvent,
+    primitives::{InInstruction, InInstructionWithBalance, Batch},
+  },
+  tokens::{primitives::OutInstruction, TokensEvent},
+  PairSigner, Serai,
+};
+
+mod common;
+use common::{serai, tx::publish_tx, in_instructions::provide_batch};
+
+serai_test!(
+  async fn burn() {
+    let network = BITCOIN_NET_ID;
+    let id = 0;
+
+    let mut block_hash = BlockHash([0; 32]);
+    OsRng.fill_bytes(&mut block_hash.0);
+
+    let pair = insecure_pair_from_name("Dave");
+    let public = pair.public();
+    let address = SeraiAddress::from(public);
+
+    let coin = BITCOIN;
+    let amount = Amount(OsRng.next_u64().saturating_add(1));
+    let balance = Balance { coin, amount };
+
+    let batch = Batch {
+      network,
+      id,
+      block: block_hash,
+      instructions: vec![InInstructionWithBalance {
+        instruction: InInstruction::Transfer(address),
+        balance,
+      }],
+    };
+
+    let block = provide_batch(batch).await;
+
+    let serai = serai().await;
+    let batches = serai.get_batch_events(block).await.unwrap();
+    assert_eq!(batches, vec![InInstructionsEvent::Batch { network, id, block: block_hash }]);
+
+    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);
+
+    // Now burn it
+    let mut rand_bytes = vec![0; 32];
+    OsRng.fill_bytes(&mut rand_bytes);
+    let external_address = ExternalAddress::new(rand_bytes).unwrap();
+
+    let mut rand_bytes = vec![0; 32];
+    OsRng.fill_bytes(&mut rand_bytes);
+    let data = Data::new(rand_bytes).unwrap();
+
+    let out = OutInstruction { address: external_address, data: Some(data) };
+    let block = publish_tx(
+      &serai
+        .sign(
+          &PairSigner::new(pair),
+          &Serai::burn(balance, out.clone()),
+          0,
+          BaseExtrinsicParamsBuilder::new(),
+        )
+        .unwrap(),
+    )
+    .await;
+
+    let events = serai.get_burn_events(block).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));
+  }
+);

substrate/client/tests/common/in_instructions.rs

@@ -0,0 +1,49 @@
+use scale::Encode;
+
+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: Batch) -> [u8; 32] {
+  let serai = serai().await;
+
+  // TODO: Get the latest session
+  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 { network: batch.network, id: batch.id, block: batch.block }],
+  );
+
+  // TODO: Check the tokens events
+
+  block
+}

substrate/client/tests/common/mod.rs

@@ -0,0 +1,82 @@
+use lazy_static::lazy_static;
+
+use tokio::sync::Mutex;
+
+use serai_client::Serai;
+
+pub mod tx;
+pub mod validator_sets;
+pub mod in_instructions;
+
+pub const URL: &str = "ws://127.0.0.1:9944";
+
+pub async fn serai() -> Serai {
+  Serai::new(URL).await.unwrap()
+}
+
+lazy_static! {
+  pub static ref SEQUENTIAL: Mutex<()> = Mutex::new(());
+}
+
+#[macro_export]
+macro_rules! serai_test {
+  ($(async fn $name: ident() $body: block)*) => {
+    $(
+      #[tokio::test]
+      async fn $name() {
+        use std::process::Command;
+
+        let guard = common::SEQUENTIAL.lock().await;
+
+        let is_running = || {
+          !Command::new("pidof").arg("serai-node").output().unwrap().stdout.is_empty()
+        };
+
+        // Spawn a fresh Serai node
+        let mut command = {
+          use core::time::Duration;
+          use std::path::Path;
+
+          // Make sure a node isn't already running
+          assert!(!is_running());
+
+          let node = {
+            let this_crate = Path::new(env!("CARGO_MANIFEST_DIR"));
+            let top_level = this_crate.join("../../../");
+            top_level.join("target/debug/serai-node")
+          };
+
+          let command = Command::new(node).arg("--dev").spawn().unwrap();
+          while Serai::new(common::URL).await.is_err() {
+            tokio::time::sleep(Duration::from_secs(1)).await;
+          }
+          let serai = serai().await;
+          while serai.get_latest_block_hash().await.is_err() {
+            tokio::time::sleep(Duration::from_secs(1)).await;
+          }
+          // TODO: https://github.com/serai-dex/serai/247
+          if std::env::var("GITHUB_CI") == Ok("true".to_string()) {
+            tokio::time::sleep(Duration::from_secs(60)).await;
+          }
+
+          // Sanity check the pidof command is well-formed
+          assert!(is_running());
+
+          command
+        };
+
+        let local = tokio::task::LocalSet::new();
+        local.run_until(async move {
+          if let Err(err) = tokio::task::spawn_local(async move { $body }).await {
+            drop(guard);
+            let _ = command.kill();
+            Err(err).unwrap()
+          } else {
+            command.kill().unwrap();
+          }
+          assert!(!is_running());
+        }).await;
+      }
+    )*
+  }
+}

substrate/client/tests/common/tx.rs

@@ -0,0 +1,51 @@
+use core::time::Duration;
+
+use tokio::time::sleep;
+
+use serai_client::subxt::{config::Header, utils::Encoded};
+
+use crate::common::serai;
+
+#[allow(dead_code)]
+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()
+    .header
+    .number();
+
+  serai.publish(tx).await.unwrap();
+
+  // Get the block it was included in
+  // TODO: Add an RPC method for this/check the guarantee on the subscription
+  let mut ticks = 0;
+  loop {
+    latest += 1;
+
+    let block = {
+      let mut block;
+      while {
+        block = serai.get_block_by_number(latest).await.unwrap();
+        block.is_none()
+      } {
+        sleep(Duration::from_secs(1)).await;
+        ticks += 1;
+
+        if ticks > 60 {
+          panic!("60 seconds without inclusion in a finalized block");
+        }
+      }
+      block.unwrap()
+    };
+
+    for extrinsic in block.extrinsics {
+      if extrinsic.0 == tx.0[2 ..] {
+        return block.header.hash().into();
+      }
+    }
+  }
+}

substrate/client/tests/common/validator_sets.rs

@@ -0,0 +1,47 @@
+use sp_core::Pair;
+
+use serai_client::{
+  subxt::config::extrinsic_params::BaseExtrinsicParamsBuilder,
+  primitives::{SeraiAddress, insecure_pair_from_name},
+  validator_sets::{
+    primitives::{ValidatorSet, KeyPair},
+    ValidatorSetsEvent,
+  },
+  PairSigner, Serai,
+};
+
+use crate::common::{serai, tx::publish_tx};
+
+#[allow(dead_code)]
+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()),
+        serai.get_nonce(&address).await.unwrap(),
+        BaseExtrinsicParamsBuilder::new(),
+      )
+      .unwrap(),
+  )
+  .await;
+
+  assert_eq!(
+    serai.get_vote_events(block).await.unwrap(),
+    vec![ValidatorSetsEvent::Vote { voter: public, set, key_pair: key_pair.clone(), votes: 1 }]
+  );
+  assert_eq!(
+    serai.get_key_gen_events(block).await.unwrap(),
+    vec![ValidatorSetsEvent::KeyGen { set, key_pair: key_pair.clone() }]
+  );
+  assert_eq!(serai.get_keys(set).await.unwrap(), Some(key_pair));
+
+  block
+}

substrate/client/tests/validator_sets.rs

@@ -0,0 +1,54 @@
+use rand_core::{RngCore, OsRng};
+
+use sp_core::{sr25519::Public, Pair};
+
+use serai_client::{
+  primitives::{BITCOIN_NET_ID, BITCOIN_NET, insecure_pair_from_name},
+  validator_sets::{
+    primitives::{Session, ValidatorSet},
+    ValidatorSetsEvent,
+  },
+  Serai,
+};
+
+mod common;
+use common::{serai, validator_sets::vote_in_keys};
+
+serai_test!(
+  async fn vote_keys() {
+    let network = BITCOIN_NET_ID;
+    let set = ValidatorSet { session: Session(0), network };
+
+    let public = insecure_pair_from_name("Alice").public();
+
+    // Neither of these keys are validated
+    // The external key is infeasible to validate on-chain, the Ristretto key is feasible
+    // TODO: Should the Ristretto key be validated?
+    let mut ristretto_key = [0; 32];
+    OsRng.fill_bytes(&mut ristretto_key);
+    let mut external_key = vec![0; 33];
+    OsRng.fill_bytes(&mut external_key);
+    let key_pair = (Public(ristretto_key), external_key.try_into().unwrap());
+
+    let serai = serai().await;
+
+    // Make sure the genesis is as expected
+    let set_data = serai.get_validator_set(set).await.unwrap().unwrap();
+    assert_eq!(set_data.network, *BITCOIN_NET);
+    let participants_ref: &[_] = set_data.participants.as_ref();
+    assert_eq!(participants_ref, [(public, set_data.bond)].as_ref());
+
+    let block = vote_in_keys(set, key_pair.clone()).await;
+
+    // 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 }]
+    );
+    assert_eq!(
+      serai.get_key_gen_events(block).await.unwrap(),
+      vec![ValidatorSetsEvent::KeyGen { set, key_pair: key_pair.clone() }]
+    );
+    assert_eq!(serai.get_keys(set).await.unwrap(), Some(key_pair));
+  }
+);