use bitcoin::blockdata::transaction::{TxIn,TxOut,SigHashType,Transaction};
use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint;
use bitcoin::blockdata::script::Script;
-use bitcoin::network::serialize;
-use bitcoin::network::encodable::{ConsensusDecodable, ConsensusEncodable};
-use bitcoin::util::hash::Sha256dHash;
+use bitcoin::consensus::encode::{self, Decodable, Encodable};
+use bitcoin::util::hash::{BitcoinHash,Sha256dHash};
use bitcoin::util::bip143;
use crypto::digest::Digest;
chain_monitor: Arc<ChainWatchInterface>,
broadcaster: Arc<BroadcasterInterface>,
pending_events: Mutex<Vec<events::Event>>,
+ logger: Arc<Logger>,
}
impl<Key : Send + cmp::Eq + hash::Hash> ChainListener for SimpleManyChannelMonitor<Key> {
- fn block_connected(&self, _header: &BlockHeader, height: u32, txn_matched: &[&Transaction], _indexes_of_txn_matched: &[u32]) {
+ fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], _indexes_of_txn_matched: &[u32]) {
+ let block_hash = header.bitcoin_hash();
let mut new_events: Vec<events::Event> = Vec::with_capacity(0);
{
- let monitors = self.monitors.lock().unwrap();
- for monitor in monitors.values() {
- let (txn_outputs, spendable_outputs) = monitor.block_connected(txn_matched, height, &*self.broadcaster);
+ let mut monitors = self.monitors.lock().unwrap();
+ for monitor in monitors.values_mut() {
+ let (txn_outputs, spendable_outputs) = monitor.block_connected(txn_matched, height, &block_hash, &*self.broadcaster);
if spendable_outputs.len() > 0 {
new_events.push(events::Event::SpendableOutputs {
outputs: spendable_outputs,
impl<Key : Send + cmp::Eq + hash::Hash + 'static> SimpleManyChannelMonitor<Key> {
/// Creates a new object which can be used to monitor several channels given the chain
/// interface with which to register to receive notifications.
- pub fn new(chain_monitor: Arc<ChainWatchInterface>, broadcaster: Arc<BroadcasterInterface>) -> Arc<SimpleManyChannelMonitor<Key>> {
+ pub fn new(chain_monitor: Arc<ChainWatchInterface>, broadcaster: Arc<BroadcasterInterface>, logger: Arc<Logger>) -> Arc<SimpleManyChannelMonitor<Key>> {
let res = Arc::new(SimpleManyChannelMonitor {
monitors: Mutex::new(HashMap::new()),
chain_monitor,
broadcaster,
pending_events: Mutex::new(Vec::new()),
+ logger,
});
let weak_res = Arc::downgrade(&res);
res.chain_monitor.register_listener(weak_res);
pub fn add_update_monitor_by_key(&self, key: Key, monitor: ChannelMonitor) -> Result<(), HandleError> {
let mut monitors = self.monitors.lock().unwrap();
match monitors.get_mut(&key) {
- Some(orig_monitor) => return orig_monitor.insert_combine(monitor),
+ Some(orig_monitor) => {
+ log_trace!(self, "Updating Channel Monitor for channel {}", log_funding_option!(monitor.funding_txo));
+ return orig_monitor.insert_combine(monitor);
+ },
None => {}
};
match &monitor.funding_txo {
- &None => self.chain_monitor.watch_all_txn(),
+ &None => {
+ log_trace!(self, "Got new Channel Monitor for no-funding-set channel (monitoring all txn!)");
+ self.chain_monitor.watch_all_txn()
+ },
&Some((ref outpoint, ref script)) => {
+ log_trace!(self, "Got new Channel Monitor for channel {}", log_bytes!(outpoint.to_channel_id()[..]));
self.chain_monitor.install_watch_tx(&outpoint.txid, script);
self.chain_monitor.install_watch_outpoint((outpoint.txid, outpoint.index as u32), script);
},
///
/// You MUST ensure that no ChannelMonitors for a given channel anywhere contain out-of-date
/// information and are actively monitoring the chain.
+#[derive(Clone)]
pub struct ChannelMonitor {
funding_txo: Option<(OutPoint, Script)>,
commitment_transaction_number_obscure_factor: u64,
/// spending. Thus, in order to claim them via revocation key, we track all the remote
/// commitment transactions which we find on-chain, mapping them to the commitment number which
/// can be used to derive the revocation key and claim the transactions.
- remote_commitment_txn_on_chain: Mutex<HashMap<Sha256dHash, u64>>,
+ remote_commitment_txn_on_chain: HashMap<Sha256dHash, (u64, Vec<Script>)>,
/// Cache used to make pruning of payment_preimages faster.
/// Maps payment_hash values to commitment numbers for remote transactions for non-revoked
/// remote transactions (ie should remain pretty small).
prev_local_signed_commitment_tx: Option<LocalSignedTx>,
current_local_signed_commitment_tx: Option<LocalSignedTx>,
+ // Used just for ChannelManager to make sure it has the latest channel data during
+ // deserialization
+ current_remote_commitment_number: u64,
+
payment_preimages: HashMap<[u8; 32], [u8; 32]>,
destination_script: Script,
+ // We simply modify last_block_hash in Channel's block_connected so that serialization is
+ // consistent but hopefully the users' copy handles block_connected in a consistent way.
+ // (we do *not*, however, update them in insert_combine to ensure any local user copies keep
+ // their last_block_hash from its state and not based on updated copies that didn't run through
+ // the full block_connected).
+ pub(crate) last_block_hash: Sha256dHash,
secp_ctx: Secp256k1<secp256k1::All>, //TODO: dedup this a bit...
logger: Arc<Logger>,
}
-impl Clone for ChannelMonitor {
- fn clone(&self) -> Self {
- ChannelMonitor {
- funding_txo: self.funding_txo.clone(),
- commitment_transaction_number_obscure_factor: self.commitment_transaction_number_obscure_factor.clone(),
-
- key_storage: self.key_storage.clone(),
- their_htlc_base_key: self.their_htlc_base_key.clone(),
- their_delayed_payment_base_key: self.their_delayed_payment_base_key.clone(),
- their_cur_revocation_points: self.their_cur_revocation_points.clone(),
-
- our_to_self_delay: self.our_to_self_delay,
- their_to_self_delay: self.their_to_self_delay,
-
- old_secrets: self.old_secrets.clone(),
- remote_claimable_outpoints: self.remote_claimable_outpoints.clone(),
- remote_commitment_txn_on_chain: Mutex::new((*self.remote_commitment_txn_on_chain.lock().unwrap()).clone()),
- remote_hash_commitment_number: self.remote_hash_commitment_number.clone(),
-
- prev_local_signed_commitment_tx: self.prev_local_signed_commitment_tx.clone(),
- current_local_signed_commitment_tx: self.current_local_signed_commitment_tx.clone(),
-
- payment_preimages: self.payment_preimages.clone(),
-
- destination_script: self.destination_script.clone(),
- secp_ctx: self.secp_ctx.clone(),
- logger: self.logger.clone(),
- }
- }
-}
#[cfg(any(test, feature = "fuzztarget"))]
/// Used only in testing and fuzztarget to check serialization roundtrips don't change the
self.our_to_self_delay != other.our_to_self_delay ||
self.their_to_self_delay != other.their_to_self_delay ||
self.remote_claimable_outpoints != other.remote_claimable_outpoints ||
+ self.remote_commitment_txn_on_chain != other.remote_commitment_txn_on_chain ||
self.remote_hash_commitment_number != other.remote_hash_commitment_number ||
self.prev_local_signed_commitment_tx != other.prev_local_signed_commitment_tx ||
+ self.current_remote_commitment_number != other.current_remote_commitment_number ||
self.current_local_signed_commitment_tx != other.current_local_signed_commitment_tx ||
self.payment_preimages != other.payment_preimages ||
self.destination_script != other.destination_script
return false
}
}
- let us = self.remote_commitment_txn_on_chain.lock().unwrap();
- let them = other.remote_commitment_txn_on_chain.lock().unwrap();
- *us == *them
+ true
}
}
}
old_secrets: [([0; 32], 1 << 48); 49],
remote_claimable_outpoints: HashMap::new(),
- remote_commitment_txn_on_chain: Mutex::new(HashMap::new()),
+ remote_commitment_txn_on_chain: HashMap::new(),
remote_hash_commitment_number: HashMap::new(),
prev_local_signed_commitment_tx: None,
current_local_signed_commitment_tx: None,
+ current_remote_commitment_number: 1 << 48,
payment_preimages: HashMap::new(),
destination_script: destination_script,
+ last_block_hash: Default::default(),
secp_ctx: Secp256k1::new(),
logger,
}
self.remote_hash_commitment_number.insert(htlc.payment_hash, commitment_number);
}
self.remote_claimable_outpoints.insert(unsigned_commitment_tx.txid(), htlc_outputs);
+ self.current_remote_commitment_number = commitment_number;
}
/// Informs this monitor of the latest local (ie broadcastable) commitment transaction. The
if our_min_secret > other_min_secret {
self.provide_secret(other_min_secret, other.get_secret(other_min_secret).unwrap(), None)?;
}
+ // TODO: We should use current_remote_commitment_number and the commitment number out of
+ // local transactions to decide how to merge
if our_min_secret >= other_min_secret {
self.their_cur_revocation_points = other.their_cur_revocation_points;
for (txid, htlcs) in other.remote_claimable_outpoints.drain() {
}
self.payment_preimages = other.payment_preimages;
}
+ self.current_remote_commitment_number = cmp::min(self.current_remote_commitment_number, other.current_remote_commitment_number);
Ok(())
}
}
}
+ /// Gets the sets of all outpoints which this ChannelMonitor expects to hear about spends of.
+ /// Generally useful when deserializing as during normal operation the return values of
+ /// block_connected are sufficient to ensure all relevant outpoints are being monitored (note
+ /// that the get_funding_txo outpoint and transaction must also be monitored for!).
+ pub fn get_monitored_outpoints(&self) -> Vec<(Sha256dHash, u32, &Script)> {
+ let mut res = Vec::with_capacity(self.remote_commitment_txn_on_chain.len() * 2);
+ for (ref txid, &(_, ref outputs)) in self.remote_commitment_txn_on_chain.iter() {
+ for (idx, output) in outputs.iter().enumerate() {
+ res.push(((*txid).clone(), idx as u32, output));
+ }
+ }
+ res
+ }
+
/// Serializes into a vec, with various modes for the exposed pub fns
fn write<W: Writer>(&self, writer: &mut W, for_local_storage: bool) -> Result<(), ::std::io::Error> {
//TODO: We still write out all the serialization here manually instead of using the fancy
}
writer.write_all(&byte_utils::be64_to_array(self.remote_claimable_outpoints.len() as u64))?;
- for (txid, htlc_outputs) in self.remote_claimable_outpoints.iter() {
+ for (ref txid, ref htlc_outputs) in self.remote_claimable_outpoints.iter() {
writer.write_all(&txid[..])?;
writer.write_all(&byte_utils::be64_to_array(htlc_outputs.len() as u64))?;
for htlc_output in htlc_outputs.iter() {
}
}
- {
- let remote_commitment_txn_on_chain = self.remote_commitment_txn_on_chain.lock().unwrap();
- writer.write_all(&byte_utils::be64_to_array(remote_commitment_txn_on_chain.len() as u64))?;
- for (txid, commitment_number) in remote_commitment_txn_on_chain.iter() {
- writer.write_all(&txid[..])?;
- writer.write_all(&byte_utils::be48_to_array(*commitment_number))?;
+ writer.write_all(&byte_utils::be64_to_array(self.remote_commitment_txn_on_chain.len() as u64))?;
+ for (ref txid, &(commitment_number, ref txouts)) in self.remote_commitment_txn_on_chain.iter() {
+ writer.write_all(&txid[..])?;
+ writer.write_all(&byte_utils::be48_to_array(commitment_number))?;
+ (txouts.len() as u64).write(writer)?;
+ for script in txouts.iter() {
+ script.write(writer)?;
}
}
if for_local_storage {
writer.write_all(&byte_utils::be64_to_array(self.remote_hash_commitment_number.len() as u64))?;
- for (payment_hash, commitment_number) in self.remote_hash_commitment_number.iter() {
- writer.write_all(payment_hash)?;
+ for (ref payment_hash, commitment_number) in self.remote_hash_commitment_number.iter() {
+ writer.write_all(*payment_hash)?;
writer.write_all(&byte_utils::be48_to_array(*commitment_number))?;
}
} else {
macro_rules! serialize_local_tx {
($local_tx: expr) => {
- if let Err(e) = $local_tx.tx.consensus_encode(&mut serialize::RawEncoder::new(WriterWriteAdaptor(writer))) {
+ if let Err(e) = $local_tx.tx.consensus_encode(&mut WriterWriteAdaptor(writer)) {
match e {
- serialize::Error::Io(e) => return Err(e),
+ encode::Error::Io(e) => return Err(e),
_ => panic!("local tx must have been well-formed!"),
}
}
writer.write_all(&[0; 1])?;
}
+ if for_local_storage {
+ writer.write_all(&byte_utils::be48_to_array(self.current_remote_commitment_number))?;
+ } else {
+ writer.write_all(&byte_utils::be48_to_array(0))?;
+ }
+
writer.write_all(&byte_utils::be64_to_array(self.payment_preimages.len() as u64))?;
for payment_preimage in self.payment_preimages.values() {
writer.write_all(payment_preimage)?;
}
+ self.last_block_hash.write(writer)?;
self.destination_script.write(writer)?;
Ok(())
}
/// Writes this monitor into the given writer, suitable for writing to disk.
+ ///
+ /// Note that the deserializer is only implemented for (Sha256dHash, ChannelMonitor), which
+ /// tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along
+ /// the "reorg path" (ie not just starting at the same height but starting at the highest
+ /// common block that appears on your best chain as well as on the chain which contains the
+ /// last block hash returned) upon deserializing the object!
pub fn write_for_disk<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
self.write(writer, true)
}
/// Encodes this monitor into the given writer, suitable for sending to a remote watchtower
+ ///
+ /// Note that the deserializer is only implemented for (Sha256dHash, ChannelMonitor), which
+ /// tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along
+ /// the "reorg path" (ie not just starting at the same height but starting at the highest
+ /// common block that appears on your best chain as well as on the chain which contains the
+ /// last block hash returned) upon deserializing the object!
pub fn write_for_watchtower<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
self.write(writer, false)
}
min
}
+ pub(super) fn get_cur_remote_commitment_number(&self) -> u64 {
+ self.current_remote_commitment_number
+ }
+
+ pub(super) fn get_cur_local_commitment_number(&self) -> u64 {
+ if let &Some(ref local_tx) = &self.current_local_signed_commitment_tx {
+ 0xffff_ffff_ffff - ((((local_tx.tx.input[0].sequence as u64 & 0xffffff) << 3*8) | (local_tx.tx.lock_time as u64 & 0xffffff)) ^ self.commitment_transaction_number_obscure_factor)
+ } else { 0xffff_ffff_ffff }
+ }
+
/// Attempts to claim a remote commitment transaction's outputs using the revocation key and
/// data in remote_claimable_outpoints. Will directly claim any HTLC outputs which expire at a
/// height > height + CLTV_SHARED_CLAIM_BUFFER. In any case, will install monitoring for
/// HTLC-Success/HTLC-Timeout transactions.
- fn check_spend_remote_transaction(&self, tx: &Transaction, height: u32) -> (Vec<Transaction>, (Sha256dHash, Vec<TxOut>), Vec<SpendableOutputDescriptor>) {
+ fn check_spend_remote_transaction(&mut self, tx: &Transaction, height: u32) -> (Vec<Transaction>, (Sha256dHash, Vec<TxOut>), Vec<SpendableOutputDescriptor>) {
// Most secp and related errors trying to create keys means we have no hope of constructing
// a spend transaction...so we return no transactions to broadcast
let mut txn_to_broadcast = Vec::new();
if !inputs.is_empty() || !txn_to_broadcast.is_empty() { // ie we're confident this is actually ours
// We're definitely a remote commitment transaction!
watch_outputs.append(&mut tx.output.clone());
- self.remote_commitment_txn_on_chain.lock().unwrap().insert(commitment_txid, commitment_number);
+ self.remote_commitment_txn_on_chain.insert(commitment_txid, (commitment_number, tx.output.iter().map(|output| { output.script_pubkey.clone() }).collect()));
}
if inputs.is_empty() { return (txn_to_broadcast, (commitment_txid, watch_outputs), spendable_outputs); } // Nothing to be done...probably a false positive/local tx
// not being generated by the above conditional. Thus, to be safe, we go ahead and
// insert it here.
watch_outputs.append(&mut tx.output.clone());
- self.remote_commitment_txn_on_chain.lock().unwrap().insert(commitment_txid, commitment_number);
+ self.remote_commitment_txn_on_chain.insert(commitment_txid, (commitment_number, tx.output.iter().map(|output| { output.script_pubkey.clone() }).collect()));
if let Some(revocation_points) = self.their_cur_revocation_points {
let revocation_point_option =
let mut res = Vec::with_capacity(local_tx.htlc_outputs.len());
let mut spendable_outputs = Vec::with_capacity(local_tx.htlc_outputs.len());
+ macro_rules! add_dynamic_output {
+ ($father_tx: expr, $vout: expr) => {
+ if let Some(ref per_commitment_point) = *per_commitment_point {
+ if let Some(ref delayed_payment_base_key) = *delayed_payment_base_key {
+ if let Ok(local_delayedkey) = chan_utils::derive_private_key(&self.secp_ctx, per_commitment_point, delayed_payment_base_key) {
+ spendable_outputs.push(SpendableOutputDescriptor::DynamicOutput {
+ outpoint: BitcoinOutPoint { txid: $father_tx.txid(), vout: $vout },
+ local_delayedkey,
+ witness_script: chan_utils::get_revokeable_redeemscript(&local_tx.revocation_key, self.our_to_self_delay, &local_tx.delayed_payment_key),
+ to_self_delay: self.our_to_self_delay
+ });
+ }
+ }
+ }
+ }
+ }
+
+
+ let redeemscript = chan_utils::get_revokeable_redeemscript(&local_tx.revocation_key, self.their_to_self_delay.unwrap(), &local_tx.delayed_payment_key);
+ let revokeable_p2wsh = redeemscript.to_v0_p2wsh();
+ for (idx, output) in local_tx.tx.output.iter().enumerate() {
+ if output.script_pubkey == revokeable_p2wsh {
+ add_dynamic_output!(local_tx.tx, idx as u32);
+ break;
+ }
+ }
+
for &(ref htlc, ref their_sig, ref our_sig) in local_tx.htlc_outputs.iter() {
if htlc.offered {
let mut htlc_timeout_tx = chan_utils::build_htlc_transaction(&local_tx.txid, local_tx.feerate_per_kw, self.their_to_self_delay.unwrap(), htlc, &local_tx.delayed_payment_key, &local_tx.revocation_key);
htlc_timeout_tx.input[0].witness.push(Vec::new());
htlc_timeout_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_bytes());
- if let Some(ref per_commitment_point) = *per_commitment_point {
- if let Some(ref delayed_payment_base_key) = *delayed_payment_base_key {
- if let Ok(local_delayedkey) = chan_utils::derive_private_key(&self.secp_ctx, per_commitment_point, delayed_payment_base_key) {
- spendable_outputs.push(SpendableOutputDescriptor::DynamicOutput {
- outpoint: BitcoinOutPoint { txid: htlc_timeout_tx.txid(), vout: 0 },
- local_delayedkey,
- witness_script: chan_utils::get_revokeable_redeemscript(&local_tx.revocation_key, self.our_to_self_delay, &local_tx.delayed_payment_key),
- to_self_delay: self.our_to_self_delay
- });
- }
- }
- }
+ add_dynamic_output!(htlc_timeout_tx, 0);
res.push(htlc_timeout_tx);
} else {
if let Some(payment_preimage) = self.payment_preimages.get(&htlc.payment_hash) {
htlc_success_tx.input[0].witness.push(payment_preimage.to_vec());
htlc_success_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_bytes());
- if let Some(ref per_commitment_point) = *per_commitment_point {
- if let Some(ref delayed_payment_base_key) = *delayed_payment_base_key {
- if let Ok(local_delayedkey) = chan_utils::derive_private_key(&self.secp_ctx, per_commitment_point, delayed_payment_base_key) {
- spendable_outputs.push(SpendableOutputDescriptor::DynamicOutput {
- outpoint: BitcoinOutPoint { txid: htlc_success_tx.txid(), vout: 0 },
- local_delayedkey,
- witness_script: chan_utils::get_revokeable_redeemscript(&local_tx.revocation_key, self.our_to_self_delay, &local_tx.delayed_payment_key),
- to_self_delay: self.our_to_self_delay
- });
- }
- }
- }
+ add_dynamic_output!(htlc_success_tx, 0);
res.push(htlc_success_tx);
}
}
(Vec::new(), Vec::new())
}
- fn block_connected(&self, txn_matched: &[&Transaction], height: u32, broadcaster: &BroadcasterInterface)-> (Vec<(Sha256dHash, Vec<TxOut>)>, Vec<SpendableOutputDescriptor>) {
+ /// Used by ChannelManager deserialization to broadcast the latest local state if it's copy of
+ /// the Channel was out-of-date.
+ pub(super) fn get_latest_local_commitment_txn(&self) -> Vec<Transaction> {
+ if let &Some(ref local_tx) = &self.current_local_signed_commitment_tx {
+ let mut res = vec![local_tx.tx.clone()];
+ match self.key_storage {
+ KeyStorage::PrivMode { ref delayed_payment_base_key, ref prev_latest_per_commitment_point, .. } => {
+ res.append(&mut self.broadcast_by_local_state(local_tx, prev_latest_per_commitment_point, &Some(*delayed_payment_base_key)).0);
+ },
+ _ => panic!("Can only broadcast by local channelmonitor"),
+ };
+ res
+ } else {
+ Vec::new()
+ }
+ }
+
+ fn block_connected(&mut self, txn_matched: &[&Transaction], height: u32, block_hash: &Sha256dHash, broadcaster: &BroadcasterInterface)-> (Vec<(Sha256dHash, Vec<TxOut>)>, Vec<SpendableOutputDescriptor>) {
let mut watch_outputs = Vec::new();
let mut spendable_outputs = Vec::new();
for tx in txn_matched {
txn = remote_txn;
}
} else {
- let remote_commitment_txn_on_chain = self.remote_commitment_txn_on_chain.lock().unwrap();
- if let Some(commitment_number) = remote_commitment_txn_on_chain.get(&prevout.txid) {
- let (tx, spendable_output) = self.check_spend_remote_htlc(tx, *commitment_number);
+ if let Some(&(commitment_number, _)) = self.remote_commitment_txn_on_chain.get(&prevout.txid) {
+ let (tx, spendable_output) = self.check_spend_remote_htlc(tx, commitment_number);
if let Some(tx) = tx {
txn.push(tx);
}
}
}
}
+ self.last_block_hash = block_hash.clone();
(watch_outputs, spendable_outputs)
}
const MAX_ALLOC_SIZE: usize = 64*1024;
-impl<R: ::std::io::Read> ReadableArgs<R, Arc<Logger>> for ChannelMonitor {
+impl<R: ::std::io::Read> ReadableArgs<R, Arc<Logger>> for (Sha256dHash, ChannelMonitor) {
fn read(reader: &mut R, logger: Arc<Logger>) -> Result<Self, DecodeError> {
let secp_ctx = Secp256k1::new();
macro_rules! unwrap_obj {
for _ in 0..remote_commitment_txn_on_chain_len {
let txid: Sha256dHash = Readable::read(reader)?;
let commitment_number = <U48 as Readable<R>>::read(reader)?.0;
- if let Some(_) = remote_commitment_txn_on_chain.insert(txid, commitment_number) {
+ let outputs_count = <u64 as Readable<R>>::read(reader)?;
+ let mut outputs = Vec::with_capacity(cmp::min(outputs_count as usize, MAX_ALLOC_SIZE / 8));
+ for _ in 0..outputs_count {
+ outputs.push(Readable::read(reader)?);
+ }
+ if let Some(_) = remote_commitment_txn_on_chain.insert(txid, (commitment_number, outputs)) {
return Err(DecodeError::InvalidValue);
}
}
macro_rules! read_local_tx {
() => {
{
- let tx = match Transaction::consensus_decode(&mut serialize::RawDecoder::new(reader.by_ref())) {
+ let tx = match Transaction::consensus_decode(reader.by_ref()) {
Ok(tx) => tx,
Err(e) => match e {
- serialize::Error::Io(ioe) => return Err(DecodeError::Io(ioe)),
+ encode::Error::Io(ioe) => return Err(DecodeError::Io(ioe)),
_ => return Err(DecodeError::InvalidValue),
},
};
_ => return Err(DecodeError::InvalidValue),
};
+ let current_remote_commitment_number = <U48 as Readable<R>>::read(reader)?.0;
+
let payment_preimages_len: u64 = Readable::read(reader)?;
let mut payment_preimages = HashMap::with_capacity(cmp::min(payment_preimages_len as usize, MAX_ALLOC_SIZE / 32));
let mut sha = Sha256::new();
}
}
+ let last_block_hash: Sha256dHash = Readable::read(reader)?;
let destination_script = Readable::read(reader)?;
- Ok(ChannelMonitor {
+ Ok((last_block_hash.clone(), ChannelMonitor {
funding_txo,
commitment_transaction_number_obscure_factor,
old_secrets,
remote_claimable_outpoints,
- remote_commitment_txn_on_chain: Mutex::new(remote_commitment_txn_on_chain),
+ remote_commitment_txn_on_chain,
remote_hash_commitment_number,
prev_local_signed_commitment_tx,
current_local_signed_commitment_tx,
+ current_remote_commitment_number,
payment_preimages,
destination_script,
+ last_block_hash,
secp_ctx,
logger,
- })
+ }))
}
}
projects / rust-lightning / blobdiff