Struct lightning::ln::channelmanager::ChannelManager

source ·

pub struct ChannelManager<M: Deref, T: Deref, ES: Deref, NS: Deref, SP: Deref, F: Deref, R: Deref, L: Deref>where
    M::Target: Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
    T::Target: BroadcasterInterface,
    ES::Target: EntropySource,
    NS::Target: NodeSigner,
    SP::Target: SignerProvider,
    F::Target: FeeEstimator,
    R::Target: Router,
    L::Target: Logger,
{ /* private fields */ }

Expand description

Manager which keeps track of a number of channels and sends messages to the appropriate channel, also tracking HTLC preimages and forwarding onion packets appropriately.

Implements ChannelMessageHandler, handling the multi-channel parts and passing things through to individual Channels.

Implements Writeable to write out all channel state to disk. Implies peer_disconnected for all peers during write/read (though does not modify this instance, only the instance being serialized). This will result in any channels which have not yet exchanged funding_created (i.e., called funding_transaction_generated for outbound channels) being closed.

Note that you can be a bit lazier about writing out ChannelManager than you can be with ChannelMonitor. With ChannelMonitor you MUST durably write each ChannelMonitorUpdate before returning from chain::Watch::watch_channel/update_channel or before completing async writes. With ChannelManagers, writing updates happens out-of-band (and will prevent any other ChannelManager operations from occurring during the serialization process). If the deserialized version is out-of-date compared to the ChannelMonitor passed by reference to read, those channels will be force-closed based on the ChannelMonitor state and no funds will be lost (modulo on-chain transaction fees).

Note that the deserializer is only implemented for (BlockHash, ChannelManager), which tells you the last block hash which was connected. You should get the best block tip before using the manager. See chain::Listen and chain::Confirm for more details.

Note that ChannelManager is responsible for tracking liveness of its channels and generating ChannelUpdate messages informing peers that the channel is temporarily disabled. To avoid spam due to quick disconnection/reconnection, updates are not sent until the channel has been offline for a full minute. In order to track this, you must call timer_tick_occurred roughly once per minute, though it doesn’t have to be perfect.

To avoid trivial DoS issues, ChannelManager limits the number of inbound connections and inbound channels without confirmed funding transactions. This may result in nodes which we do not have a channel with being unable to connect to us or open new channels with us if we have many peers with unfunded channels.

Because it is an indication of trust, inbound channels which we’ve accepted as 0conf are exempted from the count of unfunded channels. Similarly, outbound channels and connections are never limited. Please ensure you limit the count of such channels yourself.

Rather than using a plain ChannelManager, it is preferable to use either a SimpleArcChannelManager a SimpleRefChannelManager, for conciseness. See their documentation for more details, but essentially you should default to using a SimpleRefChannelManager, and use a SimpleArcChannelManager when you require a ChannelManager with a static lifetime, such as when you’re using lightning-net-tokio.

Struct lightning::ln::channelmanager::ChannelManager

Implementations§

pub fn new( fee_est: F, chain_monitor: M, tx_broadcaster: T, router: R, logger: L, entropy_source: ES, node_signer: NS, signer_provider: SP, config: UserConfig, params: ChainParameters, current_timestamp: u32 ) -> Self

pub fn get_current_default_configuration(&self) -> &UserConfig

pub fn create_channel( &self, their_network_key: PublicKey, channel_value_satoshis: u64, push_msat: u64, user_channel_id: u128, temporary_channel_id: Option<ChannelId>, override_config: Option<UserConfig> ) -> Result<ChannelId, APIError>

pub fn list_channels(&self) -> Vec<ChannelDetails>

pub fn list_usable_channels(&self) -> Vec<ChannelDetails>

pub fn list_channels_with_counterparty( &self, counterparty_node_id: &PublicKey ) -> Vec<ChannelDetails>

pub fn list_recent_payments(&self) -> Vec<RecentPaymentDetails>

pub fn close_channel( &self, channel_id: &ChannelId, counterparty_node_id: &PublicKey ) -> Result<(), APIError>

pub fn close_channel_with_feerate_and_script( &self, channel_id: &ChannelId, counterparty_node_id: &PublicKey, target_feerate_sats_per_1000_weight: Option<u32>, shutdown_script: Option<ShutdownScript> ) -> Result<(), APIError>

pub fn force_close_broadcasting_latest_txn( &self, channel_id: &ChannelId, counterparty_node_id: &PublicKey ) -> Result<(), APIError>

pub fn force_close_without_broadcasting_txn( &self, channel_id: &ChannelId, counterparty_node_id: &PublicKey ) -> Result<(), APIError>

pub fn force_close_all_channels_broadcasting_latest_txn(&self)

pub fn force_close_all_channels_without_broadcasting_txn(&self)

pub fn send_payment_with_route( &self, route: &Route, payment_hash: PaymentHash, recipient_onion: RecipientOnionFields, payment_id: PaymentId ) -> Result<(), PaymentSendFailure>

§Avoiding Duplicate Payments

§Possible Error States on PaymentSendFailure

pub fn send_payment( &self, payment_hash: PaymentHash, recipient_onion: RecipientOnionFields, payment_id: PaymentId, route_params: RouteParameters, retry_strategy: Retry ) -> Result<(), RetryableSendFailure>

pub fn abandon_payment(&self, payment_id: PaymentId)

§Event Generation

§Requested Invoices

§Restart Behavior

pub fn send_spontaneous_payment( &self, route: &Route, payment_preimage: Option<PaymentPreimage>, recipient_onion: RecipientOnionFields, payment_id: PaymentId ) -> Result<PaymentHash, PaymentSendFailure>

