Struct DishonestViewSyncRelay 

pub struct DishonestViewSyncRelay {
    pub dishonest_proposal_view_numbers: Vec<u64>,
    pub dishonest_vote_view_numbers: Vec<u64>,
    pub first_f_honest_nodes: Vec<u64>,
    pub second_f_honest_nodes: Vec<u64>,
    pub one_honest_node: u64,
    pub f_dishonest_nodes: Vec<u64>,
}

Implements a byzantine behaviour which aims at splitting the honest nodes during view sync protocol so that the honest nodes cannot view sync on their own.

Requirement: The scenario requires at least 4 dishonest nodes so total number of nodes need to be at least 13.

Scenario:

1. The first dishonest leader sends a proposal to only f + 1 honest nodes and f dishonest nodes
2. The second dishonest leader sends a proposal to only f + 1 honest nodes.
3. All dishonest nodes do not send timeout votes.
4. The first dishonest relay sends a correctly formed precommit certificate to f + 1 honest nodes and f dishonest nodes.
5. The first dishonest relay sends a correctly formed commit certificate to only one honest node.
6. The second dishonest relay behaves in the same way as the first dishonest relay.

Fields

dishonest_proposal_view_numbers: Vec<u64>

dishonest_vote_view_numbers: Vec<u64>

first_f_honest_nodes: Vec<u64>

second_f_honest_nodes: Vec<u64>

one_honest_node: u64

f_dishonest_nodes: Vec<u64>

Trait Implementations

impl Debug for DishonestViewSyncRelay

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

Formats the value using the given formatter.

impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> EventTransformerState<TYPES, I, V> for DishonestViewSyncRelay

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: OuterConsensus<TYPES>, membership_coordinator: EpochMembershipCoordinator<TYPES>, network: Arc<I::Network>, ) -> 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 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 spawn_handle<'async_trait>( &'static mut self, public_key: <TYPES as NodeType>::SignatureKey, private_key: <<TYPES as NodeType>::SignatureKey as SignatureKey>::PrivateKey, state_private_key: <<TYPES as NodeType>::StateSignatureKey as StateSignatureKey>::StatePrivateKey, nonce: u64, config: HotShotConfig<TYPES>, memberships: EpochMembershipCoordinator<TYPES>, network: Arc<<I as NodeImplementation<TYPES>>::Network>, initializer: HotShotInitializer<TYPES>, consensus_metrics: ConsensusMetricsValue, storage: <I as NodeImplementation<TYPES>>::Storage, storage_metrics: StorageMetricsValue, ) -> 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>, )

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