Struct RoundStateMachine

pub struct RoundStateMachine<T: Owner> {
    pub(crate) matchers: HashMap<Matcher, RoundEvent>,
    pub(crate) operator_data: OperatorData,
    pub(crate) dirty: bool,
    phantom: PhantomData<T>,
}

State machine for the round state. It has following states: - initial_collateral: The initial collateral state, when the operator didn’t create the first round tx yet. - round_tx: The round tx state, when the operator’s collateral utxo is currently in a round tx. - ready_to_reimburse: The ready to reimburse state, when the operator’s collateral utxo is currently in a ready to reimburse tx. - operator_exit: The operator exit state, when the operator exited the protocol (collateral spent in a non-bridge tx).

It has following events:

• KickoffUtxoUsed: The kickoff utxo is used in a round tx. The state machine stores this utxo as used, and additionally calls the owner to check if this kickoff utxo was used in a kickoff tx (If so, that will result in creation of a kickoff state machine).
• ReadyToReimburseSent: The ready to reimburse tx is sent. The state machine transitions to the ready to reimburse state. Additionally, if there are unused kickoff utxos, this information is passed to the owner which can then create a “Unspent Kickoff Connector” tx.
• RoundSent: The round tx is sent. The state machine transitions to the round tx state.
• OperatorExit: The operator exited the protocol. The state machine transitions to the operator exit state. In this state, all tracking of the operator is stopped as operator is no longer participating in the protocol.
• SavedToDb: The state machine has been saved to the database and the dirty flag should be reset to false.

Fields

matchers: HashMap<Matcher, RoundEvent>

Maps matchers to the resulting round events.

operator_data: OperatorData

Data of the operator that is being tracked.

dirty: bool

Indicates if the state machine has unsaved changes that need to be persisted on db. dirty flag is set if any matcher matches the current block. the flag is set to true in on_transition and on_dispatch the flag is set to false after the state machine is saved to db and the event SavedToDb is dispatched

phantom: PhantomData<T>

Implementations

impl<T: Owner> RoundStateMachine<T>

pub fn new(operator_data: OperatorData) -> Self

impl<T: Owner> RoundStateMachine<T>

pub(crate) fn on_transition(&mut self, state_a: &State, state_b: &State)

