Struct lightning::ln::channelmanager::ChannelManager
source · [−]pub struct ChannelManager<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
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 (ie called funding_transaction_generated for outbound channels).
Note that you can be a bit lazier about writing out ChannelManager than you can be with ChannelMonitors. With ChannelMonitors you MUST write each monitor update out to disk before returning from chain::Watch::watch_/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 ChannelMonitors 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 block_connect()ed. You MUST rescan any blocks along the “reorg path” (ie call block_disconnected() until you get to a common block and then call block_connected() to step towards your best block) upon deserialization before using the object!
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.
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.
Implementations
sourceimpl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
sourcepub fn new(
fee_est: F,
chain_monitor: M,
tx_broadcaster: T,
logger: L,
keys_manager: K,
config: UserConfig,
params: ChainParameters
) -> Self
pub fn new(
fee_est: F,
chain_monitor: M,
tx_broadcaster: T,
logger: L,
keys_manager: K,
config: UserConfig,
params: ChainParameters
) -> Self
Constructs a new ChannelManager to hold several channels and route between them.
This is the main “logic hub” for all channel-related actions, and implements ChannelMessageHandler.
Non-proportional fees are fixed according to our risk using the provided fee estimator.
panics if channel_value_satoshis is >= MAX_FUNDING_SATOSHIS
!
Users need to notify the new ChannelManager when a new block is connected or
disconnected using its block_connected
and block_disconnected
methods, starting
from after params.latest_hash
.
sourcepub fn get_current_default_configuration(&self) -> &UserConfig
pub fn get_current_default_configuration(&self) -> &UserConfig
Gets the current configuration applied to all new channels, as
sourcepub fn create_channel(
&self,
their_network_key: PublicKey,
channel_value_satoshis: u64,
push_msat: u64,
user_channel_id: u64,
override_config: Option<UserConfig>
) -> Result<[u8; 32], APIError>
pub fn create_channel(
&self,
their_network_key: PublicKey,
channel_value_satoshis: u64,
push_msat: u64,
user_channel_id: u64,
override_config: Option<UserConfig>
) -> Result<[u8; 32], APIError>
Creates a new outbound channel to the given remote node and with the given value.
user_channel_id
will be provided back as in
Event::FundingGenerationReady::user_channel_id
to allow tracking of which events
correspond with which create_channel
call. Note that the user_channel_id
defaults to 0
for inbound channels, so you may wish to avoid using 0 for user_channel_id
here.
user_channel_id
has no meaning inside of LDK, it is simply copied to events and otherwise
ignored.
Raises APIError::APIMisuseError
when channel_value_satoshis
> 2**24 or push_msat
is
greater than channel_value_satoshis * 1k
or channel_value_satoshis < 1000
.
Note that we do not check if you are currently connected to the given peer. If no
connection is available, the outbound open_channel
message may fail to send, resulting in
the channel eventually being silently forgotten (dropped on reload).
Returns the new Channel’s temporary channel_id
. This ID will appear as
Event::FundingGenerationReady::temporary_channel_id
and in
ChannelDetails::channel_id
until after
ChannelManager::funding_transaction_generated
is called, swapping the Channel’s ID for
one derived from the funding transaction’s TXID. If the counterparty rejects the channel
immediately, this temporary ID will appear in Event::ChannelClosed::channel_id
.
sourcepub fn list_channels(&self) -> Vec<ChannelDetails>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
pub fn list_channels(&self) -> Vec<ChannelDetails>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
Gets the list of open channels, in random order. See ChannelDetail field documentation for more information.
sourcepub fn list_usable_channels(&self) -> Vec<ChannelDetails>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
pub fn list_usable_channels(&self) -> Vec<ChannelDetails>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
Gets the list of usable channels, in random order. Useful as an argument to get_route to ensure non-announced channels are used.
These are guaranteed to have their ChannelDetails::is_usable
value set to true, see the
documentation for ChannelDetails::is_usable
for more info on exactly what the criteria
are.
sourcepub fn close_channel(&self, channel_id: &[u8; 32]) -> Result<(), APIError>
pub fn close_channel(&self, channel_id: &[u8; 32]) -> Result<(), APIError>
Begins the process of closing a channel. After this call (plus some timeout), no new HTLCs will be accepted on the given channel, and after additional timeout/the closing of all pending HTLCs, the channel will be closed on chain.
- If we are the channel initiator, we will pay between our
Background
andChannelConfig::force_close_avoidance_max_fee_satoshis
plus ourNormal
fee estimate. - If our counterparty is the channel initiator, we will require a channel closing
transaction feerate of at least our
Background
feerate or the feerate which would appear on a force-closure transaction, whichever is lower. We will allow our counterparty to pay as much fee as they’d like, however.
May generate a SendShutdown message event on success, which should be relayed.
sourcepub fn close_channel_with_target_feerate(
&self,
channel_id: &[u8; 32],
target_feerate_sats_per_1000_weight: u32
) -> Result<(), APIError>
pub fn close_channel_with_target_feerate(
&self,
channel_id: &[u8; 32],
target_feerate_sats_per_1000_weight: u32
) -> Result<(), APIError>
Begins the process of closing a channel. After this call (plus some timeout), no new HTLCs will be accepted on the given channel, and after additional timeout/the closing of all pending HTLCs, the channel will be closed on chain.
target_feerate_sat_per_1000_weight
has different meanings depending on if we initiated
the channel being closed or not:
- If we are the channel initiator, we will pay at least this feerate on the closing
transaction. The upper-bound is set by
ChannelConfig::force_close_avoidance_max_fee_satoshis
plus ourNormal
fee estimate (ortarget_feerate_sat_per_1000_weight
, if it is greater). - If our counterparty is the channel initiator, we will refuse to accept a channel closure
transaction feerate below
target_feerate_sat_per_1000_weight
(or the feerate which will appear on a force-closure transaction, whichever is lower).
May generate a SendShutdown message event on success, which should be relayed.
sourcepub fn force_close_channel(&self, channel_id: &[u8; 32]) -> Result<(), APIError>
pub fn force_close_channel(&self, channel_id: &[u8; 32]) -> Result<(), APIError>
Force closes a channel, immediately broadcasting the latest local commitment transaction to the chain and rejecting new HTLCs on the given channel. Fails if channel_id is unknown to the manager.
sourcepub fn force_close_all_channels(&self)
pub fn force_close_all_channels(&self)
Force close all channels, immediately broadcasting the latest local commitment transaction for each to the chain and rejecting new HTLCs on each.
sourcepub fn send_payment(
&self,
route: &Route,
payment_hash: PaymentHash,
payment_secret: &Option<PaymentSecret>
) -> Result<PaymentId, PaymentSendFailure>
pub fn send_payment(
&self,
route: &Route,
payment_hash: PaymentHash,
payment_secret: &Option<PaymentSecret>
) -> Result<PaymentId, PaymentSendFailure>
Sends a payment along a given route.
Value parameters are provided via the last hop in route, see documentation for RouteHop fields for more info.
Note that if the payment_hash already exists elsewhere (eg you’re sending a duplicative payment), we don’t do anything to stop you! We always try to ensure that if the provided next hop knows the preimage to payment_hash they can claim an additional amount as specified in the last hop in the route! Thus, you should probably do your own payment_preimage tracking (which you should already be doing as they represent “proof of payment”) and prevent double-sends yourself.
May generate SendHTLCs message(s) event on success, which should be relayed.
Each path may have a different return value, and PaymentSendValue may return a Vec with each entry matching the corresponding-index entry in the route paths, see PaymentSendFailure for more info.
In general, a path may raise:
- APIError::RouteError when an invalid route or forwarding parameter (cltv_delta, fee, node public key) is specified.
- APIError::ChannelUnavailable if the next-hop channel is not available for updates (including due to previous monitor update failure or new permanent monitor update failure).
- APIError::MonitorUpdateFailed if a new monitor update failure prevented sending the relevant updates.
Note that depending on the type of the PaymentSendFailure the HTLC may have been irrevocably committed to on our end. In such a case, do NOT retry the payment with a different route unless you intend to pay twice!
payment_secret is unrelated to payment_hash (or PaymentPreimage) and exists to authenticate the sender to the recipient and prevent payment-probing (deanonymization) attacks. For newer nodes, it will be provided to you in the invoice. If you do not have one, the Route must not contain multiple paths as multi-path payments require a recipient-provided payment_secret. If a payment_secret is provided, we assume that the invoice had the payment_secret feature bit set (either as required or as available). If multiple paths are present in the Route, we assume the invoice had the basic_mpp feature set.
sourcepub fn retry_payment(
&self,
route: &Route,
payment_id: PaymentId
) -> Result<(), PaymentSendFailure>
pub fn retry_payment(
&self,
route: &Route,
payment_id: PaymentId
) -> Result<(), PaymentSendFailure>
Retries a payment along the given Route
.
Errors returned are a superset of those returned from send_payment
, so see
send_payment
documentation for more details on errors. This method will also error if the
retry amount puts the payment more than 10% over the payment’s total amount, if the payment
for the given payment_id
cannot be found (likely due to timeout or success), or if
further retries have been disabled with abandon_payment
.
sourcepub fn abandon_payment(&self, payment_id: PaymentId)
pub fn abandon_payment(&self, payment_id: PaymentId)
Signals that no further retries for the given payment will occur.
After this method returns, any future calls to retry_payment
for the given payment_id
will fail with PaymentSendFailure::ParameterError
. If no such event has been generated,
an Event::PaymentFailed
event will be generated as soon as there are no remaining
pending HTLCs for this payment.
Note that calling this method does not prevent a payment from succeeding. You must still
wait until you receive either a Event::PaymentFailed
or Event::PaymentSent
event to
determine the ultimate status of a payment.
sourcepub fn send_spontaneous_payment(
&self,
route: &Route,
payment_preimage: Option<PaymentPreimage>
) -> Result<(PaymentHash, PaymentId), PaymentSendFailure>
pub fn send_spontaneous_payment(
&self,
route: &Route,
payment_preimage: Option<PaymentPreimage>
) -> Result<(PaymentHash, PaymentId), PaymentSendFailure>
Send a spontaneous payment, which is a payment that does not require the recipient to have generated an invoice. Optionally, you may specify the preimage. If you do choose to specify the preimage, it must be a cryptographically secure random value that no intermediate node would be able to guess – otherwise, an intermediate node may claim the payment and it will never reach the recipient.
See send_payment
documentation for more details on the return value of this function.
Similar to regular payments, you MUST NOT reuse a payment_preimage
value. See
send_payment
for more information about the risks of duplicate preimage usage.
Note that route
must have exactly one path.
sourcepub fn funding_transaction_generated(
&self,
temporary_channel_id: &[u8; 32],
funding_transaction: Transaction
) -> Result<(), APIError>
pub fn funding_transaction_generated(
&self,
temporary_channel_id: &[u8; 32],
funding_transaction: Transaction
) -> Result<(), APIError>
Call this upon creation of a funding transaction for the given channel.
Returns an APIError::APIMisuseError
if the funding_transaction spent non-SegWit outputs
or if no output was found which matches the parameters in Event::FundingGenerationReady
.
Returns APIError::ChannelUnavailable
if a funding transaction has already been provided
for the channel or if the channel has been closed as indicated by Event::ChannelClosed
.
May panic if the output found in the funding transaction is duplicative with some other channel (note that this should be trivially prevented by using unique funding transaction keys per-channel).
Do NOT broadcast the funding transaction yourself. When we have safely received our
counterparty’s signature the funding transaction will automatically be broadcast via the
BroadcasterInterface
provided when this ChannelManager
was constructed.
Note that this includes RBF or similar transaction replacement strategies - lightning does not currently support replacing a funding transaction on an existing channel. Instead, create a new channel with a conflicting funding transaction.
sourcepub fn broadcast_node_announcement(
&self,
rgb: [u8; 3],
alias: [u8; 32],
addresses: Vec<NetAddress>
)
pub fn broadcast_node_announcement(
&self,
rgb: [u8; 3],
alias: [u8; 32],
addresses: Vec<NetAddress>
)
Regenerates channel_announcements and generates a signed node_announcement from the given
arguments, providing them in corresponding events via
get_and_clear_pending_msg_events
, if at least one public channel has been confirmed
on-chain. This effectively re-broadcasts all channel announcements and sends our node
announcement to ensure that the lightning P2P network is aware of the channels we have and
our network addresses.
rgb
is a node “color” and alias
is a printable human-readable string to describe this
node to humans. They carry no in-protocol meaning.
addresses
represent the set (possibly empty) of socket addresses on which this node
accepts incoming connections. These will be included in the node_announcement, publicly
tying these addresses together and to this node. If you wish to preserve user privacy,
addresses should likely contain only Tor Onion addresses.
Panics if addresses
is absurdly large (more than 500).
sourcepub fn process_pending_htlc_forwards(&self)
pub fn process_pending_htlc_forwards(&self)
Processes HTLCs which are pending waiting on random forward delay.
Should only really ever be called in response to a PendingHTLCsForwardable event. Will likely generate further events.
sourcepub fn timer_tick_occurred(&self)
pub fn timer_tick_occurred(&self)
Performs actions which should happen on startup and roughly once per minute thereafter.
This currently includes:
- Increasing or decreasing the on-chain feerate estimates for our outbound channels,
- Broadcasting
ChannelUpdate
messages if we’ve been disconnected from our peer for more than a minute, informing the network that they should no longer attempt to route over the channel.
Note that this may cause reentrancy through chain::Watch::update_channel
calls or feerate
estimate fetches.
sourcepub fn fail_htlc_backwards(&self, payment_hash: &PaymentHash) -> bool
pub fn fail_htlc_backwards(&self, payment_hash: &PaymentHash) -> bool
Indicates that the preimage for payment_hash is unknown or the received amount is incorrect after a PaymentReceived event, failing the HTLC back to its origin and freeing resources along the path (including in our own channel on which we received it). Returns false if no payment was found to fail backwards, true if the process of failing the HTLC backwards has been started.
sourcepub fn claim_funds(&self, payment_preimage: PaymentPreimage) -> bool
pub fn claim_funds(&self, payment_preimage: PaymentPreimage) -> bool
Provides a payment preimage in response to Event::PaymentReceived
, generating any
MessageSendEvent
s needed to claim the payment.
Note that if you did not set an amount_msat
when calling create_inbound_payment
or
create_inbound_payment_for_hash
you must check that the amount in the PaymentReceived
event matches your expectation. If you fail to do so and call this method, you may provide
the sender “proof-of-payment” when they did not fulfill the full expected payment.
Returns whether any HTLCs were claimed, and thus if any new MessageSendEvent
s are now
pending for processing via get_and_clear_pending_msg_events
.
sourcepub fn get_our_node_id(&self) -> PublicKey
pub fn get_our_node_id(&self) -> PublicKey
Gets the node_id held by this ChannelManager
sourcepub fn accept_inbound_channel(
&self,
temporary_channel_id: &[u8; 32],
user_channel_id: u64
) -> Result<(), APIError>
pub fn accept_inbound_channel(
&self,
temporary_channel_id: &[u8; 32],
user_channel_id: u64
) -> Result<(), APIError>
Called to accept a request to open a channel after Event::OpenChannelRequest
has been
triggered.
The temporary_channel_id
parameter indicates which inbound channel should be accepted.
For inbound channels, the user_channel_id
parameter will be provided back in
Event::ChannelClosed::user_channel_id
to allow tracking of which events correspond
with which accept_inbound_channel
call.
sourcepub fn create_inbound_payment(
&self,
min_value_msat: Option<u64>,
invoice_expiry_delta_secs: u32
) -> Result<(PaymentHash, PaymentSecret), ()>
pub fn create_inbound_payment(
&self,
min_value_msat: Option<u64>,
invoice_expiry_delta_secs: u32
) -> Result<(PaymentHash, PaymentSecret), ()>
Gets a payment secret and payment hash for use in an invoice given to a third party wishing to pay us.
This differs from create_inbound_payment_for_hash
only in that it generates the
PaymentHash
and PaymentPreimage
for you.
The PaymentPreimage
will ultimately be returned to you in the PaymentReceived
, which
will have the PaymentReceived::payment_preimage
field filled in. That should then be
passed directly to claim_funds
.
See create_inbound_payment_for_hash
for detailed documentation on behavior and requirements.
Note that a malicious eavesdropper can intuit whether an inbound payment was created by
create_inbound_payment
or create_inbound_payment_for_hash
based on runtime.
Note
If you register an inbound payment with this method, then serialize the ChannelManager
, then
deserialize it with a node running 0.0.103 and earlier, the payment will fail to be received.
Errors if min_value_msat
is greater than total bitcoin supply.
sourcepub fn create_inbound_payment_legacy(
&self,
min_value_msat: Option<u64>,
invoice_expiry_delta_secs: u32
) -> Result<(PaymentHash, PaymentSecret), APIError>
👎 Deprecated
pub fn create_inbound_payment_legacy(
&self,
min_value_msat: Option<u64>,
invoice_expiry_delta_secs: u32
) -> Result<(PaymentHash, PaymentSecret), APIError>
Legacy version of create_inbound_payment
. Use this method if you wish to share
serialized state with LDK node(s) running 0.0.103 and earlier.
May panic if invoice_expiry_delta_secs
is greater than one year.
Note
This method is deprecated and will be removed soon.
sourcepub fn create_inbound_payment_for_hash(
&self,
payment_hash: PaymentHash,
min_value_msat: Option<u64>,
invoice_expiry_delta_secs: u32
) -> Result<PaymentSecret, ()>
pub fn create_inbound_payment_for_hash(
&self,
payment_hash: PaymentHash,
min_value_msat: Option<u64>,
invoice_expiry_delta_secs: u32
) -> Result<PaymentSecret, ()>
Gets a PaymentSecret
for a given PaymentHash
, for which the payment preimage is
stored external to LDK.
A PaymentReceived
event will only be generated if the PaymentSecret
matches a
payment secret fetched via this method or create_inbound_payment
, and which is at least
the min_value_msat
provided here, if one is provided.
The PaymentHash
(and corresponding PaymentPreimage
) should be globally unique, though
note that LDK will not stop you from registering duplicate payment hashes for inbound
payments.
min_value_msat
should be set if the invoice being generated contains a value. Any payment
received for the returned PaymentHash
will be required to be at least min_value_msat
before a PaymentReceived
event will be generated, ensuring that we do not provide the
sender “proof-of-payment” unless they have paid the required amount.
invoice_expiry_delta_secs
describes the number of seconds that the invoice is valid for
in excess of the current time. This should roughly match the expiry time set in the invoice.
After this many seconds, we will remove the inbound payment, resulting in any attempts to
pay the invoice failing. The BOLT spec suggests 3,600 secs as a default validity time for
invoices when no timeout is set.
Note that we use block header time to time-out pending inbound payments (with some margin
to compensate for the inaccuracy of block header timestamps). Thus, in practice we will
accept a payment and generate a PaymentReceived
event for some time after the expiry.
If you need exact expiry semantics, you should enforce them upon receipt of
PaymentReceived
.
Note that invoices generated for inbound payments should have their min_final_cltv_expiry
set to at least MIN_FINAL_CLTV_EXPIRY
.
Note that a malicious eavesdropper can intuit whether an inbound payment was created by
create_inbound_payment
or create_inbound_payment_for_hash
based on runtime.
Note
If you register an inbound payment with this method, then serialize the ChannelManager
, then
deserialize it with a node running 0.0.103 and earlier, the payment will fail to be received.
Errors if min_value_msat
is greater than total bitcoin supply.
sourcepub fn create_inbound_payment_for_hash_legacy(
&self,
payment_hash: PaymentHash,
min_value_msat: Option<u64>,
invoice_expiry_delta_secs: u32
) -> Result<PaymentSecret, APIError>
👎 Deprecated
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>
Legacy version of create_inbound_payment_for_hash
. Use this method if you wish to share
serialized state with LDK node(s) running 0.0.103 and earlier.
May panic if invoice_expiry_delta_secs
is greater than one year.
Note
This method is deprecated and will be removed soon.
sourcepub fn get_payment_preimage(
&self,
payment_hash: PaymentHash,
payment_secret: PaymentSecret
) -> Result<PaymentPreimage, APIError>
pub fn get_payment_preimage(
&self,
payment_hash: PaymentHash,
payment_secret: PaymentSecret
) -> Result<PaymentPreimage, APIError>
Gets an LDK-generated payment preimage from a payment hash and payment secret that were
previously returned from create_inbound_payment
.
sourcepub fn get_phantom_scid(&self) -> u64
pub fn get_phantom_scid(&self) -> u64
Gets a fake short channel id for use in receiving phantom node payments. These fake scids are used when constructing the phantom invoice’s route hints.
sourcepub fn get_phantom_route_hints(&self) -> PhantomRouteHints
pub fn get_phantom_route_hints(&self) -> PhantomRouteHints
Gets route hints for use in receiving phantom node payments.
sourceimpl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
sourcepub fn await_persistable_update_timeout(&self, max_wait: Duration) -> bool
This is supported on crate feature std
only.
pub fn await_persistable_update_timeout(&self, max_wait: Duration) -> bool
std
only.Blocks until ChannelManager needs to be persisted or a timeout is reached. It returns a bool
indicating whether persistence is necessary. Only one listener on
await_persistable_update
or await_persistable_update_timeout
is guaranteed to be woken
up.
Note that this method is not available with the no-std
feature.
sourcepub fn await_persistable_update(&self)
pub fn await_persistable_update(&self)
Blocks until ChannelManager needs to be persisted. Only one listener on
await_persistable_update
or await_persistable_update_timeout
is guaranteed to be woken
up.
sourcepub fn current_best_block(&self) -> BestBlock
pub fn current_best_block(&self) -> BestBlock
Gets the latest best block which was connected either via the chain::Listen
or
chain::Confirm
interfaces.
Trait Implementations
sourceimpl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMessageHandler for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMessageHandler for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
sourcefn handle_open_channel(
&self,
counterparty_node_id: &PublicKey,
their_features: InitFeatures,
msg: &OpenChannel
)
fn handle_open_channel(
&self,
counterparty_node_id: &PublicKey,
their_features: InitFeatures,
msg: &OpenChannel
)
Handle an incoming open_channel message from the given peer.
sourcefn handle_accept_channel(
&self,
counterparty_node_id: &PublicKey,
their_features: InitFeatures,
msg: &AcceptChannel
)
fn handle_accept_channel(
&self,
counterparty_node_id: &PublicKey,
their_features: InitFeatures,
msg: &AcceptChannel
)
Handle an incoming accept_channel message from the given peer.
sourcefn handle_funding_created(
&self,
counterparty_node_id: &PublicKey,
msg: &FundingCreated
)
fn handle_funding_created(
&self,
counterparty_node_id: &PublicKey,
msg: &FundingCreated
)
Handle an incoming funding_created message from the given peer.
sourcefn handle_funding_signed(
&self,
counterparty_node_id: &PublicKey,
msg: &FundingSigned
)
fn handle_funding_signed(
&self,
counterparty_node_id: &PublicKey,
msg: &FundingSigned
)
Handle an incoming funding_signed message from the given peer.
sourcefn handle_funding_locked(
&self,
counterparty_node_id: &PublicKey,
msg: &FundingLocked
)
fn handle_funding_locked(
&self,
counterparty_node_id: &PublicKey,
msg: &FundingLocked
)
Handle an incoming funding_locked message from the given peer.
sourcefn handle_shutdown(
&self,
counterparty_node_id: &PublicKey,
their_features: &InitFeatures,
msg: &Shutdown
)
fn handle_shutdown(
&self,
counterparty_node_id: &PublicKey,
their_features: &InitFeatures,
msg: &Shutdown
)
Handle an incoming shutdown message from the given peer.
sourcefn handle_closing_signed(
&self,
counterparty_node_id: &PublicKey,
msg: &ClosingSigned
)
fn handle_closing_signed(
&self,
counterparty_node_id: &PublicKey,
msg: &ClosingSigned
)
Handle an incoming closing_signed message from the given peer.
sourcefn handle_update_add_htlc(
&self,
counterparty_node_id: &PublicKey,
msg: &UpdateAddHTLC
)
fn handle_update_add_htlc(
&self,
counterparty_node_id: &PublicKey,
msg: &UpdateAddHTLC
)
Handle an incoming update_add_htlc message from the given peer.
sourcefn handle_update_fulfill_htlc(
&self,
counterparty_node_id: &PublicKey,
msg: &UpdateFulfillHTLC
)
fn handle_update_fulfill_htlc(
&self,
counterparty_node_id: &PublicKey,
msg: &UpdateFulfillHTLC
)
Handle an incoming update_fulfill_htlc message from the given peer.
sourcefn handle_update_fail_htlc(
&self,
counterparty_node_id: &PublicKey,
msg: &UpdateFailHTLC
)
fn handle_update_fail_htlc(
&self,
counterparty_node_id: &PublicKey,
msg: &UpdateFailHTLC
)
Handle an incoming update_fail_htlc message from the given peer.
sourcefn handle_update_fail_malformed_htlc(
&self,
counterparty_node_id: &PublicKey,
msg: &UpdateFailMalformedHTLC
)
fn handle_update_fail_malformed_htlc(
&self,
counterparty_node_id: &PublicKey,
msg: &UpdateFailMalformedHTLC
)
Handle an incoming update_fail_malformed_htlc message from the given peer.
sourcefn handle_commitment_signed(
&self,
counterparty_node_id: &PublicKey,
msg: &CommitmentSigned
)
fn handle_commitment_signed(
&self,
counterparty_node_id: &PublicKey,
msg: &CommitmentSigned
)
Handle an incoming commitment_signed message from the given peer.
sourcefn handle_revoke_and_ack(
&self,
counterparty_node_id: &PublicKey,
msg: &RevokeAndACK
)
fn handle_revoke_and_ack(
&self,
counterparty_node_id: &PublicKey,
msg: &RevokeAndACK
)
Handle an incoming revoke_and_ack message from the given peer.
sourcefn handle_update_fee(&self, counterparty_node_id: &PublicKey, msg: &UpdateFee)
fn handle_update_fee(&self, counterparty_node_id: &PublicKey, msg: &UpdateFee)
Handle an incoming update_fee message from the given peer.
sourcefn handle_announcement_signatures(
&self,
counterparty_node_id: &PublicKey,
msg: &AnnouncementSignatures
)
fn handle_announcement_signatures(
&self,
counterparty_node_id: &PublicKey,
msg: &AnnouncementSignatures
)
Handle an incoming announcement_signatures message from the given peer.
sourcefn handle_channel_update(
&self,
counterparty_node_id: &PublicKey,
msg: &ChannelUpdate
)
fn handle_channel_update(
&self,
counterparty_node_id: &PublicKey,
msg: &ChannelUpdate
)
Handle an incoming channel update from the given peer.
sourcefn handle_channel_reestablish(
&self,
counterparty_node_id: &PublicKey,
msg: &ChannelReestablish
)
fn handle_channel_reestablish(
&self,
counterparty_node_id: &PublicKey,
msg: &ChannelReestablish
)
Handle an incoming channel_reestablish message from the given peer.
sourcefn peer_disconnected(
&self,
counterparty_node_id: &PublicKey,
no_connection_possible: bool
)
fn peer_disconnected(
&self,
counterparty_node_id: &PublicKey,
no_connection_possible: bool
)
Indicates a connection to the peer failed/an existing connection was lost. If no connection is believed to be possible in the future (eg they’re sending us messages we don’t understand or indicate they require unknown feature bits), no_connection_possible is set and any outstanding channels should be failed. Read more
sourcefn peer_connected(&self, counterparty_node_id: &PublicKey, init_msg: &Init)
fn peer_connected(&self, counterparty_node_id: &PublicKey, init_msg: &Init)
Handle a peer reconnecting, possibly generating channel_reestablish message(s).
sourcefn handle_error(&self, counterparty_node_id: &PublicKey, msg: &ErrorMessage)
fn handle_error(&self, counterparty_node_id: &PublicKey, msg: &ErrorMessage)
Handle an incoming error message from the given peer.
sourceimpl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Confirm for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Confirm for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
sourcefn transactions_confirmed(
&self,
header: &BlockHeader,
txdata: &TransactionData<'_>,
height: u32
)
fn transactions_confirmed(
&self,
header: &BlockHeader,
txdata: &TransactionData<'_>,
height: u32
)
Processes transactions confirmed in a block with a given header and height. Read more
sourcefn best_block_updated(&self, header: &BlockHeader, height: u32)
fn best_block_updated(&self, header: &BlockHeader, height: u32)
Processes an update to the best header connected at the given height. Read more
sourcefn get_relevant_txids(&self) -> Vec<Txid>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
fn get_relevant_txids(&self) -> Vec<Txid>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
Returns transactions that should be monitored for reorganization out of the chain. Read more
sourcefn transaction_unconfirmed(&self, txid: &Txid)
fn transaction_unconfirmed(&self, txid: &Txid)
Processes a transaction that is no longer confirmed as result of a chain reorganization. Read more
sourceimpl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> EventsProvider for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> EventsProvider for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
sourcefn process_pending_events<H: Deref>(&self, handler: H) where
H::Target: EventHandler,
fn process_pending_events<H: Deref>(&self, handler: H) where
H::Target: EventHandler,
Processes events that must be periodically handled.
An EventHandler
may safely call back to the provider in order to handle an event.
However, it must not call Writeable::write
as doing so would result in a deadlock.
Pending events are persisted as part of ChannelManager
. While these events are cleared
when processed, an EventHandler
must be able to handle previously seen events when
restarting from an old state.
sourceimpl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Listen for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Listen for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
sourcefn block_connected(&self, block: &Block, height: u32)
fn block_connected(&self, block: &Block, height: u32)
Notifies the listener that a block was added at the given height.
sourcefn block_disconnected(&self, header: &BlockHeader, height: u32)
fn block_disconnected(&self, header: &BlockHeader, height: u32)
Notifies the listener that a block was removed at the given height.
sourceimpl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> MessageSendEventsProvider for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> MessageSendEventsProvider for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
sourceimpl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Writeable for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Writeable for ChannelManager<Signer, M, T, K, F, L> where
M::Target: Watch<Signer>,
T::Target: BroadcasterInterface,
K::Target: KeysInterface<Signer = Signer>,
F::Target: FeeEstimator,
L::Target: Logger,
sourcefn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error>
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error>
Writes self out to the given Writer
sourcefn encode(&self) -> Vec<u8>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
fn encode(&self) -> Vec<u8>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
Writes self out to a Vec
sourcefn serialized_length(&self) -> usize
fn serialized_length(&self) -> usize
Gets the length of this object after it has been serialized. This can be overridden to optimize cases where we prepend an object with its length. Read more
Auto Trait Implementations
impl<Signer, M, T, K, F, L> !RefUnwindSafe for ChannelManager<Signer, M, T, K, F, L>
impl<Signer, M, T, K, F, L> Send for ChannelManager<Signer, M, T, K, F, L> where
F: Send,
K: Send,
L: Send,
M: Send,
Signer: Send,
T: Send,
impl<Signer, M, T, K, F, L> Sync for ChannelManager<Signer, M, T, K, F, L> where
F: Sync,
K: Sync,
L: Sync,
M: Sync,
Signer: Send,
T: Sync,
impl<Signer, M, T, K, F, L> Unpin for ChannelManager<Signer, M, T, K, F, L> where
F: Unpin,
K: Unpin,
L: Unpin,
M: Unpin,
Signer: Unpin,
T: Unpin,
impl<Signer, M, T, K, F, L> UnwindSafe for ChannelManager<Signer, M, T, K, F, L> where
F: UnwindSafe,
K: UnwindSafe,
L: UnwindSafe,
M: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more