Init commit

Author: Dinonard

Cargo.lock

@@ -502,6 +502,11 @@ pub mod pallet {
                 })
                 .collect::<Vec<_>>()
         }
+
+        /// Check whether an account is a candidate.
+        pub fn is_account_candidate(account: &T::AccountId) -> bool {
+            Self::candidates().iter().any(|c| &c.who == account)
+        }
     }
 
     /// Keep track of number of authored blocks per authority, uncles are counted as well since

pallets/collator-selection/src/lib.rs

@@ -168,7 +168,7 @@ pub mod pallet {
     impl<T: Config> Pallet<T> {
         /// Execute migrations steps until the specified weight limit has been consumed.
         ///
-        /// Depending on the number of entries migrated and/or deleted, appropriate events are emited.
+        /// Depending on the number of entries migrated and/or deleted, appropriate events are emitted.
         ///
         /// In case at least some progress is made, `Ok(_)` is returned.
         /// If no progress is made, `Err(_)` is returned.
@@ -295,7 +295,7 @@ pub mod pallet {
         /// Steps:
         /// 1. Attempt to `drain` a single DB entry from the old storage. If it's unregistered, move on.
         /// 2. Unreserve the old `RegisterDeposit` amount from the developer account.
-        /// 2. Re-decode old smart contract type into new one. Operation should be infalible in practice since the same underlying type is used.
+        /// 2. Re-decode old smart contract type into new one. Operation should be infallible in practice since the same underlying type is used.
         /// 3. `register` the old-new smart contract into dApp staking v3 pallet.
         ///
         /// Returns `Ok(_)` if an entry was migrated, `Err(_)` if there are no more entries to migrate.
@@ -348,13 +348,6 @@ pub mod pallet {
                                 smart_contract,
                                 error,
                             );
-
-                            // This should never happen, but if it does, we want to know about it.
-                            #[cfg(feature = "try-runtime")]
-                            panic!(
-                                "Failed to register smart contract: {:?} with error: {:?}.",
-                                smart_contract, error
-                            );
                         }
                     }
 
@@ -383,7 +376,7 @@ pub mod pallet {
                     let locked = old_account_ledger.locked;
 
                     // Old unbonding amount can just be released, to keep things simple.
-                    // Alternative is to re-calculat this into unlocking chunks.
+                    // Alternative is to re-calculate this into unlocking chunks.
                     let _total_unbonding = old_account_ledger.unbonding_info.sum();
 
                     <T as pallet_dapps_staking::Config>::Currency::remove_lock(
@@ -430,7 +423,7 @@ pub mod pallet {
         /// Used to remove one entry from the old _dapps_staking_v2_ storage.
         ///
         /// If there are no more entries to remove, returns `Err(_)` with consumed weight and number of deleted entries.
-        /// Otherwise returns `Ok(_)` with consumed weight and number of consumed enries.
+        /// Otherwise returns `Ok(_)` with consumed weight and number of consumed entries.
         pub(crate) fn cleanup_old_storage(limit: u32) -> Result<(Weight, u32), (Weight, u32)> {
             let hashed_prefix = twox_128(pallet_dapps_staking::Pallet::<T>::name().as_bytes());
 
@@ -474,8 +467,8 @@ pub mod pallet {
 
         /// Min allowed weight that migration should be allowed to consume.
         ///
-        /// This serves as a safety marging, to prevent accidental overspending, due to
-        /// inprecision in implementation or benchmarks, when small weight limit is specified.
+        /// This serves as a safety margin, to prevent accidental overspending, due to
+        /// imprecision in implementation or benchmarks, when small weight limit is specified.
         pub(crate) fn min_call_weight() -> Weight {
             // 5% of block should be fine
             T::BlockWeights::get().max_block / 10

pallets/dapp-staking-migration/src/lib.rs

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-dapp-staking-v3"
-version = "0.0.1-alpha"
+version = "0.1.0"
 description = "Pallet for dApp staking v3 protocol"
 authors.workspace = true
 edition.workspace = true

pallets/dapp-staking-v3/Cargo.toml

@@ -151,7 +151,7 @@ mod benchmarks {
     }
 
     #[benchmark]
-    fn lock() {
+    fn lock_new_account() {
         initial_config::<T>();
 
         let staker: T::AccountId = whitelisted_caller();
@@ -167,7 +167,7 @@ mod benchmarks {
         T::BenchmarkHelper::set_balance(&staker, amount);
 
         #[extrinsic_call]
-        _(RawOrigin::Signed(staker.clone()), amount);
+        lock(RawOrigin::Signed(staker.clone()), amount);
 
         assert_last_event::<T>(
             Event::<T>::Locked {
@@ -178,6 +178,39 @@ mod benchmarks {
         );
     }
 
+    #[benchmark]
+    fn lock_existing_account() {
+        initial_config::<T>();
+
+        let staker: T::AccountId = whitelisted_caller();
+        let owner: T::AccountId = account("dapp_owner", 0, SEED);
+        let smart_contract = T::BenchmarkHelper::get_smart_contract(1);
+        assert_ok!(DappStaking::<T>::register(
+            RawOrigin::Root.into(),
+            owner.clone().into(),
+            smart_contract.clone(),
+        ));
+
+        let amount_1 = T::MinimumLockedAmount::get();
+        let amount_2 = 19;
+        T::BenchmarkHelper::set_balance(&staker, amount_1 + amount_2);
+        assert_ok!(DappStaking::<T>::lock(
+            RawOrigin::Signed(staker.clone()).into(),
+            amount_1,
+        ));
+
+        #[extrinsic_call]
+        lock(RawOrigin::Signed(staker.clone()), amount_2);
+
+        assert_last_event::<T>(
+            Event::<T>::Locked {
+                account: staker,
+                amount: amount_2,
+            }
+            .into(),
+        );
+    }
+
     #[benchmark]
     fn unlock() {
         initial_config::<T>();

pallets/dapp-staking-v3/src/benchmarking/mod.rs

@@ -52,8 +52,8 @@ pub use sp_std::vec::Vec;
 
 use astar_primitives::{
     dapp_staking::{
-        CycleConfiguration, DAppId, EraNumber, Observer as DAppStakingObserver, PeriodNumber,
-        SmartContractHandle, StakingRewardHandler, TierId,
+        AccountCheck, CycleConfiguration, DAppId, EraNumber, Observer as DAppStakingObserver,
+        PeriodNumber, SmartContractHandle, StakingRewardHandler, TierId,
     },
     oracle::PriceProvider,
     Balance, BlockNumber,
@@ -144,6 +144,9 @@ pub mod pallet {
         /// dApp staking event observers, notified when certain events occur.
         type Observers: DAppStakingObserver;
 
+        /// Used to check whether an account is allowed to participate in dApp staking.
+        type AccountCheck: AccountCheck<Self::AccountId>;
+
         /// Maximum length of a single era reward span length entry.
         #[pallet::constant]
         type EraRewardSpanLength: Get<u32>;
@@ -307,6 +310,8 @@ pub mod pallet {
         ZeroAmount,
         /// Total locked amount for staker is below minimum threshold.
         LockedAmountBelowThreshold,
+        /// Account is not allowed to participate in dApp staking due to some external reason (e.g. account is already a collator).
+        AccountNotAvailableForDappStaking,
         /// Cannot add additional unlocking chunks due to capacity limit.
         TooManyUnlockingChunks,
         /// Remaining stake prevents entire balance of starting the unlocking process.
@@ -765,16 +770,30 @@ pub mod pallet {
         ///
         /// Locked amount can immediately be used for staking.
         #[pallet::call_index(7)]
-        #[pallet::weight(T::WeightInfo::lock())]
-        pub fn lock(origin: OriginFor<T>, #[pallet::compact] amount: Balance) -> DispatchResult {
+        #[pallet::weight(T::WeightInfo::lock_new_account().max(T::WeightInfo::lock_existing_account()))]
+        pub fn lock(
+            origin: OriginFor<T>,
+            #[pallet::compact] amount: Balance,
+        ) -> DispatchResultWithPostInfo {
             Self::ensure_pallet_enabled()?;
             let account = ensure_signed(origin)?;
 
             let mut ledger = Ledger::<T>::get(&account);
 
+            // Only do the check for new accounts.
+            // External logic should ensure that accounts which are already participating in dApp staking aren't
+            // allowed to participate elsewhere where they shouldn't.
+            let is_new_account = ledger.is_empty();
+            if is_new_account {
+                ensure!(
+                    T::AccountCheck::allowed_to_stake(&account),
+                    Error::<T>::AccountNotAvailableForDappStaking
+                );
+            }
+
             // Calculate & check amount available for locking
             let available_balance =
-                T::Currency::balance(&account).saturating_sub(ledger.active_locked_amount());
+                T::Currency::total_balance(&account).saturating_sub(ledger.active_locked_amount());
             let amount_to_lock = available_balance.min(amount);
             ensure!(!amount_to_lock.is_zero(), Error::<T>::ZeroAmount);
 
@@ -795,7 +814,12 @@ pub mod pallet {
                 amount: amount_to_lock,
             });
 
-            Ok(())
+            Ok(Some(if is_new_account {
+                T::WeightInfo::lock_new_account()
+            } else {
+                T::WeightInfo::lock_existing_account()
+            })
+            .into())
         }
 
         /// Attempts to start the unlocking process for the specified amount.

pallets/dapp-staking-v3/src/lib.rs

@@ -193,6 +193,14 @@ impl DappStakingObserver for DummyDappStakingObserver {
     }
 }
 
+pub(crate) const BLACKLISTED_ACCOUNT: AccountId = 789456123;
+pub struct DummyAccountCheck;
+impl AccountCheck<AccountId> for DummyAccountCheck {
+    fn allowed_to_stake(account: &AccountId) -> bool {
+        *account != BLACKLISTED_ACCOUNT
+    }
+}
+
 impl pallet_dapp_staking::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type RuntimeFreezeReason = RuntimeFreezeReason;
@@ -203,6 +211,7 @@ impl pallet_dapp_staking::Config for Test {
     type StakingRewardHandler = DummyStakingRewardHandler;
     type CycleConfiguration = DummyCycleConfiguration;
     type Observers = DummyDappStakingObserver;
+    type AccountCheck = DummyAccountCheck;
     type EraRewardSpanLength = ConstU32<8>;
     type RewardRetentionInPeriods = ConstU32<2>;
     type MaxNumberOfContracts = ConstU32<10>;

pallets/dapp-staking-v3/src/test/mock.rs

@@ -26,7 +26,7 @@ use crate::{
 
 use frame_support::{
     assert_ok,
-    traits::{fungible::InspectFreeze, Get, OnIdle},
+    traits::{fungible::InspectFreeze, Currency, Get, OnIdle},
     weights::Weight,
 };
 use sp_runtime::{traits::Zero, Perbill};
@@ -208,11 +208,11 @@ pub(crate) fn assert_unregister(smart_contract: &MockSmartContract) {
 pub(crate) fn assert_lock(account: AccountId, amount: Balance) {
     let pre_snapshot = MemorySnapshot::new();
 
-    let free_balance = Balances::free_balance(&account);
+    let total_balance = Balances::total_balance(&account);
     let locked_balance = pre_snapshot.locked_balance(&account);
     let init_frozen_balance = Balances::balance_frozen(&FreezeReason::DAppStaking.into(), &account);
 
-    let available_balance = free_balance
+    let available_balance = total_balance
         .checked_sub(locked_balance)
         .expect("Locked amount cannot be greater than available free balance");
     let expected_lock_amount = available_balance.min(amount);

pallets/dapp-staking-v3/src/test/testing_utils.rs

@@ -25,7 +25,10 @@ use crate::{
 use frame_support::{
     assert_noop, assert_ok, assert_storage_noop,
     error::BadOrigin,
-    traits::{fungible::Unbalanced as FunUnbalanced, Currency, Get, OnFinalize, OnInitialize},
+    traits::{
+        fungible::Unbalanced as FunUnbalanced, Currency, Get, OnFinalize, OnInitialize,
+        ReservableCurrency,
+    },
 };
 use sp_runtime::traits::Zero;
 
@@ -473,7 +476,7 @@ fn lock_is_ok() {
     ExtBuilder::build().execute_with(|| {
         // Lock some amount
         let locker = 2;
-        let free_balance = Balances::free_balance(&locker);
+        let free_balance = Balances::total_balance(&locker);
         assert!(free_balance > 500, "Sanity check");
         assert_lock(locker, 100);
         assert_lock(locker, 200);
@@ -487,6 +490,25 @@ fn lock_is_ok() {
     })
 }
 
+#[test]
+fn lock_with_reserve_is_ok() {
+    ExtBuilder::build().execute_with(|| {
+        // Prepare locker account
+        let locker = 30;
+        let minimum_locked_amount: Balance = <Test as Config>::MinimumLockedAmount::get();
+        Balances::make_free_balance_be(&locker, minimum_locked_amount);
+        assert_ok!(Balances::reserve(&locker, 1));
+        assert_eq!(
+            Balances::free_balance(&locker),
+            minimum_locked_amount - 1,
+            "Sanity check post-reserve."
+        );
+
+        // Lock must still work since account is not blacklisted and has enough total balance to cover the lock requirement
+        assert_lock(locker, minimum_locked_amount);
+    })
+}
+
 #[test]
 fn lock_with_incorrect_amount_fails() {
     ExtBuilder::build().execute_with(|| {
@@ -499,7 +521,7 @@ fn lock_with_incorrect_amount_fails() {
         // Attempting to lock something after everything has been locked is same
         // as attempting to lock with "nothing"
         let locker = 1;
-        assert_lock(locker, Balances::free_balance(&locker));
+        assert_lock(locker, Balances::total_balance(&locker));
         assert_noop!(
             DappStaking::lock(RuntimeOrigin::signed(locker), 1),
             Error::<Test>::ZeroAmount,
@@ -515,6 +537,18 @@ fn lock_with_incorrect_amount_fails() {
     })
 }
 
+#[test]
+fn lock_with_blacklisted_account_fails() {
+    ExtBuilder::build().execute_with(|| {
+        Balances::make_free_balance_be(&BLACKLISTED_ACCOUNT, 100000);
+
+        assert_noop!(
+            DappStaking::lock(RuntimeOrigin::signed(BLACKLISTED_ACCOUNT), 1000),
+            Error::<Test>::AccountNotAvailableForDappStaking,
+        );
+    })
+}
+
 #[test]
 fn unbond_and_unstake_is_ok() {
     ExtBuilder::build().execute_with(|| {