pub fn round_meta(&self, method: &'static str) -> StateMachineError

async fn unhandled_event( &mut self, context: &mut StateContext<T>, event: &RoundEvent, )

pub(crate) fn on_dispatch( &mut self, _state: StateOrSuperstate<'_, '_, Self>, evt: &RoundEvent, )

pub(crate) async fn initial_collateral( &mut self, event: &RoundEvent, context: &mut StateContext<T>, ) -> Response<State>

pub(crate) async fn on_initial_collateral_entry( &mut self, context: &mut StateContext<T>, )

Entry action for the initial collateral state. This method adds the matcher for the first round tx and the matcher if the operator exits the protocol by not spending the collateral in the first round tx.

pub(crate) async fn round_tx( &mut self, event: &RoundEvent, round_idx: &mut RoundIndex, used_kickoffs: &mut HashSet<usize>, challenged_before: &mut bool, context: &mut StateContext<T>, ) -> Response<State>

State that represents a round tx. This state is entered when a round tx is mined. It is exited when the operator sends the ready to reimburse tx or exits the protocol.

pub(crate) async fn operator_exit( &mut self, event: &RoundEvent, context: &mut StateContext<T>, ) -> Response<State>

State that represents the operator exiting the protocol.

pub(crate) async fn on_operator_exit_entry(&mut self)

Entry action for the operator exit state. This method removes all matchers for the round state machine. We do not care about anything after the operator exits the protocol. For example, even if operator sends a kickoff after exiting the protocol, that kickoff is useless as reimburse connector utxo of that kickoff is in the next round, which cannot be created anymore as the collateral is spent. So we do not want to challenge it, etc.

pub(crate) async fn on_round_tx_exit( &mut self, round_idx: &mut RoundIndex, used_kickoffs: &mut HashSet<usize>, context: &mut StateContext<T>, )

Exit action for the round tx state. This method will check if all kickoffs were used in the round. If not, the owner will send a “Unspent Kickoff Connector” tx, slashing the operator.

pub(crate) async fn on_round_tx_entry( &mut self, round_idx: &mut RoundIndex, challenged_before: &mut bool, context: &mut StateContext<T>, )

Entry action for the round tx state. This method adds the matchers for the round tx and the ready to reimburse tx. It adds the matchers for the kickoff utxos in the round tx. It also adds the matchers for the operator exit.

pub(crate) async fn ready_to_reimburse( &mut self, event: &RoundEvent, context: &mut StateContext<T>, round_idx: &mut RoundIndex, ) -> Response<State>

pub(crate) async fn on_ready_to_reimburse_entry( &mut self, context: &mut StateContext<T>, round_idx: &mut RoundIndex, )

Entry action for the ready to reimburse state. This method adds the matchers for the next round tx and the operator exit.

Trait Implementations

impl<T: Owner> BlockMatcher for RoundStateMachine<T>

type StateEvent = RoundEvent

fn match_block(&self, block: &BlockCache) -> Vec<Self::StateEvent>

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

fn clone(&self) -> RoundStateMachine<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 RoundStateMachine<T>

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

Formats the value using the given formatter.

impl<'de, T: Owner> Deserialize<'de> for RoundStateMachine<T>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Owner> IntoStateMachine for RoundStateMachine<T>

const INITIAL: State

Initial state of the state machine.

const ON_TRANSITION: fn(_: &mut Self, _: &Self::State, _: &Self::State) = Self::on_transition

Method that is called after every transition.

const ON_DISPATCH: fn(_: &mut Self, _: StateOrSuperstate<'_, '_, Self>, _: &Self::Event<'_>) = Self::on_dispatch

Method that is called before an event is dispatched to a state or superstate handler.

type Event<'event> = RoundEvent

Event that is processed by the state machine.

type Context<'context> = StateContext<T>

External context that can be passed in.

type State = State

Enumeration of the various states.

type Superstate<'sub> = Superstate

Enumeration of the various superstates.

impl<T: PartialEq + Owner> PartialEq for RoundStateMachine<T>

fn eq(&self, other: &RoundStateMachine<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Owner> Serialize for RoundStateMachine<T>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Owner> State<RoundStateMachine<T>> for State

fn call_handler<'fut>( &'fut mut self, shared_storage: &'fut mut RoundStateMachine<T>, event: &'fut <RoundStateMachine<T> as IntoStateMachine>::Event<'_>, context: &'fut mut <RoundStateMachine<T> as IntoStateMachine>::Context<'_>, ) -> Pin<Box<dyn Future<Output = Response<Self>> + Send + 'fut>>

Call the handler for the current state and let it handle the given event.

fn call_entry_action<'fut>( &'fut mut self, shared_storage: &'fut mut RoundStateMachine<T>, context: &'fut mut <RoundStateMachine<T> as IntoStateMachine>::Context<'_>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'fut>>

Call the entry action for the current state.

fn call_exit_action<'fut>( &'fut mut self, shared_storage: &'fut mut RoundStateMachine<T>, context: &'fut mut <RoundStateMachine<T> as IntoStateMachine>::Context<'_>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'fut>>

Call the exit action for the current state.

fn superstate( &mut self, ) -> Option<<RoundStateMachine<T> as IntoStateMachine>::Superstate<'_>>

Return the superstate of the current state, if there is one.

impl<'sub, T: Owner> Superstate<RoundStateMachine<T>> for Superstate

where Self: 'sub,

fn call_handler<'fut>( &'fut mut self, shared_storage: &'fut mut RoundStateMachine<T>, event: &'fut <RoundStateMachine<T> as IntoStateMachine>::Event<'_>, context: &'fut mut <RoundStateMachine<T> as IntoStateMachine>::Context<'_>, ) -> Pin<Box<dyn Future<Output = Response<<RoundStateMachine<T> as IntoStateMachine>::State>> + Send + 'fut>>

Call the handler for the current superstate.

fn call_entry_action<'fut>( &'fut mut self, shared_storage: &'fut mut RoundStateMachine<T>, context: &'fut mut <RoundStateMachine<T> as IntoStateMachine>::Context<'_>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'fut>>

Call the entry action for the current superstate.

fn call_exit_action<'fut>( &'fut mut self, shared_storage: &'fut mut RoundStateMachine<T>, context: &'fut mut <RoundStateMachine<T> as IntoStateMachine>::Context<'_>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'fut>>

Call the exit action for the current superstate.

fn superstate( &mut self, ) -> Option<<RoundStateMachine<T> as IntoStateMachine>::Superstate<'_>>

Return the superstate of the current superstate, if there is one.

impl<T: Eq + Owner> Eq for RoundStateMachine<T>

impl<T: Owner> StructuralPartialEq for RoundStateMachine<T>