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>::Signer>,
    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 write each monitor update out to disk before returning from chain::Watch::watch_channel/update_channel, 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 (mod 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 ) -> 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, override_config: Option<UserConfig> ) -> Result<[u8; 32], 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: &[u8; 32], counterparty_node_id: &PublicKey ) -> Result<(), APIError>

pub fn close_channel_with_target_feerate( &self, channel_id: &[u8; 32], counterparty_node_id: &PublicKey, target_feerate_sats_per_1000_weight: u32 ) -> Result<(), APIError>

pub fn force_close_broadcasting_latest_txn( &self, channel_id: &[u8; 32], counterparty_node_id: &PublicKey ) -> Result<(), APIError>

pub fn force_close_without_broadcasting_txn( &self, channel_id: &[u8; 32], 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>

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)

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 funding_transaction_generated( &self, temporary_channel_id: &[u8; 32], counterparty_node_id: &PublicKey, funding_transaction: Transaction ) -> Result<(), APIError>

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

pub fn forward_intercepted_htlc( &self, intercept_id: InterceptId, next_hop_channel_id: &[u8; 32], 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 get_our_node_id(&self) -> PublicKey

pub fn accept_inbound_channel( &self, temporary_channel_id: &[u8; 32], counterparty_node_id: &PublicKey, user_channel_id: u128 ) -> Result<(), APIError>

pub fn accept_inbound_channel_from_trusted_peer_0conf( &self, temporary_channel_id: &[u8; 32], counterparty_node_id: &PublicKey, user_channel_id: u128 ) -> Result<(), APIError>

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

pub fn create_inbound_payment_legacy( &self, min_value_msat: Option<u64>, invoice_expiry_delta_secs: u32 ) -> Result<(PaymentHash, PaymentSecret), APIError>

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

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

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_persistable_update_future(&self) -> Future ⓘ

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§

fn handle_open_channel( &self, counterparty_node_id: &PublicKey, msg: &OpenChannel )

fn handle_accept_channel( &self, counterparty_node_id: &PublicKey, msg: &AcceptChannel )

fn handle_funding_created( &self, counterparty_node_id: &PublicKey, msg: &FundingCreated )

fn handle_funding_signed( &self, counterparty_node_id: &PublicKey, msg: &FundingSigned )

fn handle_channel_ready( &self, counterparty_node_id: &PublicKey, msg: &ChannelReady )

fn handle_shutdown(&self, counterparty_node_id: &PublicKey, msg: &Shutdown)

fn handle_closing_signed( &self, counterparty_node_id: &PublicKey, msg: &ClosingSigned )

fn handle_update_add_htlc( &self, counterparty_node_id: &PublicKey, msg: &UpdateAddHTLC )

fn handle_update_fulfill_htlc( &self, counterparty_node_id: &PublicKey, msg: &UpdateFulfillHTLC )

fn handle_update_fail_htlc( &self, counterparty_node_id: &PublicKey, msg: &UpdateFailHTLC )

fn handle_update_fail_malformed_htlc( &self, counterparty_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC )

fn handle_commitment_signed( &self, counterparty_node_id: &PublicKey, msg: &CommitmentSigned )

fn handle_revoke_and_ack( &self, counterparty_node_id: &PublicKey, msg: &RevokeAndACK )

fn handle_update_fee(&self, counterparty_node_id: &PublicKey, msg: &UpdateFee)

fn handle_announcement_signatures( &self, counterparty_node_id: &PublicKey, msg: &AnnouncementSignatures )

fn handle_channel_update( &self, counterparty_node_id: &PublicKey, msg: &ChannelUpdate )

fn handle_channel_reestablish( &self, counterparty_node_id: &PublicKey, msg: &ChannelReestablish )

fn peer_disconnected(&self, counterparty_node_id: &PublicKey)

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

fn handle_error(&self, counterparty_node_id: &PublicKey, msg: &ErrorMessage)

fn provided_node_features(&self) -> NodeFeatures

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

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

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

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

fn transaction_unconfirmed(&self, txid: &Txid)

fn process_pending_events<H: Deref>(&self, handler: H)where H::Target: EventHandler,

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

fn block_disconnected(&self, header: &BlockHeader, height: u32)

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