Struct ClientContext

pub struct ClientContext<M> {
    client: FinalClient,
    module_instance_id: ModuleInstanceId,
    global_dbtx_access_token: GlobalDBTxAccessToken,
    module_db: Database,
    _marker: PhantomData<M>,
}

A Client context for a ClientModule M

Client modules can interact with the whole client through this struct.

Fields

client: FinalClient

module_instance_id: ModuleInstanceId

global_dbtx_access_token: GlobalDBTxAccessToken

module_db: Database

_marker: PhantomData<M>

Implementations

impl<M> ClientContext<M>

where M: ClientModule,

pub fn self_ref<'s>(&'s self) -> ClientContextSelfRef<'s, M>

Get a reference back to client module from the Self

It’s often necessary for a client module to “move self” by-value, especially due to async lifetimes issues. Clients usually work with &mut self, which can’t really work in such context.

Fortunately ClientContext is Clone and `Send, and can be used to recover the reference to the module at later time.

pub fn global_api(&self) -> DynGlobalApi

Get a reference to a global Api handle

pub fn decoders(&self) -> ModuleDecoderRegistry

pub fn input_from_dyn<'i>( &self, input: &'i DynInput, ) -> Option<&'i <M::Common as ModuleCommon>::Input>

pub fn output_from_dyn<'o>( &self, output: &'o DynOutput, ) -> Option<&'o <M::Common as ModuleCommon>::Output>

pub fn map_dyn<'s, 'i, 'o, I>( &'s self, typed: impl IntoIterator<Item = I> + 'i, ) -> impl Iterator<Item = <I as IntoDynInstance>::DynType> + 'o

where I: IntoDynInstance, 'i: 'o, 's: 'o,

pub fn make_dyn_output( &self, output: <M::Common as ModuleCommon>::Output, ) -> DynOutput

Turn a typed output into a dyn version

pub fn make_dyn_input( &self, input: <M::Common as ModuleCommon>::Input, ) -> DynInput

Turn a typed input into a dyn version

pub fn make_dyn<I>(&self, typed: I) -> <I as IntoDynInstance>::DynType

where I: IntoDynInstance,

Turn a typed into a dyn version

pub fn make_client_outputs<O, S>( &self, output: ClientOutputBundle<O, S>, ) -> ClientOutputBundle

where O: IntoDynInstance<DynType = DynOutput> + 'static, S: IntoDynInstance<DynType = DynState> + 'static,

Turn a typed ClientOutputBundle into a dyn version

pub fn make_client_inputs<I, S>( &self, inputs: ClientInputBundle<I, S>, ) -> ClientInputBundle

where I: IntoDynInstance<DynType = DynInput> + 'static, S: IntoDynInstance<DynType = DynState> + 'static,

Turn a typed ClientInputBundle into a dyn version

pub fn make_dyn_state<S>(&self, sm: S) -> DynState

where S: IState + 'static,

pub async fn finalize_and_submit_transaction<F, Meta>( &self, operation_id: OperationId, operation_type: &str, operation_meta: F, tx_builder: TransactionBuilder, ) -> Result<(TransactionId, Vec<OutPoint>)>

where F: Fn(TransactionId, Vec<OutPoint>) -> Meta + Clone + MaybeSend + MaybeSync, Meta: Serialize + MaybeSend,

See crate::Client::finalize_and_submit_transaction

pub async fn transaction_updates( &self, operation_id: OperationId, ) -> TransactionUpdates

See crate::Client::transaction_updates

pub async fn await_primary_module_outputs( &self, operation_id: OperationId, outputs: Vec<OutPoint>, ) -> Result<Amount>

See crate::Client::await_primary_module_outputs

pub async fn get_operation( &self, operation_id: OperationId, ) -> Result<OperationLogEntry>

fn global_db(&self) -> Database

Get global db.

Only intended for internal use (private).

pub fn module_db(&self) -> &Database

pub async fn has_active_states(&self, op_id: OperationId) -> bool

pub async fn operation_exists(&self, op_id: OperationId) -> bool

pub async fn get_own_active_states(&self) -> Vec<(M::States, ActiveStateMeta)>

pub async fn get_config(&self) -> ClientConfig

pub async fn get_invite_code(&self) -> InviteCode

Returns an invite code for the federation that points to an arbitrary guardian server for fetching the config

pub fn get_internal_payment_markers(&self) -> Result<(PublicKey, u64)>

pub async fn manual_operation_start( &self, operation_id: OperationId, op_type: &str, operation_meta: impl Serialize + Debug, sms: Vec<DynState>, ) -> Result<()>

This method starts n state machines with given operation id without a corresponding transaction

pub async fn manual_operation_start_dbtx( &self, dbtx: &mut DatabaseTransaction<'_>, operation_id: OperationId, op_type: &str, operation_meta: impl Serialize + Debug, sms: Vec<DynState>, ) -> Result<()>

async fn manual_operation_start_inner( &self, dbtx: &mut DatabaseTransaction<'_>, operation_id: OperationId, op_type: &str, operation_meta: impl Serialize + Debug, sms: Vec<DynState>, ) -> Result<()>

See Self::manual_operation_start, just inside a database transaction.

pub fn outcome_or_updates<U, S>( &self, operation: &OperationLogEntry, operation_id: OperationId, stream_gen: impl FnOnce() -> S, ) -> UpdateStreamOrOutcome<U>

where U: Clone + Serialize + DeserializeOwned + Debug + MaybeSend + MaybeSync + 'static, S: Stream<Item = U> + MaybeSend + 'static,

pub async fn claim_inputs<I, S>( &self, dbtx: &mut DatabaseTransaction<'_>, inputs: ClientInputBundle<I, S>, operation_id: OperationId, ) -> Result<(TransactionId, Vec<OutPoint>)>

where I: IInput + MaybeSend + MaybeSync + 'static, S: IState + MaybeSend + MaybeSync + 'static,

async fn claim_inputs_dyn( &self, dbtx: &mut DatabaseTransaction<'_>, inputs: InstancelessDynClientInputBundle, operation_id: OperationId, ) -> Result<(TransactionId, Vec<OutPoint>)>

pub async fn add_state_machines_dbtx( &self, dbtx: &mut DatabaseTransaction<'_>, states: Vec<DynState>, ) -> AddStateMachinesResult

pub async fn add_operation_log_entry_dbtx( &self, dbtx: &mut DatabaseTransaction<'_>, operation_id: OperationId, operation_type: &str, operation_meta: impl Serialize, )

pub async fn log_event<E, Cap>( &self, dbtx: &mut DatabaseTransaction<'_, Cap>, event: E, )

where E: Event + Send, Cap: Send,

Trait Implementations

impl<M> Clone for ClientContext<M>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M> Debug for ClientContext<M>

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

Formats the value using the given formatter.