Struct IgnoringMessageHandler

pub struct IgnoringMessageHandler {}

A dummy struct which implements RoutingMessageHandler without storing any routing information or doing any processing. You can provide one of these as the route_handler in a MessageHandler.

Trait Implementations

impl AsyncPaymentsMessageHandler for IgnoringMessageHandler

fn handle_offer_paths_request( &self, _message: OfferPathsRequest, _context: AsyncPaymentsContext, _responder: Option<Responder>, ) -> Option<(OfferPaths, ResponseInstruction)>

Handle an OfferPathsRequest message. If we are a static invoice server and the message was sent over paths that we previously provided to an async recipient, an OfferPaths message should be returned.

fn handle_offer_paths( &self, _message: OfferPaths, _context: AsyncPaymentsContext, _responder: Option<Responder>, ) -> Option<(ServeStaticInvoice, ResponseInstruction)>

Handle an OfferPaths message. If this is in response to an OfferPathsRequest that we previously sent as an async recipient, we should build an Offer containing the included OfferPaths::paths and a corresponding StaticInvoice, and reply with ServeStaticInvoice.

fn handle_serve_static_invoice( &self, _message: ServeStaticInvoice, _context: AsyncPaymentsContext, _responder: Option<Responder>, )

Handle a ServeStaticInvoice message. If this is in response to an OfferPaths message we previously sent as a static invoice server, a StaticInvoicePersisted message should be sent once the message is handled.

fn handle_static_invoice_persisted( &self, _message: StaticInvoicePersisted, _context: AsyncPaymentsContext, )

Handle a StaticInvoicePersisted message. If this is in response to a ServeStaticInvoice message we previously sent as an async recipient, then the offer we generated on receipt of a previous OfferPaths message is now ready to be used for async payments.

fn handle_held_htlc_available( &self, _message: HeldHtlcAvailable, _context: AsyncPaymentsContext, _responder: Option<Responder>, ) -> Option<(ReleaseHeldHtlc, ResponseInstruction)>

Handle a HeldHtlcAvailable message. A ReleaseHeldHtlc should be returned to release the held funds.

fn handle_release_held_htlc( &self, _message: ReleaseHeldHtlc, _context: AsyncPaymentsContext, )

Handle a ReleaseHeldHtlc message. If authentication of the message succeeds, an HTLC should be released to the corresponding payee.

fn release_pending_messages( &self, ) -> Vec<(AsyncPaymentsMessage, MessageSendInstructions)>

Release any AsyncPaymentsMessages that need to be sent.

impl BaseMessageHandler for IgnoringMessageHandler

fn peer_disconnected(&self, _their_node_id: PublicKey)

Indicates a connection to the peer failed/an existing connection was lost.

fn peer_connected( &self, _their_node_id: PublicKey, _init: &Init, _inbound: bool, ) -> Result<(), ()>

Handle a peer (re)connecting.

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 get_and_clear_pending_msg_events(&self) -> Vec<MessageSendEvent>

Gets the list of pending events which were generated by previous actions, clearing the list in the process.

impl CustomMessageHandler for IgnoringMessageHandler

