Implement genesis liquidity protocol (#545)

* add genesis liquidity implementation

* add missing deposit event

* fix CI issues

* minor fixes

* make math safer

* fix fmt

* make remove liquidity an authorized call

* implement setting initial values for coins

* add genesis liquidity test & misc fixes

* updato develop latest

* fix rotation test

* Finish merging develop

* Remove accidentally committed ETH files

* fix pr comments

* further bug fixes

* fix last pr comments

* tidy up

* Misc

---------

Co-authored-by: Luke Parker <lukeparker5132@gmail.com>

substrate/client/src/serai/dex.rs

@@ -1,7 +1,9 @@
 use sp_core::bounded_vec::BoundedVec;
 use serai_abi::primitives::{SeraiAddress, Amount, Coin};
 
-use crate::{SeraiError, TemporalSerai};
+use scale::{decode_from_bytes, Encode};
+
+use crate::{Serai, SeraiError, TemporalSerai};
 
 pub type DexEvent = serai_abi::dex::Event;
 
@@ -57,4 +59,20 @@ impl<'a> SeraiDex<'a> {
       send_to: address,
     })
   }
+
+  /// Returns the reserves of `coin:SRI` pool.
+  pub async fn get_reserves(&self, coin: Coin) -> Result<Option<(Amount, Amount)>, SeraiError> {
+    let reserves = self
+      .0
+      .serai
+      .call(
+        "state_call",
+        ["DexApi_get_reserves".to_string(), hex::encode((coin, Coin::Serai).encode())],
+      )
+      .await?;
+    let bytes = Serai::hex_decode(reserves)?;
+    let result = decode_from_bytes::<Option<(u64, u64)>>(bytes.into())
+      .map_err(|e| SeraiError::ErrorInResponse(e.to_string()))?;
+    Ok(result.map(|amounts| (Amount(amounts.0), Amount(amounts.1))))
+  }
 }

substrate/client/src/serai/genesis_liquidity.rs

@@ -0,0 +1,65 @@
+pub use serai_abi::genesis_liquidity::primitives;
+use primitives::{Values, LiquidityAmount};
+
+use serai_abi::primitives::*;
+
+use sp_core::sr25519::Signature;
+
+use scale::Encode;
+
+use crate::{Serai, SeraiError, TemporalSerai, Transaction};
+
+pub type GenesisLiquidityEvent = serai_abi::genesis_liquidity::Event;
+
+const PALLET: &str = "GenesisLiquidity";
+
+#[derive(Clone, Copy)]
+pub struct SeraiGenesisLiquidity<'a>(pub(crate) &'a TemporalSerai<'a>);
+impl<'a> SeraiGenesisLiquidity<'a> {
+  pub async fn events(&self) -> Result<Vec<GenesisLiquidityEvent>, SeraiError> {
+    self
+      .0
+      .events(|event| {
+        if let serai_abi::Event::GenesisLiquidity(event) = event {
+          Some(event.clone())
+        } else {
+          None
+        }
+      })
+      .await
+  }
+
+  pub fn oraclize_values(values: Values, signature: Signature) -> Transaction {
+    Serai::unsigned(serai_abi::Call::GenesisLiquidity(
+      serai_abi::genesis_liquidity::Call::oraclize_values { values, signature },
+    ))
+  }
+
+  pub fn remove_coin_liquidity(balance: Balance) -> serai_abi::Call {
+    serai_abi::Call::GenesisLiquidity(serai_abi::genesis_liquidity::Call::remove_coin_liquidity {
+      balance,
+    })
+  }
+
+  pub async fn liquidity(
+    &self,
+    address: &SeraiAddress,
+    coin: Coin,
+  ) -> Result<LiquidityAmount, SeraiError> {
+    Ok(
+      self
+        .0
+        .storage(
+          PALLET,
+          "Liquidity",
+          (coin, sp_core::hashing::blake2_128(&address.encode()), &address.0),
+        )
+        .await?
+        .unwrap_or(LiquidityAmount::zero()),
+    )
+  }
+
+  pub async fn supply(&self, coin: Coin) -> Result<LiquidityAmount, SeraiError> {
+    Ok(self.0.storage(PALLET, "Supply", coin).await?.unwrap_or(LiquidityAmount::zero()))
+  }
+}

substrate/client/src/serai/liquidity_tokens.rs

