Merge remote-tracking branch 'main' into dev

Author: saiintbrisson

pallets/emission0/src/distribute.rs

@@ -74,9 +74,7 @@ pub fn get_total_emission_per_block<T: Config>() -> BalanceOf<T> {
     }
 
     let interval = T::HalvingInterval::get();
-    let halving_count = total_issuance
-        .checked_div(interval.get())
-        .unwrap_or_default();
+    let halving_count = total_issuance.checked_div(interval.get()).unwrap_or(0);
     let emission = T::BlockEmission::get() >> halving_count;
 
     let not_recycled =

pallets/torus0/src/agent.rs

@@ -148,9 +148,10 @@ pub fn unregister<T: crate::Config>(agent_key: AccountIdOf<T>) -> DispatchResult
         namespace_path,
     )?;
 
-    crate::Agents::<T>::remove(&agent_key);
     crate::stake::clear_key::<T>(&agent_key)?;
 
+    crate::Agents::<T>::remove(&agent_key);
+
     crate::Pallet::<T>::deposit_event(crate::Event::<T>::AgentUnregistered(agent_key));
 
     Ok(())

pallets/torus0/src/migrations.rs

@@ -4,7 +4,7 @@ use polkadot_sdk::frame_support::{
 
 use crate::{Config, Pallet};
 
-pub mod v3 {
+pub mod v4 {
     use super::*;
     use crate::{Agent, Agents};
     use scale_info::prelude::vec::Vec;
@@ -35,9 +35,9 @@ pub mod v3 {
             StorageMap<crate::Pallet<T>, Identity, AccountIdOf<T>, Agent<T>>;
     }
 
-    pub type Migration<T, W> = VersionedMigration<2, 3, MigrateToV3<T>, Pallet<T>, W>;
-    pub struct MigrateToV3<T>(core::marker::PhantomData<T>);
-    impl<T: Config> UncheckedOnRuntimeUpgrade for MigrateToV3<T> {
+    pub type Migration<T, W> = VersionedMigration<3, 4, MigrateToV4<T>, Pallet<T>, W>;
+    pub struct MigrateToV4<T>(core::marker::PhantomData<T>);
+    impl<T: Config> UncheckedOnRuntimeUpgrade for MigrateToV4<T> {
         fn on_runtime_upgrade() -> Weight {
             let old_agents = storage::Agents::<T>::iter().collect::<Vec<_>>();
             let _ = storage::Agents::<T>::clear(u32::MAX, None);
@@ -63,24 +63,6 @@ pub mod v3 {
     }
 }
 
-pub mod v4 {
-    use polkadot_sdk::{
-        frame_support::{migrations::VersionedMigration, traits::UncheckedOnRuntimeUpgrade},
-        sp_weights::Weight,
-    };
-
-    use crate::{Config, Pallet};
-
-    pub type Migration<T, W> = VersionedMigration<3, 4, MigrateToV4<T>, Pallet<T>, W>;
-    pub struct MigrateToV4<T>(core::marker::PhantomData<T>);
-
-    impl<T: Config> UncheckedOnRuntimeUpgrade for MigrateToV4<T> {
-        fn on_runtime_upgrade() -> Weight {
-            Weight::zero()
-        }
-    }
-}
-
 pub mod v5 {
     use pallet_torus0_api::{NamespacePath, NAMESPACE_AGENT_PREFIX};
     use polkadot_sdk::{

pallets/torus0/src/stake.rs

@@ -2,13 +2,13 @@ use polkadot_sdk::{
     frame_support::{
         dispatch::DispatchResult,
         ensure,
-        traits::{Currency, ExistenceRequirement, WithdrawReasons},
+        traits::{Currency, ExistenceRequirement, Imbalance, WithdrawReasons},
     },
     sp_std::{collections::btree_map::BTreeMap, vec::Vec},
-    sp_tracing::error,
 };
 
-use crate::{agent, AccountIdOf, BalanceOf};
+use crate::agent;
+use crate::{AccountIdOf, BalanceOf};
 
 /// Stakes `amount` tokens from `staker` to `staked` by withdrawing the tokens
 /// and adding them to the [`crate::StakingTo`] and [`crate::StakedBy`] maps.
@@ -51,11 +51,6 @@ pub fn remove_stake<T: crate::Config>(
     staked: AccountIdOf<T>,
     amount: BalanceOf<T>,
 ) -> DispatchResult {
-    ensure!(
-        amount >= crate::MinAllowedStake::<T>::get(),
-        crate::Error::<T>::StakeTooSmall
-    );
-
     ensure!(
         agent::exists::<T>(&staked),
         crate::Error::<T>::AgentDoesNotExist
@@ -66,21 +61,44 @@ pub fn remove_stake<T: crate::Config>(
         crate::Error::<T>::NotEnoughStakeToWithdraw
     );
 
-    crate::StakingTo::<T>::mutate(&staker, &staked, |stake| {
-        *stake = Some(stake.unwrap_or(0).saturating_sub(amount))
-    });
-
-    crate::StakedBy::<T>::mutate(&staked, &staker, |stake| {
-        *stake = Some(stake.unwrap_or(0).saturating_sub(amount))
-    });
+    remove_stake0::<T>(staker, staked, amount, true);
 
-    crate::TotalStake::<T>::mutate(|total_stake| *total_stake = total_stake.saturating_sub(amount));
+    Ok(())
+}
 
-    let _ = <T as crate::Config>::Currency::deposit_creating(&staker, amount);
+fn remove_stake0<T: crate::Config>(
+    staker: AccountIdOf<T>,
+    staked: AccountIdOf<T>,
+    amount: BalanceOf<T>,
+    keep: bool,
+) {
+    let Some(stake) = crate::StakingTo::<T>::get(&staker, &staked) else {
+        return;
+    };
+
+    let mut stake = T::Currency::issue(stake);
+    let retrieved = stake.extract(amount);
+
+    let new_stake = if keep || stake.peek() > 0 {
+        Some(stake.peek())
+    } else {
+        None
+    };
+
+    crate::StakingTo::<T>::set(&staker, &staked, new_stake);
+    crate::StakedBy::<T>::set(&staked, &staker, new_stake);
+    crate::TotalStake::<T>::mutate(|total_stake| {
+        *total_stake = total_stake.saturating_sub(retrieved.peek())
+    });
 
-    crate::Pallet::<T>::deposit_event(crate::Event::<T>::StakeRemoved(staker, staked, amount));
+    let retrieved_value = retrieved.peek();
+    <T as crate::Config>::Currency::resolve_creating(&staker, retrieved);
 
-    Ok(())
+    crate::Pallet::<T>::deposit_event(crate::Event::<T>::StakeRemoved(
+        staker,
+        staked,
+        retrieved_value,
+    ));
 }
 
 /// Transfers stake from an account to another (see [`remove_stake`],
@@ -99,16 +117,10 @@ pub fn transfer_stake<T: crate::Config>(
 /// Usually called when de-registering an agent, removes all stakes on a given
 /// key.
 pub(crate) fn clear_key<T: crate::Config>(key: &AccountIdOf<T>) -> DispatchResult {
-    for (staker, staked, amount) in crate::StakingTo::<T>::iter() {
+    let stakes: Vec<_> = crate::StakingTo::<T>::iter().collect();
+    for (staker, staked, amount) in stakes {
         if &staker == key || &staked == key {
-            crate::StakingTo::<T>::remove(&staker, &staked);
-            crate::StakedBy::<T>::remove(&staked, &staker);
-            if let Err(err) = remove_stake::<T>(staker.clone(), staked.clone(), amount) {
-                error!(
-                    "could not remove stake from {:?} to {:?}: {err:?}",
-                    staker, staked
-                )
-            }
+            remove_stake0::<T>(staker, staked, amount, false);
         }
     }
 

pallets/torus0/tests/stake.rs

@@ -1,6 +1,6 @@
 use pallet_torus0::{Error, MinAllowedStake, StakedBy, StakingTo, TotalStake};
 use polkadot_sdk::frame_support::{assert_err, traits::Currency};
-use test_utils::{assert_ok, get_origin, pallet_governance, Balances, Test};
+use test_utils::{as_tors, assert_ok, get_origin, pallet_governance, Balances, Test};
 
 #[test]
 fn add_stake_correctly() {
@@ -192,94 +192,51 @@ fn remove_stake_correctly() {
 }
 
 #[test]
-fn remove_stake_with_less_than_required_amount() {
+fn remove_stake_with_unregistered_agent() {
     test_utils::new_test_ext().execute_with(|| {
         let from = 0;
         let to = 1;
-        let stake_to_add_and_remove = MinAllowedStake::<Test>::get();
-        let total_balance = stake_to_add_and_remove * 2;
+
+        let stake = as_tors(500);
+        let total_balance = stake * 2;
 
         assert_ok!(pallet_governance::whitelist::add_to_whitelist::<Test>(to));
         assert_ok!(pallet_torus0::Pallet::<Test>::register_agent(
             get_origin(to),
             to,
-            "to".as_bytes().to_vec(),
-            "to://idk".as_bytes().to_vec(),
-            "idk".as_bytes().to_vec()
+            b"to".to_vec(),
+            b"to://idk".to_vec(),
+            b"idk".to_vec()
         ));
 
         let _ = Balances::deposit_creating(&from, total_balance);
-        assert_eq!(Balances::total_balance(&to), 0);
 
+        assert_eq!(Balances::total_balance(&from), total_balance);
+        assert_eq!(Balances::total_balance(&to), 0);
         assert_ok!(pallet_torus0::Pallet::<Test>::add_stake(
             get_origin(from),
             to,
-            stake_to_add_and_remove
+            stake,
         ));
 
-        assert_err!(
-            pallet_torus0::Pallet::<Test>::remove_stake(
-                get_origin(from),
-                to,
-                stake_to_add_and_remove - 1
-            ),
-            Error::<Test>::StakeTooSmall,
-        );
+        assert_eq!(Balances::total_balance(&from), total_balance / 2);
 
-        assert_eq!(Balances::total_balance(&from), stake_to_add_and_remove);
-        assert_eq!(
-            StakingTo::<Test>::get(from, to),
-            Some(stake_to_add_and_remove)
-        );
-        assert_eq!(
-            StakedBy::<Test>::get(to, from),
-            Some(stake_to_add_and_remove)
-        );
-        assert_eq!(TotalStake::<Test>::get(), stake_to_add_and_remove);
-    });
-}
+        assert_eq!(TotalStake::<Test>::get(), stake);
+        assert_eq!(StakingTo::<Test>::get(from, to), Some(stake));
+        assert_eq!(StakedBy::<Test>::get(to, from), Some(stake));
 
-#[test]
-fn remove_stake_with_unregistered_agent() {
-    test_utils::new_test_ext().execute_with(|| {
-        let from = 0;
-        let to = 1;
-        let stake_to_add_and_remove = MinAllowedStake::<Test>::get();
-        let total_balance = stake_to_add_and_remove * 2;
-
-        assert_ok!(pallet_governance::whitelist::add_to_whitelist::<Test>(to));
-        assert_ok!(pallet_torus0::Pallet::<Test>::register_agent(
-            get_origin(to),
-            to,
-            "to".as_bytes().to_vec(),
-            "to://idk".as_bytes().to_vec(),
-            "idk".as_bytes().to_vec()
-        ));
-
-        let _ = Balances::deposit_creating(&from, total_balance);
-
-        assert_eq!(Balances::total_balance(&to), 0);
-        assert_ok!(pallet_torus0::Pallet::<Test>::add_stake(
-            get_origin(from),
-            to,
-            stake_to_add_and_remove,
-        ));
         assert_ok!(pallet_torus0::Pallet::<Test>::unregister_agent(get_origin(
             to
         )));
 
         assert_err!(
-            pallet_torus0::Pallet::<Test>::remove_stake(
-                get_origin(from),
-                to,
-                stake_to_add_and_remove
-            ),
+            pallet_torus0::Pallet::<Test>::remove_stake(get_origin(from), to, stake),
             Error::<Test>::AgentDoesNotExist,
         );
 
-        assert_eq!(Balances::total_balance(&from), stake_to_add_and_remove);
+        assert_eq!(Balances::total_balance(&from), total_balance);
         assert_eq!(StakingTo::<Test>::get(from, to), None);
         assert_eq!(StakedBy::<Test>::get(to, from), None);
-        assert_eq!(TotalStake::<Test>::get(), stake_to_add_and_remove);
+        assert_eq!(TotalStake::<Test>::get(), 0);
     });
 }

runtime/src/configs.rs

@@ -137,11 +137,11 @@ impl pallet_sudo::Config for Runtime {
 
 parameter_types! {
     // Base: 1 token + (88 bytes * 0.01 token)
-    pub const DepositBase: Balance = 10u128.saturating_pow(TOKEN_DECIMALS)  // 1 token
-        .saturating_add(88u128.saturating_mul(10u128.saturating_pow(TOKEN_DECIMALS - 2)));  // 0.01 token per byte
+    pub const DepositBase: Balance = 10u128.saturating_pow(TOKEN_DECIMALS) // 1 token
+        .saturating_add(88u128.saturating_mul(10u128.saturating_pow(TOKEN_DECIMALS.saturating_sub(2))));  // 0.01 token per byte
     // Factor: (32 bytes * 0.01 token)
     pub const DepositFactor: Balance =
-        32u128.saturating_mul(10u128.saturating_pow(TOKEN_DECIMALS - 2));  // 0.01 token per byte
+        32u128.saturating_mul(10u128.saturating_pow(TOKEN_DECIMALS.saturating_sub(2)));  // 0.01 token per byte
 }
 
 impl pallet_multisig::Config for Runtime {

runtime/src/configs/eth.rs

@@ -32,13 +32,10 @@ impl<F: FindAuthor<u32>> FindAuthor<H160> for FindAuthorTruncated<F> {
     where
         I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
     {
-        let authority_id = F::find_author(digests).and_then(|author_index| {
-            pallet_aura::Authorities::<Runtime>::get()
-                .get(author_index as usize)
-                .cloned()
-        })?;
-
-        authority_id.to_raw_vec().get(4..24).map(H160::from_slice)
+        use pallet_aura::Authorities;
+        F::find_author(digests)
+            .and_then(|index| Authorities::<Runtime>::get().get(index as usize).cloned())
+            .and_then(|id| id.to_raw_vec().get(4..24).map(H160::from_slice))
     }
 }
 
@@ -63,7 +60,7 @@ pub const MAXIMUM_BLOCK_WEIGHT: Weight = Weight::from_parts(WEIGHT_REF_TIME_PER_
 
 parameter_types! {
     pub BlockGasLimit: U256
-        = U256::from(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT.ref_time() / WEIGHT_PER_GAS);
+        = U256::from((NORMAL_DISPATCH_RATIO.deconstruct() as u64).saturating_mul(MAXIMUM_BLOCK_WEIGHT.ref_time()).checked_div(WEIGHT_PER_GAS).unwrap_or(0));
     pub const GasLimitPovSizeRatio: u64 = 16;
     /// The amount of gas per storage (in bytes): BLOCK_GAS_LIMIT / BLOCK_STORAGE_LIMIT
     /// The current definition of BLOCK_STORAGE_LIMIT is 160 KB, resulting in a value of 366.

runtime/src/lib.rs

@@ -38,7 +38,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     spec_name: create_runtime_str!("torus-runtime"),
     impl_name: create_runtime_str!("torus-runtime"),
     authoring_version: 1,
-    spec_version: 20,
+    spec_version: 21,
     impl_version: 1,
     apis: apis::RUNTIME_API_VERSIONS,
     transaction_version: 1,
@@ -90,7 +90,6 @@ type Migrations = (
     pallet_permission0::migrations::v2::Migration<Runtime, RocksDbWeight>,
     pallet_permission0::migrations::v3::Migration<Runtime, RocksDbWeight>,
     pallet_emission0::migrations::v2::Migration<Runtime, RocksDbWeight>,
-    pallet_torus0::migrations::v3::Migration<Runtime, RocksDbWeight>,
     pallet_torus0::migrations::v4::Migration<Runtime, RocksDbWeight>,
     pallet_torus0::migrations::v5::Migration<Runtime, RocksDbWeight>,
 );

test-utils/src/lib.rs

@@ -1,4 +1,4 @@
-#![allow(non_camel_case_types)]
+#![allow(non_camel_case_types, unexpected_cfgs)]
 
 use std::{cell::RefCell, num::NonZeroU128};