pub struct MintClientModule {
pub(crate) federation_id: FederationId,
pub(crate) cfg: MintClientConfig,
pub(crate) secret: DerivableSecret,
pub(crate) secp: Secp256k1<All>,
pub(crate) notifier: ModuleNotifier<MintClientStateMachines>,
pub client_ctx: ClientContext<Self>,
}
Expand description
The MintClientModule
is responsible for handling e-cash minting
operations. It interacts with the mint server to issue, reissue, and
validate e-cash notes.
§Derivable Secret
The DerivableSecret
is a cryptographic secret that can be used to derive
other secrets. In the context of the MintClientModule
, it is used to
derive the blinding and spend keys for e-cash notes. The DerivableSecret
is initialized when the MintClientModule
is created and is kept private
within the module.
§Blinding Key
The blinding key is derived from the DerivableSecret
and is used to blind
the e-cash note during the issuance process. This ensures that the mint
server cannot link the e-cash note to the client that requested it,
providing privacy for the client.
§Spend Key
The spend key is also derived from the DerivableSecret
and is used to
spend the e-cash note. Only the client that possesses the DerivableSecret
can derive the correct spend key to spend the e-cash note. This ensures that
only the owner of the e-cash note can spend it.
Fields§
§federation_id: FederationId
§cfg: MintClientConfig
§secret: DerivableSecret
§secp: Secp256k1<All>
§notifier: ModuleNotifier<MintClientStateMachines>
§client_ctx: ClientContext<Self>
Implementations§
source§impl MintClientModule
impl MintClientModule
pub async fn prepare_plaintext_ecash_backup( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> Result<EcashBackup>
source§impl MintClientModule
impl MintClientModule
pub(crate) async fn create_sufficient_input( &self, dbtx: &mut DatabaseTransaction<'_>, operation_id: OperationId, min_amount: Amount, ) -> Result<Vec<ClientInput<MintInput, MintClientStateMachines>>>
sourcepub async fn get_notes_tier_counts(
&self,
dbtx: &mut DatabaseTransaction<'_>,
) -> TieredCounts
pub async fn get_notes_tier_counts( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> TieredCounts
Returns the number of held e-cash notes per denomination
sourcepub async fn get_available_notes_by_tier_counts(
&self,
dbtx: &mut DatabaseTransaction<'_>,
counts: TieredCounts,
) -> (TieredMulti<SpendableNoteUndecoded>, TieredCounts)
pub async fn get_available_notes_by_tier_counts( &self, dbtx: &mut DatabaseTransaction<'_>, counts: TieredCounts, ) -> (TieredMulti<SpendableNoteUndecoded>, TieredCounts)
Pick SpendableNote
s by given counts, when available
Return the notes picked, and counts of notes that were not available.
sourcepub async fn create_exact_output(
&self,
dbtx: &mut DatabaseTransaction<'_>,
operation_id: OperationId,
notes_per_denomination: u16,
exact_amount: Amount,
) -> Vec<ClientOutput<MintOutput, MintClientStateMachines>>
pub async fn create_exact_output( &self, dbtx: &mut DatabaseTransaction<'_>, operation_id: OperationId, notes_per_denomination: u16, exact_amount: Amount, ) -> Vec<ClientOutput<MintOutput, MintClientStateMachines>>
Creates a mint output with exactly the given amount
, issuing e-cash
notes such that the client holds notes_per_denomination
notes of each
e-cash note denomination held.
sourcepub async fn get_wallet_summary(
&self,
dbtx: &mut DatabaseTransaction<'_>,
) -> TieredCounts
pub async fn get_wallet_summary( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> TieredCounts
Returns the number of held e-cash notes per denomination
sourcepub async fn await_output_finalized(
&self,
operation_id: OperationId,
out_point: OutPoint,
) -> Result<Amount>
pub async fn await_output_finalized( &self, operation_id: OperationId, out_point: OutPoint, ) -> Result<Amount>
Wait for the e-cash notes to be retrieved. If this is not possible because another terminal state was reached an error describing the failure is returned.
sourcepub async fn consolidate_notes(
&self,
dbtx: &mut DatabaseTransaction<'_>,
operation_id: OperationId,
) -> Result<Vec<ClientInput<MintInput, MintClientStateMachines>>>
pub async fn consolidate_notes( &self, dbtx: &mut DatabaseTransaction<'_>, operation_id: OperationId, ) -> Result<Vec<ClientInput<MintInput, MintClientStateMachines>>>
Provisional implementation of note consolidation
When a certain denomination crosses the threshold of notes allowed, spend some chunk of them as inputs.
Return notes and the sume of their amount.
sourcepub fn create_input_from_notes(
&self,
operation_id: OperationId,
notes: TieredMulti<SpendableNote>,
) -> Result<Vec<ClientInput<MintInput, MintClientStateMachines>>>
pub fn create_input_from_notes( &self, operation_id: OperationId, notes: TieredMulti<SpendableNote>, ) -> Result<Vec<ClientInput<MintInput, MintClientStateMachines>>>
Create a mint input from external, potentially untrusted notes
pub(crate) async fn spend_notes_oob( &self, dbtx: &mut DatabaseTransaction<'_>, notes_selector: &impl NotesSelector, amount: Amount, try_cancel_after: Duration, ) -> Result<(OperationId, Vec<MintClientStateMachines>, TieredMulti<SpendableNote>)>
pub async fn await_spend_oob_refund( &self, operation_id: OperationId, ) -> SpendOOBRefund
sourcepub(crate) async fn select_notes(
dbtx: &mut DatabaseTransaction<'_>,
notes_selector: &impl NotesSelector,
requested_amount: Amount,
fee_per_note_input: Amount,
) -> Result<TieredMulti<SpendableNote>>
pub(crate) async fn select_notes( dbtx: &mut DatabaseTransaction<'_>, notes_selector: &impl NotesSelector, requested_amount: Amount, fee_per_note_input: Amount, ) -> Result<TieredMulti<SpendableNote>>
Select notes with requested_amount
using notes_selector
.
pub(crate) async fn get_all_spendable_notes( dbtx: &mut DatabaseTransaction<'_>, ) -> TieredMulti<SpendableNoteUndecoded>
pub(crate) async fn get_next_note_index( &self, dbtx: &mut DatabaseTransaction<'_>, amount: Amount, ) -> NoteIndex
sourcepub fn new_note_secret_static(
secret: &DerivableSecret,
amount: Amount,
note_idx: NoteIndex,
) -> DerivableSecret
pub fn new_note_secret_static( secret: &DerivableSecret, amount: Amount, note_idx: NoteIndex, ) -> DerivableSecret
Derive the note DerivableSecret
from the Mint’s secret
the amount
tier and note_idx
Static to help re-use in other places, that don’t have a whole Self
available
§E-Cash Note Creation
When creating an e-cash note, the MintClientModule
first derives the
blinding and spend keys from the DerivableSecret
. It then creates a
NoteIssuanceRequest
containing the blinded spend key and sends it to
the mint server. The mint server signs the blinded spend key and
returns it to the client. The client can then unblind the signed
spend key to obtain the e-cash note, which can be spent using the
spend key.
sourcepub(crate) async fn new_note_secret(
&self,
amount: Amount,
dbtx: &mut DatabaseTransaction<'_>,
) -> DerivableSecret
pub(crate) async fn new_note_secret( &self, amount: Amount, dbtx: &mut DatabaseTransaction<'_>, ) -> DerivableSecret
We always keep track of an incrementing index in the database and use it as part of the derivation path for the note secret. This ensures that we never reuse the same note secret twice.
pub async fn new_ecash_note( &self, amount: Amount, dbtx: &mut DatabaseTransaction<'_>, ) -> (NoteIssuanceRequest, BlindNonce)
sourcepub async fn reissue_external_notes<M: Serialize + Send>(
&self,
oob_notes: OOBNotes,
extra_meta: M,
) -> Result<OperationId>
pub async fn reissue_external_notes<M: Serialize + Send>( &self, oob_notes: OOBNotes, extra_meta: M, ) -> Result<OperationId>
Try to reissue e-cash notes received from a third party to receive them
in our wallet. The progress and outcome can be observed using
MintClientModule::subscribe_reissue_external_notes
.
Can return error of type ReissueExternalNotesError
sourcepub async fn subscribe_reissue_external_notes(
&self,
operation_id: OperationId,
) -> Result<UpdateStreamOrOutcome<ReissueExternalNotesState>>
pub async fn subscribe_reissue_external_notes( &self, operation_id: OperationId, ) -> Result<UpdateStreamOrOutcome<ReissueExternalNotesState>>
Subscribe to updates on the progress of a reissue operation started with
MintClientModule::reissue_external_notes
.
sourcepub async fn spend_notes<M: Serialize + Send>(
&self,
min_amount: Amount,
try_cancel_after: Duration,
include_invite: bool,
extra_meta: M,
) -> Result<(OperationId, OOBNotes)>
pub async fn spend_notes<M: Serialize + Send>( &self, min_amount: Amount, try_cancel_after: Duration, include_invite: bool, extra_meta: M, ) -> Result<(OperationId, OOBNotes)>
Fetches and removes notes of at least amount min_amount
from the
wallet to be sent to the recipient out of band. These spends can be
canceled by calling MintClientModule::try_cancel_spend_notes
as long
as the recipient hasn’t reissued the e-cash notes themselves yet.
The client will also automatically attempt to cancel the operation after
try_cancel_after
time has passed. This is a safety mechanism to avoid
users forgetting about failed out-of-band transactions. The timeout
should be chosen such that the recipient (who is potentially offline at
the time of receiving the e-cash notes) had a reasonable timeframe to
come online and reissue the notes themselves.
sourcepub async fn spend_notes_with_selector<M: Serialize + Send>(
&self,
notes_selector: &impl NotesSelector,
requested_amount: Amount,
try_cancel_after: Duration,
include_invite: bool,
extra_meta: M,
) -> Result<(OperationId, OOBNotes)>
pub async fn spend_notes_with_selector<M: Serialize + Send>( &self, notes_selector: &impl NotesSelector, requested_amount: Amount, try_cancel_after: Duration, include_invite: bool, extra_meta: M, ) -> Result<(OperationId, OOBNotes)>
Same as spend_notes
but allows different to select notes to be used.
sourcepub fn validate_notes(&self, oob_notes: &OOBNotes) -> Result<Amount>
pub fn validate_notes(&self, oob_notes: &OOBNotes) -> Result<Amount>
Validate the given notes and return the total amount of the notes. Validation checks that:
- the federation ID is correct
- the note has a valid signature
- the spend key is correct.
sourcepub async fn try_cancel_spend_notes(&self, operation_id: OperationId)
pub async fn try_cancel_spend_notes(&self, operation_id: OperationId)
Try to cancel a spend operation started with
MintClientModule::spend_notes
. If the e-cash notes have already been
spent this operation will fail which can be observed using
MintClientModule::subscribe_spend_notes
.
sourcepub async fn subscribe_spend_notes(
&self,
operation_id: OperationId,
) -> Result<UpdateStreamOrOutcome<SpendOOBState>>
pub async fn subscribe_spend_notes( &self, operation_id: OperationId, ) -> Result<UpdateStreamOrOutcome<SpendOOBState>>
Subscribe to updates on the progress of a raw e-cash spend operation
started with MintClientModule::spend_notes
.
pub(crate) async fn mint_operation( &self, operation_id: OperationId, ) -> Result<OperationLogEntry>
pub(crate) async fn delete_spendable_note( client_ctx: &ClientContext<MintClientModule>, dbtx: &mut DatabaseTransaction<'_>, amount: Amount, note: &SpendableNote, )
pub async fn advance_note_idx(&self, amount: Amount) -> Result<DerivableSecret>
Trait Implementations§
source§impl ClientModule for MintClientModule
impl ClientModule for MintClientModule
type Init = MintClientInit
source§type Common = MintModuleTypes
type Common = MintModuleTypes
source§type Backup = EcashBackup
type Backup = EcashBackup
source§type ModuleStateMachineContext = MintClientContext
type ModuleStateMachineContext = MintClientContext
source§type States = MintClientStateMachines
type States = MintClientStateMachines
fn context(&self) -> Self::ModuleStateMachineContext
source§fn input_fee(
&self,
_amount: Amount,
_input: &<Self::Common as ModuleCommon>::Input,
) -> Option<Amount>
fn input_fee( &self, _amount: Amount, _input: &<Self::Common as ModuleCommon>::Input, ) -> Option<Amount>
source§fn output_fee(
&self,
_output: &<Self::Common as ModuleCommon>::Output,
) -> Option<Amount>
fn output_fee( &self, _output: &<Self::Common as ModuleCommon>::Output, ) -> Option<Amount>
fn handle_cli_command<'life0, 'life1, 'async_trait>(
&'life0 self,
args: &'life1 [OsString],
) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
fn supports_backup(&self) -> bool
fn backup<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<EcashBackup>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
source§fn supports_being_primary(&self) -> bool
fn supports_being_primary(&self) -> bool
source§fn create_final_inputs_and_outputs<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
dbtx: &'life1 mut DatabaseTransaction<'life2>,
operation_id: OperationId,
input_amount: Amount,
output_amount: Amount,
) -> Pin<Box<dyn Future<Output = Result<(Vec<ClientInput<MintInput, MintClientStateMachines>>, Vec<ClientOutput<MintOutput, MintClientStateMachines>>)>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
fn create_final_inputs_and_outputs<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
dbtx: &'life1 mut DatabaseTransaction<'life2>,
operation_id: OperationId,
input_amount: Amount,
output_amount: Amount,
) -> Pin<Box<dyn Future<Output = Result<(Vec<ClientInput<MintInput, MintClientStateMachines>>, Vec<ClientOutput<MintOutput, MintClientStateMachines>>)>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
source§fn await_primary_module_output<'life0, 'async_trait>(
&'life0 self,
operation_id: OperationId,
out_point: OutPoint,
) -> Pin<Box<dyn Future<Output = Result<Amount>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn await_primary_module_output<'life0, 'async_trait>(
&'life0 self,
operation_id: OperationId,
out_point: OutPoint,
) -> Pin<Box<dyn Future<Output = Result<Amount>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
Self::create_final_inputs_and_outputs
to become available. This
function returning typically implies a change in the output of
Self::get_balance
.source§fn get_balance<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
dbtx: &'life1 mut DatabaseTransaction<'life2>,
) -> Pin<Box<dyn Future<Output = Amount> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
fn get_balance<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
dbtx: &'life1 mut DatabaseTransaction<'life2>,
) -> Pin<Box<dyn Future<Output = Amount> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
source§fn subscribe_balance_changes<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = BoxStream<'static, ()>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn subscribe_balance_changes<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = BoxStream<'static, ()>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
source§fn leave<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
dbtx: &'life1 mut DatabaseTransaction<'life2>,
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
fn leave<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
dbtx: &'life1 mut DatabaseTransaction<'life2>,
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
fn handle_rpc<'life0, 'async_trait>(
&'life0 self,
method: String,
request: Value,
) -> Pin<Box<dyn Future<Output = BoxStream<'_, Result<Value>>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn decoder() -> Decoder
fn kind() -> ModuleKind
Auto Trait Implementations§
impl Freeze for MintClientModule
impl !RefUnwindSafe for MintClientModule
impl Send for MintClientModule
impl Sync for MintClientModule
impl Unpin for MintClientModule
impl !UnwindSafe for MintClientModule
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Conv for T
impl<T> Conv for T
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.§impl<T> DowncastSync for T
impl<T> DowncastSync for T
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self>
fn with_context(self, otel_cx: Context) -> WithContext<Self>
§fn with_current_context(self) -> WithContext<Self>
fn with_current_context(self) -> WithContext<Self>
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self>
fn with_context(self, otel_cx: Context) -> WithContext<Self>
§fn with_current_context(self) -> WithContext<Self>
fn with_current_context(self) -> WithContext<Self>
source§impl<T> IClientModule for Twhere
T: ClientModule,
impl<T> IClientModule for Twhere
T: ClientModule,
fn as_any(&self) -> &(dyn Any + Sync + Send + 'static)
fn decoder(&self) -> Decoder
fn context(&self, instance: u16) -> DynContext
fn start<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
'life0: 'async_trait,
T: 'async_trait,
fn handle_cli_command<'life0, 'life1, 'async_trait>(
&'life0 self,
args: &'life1 [OsString],
) -> Pin<Box<dyn Future<Output = Result<Value, Error>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
T: 'async_trait,
fn handle_rpc<'life0, 'async_trait>(
&'life0 self,
method: String,
request: Value,
) -> Pin<Box<dyn Future<Output = Pin<Box<dyn Stream<Item = Result<Value, Error>> + Send + 'life0>>> + Send + 'async_trait>>where
'life0: 'async_trait,
T: 'async_trait,
fn input_fee(&self, amount: Amount, input: &DynInput) -> Option<Amount>
fn output_fee(&self, output: &DynOutput) -> Option<Amount>
fn supports_backup(&self) -> bool
fn backup<'life0, 'async_trait>(
&'life0 self,
module_instance_id: u16,
) -> Pin<Box<dyn Future<Output = Result<DynModuleBackup, Error>> + Send + 'async_trait>>where
'life0: 'async_trait,
T: 'async_trait,
fn supports_being_primary(&self) -> bool
fn create_final_inputs_and_outputs<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
module_instance: u16,
dbtx: &'life1 mut DatabaseTransaction<'life2>,
operation_id: OperationId,
input_amount: Amount,
output_amount: Amount,
) -> Pin<Box<dyn Future<Output = Result<(Vec<ClientInput>, Vec<ClientOutput>), Error>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
T: 'async_trait,
fn await_primary_module_output<'life0, 'async_trait>(
&'life0 self,
operation_id: OperationId,
out_point: OutPoint,
) -> Pin<Box<dyn Future<Output = Result<Amount, Error>> + Send + 'async_trait>>where
'life0: 'async_trait,
T: 'async_trait,
fn get_balance<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
module_instance: u16,
dbtx: &'life1 mut DatabaseTransaction<'life2>,
) -> Pin<Box<dyn Future<Output = Amount> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
T: 'async_trait,
fn subscribe_balance_changes<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Pin<Box<dyn Stream<Item = ()> + Send>>> + Send + 'async_trait>>where
'life0: 'async_trait,
T: 'async_trait,
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
source§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T
in a tonic::Request
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.