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>>>,
    config: BridgeConfig,
    next_height_to_process: u32,
    rpc: ExtendedBitcoinRpc,
    last_finalized_block: Option<Arc<BlockCache>>,
}

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>>>

config: BridgeConfig

next_height_to_process: u32

rpc: ExtendedBitcoinRpc

last_finalized_block: Option<Arc<BlockCache>>

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 async fn handle_event( &mut self, event: SystemEvent, dbtx: Arc<Mutex<Transaction<'static, Postgres>>>, ) -> 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 fn clone_without_machines(&self) -> Self

pub fn new_context( &self, dbtx: Arc<Mutex<Transaction<'static, Postgres>>>, block: &Block, block_height: u32, ) -> Result<StateContext<T>, BridgeError>

Warning: This is costly due to the calculation of the block_cache, use a pre-existing block_cache with the new_context_with_block_cache method if possible.

pub fn new_context_with_block_cache( &self, dbtx: Arc<Mutex<Transaction<'static, Postgres>>>, block_cache: Arc<BlockCache>, ) -> Result<StateContext<T>, BridgeError>

pub async fn new( db: Database, owner: T, rpc: ExtendedBitcoinRpc, config: BridgeConfig, ) -> Result<Self>

async fn get_block( &self, dbtx: Option<DatabaseTransaction<'_, '_>>, height: u32, ) -> Result<Block, BridgeError>

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

Loads the state manager and its 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, context: &mut StateContext<T>, ) -> Result<()>

Saves the state machines with dirty flag set to the database. Uses the database transaction from the context if any. 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, dbtx: Arc<Mutex<Transaction<'static, Postgres>>>, 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, context: &mut StateContext<T>, ) -> 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>>>