pallet-simple-staking

Cargo.toml

@@ -4,7 +4,7 @@ panic = 'unwind'
 [workspace]
 members = [
 	'node',
-	'pallets/template',
+	'pallets/simple-staking',
 	'runtime/statemint',
 	'runtime/statemine',
 ]

pallets/template/Cargo.toml → pallets/simple-staking/Cargo.toml

@@ -4,7 +4,7 @@ description = 'FRAME pallet template for defining custom runtime logic.'
 edition = '2018'
 homepage = 'https://substrate.dev'
 license = 'Unlicense'
-name = 'pallet-template'
+name = 'pallet-simple-staking'
 readme = 'README.md'
 repository = 'https://github.com/paritytech/substrate/'
 version = '3.0.0'
@@ -20,6 +20,7 @@ std = [
 	'frame-support/std',
 	'frame-system/std',
 	'frame-benchmarking/std',
+	'sp-runtime/std',
 ]
 
 [dependencies.codec]
@@ -28,6 +29,12 @@ features = ['derive']
 package = 'parity-scale-codec'
 version = '2.0.0'
 
+[dev-dependencies.pallet-balances]
+default-features = false
+git = 'https://github.com/paritytech/substrate.git'
+branch = 'rococo-v1'
+version = '3.0.0'
+
 [dependencies.frame-benchmarking]
 default-features = false
 optional = true

pallets/template/src/benchmarking.rs → pallets/simple-staking/src/benchmarking.rs

@@ -3,7 +3,7 @@
 use super::*;
 
 #[allow(unused)]
-use crate::Module as Template;
+use crate::Module as simple_staking;
 use frame_benchmarking::{benchmarks, impl_benchmark_test_suite, whitelisted_caller};
 use frame_system::RawOrigin;
 
@@ -17,4 +17,4 @@ benchmarks! {
 	}
 }
 
-impl_benchmark_test_suite!(Template, crate::mock::new_test_ext(), crate::mock::Test,);
+impl_benchmark_test_suite!(simple_staking, crate::mock::new_test_ext(), crate::mock::Test,);

pallets/simple-staking/src/lib.rs

@@ -0,0 +1,161 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+/// Edit this file to define custom logic or remove it if it is not needed.
+/// Learn more about FRAME and the core library of Substrate FRAME pallets:
+/// <https://substrate.dev/docs/en/knowledgebase/runtime/frame>
+pub use pallet::*;
+
+#[cfg(test)]
+mod mock;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::{dispatch::DispatchResultWithPostInfo, pallet_prelude::*, traits::{Currency, ReservableCurrency, Vec}};
+	use frame_system::{pallet_prelude::*, ensure_root};
+	use frame_system::Config as SystemConfig;
+	use frame_support::sp_runtime::{RuntimeDebug};
+	/// Configure the pallet by specifying the parameters and types on which it depends.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Because this pallet emits events, it depends on the runtime's definition of an event.
+		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
+		/// The currency mechanism.
+		type Currency: ReservableCurrency<Self::AccountId>;
+	}
+	type BalanceOf<T> = <<T as Config>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance;
+
+
+	#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug)]
+	pub struct AuthorInfo<AccountId, Balance, BlockNumber> {
+		pub who: AccountId,
+		pub deposit: Balance,
+		pub last_block: BlockNumber
+	}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(_);
+
+	// The pallet's runtime storage items.
+	// https://substrate.dev/docs/en/knowledgebase/runtime/storage
+
+	#[pallet::storage]
+	#[pallet::getter(fn invulnerables)]
+	pub type Invulnerables<T: Config>= StorageValue<_, Vec<T::AccountId>>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn authors)]
+	pub type Authors<T: Config> = StorageValue<_, Vec<AuthorInfo<T::AccountId, BalanceOf<T>, T::BlockNumber>>, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn max_authors)]
+	pub type MaxAuthors<T> = StorageValue<_, u32>; 
+
+	#[pallet::storage]
+	#[pallet::getter(fn authority_bond)]
+	pub type AuthorityBond<T: Config>= StorageValue<_, BalanceOf<T>>;
+
+
+	#[pallet::event]
+	#[pallet::metadata(T::AccountId = "AccountId")]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Event documentation should end with an array that provides descriptive names for event
+		/// parameters. [something, who]
+		NewInvulnerables(Vec<T::AccountId>),
+		NewMaxAuthorCount(u32),
+		AuthorAdded(T::AccountId, BalanceOf<T>),
+		AuthorRemoved(T::AccountId)
+	}
+
+	// Errors inform users that something went wrong.
+	#[pallet::error]
+	pub enum Error<T> {
+		MaxAuthors,
+		Unknown,
+		Permission,
+		AlreadyAuthor,
+		NotAuthor
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		//TODO on init (or finalize) add to aura set at next era 
+		//TODO split half the pot to the author per block
+	}
+
+	// Dispatchable functions allows users to interact with the pallet and invoke state changes.
+	// These functions materialize as "extrinsics", which are often compared to transactions.
+	// Dispatchable functions must be annotated with a weight and must return a DispatchResult.
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+
+
+		#[pallet::weight(10_000)]
+		pub fn set_invulnerables(origin: OriginFor<T>, new: Vec<T::AccountId>) -> DispatchResultWithPostInfo {
+			//TODO chose protective scheme requires message from relay chain 
+			ensure_root(origin)?;
+			<Invulnerables<T>>::put(&new);
+			Self::deposit_event(Event::NewInvulnerables(new));
+			Ok(().into())
+		}
+
+		#[pallet::weight(10_000)]
+		pub fn set_max_author_count(origin: OriginFor<T>, max_authors: u32) -> DispatchResultWithPostInfo {
+			//TODO chose protective scheme requires message from relay chain 
+			ensure_root(origin)?;
+			<MaxAuthors<T>>::put(&max_authors);
+			Self::deposit_event(Event::NewMaxAuthorCount(max_authors));
+			Ok(().into())
+
+		}
+
+		#[pallet::weight(10_000)]
+		pub fn author_intent(origin: OriginFor<T>, deposit: BalanceOf<T>) -> DispatchResultWithPostInfo {
+			// lock deposit to start or require min?
+			let who = ensure_signed(origin)?;
+			let length = match <Authors<T>>::decode_len() {
+				Some(len) => len,
+				None => 0
+			};
+			ensure!(length + 1 <= MaxAuthors::<T>::get().ok_or(Error::<T>::MaxAuthors)? as usize, Error::<T>::MaxAuthors); 
+			let new_author = AuthorInfo {
+				who: who.clone(), 
+				deposit, 
+				last_block: frame_system::Pallet::<T>::block_number()
+			};
+			<Authors<T>>::try_mutate(|authors| -> DispatchResult {
+				let exists = authors.into_iter().any(|author| author.who == who);
+				match exists {
+					false => {
+						T::Currency::reserve(&who, deposit)?;
+						Ok(authors.push(new_author))
+					},
+					true => Err(Error::<T>::AlreadyAuthor)?,
+				}
+			})?;
+			Self::deposit_event(Event::AuthorAdded(who, deposit));
+			Ok(().into())
+		}
+
+		#[pallet::weight(10_000)]
+		pub fn leave_intent(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			<Authors<T>>::try_mutate(|authors| -> DispatchResult {
+				let index = authors.iter().position(|author| author.who == who).ok_or(Error::<T>::NotAuthor)?;
+				T::Currency::unreserve(&who, authors[index].deposit);
+				authors.remove(index);
+				Ok(())
+			})?;
+			Self::deposit_event(Event::AuthorRemoved(who));
+			Ok(().into())
+
+		}
+	}
+}

