Enum nash_protocol::protocol::ProtocolHook

pub enum ProtocolHook {
    SignAllState(SignAllStates),
    Protocol(NashProtocolRequest),
}

Captures and protocol request or pipeline that can be executed in a run_before or run_after hook for the NashProtocol and NashProtocolPipeline traits.

Variants

SignAllState(SignAllStates)

Tuple Fields of SignAllState

0: SignAllStates

Protocol(NashProtocolRequest)

Tuple Fields of Protocol

0: NashProtocolRequest

Trait Implementations

impl Clone for ProtocolHook

fn clone(&self) -> ProtocolHook

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProtocolHook

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

Formats the value using the given formatter.

impl NashProtocolPipeline for ProtocolHook

Implement NashProtocolPipeline for ProtocolHook so that hooks can be run as typical pipelines

type PipelineState = ProtocolHookState

State managed by pipeline and used to hold intermediate results and allow the implementer to decide whether the pipeline is over

type ActionType = NashProtocolRequest

Wrapper type for all actions this pipeline can take

fn acquire_permit<'life0, 'async_trait>(
    &'life0 self,
    state: Arc<RwLock<State>>
) -> Pin<Box<dyn Future<Output = Option<OwnedSemaphorePermit>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

If you want to limit the amount of concurrency of a pipeline return a Semaphore here

fn init_state<'life0, 'async_trait>(
    &'life0 self,
    state: Arc<RwLock<State>>
) -> Pin<Box<dyn Future<Output = Self::PipelineState> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Create initial state for the pipeline

fn next_step<'life0, 'life1, 'async_trait>(
    &'life0 self,
    pipeline_state: &'life1 Self::PipelineState,
    client_state: Arc<RwLock<State>>
) -> Pin<Box<dyn Future<Output = Result<Option<Self::ActionType>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Give next action to take or return None if pipeline is finished. &State needs to be mutable as client may modify itself when producing the next step (e.g., removing and r value generate a signature)

fn process_step<'life0, 'life1, 'async_trait>(
    &'life0 self,
    result: <NashProtocolRequest as NashProtocol>::Response,
    pipeline_state: &'life1 mut Self::PipelineState
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Process the results of a pipeline step

fn output(
    &self,
    pipeline_state: Self::PipelineState
) -> Result<ResponseOrError<NashProtocolResponse>>

Get results from pipeline or None if the pipeline is not finished

fn run_before<'life0, 'async_trait>(
    &'life0 self,
    state: Arc<RwLock<State>>
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ProtocolHook>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

fn run_after<'life0, 'async_trait>(
    &'life0 self,
    state: Arc<RwLock<State>>
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ProtocolHook>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait,