Struct dkg_gadget::worker::DKGWorker

pub struct DKGWorker<B, BE, C, GE>where
    B: Block,
    BE: Backend<B>,
    C: Client<B, BE>,
    GE: GossipEngineIface,{

    pub client: Arc<C>,
    pub backend: Arc<BE>,
    pub key_store: DKGKeystore,
    pub gossip_engine: Arc<GE>,
    pub db: Arc<dyn DKGDbBackend>,
    pub metrics: Arc<Option<Metrics>>,
    pub best_authorities: Shared<Vec<(u16, Public)>>,
    pub next_best_authorities: Shared<Vec<(u16, Public)>>,
    pub latest_header: Shared<Option<B::Header>>,
    pub current_validator_set: Shared<AuthoritySet<Public, MaxAuthorities>>,
    pub queued_validator_set: Shared<AuthoritySet<Public, MaxAuthorities>>,
    pub aggregated_public_keys: Shared<AggregatedPublicKeysAndSigs>,
    pub aggregated_misbehaviour_reports: Shared<AggregatedMisbehaviourReportStore>,
    pub local_keystore: Shared<Option<Arc<LocalKeystore>>>,
    pub network: Option<Arc<NetworkService<B, B::Hash>>>,
    pub sync_service: Option<Arc<SyncingService<B>>>,
    pub test_bundle: Option<TestBundle>,
    pub logger: DebugLogger,
    pub dkg_modules: DKGModules<B, BE, C, GE>,
    pub signing_manager: SigningManager<B, BE, C, GE>,
    pub keygen_manager: KeygenManager<B, BE, C, GE>,
    /* private fields */
}

A DKG worker plays the DKG protocol

Fields

client: Arc<C>

backend: Arc<BE>

key_store: DKGKeystore

gossip_engine: Arc<GE>

db: Arc<dyn DKGDbBackend>

metrics: Arc<Option<Metrics>>

best_authorities: Shared<Vec<(u16, Public)>>

Cached best authorities

next_best_authorities: Shared<Vec<(u16, Public)>>

Cached next best authorities

latest_header: Shared<Option<B::Header>>

Latest block header

current_validator_set: Shared<AuthoritySet<Public, MaxAuthorities>>

Current validator set

queued_validator_set: Shared<AuthoritySet<Public, MaxAuthorities>>

Queued validator set

aggregated_public_keys: Shared<AggregatedPublicKeysAndSigs>

Tracking for the broadcasted public keys and signatures

aggregated_misbehaviour_reports: Shared<AggregatedMisbehaviourReportStore>

Tracking for the misbehaviour reports

local_keystore: Shared<Option<Arc<LocalKeystore>>>

Concrete type that points to the actual local keystore if it exists

network: Option<Arc<NetworkService<B, B::Hash>>>

Used to keep track of network status

sync_service: Option<Arc<SyncingService<B>>>

Used to keep track of sync status

test_bundle: Option<TestBundle>

logger: DebugLogger

dkg_modules: DKGModules<B, BE, C, GE>

signing_manager: SigningManager<B, BE, C, GE>

keygen_manager: KeygenManager<B, BE, C, GE>

Implementations

impl<B, BE, C, GE> DKGWorker<B, BE, C, GE>where B: Block + Codec, BE: Backend<B> + Unpin + 'static, GE: GossipEngineIface + 'static, C: Client<B, BE> + 'static, C::Api: DKGApi<B, AuthorityId, NumberFor<B>, MaxProposalLength, MaxAuthorities>,

pub fn new( worker_params: WorkerParams<B, BE, C, GE>, logger: DebugLogger ) -> Self

Return a new DKG worker instance.

Note that a DKG worker is only fully functional if a corresponding DKG pallet has been deployed on-chain.

The DKG pallet is needed in order to keep track of the DKG authority set.

impl<B, BE, C, GE> DKGWorker<B, BE, C, GE>where B: Block, BE: Backend<B> + Unpin + 'static, GE: GossipEngineIface + 'static, C: Client<B, BE> + 'static, C::Api: DKGApi<B, AuthorityId, NumberFor<B>, MaxProposalLength, MaxAuthorities>,

pub async fn get_party_index(&self, header: &B::Header) -> Option<u16>

Get the party index of our worker

Returns None if we are not in the best authority set

