+ #[cfg(test)]
+ fn provide_secret(&self, idx: u64, secret: [u8; 32]) -> Result<(), MonitorUpdateError> {
+ self.inner.lock().unwrap().provide_secret(idx, secret)
+ }
+
+ /// Informs this monitor of the latest counterparty (ie non-broadcastable) commitment transaction.
+ /// The monitor watches for it to be broadcasted and then uses the HTLC information (and
+ /// possibly future revocation/preimage information) to claim outputs where possible.
+ /// We cache also the mapping hash:commitment number to lighten pruning of old preimages by watchtowers.
+ pub(crate) fn provide_latest_counterparty_commitment_tx<L: Deref>(
+ &self,
+ txid: Txid,
+ htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)>,
+ commitment_number: u64,
+ their_revocation_point: PublicKey,
+ logger: &L,
+ ) where L::Target: Logger {
+ self.inner.lock().unwrap().provide_latest_counterparty_commitment_tx(
+ txid, htlc_outputs, commitment_number, their_revocation_point, logger)
+ }
+
+ #[cfg(test)]
+ fn provide_latest_holder_commitment_tx(
+ &self,
+ holder_commitment_tx: HolderCommitmentTransaction,
+ htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
+ ) -> Result<(), MonitorUpdateError> {
+ self.inner.lock().unwrap().provide_latest_holder_commitment_tx(
+ holder_commitment_tx, htlc_outputs)
+ }
+
+ #[cfg(test)]
+ pub(crate) fn provide_payment_preimage<B: Deref, F: Deref, L: Deref>(
+ &self,
+ payment_hash: &PaymentHash,
+ payment_preimage: &PaymentPreimage,
+ broadcaster: &B,
+ fee_estimator: &F,
+ logger: &L,
+ ) where
+ B::Target: BroadcasterInterface,
+ F::Target: FeeEstimator,
+ L::Target: Logger,
+ {
+ self.inner.lock().unwrap().provide_payment_preimage(
+ payment_hash, payment_preimage, broadcaster, fee_estimator, logger)
+ }
+
+ pub(crate) fn broadcast_latest_holder_commitment_txn<B: Deref, L: Deref>(
+ &self,
+ broadcaster: &B,
+ logger: &L,
+ ) where
+ B::Target: BroadcasterInterface,
+ L::Target: Logger,
+ {
+ self.inner.lock().unwrap().broadcast_latest_holder_commitment_txn(broadcaster, logger)
+ }
+
+ /// Updates a ChannelMonitor on the basis of some new information provided by the Channel
+ /// itself.
+ ///
+ /// panics if the given update is not the next update by update_id.
+ pub fn update_monitor<B: Deref, F: Deref, L: Deref>(
+ &self,
+ updates: &ChannelMonitorUpdate,
+ broadcaster: &B,
+ fee_estimator: &F,
+ logger: &L,
+ ) -> Result<(), MonitorUpdateError>
+ where
+ B::Target: BroadcasterInterface,
+ F::Target: FeeEstimator,
+ L::Target: Logger,
+ {
+ self.inner.lock().unwrap().update_monitor(updates, broadcaster, fee_estimator, logger)
+ }
+
+ /// Gets the update_id from the latest ChannelMonitorUpdate which was applied to this
+ /// ChannelMonitor.
+ pub fn get_latest_update_id(&self) -> u64 {
+ self.inner.lock().unwrap().get_latest_update_id()
+ }
+
+ /// Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for.
+ pub fn get_funding_txo(&self) -> (OutPoint, Script) {
+ self.inner.lock().unwrap().get_funding_txo().clone()
+ }
+
+ /// Gets a list of txids, with their output scripts (in the order they appear in the
+ /// transaction), which we must learn about spends of via block_connected().
+ ///
+ /// (C-not exported) because we have no HashMap bindings
+ pub fn get_outputs_to_watch(&self) -> HashMap<Txid, Vec<(u32, Script)>> {
+ self.inner.lock().unwrap().get_outputs_to_watch().clone()
+ }
+
+ /// Get the list of HTLCs who's status has been updated on chain. This should be called by
+ /// ChannelManager via [`chain::Watch::release_pending_monitor_events`].
+ ///
+ /// [`chain::Watch::release_pending_monitor_events`]: ../trait.Watch.html#tymethod.release_pending_monitor_events
+ pub fn get_and_clear_pending_monitor_events(&self) -> Vec<MonitorEvent> {
+ self.inner.lock().unwrap().get_and_clear_pending_monitor_events()
+ }
+
+ /// Gets the list of pending events which were generated by previous actions, clearing the list
+ /// in the process.
+ ///
+ /// This is called by ChainMonitor::get_and_clear_pending_events() and is equivalent to
+ /// EventsProvider::get_and_clear_pending_events() except that it requires &mut self as we do
+ /// no internal locking in ChannelMonitors.
+ pub fn get_and_clear_pending_events(&self) -> Vec<Event> {
+ self.inner.lock().unwrap().get_and_clear_pending_events()
+ }
+
+ pub(crate) fn get_min_seen_secret(&self) -> u64 {
+ self.inner.lock().unwrap().get_min_seen_secret()
+ }
+
+ pub(crate) fn get_cur_counterparty_commitment_number(&self) -> u64 {
+ self.inner.lock().unwrap().get_cur_counterparty_commitment_number()
+ }
+
+ pub(crate) fn get_cur_holder_commitment_number(&self) -> u64 {
+ self.inner.lock().unwrap().get_cur_holder_commitment_number()
+ }
+
+ /// Used by ChannelManager deserialization to broadcast the latest holder state if its copy of
+ /// the Channel was out-of-date. You may use it to get a broadcastable holder toxic tx in case of
+ /// fallen-behind, i.e when receiving a channel_reestablish with a proof that our counterparty side knows
+ /// a higher revocation secret than the holder commitment number we are aware of. Broadcasting these
+ /// transactions are UNSAFE, as they allow counterparty side to punish you. Nevertheless you may want to
+ /// broadcast them if counterparty don't close channel with his higher commitment transaction after a
+ /// substantial amount of time (a month or even a year) to get back funds. Best may be to contact
+ /// out-of-band the other node operator to coordinate with him if option is available to you.
+ /// In any-case, choice is up to the user.
+ pub fn get_latest_holder_commitment_txn<L: Deref>(&self, logger: &L) -> Vec<Transaction>
+ where L::Target: Logger {
+ self.inner.lock().unwrap().get_latest_holder_commitment_txn(logger)
+ }
+
+ /// Unsafe test-only version of get_latest_holder_commitment_txn used by our test framework
+ /// to bypass HolderCommitmentTransaction state update lockdown after signature and generate
+ /// revoked commitment transaction.
+ #[cfg(any(test, feature = "unsafe_revoked_tx_signing"))]
+ pub fn unsafe_get_latest_holder_commitment_txn<L: Deref>(&self, logger: &L) -> Vec<Transaction>
+ where L::Target: Logger {
+ self.inner.lock().unwrap().unsafe_get_latest_holder_commitment_txn(logger)
+ }
+
+ /// Processes transactions in a newly connected block, which may result in any of the following:
+ /// - update the monitor's state against resolved HTLCs
+ /// - punish the counterparty in the case of seeing a revoked commitment transaction
+ /// - force close the channel and claim/timeout incoming/outgoing HTLCs if near expiration
+ /// - detect settled outputs for later spending
+ /// - schedule and bump any in-flight claims
+ ///
+ /// Returns any new outputs to watch from `txdata`; after called, these are also included in
+ /// [`get_outputs_to_watch`].
+ ///
+ /// [`get_outputs_to_watch`]: #method.get_outputs_to_watch
+ pub fn block_connected<B: Deref, F: Deref, L: Deref>(
+ &self,
+ header: &BlockHeader,
+ txdata: &TransactionData,
+ height: u32,
+ broadcaster: B,
+ fee_estimator: F,
+ logger: L,
+ ) -> Vec<(Txid, Vec<(u32, TxOut)>)>
+ where
+ B::Target: BroadcasterInterface,
+ F::Target: FeeEstimator,
+ L::Target: Logger,
+ {
+ self.inner.lock().unwrap().block_connected(
+ header, txdata, height, broadcaster, fee_estimator, logger)
+ }
+
+ /// Determines if the disconnected block contained any transactions of interest and updates
+ /// appropriately.
+ pub fn block_disconnected<B: Deref, F: Deref, L: Deref>(
+ &self,
+ header: &BlockHeader,
+ height: u32,
+ broadcaster: B,
+ fee_estimator: F,
+ logger: L,
+ ) where
+ B::Target: BroadcasterInterface,
+ F::Target: FeeEstimator,
+ L::Target: Logger,
+ {
+ self.inner.lock().unwrap().block_disconnected(
+ header, height, broadcaster, fee_estimator, logger)
+ }
+}
+
+impl<Signer: Sign> ChannelMonitorImpl<Signer> {