Fungible counterpart

frame/nis/src/lib.rs

@@ -74,16 +74,28 @@ mod mock;
 mod tests;
 pub mod weights;
 
+pub struct WithMaximumOf<A: sp_core::TypedGet>(sp_std::marker::PhantomData<A>);
+impl<A: sp_core::TypedGet> sp_runtime::traits::Convert<sp_runtime::Perquintill, A::Type> for WithMaximumOf<A> where
+	A::Type: Clone + sp_arithmetic::traits::Unsigned + From<u64>,
+	u64: TryFrom<A::Type>,
+{
+	fn convert(a: sp_runtime::Perquintill) -> A::Type {
+		a * A::get()
+	}
+}
+
 #[frame_support::pallet]
 pub mod pallet {
 	pub use crate::weights::WeightInfo;
 	use frame_support::{
 		pallet_prelude::*,
-		traits::{Currency, DefensiveSaturating, OnUnbalanced, ReservableCurrency},
+		traits::{Currency, Defensive, DefensiveSaturating, OnUnbalanced, ReservableCurrency,
+			fungible::{Inspect as FungibleInspect, Mutate as FungibleMutate}
+		},
 	};
 	use frame_system::pallet_prelude::*;
 	use sp_arithmetic::{PerThing, Perquintill};
-	use sp_runtime::traits::{Saturating, Zero};
+	use sp_runtime::traits::{Saturating, Zero, Convert};
 	use sp_std::prelude::*;
 
 	type BalanceOf<T> =
@@ -95,8 +107,33 @@ pub mod pallet {
 		<T as frame_system::Config>::AccountId,
 	>>::NegativeImbalance;
 
+	pub struct NoFungibleReceipt<T>(sp_std::marker::PhantomData<T>);
+	impl<T> FungibleInspect<T> for NoFungibleReceipt<T> {
+		type Balance = u32;
+		fn total_issuance() -> u32 { 0 }
+		fn minimum_balance() -> u32 { 0 }
+		fn balance(_who: &T) -> u32 { 0 }
+		fn reducible_balance(_who: &T, _keep_alive: bool) -> u32 { 0 }
+		fn can_deposit(_who: &T, _amount: u32, _mint: bool) -> frame_support::traits::tokens::DepositConsequence {
+			frame_support::traits::tokens::DepositConsequence::Success
+		}
+		fn can_withdraw(_who: &T, _amount: u32) -> frame_support::traits::tokens::WithdrawConsequence<u32> {
+			frame_support::traits::tokens::WithdrawConsequence::Success
+		}
+	}
+	impl<T> FungibleMutate<T> for NoFungibleReceipt<T> {
+		fn mint_into(_who: &T, _amount: u32) -> DispatchResult { Ok(()) }
+		fn burn_from(_who: &T, _amount: u32) -> Result<u32, DispatchError> { Ok(0) }
+	}
+	impl<T> Convert<Perquintill, u32> for NoFungibleReceipt<T> {
+		fn convert(_: Perquintill) -> u32 { 0 }
+	}
+
 	#[pallet::config]
 	pub trait Config: frame_system::Config {
+		/// Information on runtime weights.
+		type WeightInfo: WeightInfo;
+
 		/// Overarching event type.
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
@@ -130,6 +167,13 @@ pub mod pallet {
 		/// the issuance with which we determine the thawed value of a bond.
 		type IgnoredIssuance: Get<BalanceOf<Self>>;
 
+		type FungibleReceipt: FungibleMutate<Self::AccountId>;
+
+		type FungibleEquivalence: Convert<
+			Perquintill,
+			<Self::FungibleReceipt as FungibleInspect<Self::AccountId>>::Balance,
+		>;
+
 		/// Number of duration queues in total. This sets the maximum duration supported, which is
 		/// this value multiplied by `Period`.
 		#[pallet::constant]
@@ -172,9 +216,6 @@ pub mod pallet {
 		/// bids to make into bonds to reach the target.
 		#[pallet::constant]
 		type MaxIntakeBids: Get<u32>;
-
-		/// Information on runtime weights.
-		type WeightInfo: WeightInfo;
 	}
 
 	#[pallet::pallet]
@@ -477,6 +518,10 @@ pub mod pallet {
 			ensure!(bond.who == who, Error::<T>::NotOwner);
 			let now = frame_system::Pallet::<T>::block_number();
 			ensure!(now >= bond.expiry, Error::<T>::NotExpired);
+
+			let fung_eq = T::FungibleEquivalence::convert(bond.proportion);
+			T::FungibleReceipt::burn_from(&who, fung_eq)?;
+
 			// Remove it
 			Active::<T>::remove(index);
 
@@ -636,9 +681,13 @@ pub mod pallet {
 								totals.index += 1;
 								let e = Event::Issued { index, expiry, who: who.clone(), amount };
 								Self::deposit_event(e);
-								let bond = ActiveType { amount, proportion, who, expiry };
+								let bond = ActiveType { amount, proportion, who: who.clone(), expiry };
 								Active::<T>::insert(index, bond);
 
+								// issue the fungible counterpart
+								let fung_eq = T::FungibleEquivalence::convert(proportion);
+								let _ = T::FungibleReceipt::mint_into(&who, fung_eq).defensive();
+
 								bids_taken += 1;
 
 								if remaining.is_zero() || bids_taken == max_bids {

frame/nis/src/mock.rs

@@ -17,17 +17,18 @@
 
 //! Test environment for NIS pallet.
 
-use crate as pallet_nis;
+use crate::{self as pallet_nis, NoFungibleReceipt, WithMaximumOf};
 
 use frame_support::{
 	ord_parameter_types, parameter_types,
-	traits::{ConstU16, ConstU32, ConstU64, Currency, GenesisBuild, OnFinalize, OnInitialize},
+	traits::{ConstU16, ConstU32, ConstU64, Currency, GenesisBuild, OnFinalize, OnInitialize, StorageMapShim},
 };
 use sp_core::H256;
 use sp_runtime::{
 	testing::Header,
 	traits::{BlakeTwo256, IdentityLookup},
 };
+use pallet_balances::{Instance1, Instance2};
 
 type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
 type Block = frame_system::mocking::MockBlock<Test>;
@@ -39,9 +40,10 @@ frame_support::construct_runtime!(
 		NodeBlock = Block,
 		UncheckedExtrinsic = UncheckedExtrinsic,
 	{
-		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
-		Balances: pallet_balances::{Pallet, Call, Config<T>, Storage, Event<T>},
-		Nis: pallet_nis::{Pallet, Call, Config, Storage, Event<T>},
+		System: frame_system,
+		Balances: pallet_balances::<Instance1>,
+		NisBalances: pallet_balances::<Instance2>,
+		Nis: pallet_nis,
 	}
 );
 
@@ -72,7 +74,7 @@ impl frame_system::Config for Test {
 	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
-impl pallet_balances::Config for Test {
+impl pallet_balances::Config<Instance1> for Test {
 	type Balance = u64;
 	type DustRemoval = ();
 	type RuntimeEvent = RuntimeEvent;
@@ -84,6 +86,19 @@ impl pallet_balances::Config for Test {
 	type ReserveIdentifier = [u8; 8];
 }
 
+impl pallet_balances::Config<Instance2> for Test {
+	type Balance = u64;
+	type DustRemoval = ();
+	type RuntimeEvent = RuntimeEvent;
+	type ExistentialDeposit = frame_support::traits::ConstU64<1>;
+	type AccountStore =
+		StorageMapShim<pallet_balances::Account<Test, Instance2>, frame_system::Provider<Test>, u64, pallet_balances::AccountData<u64>>;
+	type WeightInfo = ();
+	type MaxLocks = ();
+	type MaxReserves = ();
+	type ReserveIdentifier = [u8; 8];
+}
+
 parameter_types! {
 	pub IgnoredIssuance: u64 = Balances::total_balance(&0); // Account zero is ignored.
 }
@@ -92,28 +107,30 @@ ord_parameter_types! {
 }
 
 impl pallet_nis::Config for Test {
+	type WeightInfo = ();
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
-	type CurrencyBalance = <Self as pallet_balances::Config>::Balance;
+	type CurrencyBalance = <Self as pallet_balances::Config<Instance1>>::Balance;
 	type AdminOrigin = frame_system::EnsureSignedBy<One, Self::AccountId>;
 	type Deficit = ();
 	type Surplus = ();
 	type IgnoredIssuance = IgnoredIssuance;
+	type FungibleReceipt = NisBalances;
+	type FungibleEquivalence = WithMaximumOf<ConstU64<21_000_000u64>>;
 	type QueueCount = ConstU32<3>;
 	type MaxQueueLen = ConstU32<3>;
 	type FifoQueueLen = ConstU32<1>;
 	type Period = ConstU64<3>;
 	type MinFreeze = ConstU64<2>;
 	type IntakePeriod = ConstU64<2>;
 	type MaxIntakeBids = ConstU32<2>;
-	type WeightInfo = ();
 }
 
 // This function basically just builds a genesis storage key/value store according to
 // our desired mockup.
 pub fn new_test_ext() -> sp_io::TestExternalities {
 	let mut t = frame_system::GenesisConfig::default().build_storage::<Test>().unwrap();
-	pallet_balances::GenesisConfig::<Test> {
+	pallet_balances::GenesisConfig::<Test, Instance1> {
 		balances: vec![(1, 100), (2, 100), (3, 100), (4, 100)],
 	}
 	.assimilate_storage(&mut t)

frame/nis/src/tests.rs

@@ -20,8 +20,9 @@
 use super::*;
 use crate::{mock::*, Error};
 use frame_support::{assert_noop, assert_ok, dispatch::DispatchError, traits::Currency};
-use pallet_balances::Error as BalancesError;
+use pallet_balances::{Error as BalancesError, Instance1, Instance2};
 use sp_arithmetic::Perquintill;
+use sp_runtime::TokenError;
 
 #[test]
 fn basic_setup_works() {
@@ -71,7 +72,7 @@ fn place_bid_works() {
 		assert_noop!(Nis::place_bid(RuntimeOrigin::signed(1), 1, 2), Error::<Test>::AmountTooSmall);
 		assert_noop!(
 			Nis::place_bid(RuntimeOrigin::signed(1), 101, 2),
-			BalancesError::<Test>::InsufficientBalance
+			BalancesError::<Test, Instance1>::InsufficientBalance
 		);
 		assert_noop!(
 			Nis::place_bid(RuntimeOrigin::signed(1), 10, 4),
@@ -330,19 +331,32 @@ fn thaw_when_issuance_higher_works() {
 		assert_ok!(Nis::place_bid(RuntimeOrigin::signed(1), 100, 1));
 		Nis::enlarge(100, 1);
 
+		assert_eq!(NisBalances::free_balance(1), 5_250_000);	// (25% of 21m)
+
 		// Everybody else's balances goes up by 50%
 		Balances::make_free_balance_be(&2, 150);
 		Balances::make_free_balance_be(&3, 150);
 		Balances::make_free_balance_be(&4, 150);
 
 		run_to_block(4);
+
+		// Transfer counterpart away...
+		assert_ok!(NisBalances::transfer(RuntimeOrigin::signed(1), 2, 250_000));
+		// ...and it's not thawable.
+		assert_noop!(Nis::thaw(RuntimeOrigin::signed(1), 0), TokenError::NoFunds);
+
+		// Transfer counterpart back...
+		assert_ok!(NisBalances::transfer(RuntimeOrigin::signed(2), 1, 250_000));
+		// ...and it is.
 		assert_ok!(Nis::thaw(RuntimeOrigin::signed(1), 0));
 
 		assert_eq!(Balances::free_balance(1), 150);
 		assert_eq!(Balances::reserved_balance(1), 0);
 	});
 }
 
+// TODO: Partial thawing.
+
 #[test]
 fn thaw_with_ignored_issuance_works() {
 	new_test_ext().execute_with(|| {

frame/support/src/traits.rs

@@ -25,7 +25,7 @@ pub use tokens::{
 		Currency, LockIdentifier, LockableCurrency, NamedReservableCurrency, ReservableCurrency,
 		TotalIssuanceOf, VestingSchedule,
 	},
-	fungible, fungibles,
+	fungible, fungibles, nonfungible, nonfungibles,
 	imbalance::{Imbalance, OnUnbalanced, SignedImbalance},
 	BalanceStatus, ExistenceRequirement, Locker, WithdrawReasons,
 };

frame/support/src/traits/tokens/fungible.rs

@@ -77,7 +77,7 @@ pub trait Mutate<AccountId>: Inspect<AccountId> {
 	/// is returned and nothing is changed. If successful, the amount of tokens reduced is returned.
 	///
 	/// The default implementation just uses `withdraw` along with `reducible_balance` to ensure
-	/// that is doesn't fail.
+	/// that it doesn't fail.
 	fn slash(who: &AccountId, amount: Self::Balance) -> Result<Self::Balance, DispatchError> {
 		Self::burn_from(who, Self::reducible_balance(who, false).min(amount))
 	}