pub async fn get_next_party_index(&self, header: &B::Header) -> Option<u16>

Get the next party index of our worker for possible queued keygen

Returns None if we are not in the next best authority set

pub async fn get_keygen_threshold(&self, header: &B::Header) -> u16

Get the keygen threshold at a specific block

pub async fn get_next_keygen_threshold(&self, header: &B::Header) -> u16

Get the next keygen threshold at a specific block

pub async fn get_signature_threshold(&self, header: &B::Header) -> u16

Get the signature threshold at a specific block

pub async fn get_next_signature_threshold(&self, header: &B::Header) -> u16

Get the next signature threshold at a specific block

pub async fn get_dkg_pub_key( &self, header: &B::Header ) -> (AuthoritySetId, Vec<u8>)

Get the active DKG public key

pub async fn dkg_pub_key_is_unset(&self, header: &B::Header) -> bool

pub async fn get_next_dkg_pub_key( &self, header: &B::Header ) -> Option<(AuthoritySetId, Vec<u8>)>

Get the next DKG public key

pub async fn get_keygen_jailed( &self, header: &B::Header, set: &[AuthorityId] ) -> Vec<AuthorityId>

Get the jailed keygen authorities

pub async fn get_best_authorities( &self, header: &B::Header ) -> Vec<(u16, AuthorityId)>

Get the best authorities for keygen

pub async fn get_next_best_authorities( &self, header: &B::Header ) -> Vec<(u16, AuthorityId)>

Get the next best authorities for keygen

pub async fn validator_set( &self, header: &B::Header ) -> Option<(AuthoritySet<Public, MaxAuthorities>, AuthoritySet<Public, MaxAuthorities>)>

Return the next and queued validator set at header header.

Note that the validator set could be None. This is the case if we don’t find a DKG authority set change and we can’t fetch the authority set from the DKG on-chain state.

Such a failure is usually an indication that the DKG pallet has not been deployed (yet).

If the validators are None, we use the arbitrary validators gotten from the authority set and queued authority set in the given header

pub async fn verify_signature_against_authorities_inner( logger: &DebugLogger, signed_dkg_msg: SignedDKGMessage<Public>, latest_header: &Arc<RwLock<Option<B::Header>>>, client: &Arc<C> ) -> Result<DKGMessage<Public>, DKGError>

pub async fn handle_dkg_error(&self, dkg_error: DKGError)

pub fn authenticate_msg_origin( &self, is_main_round: bool, authorities: (Vec<Public>, Vec<Public>), msg: &[u8], signature: &[u8] ) -> Result<Public, DKGError>

pub async fn should_execute_new_keygen( &self, header: &B::Header ) -> AnticipatedKeygenExecutionStatus

pub async fn get_unsigned_proposal_batches( &self, header: &B::Header ) -> Result<Vec<StoredUnsignedProposalBatch<BatchId, MaxProposalLength, MaxProposalsInBatch, <<B as Block>::Header as Header>::Number>>, ApiError>

pub async fn exec_client_function<F, T>(&self, function: F) -> Twhere for<'a> F: FnOnce(&'a C) -> T + Send + 'static, T: Send + 'static,

Wraps the call in a SpawnBlocking task

pub async fn run(self)

Trait Implementations

impl<B, BE, C, GE> Clone for DKGWorker<B, BE, C, GE>where B: Block, BE: Backend<B> + 'static, C: Client<B, BE> + 'static, GE: GossipEngineIface,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B, BE, C, GE> HasLatestHeader<B> for DKGWorker<B, BE, C, GE>where B: Block, BE: Backend<B> + 'static, GE: GossipEngineIface, C: Client<B, BE> + 'static, MaxProposalLength: Get<u32>, MaxAuthorities: Get<u32>,

fn get_latest_block_number(&self) -> NumberFor<B>

Gets latest block number from latest block header

fn get_latest_header(&self) -> &Arc<RwLock<Option<B::Header>>>

impl<B, BE, C, GE> KeystoreExt for DKGWorker<B, BE, C, GE>where B: Block, BE: Backend<B>, GE: GossipEngineIface, C: Client<B, BE>, MaxProposalLength: Get<u32>, MaxAuthorities: Get<u32>,

fn get_keystore(&self) -> &DKGKeystore

fn get_authority_public_key(&self) -> Public

fn get_sr25519_public_key(&self) -> Public