Struct StateManager

pub struct StateManager<T: Owner> {
    pub db: Database,
    queue: PGMQueueExt,
    owner: T,
    round_machines: Vec<InitializedStateMachine<RoundStateMachine<T>>>,
    kickoff_machines: Vec<InitializedStateMachine<KickoffStateMachine<T>>>,
    context: StateContext<T>,
    paramset: &'static ProtocolParamset,
    next_height_to_process: u32,
}

State manager stores the state machines. It is responsible for following: - Persisting current state of the state machines to the database. - Collecting new SystemEvents from the message queue and passing them to the state machines, thus updating the state machines.

Fields

db: Database

queue: PGMQueueExt

owner: T

round_machines: Vec<InitializedStateMachine<RoundStateMachine<T>>>

kickoff_machines: Vec<InitializedStateMachine<KickoffStateMachine<T>>>

context: StateContext<T>

paramset: &'static ProtocolParamset

next_height_to_process: u32

Implementations

impl<T: Owner + Debug + 'static> StateManager<T>

pub async fn dispatch_new_round_machine( db: Database, tx: DatabaseTransaction<'_, '_>, operator_data: OperatorData, ) -> Result<(), Report>

Appends a message to the state manager’s message queue to create a new round state machine

pub async fn dispatch_new_kickoff_machine( db: Database, tx: DatabaseTransaction<'_, '_>, kickoff_data: KickoffData, kickoff_height: u32, deposit_data: DepositData, payout_blockhash: Witness, ) -> Result<(), Report>

Appends a message to the state manager’s message queue to create a new kickoff state machine

pub fn update_block_cache(&mut self, block: &Block, block_height: u32)

Updates the block cache with the new block Sets the block cache in the context

pub async fn handle_event( &mut self, event: SystemEvent, dbtx: DatabaseTransaction<'_, '_>, ) -> Result<(), BridgeError>

Handles the system events

impl<T: Owner + Debug + 'static> StateManager<T>

pub async fn block_fetcher_task( &self, ) -> Result<WithDelay<impl Task<Output = bool> + Debug>, BridgeError>

impl<T: Owner + Debug + 'static> StateManager<T>

pub fn queue_name() -> String

Returns message queue name for the state manager.

pub async fn new( db: Database, owner: T, paramset: &'static ProtocolParamset, ) -> Result<Self>

pub async fn load_from_db(&mut self) -> Result<(), BridgeError>

Loads the state machines from the database. This method should be called when initializing the StateManager.

Errors

Returns a BridgeError if the database operation fails

pub async fn save_state_to_db( &mut self, block_height: u32, dbtx: Option<DatabaseTransaction<'_, '_>>, ) -> Result<()>

Saves the state machines with dirty flag set to the database. Resets the dirty flag for all machines after successful save.

Errors

Returns a BridgeError if the database operation fails.

pub fn get_next_height_to_process(&self) -> u32

fn update_machines<'a, M>( machines: &mut Vec<InitializedStateMachine<M>>, base_context: &'a StateContext<T>, ) -> (Vec<InitializedStateMachine<M>>, Vec<impl Future<Output = (InitializedStateMachine<M>, StateContext<T>)> + Send + 'a>)

where M: IntoStateMachine + Send + Sync + 'static, M::State: Send + Sync + 'static, InitializedStateMachine<M>: ContextProcessor<T, M>,

Updates the machines using the context and returns machines without events and futures that process new events for machines that changed. Empties the machines vector.

Parameters

• machines: A mutable reference to the vector of state machines to update.
• base_context: A reference to the base state context.

Returns

A tuple of the unchanged machines and the futures that process new events for machines that generated events.

Type Parameters

• M: The type of the state machine.
• a: The lifetime of the state context reference (the future captures the context by reference).

pub async fn process_and_add_new_states_from_height( &mut self, new_round_machines: Vec<InitializedStateMachine<RoundStateMachine<T>>>, new_kickoff_machines: Vec<InitializedStateMachine<KickoffStateMachine<T>>>, start_height: u32, ) -> Result<(), Report>

Given some new states and a start height, process the states from the given start height until the next height to process. Then append the new states to the current state machines.

pub async fn process_block_parallel( &mut self, block_height: u32, ) -> Result<(), Report>

It requires that the block cache is updated before calling this function. Moves all state machines forward in parallel. The state machines are updated until all of them stabilize in their state (ie. the block does not generate any new events)

Errors

If the state machines do not stabilize after some iterations, we return an error.

Trait Implementations

impl<T: Clone + Owner> Clone for StateManager<T>

fn clone(&self) -> StateManager<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Owner> Debug for StateManager<T>

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

Formats the value using the given formatter.

impl<T: Owner + Debug + 'static> IntoTask for StateManager<T>

fn into_task(self) -> Self::Task

Converts the StateManager into the consumer task with a polling delay.

type Task = WithDelay<BufferedErrors<MessageConsumerTask<T>>>