prevent stake allocation during genesis period

substrate/client/tests/batch.rs

@@ -7,6 +7,7 @@ use blake2::{
 
 use scale::Encode;
 
+use serai_abi::primitives::insecure_pair_from_name;
 use serai_client::{
  primitives::{Amount, NetworkId, Coin, Balance, BlockHash, SeraiAddress},
  in_instructions::{
@@ -45,7 +46,7 @@ serai_test!(
  }],
  };
 
- let block = provide_batch(&serai, batch.clone()).await;
+ let block = provide_batch(&serai, &[insecure_pair_from_name("Alice")], batch.clone()).await;
 
  let serai = serai.as_of(block);
  {

substrate/client/tests/burn.rs

@@ -52,7 +52,7 @@ serai_test!(
  }],
  };
 
- let block = provide_batch(&serai, batch.clone()).await;
+ let block = provide_batch(&serai, &[insecure_pair_from_name("Alice")], batch.clone()).await;
 
  let instruction = {
  let serai = serai.as_of(block);

substrate/client/tests/common/genesis_liquidity.rs

@@ -1,31 +1,29 @@
 use std::collections::HashMap;
 
 use rand_core::{RngCore, OsRng};
-use zeroize::Zeroizing;
 
-use ciphersuite::{Ciphersuite, Ristretto};
-use frost::dkg::musig::musig;
-use schnorrkel::Schnorrkel;
-
-use sp_core::{sr25519::Signature, Pair as PairTrait};
+use sp_core::sr25519::Pair;
 
 use serai_abi::{
  genesis_liquidity::primitives::{oraclize_values_message, Values},
- validator_sets::primitives::{musig_context, Session, ValidatorSet},
+ validator_sets::primitives::{Session, ValidatorSet},
  in_instructions::primitives::{InInstruction, InInstructionWithBalance, Batch},
- primitives::{
- Amount, NetworkId, Coin, Balance, BlockHash, SeraiAddress, insecure_pair_from_name,
- },
+ primitives::{Amount, NetworkId, Coin, Balance, BlockHash, SeraiAddress},
 };
 
 use serai_client::{Serai, SeraiGenesisLiquidity};
 
-use crate::common::{in_instructions::provide_batch, tx::publish_tx};
+use crate::common::{
+ in_instructions::provide_batch,
+ tx::{get_musig_of_pairs, publish_tx},
+ validator_sets::get_ordered_keys,
+};
 
 #[allow(dead_code)]
 pub async fn set_up_genesis(
  serai: &Serai,
  coins: &[Coin],
+ pairs: &[Pair],
  values: &HashMap<Coin, u64>,
 ) -> (HashMap<Coin, Vec<(SeraiAddress, Amount)>>, HashMap<NetworkId, u32>) {
  // make accounts with amounts
@@ -67,49 +65,27 @@ pub async fn set_up_genesis(
 
  let batch =
  Batch { network: coin.network(), id: batch_ids[&coin.network()], block, instructions };
- provide_batch(serai, batch).await;
+ provide_batch(serai, &get_ordered_keys(serai, coin.network(), pairs).await, batch).await;
  }
 
  // set values relative to each other. We can do that without checking for genesis period blocks
  // since we are running in test(fast-epoch) mode.
  // TODO: Random values here
  let values =
  Values { monero: values[&Coin::Monero], ether: values[&Coin::Ether], dai: values[&Coin::Dai] };
- set_values(serai, &values).await;
+ set_values(serai, &get_ordered_keys(serai, NetworkId::Serai, pairs).await, &values).await;
 
  (accounts, batch_ids)
 }
 
 #[allow(dead_code)]
-async fn set_values(serai: &Serai, values: &Values) {
- // prepare a Musig tx to oraclize the relative values
- let pair = insecure_pair_from_name("Alice");
- let public = pair.public();
+pub async fn set_values(serai: &Serai, pairs: &[Pair], values: &Values) {
  // we publish the tx in set 1
  let set = ValidatorSet { session: Session(1), network: NetworkId::Serai };
 
- let public_key = <Ristretto as Ciphersuite>::read_G::<&[u8]>(&mut public.0.as_ref()).unwrap();
- let secret_key = <Ristretto as Ciphersuite>::read_F::<&[u8]>(
- &mut pair.as_ref().secret.to_bytes()[.. 32].as_ref(),
- )
- .unwrap();
-
- assert_eq!(Ristretto::generator() * secret_key, public_key);
- let threshold_keys =
- musig::<Ristretto>(&musig_context(set), &Zeroizing::new(secret_key), &[public_key]).unwrap();
-
- let sig = frost::tests::sign_without_caching(
- &mut OsRng,
- frost::tests::algorithm_machines(
- &mut OsRng,
- &Schnorrkel::new(b"substrate"),
- &HashMap::from([(threshold_keys.params().i(), threshold_keys.into())]),
- ),
- &oraclize_values_message(&set, values),
- );
+ // prepare a Musig tx to oraclize the relative values
+ let sig = get_musig_of_pairs(pairs, set, &oraclize_values_message(&set, values));
 
  // oraclize values
- let _ =
- publish_tx(serai, &SeraiGenesisLiquidity::oraclize_values(*values, Signature(sig.to_bytes())))
- .await;
+ let _ = publish_tx(serai, &SeraiGenesisLiquidity::oraclize_values(*values, sig)).await;
 }

substrate/client/tests/common/in_instructions.rs

@@ -6,7 +6,7 @@ use blake2::{
 
 use scale::Encode;
 
-use sp_core::Pair;
+use sp_core::{sr25519::Pair, Pair as PairTrait};
 
 use serai_client::{
  primitives::{insecure_pair_from_name, BlockHash, NetworkId, Balance, SeraiAddress},
@@ -21,7 +21,7 @@ use serai_client::{
 use crate::common::{tx::publish_tx, validator_sets::set_keys};
 
 #[allow(dead_code)]
-pub async fn provide_batch(serai: &Serai, batch: Batch) -> [u8; 32] {
+pub async fn provide_batch(serai: &Serai, pairs: &[Pair], batch: Batch) -> [u8; 32] {
  let serai_latest = serai.as_of_latest_finalized_block().await.unwrap();
  let session = serai_latest.validator_sets().session(batch.network).await.unwrap().unwrap();
  let set = ValidatorSet { session, network: batch.network };
@@ -31,7 +31,7 @@ pub async fn provide_batch(serai: &Serai, batch: Batch) -> [u8; 32] {
  keys
  } else {
  let keys = KeyPair(pair.public(), vec![].try_into().unwrap());
- set_keys(serai, set, keys.clone(), &[insecure_pair_from_name("Alice")]).await;
+ set_keys(serai, set, keys.clone(), pairs).await;
  keys
  };
  assert_eq!(keys.0, pair.public());
@@ -83,5 +83,5 @@ pub async fn mint_coin(
  }],
  };
 
- provide_batch(serai, batch).await
+ provide_batch(serai, &[insecure_pair_from_name("Alice")], batch).await
 }

substrate/client/tests/common/tx.rs

@@ -1,9 +1,24 @@
+use std::collections::HashMap;
+
 use core::time::Duration;
 
+use rand_core::OsRng;
+use zeroize::Zeroizing;
+use serai_abi::validator_sets::primitives::{musig_context, ValidatorSet};
+
 use tokio::time::sleep;
 
 use serai_client::{Transaction, Serai};
 
+use sp_core::{
+ sr25519::{Pair, Signature},
+ Pair as PairTrait,
+};
+
+use ciphersuite::{Ciphersuite, Ristretto};
+use frost::dkg::musig::musig;
+use schnorrkel::Schnorrkel;
+
 #[allow(dead_code)]
 pub async fn publish_tx(serai: &Serai, tx: &Transaction) -> [u8; 32] {
  let mut latest = serai
@@ -13,7 +28,12 @@ pub async fn publish_tx(serai: &Serai, tx: &Transaction) -> [u8; 32] {
  .unwrap()
  .number();
 
- serai.publish(tx).await.unwrap();
+ let r = serai.publish(tx).await;
+ if r.is_err() {
+ // put some delay before panic so that prints on the node side is flushed
+ tokio::time::sleep(Duration::from_secs(3)).await;
+ r.unwrap();
+ }
 
  // Get the block it was included in
  // TODO: Add an RPC method for this/check the guarantee on the subscription
@@ -44,3 +64,39 @@ pub async fn publish_tx(serai: &Serai, tx: &Transaction) -> [u8; 32] {
  }
  }
 }
+
+#[allow(dead_code)]
+pub fn get_musig_of_pairs(pairs: &[Pair], set: ValidatorSet, msg: &[u8]) -> Signature {
+ let mut pub_keys = vec![];
+ for pair in pairs {
+ let public_key =
+ <Ristretto as Ciphersuite>::read_G::<&[u8]>(&mut pair.public().0.as_ref()).unwrap();
+ pub_keys.push(public_key);
+ }
+
+ let mut threshold_keys = vec![];
+ for i in 0 .. pairs.len() {
+ let secret_key = <Ristretto as Ciphersuite>::read_F::<&[u8]>(
+ &mut pairs[i].as_ref().secret.to_bytes()[.. 32].as_ref(),
+ )
+ .unwrap();
+ assert_eq!(Ristretto::generator() * secret_key, pub_keys[i]);
+
+ threshold_keys.push(
+ musig::<Ristretto>(&musig_context(set), &Zeroizing::new(secret_key), &pub_keys).unwrap(),
+ );
+ }
+
+ let mut musig_keys = HashMap::new();
+ for tk in threshold_keys {
+ musig_keys.insert(tk.params().i(), tk.into());
+ }
+
+ let sig = frost::tests::sign_without_caching(
+ &mut OsRng,
+ frost::tests::algorithm_machines(&mut OsRng, &Schnorrkel::new(b"substrate"), &musig_keys),
+ &msg,
+ );
+
+ Signature(sig.to_bytes())
+}

substrate/client/tests/common/validator_sets.rs

@@ -1,27 +1,16 @@
-use std::collections::HashMap;
-
 use serai_abi::primitives::NetworkId;
-use zeroize::Zeroizing;
-use rand_core::OsRng;
-
-use sp_core::{
- sr25519::{Pair, Signature},
- Pair as PairTrait,
-};
 
-use ciphersuite::{Ciphersuite, Ristretto};
-use frost::dkg::musig::musig;
-use schnorrkel::Schnorrkel;
+use sp_core::{sr25519::Pair, Pair as PairTrait};
 
 use serai_client::{
  validator_sets::{
- primitives::{ValidatorSet, KeyPair, musig_context, set_keys_message},
+ primitives::{ValidatorSet, KeyPair, set_keys_message},
  ValidatorSetsEvent,
  },
  Amount, Serai, SeraiValidatorSets,
 };
 
-use crate::common::tx::publish_tx;
+use crate::common::tx::{publish_tx, get_musig_of_pairs};
 
 #[allow(dead_code)]
 pub async fn set_keys(
@@ -30,46 +19,12 @@ pub async fn set_keys(
  key_pair: KeyPair,
  pairs: &[Pair],
 ) -> [u8; 32] {
- let mut pub_keys = vec![];
- for pair in pairs {
- let public_key =
- <Ristretto as Ciphersuite>::read_G::<&[u8]>(&mut pair.public().0.as_ref()).unwrap();
- pub_keys.push(public_key);
- }
-
- let mut threshold_keys = vec![];
- for i in 0 .. pairs.len() {
- let secret_key = <Ristretto as Ciphersuite>::read_F::<&[u8]>(
- &mut pairs[i].as_ref().secret.to_bytes()[.. 32].as_ref(),
- )
- .unwrap();
- assert_eq!(Ristretto::generator() * secret_key, pub_keys[i]);
-
- threshold_keys.push(
- musig::<Ristretto>(&musig_context(set), &Zeroizing::new(secret_key), &pub_keys).unwrap(),
- );
- }
-
- let mut musig_keys = HashMap::new();
- for tk in threshold_keys {
- musig_keys.insert(tk.params().i(), tk.into());
- }
-
- let sig = frost::tests::sign_without_caching(
- &mut OsRng,
- frost::tests::algorithm_machines(&mut OsRng, &Schnorrkel::new(b"substrate"), &musig_keys),
- &set_keys_message(&set, &[], &key_pair),
- );
+ let sig = get_musig_of_pairs(pairs, set, &set_keys_message(&set, &[], &key_pair));
 
  // Set the key pair
  let block = publish_tx(
  serai,
- &SeraiValidatorSets::set_keys(
- set.network,
- vec![].try_into().unwrap(),
- key_pair.clone(),
- Signature(sig.to_bytes()),
- ),
+ &SeraiValidatorSets::set_keys(set.network, vec![].try_into().unwrap(), key_pair.clone(), sig),
  )
  .await;
 
@@ -82,6 +37,29 @@ pub async fn set_keys(
  block
 }
 
+#[allow(dead_code)]
+pub async fn get_ordered_keys(serai: &Serai, network: NetworkId, accounts: &[Pair]) -> Vec<Pair> {
+ // retrieve the current session validators so that we know the order of the keys
+ // that is necessary for the correct musig signature.
+ let validators = serai
+ .as_of_latest_finalized_block()
+ .await
+ .unwrap()
+ .validator_sets()
+ .active_network_validators(network)
+ .await
+ .unwrap();
+
+ // collect the pairs of the validators
+ let mut pairs = vec![];
+ for v in validators {
+ let p = accounts.iter().find(|pair| pair.public() == v).unwrap().clone();
+ pairs.push(p);
+ }
+
+ pairs
+}
+
 #[allow(dead_code)]
 pub async fn allocate_stake(
  serai: &Serai,

substrate/client/tests/dex.rs

@@ -236,7 +236,7 @@ serai_test!(
  }],
  };
 
- let block = provide_batch(&serai, batch).await;
+ let block = provide_batch(&serai, &[insecure_pair_from_name("Alice")], batch).await;
  let mut events = serai.as_of(block).dex().events().await.unwrap();
  events.retain(|e| matches!(e, DexEvent::LiquidityAdded { .. }));
  assert_eq!(
@@ -299,6 +299,8 @@ serai_test!(
  let mut rand_bytes = vec![0; 32];
  OsRng.fill_bytes(&mut rand_bytes);
 
+ let pairs = [insecure_pair_from_name("Alice")];
+
  // XMR -> ETH
  {
  // make an out address
@@ -320,7 +322,7 @@ serai_test!(
  }],
  };
 
- let block = provide_batch(&serai, batch).await;
+ let block = provide_batch(&serai, &pairs, batch).await;
  coin1_batch_id += 1;
  let mut events = serai.as_of(block).dex().events().await.unwrap();
  events.retain(|e| matches!(e, DexEvent::SwapExecuted { .. }));
@@ -360,7 +362,7 @@ serai_test!(
  }],
  };
 
- let block = provide_batch(&serai, batch).await;
+ let block = provide_batch(&serai, &pairs, batch).await;
  let mut events = serai.as_of(block).dex().events().await.unwrap();
  events.retain(|e| matches!(e, DexEvent::SwapExecuted { .. }));
 
@@ -398,7 +400,7 @@ serai_test!(
  }],
  };
 
- let block = provide_batch(&serai, batch).await;
+ let block = provide_batch(&serai, &pairs, batch).await;
  let mut events = serai.as_of(block).dex().events().await.unwrap();
  events.retain(|e| matches!(e, DexEvent::SwapExecuted { .. }));