payment_preimages: HashMap<PaymentHash, PaymentPreimage>,
destination_script: Script,
+ // Thanks to data loss protection, we may be able to claim our non-htlc funds
+ // back, this is the script we have to spend from but we need to
+ // scan every commitment transaction for that
+ to_remote_rescue: Option<(Script, SecretKey)>,
// Used to track outpoint in the process of being claimed by our transactions. We need to scan all transactions
// for inputs spending this. If height timer (u32) is expired and claim tx hasn't reached enough confirmations
// before, use TxMaterial to regenerate a new claim tx with a satoshis-per-1000-weight-units higher than last
- // one (u64).
- our_claim_txn_waiting_first_conf: HashMap<BitcoinOutPoint, (u32, TxMaterial, u64)>,
+ // one (u64), if timelock expiration (u32) is near, decrease height timer, the in-between bumps delay.
+ // Last field cached (u32) is height of outpoint confirmation, which is needed to flush this tracker
+ // in case of reorgs, given block timer are scaled on timer expiration we can't deduce from it original height.
+ our_claim_txn_waiting_first_conf: HashMap<BitcoinOutPoint, (u32, TxMaterial, u64, u32, u32)>,
// Used to track onchain events, i.e transactions parts of channels confirmed on chain, on which
// we have to take actions once they reach enough confs. Key is a block height timer, i.e we enforce
self.current_local_signed_commitment_tx != other.current_local_signed_commitment_tx ||
self.payment_preimages != other.payment_preimages ||
self.destination_script != other.destination_script ||
+ self.to_remote_rescue != other.to_remote_rescue ||
self.our_claim_txn_waiting_first_conf != other.our_claim_txn_waiting_first_conf ||
self.onchain_events_waiting_threshold_conf != other.onchain_events_waiting_threshold_conf
{
payment_preimages: HashMap::new(),
destination_script: destination_script,
+ to_remote_rescue: None,
our_claim_txn_waiting_first_conf: HashMap::new(),
tx_weight
}
+ fn get_height_timer(current_height: u32, timelock_expiration: u32) -> u32 {
+ if timelock_expiration <= current_height || timelock_expiration - current_height <= 3 {
+ return current_height + 1
+ } else if timelock_expiration - current_height <= 15 {
+ return current_height + 3
+ }
+ current_height + 15
+ }
+
#[inline]
fn place_secret(idx: u64) -> u8 {
for i in 0..48 {
}
}
+ pub(super) fn provide_rescue_remote_commitment_tx_info(&mut self, their_revocation_point: PublicKey) {
+ match self.key_storage {
+ Storage::Local { ref payment_base_key, .. } => {
+ if let Ok(payment_key) = chan_utils::derive_public_key(&self.secp_ctx, &their_revocation_point, &PublicKey::from_secret_key(&self.secp_ctx, &payment_base_key)) {
+ let to_remote_script = Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0)
+ .push_slice(&Hash160::hash(&payment_key.serialize())[..])
+ .into_script();
+ if let Ok(to_remote_key) = chan_utils::derive_private_key(&self.secp_ctx, &their_revocation_point, &payment_base_key) {
+ self.to_remote_rescue = Some((to_remote_script, to_remote_key));
+ }
+ }
+ },
+ Storage::Watchtower { .. } => {}
+ }
+ }
+
/// Informs this monitor of the latest local (ie broadcastable) commitment transaction. The
/// monitor watches for timeouts and may broadcast it if we approach such a timeout. Thus, it
/// is important that any clones of this channel monitor (including remote clones) by kept
self.current_local_signed_commitment_tx = Some(local_tx);
}
self.payment_preimages = other.payment_preimages;
+ self.to_remote_rescue = other.to_remote_rescue;
}
self.current_remote_commitment_number = cmp::min(self.current_remote_commitment_number, other.current_remote_commitment_number);
self.last_block_hash.write(writer)?;
self.destination_script.write(writer)?;
+ if let Some((ref to_remote_script, ref local_key)) = self.to_remote_rescue {
+ writer.write_all(&[1; 1])?;
+ to_remote_script.write(writer)?;
+ local_key.write(writer)?;
+ } else {
+ writer.write_all(&[0; 1])?;
+ }
writer.write_all(&byte_utils::be64_to_array(self.our_claim_txn_waiting_first_conf.len() as u64))?;
for (ref outpoint, claim_tx_data) in self.our_claim_txn_waiting_first_conf.iter() {
}
}
writer.write_all(&byte_utils::be64_to_array(claim_tx_data.2))?;
+ writer.write_all(&byte_utils::be32_to_array(claim_tx_data.3))?;
+ writer.write_all(&byte_utils::be32_to_array(claim_tx_data.4))?;
}
writer.write_all(&byte_utils::be64_to_array(self.onchain_events_waiting_threshold_conf.len() as u64))?;
witness: Vec::new(),
});
inputs_desc.push(InputDescriptors::RevokedOutput);
- inputs_info.push((None, outp.value));
+ inputs_info.push((None, outp.value, self.our_to_self_delay as u32));
total_value += outp.value;
} else if Some(&outp.script_pubkey) == local_payment_p2wpkh.as_ref() {
spendable_outputs.push(SpendableOutputDescriptor::DynamicOutputP2WPKH {
if htlc.cltv_expiry > height + CLTV_SHARED_CLAIM_BUFFER {
inputs.push(input);
inputs_desc.push(if htlc.offered { InputDescriptors::RevokedOfferedHTLC } else { InputDescriptors::RevokedReceivedHTLC });
- inputs_info.push((Some(idx), tx.output[transaction_output_index as usize].value));
+ inputs_info.push((Some(idx), tx.output[transaction_output_index as usize].value, htlc.cltv_expiry));
total_value += tx.output[transaction_output_index as usize].value;
} else {
let mut single_htlc_tx = Transaction {
}),
};
let predicted_weight = single_htlc_tx.get_weight() + Self::get_witnesses_weight(&[if htlc.offered { InputDescriptors::RevokedOfferedHTLC } else { InputDescriptors::RevokedReceivedHTLC }]);
+ let height_timer = Self::get_height_timer(height, htlc.cltv_expiry);
let mut used_feerate;
if subtract_high_prio_fee!(self, fee_estimator, single_htlc_tx.output[0].value, predicted_weight, tx.txid(), used_feerate) {
let sighash_parts = bip143::SighashComponents::new(&single_htlc_tx);
assert!(predicted_weight >= single_htlc_tx.get_weight());
match self.our_claim_txn_waiting_first_conf.entry(single_htlc_tx.input[0].previous_output.clone()) {
hash_map::Entry::Occupied(_) => {},
- hash_map::Entry::Vacant(entry) => { entry.insert((height + 3, TxMaterial::Revoked { script: redeemscript, pubkey: Some(revocation_pubkey), key: revocation_key, is_htlc: true, amount: htlc.amount_msat / 1000 }, used_feerate)); }
+ hash_map::Entry::Vacant(entry) => { entry.insert((height_timer, TxMaterial::Revoked { script: redeemscript, pubkey: Some(revocation_pubkey), key: revocation_key, is_htlc: true, amount: htlc.amount_msat / 1000 }, used_feerate, htlc.cltv_expiry, height)); }
}
txn_to_broadcast.push(single_htlc_tx);
}
for (input, info) in spend_tx.input.iter_mut().zip(inputs_info.iter()) {
let (redeemscript, revocation_key) = sign_input!(sighash_parts, input, info.0, info.1);
+ let height_timer = Self::get_height_timer(height, info.2);
match self.our_claim_txn_waiting_first_conf.entry(input.previous_output.clone()) {
hash_map::Entry::Occupied(_) => {},
- hash_map::Entry::Vacant(entry) => { entry.insert((height + 3, TxMaterial::Revoked { script: redeemscript, pubkey: if info.0.is_some() { Some(revocation_pubkey) } else { None }, key: revocation_key, is_htlc: if info.0.is_some() { true } else { false }, amount: info.1 }, used_feerate)); }
+ hash_map::Entry::Vacant(entry) => { entry.insert((height_timer, TxMaterial::Revoked { script: redeemscript, pubkey: if info.0.is_some() { Some(revocation_pubkey) } else { None }, key: revocation_key, is_htlc: if info.0.is_some() { true } else { false }, amount: info.1 }, used_feerate, if !info.0.is_some() { height + info.2 } else { info.2 }, height)); }
}
}
assert!(predicted_weight >= spend_tx.get_weight());
if htlc.cltv_expiry > height + CLTV_SHARED_CLAIM_BUFFER {
inputs.push(input);
inputs_desc.push(if htlc.offered { InputDescriptors::OfferedHTLC } else { InputDescriptors::ReceivedHTLC });
- inputs_info.push((payment_preimage, tx.output[transaction_output_index as usize].value));
+ inputs_info.push((payment_preimage, tx.output[transaction_output_index as usize].value, htlc.cltv_expiry));
total_value += tx.output[transaction_output_index as usize].value;
} else {
let mut single_htlc_tx = Transaction {
}),
};
let predicted_weight = single_htlc_tx.get_weight() + Self::get_witnesses_weight(&[if htlc.offered { InputDescriptors::OfferedHTLC } else { InputDescriptors::ReceivedHTLC }]);
+ let height_timer = Self::get_height_timer(height, htlc.cltv_expiry);
let mut used_feerate;
if subtract_high_prio_fee!(self, fee_estimator, single_htlc_tx.output[0].value, predicted_weight, tx.txid(), used_feerate) {
let sighash_parts = bip143::SighashComponents::new(&single_htlc_tx);
});
match self.our_claim_txn_waiting_first_conf.entry(single_htlc_tx.input[0].previous_output.clone()) {
hash_map::Entry::Occupied(_) => {},
- hash_map::Entry::Vacant(entry) => { entry.insert((height + 3, TxMaterial::RemoteHTLC { script: redeemscript, key: htlc_key, preimage: Some(*payment_preimage), amount: htlc.amount_msat / 1000 }, used_feerate)); }
+ hash_map::Entry::Vacant(entry) => { entry.insert((height_timer, TxMaterial::RemoteHTLC { script: redeemscript, key: htlc_key, preimage: Some(*payment_preimage), amount: htlc.amount_msat / 1000 }, used_feerate, htlc.cltv_expiry, height)); }
}
txn_to_broadcast.push(single_htlc_tx);
}
}),
};
let predicted_weight = timeout_tx.get_weight() + Self::get_witnesses_weight(&[InputDescriptors::ReceivedHTLC]);
+ let height_timer = Self::get_height_timer(height, htlc.cltv_expiry);
let mut used_feerate;
if subtract_high_prio_fee!(self, fee_estimator, timeout_tx.output[0].value, predicted_weight, tx.txid(), used_feerate) {
let sighash_parts = bip143::SighashComponents::new(&timeout_tx);
//TODO: track SpendableOutputDescriptor
match self.our_claim_txn_waiting_first_conf.entry(timeout_tx.input[0].previous_output.clone()) {
hash_map::Entry::Occupied(_) => {},
- hash_map::Entry::Vacant(entry) => { entry.insert((height + 3, TxMaterial::RemoteHTLC { script : redeemscript, key: htlc_key, preimage: None, amount: htlc.amount_msat / 1000 }, used_feerate)); }
+ hash_map::Entry::Vacant(entry) => { entry.insert((height_timer, TxMaterial::RemoteHTLC { script : redeemscript, key: htlc_key, preimage: None, amount: htlc.amount_msat / 1000 }, used_feerate, htlc.cltv_expiry, height)); }
}
}
txn_to_broadcast.push(timeout_tx);
for (input, info) in spend_tx.input.iter_mut().zip(inputs_info.iter()) {
let (redeemscript, htlc_key) = sign_input!(sighash_parts, input, info.1, (info.0).0.to_vec());
+ let height_timer = Self::get_height_timer(height, info.2);
match self.our_claim_txn_waiting_first_conf.entry(input.previous_output.clone()) {
hash_map::Entry::Occupied(_) => {},
- hash_map::Entry::Vacant(entry) => { entry.insert((height + 3, TxMaterial::RemoteHTLC { script: redeemscript, key: htlc_key, preimage: Some(*(info.0)), amount: info.1}, used_feerate)); }
+ hash_map::Entry::Vacant(entry) => { entry.insert((height_timer, TxMaterial::RemoteHTLC { script: redeemscript, key: htlc_key, preimage: Some(*(info.0)), amount: info.1}, used_feerate, info.2, height)); }
}
}
assert!(predicted_weight >= spend_tx.get_weight());
txn_to_broadcast.push(spend_tx);
}
}
+ } else if let Some((ref to_remote_rescue, ref local_key)) = self.to_remote_rescue {
+ for (idx, outp) in tx.output.iter().enumerate() {
+ if to_remote_rescue == &outp.script_pubkey {
+ spendable_outputs.push(SpendableOutputDescriptor::DynamicOutputP2WPKH {
+ outpoint: BitcoinOutPoint { txid: commitment_txid, vout: idx as u32 },
+ key: local_key.clone(),
+ output: outp.clone(),
+ });
+ }
+ }
}
(txn_to_broadcast, (commitment_txid, watch_outputs), spendable_outputs)
None => return (None, None),
Some(their_delayed_payment_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &their_delayed_payment_base_key)),
};
- let redeemscript = chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.their_to_self_delay.unwrap(), &delayed_key);
+ let redeemscript = chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.our_to_self_delay, &delayed_key);
let revokeable_p2wsh = redeemscript.to_v0_p2wsh();
let htlc_txid = tx.txid(); //TODO: This is gonna be a performance bottleneck for watchtowers!
assert!(predicted_weight >= spend_tx.get_weight());
let outpoint = BitcoinOutPoint { txid: spend_tx.txid(), vout: 0 };
let output = spend_tx.output[0].clone();
+ let height_timer = Self::get_height_timer(height, self.their_to_self_delay.unwrap() as u32); // We can safely unwrap given we are past channel opening
match self.our_claim_txn_waiting_first_conf.entry(spend_tx.input[0].previous_output.clone()) {
hash_map::Entry::Occupied(_) => {},
- hash_map::Entry::Vacant(entry) => { entry.insert((height + 3, TxMaterial::Revoked { script: redeemscript, pubkey: None, key: revocation_key, is_htlc: false, amount: tx.output[0].value }, used_feerate)); }
+ hash_map::Entry::Vacant(entry) => { entry.insert((height_timer, TxMaterial::Revoked { script: redeemscript, pubkey: None, key: revocation_key, is_htlc: false, amount: tx.output[0].value }, used_feerate, height + self.our_to_self_delay as u32, height)); }
}
(Some(spend_tx), Some(SpendableOutputDescriptor::StaticOutput { outpoint, output }))
} else { (None, None) }
}
- fn broadcast_by_local_state(&self, local_tx: &LocalSignedTx, per_commitment_point: &Option<PublicKey>, delayed_payment_base_key: &Option<SecretKey>, height: u32) -> (Vec<Transaction>, Vec<SpendableOutputDescriptor>, Vec<TxOut>, Vec<(BitcoinOutPoint, (u32, TxMaterial, u64))>) {
+ fn broadcast_by_local_state(&self, local_tx: &LocalSignedTx, per_commitment_point: &Option<PublicKey>, delayed_payment_base_key: &Option<SecretKey>, height: u32) -> (Vec<Transaction>, Vec<SpendableOutputDescriptor>, Vec<TxOut>, Vec<(BitcoinOutPoint, (u32, TxMaterial, u64, u32, u32))>) {
let mut res = Vec::with_capacity(local_tx.htlc_outputs.len());
let mut spendable_outputs = Vec::with_capacity(local_tx.htlc_outputs.len());
let mut watch_outputs = Vec::with_capacity(local_tx.htlc_outputs.len());
htlc_timeout_tx.input[0].witness.push(htlc_script.clone().into_bytes());
add_dynamic_output!(htlc_timeout_tx, 0);
- pending_claims.push((htlc_timeout_tx.input[0].previous_output.clone(), (height + 3, TxMaterial::LocalHTLC { script: htlc_script, sigs: (*their_sig, *our_sig), preimage: None, amount: htlc.amount_msat / 1000}, 0)));
+ let height_timer = Self::get_height_timer(height, htlc.cltv_expiry);
+ pending_claims.push((htlc_timeout_tx.input[0].previous_output.clone(), (height_timer, TxMaterial::LocalHTLC { script: htlc_script, sigs: (*their_sig, *our_sig), preimage: None, amount: htlc.amount_msat / 1000}, 0, htlc.cltv_expiry, height)));
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(htlc_script.clone().into_bytes());
add_dynamic_output!(htlc_success_tx, 0);
- pending_claims.push((htlc_success_tx.input[0].previous_output.clone(), (height + 3, TxMaterial::LocalHTLC { script: htlc_script, sigs: (*their_sig, *our_sig), preimage: Some(*payment_preimage), amount: htlc.amount_msat / 1000}, 0)));
+ let height_timer = Self::get_height_timer(height, htlc.cltv_expiry);
+ pending_claims.push((htlc_success_tx.input[0].previous_output.clone(), (height_timer, TxMaterial::LocalHTLC { script: htlc_script, sigs: (*their_sig, *our_sig), preimage: Some(*payment_preimage), amount: htlc.amount_msat / 1000}, 0, htlc.cltv_expiry, height)));
res.push(htlc_success_tx);
}
}
None
}
- /// 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> {
+ /// Used by ChannelManager deserialization to broadcast the latest local state if its copy of
+ /// the Channel was out-of-date. You may use it to get a broadcastable local toxic tx in case of
+ /// fallen-behind, i.e when receiving a channel_reestablish with a proof that our remote side knows
+ /// a higher revocation secret than the local commitment number we are aware of. Broadcasting these
+ /// transactions are UNSAFE, as they allow remote side to punish you. Nevertheless you may want to
+ /// broadcast them if remote 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_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 {
}
};
if funding_txo.is_none() || (prevout.txid == funding_txo.as_ref().unwrap().0.txid && prevout.vout == funding_txo.as_ref().unwrap().0.index as u32) {
- let (remote_txn, new_outputs, mut spendable_output) = self.check_spend_remote_transaction(tx, height, fee_estimator);
- txn = remote_txn;
- spendable_outputs.append(&mut spendable_output);
- if !new_outputs.1.is_empty() {
- watch_outputs.push(new_outputs);
- }
- if txn.is_empty() {
- let (local_txn, mut spendable_output, new_outputs) = self.check_spend_local_transaction(tx, height);
+ if (tx.input[0].sequence >> 8*3) as u8 == 0x80 && (tx.lock_time >> 8*3) as u8 == 0x20 {
+ let (remote_txn, new_outputs, mut spendable_output) = self.check_spend_remote_transaction(tx, height, fee_estimator);
+ txn = remote_txn;
spendable_outputs.append(&mut spendable_output);
- txn = local_txn;
if !new_outputs.1.is_empty() {
watch_outputs.push(new_outputs);
}
+ if txn.is_empty() {
+ let (local_txn, mut spendable_output, new_outputs) = self.check_spend_local_transaction(tx, height);
+ spendable_outputs.append(&mut spendable_output);
+ txn = local_txn;
+ if !new_outputs.1.is_empty() {
+ watch_outputs.push(new_outputs);
+ }
+ }
}
if !funding_txo.is_none() && txn.is_empty() {
if let Some(spendable_output) = self.check_spend_closing_transaction(tx) {
//- htlc update there as failure-trigger tx (revoked commitment tx, non-revoked commitment tx, HTLC-timeout tx) has been disconnected
//- our claim tx on a commitment tx output
}
- self.our_claim_txn_waiting_first_conf.retain(|_, ref mut v| if v.0 == height + 3 { false } else { true });
+ self.our_claim_txn_waiting_first_conf.retain(|_, ref mut v| if v.3 == height { false } else { true });
self.last_block_hash = block_hash.clone();
}
let last_block_hash: Sha256dHash = Readable::read(reader)?;
let destination_script = Readable::read(reader)?;
+ let to_remote_rescue = match <u8 as Readable<R>>::read(reader)? {
+ 0 => None,
+ 1 => {
+ let to_remote_script = Readable::read(reader)?;
+ let local_key = Readable::read(reader)?;
+ Some((to_remote_script, local_key))
+ }
+ _ => return Err(DecodeError::InvalidValue),
+ };
let our_claim_txn_waiting_first_conf_len: u64 = Readable::read(reader)?;
let mut our_claim_txn_waiting_first_conf = HashMap::with_capacity(cmp::min(our_claim_txn_waiting_first_conf_len as usize, MAX_ALLOC_SIZE / 128));
_ => return Err(DecodeError::InvalidValue),
};
let last_fee = Readable::read(reader)?;
- our_claim_txn_waiting_first_conf.insert(outpoint, (height_target, tx_material, last_fee));
+ let timelock_expiration = Readable::read(reader)?;
+ let height = Readable::read(reader)?;
+ our_claim_txn_waiting_first_conf.insert(outpoint, (height_target, tx_material, last_fee, timelock_expiration, height));
}
let waiting_threshold_conf_len: u64 = Readable::read(reader)?;
payment_preimages,
destination_script,
+ to_remote_rescue,
our_claim_txn_waiting_first_conf,
projects / rust-lightning / blobdiff