Struct hotshot_testing::byzantine::byzantine_behaviour::DishonestLeader

pub struct DishonestLeader<TYPES: NodeType> {
    pub validated_proposals: Vec<QuorumProposal2<TYPES>>,
    pub total_proposals_from_node: u64,
    pub dishonest_at_proposal_numbers: HashSet<u64>,
    pub view_look_back: usize,
    pub dishonest_proposal_view_numbers: Arc<RwLock<HashSet<TYPES::View>>>,
}

An EventHandlerState that modifies justify_qc on QuorumProposalSend to that of a previous view to mock dishonest leader

Fields

validated_proposals: Vec<QuorumProposal2<TYPES>>

Store events from previous views

total_proposals_from_node: u64

How many times current node has been elected leader and sent proposal

dishonest_at_proposal_numbers: HashSet<u64>

Which proposals to be dishonest at

view_look_back: usize

How far back to look for a QC

dishonest_proposal_view_numbers: Arc<RwLock<HashSet<TYPES::View>>>

Shared state of all view numbers we send bad proposal at

Implementations

impl<TYPES: NodeType> DishonestLeader<TYPES>

Add method that will handle QuorumProposalSend events If we have previous proposals stored and the total_proposals_from_node matches a value specified in dishonest_at_proposal_numbers Then send out the event with the modified proposal that has an older QC

async fn handle_proposal_send_event( &self, event: &HotShotEvent<TYPES>, proposal: &Proposal<TYPES, QuorumProposal2<TYPES>>, sender: &TYPES::SignatureKey, ) -> HotShotEvent<TYPES>

When a leader is sending a proposal this method will mock a dishonest leader We accomplish this by looking back a number of specified views and using that cached proposals QC

Trait Implementations

impl<TYPES: Debug + NodeType> Debug for DishonestLeader<TYPES>

where TYPES::View: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<TYPES: NodeType, I: NodeImplementation<TYPES> + Debug, V: Versions> EventTransformerState<TYPES, I, V> for DishonestLeader<TYPES>

fn recv_handler<'life0, 'life1, 'async_trait>( &'life0 mut self, event: &'life1 HotShotEvent<TYPES>, ) -> Pin<Box<dyn Future<Output = Vec<HotShotEvent<TYPES>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

modify incoming messages from the network

fn send_handler<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, event: &'life1 HotShotEvent<TYPES>, _public_key: &'life2 TYPES::SignatureKey, _private_key: &'life3 <TYPES::SignatureKey as SignatureKey>::PrivateKey, _upgrade_lock: &'life4 UpgradeLock<TYPES, V>, _consensus: Arc<RwLock<Consensus<TYPES>>>, ) -> Pin<Box<dyn Future<Output = Vec<HotShotEvent<TYPES>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

modify outgoing messages from the network

fn spawn_handle<'async_trait>( &'static mut self, public_key: <TYPES as NodeType>::SignatureKey, private_key: <<TYPES as NodeType>::SignatureKey as SignatureKey>::PrivateKey, nonce: u64, config: HotShotConfig<<TYPES as NodeType>::SignatureKey>, memberships: Arc<RwLock<<TYPES as NodeType>::Membership>>, network: Arc<<I as NodeImplementation<TYPES>>::Network>, initializer: HotShotInitializer<TYPES>, metrics: ConsensusMetricsValue, storage: <I as NodeImplementation<TYPES>>::Storage, marketplace_config: MarketplaceConfig<TYPES, I>, ) -> Pin<Box<dyn Future<Output = SystemContextHandle<TYPES, I, V>> + Send + 'async_trait>>

where Self: Send + 'async_trait,

Creates a SystemContextHandle with the given even transformer

fn add_network_tasks<'life0, 'async_trait>( &'static mut self, handle: &'life0 mut SystemContextHandle<TYPES, I, V>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Send + 'async_trait,

Add byzantine network tasks with the trait

fn add_network_event_tasks(&self, handle: &mut SystemContextHandle<TYPES, I, V>)

Adds the NetworkEventTaskState tasks possibly modifying them as well.

fn add_network_event_task( &self, handle: &mut SystemContextHandle<TYPES, I, V>, channel: Arc<<I as NodeImplementation<TYPES>>::Network>, membership: Arc<RwLock<<TYPES as NodeType>::Membership>>, )

Adds a NetworkEventTaskState task. Can be reimplemented to modify its behaviour.