diff --git a/substrate/abi/src/genesis_liquidity.rs b/substrate/abi/src/genesis_liquidity.rs index 7837c2b1..2b0c208c 100644 --- a/substrate/abi/src/genesis_liquidity.rs +++ b/substrate/abi/src/genesis_liquidity.rs @@ -1,12 +1,13 @@ +pub use serai_genesis_liquidity_primitives as primitives; + use serai_primitives::*; -use serai_genesis_liquidity_primitives::*; +use primitives::*; #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)] -#[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub enum Call { remove_coin_liquidity { balance: Balance }, - set_initial_price { prices: Prices }, + set_initial_price { prices: Prices, signature: Signature }, } #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)] diff --git a/substrate/abi/src/liquidity_tokens.rs b/substrate/abi/src/liquidity_tokens.rs new file mode 100644 index 00000000..6bdc651b --- /dev/null +++ b/substrate/abi/src/liquidity_tokens.rs @@ -0,0 +1,18 @@ +use serai_primitives::{Balance, SeraiAddress}; + +#[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)] +#[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))] +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +pub enum Call { + burn { balance: Balance }, + transfer { to: SeraiAddress, balance: Balance }, +} + +#[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)] +#[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))] +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +pub enum Event { + Mint { to: SeraiAddress, balance: Balance }, + Burn { from: SeraiAddress, balance: Balance }, + Transfer { from: SeraiAddress, to: SeraiAddress, balance: Balance }, +} diff --git a/substrate/client/src/serai/dex.rs b/substrate/client/src/serai/dex.rs index 00108dfe..18341125 100644 --- a/substrate/client/src/serai/dex.rs +++ b/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::{SeraiError, hex_decode, TemporalSerai}; pub type DexEvent = serai_abi::dex::Event; @@ -57,4 +59,21 @@ impl<'a> SeraiDex<'a> { send_to: address, }) } + + pub async fn get_reserves( + &self, + coin1: Coin, + coin2: Coin, + ) -> Result, SeraiError> { + let hash = self + .0 + .serai + .call("state_call", ["DexApi_get_reserves".to_string(), hex::encode((coin1, coin2).encode())]) + .await?; + let bytes = hex_decode(hash) + .map_err(|_| SeraiError::InvalidNode("expected hex from node wasn't hex".to_string()))?; + let resut = decode_from_bytes::>(bytes.into()) + .map_err(|e| SeraiError::ErrorInResponse(e.to_string()))?; + Ok(resut.map(|amounts| (Amount(amounts.0), Amount(amounts.1)))) + } } diff --git a/substrate/client/src/serai/genesis_liquidity.rs b/substrate/client/src/serai/genesis_liquidity.rs new file mode 100644 index 00000000..b8882bd7 --- /dev/null +++ b/substrate/client/src/serai/genesis_liquidity.rs @@ -0,0 +1,73 @@ +pub use serai_abi::genesis_liquidity::primitives; +use primitives::Prices; + +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, SeraiError> { + self + .0 + .events(|event| { + if let serai_abi::Event::GenesisLiquidity(event) = event { + Some(event.clone()) + } else { + None + } + }) + .await + } + + pub async fn liquidity_tokens( + &self, + address: &SeraiAddress, + coin: Coin, + ) -> Result { + Ok( + self + .0 + .storage( + PALLET, + "LiquidityTokensPerAddress", + (coin, sp_core::hashing::blake2_128(&address.encode()), &address.0), + ) + .await? + .unwrap_or(Amount(0)), + ) + } + + pub fn set_initial_price(prices: Prices, signature: Signature) -> Transaction { + Serai::unsigned(serai_abi::Call::GenesisLiquidity( + serai_abi::genesis_liquidity::Call::set_initial_price { prices, 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) -> Option { + self + .0 + .storage( + PALLET, + "Liquidity", + (coin, sp_core::hashing::blake2_128(&address.encode()), &address.0), + ) + .await + .unwrap() + } +} diff --git a/substrate/client/src/serai/liquidity_tokens.rs b/substrate/client/src/serai/liquidity_tokens.rs new file mode 100644 index 00000000..22fcd49e --- /dev/null +++ b/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 { + Ok(self.0.storage(PALLET, "Supply", coin).await?.unwrap_or(Amount(0))) + } + + pub async fn token_balance( + &self, + coin: Coin, + address: SeraiAddress, + ) -> Result { + 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::Coins(serai_abi::coins::Call::transfer { to, balance }) + } + + pub fn burn(balance: Balance) -> serai_abi::Call { + serai_abi::Call::Coins(serai_abi::coins::Call::burn { balance }) + } +} diff --git a/substrate/client/src/serai/mod.rs b/substrate/client/src/serai/mod.rs index 1347fc05..fc4a9ea7 100644 --- a/substrate/client/src/serai/mod.rs +++ b/substrate/client/src/serai/mod.rs @@ -1,3 +1,4 @@ +use hex::FromHexError; use thiserror::Error; use async_lock::RwLock; @@ -26,6 +27,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 { @@ -82,6 +87,14 @@ impl<'a> Clone for TemporalSerai<'a> { } } +pub fn hex_decode(str: String) -> Result, FromHexError> { + if let Some(stripped) = str.strip_prefix("0x") { + hex::decode(stripped) + } else { + hex::decode(str) + } +} + impl Serai { pub async fn call( &self, @@ -134,19 +147,11 @@ impl Serai { } } - fn hex_decode(str: String) -> Result, SeraiError> { - (if let Some(stripped) = str.strip_prefix("0x") { - hex::decode(stripped) - } else { - hex::decode(str) - }) - .map_err(|_| SeraiError::InvalidNode("expected hex from node wasn't hex".to_string())) - } - pub async fn block_hash(&self, number: u64) -> Result, SeraiError> { let hash: Option = self.call("chain_getBlockHash", [number]).await?; let Some(hash) = hash else { return Ok(None) }; - Self::hex_decode(hash)? + hex_decode(hash) + .map_err(|_| SeraiError::InvalidNode("expected hex from node wasn't hex".to_string()))? .try_into() .map_err(|_| SeraiError::InvalidNode("didn't respond to getBlockHash with hash".to_string())) .map(Some) @@ -195,11 +200,13 @@ impl Serai { Ok(()) } + // TODO: move this into substrate/client/src/validator_sets.rs async fn active_network_validators(&self, network: NetworkId) -> Result, SeraiError> { let hash: String = self .call("state_call", ["SeraiRuntimeApi_validators".to_string(), hex::encode(network.encode())]) .await?; - let bytes = Self::hex_decode(hash)?; + let bytes = hex_decode(hash) + .map_err(|_| SeraiError::InvalidNode("expected hex from node wasn't hex".to_string()))?; let r = Vec::::decode(&mut bytes.as_slice()) .map_err(|e| SeraiError::ErrorInResponse(e.to_string()))?; Ok(r) @@ -207,9 +214,12 @@ impl Serai { pub async fn latest_finalized_block_hash(&self) -> Result<[u8; 32], SeraiError> { let hash: String = self.call("chain_getFinalizedHead", ()).await?; - Self::hex_decode(hash)?.try_into().map_err(|_| { - SeraiError::InvalidNode("didn't respond to getFinalizedHead with hash".to_string()) - }) + hex_decode(hash) + .map_err(|_| SeraiError::InvalidNode("expected hex from node wasn't hex".to_string()))? + .try_into() + .map_err(|_| { + SeraiError::InvalidNode("didn't respond to getFinalizedHead with hash".to_string()) + }) } pub async fn header(&self, hash: [u8; 32]) -> Result, SeraiError> { @@ -219,7 +229,7 @@ impl Serai { pub async fn block(&self, hash: [u8; 32]) -> Result, SeraiError> { let block: Option = self.call("chain_getBlockBin", [hex::encode(hash)]).await?; let Some(block) = block else { return Ok(None) }; - let Ok(bytes) = Self::hex_decode(block) else { + let Ok(bytes) = hex_decode(block) else { Err(SeraiError::InvalidNode("didn't return a hex-encoded block".to_string()))? }; let Ok(block) = Block::decode(&mut bytes.as_slice()) else { @@ -365,7 +375,8 @@ impl<'a> TemporalSerai<'a> { let res: Option = self.serai.call("state_getStorage", [hex::encode(full_key), hex::encode(self.block)]).await?; let Some(res) = res else { return Ok(None) }; - let res = Serai::hex_decode(res)?; + let res = hex_decode(res) + .map_err(|_| SeraiError::InvalidNode("expected hex from node wasn't hex".to_string()))?; Ok(Some(R::decode(&mut res.as_slice()).map_err(|_| { SeraiError::InvalidRuntime("different type present at storage location".to_string()) })?)) @@ -386,4 +397,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) + } } diff --git a/substrate/client/tests/common/mod.rs b/substrate/client/tests/common/mod.rs index d7e8436b..e9d88594 100644 --- a/substrate/client/tests/common/mod.rs +++ b/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; + } + )* + } +} diff --git a/substrate/client/tests/genesis_liquidity.rs b/substrate/client/tests/genesis_liquidity.rs new file mode 100644 index 00000000..9efc8f09 --- /dev/null +++ b/substrate/client/tests/genesis_liquidity.rs @@ -0,0 +1,232 @@ +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, GENESIS_SRI}, + SeraiGenesisLiquidity, + }, + validator_sets::primitives::{musig_context, Session, ValidatorSet}, +}; + +use serai_abi::{ + genesis_liquidity::primitives::{set_initial_price_message, Prices}, + primitives::COINS, +}; + +use sp_core::{sr25519::Signature, Pair as PairTrait}; + +use serai_client::{ + primitives::{ + Amount, NetworkId, Coin, Balance, BlockHash, SeraiAddress, insecure_pair_from_name, + }, + 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) { + // amounts + let amounts = vec![ + Amount(5_53246991), + Amount(3_14562819), + Amount(9_33648912), + Amount(150_873639000000), + Amount(248_665228000000), + Amount(451_765529000000), + ]; + + // addresses + let mut btc_addresses = vec![]; + let mut xmr_addresses = vec![]; + let addr_count = amounts.len(); + for (i, amount) in amounts.into_iter().enumerate() { + let mut address = SeraiAddress::new([0; 32]); + OsRng.fill_bytes(&mut address.0); + if i < addr_count / 2 { + btc_addresses.push((address, amount)); + } else { + xmr_addresses.push((address, amount)); + } + } + btc_addresses.sort_by(|a1, a2| a1.0.cmp(&a2.0)); + xmr_addresses.sort_by(|a1, a2| a1.0.cmp(&a2.0)); + + // btc batch + let mut block_hash = BlockHash([0; 32]); + OsRng.fill_bytes(&mut block_hash.0); + let btc_ins = btc_addresses + .iter() + .map(|(addr, amount)| InInstructionWithBalance { + instruction: InInstruction::GenesisLiquidity(*addr), + balance: Balance { coin: Coin::Bitcoin, amount: *amount }, + }) + .collect::>(); + let batch = + Batch { network: NetworkId::Bitcoin, id: 0, block: block_hash, instructions: btc_ins }; + provide_batch(&serai, batch).await; + + // xmr batch + let mut block_hash = BlockHash([0; 32]); + OsRng.fill_bytes(&mut block_hash.0); + let xmr_ins = xmr_addresses + .iter() + .map(|(addr, amount)| InInstructionWithBalance { + instruction: InInstruction::GenesisLiquidity(*addr), + balance: Balance { coin: Coin::Monero, amount: *amount }, + }) + .collect::>(); + let batch = Batch { network: NetworkId::Monero, id: 0, block: block_hash, instructions: xmr_ins }; + provide_batch(&serai, batch).await; + + // set prices + let prices = Prices { bitcoin: 10u64.pow(8), monero: 184100, ethereum: 4785000, dai: 1500 }; + set_prices(&serai, &prices).await; + + // wait until genesis ends.. + tokio::time::timeout(tokio::time::Duration::from_secs(300), async { + while serai.latest_finalized_block().await.unwrap().number() < 25 { + tokio::time::sleep(Duration::from_secs(6)).await; + } + }) + .await + .unwrap(); + + // check total SRI supply is +100M + let last_block = serai.latest_finalized_block().await.unwrap().hash(); + let serai = serai.as_of(last_block); + // Check balance instead of supply + let sri = serai.coins().coin_supply(Coin::Serai).await.unwrap(); + // there are 6 endowed accounts in dev-net. Take this into consideration when checking + // for the total sri minted at this time. + 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 pool_btc = btc_addresses.iter().fold(0u128, |acc, value| acc + u128::from(value.1 .0)); + let pool_xmr = xmr_addresses.iter().fold(0u128, |acc, value| acc + u128::from(value.1 .0)); + + let pool_btc_value = (pool_btc * u128::from(prices.bitcoin)) / 10u128.pow(8); + let pool_xmr_value = (pool_xmr * u128::from(prices.monero)) / 10u128.pow(12); + let total_value = pool_btc_value + pool_xmr_value; + + // calculated distributed SRI. We know that xmr is at the end of COINS array + // so it will be approximated to roof instead of floor after integer division. + let btc_sri = (pool_btc_value * u128::from(GENESIS_SRI)) / total_value; + let xmr_sri = ((pool_xmr_value * u128::from(GENESIS_SRI)) / total_value) + 1; + + let btc_reserves = serai.dex().get_reserves(Coin::Bitcoin, Coin::Serai).await.unwrap().unwrap(); + assert_eq!(u128::from(btc_reserves.0 .0), pool_btc); + assert_eq!(u128::from(btc_reserves.1 .0), btc_sri); + + let xmr_reserves = serai.dex().get_reserves(Coin::Monero, Coin::Serai).await.unwrap().unwrap(); + assert_eq!(u128::from(xmr_reserves.0 .0), pool_xmr); + assert_eq!(u128::from(xmr_reserves.1 .0), xmr_sri); + + // check each btc liq provider got liq tokens proportional to their value + let btc_liq_token_supply = u128::from( + serai + .liquidity_tokens() + .token_balance(Coin::Bitcoin, GENESIS_LIQUIDITY_ACCOUNT) + .await + .unwrap() + .0, + ); + let mut total_tokens_this_coin: u128 = 0; + for (i, (addr, amount)) in btc_addresses.iter().enumerate() { + let addr_value = (u128::from(amount.0) * u128::from(prices.bitcoin)) / 10u128.pow(8); + let addr_liq_tokens = if i == btc_addresses.len() - 1 { + btc_liq_token_supply - total_tokens_this_coin + } else { + (addr_value * btc_liq_token_supply) / pool_btc_value + }; + + let addr_actual_token_amount = + serai.genesis_liquidity().liquidity_tokens(addr, Coin::Bitcoin).await.unwrap(); + + assert_eq!(addr_liq_tokens, addr_actual_token_amount.0.into()); + total_tokens_this_coin += addr_liq_tokens; + } + + // check each xmr liq provider got liq tokens proportional to their value + let xmr_liq_token_supply = u128::from( + serai + .liquidity_tokens() + .token_balance(Coin::Monero, GENESIS_LIQUIDITY_ACCOUNT) + .await + .unwrap() + .0, + ); + total_tokens_this_coin = 0; + for (i, (addr, amount)) in xmr_addresses.iter().enumerate() { + let addr_value = (u128::from(amount.0) * u128::from(prices.monero)) / 10u128.pow(12); + let addr_liq_tokens = if i == xmr_addresses.len() - 1 { + xmr_liq_token_supply - total_tokens_this_coin + } else { + (addr_value * xmr_liq_token_supply) / pool_xmr_value + }; + + let addr_actual_token_amount = + serai.genesis_liquidity().liquidity_tokens(addr, Coin::Monero).await.unwrap(); + + assert_eq!(addr_liq_tokens, addr_actual_token_amount.0.into()); + total_tokens_this_coin += addr_liq_tokens; + } + + // TODO: remove the liq before/after genesis ended. +} + +async fn set_prices(serai: &Serai, prices: &Prices) { + // prepare a Musig tx to set the initial prices + let pair = insecure_pair_from_name("Alice"); + let public = pair.public(); + let set = ValidatorSet { session: Session(0), network: NetworkId::Serai }; + + let public_key = ::read_G::<&[u8]>(&mut public.0.as_ref()).unwrap(); + let secret_key = ::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::(&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())]), + ), + &set_initial_price_message(&set, prices), + ); + + // set initial prices + let _ = publish_tx( + serai, + &SeraiGenesisLiquidity::set_initial_price(*prices, Signature(sig.to_bytes())), + ) + .await; +} diff --git a/substrate/genesis-liquidity/pallet/Cargo.toml b/substrate/genesis-liquidity/pallet/Cargo.toml index 456a3850..5ce41383 100644 --- a/substrate/genesis-liquidity/pallet/Cargo.toml +++ b/substrate/genesis-liquidity/pallet/Cargo.toml @@ -56,5 +56,6 @@ std = [ "genesis-liquidity-primitives/std", "validator-sets-primitives/std", ] +fast-epoch = [] default = ["std"] diff --git a/substrate/genesis-liquidity/pallet/src/lib.rs b/substrate/genesis-liquidity/pallet/src/lib.rs index 64207127..6e6f2a1f 100644 --- a/substrate/genesis-liquidity/pallet/src/lib.rs +++ b/substrate/genesis-liquidity/pallet/src/lib.rs @@ -94,8 +94,14 @@ pub mod pallet { #[pallet::hooks] impl Hooks> for Pallet { fn on_finalize(n: BlockNumberFor) { + #[cfg(feature = "fast-epoch")] + let final_block = 25u32; + + #[cfg(not(feature = "fast-epoch"))] + let final_block = BLOCKS_PER_MONTH; + // Distribute the genesis sri to pools after a month - if n == BLOCKS_PER_MONTH.into() { + if n == final_block.into() { // mint the SRI Coins::::mint( GENESIS_LIQUIDITY_ACCOUNT.into(), @@ -105,8 +111,8 @@ pub mod pallet { // get coin values & total let mut account_values = BTreeMap::new(); - let mut pool_values = BTreeMap::new(); - let mut total_value: u64 = 0; + let mut pool_values = vec![]; + let mut total_value: u128 = 0; for coin in COINS { if coin == Coin::Serai { continue; @@ -117,50 +123,85 @@ pub mod pallet { // get the pool & individual address values account_values.insert(coin, vec![]); - let mut pool_amount: u64 = 0; + let mut pool_amount: u128 = 0; for (account, amount) in Liquidity::::iter_prefix(coin) { - pool_amount = pool_amount.saturating_add(amount); - let value_this_addr = amount.saturating_mul(value); + pool_amount = pool_amount.saturating_add(amount.into()); + let value_this_addr = + u128::from(amount).saturating_mul(value.into()) / 10u128.pow(coin.decimals()); account_values.get_mut(&coin).unwrap().push((account, value_this_addr)) } + // sort, so that everyone has a consistent accounts vector per coin + account_values.get_mut(&coin).unwrap().sort(); - let pool_value = pool_amount.saturating_mul(value); + let pool_value = pool_amount.saturating_mul(value.into()) / 10u128.pow(coin.decimals()); total_value = total_value.saturating_add(pool_value); - pool_values.insert(coin, (pool_amount, pool_value)); + pool_values.push((coin, pool_amount, pool_value)); } // add the liquidity per pool - for (coin, (amount, value)) in &pool_values { - let sri_amount = GENESIS_SRI.saturating_mul(*value) / total_value; + let mut total_sri_distributed = 0; + let pool_values_len = pool_values.len(); + for (i, (coin, pool_amount, pool_value)) in pool_values.into_iter().enumerate() { + // whatever sri left for the last coin should be ~= it's ratio + let sri_amount = if i == (pool_values_len - 1) { + GENESIS_SRI - total_sri_distributed + } else { + u64::try_from(u128::from(GENESIS_SRI).saturating_mul(pool_value) / total_value).unwrap() + }; + total_sri_distributed += sri_amount; + + // we can't add 0 liquidity + if !(pool_amount > 0 && sri_amount > 0) { + continue; + } + + // actually add the liquidity to dex let origin = RawOrigin::Signed(GENESIS_LIQUIDITY_ACCOUNT.into()); Dex::::add_liquidity( origin.into(), - *coin, - *amount, + coin, + u64::try_from(pool_amount).unwrap(), sri_amount, - *amount, + u64::try_from(pool_amount).unwrap(), sri_amount, GENESIS_LIQUIDITY_ACCOUNT.into(), ) .unwrap(); + + // let everyone know about the event Self::deposit_event(Event::GenesisLiquidityAddedToPool { - coin1: Balance { coin: *coin, amount: Amount(*amount) }, + coin1: Balance { coin, amount: Amount(u64::try_from(pool_amount).unwrap()) }, coin2: Balance { coin: Coin::Serai, amount: Amount(sri_amount) }, }); // set liquidity tokens per account - let tokens = LiquidityTokens::::balance(GENESIS_LIQUIDITY_ACCOUNT.into(), *coin).0; - let mut total_tokens_this_coin: u64 = 0; - for (acc, value) in account_values.get(coin).unwrap() { - let liq_tokens_this_acc = - tokens.saturating_mul(*value) / pool_values.get(coin).unwrap().1; + let tokens = + u128::from(LiquidityTokens::::balance(GENESIS_LIQUIDITY_ACCOUNT.into(), coin).0); + let mut total_tokens_this_coin: u128 = 0; + + let accounts = account_values.get(&coin).unwrap(); + for (i, (acc, acc_value)) in accounts.iter().enumerate() { + // give whatever left to the last account not to have rounding errors. + let liq_tokens_this_acc = if i == accounts.len() - 1 { + tokens - total_tokens_this_coin + } else { + tokens.saturating_mul(*acc_value) / pool_value + }; + total_tokens_this_coin = total_tokens_this_coin.saturating_add(liq_tokens_this_acc); - LiquidityTokensPerAddress::::set(coin, acc, Some(liq_tokens_this_acc)); + + LiquidityTokensPerAddress::::set( + coin, + acc, + Some(u64::try_from(liq_tokens_this_acc).unwrap()), + ); } assert_eq!(tokens, total_tokens_this_coin); } + assert_eq!(total_sri_distributed, GENESIS_SRI); - // we shouldn't have any coin left in our account at this moment, including SRI. + // we shouldn't have left any coin in genesis account at this moment, including SRI. + // All transferred to the pools. for coin in COINS { assert_eq!(Coins::::balance(GENESIS_LIQUIDITY_ACCOUNT.into(), coin), Amount(0)); } diff --git a/substrate/genesis-liquidity/primitives/Cargo.toml b/substrate/genesis-liquidity/primitives/Cargo.toml index a3911b81..e795ff24 100644 --- a/substrate/genesis-liquidity/primitives/Cargo.toml +++ b/substrate/genesis-liquidity/primitives/Cargo.toml @@ -30,5 +30,16 @@ serai-primitives = { path = "../../primitives", default-features = false } validator-sets-primitives = { package = "serai-validator-sets-primitives", path = "../../validator-sets/primitives", default-features = false } [features] -std = ["serai-primitives/std", "validator-sets-primitives/std", "sp-std/std"] +std = [ + "zeroize", + "scale/std", + "borsh?/std", + "serde?/std", + "scale-info/std", + + "serai-primitives/std", + "validator-sets-primitives/std", + + "sp-std/std" +] default = ["std"] diff --git a/substrate/genesis-liquidity/primitives/src/lib.rs b/substrate/genesis-liquidity/primitives/src/lib.rs index 9846c113..f334ec74 100644 --- a/substrate/genesis-liquidity/primitives/src/lib.rs +++ b/substrate/genesis-liquidity/primitives/src/lib.rs @@ -30,7 +30,7 @@ pub const GENESIS_SRI: u64 = 100_000_000 * 10_u64.pow(8); // This is the account to hold and manage the genesis liquidity. pub const GENESIS_LIQUIDITY_ACCOUNT: SeraiAddress = system_address(b"Genesis-liquidity-account"); -#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)] +#[derive(Clone, Copy, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)] #[cfg_attr(feature = "std", derive(Zeroize))] #[cfg_attr(feature = "borsh", derive(BorshSerialize, BorshDeserialize))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] diff --git a/substrate/runtime/Cargo.toml b/substrate/runtime/Cargo.toml index 8efe0c85..7a8169ec 100644 --- a/substrate/runtime/Cargo.toml +++ b/substrate/runtime/Cargo.toml @@ -126,7 +126,7 @@ std = [ "pallet-transaction-payment-rpc-runtime-api/std", ] -fast-epoch = [] +fast-epoch = ["genesis-liquidity-pallet/fast-epoch"] runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", diff --git a/substrate/runtime/src/lib.rs b/substrate/runtime/src/lib.rs index 11517a34..b95593f9 100644 --- a/substrate/runtime/src/lib.rs +++ b/substrate/runtime/src/lib.rs @@ -11,7 +11,6 @@ use core::marker::PhantomData; // Re-export all components pub use serai_primitives as primitives; pub use primitives::{BlockNumber, Header}; -use primitives::{NetworkId, NETWORKS}; pub use frame_system as system; pub use frame_support as support; @@ -49,7 +48,7 @@ use sp_runtime::{ BoundedVec, Perbill, ApplyExtrinsicResult, }; -use primitives::{PublicKey, AccountLookup, SubstrateAmount}; +use primitives::{NetworkId, PublicKey, AccountLookup, SubstrateAmount, Coin, NETWORKS}; use support::{ traits::{ConstU8, ConstU16, ConstU32, ConstU64, Contains}, @@ -323,7 +322,7 @@ pub type ReportLongevity = ::EpochDuration; impl babe::Config for Runtime { #[cfg(feature = "fast-epoch")] - type EpochDuration = ConstU64<{ MINUTES / 2 }>; // 30 seconds + type EpochDuration = ConstU64<{ HOURS / 2 }>; // 30 minutes #[cfg(not(feature = "fast-epoch"))] type EpochDuration = ConstU64<{ 4 * 7 * DAYS }>; @@ -638,4 +637,28 @@ sp_api::impl_runtime_apis! { } } } + + impl dex::DexApi for Runtime { + fn quote_price_exact_tokens_for_tokens( + asset1: Coin, + asset2: Coin, + amount: SubstrateAmount, + include_fee: bool + ) -> Option { + Dex::quote_price_exact_tokens_for_tokens(asset1, asset2, amount, include_fee) + } + + fn quote_price_tokens_for_exact_tokens( + asset1: Coin, + asset2: Coin, + amount: SubstrateAmount, + include_fee: bool + ) -> Option { + Dex::quote_price_tokens_for_exact_tokens(asset1, asset2, amount, include_fee) + } + + fn get_reserves(asset1: Coin, asset2: Coin) -> Option<(SubstrateAmount, SubstrateAmount)> { + Dex::get_reserves(&asset1, &asset2).ok() + } + } }