@@ -0,0 +1,41 @@
+use scale::Encode;
+
+use serai_abi::primitives::{SeraiAddress, Amount, Coin, Balance};
+
+use crate::{TemporalSerai, SeraiError};
+
+const PALLET: &str = "LiquidityTokens";
+
+#[derive(Clone, Copy)]
+pub struct SeraiLiquidityTokens<'a>(pub(crate) &'a TemporalSerai<'a>);
+impl<'a> SeraiLiquidityTokens<'a> {
+  pub async fn token_supply(&self, coin: Coin) -> Result<Amount, SeraiError> {
+    Ok(self.0.storage(PALLET, "Supply", coin).await?.unwrap_or(Amount(0)))
+  }
+
+  pub async fn token_balance(
+    &self,
+    coin: Coin,
+    address: SeraiAddress,
+  ) -> Result<Amount, SeraiError> {
+    Ok(
+      self
+        .0
+        .storage(
+          PALLET,
+          "Balances",
+          (sp_core::hashing::blake2_128(&address.encode()), &address.0, coin),
+        )
+        .await?
+        .unwrap_or(Amount(0)),
+    )
+  }
+
+  pub fn transfer(to: SeraiAddress, balance: Balance) -> serai_abi::Call {
+    serai_abi::Call::LiquidityTokens(serai_abi::liquidity_tokens::Call::transfer { to, balance })
+  }
+
+  pub fn burn(balance: Balance) -> serai_abi::Call {
+    serai_abi::Call::LiquidityTokens(serai_abi::liquidity_tokens::Call::burn { balance })
+  }
+}

substrate/client/src/serai/mod.rs

@@ -26,6 +26,10 @@ pub mod in_instructions;
 pub use in_instructions::SeraiInInstructions;
 pub mod validator_sets;
 pub use validator_sets::SeraiValidatorSets;
