Struct Actor 

pub(crate) struct Actor<TContext> {

    actions_tx: UnboundedSender<Message>,
    actions_rx: UnboundedReceiver<Message>,
    subblock_transactions_rx: Receiver<Recovered<TempoTxEnvelope>>,
    our_subblock: PendingSubblock,
    scheme_provider: SchemeProvider,
    context: TContext,
    signer: PrivateKey,
    node: TempoFullNode,
    fee_recipient: Address,
    time_to_build_subblock: Duration,
    subblock_broadcast_interval: Duration,
    epoch_length: u64,
    consensus_tip: Option<(Round, BlockHash, Signature<MinSig>)>,
    subblocks: IndexMap<B256, RecoveredSubBlock>,
    subblock_transactions: Arc<Mutex<IndexMap<TxHash, Arc<Recovered<TempoTxEnvelope>>>>>,
}

Task managing collected subblocks.

This actor is responsible for tracking consensus events and determining current tip of the chain and next block’s proposer.

Once next block proposer is known, we immediately start building a new subblock. Once it’s built, we broadcast it to the next proposer directly.

Upon receiving a subblock from the network, we ensure that we are the proposer and verify the block on top of latest state.

Fields

actions_tx: UnboundedSender<Message>

Sender of messages to the service.

actions_rx: UnboundedReceiver<Message>

Receiver of events to the service.

subblock_transactions_rx: Receiver<Recovered<TempoTxEnvelope>>

Stream of subblock transactions from RPC.

our_subblock: PendingSubblock

Handle to a task building a new subblock.

scheme_provider: SchemeProvider

Scheme provider to track participants of each epoch.

context: TContext

Commonware runtime context.

signer: PrivateKey

ed25519 private key used for consensus.

node: TempoFullNode

Execution layer node.

fee_recipient: Address

Fee recipient address to set for subblocks.

time_to_build_subblock: Duration

Timeout for building a subblock.

subblock_broadcast_interval: Duration

How often to broadcast subblocks to the current proposer.

epoch_length: u64

Length of an epoch in blocks.

consensus_tip: Option<(Round, BlockHash, Signature<MinSig>)>

Current consensus tip. Includes highest observed round, digest and certificate.

subblocks: IndexMap<B256, RecoveredSubBlock>

Collected subblocks keyed by validator public key.

subblock_transactions: Arc<Mutex<IndexMap<TxHash, Arc<Recovered<TempoTxEnvelope>>>>>

Subblock candidate transactions.

Implementations

impl<TContext: Spawner + Metrics + Pacer> Actor<TContext>

pub(crate) fn new(_: Config<TContext>) -> Self

pub(crate) fn mailbox(&self) -> Mailbox

Returns a handle to the subblocks service.

pub(crate) async fn run( self, __arg1: (impl Sender<PublicKey = PublicKey>, impl Receiver<PublicKey = PublicKey>), )

fn tip(&self) -> Option<BlockHash>

Returns the current consensus tip.

fn on_new_message(&mut self, action: Message)

fn on_new_subblock_transaction(&self, transaction: Recovered<TempoTxEnvelope>)

fn on_consensus_event( &mut self, event: Activity<Scheme<PublicKey, MinSig>, Digest>, )

Tracking of the current sconsensus state by listening to notarizations and nullifications.

fn build_new_subblock( &mut self, parent_hash: BlockHash, next_proposer: PublicKey, scheme: Arc<Scheme<PublicKey, MinSig>>, )

async fn on_network_message( &mut self, sender: PublicKey, message: Bytes, network_tx: &mut impl Sender<PublicKey = PublicKey>, ) -> Result<()>

fn on_validated_subblock(&mut self, subblock: RecoveredSubBlock)

async fn on_built_subblock( &mut self, subblock: Result<RecoveredSubBlock, Error>, next_proposer: PublicKey, )

async fn broadcast_built_subblock( &mut self, network_tx: &mut impl Sender<PublicKey = PublicKey>, )

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.