From c14923facbd9013cd3c431d44bda6e07d1994a69 Mon Sep 17 00:00:00 2001 From: akildemir Date: Fri, 28 Jun 2024 16:17:57 +0300 Subject: [PATCH] fix pr comments --- Cargo.lock | 1 + substrate/abi/src/coins.rs | 9 - substrate/abi/src/lib.rs | 5 +- substrate/client/src/serai/dex.rs | 23 +- .../client/src/serai/genesis_liquidity.rs | 44 ++-- .../client/src/serai/liquidity_tokens.rs | 4 +- substrate/client/src/serai/mod.rs | 38 ++- substrate/client/tests/genesis_liquidity.rs | 86 +++--- substrate/dex/pallet/src/tests.rs | 2 +- substrate/genesis-liquidity/pallet/Cargo.toml | 2 + substrate/genesis-liquidity/pallet/src/lib.rs | 244 ++++++++++-------- .../genesis-liquidity/primitives/src/lib.rs | 9 +- substrate/node/src/chain_spec.rs | 3 - substrate/primitives/src/constants.rs | 29 +++ substrate/primitives/src/lib.rs | 3 + substrate/runtime/src/abi.rs | 8 +- substrate/runtime/src/lib.rs | 29 +-- 17 files changed, 256 insertions(+), 283 deletions(-) create mode 100644 substrate/primitives/src/constants.rs diff --git a/Cargo.lock b/Cargo.lock index 387f8979f..7d661d297 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7966,6 +7966,7 @@ dependencies = [ "serai-dex-pallet", "serai-genesis-liquidity-primitives", "serai-primitives", + "serai-validator-sets-pallet", "serai-validator-sets-primitives", "sp-application-crypto", "sp-core", diff --git a/substrate/abi/src/coins.rs b/substrate/abi/src/coins.rs index 56255b0a8..9466db0f9 100644 --- a/substrate/abi/src/coins.rs +++ b/substrate/abi/src/coins.rs @@ -13,15 +13,6 @@ pub enum Call { burn_with_instruction { instruction: OutInstructionWithBalance }, } -#[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))] -#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))] -pub enum LiquidityTokensCall { - transfer { to: SeraiAddress, balance: Balance }, - burn { 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))] diff --git a/substrate/abi/src/lib.rs b/substrate/abi/src/lib.rs index aef03963e..ac8b8824c 100644 --- a/substrate/abi/src/lib.rs +++ b/substrate/abi/src/lib.rs @@ -12,6 +12,7 @@ pub mod system; pub mod timestamp; pub mod coins; +pub mod liquidity_tokens; pub mod dex; pub mod validator_sets; @@ -29,7 +30,7 @@ pub mod tx; pub enum Call { Timestamp(timestamp::Call), Coins(coins::Call), - LiquidityTokens(coins::LiquidityTokensCall), + LiquidityTokens(liquidity_tokens::Call), Dex(dex::Call), GenesisLiquidity(genesis_liquidity::Call), ValidatorSets(validator_sets::Call), @@ -51,7 +52,7 @@ pub enum Event { Timestamp, TransactionPayment(TransactionPaymentEvent), Coins(coins::Event), - LiquidityTokens(coins::Event), + LiquidityTokens(liquidity_tokens::Event), Dex(dex::Event), GenesisLiquidity(genesis_liquidity::Event), ValidatorSets(validator_sets::Event), diff --git a/substrate/client/src/serai/dex.rs b/substrate/client/src/serai/dex.rs index 183411257..d9edc56b6 100644 --- a/substrate/client/src/serai/dex.rs +++ b/substrate/client/src/serai/dex.rs @@ -3,7 +3,7 @@ use serai_abi::primitives::{SeraiAddress, Amount, Coin}; use scale::{decode_from_bytes, Encode}; -use crate::{SeraiError, hex_decode, TemporalSerai}; +use crate::{Serai, SeraiError, TemporalSerai}; pub type DexEvent = serai_abi::dex::Event; @@ -60,20 +60,19 @@ impl<'a> SeraiDex<'a> { }) } - pub async fn get_reserves( - &self, - coin1: Coin, - coin2: Coin, - ) -> Result, SeraiError> { - let hash = self + /// Returns the reserves of `coin:SRI` pool. + pub async fn get_reserves(&self, coin: Coin) -> Result, SeraiError> { + let reserves = self .0 .serai - .call("state_call", ["DexApi_get_reserves".to_string(), hex::encode((coin1, coin2).encode())]) + .call( + "state_call", + ["DexApi_get_reserves".to_string(), hex::encode((coin, Coin::Serai).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()) + let bytes = Serai::hex_decode(reserves)?; + let result = decode_from_bytes::>(bytes.into()) .map_err(|e| SeraiError::ErrorInResponse(e.to_string()))?; - Ok(resut.map(|amounts| (Amount(amounts.0), Amount(amounts.1)))) + Ok(result.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 index b8882bd7a..2a2072f09 100644 --- a/substrate/client/src/serai/genesis_liquidity.rs +++ b/substrate/client/src/serai/genesis_liquidity.rs @@ -29,24 +29,6 @@ impl<'a> SeraiGenesisLiquidity<'a> { .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 }, @@ -59,15 +41,21 @@ impl<'a> SeraiGenesisLiquidity<'a> { }) } - 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() + pub async fn liquidity(&self, address: &SeraiAddress, coin: Coin) -> Result { + Ok( + self + .0 + .storage( + PALLET, + "Liquidity", + (coin, sp_core::hashing::blake2_128(&address.encode()), &address.0), + ) + .await? + .unwrap_or(Amount(0)), + ) + } + + pub async fn supply(&self, coin: Coin) -> Result<(Amount, Amount), SeraiError> { + Ok(self.0.storage(PALLET, "Supply", coin).await?.unwrap_or((Amount(0), Amount(0)))) } } diff --git a/substrate/client/src/serai/liquidity_tokens.rs b/substrate/client/src/serai/liquidity_tokens.rs index 22fcd49e1..3e9052b2c 100644 --- a/substrate/client/src/serai/liquidity_tokens.rs +++ b/substrate/client/src/serai/liquidity_tokens.rs @@ -32,10 +32,10 @@ impl<'a> SeraiLiquidityTokens<'a> { } pub fn transfer(to: SeraiAddress, balance: Balance) -> serai_abi::Call { - serai_abi::Call::Coins(serai_abi::coins::Call::transfer { to, balance }) + serai_abi::Call::LiquidityTokens(serai_abi::liquidity_tokens::Call::transfer { to, balance }) } pub fn burn(balance: Balance) -> serai_abi::Call { - serai_abi::Call::Coins(serai_abi::coins::Call::burn { balance }) + serai_abi::Call::LiquidityTokens(serai_abi::liquidity_tokens::Call::burn { balance }) } } diff --git a/substrate/client/src/serai/mod.rs b/substrate/client/src/serai/mod.rs index 6048b6db7..dfd14779e 100644 --- a/substrate/client/src/serai/mod.rs +++ b/substrate/client/src/serai/mod.rs @@ -1,4 +1,3 @@ -use hex::FromHexError; use thiserror::Error; use async_lock::RwLock; @@ -87,14 +86,6 @@ 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, @@ -147,11 +138,19 @@ 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) }; - hex_decode(hash) - .map_err(|_| SeraiError::InvalidNode("expected hex from node wasn't hex".to_string()))? + Self::hex_decode(hash)? .try_into() .map_err(|_| SeraiError::InvalidNode("didn't respond to getBlockHash with hash".to_string())) .map(Some) @@ -204,8 +203,7 @@ impl Serai { let validators: String = self .call("state_call", ["SeraiRuntimeApi_validators".to_string(), hex::encode(network.encode())]) .await?; - let bytes = hex_decode(validators) - .map_err(|_| SeraiError::InvalidNode("expected hex from node wasn't hex".to_string()))?; + let bytes = Self::hex_decode(validators)?; let r = Vec::::decode(&mut bytes.as_slice()) .map_err(|e| SeraiError::ErrorInResponse(e.to_string()))?; Ok(r) @@ -213,12 +211,9 @@ impl Serai { pub async fn latest_finalized_block_hash(&self) -> Result<[u8; 32], SeraiError> { let hash: String = self.call("chain_getFinalizedHead", ()).await?; - 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()) - }) + Self::hex_decode(hash)?.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> { @@ -228,7 +223,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) = hex_decode(block) else { + let Ok(bytes) = Self::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 { @@ -374,8 +369,7 @@ 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 = hex_decode(res) - .map_err(|_| SeraiError::InvalidNode("expected hex from node wasn't hex".to_string()))?; + let res = Serai::hex_decode(res)?; Ok(Some(R::decode(&mut res.as_slice()).map_err(|_| { SeraiError::InvalidRuntime(format!( "different type present at storage location, raw value: {}", diff --git a/substrate/client/tests/genesis_liquidity.rs b/substrate/client/tests/genesis_liquidity.rs index 9efc8f092..ca1a12750 100644 --- a/substrate/client/tests/genesis_liquidity.rs +++ b/substrate/client/tests/genesis_liquidity.rs @@ -9,7 +9,7 @@ use schnorrkel::Schnorrkel; use serai_client::{ genesis_liquidity::{ - primitives::{GENESIS_LIQUIDITY_ACCOUNT, GENESIS_SRI}, + primitives::{GENESIS_LIQUIDITY_ACCOUNT, GENESIS_LP_SHARES}, SeraiGenesisLiquidity, }, validator_sets::primitives::{musig_context, Session, ValidatorSet}, @@ -24,7 +24,7 @@ use sp_core::{sr25519::Signature, Pair as PairTrait}; use serai_client::{ primitives::{ - Amount, NetworkId, Coin, Balance, BlockHash, SeraiAddress, insecure_pair_from_name, + Amount, NetworkId, Coin, Balance, BlockHash, SeraiAddress, insecure_pair_from_name, GENESIS_SRI, }, in_instructions::primitives::{InInstruction, InInstructionWithBalance, Batch}, Serai, @@ -63,8 +63,6 @@ async fn test_genesis_liquidity(serai: Serai) { 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]); @@ -93,23 +91,25 @@ async fn test_genesis_liquidity(serai: Serai) { 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 { + while serai.latest_finalized_block().await.unwrap().number() < 10 { tokio::time::sleep(Duration::from_secs(6)).await; } }) .await .unwrap(); + // set prices + let prices = Prices { bitcoin: 10u64.pow(8), monero: 184100, ethereum: 4785000, dai: 1500 }; + set_prices(&serai, &prices).await; + + // wait little bit.. + tokio::time::sleep(Duration::from_secs(12)).await; + // 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. @@ -136,65 +136,37 @@ async fn test_genesis_liquidity(serai: Serai) { 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(); + let btc_reserves = serai.dex().get_reserves(Coin::Bitcoin).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(); + let xmr_reserves = serai.dex().get_reserves(Coin::Monero).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; + let btc_liq_supply = serai.genesis_liquidity().supply(Coin::Bitcoin).await.unwrap(); + for (acc, amount) in btc_addresses { + let acc_liq_shares = serai.genesis_liquidity().liquidity(&acc, Coin::Bitcoin).await.unwrap().0; + + // 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 shares_ratio = (GENESIS_LP_SHARES * acc_liq_shares) / btc_liq_supply.0 .0; + let amounts_ratio = (GENESIS_LP_SHARES * amount.0) / u64::try_from(pool_btc).unwrap(); + assert_eq!(shares_ratio, amounts_ratio); } // 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; + let xmr_liq_supply = serai.genesis_liquidity().supply(Coin::Monero).await.unwrap(); + for (acc, amount) in xmr_addresses { + let acc_liq_shares = serai.genesis_liquidity().liquidity(&acc, Coin::Monero).await.unwrap().0; + let shares_ratio = (GENESIS_LP_SHARES * acc_liq_shares) / xmr_liq_supply.0 .0; + let amounts_ratio = (GENESIS_LP_SHARES * amount.0) / u64::try_from(pool_xmr).unwrap(); + assert_eq!(shares_ratio, amounts_ratio); } - // TODO: remove the liq before/after genesis ended. + // TODO: test remove the liq before/after genesis ended. } async fn set_prices(serai: &Serai, prices: &Prices) { diff --git a/substrate/dex/pallet/src/tests.rs b/substrate/dex/pallet/src/tests.rs index 80b45464d..b00141997 100644 --- a/substrate/dex/pallet/src/tests.rs +++ b/substrate/dex/pallet/src/tests.rs @@ -25,7 +25,7 @@ pub use coins_pallet as coins; use coins::Pallet as CoinsPallet; -use serai_primitives::*; +use serai_primitives::{Balance, COINS, PublicKey, system_address, Amount}; type LiquidityTokens = coins_pallet::Pallet; type LiquidityTokensError = coins_pallet::Error; diff --git a/substrate/genesis-liquidity/pallet/Cargo.toml b/substrate/genesis-liquidity/pallet/Cargo.toml index 068902d90..befeb29bc 100644 --- a/substrate/genesis-liquidity/pallet/Cargo.toml +++ b/substrate/genesis-liquidity/pallet/Cargo.toml @@ -32,6 +32,7 @@ sp-application-crypto = { git = "https://github.com/serai-dex/substrate", defaul dex-pallet = { package = "serai-dex-pallet", path = "../../dex/pallet", default-features = false } coins-pallet = { package = "serai-coins-pallet", path = "../../coins/pallet", default-features = false } +validator-sets-pallet = { package = "serai-validator-sets-pallet", path = "../../validator-sets/pallet", default-features = false } serai-primitives = { path = "../../primitives", default-features = false } genesis-liquidity-primitives = { package = "serai-genesis-liquidity-primitives", path = "../primitives", default-features = false } @@ -51,6 +52,7 @@ std = [ "coins-pallet/std", "dex-pallet/std", + "validator-sets-pallet/std", "serai-primitives/std", "genesis-liquidity-primitives/std", diff --git a/substrate/genesis-liquidity/pallet/src/lib.rs b/substrate/genesis-liquidity/pallet/src/lib.rs index 6e6f2a1f9..259b0d6ef 100644 --- a/substrate/genesis-liquidity/pallet/src/lib.rs +++ b/substrate/genesis-liquidity/pallet/src/lib.rs @@ -5,19 +5,17 @@ pub mod pallet { use super::*; use frame_system::{pallet_prelude::*, RawOrigin}; - use frame_support::{ - pallet_prelude::*, - sp_runtime::{self, SaturatedConversion}, - }; + use frame_support::{pallet_prelude::*, sp_runtime::SaturatedConversion}; - use sp_std::{vec, vec::Vec, collections::btree_map::BTreeMap}; + use sp_std::{vec, vec::Vec}; use sp_core::sr25519::Signature; use sp_application_crypto::RuntimePublic; use dex_pallet::{Pallet as Dex, Config as DexConfig}; use coins_pallet::{Config as CoinsConfig, Pallet as Coins, AllowMint}; + use validator_sets_pallet::{Config as VsConfig, Pallet as ValidatorSets}; - use serai_primitives::*; + use serai_primitives::{Coin, COINS, *}; use validator_sets_primitives::{ValidatorSet, Session, musig_key}; pub use genesis_liquidity_primitives as primitives; use primitives::*; @@ -27,24 +25,15 @@ pub mod pallet { #[pallet::config] pub trait Config: - frame_system::Config + DexConfig + CoinsConfig + coins_pallet::Config + frame_system::Config + + VsConfig + + DexConfig + + CoinsConfig + + coins_pallet::Config { type RuntimeEvent: From> + IsType<::RuntimeEvent>; } - #[pallet::genesis_config] - #[derive(Clone, PartialEq, Eq, Debug, Encode, Decode)] - pub struct GenesisConfig { - /// List of participants to place in the initial validator sets. - pub participants: Vec, - } - - impl Default for GenesisConfig { - fn default() -> Self { - GenesisConfig { participants: Default::default() } - } - } - #[pallet::error] pub enum Error { GenesisPeriodEnded, @@ -69,39 +58,34 @@ pub mod pallet { pub(crate) type Liquidity = StorageDoubleMap<_, Identity, Coin, Blake2_128Concat, PublicKey, SubstrateAmount, OptionQuery>; + /// Keeps the total shares and the total amount of coins per coin. #[pallet::storage] - pub(crate) type LiquidityTokensPerAddress = - StorageDoubleMap<_, Identity, Coin, Blake2_128Concat, PublicKey, SubstrateAmount, OptionQuery>; + pub(crate) type Supply = StorageMap<_, Identity, Coin, (u64, u64), OptionQuery>; #[pallet::storage] pub(crate) type EconomicSecurityReached = - StorageMap<_, Identity, NetworkId, BlockNumberFor, ValueQuery>; + StorageMap<_, Identity, NetworkId, BlockNumberFor, OptionQuery>; #[pallet::storage] - pub(crate) type Participants = - StorageMap<_, Identity, NetworkId, BoundedVec>, ValueQuery>; + pub(crate) type Oracle = StorageMap<_, Identity, Coin, u64, OptionQuery>; #[pallet::storage] - pub(crate) type Oracle = StorageMap<_, Identity, Coin, u64, ValueQuery>; - - #[pallet::genesis_build] - impl BuildGenesisConfig for GenesisConfig { - fn build(&self) { - Participants::::set(NetworkId::Serai, self.participants.clone().try_into().unwrap()); - } - } + pub(crate) type GenesisComplete = StorageValue<_, bool, OptionQuery>; #[pallet::hooks] impl Hooks> for Pallet { fn on_finalize(n: BlockNumberFor) { #[cfg(feature = "fast-epoch")] - let final_block = 25u32; + let final_block = 10u64; #[cfg(not(feature = "fast-epoch"))] - let final_block = BLOCKS_PER_MONTH; + let final_block = MONTHS; // Distribute the genesis sri to pools after a month - if n == final_block.into() { + if n.saturated_into::() >= final_block && + Self::oraclization_is_done() && + GenesisComplete::::get().is_none() + { // mint the SRI Coins::::mint( GENESIS_LIQUIDITY_ACCOUNT.into(), @@ -109,8 +93,7 @@ pub mod pallet { ) .unwrap(); - // get coin values & total - let mut account_values = BTreeMap::new(); + // get pool & total values let mut pool_values = vec![]; let mut total_value: u128 = 0; for coin in COINS { @@ -119,20 +102,11 @@ pub mod pallet { } // initial coin value in terms of btc - let value = Oracle::::get(coin); - - // get the pool & individual address values - account_values.insert(coin, vec![]); - let mut pool_amount: u128 = 0; - for (account, amount) in Liquidity::::iter_prefix(coin) { - 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 Some(value) = Oracle::::get(coin) else { + continue; + }; + let pool_amount = u128::from(Supply::::get(coin).unwrap_or((0, 0)).1); let pool_value = pool_amount.saturating_mul(value.into()) / 10u128.pow(coin.decimals()); total_value = total_value.saturating_add(pool_value); pool_values.push((coin, pool_amount, pool_value)); @@ -173,30 +147,6 @@ pub mod pallet { 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 = - 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(u64::try_from(liq_tokens_this_acc).unwrap()), - ); - } - assert_eq!(tokens, total_tokens_this_coin); } assert_eq!(total_sri_distributed, GENESIS_SRI); @@ -205,15 +155,17 @@ pub mod pallet { for coin in COINS { assert_eq!(Coins::::balance(GENESIS_LIQUIDITY_ACCOUNT.into(), coin), Amount(0)); } + + GenesisComplete::::set(Some(true)); } // we accept we reached economic security once we can mint smallest amount of a network's coin for coin in COINS { let existing = EconomicSecurityReached::::get(coin.network()); - if existing == 0u32.into() && + if existing.is_none() && ::AllowMint::is_allowed(&Balance { coin, amount: Amount(1) }) { - EconomicSecurityReached::::set(coin.network(), n); + EconomicSecurityReached::::set(coin.network(), Some(n)); Self::deposit_event(Event::EconomicSecurityReached { network: coin.network() }); } } @@ -232,36 +184,77 @@ pub mod pallet { // mint the coins Coins::::mint(GENESIS_LIQUIDITY_ACCOUNT.into(), balance)?; - // save - let existing = Liquidity::::get(balance.coin, account).unwrap_or(0); - let new = existing.checked_add(balance.amount.0).ok_or(Error::::AmountOverflowed)?; - Liquidity::::set(balance.coin, account, Some(new)); + // calculate new shares & supply + let (new_shares, new_supply) = if let Some(supply) = Supply::::get(balance.coin) { + // calculate amount of shares for this amount + let shares = Self::mul_div(supply.0, balance.amount.0, supply.1)?; + + // get new shares for this account + let existing = Liquidity::::get(balance.coin, account).unwrap_or(0); + let new = existing.checked_add(shares).ok_or(Error::::AmountOverflowed)?; + + ( + new, + ( + supply.0.checked_add(shares).ok_or(Error::::AmountOverflowed)?, + supply.1.checked_add(balance.amount.0).ok_or(Error::::AmountOverflowed)?, + ), + ) + } else { + (GENESIS_LP_SHARES, (GENESIS_LP_SHARES, balance.amount.0)) + }; + // save + Liquidity::::set(balance.coin, account, Some(new_shares)); + Supply::::set(balance.coin, Some(new_supply)); Self::deposit_event(Event::GenesisLiquidityAdded { by: account.into(), balance }); Ok(()) } - /// Returns the number of blocks since the coin's network reached economic security first time. - /// If the network is yet to be reached that threshold, 0 is returned. And maximum of - /// `GENESIS_SRI_TRICKLE_FEED` returned. - fn blocks_since_ec_security(coin: &Coin) -> u64 { - let ec_security_block = - EconomicSecurityReached::::get(coin.network()).saturated_into::(); - let current = >::block_number().saturated_into::(); - if ec_security_block > 0 { - let diff = current - ec_security_block; - if diff > GENESIS_SRI_TRICKLE_FEED { - return GENESIS_SRI_TRICKLE_FEED; + /// Returns the number of blocks since the all networks reached economic security first time. + /// If networks is yet to be reached that threshold, None is returned. + fn blocks_since_ec_security() -> Option { + let mut min = u64::MAX; + for n in NETWORKS { + let ec_security_block = EconomicSecurityReached::::get(n)?.saturated_into::(); + let current = >::block_number().saturated_into::(); + let diff = current.saturating_sub(ec_security_block); + min = diff.min(min); + } + Some(min) + } + + fn genesis_ended() -> bool { + Self::oraclization_is_done() && + >::block_number().saturated_into::() >= MONTHS + } + + fn oraclization_is_done() -> bool { + for c in COINS { + if c == Coin::Serai { + continue; } - return diff; + if Oracle::::get(c).is_none() { + return false; + } } - 0 + true } - fn genesis_ended() -> bool { - >::block_number() >= BLOCKS_PER_MONTH.into() + fn mul_div(a: u64, b: u64, c: u64) -> Result> { + let a = u128::from(a); + let b = u128::from(b); + let c = u128::from(c); + + let result = a + .checked_mul(b) + .ok_or(Error::::AmountOverflowed)? + .checked_div(c) + .ok_or(Error::::AmountOverflowed)?; + + result.try_into().map_err(|_| Error::::AmountOverflowed) } } @@ -276,11 +269,15 @@ pub mod pallet { // check we are still in genesis period if Self::genesis_ended() { - // check user have enough to remove - let existing = LiquidityTokensPerAddress::::get(balance.coin, account).unwrap_or(0); - if balance.amount.0 > existing { - Err(Error::::NotEnoughLiquidity)?; - } + // see how much liq tokens we have + let total_liq_tokens = + LiquidityTokens::::balance(GENESIS_LIQUIDITY_ACCOUNT.into(), Coin::Serai).0; + + // get how much user wants to remove + let user_shares = Liquidity::::get(balance.coin, account).unwrap_or(0); + let total_shares = Supply::::get(balance.coin).unwrap_or((0, 0)).0; + let user_liq_tokens = Self::mul_div(total_liq_tokens, user_shares, total_shares)?; + let amount_to_remove = Self::mul_div(user_liq_tokens, balance.amount.0, GENESIS_LP_SHARES)?; // remove liquidity from pool let prev_sri = Coins::::balance(GENESIS_LIQUIDITY_ACCOUNT.into(), Coin::Serai); @@ -288,7 +285,7 @@ pub mod pallet { Dex::::remove_liquidity( origin.clone().into(), balance.coin, - balance.amount.0, + amount_to_remove, 1, 1, GENESIS_LIQUIDITY_ACCOUNT.into(), @@ -297,9 +294,10 @@ pub mod pallet { let current_coin = Coins::::balance(GENESIS_LIQUIDITY_ACCOUNT.into(), balance.coin); // burn the SRI if necessary + // TODO: take into consideration movement between pools. let mut sri = current_sri.0.saturating_sub(prev_sri.0); let distance_to_full_pay = - GENESIS_SRI_TRICKLE_FEED - Self::blocks_since_ec_security(&balance.coin); + GENESIS_SRI_TRICKLE_FEED.saturating_sub(Self::blocks_since_ec_security().unwrap_or(0)); let burn_sri_amount = sri.saturating_mul(distance_to_full_pay) / GENESIS_SRI_TRICKLE_FEED; Coins::::burn( origin.clone().into(), @@ -321,9 +319,13 @@ pub mod pallet { )?; // save - let existing = LiquidityTokensPerAddress::::get(balance.coin, account).unwrap_or(0); - let new = existing.checked_sub(balance.amount.0).ok_or(Error::::AmountOverflowed)?; - LiquidityTokensPerAddress::::set(balance.coin, account, Some(new)); + let new_shares = + user_shares.checked_sub(amount_to_remove).ok_or(Error::::AmountOverflowed)?; + if new_shares == 0 { + Liquidity::::set(balance.coin, account, None); + } else { + Liquidity::::set(balance.coin, account, Some(new_shares)); + } } else { let existing = Liquidity::::get(balance.coin, account).unwrap_or(0); if balance.amount.0 > existing || balance.amount.0 == 0 { @@ -345,7 +347,7 @@ pub mod pallet { Ok(()) } - /// A call to submit the initial coi values. + /// A call to submit the initial coin values in terms of BTC. #[pallet::call_index(1)] #[pallet::weight((0, DispatchClass::Operational))] // TODO pub fn set_initial_price( @@ -356,10 +358,10 @@ pub mod pallet { ensure_none(origin)?; // set the prices - Oracle::::set(Coin::Bitcoin, prices.bitcoin); - Oracle::::set(Coin::Monero, prices.monero); - Oracle::::set(Coin::Ether, prices.ethereum); - Oracle::::set(Coin::Dai, prices.dai); + Oracle::::set(Coin::Bitcoin, Some(prices.bitcoin)); + Oracle::::set(Coin::Monero, Some(prices.monero)); + Oracle::::set(Coin::Ether, Some(prices.ethereum)); + Oracle::::set(Coin::Dai, Some(prices.dai)); Ok(()) } } @@ -371,8 +373,26 @@ pub mod pallet { fn validate_unsigned(_: TransactionSource, call: &Self::Call) -> TransactionValidity { match call { Call::set_initial_price { ref prices, ref signature } => { + // TODO: if this is supposed to be called after a month, serai set won't still be + // in the session 0? Ideally this should pull the session from Vs pallet? let set = ValidatorSet { network: NetworkId::Serai, session: Session(0) }; - let signers = Participants::::get(NetworkId::Serai); + let signers = ValidatorSets::::participants_for_latest_decided_set(NetworkId::Serai) + .expect("no participant in the current set") + .into_iter() + .map(|(p, _)| p) + .collect::>(); + + // check this didn't get called before + if Self::oraclization_is_done() { + Err(InvalidTransaction::Custom(0))?; + } + + // make sure signers settings the price at the end of the genesis period. + // we don't need this check for tests. + #[cfg(not(feature = "fast-epoch"))] + if >::block_number().saturated_into::() < MONTHS { + Err(InvalidTransaction::Custom(1))?; + } if !musig_key(set, &signers).verify(&set_initial_price_message(&set, prices), signature) { Err(InvalidTransaction::BadProof)?; diff --git a/substrate/genesis-liquidity/primitives/src/lib.rs b/substrate/genesis-liquidity/primitives/src/lib.rs index f334ec74e..7053e3f5b 100644 --- a/substrate/genesis-liquidity/primitives/src/lib.rs +++ b/substrate/genesis-liquidity/primitives/src/lib.rs @@ -18,14 +18,7 @@ use scale_info::TypeInfo; use serai_primitives::*; use validator_sets_primitives::ValidatorSet; -// amount of blocks in 30 days for 6s per block. -pub const BLOCKS_PER_MONTH: u32 = 10 * 60 * 24 * 30; - -/// 180 days of blocks -pub const GENESIS_SRI_TRICKLE_FEED: u64 = 10 * 60 * 24 * 180; - -// 100 Million SRI -pub const GENESIS_SRI: u64 = 100_000_000 * 10_u64.pow(8); +pub const GENESIS_LP_SHARES: u64 = 10_000; // This is the account to hold and manage the genesis liquidity. pub const GENESIS_LIQUIDITY_ACCOUNT: SeraiAddress = system_address(b"Genesis-liquidity-account"); diff --git a/substrate/node/src/chain_spec.rs b/substrate/node/src/chain_spec.rs index 976c54cd8..e66ee4a6d 100644 --- a/substrate/node/src/chain_spec.rs +++ b/substrate/node/src/chain_spec.rs @@ -8,7 +8,6 @@ use sc_service::ChainType; use serai_runtime::{ primitives::*, WASM_BINARY, BABE_GENESIS_EPOCH_CONFIG, RuntimeGenesisConfig, SystemConfig, CoinsConfig, DexConfig, ValidatorSetsConfig, SignalsConfig, BabeConfig, GrandpaConfig, - GenesisLiquidityConfig, }; pub type ChainSpec = sc_service::GenericChainSpec; @@ -64,7 +63,6 @@ fn devnet_genesis( .collect(), participants: validators.clone(), }, - genesis_liquidity: GenesisLiquidityConfig { participants: validators.clone() }, signals: SignalsConfig::default(), babe: BabeConfig { authorities: validators.iter().map(|validator| ((*validator).into(), 1)).collect(), @@ -116,7 +114,6 @@ fn testnet_genesis(wasm_binary: &[u8], validators: Vec<&'static str>) -> Runtime .collect(), participants: validators.clone(), }, - genesis_liquidity: GenesisLiquidityConfig { participants: validators.clone() }, signals: SignalsConfig::default(), babe: BabeConfig { authorities: validators.iter().map(|validator| ((*validator).into(), 1)).collect(), diff --git a/substrate/primitives/src/constants.rs b/substrate/primitives/src/constants.rs new file mode 100644 index 000000000..c5c53d75d --- /dev/null +++ b/substrate/primitives/src/constants.rs @@ -0,0 +1,29 @@ +use crate::BlockNumber; + +// 1 MB +pub const BLOCK_SIZE: u32 = 1024 * 1024; +// 6 seconds +pub const TARGET_BLOCK_TIME: u64 = 6; + +/// Measured in blocks. +pub const MINUTES: BlockNumber = 60 / TARGET_BLOCK_TIME; +pub const HOURS: BlockNumber = MINUTES * 60; +pub const DAYS: BlockNumber = HOURS * 24; +pub const WEEKS: BlockNumber = DAYS * 7; +pub const MONTHS: BlockNumber = WEEKS * 4; + +/// 6 months of blocks +pub const GENESIS_SRI_TRICKLE_FEED: u64 = MONTHS * 6; + +// 100 Million SRI +pub const GENESIS_SRI: u64 = 100_000_000 * 10_u64.pow(8); + +/// This needs to be long enough for arbitrage to occur and make holding any fake price up +/// sufficiently unrealistic. +#[allow(clippy::cast_possible_truncation)] +pub const ARBITRAGE_TIME: u16 = (2 * HOURS) as u16; + +/// Since we use the median price, double the window length. +/// +/// We additionally +1 so there is a true median. +pub const MEDIAN_PRICE_WINDOW_LENGTH: u16 = (2 * ARBITRAGE_TIME) + 1; diff --git a/substrate/primitives/src/lib.rs b/substrate/primitives/src/lib.rs index 2af36e22d..d2c52219e 100644 --- a/substrate/primitives/src/lib.rs +++ b/substrate/primitives/src/lib.rs @@ -37,6 +37,9 @@ pub use balance::*; mod account; pub use account::*; +mod constants; +pub use constants::*; + pub type BlockNumber = u64; pub type Header = sp_runtime::generic::Header; diff --git a/substrate/runtime/src/abi.rs b/substrate/runtime/src/abi.rs index 146ce8aec..812cb58d8 100644 --- a/substrate/runtime/src/abi.rs +++ b/substrate/runtime/src/abi.rs @@ -30,10 +30,10 @@ impl From for RuntimeCall { } }, Call::LiquidityTokens(lt) => match lt { - serai_abi::coins::LiquidityTokensCall::transfer { to, balance } => { + serai_abi::liquidity_tokens::Call::transfer { to, balance } => { RuntimeCall::LiquidityTokens(coins::Call::transfer { to: to.into(), balance }) } - serai_abi::coins::LiquidityTokensCall::burn { balance } => { + serai_abi::liquidity_tokens::Call::burn { balance } => { RuntimeCall::LiquidityTokens(coins::Call::burn { balance }) } }, @@ -220,9 +220,9 @@ impl TryInto for RuntimeCall { }), RuntimeCall::LiquidityTokens(call) => Call::LiquidityTokens(match call { coins::Call::transfer { to, balance } => { - serai_abi::coins::LiquidityTokensCall::transfer { to: to.into(), balance } + serai_abi::liquidity_tokens::Call::transfer { to: to.into(), balance } } - coins::Call::burn { balance } => serai_abi::coins::LiquidityTokensCall::burn { balance }, + coins::Call::burn { balance } => serai_abi::liquidity_tokens::Call::burn { balance }, _ => Err(())?, }), RuntimeCall::Dex(call) => Call::Dex(match call { diff --git a/substrate/runtime/src/lib.rs b/substrate/runtime/src/lib.rs index 3f034eed2..5301f0432 100644 --- a/substrate/runtime/src/lib.rs +++ b/substrate/runtime/src/lib.rs @@ -48,7 +48,11 @@ use sp_runtime::{ BoundedVec, Perbill, ApplyExtrinsicResult, }; -use primitives::{NetworkId, PublicKey, AccountLookup, SubstrateAmount, Coin, NETWORKS}; +#[allow(unused_imports)] +use primitives::{ + NetworkId, PublicKey, AccountLookup, SubstrateAmount, Coin, NETWORKS, MEDIAN_PRICE_WINDOW_LENGTH, + HOURS, DAYS, MINUTES, TARGET_BLOCK_TIME, BLOCK_SIZE, +}; use support::{ traits::{ConstU8, ConstU16, ConstU32, ConstU64, Contains}, @@ -115,28 +119,7 @@ pub fn native_version() -> NativeVersion { NativeVersion { runtime_version: VERSION, can_author_with: Default::default() } } -// 1 MB -pub const BLOCK_SIZE: u32 = 1024 * 1024; -// 6 seconds -pub const TARGET_BLOCK_TIME: u64 = 6; - -/// Measured in blocks. -pub const MINUTES: BlockNumber = 60 / TARGET_BLOCK_TIME; -pub const HOURS: BlockNumber = MINUTES * 60; -pub const DAYS: BlockNumber = HOURS * 24; - pub const PRIMARY_PROBABILITY: (u64, u64) = (1, 4); - -/// This needs to be long enough for arbitrage to occur and make holding any fake price up -/// sufficiently unrealistic. -#[allow(clippy::cast_possible_truncation)] -pub const ARBITRAGE_TIME: u16 = (2 * HOURS) as u16; - -/// Since we use the median price, double the window length. -/// -/// We additionally +1 so there is a true median. -pub const MEDIAN_PRICE_WINDOW_LENGTH: u16 = (2 * ARBITRAGE_TIME) + 1; - pub const BABE_GENESIS_EPOCH_CONFIG: sp_consensus_babe::BabeEpochConfiguration = sp_consensus_babe::BabeEpochConfiguration { c: PRIMARY_PROBABILITY, @@ -295,7 +278,7 @@ pub type ReportLongevity = ::EpochDuration; impl babe::Config for Runtime { #[cfg(feature = "fast-epoch")] - type EpochDuration = ConstU64<{ HOURS / 2 }>; // 30 minutes + type EpochDuration = ConstU64<{ MINUTES / 2 }>; // 30 seconds #[cfg(not(feature = "fast-epoch"))] type EpochDuration = ConstU64<{ 4 * 7 * DAYS }>;