fedimint_mint_client

Struct MintClientModule

source
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

source§

impl MintClientModule

source

pub(crate) async fn create_sufficient_input( &self, dbtx: &mut DatabaseTransaction<'_>, operation_id: OperationId, min_amount: Amount, ) -> Result<Vec<ClientInput<MintInput, MintClientStateMachines>>>

source

pub async fn get_notes_tier_counts( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> TieredCounts

Returns the number of held e-cash notes per denomination

source

pub async fn get_available_notes_by_tier_counts( &self, dbtx: &mut DatabaseTransaction<'_>, counts: TieredCounts, ) -> (TieredMulti<SpendableNoteUndecoded>, TieredCounts)

Pick SpendableNotes by given counts, when available

Return the notes picked, and counts of notes that were not available.

source

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.

source

pub async fn get_wallet_summary( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> TieredCounts

Returns the number of held e-cash notes per denomination

source

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.

source

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.

source

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

source

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

source

pub async fn await_spend_oob_refund( &self, operation_id: OperationId, ) -> SpendOOBRefund

source

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.

source

pub(crate) async fn get_all_spendable_notes( dbtx: &mut DatabaseTransaction<'_>, ) -> TieredMulti<SpendableNoteUndecoded>

source

pub(crate) async fn get_next_note_index( &self, dbtx: &mut DatabaseTransaction<'_>, amount: Amount, ) -> NoteIndex

source

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.

source

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.

source

pub async fn new_ecash_note( &self, amount: Amount, dbtx: &mut DatabaseTransaction<'_>, ) -> (NoteIssuanceRequest, BlindNonce)

source

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

source

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.

source

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.

source

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.

source

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

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.

source

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.

source

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

source

pub(crate) async fn delete_spendable_note( client_ctx: &ClientContext<MintClientModule>, dbtx: &mut DatabaseTransaction<'_>, amount: Amount, note: &SpendableNote, )

source

pub async fn advance_note_idx(&self, amount: Amount) -> Result<DerivableSecret>

Trait Implementations§

source§

impl ClientModule for MintClientModule

source§

type Init = MintClientInit

source§

type Common = MintModuleTypes

Common module types shared between client and server
source§

type Backup = EcashBackup

Data stored in regular backups so that restoring doesn’t have to start from epoch 0
source§

type ModuleStateMachineContext = MintClientContext

Data and API clients available to state machine transitions of this module
source§

type States = MintClientStateMachines

All possible states this client can submit to the executor
source§

fn context(&self) -> Self::ModuleStateMachineContext

source§

fn input_fee( &self, _amount: Amount, _input: &<Self::Common as ModuleCommon>::Input, ) -> Option<Amount>

Returns the fee the processing of this input requires. Read more
source§

fn output_fee( &self, _output: &<Self::Common as ModuleCommon>::Output, ) -> Option<Amount>

Returns the fee the processing of this output requires. Read more
source§

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,

source§

fn supports_backup(&self) -> bool

source§

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

Does this module support being a primary module Read more
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,

Creates all inputs and outputs necessary to balance the transaction. The function returns an error if and only if the client’s funds are not sufficient to create the inputs necessary to fully fund the transaction. Read more
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,

Waits for the funds from an output created by 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,

Returns the balance held by this module and available for funding transactions.
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,

Returns a stream that will output the updated module balance each time it changes.
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,

Leave the federation Read more
source§

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,

source§

fn decoder() -> Decoder

source§

fn kind() -> ModuleKind

source§

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: Sync + 'async_trait,

Initialize client. Read more
source§

impl Debug for MintClientModule

source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

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

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

Convert &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)

Convert &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
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
source§

impl<T> IClientModule for T
where T: ClientModule,

source§

fn as_any(&self) -> &(dyn Any + Sync + Send + 'static)

source§

fn decoder(&self) -> Decoder

source§

fn context(&self, instance: u16) -> DynContext

source§

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where 'life0: 'async_trait, T: 'async_trait,

source§

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,

source§

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,

source§

fn input_fee(&self, amount: Amount, input: &DynInput) -> Option<Amount>

source§

fn output_fee(&self, output: &DynOutput) -> Option<Amount>

source§

fn supports_backup(&self) -> bool

source§

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,

source§

fn supports_being_primary(&self) -> bool

source§

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,

source§

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,

source§

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,

source§

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

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoRequest<T> for T

source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows 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) -> R
where R: 'a,

Mutably borrows 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
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows 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
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows 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
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .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
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .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
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
source§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSend for T
where T: Send,

source§

impl<T> MaybeSync for T
where T: Sync,