inital commit, which is clearly not initial

Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>

runtime/casper/src/impls.rs

@@ -0,0 +1,93 @@
+use super::*;
+use frame_support::{
+    dispatch::DispatchResultWithPostInfo,
+    traits::PrivilegeCmp,
+};
+use pallet_alliance::{ProposalIndex, ProposalProvider};
+use sp_runtime::DispatchError;
+use sp_std::{cmp::Ordering, marker::PhantomData};
+
+type AccountIdOf<T> = <T as frame_system::Config>::AccountId;
+type ProposalOf<T, I> = <T as pallet_collective::Config<I>>::Proposal;
+type HashOf<T> = <T as frame_system::Config>::Hash;
+
+/// Proposal provider for alliance pallet.
+/// Adapter from collective pallet to alliance proposal provider trait.
+pub struct AllianceProposalProvider<T, I = ()>(PhantomData<(T, I)>);
+impl <T, I> ProposalProvider<AccountIdOf<T>, HashOf<T>, ProposalOf<T, I>> for AllianceProposalProvider<T, I>
+where
+    T: pallet_collective::Config<I> + frame_system::Config,
+    I: 'static,
+{
+    fn propose_proposal(
+        who: AccountIdOf<T>,
+        threshold: u32,
+        proposal: Box<ProposalOf<T, I>>,
+        length_bound: u32,
+    ) -> Result<(u32, u32), DispatchError> {
+        pallet_collective::Pallet::<T, I>::do_propose_proposed(who, threshold, proposal, length_bound)
+    }
+
+    fn vote_proposal(
+        who: AccountIdOf<T>,
+        proposal: HashOf<T>,
+        index: ProposalIndex,
+        approve: bool,
+    ) -> Result<bool, DispatchError> {
+        pallet_collective::Pallet::<T, I>::do_vote(who, proposal, index, approve)
+    }
+
+    fn close_proposal(
+        proposal_hash: HashOf<T>,
+        proposal_index: ProposalIndex,
+        proposal_weight_bound: Weight,
+        length_bound: u32,
+    ) -> DispatchResultWithPostInfo {
+        pallet_collective::Pallet::<T, I>::do_close(
+            proposal_hash,
+            proposal_index,
+            proposal_weight_bound,
+            length_bound,
+        )
+    }
+
+    fn proposal_of(proposal_hash: HashOf<T>) -> Option<ProposalOf<T, I>> {
+        pallet_collective::ProposalOf::<T, I>::get(proposal_hash)
+    }
+}
+
+/// Used the compare the privilege of an origin inside the scheduler.
+pub struct EqualOrGreatestRootCmp;
+impl PrivilegeCmp<OriginCaller> for EqualOrGreatestRootCmp {
+    fn cmp_privilege(left: &OriginCaller, right: &OriginCaller) -> Option<Ordering> {
+        if left == right {
+            return Some(Ordering::Equal)
+        }
+
+        match (left, right) {
+            // Root is greater than anything
+            (OriginCaller::system(frame_system::RawOrigin::Root), _) => Some(Ordering::Greater),
+            // For every other we don't care, as they are not used for `ScheduleOrigin`.
+            _ => None,
+        }
+    }
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarks {
+    use super::*;
+    use frame_support::traits::fungible;
+    use pallet_ranked_collective::Rank;
+    use sp_runtime::traits::Convert;
+
+    /// Rank to salary conversion helper type
+    pub struct RankToSalary<Fungible>(PhantomData<Fungible>);
+    impl<Fungible> Convert<Rank, Balance> for RankToSalary<Fungible>
+    where
+        Fungible: fungible::Inspect<AccountId, Balance = Balance>,
+    {
+        fn convert(r: Rank) -> Balance {
+            Balance::from(r).saturating_mul(Fungible::minimum_balance())
+        }
+    }
+}