#[derive(Clone, Encode, Decode, RuntimeDebug, TypeInfo)]

	pub fn from_owner(owner: A) -> Self {

		Bond {

			owner,

			amount: B::default(),

		}

	}

	fn cmp(&self, other: &Self) -> Ordering {

		self.owner.cmp(&other.owner)

	}

	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {

		Some(self.cmp(other))

	}

	fn eq(&self, other: &Self) -> bool {

		self.owner == other.owner

	}

#[derive(Copy, Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]

	/// Committed to be online and producing valid blocks (not equivocating)

	/// Temporarily inactive and excused for inactivity

#[derive(Clone, Encode, Decode, RuntimeDebug, TypeInfo)]

#[derive(Encode, Decode, RuntimeDebug, TypeInfo)]

	fn eq(&self, other: &Self) -> bool {

		let must_be_true = self.bond == other.bond && self.total == other.total;

		if !must_be_true {

		}

		) in self.delegations.iter().zip(other.delegations.iter())

		true

	}

#[derive(Clone, Default, Encode, Decode, RuntimeDebug, TypeInfo)]

#[derive(PartialEq, Clone, Copy, Encode, Decode, RuntimeDebug, TypeInfo)]

#[derive(Clone, Encode, Decode, RuntimeDebug, TypeInfo)]

	fn default() -> Delegations<A, B> {

		Delegations {

			delegations: Vec::new(),

			total: B::default(),

		}

	}

	pub fn sort_greatest_to_least(&mut self) {

		self.delegations.sort_by(|a, b| b.amount.cmp(&a.amount));

	}

	pub fn insert_sorted_greatest_to_least(&mut self, delegation: Bond<AccountId, Balance>) {

		self.total = self.total.saturating_add(delegation.amount);

		// if delegations nonempty && last_element == delegation.amount => push input and return

		if !self.delegations.is_empty() {

			if self.delegations[self.delegations.len() - 1].amount == delegation.amount {

				self.delegations.push(delegation);

				// early return

				return;

			}

		}

		match self

			.delegations

			.binary_search_by(|x| delegation.amount.cmp(&x.amount))

			Ok(i) => {

				let mut new_index = i + 1;

				while new_index <= (self.delegations.len() - 1) {

					if self.delegations[new_index].amount == delegation.amount {

						self.delegations.insert(new_index, delegation);

						return;

			Err(i) => self.delegations.insert(i, delegation),

	}

	pub fn top_capacity<T: Config>(&self) -> CapacityStatus {

		match &self.delegations {

			x if x.len() as u32 >= T::MaxTopDelegationsPerCandidate::get() => CapacityStatus::Full,

			x if x.is_empty() => CapacityStatus::Empty,

			_ => CapacityStatus::Partial,

	}

	pub fn bottom_capacity<T: Config>(&self) -> CapacityStatus {

		match &self.delegations {

			x if x.len() as u32 >= T::MaxBottomDelegationsPerCandidate::get() => {

				CapacityStatus::Full

			x if x.is_empty() => CapacityStatus::Empty,

			_ => CapacityStatus::Partial,

	}

	pub fn lowest_delegation_amount(&self) -> Balance {

		self.delegations

			.last()

			.map(|x| x.amount)

			.unwrap_or(Balance::zero())

	}

	pub fn highest_delegation_amount(&self) -> Balance {

		self.delegations

			.first()

			.map(|x| x.amount)

			.unwrap_or(Balance::zero())

	}

#[derive(PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]

	/// Reached capacity

	/// Empty aka contains no delegations

	/// Partially full (nonempty and not full)

#[derive(Encode, Decode, RuntimeDebug, TypeInfo)]

	pub fn new(bond: Balance) -> Self {

		CandidateMetadata {

			bond,

			delegation_count: 0u32,

			total_counted: bond,

			lowest_top_delegation_amount: Zero::zero(),

			highest_bottom_delegation_amount: Zero::zero(),

			lowest_bottom_delegation_amount: Zero::zero(),

			top_capacity: CapacityStatus::Empty,

			bottom_capacity: CapacityStatus::Empty,

			request: None,

			status: CollatorStatus::Active,

		}

	}

	pub fn is_active(&self) -> bool {

		matches!(self.status, CollatorStatus::Active)

	}

	pub fn is_leaving(&self) -> bool {

		matches!(self.status, CollatorStatus::Leaving(_))

	}

	pub fn schedule_leave<T: Config>(&mut self) -> Result<(RoundIndex, RoundIndex), DispatchError> {

		ensure!(!self.is_leaving(), Error::<T>::CandidateAlreadyLeaving);

		let now = <Round<T>>::get().current;

		let when = now + T::LeaveCandidatesDelay::get();

		self.status = CollatorStatus::Leaving(when);

		Ok((now, when))

	}

	pub fn can_leave<T: Config>(&self) -> DispatchResult {

		if let CollatorStatus::Leaving(when) = self.status {

			ensure!(

				<Round<T>>::get().current >= when,

				Error::<T>::CandidateCannotLeaveYet

			Ok(())

	}

	pub fn go_offline(&mut self) {

		self.status = CollatorStatus::Idle;

	}

	pub fn go_online(&mut self) {

		self.status = CollatorStatus::Active;

	}

	pub fn bond_more<T: Config>(&mut self, who: T::AccountId, more: Balance) -> DispatchResult

	where

		BalanceOf<T>: From<Balance>,

	{

		ensure!(

			<Pallet<T>>::get_collator_stakable_free_balance(&who) >= more.into(),

		let new_total = <Total<T>>::get().saturating_add(more.into());

		<Total<T>>::put(new_total);

		self.bond = self.bond.saturating_add(more);

		// Freeze the total new amount (current + additional)

		<Pallet<T>>::freeze_extended(&who.clone(), self.bond.into(), true)

			.map_err(|_| DispatchError::from(Error::<T>::InsufficientBalance))?;

		self.total_counted = self.total_counted.saturating_add(more);

		<Pallet<T>>::deposit_event(Event::CandidateBondedMore {

			candidate: who.clone(),

			amount: more.into(),

			new_total_bond: self.bond.into(),

		});

		Ok(())

	}

	pub fn bond_less<T: Config>(&mut self, who: T::AccountId, amount: Balance) -> DispatchResult

	where

		BalanceOf<T>: From<Balance>,

	{

		let new_total_staked = <Total<T>>::get().saturating_sub(amount.into());

		<Total<T>>::put(new_total_staked);

		self.bond = self.bond.saturating_sub(amount);

		// Update the freeze to the new total amount

		if self.bond.is_zero() {

			<Pallet<T>>::freeze_extended(&who, self.bond.into(), true)?;

		self.total_counted = self.total_counted.saturating_sub(amount);

		let event = Event::CandidateBondedLess {

			candidate: who.clone(),

			amount: amount.into(),

			new_bond: self.bond.into(),

		};

		// update candidate pool value because it must change if self bond changes

		if self.is_active() {

			Pallet::<T>::update_active(who, self.total_counted.into());

		}

		Pallet::<T>::deposit_event(event);

		Ok(())

	}

	pub fn schedule_bond_less<T: Config>(

		&mut self,

		less: Balance,

	) -> Result<RoundIndex, DispatchError>

	where

		BalanceOf<T>: Into<Balance>,

	{

		// ensure no pending request

		ensure!(

			self.request.is_none(),

			Error::<T>::PendingCandidateRequestAlreadyExists

		ensure!(self.bond > less, Error::<T>::CandidateBondBelowMin);

		ensure!(

			self.bond - less >= T::MinCandidateStk::get().into(),

			Error::<T>::CandidateBondBelowMin

		let when_executable = <Round<T>>::get().current + T::CandidateBondLessDelay::get();

		self.request = Some(CandidateBondLessRequest {

			amount: less,

			when_executable,

		});

		Ok(when_executable)

	}

	pub fn execute_bond_less<T: Config>(&mut self, who: T::AccountId) -> DispatchResult

	where

		BalanceOf<T>: From<Balance>,

	{

		let request = self

			.request

			.ok_or(Error::<T>::PendingCandidateRequestsDNE)?;

		ensure!(

			request.when_executable <= <Round<T>>::get().current,

		self.bond_less::<T>(who.clone(), request.amount)?;

		self.request = None;

		Ok(())

	}

	pub fn cancel_bond_less<T: Config>(&mut self, who: T::AccountId) -> DispatchResult

	where

		BalanceOf<T>: From<Balance>,

	{

		let request = self

			.request

			.ok_or(Error::<T>::PendingCandidateRequestsDNE)?;

		let event = Event::CancelledCandidateBondLess {

			candidate: who.clone().into(),

			amount: request.amount.into(),

			execute_round: request.when_executable,

		};

		self.request = None;

		Pallet::<T>::deposit_event(event);

		Ok(())

	}

	pub fn reset_top_data<T: Config>(

		&mut self,

		candidate: T::AccountId,

		top_delegations: &Delegations<T::AccountId, BalanceOf<T>>,

	) where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		self.lowest_top_delegation_amount = top_delegations.lowest_delegation_amount().into();

		self.top_capacity = top_delegations.top_capacity::<T>();

		let old_total_counted = self.total_counted;

		self.total_counted = self.bond.saturating_add(top_delegations.total.into());

		// CandidatePool value for candidate always changes if top delegations total changes

		// so we moved the update into this function to deduplicate code and patch a bug that

		// forgot to apply the update when increasing top delegation

		if old_total_counted != self.total_counted && self.is_active() {

			Pallet::<T>::update_active(candidate, self.total_counted.into());

		}

	}

	pub fn reset_bottom_data<T: Config>(

		&mut self,

		bottom_delegations: &Delegations<T::AccountId, BalanceOf<T>>,

	) where

		BalanceOf<T>: Into<Balance>,

	{

		self.lowest_bottom_delegation_amount = bottom_delegations.lowest_delegation_amount().into();

		self.highest_bottom_delegation_amount =

			bottom_delegations.highest_delegation_amount().into();

		self.bottom_capacity = bottom_delegations.bottom_capacity::<T>();

	}

	pub fn add_delegation<T: Config>(

		&mut self,

		candidate: &T::AccountId,

		delegation: Bond<T::AccountId, BalanceOf<T>>,

	) -> Result<(DelegatorAdded<Balance>, Option<Balance>), DispatchError>

	where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		let mut less_total_staked = None;

		let delegator_added = match self.top_capacity {

				if self.lowest_top_delegation_amount < delegation.amount.into() {

					less_total_staked = self.add_top_delegation::<T>(candidate, delegation);

					DelegatorAdded::AddedToTop {

						new_total: self.total_counted,

					}

					if matches!(self.bottom_capacity, CapacityStatus::Full) {

						ensure!(

							delegation.amount.into() > self.lowest_bottom_delegation_amount,

							Error::<T>::CannotDelegateLessThanOrEqualToLowestBottomWhenFull

						less_total_staked = Some(self.lowest_bottom_delegation_amount);

					}

					self.add_bottom_delegation::<T>(false, candidate, delegation);

					DelegatorAdded::AddedToBottom

				self.add_top_delegation::<T>(candidate, delegation);

				DelegatorAdded::AddedToTop {

					new_total: self.total_counted,

				}

		Ok((delegator_added, less_total_staked))

	}

	pub fn add_top_delegation<T: Config>(

		&mut self,

		candidate: &T::AccountId,

		delegation: Bond<T::AccountId, BalanceOf<T>>,

	) -> Option<Balance>

	where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		let mut less_total_staked = None;

		let mut top_delegations = <TopDelegations<T>>::get(candidate)

			.expect("CandidateInfo existence => TopDelegations existence");

		let max_top_delegations_per_candidate = T::MaxTopDelegationsPerCandidate::get();

		if top_delegations.delegations.len() as u32 == max_top_delegations_per_candidate {

			let new_bottom_delegation = top_delegations.delegations.pop().expect("");

			top_delegations.total = top_delegations

				.total

				.saturating_sub(new_bottom_delegation.amount);

			if matches!(self.bottom_capacity, CapacityStatus::Full) {

				less_total_staked = Some(self.lowest_bottom_delegation_amount);

			}

			self.add_bottom_delegation::<T>(true, candidate, new_bottom_delegation);

		}

		top_delegations.insert_sorted_greatest_to_least(delegation);

		// update candidate info

		self.reset_top_data::<T>(candidate.clone(), &top_delegations);

		if less_total_staked.is_none() {

			// only increment delegation count if we are not kicking a bottom delegation

			self.delegation_count = self.delegation_count.saturating_add(1u32);

		}

		<TopDelegations<T>>::insert(&candidate, top_delegations);

		less_total_staked

	}

	pub fn add_bottom_delegation<T: Config>(

		&mut self,

		bumped_from_top: bool,

		candidate: &T::AccountId,

		delegation: Bond<T::AccountId, BalanceOf<T>>,

	) where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		let mut bottom_delegations = <BottomDelegations<T>>::get(candidate)

			.expect("CandidateInfo existence => BottomDelegations existence");

		let increase_delegation_count = if bottom_delegations.delegations.len() as u32

			== T::MaxBottomDelegationsPerCandidate::get()

			let lowest_bottom_to_be_kicked = bottom_delegations

				.delegations

				.pop()

				.expect("if at full capacity (>0), then >0 bottom delegations exist; qed");

			// EXPECT lowest_bottom_to_be_kicked.amount < delegation.amount enforced by caller

			// if lowest_bottom_to_be_kicked.amount == delegation.amount, we will still kick

			// the lowest bottom to enforce first come first served

			bottom_delegations.total = bottom_delegations

				.total

				.saturating_sub(lowest_bottom_to_be_kicked.amount);

			// update delegator state

			// total staked is updated via propagation of lowest bottom delegation amount prior

			// to call

			let mut delegator_state = <DelegatorState<T>>::get(&lowest_bottom_to_be_kicked.owner)

				.expect("Delegation existence => DelegatorState existence");

			let leaving = delegator_state.delegations.0.len() == 1usize;

			delegator_state.rm_delegation::<T>(candidate);

			<Pallet<T>>::delegation_remove_request_with_state(

				&candidate,

				&lowest_bottom_to_be_kicked.owner,

				&mut delegator_state,

			);

			<AutoCompoundDelegations<T>>::remove_auto_compound(

				&candidate,

				&lowest_bottom_to_be_kicked.owner,

			);

			Pallet::<T>::deposit_event(Event::DelegationKicked {

				delegator: lowest_bottom_to_be_kicked.owner.clone(),

				candidate: candidate.clone(),

				unstaked_amount: lowest_bottom_to_be_kicked.amount,

			});

			if leaving {

				<DelegatorState<T>>::remove(&lowest_bottom_to_be_kicked.owner);

				Pallet::<T>::deposit_event(Event::DelegatorLeft {

					delegator: lowest_bottom_to_be_kicked.owner,

					unstaked_amount: lowest_bottom_to_be_kicked.amount,

				});

			} else {

				<DelegatorState<T>>::insert(&lowest_bottom_to_be_kicked.owner, delegator_state);

			}

			false

			!bumped_from_top

		if increase_delegation_count {

			self.delegation_count = self.delegation_count.saturating_add(1u32);

		}

		bottom_delegations.insert_sorted_greatest_to_least(delegation);

		self.reset_bottom_data::<T>(&bottom_delegations);

		<BottomDelegations<T>>::insert(candidate, bottom_delegations);

	}

	pub fn rm_delegation_if_exists<T: Config>(

		&mut self,

		candidate: &T::AccountId,

		delegator: T::AccountId,

		amount: Balance,

	) -> Result<bool, DispatchError>

	where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		let amount_geq_lowest_top = amount >= self.lowest_top_delegation_amount;

		let top_is_not_full = !matches!(self.top_capacity, CapacityStatus::Full);

		let lowest_top_eq_highest_bottom =

			self.lowest_top_delegation_amount == self.highest_bottom_delegation_amount;

		let delegation_dne_err: DispatchError = Error::<T>::DelegationDNE.into();

		if top_is_not_full || (amount_geq_lowest_top && !lowest_top_eq_highest_bottom) {

			self.rm_top_delegation::<T>(candidate, delegator)

	}

	pub fn rm_top_delegation<T: Config>(

		&mut self,

		candidate: &T::AccountId,

		delegator: T::AccountId,

	) -> Result<bool, DispatchError>

	where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		let old_total_counted = self.total_counted;

		// remove top delegation

		let mut top_delegations = <TopDelegations<T>>::get(candidate)

			.expect("CandidateInfo exists => TopDelegations exists");

		let mut actual_amount_option: Option<BalanceOf<T>> = None;

		top_delegations.delegations = top_delegations

			.delegations

			.clone()

			.into_iter()

			.filter(|d| {

				if d.owner != delegator {

					true

					actual_amount_option = Some(d.amount);

					false

			})

			.collect();

		let actual_amount = actual_amount_option.ok_or(Error::<T>::DelegationDNE)?;

		top_delegations.total = top_delegations.total.saturating_sub(actual_amount);

		if !matches!(self.bottom_capacity, CapacityStatus::Empty) {

		}

		self.reset_top_data::<T>(candidate.clone(), &top_delegations);

		self.delegation_count = self.delegation_count.saturating_sub(1u32);

		<TopDelegations<T>>::insert(candidate, top_delegations);

		// return whether total counted changed

		Ok(old_total_counted == self.total_counted)

	}

	pub fn increase_delegation<T: Config>(

		&mut self,

		candidate: &T::AccountId,

		delegator: T::AccountId,

		bond: BalanceOf<T>,

		more: BalanceOf<T>,

	) -> Result<bool, DispatchError>

	where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		let lowest_top_eq_highest_bottom =

			self.lowest_top_delegation_amount == self.highest_bottom_delegation_amount;

		let bond_geq_lowest_top = bond.into() >= self.lowest_top_delegation_amount;

		let delegation_dne_err: DispatchError = Error::<T>::DelegationDNE.into();

		if bond_geq_lowest_top && !lowest_top_eq_highest_bottom {

			self.increase_top_delegation::<T>(candidate, delegator.clone(), more)

		} else if bond_geq_lowest_top && lowest_top_eq_highest_bottom {

			self.increase_bottom_delegation::<T>(candidate, delegator, bond, more)

	}

	pub fn increase_top_delegation<T: Config>(

		&mut self,

		candidate: &T::AccountId,

		delegator: T::AccountId,

		more: BalanceOf<T>,

	) -> Result<bool, DispatchError>

	where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		let mut top_delegations = <TopDelegations<T>>::get(candidate)

			.expect("CandidateInfo exists => TopDelegations exists");

		let mut in_top = false;

		top_delegations.delegations = top_delegations

			.delegations

			.clone()

			.into_iter()

			.map(|d| {

				if d.owner != delegator {

					d

					in_top = true;

					let new_amount = d.amount.saturating_add(more);

					Bond {

						owner: d.owner,

						amount: new_amount,

					}

			})

			.collect();

		ensure!(in_top, Error::<T>::DelegationDNE);

		top_delegations.total = top_delegations.total.saturating_add(more);

		top_delegations.sort_greatest_to_least();

		self.reset_top_data::<T>(candidate.clone(), &top_delegations);

		<TopDelegations<T>>::insert(candidate, top_delegations);

		Ok(true)

	}

	pub fn increase_bottom_delegation<T: Config>(

		&mut self,

		candidate: &T::AccountId,

		delegator: T::AccountId,

		bond: BalanceOf<T>,

		more: BalanceOf<T>,

	) -> Result<bool, DispatchError>

	where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		let mut bottom_delegations =

			<BottomDelegations<T>>::get(candidate).ok_or(Error::<T>::CandidateDNE)?;

		let mut delegation_option: Option<Bond<T::AccountId, BalanceOf<T>>> = None;

		let in_top_after = if (bond.saturating_add(more)).into() > self.lowest_top_delegation_amount

			bottom_delegations.delegations = bottom_delegations

				.delegations

				.clone()

				.into_iter()

				.filter(|d| {

					if d.owner != delegator {

						true

						delegation_option = Some(Bond {

							owner: d.owner.clone(),

							amount: d.amount.saturating_add(more),

						});

						false

				})

				.collect();

			let delegation = delegation_option.ok_or(Error::<T>::DelegationDNE)?;

			bottom_delegations.total = bottom_delegations.total.saturating_sub(bond);

			// add it to top

			let mut top_delegations = <TopDelegations<T>>::get(candidate)

				.expect("CandidateInfo existence => TopDelegations existence");

			if matches!(top_delegations.top_capacity::<T>(), CapacityStatus::Full) {

				// pop lowest top delegation

				let new_bottom_delegation = top_delegations

					.delegations

					.pop()

					.expect("Top capacity full => Exists at least 1 top delegation");

				top_delegations.total = top_delegations

					.total

					.saturating_sub(new_bottom_delegation.amount);

				bottom_delegations.insert_sorted_greatest_to_least(new_bottom_delegation);

			}

			top_delegations.insert_sorted_greatest_to_least(delegation);

			self.reset_top_data::<T>(candidate.clone(), &top_delegations);

			<TopDelegations<T>>::insert(candidate, top_delegations);

			true

			let mut in_bottom = false;

			// just increase the delegation

			bottom_delegations.delegations = bottom_delegations

				.delegations

				.clone()

				.into_iter()

				.map(|d| {

					if d.owner != delegator {

						d

						in_bottom = true;

						Bond {

							owner: d.owner,

							amount: d.amount.saturating_add(more),

						}

				})

				.collect();

			ensure!(in_bottom, Error::<T>::DelegationDNE);

			bottom_delegations.total = bottom_delegations.total.saturating_add(more);

			bottom_delegations.sort_greatest_to_least();

			false

		self.reset_bottom_data::<T>(&bottom_delegations);

		<BottomDelegations<T>>::insert(candidate, bottom_delegations);

		Ok(in_top_after)

	}

	pub fn decrease_delegation<T: Config>(

		&mut self,

		candidate: &T::AccountId,

		delegator: T::AccountId,

		bond: Balance,

		less: BalanceOf<T>,

	) -> Result<bool, DispatchError>

	where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		let lowest_top_eq_highest_bottom =

			self.lowest_top_delegation_amount == self.highest_bottom_delegation_amount;

		let bond_geq_lowest_top = bond >= self.lowest_top_delegation_amount;

		let delegation_dne_err: DispatchError = Error::<T>::DelegationDNE.into();

		if bond_geq_lowest_top && !lowest_top_eq_highest_bottom {

			self.decrease_top_delegation::<T>(candidate, delegator.clone(), bond.into(), less)

		} else if bond_geq_lowest_top && lowest_top_eq_highest_bottom {

			let result =

				self.decrease_top_delegation::<T>(candidate, delegator.clone(), bond.into(), less);

			if result == Err(delegation_dne_err) {

				result

			self.decrease_bottom_delegation::<T>(candidate, delegator, less)

	}

	pub fn decrease_top_delegation<T: Config>(

		&mut self,

		candidate: &T::AccountId,

		delegator: T::AccountId,

		bond: BalanceOf<T>,

		less: BalanceOf<T>,

	) -> Result<bool, DispatchError>

	where

		BalanceOf<T>: Into<Balance> + From<Balance>,

	{

		// The delegation after the `decrease-delegation` will be strictly less than the

		// highest bottom delegation

		let bond_after_less_than_highest_bottom =

			bond.saturating_sub(less).into() < self.highest_bottom_delegation_amount;

		let full_top_and_nonempty_bottom = matches!(self.top_capacity, CapacityStatus::Full)

			&& !matches!(self.bottom_capacity, CapacityStatus::Empty);

		let mut top_delegations =

			<TopDelegations<T>>::get(candidate).ok_or(Error::<T>::CandidateDNE)?;

		let in_top_after = if bond_after_less_than_highest_bottom && full_top_and_nonempty_bottom {

			let mut delegation_option: Option<Bond<T::AccountId, BalanceOf<T>>> = None;

			// take delegation from top

			top_delegations.delegations = top_delegations

				.delegations

				.clone()

				.into_iter()

				.filter(|d| {

					if d.owner != delegator {

						true

						top_delegations.total = top_delegations.total.saturating_sub(d.amount);

						delegation_option = Some(Bond {

							owner: d.owner.clone(),

							amount: d.amount.saturating_sub(less),

						});

						false

				})

				.collect();

			let delegation = delegation_option.ok_or(Error::<T>::DelegationDNE)?;

			let mut bottom_delegations = <BottomDelegations<T>>::get(candidate)

				.expect("CandidateInfo existence => BottomDelegations existence");

			let highest_bottom_delegation = bottom_delegations.delegations.remove(0);

			bottom_delegations.total = bottom_delegations

				.total

				.saturating_sub(highest_bottom_delegation.amount);

			// insert highest bottom into top

			top_delegations.insert_sorted_greatest_to_least(highest_bottom_delegation);

			// insert previous top into bottom

			bottom_delegations.insert_sorted_greatest_to_least(delegation);

			self.reset_bottom_data::<T>(&bottom_delegations);

			<BottomDelegations<T>>::insert(candidate, bottom_delegations);

			false

			let mut is_in_top = false;

			top_delegations.delegations = top_delegations

				.delegations

				.clone()

				.into_iter()

				.map(|d| {

					if d.owner != delegator {

						d

						is_in_top = true;

						Bond {

							owner: d.owner,

							amount: d.amount.saturating_sub(less),

						}

				})

				.collect();

			ensure!(is_in_top, Error::<T>::DelegationDNE);

			top_delegations.total = top_delegations.total.saturating_sub(less);

			top_delegations.sort_greatest_to_least();

			true

		self.reset_top_data::<T>(candidate.clone(), &top_delegations);

		<TopDelegations<T>>::insert(candidate, top_delegations);

		Ok(in_top_after)

	}

	pub fn decrease_bottom_delegation<T: Config>(

		&mut self,

		candidate: &T::AccountId,

		delegator: T::AccountId,

		less: BalanceOf<T>,

	) -> Result<bool, DispatchError>

	where

		BalanceOf<T>: Into<Balance>,

	{

		let mut bottom_delegations = <BottomDelegations<T>>::get(candidate)

			.expect("CandidateInfo exists => BottomDelegations exists");

		let mut in_bottom = false;

		bottom_delegations.delegations = bottom_delegations

			.delegations

			.clone()

			.into_iter()

			.map(|d| {

				if d.owner != delegator {

					in_bottom = true;

					Bond {

						owner: d.owner,

						amount: d.amount.saturating_sub(less),

					}

			})

			.collect();

		ensure!(in_bottom, Error::<T>::DelegationDNE);

		bottom_delegations.sort_greatest_to_least();

		self.reset_bottom_data::<T>(&bottom_delegations);

		<BottomDelegations<T>>::insert(candidate, bottom_delegations);

		Ok(false)

	}

#[derive(Clone, Copy, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo, DecodeWithMemTracking)]

	AddedToBottom,

#[derive(Clone, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]

	/// Active with no scheduled exit

#[derive(Clone, Encode, Decode, RuntimeDebug, TypeInfo)]

	pub fn new(id: AccountId, collator: AccountId, amount: Balance) -> Self {

		Delegator {

			id,

			delegations: OrderedSet::from(vec![Bond {

				owner: collator,

				amount,

			}]),

			total: amount,

			less_total: Balance::zero(),

			status: DelegatorStatus::Active,

		}

	}

	pub fn total(&self) -> Balance {

		self.total

	}

	pub fn total_sub_if<T, F>(&mut self, amount: Balance, check: F) -> DispatchResult

	where

		T: Config,

		T::AccountId: From<AccountId>,

		BalanceOf<T>: From<Balance>,

		F: Fn(Balance) -> DispatchResult,

	{

		let total = self.total.saturating_sub(amount);

		check(total)?;

		self.total = total;

		self.adjust_bond_lock::<T>(BondAdjust::Decrease)?;

		Ok(())

	}

	pub fn total_sub<T>(&mut self, amount: Balance) -> DispatchResult

	where

		T: Config,

		T::AccountId: From<AccountId>,

		BalanceOf<T>: From<Balance>,

	{

		self.total = self.total.saturating_sub(amount);

		self.adjust_bond_lock::<T>(BondAdjust::Decrease)?;

		Ok(())

	}

	pub fn add_delegation(&mut self, bond: Bond<AccountId, Balance>) -> bool {

		let amt = bond.amount;

		if self.delegations.insert(bond) {

			self.total = self.total.saturating_add(amt);

			true

			false

	}

	pub fn rm_delegation<T: Config>(&mut self, collator: &AccountId) -> Option<Balance>

	where

		BalanceOf<T>: From<Balance>,

		T::AccountId: From<AccountId>,

	{

		let mut amt: Option<Balance> = None;

		let delegations = self

			.delegations

			.0

			.iter()

			.filter_map(|x| {

				if &x.owner == collator {

					amt = Some(x.amount);

					None

					Some(x.clone())

			})

			.collect();

		if let Some(balance) = amt {

			self.delegations = OrderedSet::from(delegations);

			self.total_sub::<T>(balance)

				.expect("Decreasing lock cannot fail, qed");

			Some(self.total)

	}

	pub fn increase_delegation<T: Config>(

		&mut self,

		candidate: AccountId,

		amount: Balance,

	) -> Result<bool, sp_runtime::DispatchError>

	where

		BalanceOf<T>: From<Balance>,

		T::AccountId: From<AccountId>,

		Delegator<T::AccountId, BalanceOf<T>>: From<Delegator<AccountId, Balance>>,

	{

		let delegator_id: T::AccountId = self.id.clone().into();

		let candidate_id: T::AccountId = candidate.clone().into();

		let balance_amt: BalanceOf<T> = amount.into();

		for x in &mut self.delegations.0 {

			if x.owner == candidate {

				let before_amount: BalanceOf<T> = x.amount.into();

				x.amount = x.amount.saturating_add(amount);

				self.total = self.total.saturating_add(amount);

				self.adjust_bond_lock::<T>(BondAdjust::Increase(amount))?;

				let mut collator_state =

					<CandidateInfo<T>>::get(&candidate_id).ok_or(Error::<T>::CandidateDNE)?;

				let before = collator_state.total_counted;

				let in_top = collator_state.increase_delegation::<T>(

					&candidate_id,

					delegator_id.clone(),

					before_amount,

					balance_amt,

				)?;

				let after = collator_state.total_counted;

				if collator_state.is_active() && (before != after) {

					Pallet::<T>::update_active(candidate_id.clone(), after);

				}

				<CandidateInfo<T>>::insert(&candidate_id, collator_state);

				let new_total_staked = <Total<T>>::get().saturating_add(balance_amt);

				<Total<T>>::put(new_total_staked);

				let nom_st: Delegator<T::AccountId, BalanceOf<T>> = self.clone().into();

				<DelegatorState<T>>::insert(&delegator_id, nom_st);

				return Ok(in_top);

			}

	}

	pub fn adjust_bond_lock<T: Config>(