+pub mod genesis_liquidity;
+pub use genesis_liquidity::SeraiGenesisLiquidity;
+pub mod liquidity_tokens;
+pub use liquidity_tokens::SeraiLiquidityTokens;
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode)]
 pub struct Block {
@@ -194,6 +198,7 @@ impl Serai {
     Ok(())
   }
 
+  // TODO: move this into substrate/client/src/validator_sets.rs
   async fn active_network_validators(&self, network: NetworkId) -> Result<Vec<Public>, SeraiError> {
     let validators: String = self
       .call("state_call", ["SeraiRuntimeApi_validators".to_string(), hex::encode(network.encode())])
@@ -388,4 +393,12 @@ impl<'a> TemporalSerai<'a> {
   pub fn validator_sets(&'a self) -> SeraiValidatorSets<'a> {
     SeraiValidatorSets(self)
   }
+
+  pub fn genesis_liquidity(&'a self) -> SeraiGenesisLiquidity {
+    SeraiGenesisLiquidity(self)
+  }
+
+  pub fn liquidity_tokens(&'a self) -> SeraiLiquidityTokens {
+    SeraiLiquidityTokens(self)
+  }
 }

substrate/client/tests/common/mod.rs

@@ -66,3 +66,67 @@ macro_rules! serai_test {
     )*
   }
 }
+
+#[macro_export]
+macro_rules! serai_test_fast_epoch {
+  ($($name: ident: $test: expr)*) => {
+    $(
+      #[tokio::test]
+      async fn $name() {
+        use std::collections::HashMap;
+        use dockertest::{
+          PullPolicy, StartPolicy, LogOptions, LogAction, LogPolicy, LogSource, Image,
+          TestBodySpecification, DockerTest,
+        };
+
+        serai_docker_tests::build("serai-fast-epoch".to_string());
+
+        let handle = concat!("serai_client-serai_node-", stringify!($name));
+
+        let composition = TestBodySpecification::with_image(
+          Image::with_repository("serai-dev-serai-fast-epoch").pull_policy(PullPolicy::Never),
+        )
+        .replace_cmd(vec![
+          "serai-node".to_string(),
+          "--dev".to_string(),
+          "--unsafe-rpc-external".to_string(),
+          "--rpc-cors".to_string(),
+          "all".to_string(),
+        ])
+        .replace_env(
+          HashMap::from([
+            ("RUST_LOG".to_string(), "runtime=debug".to_string()),
+            ("KEY".to_string(), " ".to_string()),
+          ])
+        )
+        .set_publish_all_ports(true)
+        .set_handle(handle)
+        .set_start_policy(StartPolicy::Strict)
+        .set_log_options(Some(LogOptions {
+          action: LogAction::Forward,
+          policy: LogPolicy::Always,
+          source: LogSource::Both,
+        }));
+
+        let mut test = DockerTest::new().with_network(dockertest::Network::Isolated);
+        test.provide_container(composition);
+        test.run_async(|ops| async move {
+          // Sleep until the Substrate RPC starts
+          let serai_rpc = ops.handle(handle).host_port(9944).unwrap();
+          let serai_rpc = format!("http://{}:{}", serai_rpc.0, serai_rpc.1);
+          // Bound execution to 60 seconds
+          for _ in 0 .. 60 {
+            tokio::time::sleep(core::time::Duration::from_secs(1)).await;
+            let Ok(client) = Serai::new(serai_rpc.clone()).await else { continue };
+            if client.latest_finalized_block_hash().await.is_err() {
+              continue;
+            }
+            break;
+          }
+          #[allow(clippy::redundant_closure_call)]
+          $test(Serai::new(serai_rpc).await.unwrap()).await;
+        }).await;
+      }
+    )*
+  }
+}

substrate/client/tests/genesis_liquidity.rs

@@ -0,0 +1,216 @@
+use std::{time::Duration, collections::HashMap};
+
+use rand_core::{RngCore, OsRng};
+use zeroize::Zeroizing;
+
+use ciphersuite::{Ciphersuite, Ristretto};
+use frost::dkg::musig::musig;
+use schnorrkel::Schnorrkel;
+
+use serai_client::{
+  genesis_liquidity::{
+    primitives::{GENESIS_LIQUIDITY_ACCOUNT, INITIAL_GENESIS_LP_SHARES},
+    SeraiGenesisLiquidity,
+  },
+  validator_sets::primitives::{musig_context, Session, ValidatorSet},
+};
+
+use serai_abi::{
+  genesis_liquidity::primitives::{oraclize_values_message, Values},
+  primitives::COINS,
+};
+
+use sp_core::{sr25519::Signature, Pair as PairTrait};
+
+use serai_client::{
+  primitives::{
+    Amount, NetworkId, Coin, Balance, BlockHash, SeraiAddress, insecure_pair_from_name, GENESIS_SRI,
+  },
+  in_instructions::primitives::{InInstruction, InInstructionWithBalance, Batch},
+  Serai,
+};
+
+mod common;
+use common::{in_instructions::provide_batch, tx::publish_tx};
+
+serai_test_fast_epoch!(
+  genesis_liquidity: (|serai: Serai| async move {
+    test_genesis_liquidity(serai).await;
+  })
+);
+
+async fn test_genesis_liquidity(serai: Serai) {
+  // all coins except the native
+  let coins = COINS.into_iter().filter(|c| *c != Coin::native()).collect::<Vec<_>>();
+
+  // make accounts with amounts
+  let mut accounts = HashMap::new();
+  for coin in coins.clone() {
+    // make 5 accounts per coin
+    let mut values = vec![];
+    for _ in 0 .. 5 {
+      let mut address = SeraiAddress::new([0; 32]);
+      OsRng.fill_bytes(&mut address.0);
+      values.push((address, Amount(OsRng.next_u64() % 10u64.pow(coin.decimals()))));
+    }
+    accounts.insert(coin, values);
+  }
+
+  // send a batch per coin
+  let mut batch_ids: HashMap<NetworkId, u32> = HashMap::new();
+  for coin in coins.clone() {
+    // set up instructions
+    let instructions = accounts[&coin]
+      .iter()
+      .map(|(addr, amount)| InInstructionWithBalance {
+        instruction: InInstruction::GenesisLiquidity(*addr),
+        balance: Balance { coin, amount: *amount },
+      })
+      .collect::<Vec<_>>();
+
+    // set up bloch hash
+    let mut block = BlockHash([0; 32]);
+    OsRng.fill_bytes(&mut block.0);
+
+    // set up batch id
+    batch_ids
+      .entry(coin.network())
+      .and_modify(|v| {
+        *v += 1;
+      })
+      .or_insert(0);
+
+    let batch =
+      Batch { network: coin.network(), id: batch_ids[&coin.network()], block, instructions };
+    provide_batch(&serai, batch).await;
+  }
+
+  // wait until genesis ends
+  let genesis_blocks = 10; // TODO
+  let block_time = 6; // TODO
+  tokio::time::timeout(
+    tokio::time::Duration::from_secs(3 * (genesis_blocks * block_time)),
+    async {
+      while serai.latest_finalized_block().await.unwrap().number() < 10 {
+        tokio::time::sleep(Duration::from_secs(6)).await;
+      }
+    },
+  )
+  .await
+  .unwrap();
+
+  // set values relative to each other
+  // TODO: Random values here
+  let values = Values { monero: 184100, ether: 4785000, dai: 1500 };
+  set_values(&serai, &values).await;
+  let values_map = HashMap::from([
+    (Coin::Monero, values.monero),
+    (Coin::Ether, values.ether),
+    (Coin::Dai, values.dai),
+  ]);
+
+  // wait a little bit..
+  tokio::time::sleep(Duration::from_secs(12)).await;
+
+  // check total SRI supply is +100M
+  // there are 6 endowed accounts in dev-net. Take this into consideration when checking
+  // for the total sri minted at this time.
+  let serai = serai.as_of_latest_finalized_block().await.unwrap();
+  let sri = serai.coins().coin_supply(Coin::Serai).await.unwrap();
+  let endowed_amount: u64 = 1 << 60;
+  let total_sri = (6 * endowed_amount) + GENESIS_SRI;
+  assert_eq!(sri, Amount(total_sri));
+
+  // check genesis account has no coins, all transferred to pools.
+  for coin in COINS {
+    let amount = serai.coins().coin_balance(coin, GENESIS_LIQUIDITY_ACCOUNT).await.unwrap();
+    assert_eq!(amount.0, 0);
+  }
+
+  // check pools has proper liquidity
+  let mut pool_amounts = HashMap::new();
+  let mut total_value = 0u128;
+  for coin in coins.clone() {
+    let total_coin = accounts[&coin].iter().fold(0u128, |acc, value| acc + u128::from(value.1 .0));
+    let value = if coin != Coin::Bitcoin {
+      (total_coin * u128::from(values_map[&coin])) / 10u128.pow(coin.decimals())
+    } else {
+      total_coin
+    };
+
+    total_value += value;
+    pool_amounts.insert(coin, (total_coin, value));
+  }
+
+  // check distributed SRI per pool
+  let mut total_sri_distributed = 0u128;
+  for coin in coins.clone() {
+    let sri = if coin == *COINS.last().unwrap() {
+      u128::from(GENESIS_SRI).checked_sub(total_sri_distributed).unwrap()
+    } else {
+      (pool_amounts[&coin].1 * u128::from(GENESIS_SRI)) / total_value
+    };
+    total_sri_distributed += sri;
+
+    let reserves = serai.dex().get_reserves(coin).await.unwrap().unwrap();
+    assert_eq!(u128::from(reserves.0 .0), pool_amounts[&coin].0); // coin side
+    assert_eq!(u128::from(reserves.1 .0), sri); // SRI side
+  }
+
+  // check each liquidity provider got liquidity tokens proportional to their value
+  for coin in coins {
+    let liq_supply = serai.genesis_liquidity().supply(coin).await.unwrap();
+    for (acc, amount) in &accounts[&coin] {
+      let acc_liq_shares = serai.genesis_liquidity().liquidity(acc, coin).await.unwrap().shares;
+
+      // since we can't test the ratios directly(due to integer division giving 0)
+      // we test whether they give the same result when multiplied by another constant.
+      // Following test ensures the account in fact has the right amount of shares.
+      let mut shares_ratio = (INITIAL_GENESIS_LP_SHARES * acc_liq_shares) / liq_supply.shares;
+      let amounts_ratio =
+        (INITIAL_GENESIS_LP_SHARES * amount.0) / u64::try_from(pool_amounts[&coin].0).unwrap();
+
+      // we can tolerate 1 unit diff between them due to integer division.
+      if shares_ratio.abs_diff(amounts_ratio) == 1 {
+        shares_ratio = amounts_ratio;
+      }
+
+      assert_eq!(shares_ratio, amounts_ratio);
+    }
+  }
+
+  // TODO: test remove the liq before/after genesis ended.
+}
+
+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();
+  // we publish the tx in set 4
+  let set = ValidatorSet { session: Session(4), 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),
+  );
+
+  // oraclize values
+  let _ =
+    publish_tx(serai, &SeraiGenesisLiquidity::oraclize_values(*values, Signature(sig.to_bytes())))
+      .await;
+}