pub fn send_spontaneous_payment_with_retry( &self, payment_preimage: Option<PaymentPreimage>, recipient_onion: RecipientOnionFields, payment_id: PaymentId, route_params: RouteParameters, retry_strategy: Retry ) -> Result<PaymentHash, RetryableSendFailure>

pub fn send_probe( &self, path: Path ) -> Result<(PaymentHash, PaymentId), PaymentSendFailure>

pub fn send_spontaneous_preflight_probes( &self, node_id: PublicKey, amount_msat: u64, final_cltv_expiry_delta: u32, liquidity_limit_multiplier: Option<u64> ) -> Result<Vec<(PaymentHash, PaymentId)>, ProbeSendFailure>

pub fn send_preflight_probes( &self, route_params: RouteParameters, liquidity_limit_multiplier: Option<u64> ) -> Result<Vec<(PaymentHash, PaymentId)>, ProbeSendFailure>

pub fn funding_transaction_generated( &self, temporary_channel_id: &ChannelId, counterparty_node_id: &PublicKey, funding_transaction: Transaction ) -> Result<(), APIError>

pub fn batch_funding_transaction_generated( &self, temporary_channels: &[(&ChannelId, &PublicKey)], funding_transaction: Transaction ) -> Result<(), APIError>

pub fn update_partial_channel_config( &self, counterparty_node_id: &PublicKey, channel_ids: &[ChannelId], config_update: &ChannelConfigUpdate ) -> Result<(), APIError>

pub fn update_channel_config( &self, counterparty_node_id: &PublicKey, channel_ids: &[ChannelId], config: &ChannelConfig ) -> Result<(), APIError>

pub fn forward_intercepted_htlc( &self, intercept_id: InterceptId, next_hop_channel_id: &ChannelId, next_node_id: PublicKey, amt_to_forward_msat: u64 ) -> Result<(), APIError>

pub fn fail_intercepted_htlc( &self, intercept_id: InterceptId ) -> Result<(), APIError>

pub fn process_pending_htlc_forwards(&self)

pub fn timer_tick_occurred(&self)

pub fn fail_htlc_backwards(&self, payment_hash: &PaymentHash)

pub fn fail_htlc_backwards_with_reason( &self, payment_hash: &PaymentHash, failure_code: FailureCode )

pub fn claim_funds(&self, payment_preimage: PaymentPreimage)

pub fn claim_funds_with_known_custom_tlvs( &self, payment_preimage: PaymentPreimage )

§Note

pub fn get_our_node_id(&self) -> PublicKey

pub fn accept_inbound_channel( &self, temporary_channel_id: &ChannelId, counterparty_node_id: &PublicKey, user_channel_id: u128 ) -> Result<(), APIError>

pub fn accept_inbound_channel_from_trusted_peer_0conf( &self, temporary_channel_id: &ChannelId, counterparty_node_id: &PublicKey, user_channel_id: u128 ) -> Result<(), APIError>

pub fn create_offer_builder( &self, description: String ) -> Result<OfferBuilder<'_, DerivedMetadata, All>, Bolt12SemanticError>

§Privacy

§Limitations

§Errors

pub fn create_refund_builder( &self, description: String, amount_msats: u64, absolute_expiry: Duration, payment_id: PaymentId, retry_strategy: Retry, max_total_routing_fee_msat: Option<u64> ) -> Result<RefundBuilder<'_, All>, Bolt12SemanticError>

§Payment

§Privacy

§Limitations

§Errors

pub fn pay_for_offer( &self, offer: &Offer, quantity: Option<u64>, amount_msats: Option<u64>, payer_note: Option<String>, payment_id: PaymentId, retry_strategy: Retry, max_total_routing_fee_msat: Option<u64> ) -> Result<(), Bolt12SemanticError>

§Payment

§Privacy

§Limitations

§Errors

pub fn request_refund_payment( &self, refund: &Refund ) -> Result<(), Bolt12SemanticError>

§Limitations

§Errors

pub fn create_inbound_payment( &self, min_value_msat: Option<u64>, invoice_expiry_delta_secs: u32, min_final_cltv_expiry_delta: Option<u16> ) -> Result<(PaymentHash, PaymentSecret), ()>

§Note

pub fn create_inbound_payment_for_hash( &self, payment_hash: PaymentHash, min_value_msat: Option<u64>, invoice_expiry_delta_secs: u32, min_final_cltv_expiry: Option<u16> ) -> Result<PaymentSecret, ()>

§Note

pub fn get_payment_preimage( &self, payment_hash: PaymentHash, payment_secret: PaymentSecret ) -> Result<PaymentPreimage, APIError>

pub fn get_phantom_scid(&self) -> u64

pub fn get_phantom_route_hints(&self) -> PhantomRouteHints

pub fn get_intercept_scid(&self) -> u64

pub fn compute_inflight_htlcs(&self) -> InFlightHtlcs

pub async fn process_pending_events_async<Future: Future, H: Fn(Event) -> Future>( &self, handler: H )

pub fn get_event_or_persistence_needed_future(&self) -> Future ⓘ

pub fn get_and_clear_needs_persistence(&self) -> bool

pub fn current_best_block(&self) -> BestBlock

pub fn node_features(&self) -> NodeFeatures

pub fn channel_features(&self) -> ChannelFeatures

pub fn channel_type_features(&self) -> ChannelTypeFeatures

pub fn init_features(&self) -> InitFeatures

Trait Implementations§

type Watch = <M as Deref>::Target

§Possible Error States on `PaymentSendFailure`