fn handle_custom_message( &self, _msg: Infallible, _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 peer_disconnected(&self, _their_node_id: PublicKey)

Indicates a peer disconnected.

fn peer_connected( &self, _their_node_id: PublicKey, _msg: &Init, _inbound: bool, ) -> Result<(), ()>

Handle a peer connecting.

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.

impl CustomMessageReader for IgnoringMessageHandler

type CustomMessage = Infallible

The type of the message decoded by the implementation.

fn read<R: Read>( &self, _message_type: u16, _buffer: &mut R, ) -> 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 CustomOnionMessageHandler for IgnoringMessageHandler

type CustomMessage = Infallible

The message known to the handler. To support multiple message types, you may want to make this an enum with a variant for each supported message.

fn handle_custom_message( &self, _message: Infallible, _context: Option<Vec<u8>>, _responder: Option<Responder>, ) -> Option<(Infallible, ResponseInstruction)>

Called with the custom message that was received, returning a response to send, if any.

fn read_custom_message<R: Read>( &self, _msg_type: u64, _buffer: &mut R, ) -> Result<Option<Infallible>, DecodeError>

where Self: Sized,

Read a custom message of type message_type from buffer, returning Ok(None) if the message type is unknown.

fn release_pending_custom_messages( &self, ) -> Vec<(Infallible, MessageSendInstructions)>

Releases any Self::CustomMessages that need to be sent.

impl DNSResolverMessageHandler for IgnoringMessageHandler

fn handle_dnssec_query( &self, _message: DNSSECQuery, _responder: Option<Responder>, ) -> Option<(DNSResolverMessage, ResponseInstruction)>

Handle a DNSSECQuery message.

fn handle_dnssec_proof( &self, _message: DNSSECProof, _context: DNSResolverContext, )

Handle a DNSSECProof message (in response to a DNSSECQuery we presumably sent).

fn provided_node_features(&self) -> NodeFeatures

Gets the node feature flags which this handler itself supports. Useful for setting the dns_resolver flag if this handler supports returning DNSSECProof messages in response to DNSSECQuery messages.

fn release_pending_messages( &self, ) -> Vec<(DNSResolverMessage, MessageSendInstructions)>

Release any DNSResolverMessages that need to be sent.

impl Deref for IgnoringMessageHandler

type Target = IgnoringMessageHandler

The resulting type after dereferencing.

fn deref(&self) -> &Self

Dereferences the value.

impl OffersMessageHandler for IgnoringMessageHandler

fn handle_message( &self, _message: OffersMessage, _context: Option<OffersContext>, _responder: Option<Responder>, ) -> Option<(OffersMessage, ResponseInstruction)>

Handles the given message by either responding with an Bolt12Invoice, sending a payment, or replying with an error.

fn release_pending_messages( &self, ) -> Vec<(OffersMessage, MessageSendInstructions)>

Releases any OffersMessages that need to be sent.

impl OnionMessageHandler for IgnoringMessageHandler

fn handle_onion_message(&self, _their_node_id: PublicKey, _msg: &OnionMessage)

Handle an incoming onion_message message from the given peer.

fn next_onion_message_for_peer( &self, _peer_node_id: PublicKey, ) -> Option<OnionMessage>

Returns the next pending onion message for the peer with the given node id.

fn timer_tick_occurred(&self)

Performs actions that should happen roughly every ten seconds after startup. Allows handlers to drop any buffered onion messages intended for prospective peerst.

impl RoutingMessageHandler for IgnoringMessageHandler

fn handle_node_announcement( &self, _their_node_id: Option<PublicKey>, _msg: &NodeAnnouncement, ) -> Result<bool, LightningError>

Handle an incoming node_announcement message, returning true if it should be forwarded on, false or returning an Err otherwise.

fn handle_channel_announcement( &self, _their_node_id: Option<PublicKey>, _msg: &ChannelAnnouncement, ) -> Result<bool, LightningError>

Handle a channel_announcement message, returning true if it should be forwarded on, false or returning an Err otherwise.

fn handle_channel_update( &self, _their_node_id: Option<PublicKey>, _msg: &ChannelUpdate, ) -> Result<bool, LightningError>

Handle an incoming channel_update message, returning true if it should be forwarded on, false or returning an Err otherwise.

fn get_next_channel_announcement( &self, _starting_point: u64, ) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>

Gets channel announcements and updates required to dump our routing table to a remote node, starting at the short_channel_id indicated by starting_point and including announcements for a single channel.

fn get_next_node_announcement( &self, _starting_point: Option<&NodeId>, ) -> Option<NodeAnnouncement>

Gets a node announcement required to dump our routing table to a remote node, starting at the node after the provided pubkey and including up to one announcement immediately higher (as defined by <PublicKey as Ord>::cmp) than starting_point. If None is provided for starting_point, we start at the first node.

fn handle_reply_channel_range( &self, _their_node_id: PublicKey, _msg: ReplyChannelRange, ) -> Result<(), LightningError>

Handles the reply of a query we initiated to learn about channels for a given range of blocks. We can expect to receive one or more replies to a single query.

fn handle_reply_short_channel_ids_end( &self, _their_node_id: PublicKey, _msg: ReplyShortChannelIdsEnd, ) -> Result<(), LightningError>

Handles the reply of a query we initiated asking for routing gossip messages for a list of channels. We should receive this message when a node has completed its best effort to send us the pertaining routing gossip messages.

fn handle_query_channel_range( &self, _their_node_id: PublicKey, _msg: QueryChannelRange, ) -> Result<(), LightningError>

Handles when a peer asks us to send a list of short_channel_ids for the requested range of blocks.

fn handle_query_short_channel_ids( &self, _their_node_id: PublicKey, _msg: QueryShortChannelIds, ) -> Result<(), LightningError>

Handles when a peer asks us to send routing gossip messages for a list of short_channel_ids.

fn processing_queue_high(&self) -> bool

Indicates that there are a large number of ChannelAnnouncement (or other) messages pending some async action. While there is no guarantee of the rate of future messages, the caller should seek to reduce the rate of new gossip messages handled, especially ChannelAnnouncements.

impl SendOnlyMessageHandler for IgnoringMessageHandler