fedimint_ln_server

Struct Lightning

source
pub struct Lightning {
    pub(crate) cfg: LightningConfig,
    pub(crate) btc_rpc: DynBitcoindRpc,
    pub(crate) our_peer_id: PeerId,
}
Expand description

The lightning module implements an account system. It does not have the privacy guarantees of the e-cash mint module but instead allows for smart contracting. There exist two contract types that can be used to “lock” accounts:

  • Outgoing: an account locked with an HTLC-like contract allowing to incentivize an external Lightning node to make payments for the funder
  • Incoming: a contract type that represents the acquisition of a preimage belonging to a hash. Every incoming contract is preceded by an offer that specifies how much the seller is asking for the preimage to a particular hash. It also contains some threshold-encrypted data. Once the contract is funded the data is decrypted. If it is a valid preimage the contract’s funds are now accessible to the creator of the offer, if not they are accessible to the funder.

These two primitives allow to integrate the federation with the wider Lightning network through a centralized but untrusted (except for availability) Lightning gateway server.

Fields§

§cfg: LightningConfig§btc_rpc: DynBitcoindRpc§our_peer_id: PeerId

Implementations§

source§

impl Lightning

source

pub(crate) fn new( cfg: LightningConfig, task_group: &TaskGroup, our_peer_id: PeerId, ) -> Result<Self>

source

pub(crate) async fn block_count(&self) -> Result<u64>

source

