Wpha Council

pallets/phala/src/compute/wrapped_balances.rs

@@ -8,24 +8,27 @@ pub mod pallet {
  use crate::pool_proxy::PoolProxy;
  use crate::registry;
  use crate::vault;
- use crate::{BalanceOf, NegativeImbalanceOf, PhalaConfig};
+ use crate::{BalanceOf, NegativeImbalanceOf, PhalaConfig, PositiveImbalanceOf};
+ use frame_support::traits::tokens::{Fortitude, Precision};
  use frame_support::{
  pallet_prelude::*,
  traits::{
- tokens::fungibles::{Inspect, Mutate},
  tokens::nonfungibles::InspectEnumerable,
- Currency,
- ExistenceRequirement::{AllowDeath, KeepAlive},
- OnUnbalanced, StorageVersion,
+ tokens::{
+ fungibles::{Inspect, Mutate},
+ BalanceStatus,
+ },
+ Currency, ExistenceRequirement, Imbalance, LockIdentifier, LockableCurrency,
+ OnUnbalanced, ReservableCurrency, SignedImbalance, StorageVersion, WithdrawReasons,
  },
  };
- use frame_support::traits::tokens::{Fortitude, Precision};
  use frame_system::{pallet_prelude::*, RawOrigin};
  use pallet_democracy::{AccountVote, ReferendumIndex, ReferendumInfo};
  pub use rmrk_traits::primitives::{CollectionId, NftId};
  use scale_info::TypeInfo;
- use sp_runtime::traits::Zero;
+ use sp_runtime::traits::{CheckedSub, Zero};
  use sp_std::{fmt::Display, prelude::*, result::Result};
+
  #[pallet::config]
  pub trait Config:
  frame_system::Config
@@ -89,6 +92,14 @@ pub mod pallet {
  pub type StakerAccounts<T: Config> =
  StorageMap<_, Twox64Concat, T::AccountId, FinanceAccount<BalanceOf<T>>>;
 
+ #[pallet::storage]
+ #[pallet::getter(fn election_locks)]
+ pub type ElectionLocks<T: Config> = StorageMap<_, Twox64Concat, T::AccountId, BalanceOf<T>>;
+
+ #[pallet::storage]
+ #[pallet::getter(fn election_reserves)]
+ pub type ElectionReserves<T: Config> = StorageMap<_, Twox64Concat, T::AccountId, BalanceOf<T>>;
+
  #[pallet::event]
  #[pallet::generate_deposit(pub(super) fn deposit_event)]
  pub enum Event<T: Config> {
@@ -133,6 +144,226 @@ pub mod pallet {
  ReferendumOngoing,
  /// The Iteration exceed the max limitaion
  IterationsIsNotVaild,
+
+ LockLargerThanTotalBalance,
+
+ LiquidityRestrictions,
+ }
+
+ impl<T: Config> Currency<T::AccountId> for Pallet<T>
+ where
+ BalanceOf<T>: sp_runtime::traits::AtLeast32BitUnsigned + Copy + FixedPointConvert + Display,
+ T: pallet_assets::Config<AssetId = u32, Balance = BalanceOf<T>>,
+ T: Config + pallet_balances::Config + vault::Config,
+ T: pallet_balances::Config<Balance = BalanceOf<T>>,
+ {
+ type Balance = BalanceOf<T>;
+ type PositiveImbalance = PositiveImbalanceOf<T>;
+ type NegativeImbalance = NegativeImbalanceOf<T>;
+ fn total_balance(who: &T::AccountId) -> Self::Balance {
+ <pallet_assets::pallet::Pallet<T> as Inspect<T::AccountId>>::total_balance(
+ T::WPhaAssetId::get(),
+ who,
+ )
+ }
+
+ fn free_balance(who: &T::AccountId) -> Self::Balance {
+ let total_balance = Self::total_balance(who);
+ let lock = StakerAccounts::<T>::get(who).map_or(Zero::zero(), |status| status.locked);
+ let election_lock = ElectionLocks::<T>::get(who).unwrap_or_default();
+ let election_reserve = ElectionReserves::<T>::get(who).unwrap_or_default();
+ total_balance
+ .checked_sub(&lock.max(election_lock).max(election_reserve))
+ .unwrap_or_default()
+ }
+
+ fn can_slash(who: &T::AccountId, value: Self::Balance) -> bool {
+ if value.is_zero() {
+ return true;
+ }
+ Self::free_balance(who) >= value
+ }
+
+ fn total_issuance() -> Self::Balance {
+ <pallet_assets::pallet::Pallet<T> as Inspect<T::AccountId>>::total_issuance(
+ T::WPhaAssetId::get(),
+ )
+ }
+
+ fn active_issuance() -> Self::Balance {
+ <pallet_assets::pallet::Pallet<T> as Inspect<T::AccountId>>::total_issuance(
+ T::WPhaAssetId::get(),
+ )
+ }
+
+ fn deactivate(_amount: Self::Balance) {}
+
+ fn reactivate(_amount: Self::Balance) {}
+
+ fn minimum_balance() -> Self::Balance {
+ <pallet_assets::pallet::Pallet<T> as Inspect<T::AccountId>>::minimum_balance(
+ T::WPhaAssetId::get(),
+ )
+ }
+
+ fn burn(mut _amount: Self::Balance) -> Self::PositiveImbalance {
+ Self::PositiveImbalance::zero()
+ }
+
+ fn issue(mut _amount: Self::Balance) -> Self::NegativeImbalance {
+ Self::NegativeImbalance::zero()
+ }
+
+ fn ensure_can_withdraw(
+ who: &T::AccountId,
+ amount: Self::Balance,
+ _reasons: WithdrawReasons,
+ new_balance: Self::Balance,
+ ) -> DispatchResult {
+ if amount.is_zero() {
+ return Ok(());
+ }
+ let mut lock =
+ StakerAccounts::<T>::get(who).map_or(Zero::zero(), |status| status.locked);
+ let election_lock = ElectionLocks::<T>::get(who).unwrap_or_default();
+ let election_reserve = ElectionReserves::<T>::get(who).unwrap_or_default();
+ lock = lock.max(election_lock).max(election_reserve);
+ ensure!(new_balance >= lock, Error::<T>::LiquidityRestrictions);
+ Ok(())
+ }
+
+ fn transfer(
+ _transactor: &T::AccountId,
+ _dest: &T::AccountId,
+ _value: Self::Balance,
+ _existence_requirement: ExistenceRequirement,
+ ) -> DispatchResult {
+ Ok(())
+ }
+
+ fn slash(
+ who: &T::AccountId,
+ _value: Self::Balance,
+ ) -> (Self::NegativeImbalance, Self::Balance) {
+ (Self::NegativeImbalance::zero(), Self::total_balance(who))
+ }
+
+ fn deposit_into_existing(
+ _who: &T::AccountId,
+ _value: Self::Balance,
+ ) -> Result<Self::PositiveImbalance, DispatchError> {
+ Ok(Self::PositiveImbalance::zero())
+ }
+
+ fn deposit_creating(_who: &T::AccountId, _value: Self::Balance) -> Self::PositiveImbalance {
+ Self::PositiveImbalance::zero()
+ }
+
+ fn withdraw(
+ _who: &T::AccountId,
+ _value: Self::Balance,
+ _reasons: WithdrawReasons,
+ _liveness: ExistenceRequirement,
+ ) -> Result<Self::NegativeImbalance, DispatchError> {
+ Ok(Self::NegativeImbalance::zero())
+ }
+
+ fn make_free_balance_be(
+ _who: &T::AccountId,
+ _value: Self::Balance,
+ ) -> SignedImbalance<Self::Balance, Self::PositiveImbalance> {
+ SignedImbalance::Positive(Self::PositiveImbalance::zero())
+ }
+ }
+
+ impl<T: Config> ReservableCurrency<T::AccountId> for Pallet<T>
+ where
+ BalanceOf<T>: sp_runtime::traits::AtLeast32BitUnsigned + Copy + FixedPointConvert + Display,
+ T: pallet_assets::Config<AssetId = u32, Balance = BalanceOf<T>>,
+ T: Config + pallet_balances::Config + vault::Config,
+ T: pallet_balances::Config<Balance = BalanceOf<T>>,
+ {
+ fn can_reserve(who: &T::AccountId, value: Self::Balance) -> bool {
+ Self::free_balance(who) >= value
+ }
+ fn reserved_balance(who: &T::AccountId) -> Self::Balance {
+ ElectionReserves::<T>::get(who).unwrap_or_default()
+ }
+ fn reserve(who: &T::AccountId, value: Self::Balance) -> DispatchResult {
+ let actual = value.min(Self::free_balance(who));
+ ElectionReserves::<T>::mutate(who, |reserve| {
+ *reserve = Some(reserve.unwrap_or_default() + actual);
+ });
+ Ok(())
+ }
+ fn unreserve(who: &T::AccountId, value: Self::Balance) -> Self::Balance {
+ let actual = value.min(ElectionReserves::<T>::get(who).unwrap_or_default());
+ ElectionReserves::<T>::mutate(who, |reserve| {
+ *reserve = Some(reserve.unwrap_or_default() - actual);
+ });
+ value - actual
+ }
+ fn slash_reserved(
+ who: &T::AccountId,
+ value: Self::Balance,
+ ) -> (Self::NegativeImbalance, Self::Balance) {
+ let actual = value.min(ElectionReserves::<T>::get(who).unwrap_or_default());
+ ElectionReserves::<T>::mutate(who, |reserve| {
+ *reserve = Some(reserve.unwrap_or_default() - actual);
+ });
+ Self::burn_from(who, actual)
+ .expect("burn nft when slash reserved should success; qed.");
+ let imbalance = <T as PhalaConfig>::Currency::withdraw(
+ &T::WrappedBalancesAccountId::get(),
+ actual,
+ WithdrawReasons::all(),
+ ExistenceRequirement::AllowDeath,
+ )
+ .expect("slash imbalance should success; qed.");
+ (imbalance, value - actual)
+ }
+ fn repatriate_reserved(
+ _slashed: &T::AccountId,
+ _beneficiary: &T::AccountId,
+ _value: Self::Balance,
+ _status: BalanceStatus,
+ ) -> Result<Self::Balance, DispatchError> {
+ Ok(Zero::zero())
+ }
+ }
+ impl<T: Config> LockableCurrency<T::AccountId> for Pallet<T>
+ where
+ BalanceOf<T>: sp_runtime::traits::AtLeast32BitUnsigned + Copy + FixedPointConvert + Display,
+ T: pallet_assets::Config<AssetId = u32, Balance = BalanceOf<T>>,
+ T: Config + pallet_balances::Config + vault::Config,
+ T: pallet_balances::Config<Balance = BalanceOf<T>>,
+ {
+ type Moment = T::BlockNumber;
+ type MaxLocks = T::MaxLocks;
+ fn set_lock(
+ _id: LockIdentifier,
+ who: &T::AccountId,
+ amount: Self::Balance,
+ _reasons: WithdrawReasons,
+ ) {
+ let actual = amount.min(Self::free_balance(who));
+ ElectionLocks::<T>::insert(who, actual);
+ }
+ fn extend_lock(
+ _id: LockIdentifier,
+ who: &T::AccountId,
+ amount: Self::Balance,
+ _reasons: WithdrawReasons,
+ ) {
+ let current_lock = ElectionLocks::<T>::get(who).unwrap_or_default();
+ let actual = (current_lock + amount).min(Self::free_balance(who));
+ ElectionLocks::<T>::mutate(who, |locks| {
+ *locks = Some(locks.unwrap_or_default() + actual);
+ });
+ }
+ fn remove_lock(_id: LockIdentifier, who: &T::AccountId) {
+ ElectionLocks::<T>::remove(who);
+ }
  }
 
  impl<T: Config> rmrk_traits::TransferHooks<T::AccountId, u32, u32> for Pallet<T>
@@ -196,7 +427,7 @@ pub mod pallet {
  &user,
  &T::WrappedBalancesAccountId::get(),
  amount,
- KeepAlive,
+ ExistenceRequirement::KeepAlive,
  )?;
  Self::mint_into(&user, amount)?;
  if !StakerAccounts::<T>::contains_key(&user) {
@@ -224,14 +455,17 @@ pub mod pallet {
  let free_stakes: BalanceOf<T> = <pallet_assets::pallet::Pallet<T> as Inspect<
  T::AccountId,
  >>::balance(T::WPhaAssetId::get(), &user);
- let locked =
+ let mut locked =
  StakerAccounts::<T>::get(&user).map_or(Zero::zero(), |status| status.locked);
+ let election_lock = ElectionLocks::<T>::get(&user).unwrap_or_default();
+ let election_reserve = ElectionReserves::<T>::get(&user).unwrap_or_default();
+ locked = locked.max(election_lock).max(election_reserve);
  let withdraw_amount = (active_stakes - locked).min(free_stakes);
  <T as PhalaConfig>::Currency::transfer(
  &T::WrappedBalancesAccountId::get(),
  &user,
  withdraw_amount,
- AllowDeath,
+ ExistenceRequirement::AllowDeath,
  )?;
  Self::burn_from(&user, withdraw_amount)?;
  Ok(())
@@ -253,8 +487,11 @@ pub mod pallet {
  Error::<T>::UnwrapAmountExceedsAvaliableStake
  );
  let active_stakes = Self::get_net_value(user.clone())?;
- let locked =
+ let mut locked =
  StakerAccounts::<T>::get(&user).map_or(Zero::zero(), |status| status.locked);
+ let election_lock = ElectionLocks::<T>::get(&user).unwrap_or_default();
+ let election_reserve = ElectionReserves::<T>::get(&user).unwrap_or_default();
+ locked = locked.max(election_lock).max(election_reserve);
  ensure!(
  amount + locked <= active_stakes,
  Error::<T>::UnwrapAmountExceedsAvaliableStake,
@@ -263,7 +500,7 @@ pub mod pallet {
  &T::WrappedBalancesAccountId::get(),
  &user,
  amount,
- AllowDeath,
+ ExistenceRequirement::AllowDeath,
  )?;
  Self::burn_from(&user, amount)?;
  Self::deposit_event(Event::<T>::Unwrapped { user, amount });
@@ -379,9 +616,14 @@ pub mod pallet {
  pub fn remove_dust(who: &T::AccountId, dust: BalanceOf<T>) {
  debug_assert!(dust != Zero::zero());
  if dust != Zero::zero() {
- let actual_removed =
- pallet_assets::Pallet::<T>::burn_from(T::WPhaAssetId::get(), who, dust, Precision::BestEffort, Fortitude::Force)
- .expect("slash should success with correct amount: qed.");
+ let actual_removed = pallet_assets::Pallet::<T>::burn_from(
+ T::WPhaAssetId::get(),
+ who,
+ dust,
+ Precision::BestEffort,
+ Fortitude::Force,
+ )
+ .expect("slash should success with correct amount: qed.");
  let (imbalance, _remaining) = <T as PhalaConfig>::Currency::slash(
  &<computation::pallet::Pallet<T>>::account_id(),
  dust,
@@ -407,7 +649,7 @@ pub mod pallet {
  target,
  amount,
  Precision::BestEffort,
- Fortitude::Force
+ Fortitude::Force,
  )?;
  Ok(())
  }

pallets/phala/src/lib.rs

@@ -39,6 +39,9 @@ type NegativeImbalanceOf<T> = <<T as PhalaConfig>::Currency as frame_support::tr
  <T as frame_system::Config>::AccountId,
 >>::NegativeImbalance;
 
+type PositiveImbalanceOf<T> = <<T as PhalaConfig>::Currency as frame_support::traits::Currency<
+ <T as frame_system::Config>::AccountId,
+>>::PositiveImbalance;
 // Alias
 pub use compute::base_pool as pallet_base_pool;
 pub use compute::computation as pallet_computation;

standalone/runtime/src/lib.rs

@@ -931,7 +931,7 @@ const_assert!(DesiredMembers::get() <= CouncilMaxMembers::get());
 impl pallet_elections_phragmen::Config for Runtime {
  type RuntimeEvent = RuntimeEvent;
  type PalletId = ElectionsPhragmenPalletId;
- type Currency = Balances;
+ type Currency = PhalaWrappedBalances;
  type ChangeMembers = Council;
  // NOTE: this implies that council's genesis members cannot be set directly and must come from
  // this module.