use bitcoin::secp256k1;
use chain;
+use chain::Confirm;
use chain::Watch;
use chain::chaininterface::{BroadcasterInterface, FeeEstimator};
use chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, ChannelMonitorUpdateErr, HTLC_FAIL_BACK_BUFFER, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS, ANTI_REORG_DELAY, MonitorEvent, CLOSED_CHANNEL_UPDATE_ID};
}
/// The best known block as identified by its hash and height.
+#[derive(Clone, Copy)]
pub struct BestBlock {
block_hash: BlockHash,
height: u32,
}
}
- /// 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`].
- ///
- /// Panics if a funding transaction has already been provided for this channel.
- ///
- /// 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.
- pub fn funding_transaction_generated(&self, temporary_channel_id: &[u8; 32], funding_transaction: Transaction) -> Result<(), APIError> {
- let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier);
-
- for inp in funding_transaction.input.iter() {
- if inp.witness.is_empty() {
- return Err(APIError::APIMisuseError {
- err: "Funding transaction must be fully signed and spend Segwit outputs".to_owned()
- });
- }
- }
-
+ /// Handles the generation of a funding transaction, optionally (for tests) with a function
+ /// which checks the correctness of the funding transaction given the associated channel.
+ fn funding_transaction_generated_intern<FundingOutput: Fn(&Channel<Signer>, &Transaction) -> Result<OutPoint, APIError>>
+ (&self, temporary_channel_id: &[u8; 32], funding_transaction: Transaction, find_funding_output: FundingOutput) -> Result<(), APIError> {
let (chan, msg) = {
let (res, chan) = match self.channel_state.lock().unwrap().by_id.remove(temporary_channel_id) {
Some(mut chan) => {
- let mut output_index = None;
- let expected_spk = chan.get_funding_redeemscript().to_v0_p2wsh();
- for (idx, outp) in funding_transaction.output.iter().enumerate() {
- if outp.script_pubkey == expected_spk && outp.value == chan.get_value_satoshis() {
- if output_index.is_some() {
- return Err(APIError::APIMisuseError {
- err: "Multiple outputs matched the expected script and value".to_owned()
- });
- }
- if idx > u16::max_value() as usize {
- return Err(APIError::APIMisuseError {
- err: "Transaction had more than 2^16 outputs, which is not supported".to_owned()
- });
- }
- output_index = Some(idx as u16);
- }
- }
- if output_index.is_none() {
- return Err(APIError::APIMisuseError {
- err: "No output matched the script_pubkey and value in the FundingGenerationReady event".to_owned()
- });
- }
- let funding_txo = OutPoint { txid: funding_transaction.txid(), index: output_index.unwrap() };
+ let funding_txo = find_funding_output(&chan, &funding_transaction)?;
(chan.get_outbound_funding_created(funding_transaction, funding_txo, &self.logger)
.map_err(|e| if let ChannelError::Close(msg) = e {
Ok(())
}
+ #[cfg(test)]
+ pub(crate) fn funding_transaction_generated_unchecked(&self, temporary_channel_id: &[u8; 32], funding_transaction: Transaction, output_index: u16) -> Result<(), APIError> {
+ self.funding_transaction_generated_intern(temporary_channel_id, funding_transaction, |_, tx| {
+ Ok(OutPoint { txid: tx.txid(), index: output_index })
+ })
+ }
+
+ /// 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`].
+ ///
+ /// Panics if a funding transaction has already been provided for this channel.
+ ///
+ /// 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.
+ pub fn funding_transaction_generated(&self, temporary_channel_id: &[u8; 32], funding_transaction: Transaction) -> Result<(), APIError> {
+ let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier);
+
+ for inp in funding_transaction.input.iter() {
+ if inp.witness.is_empty() {
+ return Err(APIError::APIMisuseError {
+ err: "Funding transaction must be fully signed and spend Segwit outputs".to_owned()
+ });
+ }
+ }
+ self.funding_transaction_generated_intern(temporary_channel_id, funding_transaction, |chan, tx| {
+ let mut output_index = None;
+ let expected_spk = chan.get_funding_redeemscript().to_v0_p2wsh();
+ for (idx, outp) in tx.output.iter().enumerate() {
+ if outp.script_pubkey == expected_spk && outp.value == chan.get_value_satoshis() {
+ if output_index.is_some() {
+ return Err(APIError::APIMisuseError {
+ err: "Multiple outputs matched the expected script and value".to_owned()
+ });
+ }
+ if idx > u16::max_value() as usize {
+ return Err(APIError::APIMisuseError {
+ err: "Transaction had more than 2^16 outputs, which is not supported".to_owned()
+ });
+ }
+ output_index = Some(idx as u16);
+ }
+ }
+ if output_index.is_none() {
+ return Err(APIError::APIMisuseError {
+ err: "No output matched the script_pubkey and value in the FundingGenerationReady event".to_owned()
+ });
+ }
+ Ok(OutPoint { txid: tx.txid(), index: output_index.unwrap() })
+ })
+ }
+
fn get_announcement_sigs(&self, chan: &Channel<Signer>) -> Option<msgs::AnnouncementSignatures> {
if !chan.should_announce() {
log_trace!(self.logger, "Can't send announcement_signatures for private channel {}", log_bytes!(chan.channel_id()));
fn internal_funding_created(&self, counterparty_node_id: &PublicKey, msg: &msgs::FundingCreated) -> Result<(), MsgHandleErrInternal> {
let ((funding_msg, monitor), mut chan) = {
- let last_block_hash = self.best_block.read().unwrap().block_hash();
+ let best_block = *self.best_block.read().unwrap();
let mut channel_lock = self.channel_state.lock().unwrap();
let channel_state = &mut *channel_lock;
match channel_state.by_id.entry(msg.temporary_channel_id.clone()) {
if chan.get().get_counterparty_node_id() != *counterparty_node_id {
return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!".to_owned(), msg.temporary_channel_id));
}
- (try_chan_entry!(self, chan.get_mut().funding_created(msg, last_block_hash, &self.logger), channel_state, chan), chan.remove())
+ (try_chan_entry!(self, chan.get_mut().funding_created(msg, best_block, &self.logger), channel_state, chan), chan.remove())
},
hash_map::Entry::Vacant(_) => return Err(MsgHandleErrInternal::send_err_msg_no_close("Failed to find corresponding channel".to_owned(), msg.temporary_channel_id))
}
fn internal_funding_signed(&self, counterparty_node_id: &PublicKey, msg: &msgs::FundingSigned) -> Result<(), MsgHandleErrInternal> {
let funding_tx = {
- let last_block_hash = self.best_block.read().unwrap().block_hash();
+ let best_block = *self.best_block.read().unwrap();
let mut channel_lock = self.channel_state.lock().unwrap();
let channel_state = &mut *channel_lock;
match channel_state.by_id.entry(msg.channel_id) {
if chan.get().get_counterparty_node_id() != *counterparty_node_id {
return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!".to_owned(), msg.channel_id));
}
- let (monitor, funding_tx) = match chan.get_mut().funding_signed(&msg, last_block_hash, &self.logger) {
+ let (monitor, funding_tx) = match chan.get_mut().funding_signed(&msg, best_block, &self.logger) {
Ok(update) => update,
Err(e) => try_chan_entry!(self, Err(e), channel_state, chan),
};
}
let txdata: Vec<_> = block.txdata.iter().enumerate().collect();
- self.transactions_confirmed(&block.header, height, &txdata);
- self.update_best_block(&block.header, height);
+ self.transactions_confirmed(&block.header, &txdata, height);
+ self.best_block_updated(&block.header, height);
}
fn block_disconnected(&self, header: &BlockHeader, height: u32) {
*best_block = BestBlock::new(header.prev_blockhash, new_height)
}
- self.do_chain_event(Some(new_height), |channel| channel.update_best_block(new_height, header.time));
+ self.do_chain_event(Some(new_height), |channel| channel.best_block_updated(new_height, header.time));
+ }
+}
+
+impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> chain::Confirm for ChannelManager<Signer, M, T, K, F, L>
+where
+ M::Target: chain::Watch<Signer>,
+ T::Target: BroadcasterInterface,
+ K::Target: KeysInterface<Signer = Signer>,
+ F::Target: FeeEstimator,
+ L::Target: Logger,
+{
+ fn transactions_confirmed(&self, header: &BlockHeader, txdata: &TransactionData, height: u32) {
+ // Note that we MUST NOT end up calling methods on self.chain_monitor here - we're called
+ // during initialization prior to the chain_monitor being fully configured in some cases.
+ // See the docs for `ChannelManagerReadArgs` for more.
+
+ let block_hash = header.block_hash();
+ log_trace!(self.logger, "{} transactions included in block {} at height {} provided", txdata.len(), block_hash, height);
+
+ let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier);
+ self.do_chain_event(Some(height), |channel| channel.transactions_confirmed(&block_hash, height, txdata, &self.logger).map(|a| (a, Vec::new())));
+ }
+
+ fn best_block_updated(&self, header: &BlockHeader, height: u32) {
+ // Note that we MUST NOT end up calling methods on self.chain_monitor here - we're called
+ // during initialization prior to the chain_monitor being fully configured in some cases.
+ // See the docs for `ChannelManagerReadArgs` for more.
+
+ let block_hash = header.block_hash();
+ log_trace!(self.logger, "New best block: {} at height {}", block_hash, height);
+
+ let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier);
+
+ *self.best_block.write().unwrap() = BestBlock::new(block_hash, height);
+
+ self.do_chain_event(Some(height), |channel| channel.best_block_updated(height, header.time));
+
+ loop {
+ // Update last_node_announcement_serial to be the max of its current value and the
+ // block timestamp. This should keep us close to the current time without relying on
+ // having an explicit local time source.
+ // Just in case we end up in a race, we loop until we either successfully update
+ // last_node_announcement_serial or decide we don't need to.
+ let old_serial = self.last_node_announcement_serial.load(Ordering::Acquire);
+ if old_serial >= header.time as usize { break; }
+ if self.last_node_announcement_serial.compare_exchange(old_serial, header.time as usize, Ordering::AcqRel, Ordering::Relaxed).is_ok() {
+ break;
+ }
+ }
+ }
+
+ fn get_relevant_txids(&self) -> Vec<Txid> {
+ let channel_state = self.channel_state.lock().unwrap();
+ let mut res = Vec::with_capacity(channel_state.short_to_id.len());
+ for chan in channel_state.by_id.values() {
+ if let Some(funding_txo) = chan.get_funding_txo() {
+ res.push(funding_txo.txid);
+ }
+ }
+ res
+ }
+
+ fn transaction_unconfirmed(&self, txid: &Txid) {
+ let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier);
+ self.do_chain_event(None, |channel| {
+ if let Some(funding_txo) = channel.get_funding_txo() {
+ if funding_txo.txid == *txid {
+ channel.funding_transaction_unconfirmed().map(|_| (None, Vec::new()))
+ } else { Ok((None, Vec::new())) }
+ } else { Ok((None, Vec::new())) }
+ });
}
}
impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<Signer, M, T, K, F, L>
- where M::Target: chain::Watch<Signer>,
- T::Target: BroadcasterInterface,
- K::Target: KeysInterface<Signer = Signer>,
- F::Target: FeeEstimator,
- L::Target: Logger,
+where
+ M::Target: chain::Watch<Signer>,
+ T::Target: BroadcasterInterface,
+ K::Target: KeysInterface<Signer = Signer>,
+ F::Target: FeeEstimator,
+ L::Target: Logger,
{
/// Calls a function which handles an on-chain event (blocks dis/connected, transactions
/// un/confirmed, etc) on each channel, handling any resulting errors or messages generated by
}
}
- /// Updates channel state to take note of transactions which were confirmed in the given block
- /// at the given height.
- ///
- /// Note that you must still call (or have called) [`update_best_block`] with the block
- /// information which is included here.
- ///
- /// This method may be called before or after [`update_best_block`] for a given block's
- /// transaction data and may be called multiple times with additional transaction data for a
- /// given block.
- ///
- /// This method may be called for a previous block after an [`update_best_block`] call has
- /// been made for a later block, however it must *not* be called with transaction data from a
- /// block which is no longer in the best chain (ie where [`update_best_block`] has already
- /// been informed about a blockchain reorganization which no longer includes the block which
- /// corresponds to `header`).
- ///
- /// [`update_best_block`]: `Self::update_best_block`
- pub fn transactions_confirmed(&self, header: &BlockHeader, height: u32, txdata: &TransactionData) {
- // Note that we MUST NOT end up calling methods on self.chain_monitor here - we're called
- // during initialization prior to the chain_monitor being fully configured in some cases.
- // See the docs for `ChannelManagerReadArgs` for more.
-
- let block_hash = header.block_hash();
- log_trace!(self.logger, "{} transactions included in block {} at height {} provided", txdata.len(), block_hash, height);
-
- let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier);
- self.do_chain_event(Some(height), |channel| channel.transactions_confirmed(&block_hash, height, txdata, &self.logger).map(|a| (a, Vec::new())));
- }
-
- /// Updates channel state with the current best blockchain tip. You should attempt to call this
- /// quickly after a new block becomes available, however if multiple new blocks become
- /// available at the same time, only a single `update_best_block()` call needs to be made.
- ///
- /// This method should also be called immediately after any block disconnections, once at the
- /// reorganization fork point, and once with the new chain tip. Calling this method at the
- /// blockchain reorganization fork point ensures we learn when a funding transaction which was
- /// previously confirmed is reorganized out of the blockchain, ensuring we do not continue to
- /// accept payments which cannot be enforced on-chain.
- ///
- /// In both the block-connection and block-disconnection case, this method may be called either
- /// once per block connected or disconnected, or simply at the fork point and new tip(s),
- /// skipping any intermediary blocks.
- pub fn update_best_block(&self, header: &BlockHeader, height: u32) {
- // Note that we MUST NOT end up calling methods on self.chain_monitor here - we're called
- // during initialization prior to the chain_monitor being fully configured in some cases.
- // See the docs for `ChannelManagerReadArgs` for more.
-
- let block_hash = header.block_hash();
- log_trace!(self.logger, "New best block: {} at height {}", block_hash, height);
-
- let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier);
-
- *self.best_block.write().unwrap() = BestBlock::new(block_hash, height);
-
- self.do_chain_event(Some(height), |channel| channel.update_best_block(height, header.time));
-
- loop {
- // Update last_node_announcement_serial to be the max of its current value and the
- // block timestamp. This should keep us close to the current time without relying on
- // having an explicit local time source.
- // Just in case we end up in a race, we loop until we either successfully update
- // last_node_announcement_serial or decide we don't need to.
- let old_serial = self.last_node_announcement_serial.load(Ordering::Acquire);
- if old_serial >= header.time as usize { break; }
- if self.last_node_announcement_serial.compare_exchange(old_serial, header.time as usize, Ordering::AcqRel, Ordering::Relaxed).is_ok() {
- break;
- }
- }
- }
-
- /// Gets the set of txids which should be monitored for their confirmation state.
- ///
- /// If you're providing information about reorganizations via [`transaction_unconfirmed`], this
- /// is the set of transactions which you may need to call [`transaction_unconfirmed`] for.
- ///
- /// This may be useful to poll to determine the set of transactions which must be registered
- /// with an Electrum server or for which an Electrum server needs to be polled to determine
- /// transaction confirmation state.
- ///
- /// This may update after any [`transactions_confirmed`] or [`block_connected`] call.
- ///
- /// Note that this is NOT the set of transactions which must be included in calls to
- /// [`transactions_confirmed`] if they are confirmed, but a small subset of it.
- ///
- /// [`transactions_confirmed`]: Self::transactions_confirmed
- /// [`transaction_unconfirmed`]: Self::transaction_unconfirmed
- /// [`block_connected`]: chain::Listen::block_connected
- pub fn get_relevant_txids(&self) -> Vec<Txid> {
- let channel_state = self.channel_state.lock().unwrap();
- let mut res = Vec::with_capacity(channel_state.short_to_id.len());
- for chan in channel_state.by_id.values() {
- if let Some(funding_txo) = chan.get_funding_txo() {
- res.push(funding_txo.txid);
- }
- }
- res
- }
-
- /// Marks a transaction as having been reorganized out of the blockchain.
- ///
- /// If a transaction is included in [`get_relevant_txids`], and is no longer in the main branch
- /// of the blockchain, this function should be called to indicate that the transaction should
- /// be considered reorganized out.
- ///
- /// Once this is called, the given transaction will no longer appear on [`get_relevant_txids`],
- /// though this may be called repeatedly for a given transaction without issue.
- ///
- /// Note that if the transaction is confirmed on the main chain in a different block (indicated
- /// via a call to [`transactions_confirmed`]), it may re-appear in [`get_relevant_txids`], thus
- /// be very wary of race-conditions wherein the final state of a transaction indicated via
- /// these APIs is not the same as its state on the blockchain.
- ///
- /// [`transactions_confirmed`]: Self::transactions_confirmed
- /// [`get_relevant_txids`]: Self::get_relevant_txids
- pub fn transaction_unconfirmed(&self, txid: &Txid) {
- let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier);
- self.do_chain_event(None, |channel| {
- if let Some(funding_txo) = channel.get_funding_txo() {
- if funding_txo.txid == *txid {
- channel.funding_transaction_unconfirmed().map(|_| (None, Vec::new()))
- } else { Ok((None, Vec::new())) }
- } else { Ok((None, Vec::new())) }
- });
- }
-
/// 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
projects / rust-lightning / blobdiff