pallets/template/src/mock.rs → pallets/simple-staking/src/mock.rs

@@ -1,4 +1,5 @@
-use crate as pallet_template;
+use super::*;
+use crate as simple_staking;
 use sp_core::H256;
 use frame_support::parameter_types;
 use sp_runtime::{
@@ -17,7 +18,8 @@ frame_support::construct_runtime!(
 		UncheckedExtrinsic = UncheckedExtrinsic,
 	{
 		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
-		TemplateModule: pallet_template::{Pallet, Call, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		SimpleStaking: simple_staking::{Pallet, Call, Storage, Event<T>},
 	}
 );
 
@@ -44,18 +46,43 @@ impl system::Config for Test {
 	type BlockHashCount = BlockHashCount;
 	type Version = ();
 	type PalletInfo = PalletInfo;
-	type AccountData = ();
+	type AccountData = pallet_balances::AccountData<u64>;
 	type OnNewAccount = ();
 	type OnKilledAccount = ();
 	type SystemWeightInfo = ();
 	type SS58Prefix = SS58Prefix;
 }
 
-impl pallet_template::Config for Test {
+parameter_types! {
+	pub const ExistentialDeposit: u64 = 1;
+}
+
+impl pallet_balances::Config for Test {
+	type Balance = u64;
 	type Event = Event;
+	type DustRemoval = ();
+	type ExistentialDeposit = ExistentialDeposit;
+	type AccountStore = System;
+	type WeightInfo = ();
+	type MaxLocks = ();
 }
 
-// Build genesis storage according to the mock runtime.
-pub fn new_test_ext() -> sp_io::TestExternalities {
-	system::GenesisConfig::default().build_storage::<Test>().unwrap().into()
+impl Config for Test {
+	type Event = Event;
+	type Currency = Balances;
 }
+
+const A: u64 = 1;
+const B: u64 = 2;
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::default().build_storage::<Test>().unwrap();
+	let genesis = pallet_balances::GenesisConfig::<Test> {
+		balances: vec![
+			(A, 100),
+			(B, 200),
+		],
+	};
+	genesis.assimilate_storage(&mut t).unwrap();
+	t.into()
+}