Struct LiquidityManager 

pub struct LiquidityManager<ES: Deref + Clone, NS: Deref + Clone, CM: Deref + Clone, C: Deref + Clone, K: Deref + Clone, TP: Deref + Clone, T: Deref + Clone>
where
    ES::Target: EntropySource,
    NS::Target: NodeSigner,
    CM::Target: AChannelManager,
    C::Target: Filter,
    K::Target: KVStore,
    TP::Target: TimeProvider,
    T::Target: BroadcasterInterface,
{ /* private fields */ }

The main interface into LSP functionality.

Should be used as a CustomMessageHandler for your PeerManager’s MessageHandler.

Users need to continually poll LiquidityManager::get_and_clear_pending_events in order to surface LiquidityEvent’s that likely need to be handled.

If the LSPS2 service is configured, users must forward the following parameters from LDK events:

• Event::HTLCIntercepted to LSPS2ServiceHandler::htlc_intercepted
• Event::ChannelReady to LSPS2ServiceHandler::channel_ready
• Event::HTLCHandlingFailed to LSPS2ServiceHandler::htlc_handling_failed
• Event::PaymentForwarded to LSPS2ServiceHandler::payment_forwarded

Implementations

impl<ES: Deref + Clone, NS: Deref + Clone, CM: Deref + Clone, C: Deref + Clone, K: Deref + Clone, T: Deref + Clone> LiquidityManager<ES, NS, CM, C, K, DefaultTimeProvider, T>

where ES::Target: EntropySource, NS::Target: NodeSigner, CM::Target: AChannelManager, C::Target: Filter, K::Target: KVStore, T::Target: BroadcasterInterface,

pub async fn new( entropy_source: ES, node_signer: NS, channel_manager: CM, chain_source: Option<C>, chain_params: Option<ChainParameters>, kv_store: K, transaction_broadcaster: T, service_config: Option<LiquidityServiceConfig>, client_config: Option<LiquidityClientConfig>, ) -> Result<Self, Error>

Available on crate feature time only.

Constructor for the LiquidityManager using the default system clock

Will read persisted service states from the given KVStore.

impl<ES: Deref + Clone, NS: Deref + Clone, CM: Deref + Clone, C: Deref + Clone, K: Deref + Clone, TP: Deref + Clone, T: Deref + Clone> LiquidityManager<ES, NS, CM, C, K, TP, T>

where ES::Target: EntropySource, NS::Target: NodeSigner, CM::Target: AChannelManager, C::Target: Filter, K::Target: KVStore, TP::Target: TimeProvider, T::Target: BroadcasterInterface,

pub async fn new_with_custom_time_provider( entropy_source: ES, node_signer: NS, channel_manager: CM, transaction_broadcaster: T, chain_source: Option<C>, chain_params: Option<ChainParameters>, kv_store: K, service_config: Option<LiquidityServiceConfig>, client_config: Option<LiquidityClientConfig>, time_provider: TP, ) -> Result<Self, Error>

Constructor for the LiquidityManager with a custom time provider.

Will read persisted service states from the given KVStore.

This should be used on non-std platforms where access to the system time is not available. Sets up the required protocol message handlers based on the given LiquidityClientConfig and LiquidityServiceConfig.

pub fn lsps0_client_handler(&self) -> &LSPS0ClientHandler<ES, K>

Returns a reference to the LSPS0 client-side handler.

pub fn lsps0_service_handler(&self) -> Option<&LSPS0ServiceHandler>

Returns a reference to the LSPS0 server-side handler.

pub fn lsps1_client_handler(&self) -> Option<&LSPS1ClientHandler<ES, K>>

Returns a reference to the LSPS1 client-side handler.

The returned handler allows to initiate the LSPS1 client-side flow, i.e., allows to request channels from the configured LSP.

pub fn lsps2_client_handler(&self) -> Option<&LSPS2ClientHandler<ES, K>>

Returns a reference to the LSPS2 client-side handler.

The returned handler allows to initiate the LSPS2 client-side flow. That is, it allows to retrieve all necessary data to create ‘just-in-time’ invoices that, when paid, will have the configured LSP open a ‘just-in-time’ channel.

pub fn lsps2_service_handler(&self) -> Option<&LSPS2ServiceHandler<CM, K, T>>

Returns a reference to the LSPS2 server-side handler.

