forked from ghostchain/ghost-node
1342 lines
46 KiB
Rust
1342 lines
46 KiB
Rust
// Ensure we're `no_std` when compiling for Wasm.
|
|
#![cfg_attr(not(feature = "std"), no_std)]
|
|
|
|
use core::usize;
|
|
|
|
use codec::{Decode, Encode, MaxEncodedLen};
|
|
use scale_info::TypeInfo;
|
|
use serde::{Deserialize, Deserializer};
|
|
|
|
use frame_support::{
|
|
pallet_prelude::*,
|
|
traits::{
|
|
Currency, DisabledValidators, Get, OneSessionHandler, ValidatorSet,
|
|
ValidatorSetWithIdentification,
|
|
},
|
|
WeakBoundedVec,
|
|
};
|
|
use frame_system::{
|
|
offchain::{SendTransactionTypes, SubmitTransaction},
|
|
pallet_prelude::*,
|
|
};
|
|
|
|
pub use pallet::*;
|
|
|
|
use sp_core::H256;
|
|
use sp_runtime::{
|
|
offchain::{
|
|
self as rt_offchain,
|
|
storage::StorageValueRef,
|
|
storage_lock::{StorageLock, Time},
|
|
HttpError,
|
|
},
|
|
traits::{BlockNumberProvider, Convert, Saturating, TrailingZeroInput},
|
|
Perbill, RuntimeAppPublic, RuntimeDebug,
|
|
};
|
|
use sp_staking::{
|
|
offence::{Kind, Offence, ReportOffence},
|
|
EraIndex, SessionIndex,
|
|
};
|
|
use sp_std::{collections::btree_map::BTreeMap, prelude::*, vec::Vec};
|
|
|
|
use ghost_traits::exposure::ExposureListener;
|
|
use ghost_networks::{
|
|
NetworkData, NetworkDataBasicHandler, NetworkDataInspectHandler, NetworkDataMutateHandler,
|
|
NetworkType,
|
|
};
|
|
|
|
pub mod weights;
|
|
pub use crate::weights::WeightInfo;
|
|
mod benchmarking;
|
|
mod mock;
|
|
mod tests;
|
|
|
|
mod deserialisations;
|
|
mod evm_types;
|
|
mod bitmap;
|
|
|
|
use evm_types::{EvmResponse, EvmResponseType};
|
|
use bitmap::{Bucket, BitMap};
|
|
|
|
pub mod sr25519 {
|
|
mod app_sr25519 {
|
|
use sp_application_crypto::{app_crypto, sr25519, KeyTypeId};
|
|
const SLOW_CLAP: KeyTypeId = KeyTypeId(*b"slow");
|
|
app_crypto!(sr25519, SLOW_CLAP);
|
|
}
|
|
|
|
sp_application_crypto::with_pair! {
|
|
pub type AuthorityPair = app_sr25519::Pair;
|
|
}
|
|
|
|
pub type AuthoritySignature = app_sr25519::Signature;
|
|
pub type AuthorityId = app_sr25519::Public;
|
|
}
|
|
|
|
const LOG_TARGET: &str = "runtime::ghost-slow-clap";
|
|
const DB_PREFIX: &[u8] = b"slow_clap::";
|
|
|
|
const MIN_LOCK_GUARD_PERIOD: u64 = 15_000;
|
|
const FETCH_TIMEOUT_PERIOD: u64 = 3_000;
|
|
const LOCK_BLOCK_EXPIRATION: u64 = 20;
|
|
|
|
const COMMITMENT_DELAY_MILLIS: u64 = 600_000;
|
|
const ONE_HOUR_MILLIS: u64 = 3_600_000;
|
|
|
|
pub type AuthIndex = u32;
|
|
|
|
#[derive(
|
|
RuntimeDebug,
|
|
Default,
|
|
Copy,
|
|
Clone,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Encode,
|
|
Decode,
|
|
TypeInfo,
|
|
MaxEncodedLen,
|
|
)]
|
|
pub struct CommitmentDetails {
|
|
pub last_stored_block: u64,
|
|
pub last_updated: u64,
|
|
pub commits: u64,
|
|
}
|
|
|
|
#[derive(
|
|
RuntimeDebug, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, TypeInfo, MaxEncodedLen,
|
|
)]
|
|
pub struct BlockCommitment<NetworkId> {
|
|
pub session_index: SessionIndex,
|
|
pub authority_index: AuthIndex,
|
|
pub network_id: NetworkId,
|
|
pub commitment: CommitmentDetails,
|
|
}
|
|
|
|
#[derive(
|
|
RuntimeDebug, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, TypeInfo, MaxEncodedLen,
|
|
)]
|
|
pub struct Clap<AccountId, NetworkId, Balance> {
|
|
pub session_index: SessionIndex,
|
|
pub authority_index: AuthIndex,
|
|
pub transaction_hash: H256,
|
|
pub block_number: u64,
|
|
pub removed: bool,
|
|
pub network_id: NetworkId,
|
|
pub receiver: AccountId,
|
|
pub amount: Balance,
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
|
|
pub struct ApplauseDetail<NetworkId, Balance> {
|
|
pub network_id: NetworkId,
|
|
pub authorities: BitMap,
|
|
pub clapped_amount: Balance,
|
|
pub block_number: u64,
|
|
pub finalized: bool,
|
|
}
|
|
|
|
impl<NetworkId, Balance: Default> ApplauseDetail<NetworkId, Balance> {
|
|
pub fn new(network_id: NetworkId, block_number: u64, max_authorities: usize) -> Self {
|
|
ApplauseDetail {
|
|
network_id,
|
|
block_number,
|
|
finalized: false,
|
|
clapped_amount: Default::default(),
|
|
authorities: BitMap::new(max_authorities as AuthIndex),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default, Clone, Copy, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
|
|
pub struct PreparedApplause<AccountId, NetworkId, Balance> {
|
|
pub network_id: NetworkId,
|
|
pub receiver: AccountId,
|
|
pub amount: Balance,
|
|
pub block_number: u64,
|
|
}
|
|
|
|
#[cfg_attr(test, derive(PartialEq))]
|
|
enum OffchainErr<NetworkId> {
|
|
HttpJsonParsingError,
|
|
HttpBytesParsingError,
|
|
HttpRequestError(HttpError),
|
|
RequestUncompleted,
|
|
HttpResponseNotOk(u16),
|
|
ErrorInEvmResponse,
|
|
NoStoredNetworks,
|
|
NoEndpointAvailable(NetworkId),
|
|
StorageRetrievalError(NetworkId),
|
|
UtxoNotImplemented(NetworkId),
|
|
UnknownNetworkType(NetworkId),
|
|
OffchainTimeoutPeriod(NetworkId),
|
|
}
|
|
|
|
impl<NetworkId: core::fmt::Debug> core::fmt::Debug for OffchainErr<NetworkId> {
|
|
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
match *self {
|
|
OffchainErr::HttpJsonParsingError => {
|
|
write!(fmt, "Failed to parse evm response as JSON.")
|
|
}
|
|
OffchainErr::HttpBytesParsingError => {
|
|
write!(fmt, "Failed to parse evm response as bytes.")
|
|
}
|
|
OffchainErr::HttpRequestError(http_error) => match http_error {
|
|
HttpError::DeadlineReached => write!(
|
|
fmt,
|
|
"Requested action couldn't been completed within a deadline."
|
|
),
|
|
HttpError::IoError => {
|
|
write!(fmt, "There was an IO error while processing the request.")
|
|
}
|
|
HttpError::Invalid => {
|
|
write!(fmt, "The ID of the request is invalid in this context.")
|
|
}
|
|
},
|
|
OffchainErr::StorageRetrievalError(ref network_id) => write!(
|
|
fmt,
|
|
"Storage value found for network #{:?} but it's undecodable.",
|
|
network_id
|
|
),
|
|
OffchainErr::RequestUncompleted => write!(fmt, "Failed to complete request."),
|
|
OffchainErr::HttpResponseNotOk(code) => {
|
|
write!(fmt, "Http response returned code {:?}.", code)
|
|
}
|
|
OffchainErr::ErrorInEvmResponse => write!(fmt, "Error in evm reponse."),
|
|
OffchainErr::NoStoredNetworks => {
|
|
write!(fmt, "No networks stored for the offchain slow claps.")
|
|
}
|
|
OffchainErr::NoEndpointAvailable(ref network_id) => write!(
|
|
fmt,
|
|
"No RPC endpoint available for network #{:?}.",
|
|
network_id
|
|
),
|
|
OffchainErr::UtxoNotImplemented(ref network_id) => write!(
|
|
fmt,
|
|
"Network #{:?} is marked as UTXO, which is not implemented yet.",
|
|
network_id
|
|
),
|
|
OffchainErr::UnknownNetworkType(ref network_id) => {
|
|
write!(fmt, "Unknown type for network #{:?}.", network_id)
|
|
}
|
|
OffchainErr::OffchainTimeoutPeriod(ref network_id) => write!(
|
|
fmt,
|
|
"Offchain request should be in-flight for network #{:?}.",
|
|
network_id
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type NetworkIdOf<T> = <<T as Config>::NetworkDataHandler as NetworkDataBasicHandler>::NetworkId;
|
|
|
|
pub type BalanceOf<T> =
|
|
<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
|
|
|
|
pub type ValidatorId<T> = <<T as Config>::ValidatorSet as ValidatorSet<
|
|
<T as frame_system::Config>::AccountId,
|
|
>>::ValidatorId;
|
|
|
|
pub type IdentificationTuple<T> = (
|
|
ValidatorId<T>,
|
|
<<T as Config>::ValidatorSet as ValidatorSetWithIdentification<
|
|
<T as frame_system::Config>::AccountId,
|
|
>>::Identification,
|
|
);
|
|
|
|
type OffchainResult<T, A> = Result<A, OffchainErr<NetworkIdOf<T>>>;
|
|
|
|
#[frame_support::pallet]
|
|
pub mod pallet {
|
|
use super::*;
|
|
|
|
const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
|
|
|
|
#[pallet::pallet]
|
|
#[pallet::storage_version(STORAGE_VERSION)]
|
|
#[pallet::without_storage_info]
|
|
pub struct Pallet<T>(_);
|
|
|
|
#[pallet::config]
|
|
pub trait Config: SendTransactionTypes<Call<Self>> + frame_system::Config {
|
|
type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
|
|
type AuthorityId: Member
|
|
+ Parameter
|
|
+ RuntimeAppPublic
|
|
+ Ord
|
|
+ MaybeSerializeDeserialize
|
|
+ MaxEncodedLen;
|
|
|
|
type ValidatorSet: ValidatorSetWithIdentification<Self::AccountId>;
|
|
type Currency: Currency<Self::AccountId>;
|
|
type NetworkDataHandler: NetworkDataBasicHandler
|
|
+ NetworkDataInspectHandler<NetworkData>
|
|
+ NetworkDataMutateHandler<NetworkData, BalanceOf<Self>>;
|
|
type BlockNumberProvider: BlockNumberProvider<BlockNumber = BlockNumberFor<Self>>;
|
|
type ReportUnresponsiveness: ReportOffence<
|
|
Self::AccountId,
|
|
IdentificationTuple<Self>,
|
|
SlowClapOffence<IdentificationTuple<Self>>,
|
|
>;
|
|
type DisabledValidators: DisabledValidators;
|
|
type ExposureListener: ExposureListener<BalanceOf<Self>, EraIndex, AuthIndex>;
|
|
|
|
#[pallet::constant]
|
|
type MaxAuthorities: Get<u32>;
|
|
|
|
#[pallet::constant]
|
|
type ApplauseThreshold: Get<u32>;
|
|
|
|
#[pallet::constant]
|
|
type UnsignedPriority: Get<TransactionPriority>;
|
|
|
|
#[pallet::constant]
|
|
type HistoryDepth: Get<SessionIndex>;
|
|
|
|
#[pallet::constant]
|
|
type MinAuthoritiesNumber: Get<u32>;
|
|
|
|
type WeightInfo: WeightInfo;
|
|
}
|
|
|
|
#[pallet::event]
|
|
#[pallet::generate_deposit(pub(super) fn deposit_event)]
|
|
pub enum Event<T: Config> {
|
|
BlackSwan,
|
|
AuthoritiesCommitmentEquilibrium,
|
|
AuthoritiesApplauseEquilibrium,
|
|
SomeAuthoritiesDelayed {
|
|
delayed: Vec<IdentificationTuple<T>>,
|
|
},
|
|
SomeAuthoritiesTrottling {
|
|
throttling: Vec<IdentificationTuple<T>>,
|
|
},
|
|
Clapped {
|
|
authority_id: AuthIndex,
|
|
network_id: NetworkIdOf<T>,
|
|
clap_unique_hash: H256,
|
|
receiver: T::AccountId,
|
|
amount: BalanceOf<T>,
|
|
removed: bool,
|
|
},
|
|
Applaused {
|
|
network_id: NetworkIdOf<T>,
|
|
receiver: T::AccountId,
|
|
received_amount: BalanceOf<T>,
|
|
block_number: u64,
|
|
},
|
|
BlockCommited {
|
|
authority_id: AuthIndex,
|
|
network_id: NetworkIdOf<T>,
|
|
},
|
|
}
|
|
|
|
#[pallet::error]
|
|
pub enum Error<T> {
|
|
NotEnoughClaps,
|
|
AlreadyClapped,
|
|
UnregistedNetwork,
|
|
UnregisteredClapRemove,
|
|
TooMuchAuthorities,
|
|
CouldNotAccumulateCommission,
|
|
CouldNotAccumulateIncomingImbalance,
|
|
CouldNotIncreaseGatekeeperAmount,
|
|
NonExistentAuthorityIndex,
|
|
TimeWentBackwards,
|
|
DisabledAuthority,
|
|
ExecutedBlockIsHigher,
|
|
}
|
|
|
|
#[pallet::storage]
|
|
#[pallet::getter(fn total_exposure)]
|
|
pub(super) type TotalExposure<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
|
|
|
|
#[pallet::storage]
|
|
#[pallet::getter(fn latest_executed_block)]
|
|
pub(super) type LatestExecutedBlock<T: Config> = StorageMap<
|
|
_,
|
|
Twox64Concat,
|
|
NetworkIdOf<T>,
|
|
u64,
|
|
ValueQuery,
|
|
>;
|
|
|
|
#[pallet::storage]
|
|
#[pallet::getter(fn block_commitments)]
|
|
pub(super) type BlockCommitments<T: Config> = StorageMap<
|
|
_,
|
|
Twox64Concat,
|
|
NetworkIdOf<T>,
|
|
BTreeMap<AuthIndex, CommitmentDetails>,
|
|
ValueQuery,
|
|
>;
|
|
|
|
#[pallet::storage]
|
|
#[pallet::getter(fn applause_details)]
|
|
pub(super) type ApplauseDetails<T: Config> = StorageDoubleMap<
|
|
_,
|
|
Twox64Concat,
|
|
SessionIndex,
|
|
Twox64Concat,
|
|
H256,
|
|
ApplauseDetail<NetworkIdOf<T>, BalanceOf<T>>,
|
|
OptionQuery
|
|
>;
|
|
|
|
#[pallet::storage]
|
|
#[pallet::getter(fn disabled_authority_indexes)]
|
|
pub(super) type DisabledAuthorityIndexes<T: Config> = StorageMap<
|
|
_,
|
|
Twox64Concat,
|
|
SessionIndex,
|
|
BitMap,
|
|
OptionQuery,
|
|
>;
|
|
|
|
#[pallet::storage]
|
|
#[pallet::getter(fn authorities)]
|
|
pub(super) type Authorities<T: Config> = StorageMap<
|
|
_,
|
|
Twox64Concat,
|
|
SessionIndex,
|
|
WeakBoundedVec<T::AuthorityId, T::MaxAuthorities>,
|
|
ValueQuery,
|
|
>;
|
|
|
|
#[pallet::storage]
|
|
#[pallet::getter(fn validators)]
|
|
pub(super) type Validators<T: Config> = StorageMap<
|
|
_,
|
|
Twox64Concat,
|
|
SessionIndex,
|
|
WeakBoundedVec<ValidatorId<T>, T::MaxAuthorities>,
|
|
ValueQuery,
|
|
>;
|
|
|
|
#[pallet::genesis_config]
|
|
#[derive(frame_support::DefaultNoBound)]
|
|
pub struct GenesisConfig<T: Config> {
|
|
pub authorities: Vec<T::AuthorityId>,
|
|
}
|
|
|
|
#[pallet::genesis_build]
|
|
impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
|
|
fn build(&self) {
|
|
if !self.authorities.is_empty() {
|
|
Pallet::<T>::initialize_authorities(self.authorities.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
#[pallet::call]
|
|
impl<T: Config> Pallet<T> {
|
|
#[pallet::call_index(0)]
|
|
#[pallet::weight((T::WeightInfo::slow_clap(), DispatchClass::Normal, Pays::No))]
|
|
pub fn slow_clap(
|
|
origin: OriginFor<T>,
|
|
clap: Clap<T::AccountId, NetworkIdOf<T>, BalanceOf<T>>,
|
|
// since signature verification is done in `validate_unsigned`
|
|
// we can skip doing it here again.
|
|
_signature: <T::AuthorityId as RuntimeAppPublic>::Signature,
|
|
) -> DispatchResult {
|
|
ensure_none(origin)?;
|
|
Self::try_slow_clap(&clap)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[pallet::call_index(1)]
|
|
#[pallet::weight((T::WeightInfo::commit_block(), DispatchClass::Normal, Pays::No))]
|
|
pub fn commit_block(
|
|
origin: OriginFor<T>,
|
|
block_commitment: BlockCommitment<NetworkIdOf<T>>,
|
|
// since signature verification is done in `validate_unsigned`
|
|
// we can skip doing it here again.
|
|
_signature: <T::AuthorityId as RuntimeAppPublic>::Signature,
|
|
) -> DispatchResult {
|
|
ensure_none(origin)?;
|
|
Self::try_commit_block(&block_commitment)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[pallet::hooks]
|
|
impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
|
|
fn offchain_worker(now: BlockNumberFor<T>) {
|
|
if let Err(e) = Self::start_slow_clapping(now) {
|
|
log::info!(
|
|
target: LOG_TARGET,
|
|
"👻 Skipping slow clap at {:?}: {:?}",
|
|
now,
|
|
e,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[pallet::validate_unsigned]
|
|
impl<T: Config> ValidateUnsigned for Pallet<T> {
|
|
type Call = Call<T>;
|
|
fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
|
|
match call {
|
|
Call::commit_block { block_commitment, signature } => {
|
|
let session_index = block_commitment.session_index;
|
|
let authority_index = block_commitment.authority_index;
|
|
|
|
match Authorities::<T>::get(&session_index).get(authority_index as usize) {
|
|
Some(authority) => {
|
|
if !block_commitment.using_encoded(|encoded| authority.verify(&encoded, signature)) {
|
|
return InvalidTransaction::BadProof.into();
|
|
}
|
|
},
|
|
None => return InvalidTransaction::BadSigner.into(),
|
|
}
|
|
|
|
ValidTransaction::with_tag_prefix("SlowClap")
|
|
.priority(T::UnsignedPriority::get())
|
|
.and_provides(block_commitment.commitment.encode())
|
|
.longevity(LOCK_BLOCK_EXPIRATION)
|
|
.propagate(true)
|
|
.build()
|
|
}
|
|
Call::slow_clap { clap, signature } => {
|
|
let (session_index, _) = Self::mended_session_index(&clap);
|
|
|
|
match Authorities::<T>::get(&session_index).get(clap.authority_index as usize) {
|
|
Some(authority) => {
|
|
if !clap.using_encoded(|encoded| authority.verify(&encoded, signature)) {
|
|
return InvalidTransaction::BadProof.into();
|
|
}
|
|
},
|
|
None => return InvalidTransaction::BadSigner.into(),
|
|
}
|
|
|
|
ValidTransaction::with_tag_prefix("SlowClap")
|
|
.priority(T::UnsignedPriority::get())
|
|
.and_provides(signature)
|
|
.longevity(LOCK_BLOCK_EXPIRATION)
|
|
.propagate(true)
|
|
.build()
|
|
}
|
|
_ => InvalidTransaction::Call.into(),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Config> Pallet<T> {
|
|
fn create_storage_key(first: &[u8], second: &[u8]) -> Vec<u8> {
|
|
let mut key = DB_PREFIX.to_vec();
|
|
key.extend(first);
|
|
key.extend(second);
|
|
key
|
|
}
|
|
|
|
fn read_persistent_offchain_storage<R: codec::Decode>(
|
|
storage_key: &[u8],
|
|
default_value: R,
|
|
) -> R {
|
|
StorageValueRef::persistent(&storage_key)
|
|
.get::<R>()
|
|
.ok()
|
|
.flatten()
|
|
.unwrap_or(default_value)
|
|
}
|
|
|
|
fn generate_unique_hash(clap: &Clap<T::AccountId, NetworkIdOf<T>, BalanceOf<T>>) -> H256 {
|
|
let mut clap_args_str = clap.receiver.encode();
|
|
clap_args_str.extend(&clap.amount.encode());
|
|
clap_args_str.extend(&clap.block_number.encode());
|
|
clap_args_str.extend(&clap.network_id.encode());
|
|
|
|
H256::from_slice(&sp_io::hashing::keccak_256(&clap_args_str)[..])
|
|
}
|
|
|
|
fn u64_to_hexadecimal_bytes(value: u64) -> Vec<u8> {
|
|
let mut hex_str = Vec::new();
|
|
hex_str.push(b'0');
|
|
hex_str.push(b'x');
|
|
|
|
if value == 0 {
|
|
hex_str.push(b'0');
|
|
return hex_str;
|
|
}
|
|
|
|
for i in (0..16).rev() {
|
|
let nibble = (value >> (i * 4)) & 0xF;
|
|
if nibble != 0 || hex_str.len() > 2 {
|
|
hex_str.push(match nibble {
|
|
0..=9 => b'0' + nibble as u8,
|
|
10..=15 => b'a' + (nibble - 10) as u8,
|
|
_ => unreachable!(),
|
|
});
|
|
}
|
|
}
|
|
|
|
hex_str
|
|
}
|
|
|
|
fn mended_session_index(
|
|
clap: &Clap<T::AccountId, NetworkIdOf<T>, BalanceOf<T>>,
|
|
) -> (SessionIndex, H256) {
|
|
let prev_session_index = clap.session_index.saturating_sub(1);
|
|
let clap_unique_hash = Self::generate_unique_hash(&clap);
|
|
|
|
let session_index = if ApplauseDetails::<T>::get(&prev_session_index, &clap_unique_hash).is_some() {
|
|
prev_session_index
|
|
} else {
|
|
clap.session_index
|
|
};
|
|
|
|
(session_index, clap_unique_hash)
|
|
}
|
|
|
|
fn try_slow_clap(clap: &Clap<T::AccountId, NetworkIdOf<T>, BalanceOf<T>>) -> DispatchResult {
|
|
let network_id = clap.network_id;
|
|
ensure!(T::NetworkDataHandler::get(&network_id).is_some(), Error::<T>::UnregistedNetwork);
|
|
|
|
let (session_index, clap_unique_hash) = Self::mended_session_index(&clap);
|
|
let authorities_length = Authorities::<T>::get(&session_index).len();
|
|
|
|
let is_disabled = DisabledAuthorityIndexes::<T>::get(&session_index)
|
|
.map(|bitmap| bitmap.exists(&clap.authority_index))
|
|
.unwrap_or(true);
|
|
|
|
ensure!(!is_disabled, Error::<T>::DisabledAuthority);
|
|
|
|
let applause_threshold = Perbill::from_parts(T::ApplauseThreshold::get());
|
|
let threshold_amount = applause_threshold.mul_floor(TotalExposure::<T>::get());
|
|
let new_clapped_amount = T::ExposureListener::get_validator_exposure(
|
|
clap.authority_index,
|
|
);
|
|
|
|
let mut applause_details = match ApplauseDetails::<T>::take(&session_index, &clap_unique_hash) {
|
|
Some(applause_details) => applause_details,
|
|
None => {
|
|
ensure!(
|
|
LatestExecutedBlock::<T>::get(&network_id) <= clap.block_number,
|
|
Error::<T>::ExecutedBlockIsHigher,
|
|
);
|
|
ApplauseDetail::new(network_id, clap.block_number, authorities_length)
|
|
}
|
|
};
|
|
|
|
let total_clapped = if clap.removed {
|
|
ensure!(
|
|
applause_details.authorities.exists(&clap.authority_index),
|
|
Error::<T>::UnregisteredClapRemove,
|
|
);
|
|
applause_details.authorities.unset(clap.authority_index);
|
|
applause_details.clapped_amount.saturating_sub(new_clapped_amount)
|
|
} else {
|
|
ensure!(
|
|
!applause_details.authorities.exists(&clap.authority_index),
|
|
Error::<T>::AlreadyClapped,
|
|
);
|
|
applause_details.authorities.set(clap.authority_index);
|
|
applause_details.clapped_amount.saturating_add(new_clapped_amount)
|
|
};
|
|
|
|
applause_details.clapped_amount = total_clapped;
|
|
|
|
Self::deposit_event(Event::<T>::Clapped {
|
|
network_id,
|
|
authority_id: clap.authority_index,
|
|
clap_unique_hash,
|
|
receiver: clap.receiver.clone(),
|
|
amount: clap.amount,
|
|
removed: clap.removed,
|
|
});
|
|
|
|
let is_enough = applause_details.authorities
|
|
.count_ones()
|
|
.gt(&(authorities_length as u32 / 2));
|
|
|
|
if total_clapped > threshold_amount && is_enough && !applause_details.finalized {
|
|
applause_details.finalized = true;
|
|
if let Err(e) = Self::try_applause(&clap) {
|
|
sp_runtime::print(e);
|
|
}
|
|
}
|
|
|
|
ApplauseDetails::<T>::insert(&session_index, &clap_unique_hash, applause_details);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn try_applause(clap: &Clap<T::AccountId, NetworkIdOf<T>, BalanceOf<T>>) -> DispatchResult {
|
|
if T::NetworkDataHandler::is_nullification_period() {
|
|
return Ok(());
|
|
}
|
|
|
|
let commission = T::NetworkDataHandler::get(&clap.network_id)
|
|
.map(|network_data| Perbill::from_parts(network_data.incoming_fee))
|
|
.unwrap_or_default()
|
|
.mul_ceil(clap.amount);
|
|
let final_amount = clap.amount.saturating_sub(commission);
|
|
|
|
let _ = T::NetworkDataHandler::increase_gatekeeper_amount(&clap.network_id, &clap.amount)
|
|
.map_err(|_| Error::<T>::CouldNotIncreaseGatekeeperAmount)?;
|
|
let _ = T::NetworkDataHandler::accumulate_incoming_imbalance(&final_amount)
|
|
.map_err(|_| Error::<T>::CouldNotAccumulateIncomingImbalance)?;
|
|
let _ = T::NetworkDataHandler::accumulate_commission(&commission)
|
|
.map_err(|_| Error::<T>::CouldNotAccumulateCommission)?;
|
|
let _ = T::Currency::deposit_creating(&clap.receiver, final_amount);
|
|
|
|
LatestExecutedBlock::<T>::set(clap.network_id, clap.block_number);
|
|
|
|
Self::deposit_event(Event::<T>::Applaused {
|
|
network_id: clap.network_id,
|
|
receiver: clap.receiver.clone(),
|
|
received_amount: final_amount,
|
|
block_number: clap.block_number
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn try_commit_block(new_commitment: &BlockCommitment<NetworkIdOf<T>>) -> DispatchResult {
|
|
let authority_index = new_commitment.authority_index;
|
|
let network_id = new_commitment.network_id;
|
|
ensure!(T::NetworkDataHandler::get(&network_id).is_some(), Error::<T>::UnregistedNetwork);
|
|
|
|
let current_commits = BlockCommitments::<T>::try_mutate(&network_id, |current_commitments| -> Result<u64, DispatchError> {
|
|
let mut new_commitment_details = new_commitment.commitment;
|
|
|
|
let (current_commits, current_last_updated) = current_commitments
|
|
.get(&authority_index)
|
|
.map(|details| (details.commits + 1, details.last_updated))
|
|
.unwrap_or((1, 0));
|
|
|
|
ensure!(
|
|
new_commitment_details.last_updated > current_last_updated,
|
|
Error::<T>::TimeWentBackwards
|
|
);
|
|
|
|
new_commitment_details.commits = current_commits;
|
|
current_commitments.insert(authority_index, new_commitment_details);
|
|
|
|
Ok(current_commits)
|
|
})?;
|
|
|
|
Self::deposit_event(Event::<T>::BlockCommited {
|
|
network_id,
|
|
authority_id: authority_index
|
|
});
|
|
|
|
let session_index = T::ValidatorSet::session_index();
|
|
let validators = Validators::<T>::get(&session_index);
|
|
let block_commitments = BlockCommitments::<T>::get(&network_id);
|
|
|
|
let disabled_bitmap = DisabledAuthorityIndexes::<T>::get(&session_index)
|
|
.unwrap_or(BitMap::new(validators.len() as u32));
|
|
|
|
let max_block_deviation = T::NetworkDataHandler::get(&network_id)
|
|
.map(|network| ONE_HOUR_MILLIS
|
|
.saturating_mul(6)
|
|
.saturating_div(network.avg_block_speed)
|
|
)
|
|
.unwrap_or_default();
|
|
|
|
if current_commits > 1 {
|
|
let offence_bitmap = Self::capture_deviation_in_commitments_and_remove(
|
|
&disabled_bitmap,
|
|
&block_commitments,
|
|
&validators,
|
|
max_block_deviation,
|
|
);
|
|
|
|
let offence_type = OffenceType::CommitmentOffence;
|
|
Self::try_offend_validators(
|
|
&session_index,
|
|
&validators,
|
|
offence_bitmap,
|
|
disabled_bitmap,
|
|
offence_type,
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn start_slow_clapping(block_number: BlockNumberFor<T>) -> OffchainResult<T, ()> {
|
|
let session_index = T::ValidatorSet::session_index();
|
|
let networks_len = T::NetworkDataHandler::iter().count();
|
|
let network_in_use = T::NetworkDataHandler::iter()
|
|
.nth(
|
|
block_number
|
|
.into()
|
|
.as_usize()
|
|
.checked_rem(networks_len)
|
|
.unwrap_or_default(),
|
|
)
|
|
.ok_or(OffchainErr::NoStoredNetworks)?;
|
|
|
|
let network_id_encoded = network_in_use.0.encode();
|
|
|
|
let rate_limit_delay_key = Self::create_storage_key(b"rate-limit-", &network_id_encoded);
|
|
let rate_limit_delay = Self::read_persistent_offchain_storage(
|
|
&rate_limit_delay_key,
|
|
network_in_use.1.rate_limit_delay,
|
|
);
|
|
|
|
let network_lock_key = Self::create_storage_key(b"network-lock-", &network_id_encoded);
|
|
let block_until =
|
|
rt_offchain::Duration::from_millis(rate_limit_delay.max(MIN_LOCK_GUARD_PERIOD));
|
|
let mut network_lock = StorageLock::<Time>::with_deadline(&network_lock_key, block_until);
|
|
|
|
let _lock_guard = network_lock
|
|
.try_lock()
|
|
.map_err(|_| OffchainErr::OffchainTimeoutPeriod(network_in_use.0))?;
|
|
|
|
log::info!(
|
|
target: LOG_TARGET,
|
|
"👻 Offchain worker started for network #{:?} at block #{:?}",
|
|
network_in_use.0,
|
|
block_number,
|
|
);
|
|
|
|
Self::do_evm_claps_or_save_block(session_index, network_in_use.0, &network_in_use.1)
|
|
}
|
|
|
|
fn do_evm_claps_or_save_block(
|
|
session_index: SessionIndex,
|
|
network_id: NetworkIdOf<T>,
|
|
network_data: &NetworkData,
|
|
) -> OffchainResult<T, ()> {
|
|
let network_id_encoded = network_id.encode();
|
|
|
|
let block_number_key = Self::create_storage_key(b"block-", &network_id_encoded);
|
|
let block_distance_key = Self::create_storage_key(b"block-distance-", &network_id_encoded);
|
|
let endpoint_key = Self::create_storage_key(b"endpoint-", &network_id_encoded);
|
|
|
|
let max_block_distance = Self::read_persistent_offchain_storage(
|
|
&block_distance_key,
|
|
network_data.block_distance,
|
|
);
|
|
let stored_endpoints = Self::read_persistent_offchain_storage(
|
|
&endpoint_key,
|
|
network_data.default_endpoints.clone(),
|
|
);
|
|
|
|
let random_seed = sp_io::offchain::random_seed();
|
|
let random_number = <u32>::decode(&mut TrailingZeroInput::new(random_seed.as_ref()))
|
|
.expect("input is padded with zeroes; qed");
|
|
|
|
let random_index = (random_number as usize)
|
|
.checked_rem(stored_endpoints.len())
|
|
.unwrap_or_default();
|
|
|
|
let endpoints = if !stored_endpoints.is_empty() {
|
|
&stored_endpoints
|
|
} else {
|
|
&network_data.default_endpoints
|
|
};
|
|
|
|
let rpc_endpoint = endpoints
|
|
.get(random_index)
|
|
.ok_or(OffchainErr::NoEndpointAvailable(network_id))?;
|
|
|
|
let (from_block, to_block): (u64, u64) = StorageValueRef::persistent(&block_number_key)
|
|
.get()
|
|
.map_err(|_| OffchainErr::StorageRetrievalError(network_id))?
|
|
.unwrap_or_default();
|
|
|
|
let request_body = if from_block < to_block.saturating_sub(1) {
|
|
Self::prepare_request_body_for_latest_transfers(
|
|
from_block,
|
|
to_block.saturating_sub(1),
|
|
network_data,
|
|
)
|
|
} else {
|
|
Self::prepare_request_body_for_latest_block(network_data)
|
|
};
|
|
|
|
let response_bytes = Self::fetch_from_remote(&rpc_endpoint, &request_body)?;
|
|
|
|
match network_data.network_type {
|
|
NetworkType::Evm => {
|
|
let parsed_evm_response = Self::parse_evm_response(&response_bytes)?;
|
|
let new_block_range = match parsed_evm_response {
|
|
EvmResponseType::BlockNumber(new_evm_block) if from_block.le(&to_block) => {
|
|
let estimated_block =
|
|
new_evm_block.saturating_sub(network_data.finality_delay);
|
|
let adjusted_block =
|
|
Self::adjust_to_block(estimated_block, from_block, max_block_distance);
|
|
|
|
if from_block == 0 {
|
|
(estimated_block, estimated_block)
|
|
} else {
|
|
(from_block, adjusted_block)
|
|
}
|
|
}
|
|
_ => (to_block, to_block),
|
|
};
|
|
|
|
StorageValueRef::persistent(&block_number_key).set(&new_block_range);
|
|
|
|
if !sp_io::offchain::is_validator() {
|
|
log::info!(target: LOG_TARGET, "👻 Not a validator; no transactions available");
|
|
return Ok(());
|
|
}
|
|
|
|
for (authority_index, authority_key) in Self::local_authorities(&session_index) {
|
|
parsed_evm_response.sign_and_submit::<T>(
|
|
new_block_range.0,
|
|
authority_index,
|
|
authority_key,
|
|
session_index,
|
|
network_id,
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
NetworkType::Utxo => Err(OffchainErr::UtxoNotImplemented(network_id).into()),
|
|
_ => Err(OffchainErr::UnknownNetworkType(network_id).into()),
|
|
}
|
|
}
|
|
|
|
fn adjust_to_block(estimated_block: u64, from_block: u64, max_block_distance: u64) -> u64 {
|
|
let fallback_value = from_block
|
|
.saturating_add(max_block_distance)
|
|
.min(estimated_block);
|
|
|
|
estimated_block
|
|
.checked_sub(from_block)
|
|
.map(|current_distance| {
|
|
current_distance
|
|
.le(&max_block_distance)
|
|
.then_some(estimated_block)
|
|
})
|
|
.flatten()
|
|
.unwrap_or(fallback_value)
|
|
}
|
|
|
|
fn local_authorities(
|
|
session_index: &SessionIndex,
|
|
) -> impl Iterator<Item = (u32, T::AuthorityId)> {
|
|
let authorities = Authorities::<T>::get(session_index);
|
|
let mut local_authorities = T::AuthorityId::all();
|
|
local_authorities.sort();
|
|
|
|
authorities
|
|
.into_iter()
|
|
.enumerate()
|
|
.filter_map(move |(index, authority)| {
|
|
local_authorities
|
|
.binary_search(&authority)
|
|
.ok()
|
|
.map(|location| (index as u32, local_authorities[location].clone()))
|
|
})
|
|
}
|
|
|
|
fn fetch_from_remote(rpc_endpoint: &[u8], request_body: &[u8]) -> OffchainResult<T, Vec<u8>> {
|
|
let rpc_endpoint_str =
|
|
core::str::from_utf8(rpc_endpoint).expect("rpc endpoint valid str; qed");
|
|
let request_body_str =
|
|
core::str::from_utf8(request_body).expect("request body valid str: qed");
|
|
|
|
let deadline = sp_io::offchain::timestamp()
|
|
.add(rt_offchain::Duration::from_millis(FETCH_TIMEOUT_PERIOD));
|
|
|
|
let pending = rt_offchain::http::Request::post(&rpc_endpoint_str, vec![request_body_str])
|
|
.add_header("Accept", "application/json")
|
|
.add_header("Content-Type", "application/json")
|
|
.deadline(deadline)
|
|
.send()
|
|
.map_err(|err| OffchainErr::HttpRequestError(err))?;
|
|
|
|
let response = pending
|
|
.try_wait(deadline)
|
|
.map_err(|_| OffchainErr::RequestUncompleted)?
|
|
.map_err(|_| OffchainErr::RequestUncompleted)?;
|
|
|
|
if response.code != 200 {
|
|
return Err(OffchainErr::HttpResponseNotOk(response.code));
|
|
}
|
|
|
|
Ok(response.body().collect::<Vec<u8>>())
|
|
}
|
|
|
|
fn prepare_request_body_for_latest_block(network_data: &NetworkData) -> Vec<u8> {
|
|
match network_data.network_type {
|
|
NetworkType::Evm => {
|
|
b"{\"id\":0,\"jsonrpc\":\"2.0\",\"method\":\"eth_blockNumber\"}".to_vec()
|
|
}
|
|
_ => Default::default(),
|
|
}
|
|
}
|
|
|
|
fn prepare_request_body_for_latest_transfers(
|
|
from_block: u64,
|
|
to_block: u64,
|
|
network_data: &NetworkData,
|
|
) -> Vec<u8> {
|
|
match network_data.network_type {
|
|
NetworkType::Evm => {
|
|
let mut body =
|
|
b"{\"id\":0,\"jsonrpc\":\"2.0\",\"method\":\"eth_getLogs\",\"params\":[{"
|
|
.to_vec();
|
|
body.extend(b"\"fromBlock\":\"".to_vec());
|
|
body.extend(Self::u64_to_hexadecimal_bytes(from_block));
|
|
body.extend(b"\",\"toBlock\":\"".to_vec());
|
|
body.extend(Self::u64_to_hexadecimal_bytes(to_block));
|
|
body.extend(b"\",\"address\":\"".to_vec());
|
|
body.extend(network_data.gatekeeper.to_vec());
|
|
body.extend(b"\",\"topics\":[\"".to_vec());
|
|
body.extend(network_data.topic_name.to_vec());
|
|
body.extend(b"\"]}]}".to_vec());
|
|
body
|
|
}
|
|
_ => Default::default(),
|
|
}
|
|
}
|
|
|
|
fn parse_evm_response(response_bytes: &[u8]) -> OffchainResult<T, EvmResponseType> {
|
|
let response_str = sp_std::str::from_utf8(&response_bytes)
|
|
.map_err(|_| OffchainErr::HttpBytesParsingError)?;
|
|
|
|
let response_result: EvmResponse =
|
|
serde_json::from_str(&response_str).map_err(|_| OffchainErr::HttpJsonParsingError)?;
|
|
|
|
if response_result.error.is_some() {
|
|
return Err(OffchainErr::ErrorInEvmResponse);
|
|
}
|
|
|
|
Ok(response_result
|
|
.result
|
|
.ok_or(OffchainErr::ErrorInEvmResponse)?)
|
|
}
|
|
|
|
fn initialize_authorities(authorities: Vec<T::AuthorityId>) {
|
|
let session_index = T::ValidatorSet::session_index();
|
|
assert!(
|
|
Authorities::<T>::get(&session_index).is_empty(),
|
|
"Authorities are already initilized!"
|
|
);
|
|
|
|
let authorities_len = authorities.len();
|
|
let bounded_authorities = WeakBoundedVec::<_, T::MaxAuthorities>::try_from(authorities)
|
|
.expect("more than the maximum number of authorities");
|
|
|
|
let validators = T::ValidatorSet::validators();
|
|
let bounded_validators = WeakBoundedVec::<_, T::MaxAuthorities>::try_from(validators)
|
|
.expect("more than the maximum number of validators");
|
|
|
|
if let Some(target_session_index) = session_index.checked_sub(T::HistoryDepth::get()) {
|
|
Self::clear_history(&target_session_index);
|
|
}
|
|
|
|
Validators::<T>::insert(&session_index, bounded_validators);
|
|
Authorities::<T>::set(&session_index, bounded_authorities);
|
|
|
|
let mut disabled_bitmap = BitMap::new(authorities_len as AuthIndex);
|
|
for disabled_index in T::DisabledValidators::disabled_validators() {
|
|
disabled_bitmap.set(disabled_index);
|
|
}
|
|
DisabledAuthorityIndexes::<T>::insert(session_index, disabled_bitmap);
|
|
}
|
|
|
|
fn clear_history(target_session_index: &SessionIndex) {
|
|
Authorities::<T>::remove(target_session_index);
|
|
Validators::<T>::remove(target_session_index);
|
|
DisabledAuthorityIndexes::<T>::remove(target_session_index);
|
|
|
|
let cursor = ApplauseDetails::<T>::clear_prefix(target_session_index, u32::MAX, None);
|
|
debug_assert!(cursor.maybe_cursor.is_none());
|
|
}
|
|
|
|
fn calculate_weighted_median(values: &mut Vec<(AuthIndex, u64)>) -> u64 {
|
|
values.sort_by_key(|data| data.1);
|
|
|
|
let mid = values.len() / 2;
|
|
if values.len() % 2 == 1 {
|
|
values[mid].1
|
|
} else {
|
|
values[mid - 1].1
|
|
}
|
|
}
|
|
|
|
fn apply_median_deviation(
|
|
bitmap: &mut BitMap,
|
|
disabled: &BitMap,
|
|
values: &Vec<(AuthIndex, u64)>,
|
|
median: u64,
|
|
max_deviation: u64,
|
|
) {
|
|
values.iter().for_each(|(authority_index, value)| {
|
|
if !disabled.exists(authority_index) && value.abs_diff(median) > max_deviation {
|
|
bitmap.set(*authority_index);
|
|
}
|
|
})
|
|
}
|
|
|
|
fn capture_deviation_in_commitments_and_remove(
|
|
disabled_bitmap: &BitMap,
|
|
block_commitments: &BTreeMap<AuthIndex, CommitmentDetails>,
|
|
validators: &WeakBoundedVec<ValidatorId<T>, T::MaxAuthorities>,
|
|
max_block_deviation: u64,
|
|
) -> BitMap {
|
|
let validators_len = validators.len() as u32;
|
|
|
|
let mut delayed = BitMap::new(validators_len);
|
|
let mut stored_blocks: Vec<(AuthIndex, u64)> = Vec::new();
|
|
let mut time_updates: Vec<(AuthIndex, u64)> = Vec::new();
|
|
|
|
for authority_index in 0..validators_len {
|
|
let data = block_commitments.get(&authority_index).copied().unwrap_or_default();
|
|
stored_blocks.push((authority_index, data.last_stored_block));
|
|
time_updates.push((authority_index, data.last_updated));
|
|
}
|
|
|
|
let stored_block_median = Self::calculate_weighted_median(&mut stored_blocks);
|
|
let time_update_median = Self::calculate_weighted_median(&mut time_updates);
|
|
|
|
Self::apply_median_deviation(&mut delayed, disabled_bitmap, &stored_blocks, stored_block_median, max_block_deviation);
|
|
Self::apply_median_deviation(&mut delayed, disabled_bitmap, &time_updates, time_update_median, ONE_HOUR_MILLIS);
|
|
|
|
delayed
|
|
}
|
|
|
|
fn get_cumulative_missing_clapped_amount(
|
|
disabled_bitmap: &BitMap,
|
|
session_index: &SessionIndex,
|
|
missed_validators: &mut BitMap,
|
|
) -> Perbill {
|
|
let total_exposure = TotalExposure::<T>::get();
|
|
|
|
let bucket_size = BitMap::size_of_bucket();
|
|
let mut missed_percent = Perbill::default();
|
|
|
|
for applause_details in ApplauseDetails::<T>::iter_prefix_values(session_index) {
|
|
let max_value = applause_details.authorities.max_value();
|
|
let clapped_amount = applause_details.clapped_amount;
|
|
let is_finalized = applause_details.finalized as Bucket;
|
|
|
|
for (bucket_id, bucket) in applause_details.authorities.iter_buckets() {
|
|
let bits_in_bucket = 1 << bucket_size;
|
|
let bucket_shift = bucket_id << bucket_size;
|
|
|
|
let disabled_bucket = disabled_bitmap.get_bucket(bucket_id);
|
|
let missed_authorities = bucket ^ (Bucket::MAX * is_finalized);
|
|
let missed_authorities = missed_authorities & !disabled_bucket;
|
|
|
|
for bit_position in 0..bits_in_bucket {
|
|
if (missed_authorities >> bit_position) & 1 == 0 {
|
|
continue;
|
|
}
|
|
|
|
let position = bucket_shift + bit_position;
|
|
if position > max_value {
|
|
continue;
|
|
}
|
|
|
|
missed_validators.set(position.into());
|
|
missed_percent = missed_percent
|
|
.saturating_add(Perbill::from_rational(
|
|
total_exposure.saturating_sub(clapped_amount),
|
|
total_exposure,
|
|
));
|
|
}
|
|
}
|
|
}
|
|
|
|
missed_percent
|
|
}
|
|
|
|
fn try_offend_validators(
|
|
session_index: &SessionIndex,
|
|
validators: &WeakBoundedVec<ValidatorId<T>, T::MaxAuthorities>,
|
|
offence_bitmap: BitMap,
|
|
disabled_bitmap: BitMap,
|
|
offence_type: OffenceType,
|
|
) {
|
|
let validator_set_count = validators.len() as u32;
|
|
|
|
let offenders = validators
|
|
.into_iter()
|
|
.enumerate()
|
|
.filter_map(|(index, id)| {
|
|
(offence_bitmap.exists(&(index as AuthIndex))).then(|| {
|
|
<T::ValidatorSet as ValidatorSetWithIdentification<T::AccountId>>::IdentificationOf::convert(
|
|
id.clone(),
|
|
).map(|full_id| (id.clone(), full_id))
|
|
})
|
|
.flatten()
|
|
})
|
|
.collect::<Vec<IdentificationTuple<T>>>();
|
|
|
|
let not_enough_validators_left = validator_set_count
|
|
.saturating_sub(disabled_bitmap
|
|
.bitor(offence_bitmap)
|
|
.count_ones()
|
|
).lt(&T::MinAuthoritiesNumber::get());
|
|
|
|
if not_enough_validators_left && offenders.len() > 0 {
|
|
Self::deposit_event(Event::<T>::BlackSwan);
|
|
return;
|
|
}
|
|
|
|
if offenders.len() == 0 {
|
|
let equilibrium_event = match offence_type {
|
|
OffenceType::CommitmentOffence => Event::<T>::AuthoritiesCommitmentEquilibrium,
|
|
OffenceType::ThrottlingOffence(_) => Event::<T>::AuthoritiesApplauseEquilibrium,
|
|
};
|
|
Self::deposit_event(equilibrium_event);
|
|
return;
|
|
}
|
|
|
|
let offence_event = match offence_type {
|
|
OffenceType::CommitmentOffence =>
|
|
Event::<T>::SomeAuthoritiesDelayed { delayed: offenders.clone() },
|
|
OffenceType::ThrottlingOffence(_) =>
|
|
Event::<T>::SomeAuthoritiesTrottling { throttling: offenders.clone() },
|
|
};
|
|
|
|
Self::deposit_event(offence_event);
|
|
|
|
let offence = SlowClapOffence {
|
|
validator_set_count,
|
|
session_index: *session_index,
|
|
offenders,
|
|
offence_type,
|
|
};
|
|
|
|
if let Err(e) = T::ReportUnresponsiveness::report_offence(vec![], offence) {
|
|
sp_runtime::print(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {
|
|
type Public = T::AuthorityId;
|
|
}
|
|
|
|
impl<T: Config> BlockNumberProvider for Pallet<T> {
|
|
type BlockNumber = BlockNumberFor<T>;
|
|
fn current_block_number() -> Self::BlockNumber {
|
|
T::BlockNumberProvider::current_block_number()
|
|
}
|
|
}
|
|
|
|
impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
|
|
type Key = T::AuthorityId;
|
|
|
|
fn on_genesis_session<'a, I: 'a>(validators: I)
|
|
where
|
|
I: Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
|
|
{
|
|
let authorities = validators.map(|x| x.1).collect::<Vec<_>>();
|
|
Self::initialize_authorities(authorities);
|
|
}
|
|
|
|
fn on_new_session<'a, I: 'a>(_changed: bool, validators: I, _queued_validators: I)
|
|
where
|
|
I: Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
|
|
{
|
|
for (network_id, _) in BlockCommitments::<T>::iter() {
|
|
BlockCommitments::<T>::remove(network_id);
|
|
}
|
|
|
|
let current_era = T::ExposureListener::get_current_era();
|
|
let total_exposure = T::ExposureListener::get_total_exposure(current_era);
|
|
|
|
TotalExposure::<T>::set(total_exposure);
|
|
|
|
let authorities = validators.map(|x| x.1).collect::<Vec<_>>();
|
|
Self::initialize_authorities(authorities);
|
|
}
|
|
|
|
fn on_before_session_ending() {
|
|
let session_index = T::ValidatorSet::session_index().saturating_sub(1);
|
|
|
|
let validators = Validators::<T>::get(&session_index);
|
|
let validators_len = validators.len() as u32;
|
|
let disabled_bitmap = DisabledAuthorityIndexes::<T>::get(&session_index)
|
|
.unwrap_or(BitMap::new(validators_len));
|
|
|
|
let mut offence_bitmap = BitMap::new(validators_len);
|
|
|
|
let missed_percent = Self::get_cumulative_missing_clapped_amount(
|
|
&disabled_bitmap,
|
|
&session_index,
|
|
&mut offence_bitmap,
|
|
);
|
|
|
|
let offence_type = OffenceType::ThrottlingOffence(missed_percent);
|
|
Self::try_offend_validators(
|
|
&session_index,
|
|
&validators,
|
|
offence_bitmap,
|
|
disabled_bitmap,
|
|
offence_type,
|
|
);
|
|
}
|
|
|
|
fn on_disabled(validator_index: u32) {
|
|
let session_index = T::ValidatorSet::session_index();
|
|
let length = Authorities::<T>::get(&session_index).len();
|
|
DisabledAuthorityIndexes::<T>::mutate(&session_index, |maybe_bitmap| {
|
|
if let Some(bitmap) = maybe_bitmap {
|
|
bitmap.set(validator_index);
|
|
} else {
|
|
let mut new_bitmap = BitMap::new(length as u32);
|
|
new_bitmap.set(validator_index);
|
|
*maybe_bitmap = Some(new_bitmap);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
#[derive(RuntimeDebug, TypeInfo)]
|
|
#[cfg_attr(feature = "std", derive(Clone, PartialEq, Eq))]
|
|
pub enum OffenceType {
|
|
CommitmentOffence,
|
|
ThrottlingOffence(Perbill),
|
|
}
|
|
|
|
#[derive(RuntimeDebug, TypeInfo)]
|
|
#[cfg_attr(feature = "std", derive(Clone, PartialEq, Eq))]
|
|
pub struct SlowClapOffence<Offender> {
|
|
session_index: SessionIndex,
|
|
validator_set_count: u32,
|
|
offenders: Vec<Offender>,
|
|
offence_type: OffenceType,
|
|
}
|
|
|
|
impl<Offender: Clone> Offence<Offender> for SlowClapOffence<Offender> {
|
|
const ID: Kind = *b"slow-clap:throtl";
|
|
type TimeSlot = SessionIndex;
|
|
|
|
fn offenders(&self) -> Vec<Offender> {
|
|
self.offenders.clone()
|
|
}
|
|
|
|
fn session_index(&self) -> SessionIndex {
|
|
self.session_index
|
|
}
|
|
|
|
fn validator_set_count(&self) -> u32 {
|
|
self.validator_set_count
|
|
}
|
|
|
|
fn time_slot(&self) -> Self::TimeSlot {
|
|
self.session_index
|
|
}
|
|
|
|
fn slash_fraction(&self, offenders_count: u32) -> Perbill {
|
|
match self.offence_type {
|
|
OffenceType::ThrottlingOffence(missed_percent) => missed_percent
|
|
.saturating_mul(Perbill::from_rational(1, offenders_count)),
|
|
OffenceType::CommitmentOffence => offenders_count
|
|
.checked_sub(self.validator_set_count / 10 + 1)
|
|
.map(|threshold| Perbill::from_rational(3 * threshold, self.validator_set_count)
|
|
.saturating_mul(Perbill::from_percent(7))
|
|
)
|
|
.unwrap_or_default(),
|
|
}
|
|
}
|
|
}
|