pub(crate) async fn consensus_block_count( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> u64

source

pub(crate) async fn wait_block_height( &self, block_height: u64, dbtx: &mut DatabaseTransaction<'_>, )

source

pub(crate) fn validate_decryption_share( &self, peer: PeerId, share: &PreimageDecryptionShare, message: &EncryptedPreimage, ) -> bool

source

pub(crate) async fn get_offer( &self, dbtx: &mut DatabaseTransaction<'_>, payment_hash: Hash, ) -> Option<IncomingContractOffer>

source

pub(crate) async fn wait_offer( &self, context: &mut ApiEndpointContext<'_>, payment_hash: Hash, ) -> IncomingContractOffer

source

pub(crate) async fn get_contract_account( &self, dbtx: &mut DatabaseTransaction<'_>, contract_id: ContractId, ) -> Option<ContractAccount>

source

pub(crate) async fn wait_contract_account( &self, context: &mut ApiEndpointContext<'_>, contract_id: ContractId, ) -> ContractAccount

source

pub(crate) async fn wait_outgoing_contract_account_cancelled( &self, context: &mut ApiEndpointContext<'_>, contract_id: ContractId, ) -> ContractAccount

source

pub(crate) async fn get_decrypted_preimage_status( &self, context: &mut ApiEndpointContext<'_>, contract_id: ContractId, ) -> (IncomingContractAccount, DecryptedPreimageStatus)

source

pub(crate) async fn wait_preimage_decrypted( &self, context: &mut ApiEndpointContext<'_>, contract_id: ContractId, ) -> (IncomingContractAccount, Option<Preimage>)

source

pub(crate) fn get_incoming_contract_account( contract: ContractAccount, ) -> IncomingContractAccount

source

pub(crate) async fn list_gateways( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> Vec<LightningGatewayAnnouncement>

source

pub(crate) async fn register_gateway( &self, dbtx: &mut DatabaseTransaction<'_>, gateway: LightningGatewayAnnouncement, )

source

pub(crate) async fn delete_expired_gateways( &self, dbtx: &mut DatabaseTransaction<'_>, )

source

pub(crate) async fn get_gateway_remove_challenge( &self, gateway_id: PublicKey, dbtx: &mut DatabaseTransaction<'_>, ) -> Option<Hash>

Returns the challenge to the gateway that must be signed by the gateway’s private key in order for the gateway registration record to be removed. The challenge is the concatenation of the gateway’s public key and the valid_until bytes. This ensures that the challenges changes every time the gateway is re-registered and ensures that the challenge is unique per-gateway.

source

pub(crate) async fn remove_gateway( &self, remove_gateway_request: RemoveGatewayRequest, dbtx: &mut DatabaseTransaction<'_>, ) -> Result<()>

Removes the gateway registration record. First the signature provided by the gateway is verified by checking if the gateway’s challenge has been signed by the gateway’s private key.

Trait Implementations§

source§

impl Debug for Lightning

source§

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

Formats the value using the given formatter. Read more
source§

impl ServerModule for Lightning

source§

type Common = LightningModuleTypes

source§

type Init = LightningInit

source§

fn consensus_proposal<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Vec<LightningConsensusItem>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

This module’s contribution to the next consensus proposal. This method is only guaranteed to be called once every few seconds. Consensus items are not meant to be latency critical; do not create them as a response to a processed transaction. Only use consensus items to establish consensus on a value that is required to verify transactions, like unix time, block heights and feerates, and model all other state changes trough transactions. The intention for this method is to always return all available consensus items even if they are redundant while process_consensus_item returns an error for the redundant proposals. Read more
source§

fn process_consensus_item<'a, 'b, 'life0, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'b>, consensus_item: LightningConsensusItem, peer_id: PeerId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'a: 'async_trait, 'b: 'async_trait, 'life0: 'async_trait,

This function is called once for every consensus item. The function should return Ok if and only if the consensus item changes the system state. Therefore this method should return an error in case of merely redundant consensus items such that they will be purged from the history of the federation. This enables consensus_proposal to return all available consensus item without wasting disk space with redundant consensus items.
source§

fn process_input<'a, 'b, 'c, 'life0, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'c>, input: &'b LightningInput, ) -> Pin<Box<dyn Future<Output = Result<InputMeta, LightningInputError>> + Send + 'async_trait>>
where Self: 'async_trait, 'a: 'async_trait, 'b: 'async_trait, 'c: 'async_trait, 'life0: 'async_trait,

Try to spend a transaction input. On success all necessary updates will be part of the database transaction. On failure (e.g. double spend) the database transaction is rolled back and the operation will take no effect.
source§

fn process_output<'a, 'b, 'life0, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'b>, output: &'a LightningOutput, out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<TransactionItemAmount, LightningOutputError>> + Send + 'async_trait>>
where Self: 'async_trait, 'a: 'async_trait, 'b: 'async_trait, 'life0: 'async_trait,

Try to create an output (e.g. issue notes, peg-out BTC, …). On success all necessary updates to the database will be part of the database transaction. On failure (e.g. double spend) the database transaction is rolled back and the operation will take no effect. Read more
source§

fn output_status<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Option<LightningOutputOutcome>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieve the current status of the output. Depending on the module this might contain data needed by the client to access funds or give an estimate of when funds will be available. Returns None if the output is unknown, NOT if it is just not ready yet.
source§

fn audit<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, audit: &'life3 mut Audit, module_instance_id: ModuleInstanceId, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Queries the database and returns all assets and liabilities of the module. Read more
source§

fn api_endpoints(&self) -> Vec<ApiEndpoint<Self>>

Returns a list of custom API endpoints defined by the module. These are made available both to users as well as to other modules. They thus should be deterministic, only dependant on their input and the current epoch.
source§

fn module_kind() -> ModuleKind

source§

fn decoder() -> Decoder

Returns a decoder for the following associated types of this module: Read more
source§

fn verify_input( &self, _input: &<Self::Common as ModuleCommon>::Input, ) -> Result<(), <Self::Common as ModuleCommon>::InputError>

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> IServerModule for T
where T: ServerModule + 'static + Sync,

source§

fn consensus_proposal<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, module_instance_id: u16, ) -> Pin<Box<dyn Future<Output = Vec<DynModuleConsensusItem>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, T: 'async_trait,

This module’s contribution to the next consensus proposal

source§

fn process_consensus_item<'a, 'b, 'life0, 'life1, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'a>, consensus_item: &'b DynModuleConsensusItem, peer_id: PeerId, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
where 'a: 'async_trait, 'b: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, T: 'async_trait,

This function is called once for every consensus item. The function returns an error if any only if the consensus item does not change our state and therefore may be safely discarded by the atomic broadcast.

source§

fn process_input<'a, 'b, 'c, 'life0, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'c>, input: &'b DynInput, ) -> Pin<Box<dyn Future<Output = Result<InputMeta, DynInputError>> + Send + 'async_trait>>
where 'a: 'async_trait, 'b: 'async_trait, 'c: 'async_trait, 'life0: 'async_trait, T: 'async_trait,

Try to spend a transaction input. On success all necessary updates will be part of the database transaction. On failure (e.g. double spend) the database transaction is rolled back and the operation will take no effect.

source§

fn process_output<'a, 'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'a>, output: &'life2 DynOutput, out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<TransactionItemAmount, DynOutputError>> + Send + 'async_trait>>
where 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, T: 'async_trait,

Try to create an output (e.g. issue notes, peg-out BTC, …). On success all necessary updates to the database will be part of the database transaction. On failure (e.g. double spend) the database transaction is rolled back and the operation will take no effect.

The supplied out_point identifies the operation (e.g. a peg-out or note issuance) and can be used to retrieve its outcome later using output_status.

source§

fn output_status<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, out_point: OutPoint, module_instance_id: u16, ) -> Pin<Box<dyn Future<Output = Option<DynOutputOutcome>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, T: 'async_trait,

Retrieve the current status of the output. Depending on the module this might contain data needed by the client to access funds or give an estimate of when funds will be available. Returns None if the output is unknown, NOT if it is just not ready yet.

source§

fn audit<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, audit: &'life3 mut Audit, module_instance_id: u16, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, T: 'async_trait,

Queries the database and returns all assets and liabilities of the module.

Summing over all modules, if liabilities > assets then an error has occurred in the database and consensus should halt.

source§

fn decoder(&self) -> Decoder

Returns the decoder belonging to the server module
source§

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

source§

fn module_kind(&self) -> ModuleKind

source§

fn verify_input(&self, input: &DynInput) -> Result<(), DynInputError>

source§

fn api_endpoints(&self) -> Vec<ApiEndpoint<DynServerModule>>

Returns a list of custom API endpoints defined by the module. These are made available both to users as well as to other modules. They thus should be deterministic, only dependant on their input and the current epoch.
§

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

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
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,