The returned hendler allows to initiate the LSPS2 service-side flow.

pub fn lsps5_client_handler(&self) -> Option<&LSPS5ClientHandler<ES, K>>

Returns a reference to the LSPS5 client-side handler.

The returned handler allows to initiate the LSPS5 client-side flow. That is, it allows to

pub fn lsps5_service_handler( &self, ) -> Option<&LSPS5ServiceHandler<CM, NS, K, TP>>

Returns a reference to the LSPS5 server-side handler.

The returned handler allows to initiate the LSPS5 service-side flow.

pub fn get_pending_msgs_or_needs_persist_future(&self) -> Future

Returns a Future that will complete when the next batch of pending messages is ready to be processed or we need to be repersisted.

Note that callbacks registered on the Future MUST NOT call back into this LiquidityManager and should instead register actions to be taken later.

pub fn next_event(&self) -> Option<LiquidityEvent>

Returns Some if an event is ready.

Typically you would spawn a thread or task that calls this in a loop.

Note: Users must handle events as soon as possible to avoid an increased event queue memory footprint. We will start dropping any generated events after MAX_EVENT_QUEUE_SIZE has been reached.

pub async fn next_event_async(&self) -> LiquidityEvent

Asynchronously polls the event queue and returns once the next event is ready.

Typically you would spawn a thread or task that calls this in a loop.

Note: Users must handle events as soon as possible to avoid an increased event queue memory footprint. We will start dropping any generated events after MAX_EVENT_QUEUE_SIZE has been reached.

pub fn get_and_clear_pending_events(&self) -> Vec<LiquidityEvent>

Returns and clears all events without blocking.

Typically you would spawn a thread or task that calls this in a loop.

Note: Users must handle events as soon as possible to avoid an increased event queue memory footprint. We will start dropping any generated events after MAX_EVENT_QUEUE_SIZE has been reached.

pub async fn persist(&self) -> Result<(), Error>

Persists the state of the service handlers towards the given KVStore implementation.

This will be regularly called by LDK’s background processor if necessary and only needs to be called manually if it’s not utilized.

Trait Implementations

impl<ES: Deref + Clone, NS: Deref + Clone, CM: Deref + Clone, C: Deref + Clone, K: Deref + Clone, TP: Deref + Clone, T: Deref + Clone> ALiquidityManager for LiquidityManager<ES, NS, CM, C, K, TP, T>

where ES::Target: EntropySource, NS::Target: NodeSigner, CM::Target: AChannelManager, C::Target: Filter, K::Target: KVStore, TP::Target: TimeProvider, T::Target: BroadcasterInterface,

type EntropySource = <ES as Deref>::Target

A type implementing EntropySource

type ES = ES

A type that may be dereferenced to Self::EntropySource.

type NodeSigner = <NS as Deref>::Target

A type implementing NodeSigner

type NS = NS

A type that may be dereferenced to Self::NodeSigner.

type AChannelManager = <CM as Deref>::Target

A type implementing AChannelManager

type CM = CM

A type that may be dereferenced to Self::AChannelManager.

type Filter = <C as Deref>::Target

A type implementing Filter.

type C = C

A type that may be dereferenced to Self::Filter.

type KVStore = <K as Deref>::Target

A type implementing KVStore.

type K = K

A type that may be dereferenced to Self::KVStore.

type TimeProvider = <TP as Deref>::Target

A type implementing TimeProvider.

type TP = TP

A type that may be dereferenced to Self::TimeProvider.

type BroadcasterInterface = <T as Deref>::Target

A type implementing BroadcasterInterface.

type T = T

A type that may be dereferenced to Self::BroadcasterInterface.

fn get_lm(&self) -> &LiquidityManager<ES, NS, CM, C, K, TP, T>

Returns a reference to the actual LiquidityManager object.

impl<ES: Deref + Clone, NS: Deref + Clone, CM: Deref + Clone, C: Deref + Clone, K: Deref + Clone, TP: Deref + Clone, T: Deref + Clone> Confirm for LiquidityManager<ES, NS, CM, C, K, TP, T>

where ES::Target: EntropySource, NS::Target: NodeSigner, CM::Target: AChannelManager, C::Target: Filter, K::Target: KVStore, TP::Target: TimeProvider, T::Target: BroadcasterInterface,

fn transactions_confirmed( &self, _header: &Header, _txdata: &TransactionData<'_>, _height: u32, )

Notifies LDK of transactions confirmed in a block with a given header and height.

fn transaction_unconfirmed(&self, _txid: &Txid)

Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization.

fn best_block_updated(&self, header: &Header, height: u32)

Notifies LDK of an update to the best header connected at the given height.

fn get_relevant_txids(&self) -> Vec<(Txid, u32, Option<BlockHash>)>

Returns transactions that must be monitored for reorganization out of the chain along with the height and the hash of the block as part of which it had been previously confirmed.

impl<ES: Deref + Clone, NS: Deref + Clone, CM: Deref + Clone, C: Deref + Clone, K: Deref + Clone, TP: Deref + Clone, T: Deref + Clone> CustomMessageHandler for LiquidityManager<ES, NS, CM, C, K, TP, T>

where ES::Target: EntropySource, NS::Target: NodeSigner, CM::Target: AChannelManager, C::Target: Filter, K::Target: KVStore, TP::Target: TimeProvider, T::Target: BroadcasterInterface,

fn handle_custom_message( &self, msg: Self::CustomMessage, sender_node_id: PublicKey, ) -> Result<(), LightningError>

Handles the given message sent from sender_node_id, possibly producing messages for CustomMessageHandler::get_and_clear_pending_msg to return and thus for PeerManager to send.

fn get_and_clear_pending_msg(&self) -> Vec<(PublicKey, Self::CustomMessage)>

Returns the list of pending messages that were generated by the handler, clearing the list in the process. Each message is paired with the node id of the intended recipient. If no connection to the node exists, then the message is simply not sent.

fn provided_node_features(&self) -> NodeFeatures

Gets the node feature flags which this handler itself supports. All available handlers are queried similarly and their feature flags are OR’d together to form the NodeFeatures which are broadcasted in our NodeAnnouncement message.

fn provided_init_features(&self, _their_node_id: PublicKey) -> InitFeatures

Gets the init feature flags which should be sent to the given peer. All available handlers are queried similarly and their feature flags are OR’d together to form the InitFeatures which are sent in our Init message.

fn peer_disconnected(&self, counterparty_node_id: PublicKey)

Indicates a peer disconnected.

fn peer_connected( &self, counterparty_node_id: PublicKey, _: &Init, _: bool, ) -> Result<(), ()>

Handle a peer connecting.

impl<ES: Deref + Clone, NS: Deref + Clone, CM: Deref + Clone, C: Deref + Clone, K: Deref + Clone, TP: Deref + Clone, T: Deref + Clone> CustomMessageReader for LiquidityManager<ES, NS, CM, C, K, TP, T>

where ES::Target: EntropySource, NS::Target: NodeSigner, CM::Target: AChannelManager, C::Target: Filter, K::Target: KVStore, TP::Target: TimeProvider, T::Target: BroadcasterInterface,

type CustomMessage = RawLSPSMessage

The type of the message decoded by the implementation.

fn read<RD: LengthLimitedRead>( &self, message_type: u16, buffer: &mut RD, ) -> Result<Option<Self::CustomMessage>, DecodeError>

Decodes a custom message to CustomMessageType. If the given message type is known to the implementation and the message could be decoded, must return Ok(Some(message)). If the message type is unknown to the implementation, must return Ok(None). If a decoding error occur, must return Err(DecodeError::X) where X details the encountered error.

impl<ES: Deref + Clone, NS: Deref + Clone, CM: Deref + Clone, C: Deref + Clone, K: Deref + Clone, TP: Deref + Clone, T: Deref + Clone> Listen for LiquidityManager<ES, NS, CM, C, K, TP, T>

where ES::Target: EntropySource, NS::Target: NodeSigner, CM::Target: AChannelManager, C::Target: Filter, K::Target: KVStore, TP::Target: TimeProvider, T::Target: BroadcasterInterface,

fn filtered_block_connected( &self, header: &Header, txdata: &TransactionData<'_>, height: u32, )

Notifies the listener that a block was added at the given height, with the transaction data possibly filtered.

fn blocks_disconnected(&self, fork_point: BestBlock)

Notifies the listener that one or more blocks were removed in anticipation of a reorg.

fn block_connected(&self, block: &Block, height: u32)

Notifies the listener that a block was added at the given height.