mirror of
https://github.com/lightningdevkit/rust-lightning.git
synced 2025-02-25 07:17:40 +01:00
Merge pull request #686 from TheBlueMatt/2020-09-bump-deps
Bump rust-bitcoin and friends
This commit is contained in:
Matt Corallo
GitHub
commit
2dd8b3e896
20 changed files with 185 additions and 182 deletions
|
|
@ -19,7 +19,7 @@ stdin_fuzz = []
|
|||
[dependencies]
|
||||
afl = { version = "0.4", optional = true }
|
||||
lightning = { path = "../lightning", features = ["fuzztarget"] }
|
||||
bitcoin = { version = "0.23", features = ["fuzztarget"] }
|
||||
bitcoin = { version = "0.24", features = ["fuzztarget"] }
|
||||
hex = "0.3"
|
||||
honggfuzz = { version = "0.5", optional = true }
|
||||
libfuzzer-sys = { git = "https://github.com/rust-fuzz/libfuzzer-sys.git", optional = true }
|
||||
|
|
|
|||
|
|
@ -18,7 +18,6 @@
|
|||
//! send-side handling is correct, other peers. We consider it a failure if any action results in a
|
||||
//! channel being force-closed.
|
||||
|
||||
use bitcoin::BitcoinHash;
|
||||
use bitcoin::blockdata::block::BlockHeader;
|
||||
use bitcoin::blockdata::transaction::{Transaction, TxOut};
|
||||
use bitcoin::blockdata::script::{Builder, Script};
|
||||
|
|
@ -317,7 +316,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
|
|||
}
|
||||
$node.block_connected(&header, 1, &txn, &posn);
|
||||
for i in 2..100 {
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
$node.block_connected(&header, i, &Vec::new(), &[0; 0]);
|
||||
}
|
||||
} }
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ use bitcoin::blockdata::script::{Builder, Script};
|
|||
use bitcoin::blockdata::opcodes;
|
||||
use bitcoin::consensus::encode::deserialize;
|
||||
use bitcoin::network::constants::Network;
|
||||
use bitcoin::util::hash::BitcoinHash;
|
||||
|
||||
use bitcoin::hashes::Hash as TraitImport;
|
||||
use bitcoin::hashes::HashEngine as TraitImportEngine;
|
||||
|
|
@ -204,10 +203,10 @@ impl<'a> MoneyLossDetector<'a> {
|
|||
self.manager.block_connected(&header, self.height as u32, &txn[..], &txn_idxs[..]);
|
||||
(*self.monitor).block_connected(&header, self.height as u32, &txn[..], &txn_idxs[..]);
|
||||
if self.header_hashes.len() > self.height {
|
||||
self.header_hashes[self.height] = header.bitcoin_hash();
|
||||
self.header_hashes[self.height] = header.block_hash();
|
||||
} else {
|
||||
assert_eq!(self.header_hashes.len(), self.height);
|
||||
self.header_hashes.push(header.bitcoin_hash());
|
||||
self.header_hashes.push(header.block_hash());
|
||||
}
|
||||
self.max_height = cmp::max(self.height, self.max_height);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ For Rust-Lightning clients which wish to make direct connections to Lightning P2
|
|||
"""
|
||||
|
||||
[dependencies]
|
||||
bitcoin = "0.23"
|
||||
bitcoin = "0.24"
|
||||
lightning = { version = "0.0.11", path = "../lightning" }
|
||||
tokio = { version = ">=0.2.12", features = [ "io-util", "macros", "rt-core", "sync", "tcp", "time" ] }
|
||||
|
||||
|
|
|
|||
|
|
@ -23,10 +23,10 @@ max_level_debug = []
|
|||
unsafe_revoked_tx_signing = []
|
||||
|
||||
[dependencies]
|
||||
bitcoin = "0.23"
|
||||
bitcoin = "0.24"
|
||||
|
||||
[dev-dependencies.bitcoin]
|
||||
version = "0.23"
|
||||
version = "0.24"
|
||||
features = ["bitcoinconsensus"]
|
||||
|
||||
[dev-dependencies]
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@ use bitcoin::blockdata::block::{Block, BlockHeader};
|
|||
use bitcoin::blockdata::transaction::Transaction;
|
||||
use bitcoin::blockdata::script::Script;
|
||||
use bitcoin::blockdata::constants::genesis_block;
|
||||
use bitcoin::util::hash::BitcoinHash;
|
||||
use bitcoin::network::constants::Network;
|
||||
use bitcoin::hash_types::{Txid, BlockHash};
|
||||
|
||||
|
|
@ -366,7 +365,7 @@ impl ChainWatchInterface for ChainWatchInterfaceUtil {
|
|||
}
|
||||
|
||||
fn get_chain_utxo(&self, genesis_hash: BlockHash, _unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError> {
|
||||
if genesis_hash != genesis_block(self.network).header.bitcoin_hash() {
|
||||
if genesis_hash != genesis_block(self.network).header.block_hash() {
|
||||
return Err(ChainError::NotWatched);
|
||||
}
|
||||
Err(ChainError::NotSupported)
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
//! spendable on-chain outputs which the user owns and is responsible for using just as any other
|
||||
//! on-chain output which is theirs.
|
||||
|
||||
use bitcoin::blockdata::transaction::{Transaction, TxOut};
|
||||
use bitcoin::blockdata::transaction::{Transaction, TxOut, SigHashType};
|
||||
use bitcoin::blockdata::script::{Script, Builder};
|
||||
use bitcoin::blockdata::opcodes;
|
||||
use bitcoin::network::constants::Network;
|
||||
|
|
@ -477,7 +477,7 @@ impl ChannelKeys for InMemoryChannelKeys {
|
|||
let accepted_data = self.accepted_channel_data.as_ref().expect("must accept before signing");
|
||||
let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &accepted_data.remote_channel_pubkeys.funding_pubkey);
|
||||
|
||||
let commitment_sighash = hash_to_message!(&bip143::SighashComponents::new(&commitment_tx).sighash_all(&commitment_tx.input[0], &channel_funding_redeemscript, self.channel_value_satoshis)[..]);
|
||||
let commitment_sighash = hash_to_message!(&bip143::SigHashCache::new(commitment_tx).signature_hash(0, &channel_funding_redeemscript, self.channel_value_satoshis, SigHashType::All)[..]);
|
||||
let commitment_sig = secp_ctx.sign(&commitment_sighash, &self.funding_key);
|
||||
|
||||
let commitment_txid = commitment_tx.txid();
|
||||
|
|
@ -487,7 +487,7 @@ impl ChannelKeys for InMemoryChannelKeys {
|
|||
if let Some(_) = htlc.transaction_output_index {
|
||||
let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, feerate_per_kw, accepted_data.local_to_self_delay, htlc, &keys.a_delayed_payment_key, &keys.revocation_key);
|
||||
let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &keys);
|
||||
let htlc_sighash = hash_to_message!(&bip143::SighashComponents::new(&htlc_tx).sighash_all(&htlc_tx.input[0], &htlc_redeemscript, htlc.amount_msat / 1000)[..]);
|
||||
let htlc_sighash = hash_to_message!(&bip143::SigHashCache::new(&htlc_tx).signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, SigHashType::All)[..]);
|
||||
let our_htlc_key = match chan_utils::derive_private_key(&secp_ctx, &keys.per_commitment_point, &self.htlc_base_key) {
|
||||
Ok(s) => s,
|
||||
Err(_) => return Err(()),
|
||||
|
|
@ -548,8 +548,8 @@ impl ChannelKeys for InMemoryChannelKeys {
|
|||
};
|
||||
chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.local_to_self_delay(), &remote_delayedpubkey)
|
||||
};
|
||||
let sighash_parts = bip143::SighashComponents::new(&justice_tx);
|
||||
let sighash = hash_to_message!(&sighash_parts.sighash_all(&justice_tx.input[input], &witness_script, amount)[..]);
|
||||
let mut sighash_parts = bip143::SigHashCache::new(justice_tx);
|
||||
let sighash = hash_to_message!(&sighash_parts.signature_hash(input, &witness_script, amount, SigHashType::All)[..]);
|
||||
return Ok(secp_ctx.sign(&sighash, &revocation_key))
|
||||
}
|
||||
|
||||
|
|
@ -562,8 +562,8 @@ impl ChannelKeys for InMemoryChannelKeys {
|
|||
} else { return Err(()) }
|
||||
} else { return Err(()) }
|
||||
} else { return Err(()) };
|
||||
let sighash_parts = bip143::SighashComponents::new(&htlc_tx);
|
||||
let sighash = hash_to_message!(&sighash_parts.sighash_all(&htlc_tx.input[input], &witness_script, amount)[..]);
|
||||
let mut sighash_parts = bip143::SigHashCache::new(htlc_tx);
|
||||
let sighash = hash_to_message!(&sighash_parts.signature_hash(input, &witness_script, amount, SigHashType::All)[..]);
|
||||
return Ok(secp_ctx.sign(&sighash, &htlc_key))
|
||||
}
|
||||
Err(())
|
||||
|
|
@ -578,8 +578,8 @@ impl ChannelKeys for InMemoryChannelKeys {
|
|||
let remote_channel_data = self.accepted_channel_data.as_ref().expect("must accept before signing");
|
||||
let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_data.remote_channel_pubkeys.funding_pubkey);
|
||||
|
||||
let sighash = hash_to_message!(&bip143::SighashComponents::new(closing_tx)
|
||||
.sighash_all(&closing_tx.input[0], &channel_funding_redeemscript, self.channel_value_satoshis)[..]);
|
||||
let sighash = hash_to_message!(&bip143::SigHashCache::new(closing_tx)
|
||||
.signature_hash(0, &channel_funding_redeemscript, self.channel_value_satoshis, SigHashType::All)[..]);
|
||||
Ok(secp_ctx.sign(&sighash, &self.funding_key))
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -651,8 +651,8 @@ impl LocalCommitmentTransaction {
|
|||
/// ChannelKeys::sign_local_commitment() calls directly.
|
||||
/// Channel value is amount locked in funding_outpoint.
|
||||
pub fn get_local_sig<T: secp256k1::Signing>(&self, funding_key: &SecretKey, funding_redeemscript: &Script, channel_value_satoshis: u64, secp_ctx: &Secp256k1<T>) -> Signature {
|
||||
let sighash = hash_to_message!(&bip143::SighashComponents::new(&self.unsigned_tx)
|
||||
.sighash_all(&self.unsigned_tx.input[0], funding_redeemscript, channel_value_satoshis)[..]);
|
||||
let sighash = hash_to_message!(&bip143::SigHashCache::new(&self.unsigned_tx)
|
||||
.signature_hash(0, funding_redeemscript, channel_value_satoshis, SigHashType::All)[..]);
|
||||
secp_ctx.sign(&sighash, funding_key)
|
||||
}
|
||||
|
||||
|
|
@ -692,7 +692,7 @@ impl LocalCommitmentTransaction {
|
|||
|
||||
let htlc_redeemscript = get_htlc_redeemscript_with_explicit_keys(&this_htlc.0, &self.local_keys.a_htlc_key, &self.local_keys.b_htlc_key, &self.local_keys.revocation_key);
|
||||
|
||||
let sighash = hash_to_message!(&bip143::SighashComponents::new(&htlc_tx).sighash_all(&htlc_tx.input[0], &htlc_redeemscript, this_htlc.0.amount_msat / 1000)[..]);
|
||||
let sighash = hash_to_message!(&bip143::SigHashCache::new(&htlc_tx).signature_hash(0, &htlc_redeemscript, this_htlc.0.amount_msat / 1000, SigHashType::All)[..]);
|
||||
ret.push(Some(secp_ctx.sign(&sighash, &our_htlc_key)));
|
||||
} else {
|
||||
ret.push(None);
|
||||
|
|
|
|||
|
|
@ -11,7 +11,6 @@ use bitcoin::blockdata::block::BlockHeader;
|
|||
use bitcoin::blockdata::script::{Script,Builder};
|
||||
use bitcoin::blockdata::transaction::{TxIn, TxOut, Transaction, SigHashType};
|
||||
use bitcoin::blockdata::opcodes;
|
||||
use bitcoin::util::hash::BitcoinHash;
|
||||
use bitcoin::util::bip143;
|
||||
use bitcoin::consensus::encode;
|
||||
|
||||
|
|
@ -1477,7 +1476,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
|
||||
let local_keys = self.build_local_transaction_keys(self.cur_local_commitment_transaction_number)?;
|
||||
let local_initial_commitment_tx = self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false, self.feerate_per_kw, logger).0;
|
||||
let local_sighash = hash_to_message!(&bip143::SighashComponents::new(&local_initial_commitment_tx).sighash_all(&local_initial_commitment_tx.input[0], &funding_script, self.channel_value_satoshis)[..]);
|
||||
let local_sighash = hash_to_message!(&bip143::SigHashCache::new(&local_initial_commitment_tx).signature_hash(0, &funding_script, self.channel_value_satoshis, SigHashType::All)[..]);
|
||||
|
||||
// They sign the "local" commitment transaction...
|
||||
log_trace!(logger, "Checking funding_created tx signature {} by key {} against tx {} (sighash {}) with redeemscript {}", log_bytes!(sig.serialize_compact()[..]), log_bytes!(self.their_funding_pubkey().serialize()), encode::serialize_hex(&local_initial_commitment_tx), log_bytes!(local_sighash[..]), encode::serialize_hex(&funding_script));
|
||||
|
|
@ -1581,7 +1580,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
|
||||
let local_keys = self.build_local_transaction_keys(self.cur_local_commitment_transaction_number)?;
|
||||
let local_initial_commitment_tx = self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false, self.feerate_per_kw, logger).0;
|
||||
let local_sighash = hash_to_message!(&bip143::SighashComponents::new(&local_initial_commitment_tx).sighash_all(&local_initial_commitment_tx.input[0], &funding_script, self.channel_value_satoshis)[..]);
|
||||
let local_sighash = hash_to_message!(&bip143::SigHashCache::new(&local_initial_commitment_tx).signature_hash(0, &funding_script, self.channel_value_satoshis, SigHashType::All)[..]);
|
||||
|
||||
let their_funding_pubkey = &self.their_pubkeys.as_ref().unwrap().funding_pubkey;
|
||||
|
||||
|
|
@ -1982,7 +1981,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
(commitment_tx.0, commitment_tx.1, htlcs_cloned)
|
||||
};
|
||||
let local_commitment_txid = local_commitment_tx.0.txid();
|
||||
let local_sighash = hash_to_message!(&bip143::SighashComponents::new(&local_commitment_tx.0).sighash_all(&local_commitment_tx.0.input[0], &funding_script, self.channel_value_satoshis)[..]);
|
||||
let local_sighash = hash_to_message!(&bip143::SigHashCache::new(&local_commitment_tx.0).signature_hash(0, &funding_script, self.channel_value_satoshis, SigHashType::All)[..]);
|
||||
log_trace!(logger, "Checking commitment tx signature {} by key {} against tx {} (sighash {}) with redeemscript {}", log_bytes!(msg.signature.serialize_compact()[..]), log_bytes!(self.their_funding_pubkey().serialize()), encode::serialize_hex(&local_commitment_tx.0), log_bytes!(local_sighash[..]), encode::serialize_hex(&funding_script));
|
||||
if let Err(_) = self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey()) {
|
||||
return Err((None, ChannelError::Close("Invalid commitment tx signature from peer".to_owned())));
|
||||
|
|
@ -2011,7 +2010,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
if let Some(_) = htlc.transaction_output_index {
|
||||
let htlc_tx = self.build_htlc_transaction(&local_commitment_txid, &htlc, true, &local_keys, feerate_per_kw);
|
||||
let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &local_keys);
|
||||
let htlc_sighash = hash_to_message!(&bip143::SighashComponents::new(&htlc_tx).sighash_all(&htlc_tx.input[0], &htlc_redeemscript, htlc.amount_msat / 1000)[..]);
|
||||
let htlc_sighash = hash_to_message!(&bip143::SigHashCache::new(&htlc_tx).signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, SigHashType::All)[..]);
|
||||
log_trace!(logger, "Checking HTLC tx signature {} by key {} against tx {} (sighash {}) with redeemscript {}", log_bytes!(msg.htlc_signatures[idx].serialize_compact()[..]), log_bytes!(local_keys.b_htlc_key.serialize()), encode::serialize_hex(&htlc_tx), log_bytes!(htlc_sighash[..]), encode::serialize_hex(&htlc_redeemscript));
|
||||
if let Err(_) = self.secp_ctx.verify(&htlc_sighash, &msg.htlc_signatures[idx], &local_keys.b_htlc_key) {
|
||||
return Err((None, ChannelError::Close("Invalid HTLC tx signature from peer".to_owned())));
|
||||
|
|
@ -3015,7 +3014,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
if used_total_fee != msg.fee_satoshis {
|
||||
return Err(ChannelError::Close(format!("Remote sent us a closing_signed with a fee greater than the value they can claim. Fee in message: {}", msg.fee_satoshis)));
|
||||
}
|
||||
let mut sighash = hash_to_message!(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]);
|
||||
let mut sighash = hash_to_message!(&bip143::SigHashCache::new(&closing_tx).signature_hash(0, &funding_redeemscript, self.channel_value_satoshis, SigHashType::All)[..]);
|
||||
|
||||
let their_funding_pubkey = &self.their_pubkeys.as_ref().unwrap().funding_pubkey;
|
||||
|
||||
|
|
@ -3025,7 +3024,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
// The remote end may have decided to revoke their output due to inconsistent dust
|
||||
// limits, so check for that case by re-checking the signature here.
|
||||
closing_tx = self.build_closing_transaction(msg.fee_satoshis, true).0;
|
||||
sighash = hash_to_message!(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]);
|
||||
sighash = hash_to_message!(&bip143::SigHashCache::new(&closing_tx).signature_hash(0, &funding_redeemscript, self.channel_value_satoshis, SigHashType::All)[..]);
|
||||
secp_check!(self.secp_ctx.verify(&sighash, &msg.signature, self.their_funding_pubkey()), "Invalid closing tx signature from peer".to_owned());
|
||||
},
|
||||
};
|
||||
|
|
@ -3327,7 +3326,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
}
|
||||
});
|
||||
let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
|
||||
if header.bitcoin_hash() != self.last_block_connected {
|
||||
if header.block_hash() != self.last_block_connected {
|
||||
if self.funding_tx_confirmations > 0 {
|
||||
self.funding_tx_confirmations += 1;
|
||||
}
|
||||
|
|
@ -3376,8 +3375,8 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
}
|
||||
}
|
||||
}
|
||||
if header.bitcoin_hash() != self.last_block_connected {
|
||||
self.last_block_connected = header.bitcoin_hash();
|
||||
if header.block_hash() != self.last_block_connected {
|
||||
self.last_block_connected = header.block_hash();
|
||||
self.update_time_counter = cmp::max(self.update_time_counter, header.time);
|
||||
if self.funding_tx_confirmations > 0 {
|
||||
if self.funding_tx_confirmations == self.minimum_depth as u64 {
|
||||
|
|
@ -3399,7 +3398,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
// funding_tx_confirmed_in and return.
|
||||
false
|
||||
};
|
||||
self.funding_tx_confirmed_in = Some(header.bitcoin_hash());
|
||||
self.funding_tx_confirmed_in = Some(self.last_block_connected);
|
||||
|
||||
//TODO: Note that this must be a duplicate of the previous commitment point they sent us,
|
||||
//as otherwise we will have a commitment transaction that they can't revoke (well, kinda,
|
||||
|
|
@ -3433,10 +3432,10 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
return true;
|
||||
}
|
||||
}
|
||||
if Some(header.bitcoin_hash()) == self.funding_tx_confirmed_in {
|
||||
self.last_block_connected = header.block_hash();
|
||||
if Some(self.last_block_connected) == self.funding_tx_confirmed_in {
|
||||
self.funding_tx_confirmations = self.minimum_depth as u64 - 1;
|
||||
}
|
||||
self.last_block_connected = header.bitcoin_hash();
|
||||
false
|
||||
}
|
||||
|
||||
|
|
@ -4451,11 +4450,10 @@ impl<ChanSigner: ChannelKeys + Readable> Readable for Channel<ChanSigner> {
|
|||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use bitcoin::BitcoinHash;
|
||||
use bitcoin::util::bip143;
|
||||
use bitcoin::consensus::encode::serialize;
|
||||
use bitcoin::blockdata::script::{Script, Builder};
|
||||
use bitcoin::blockdata::transaction::{Transaction, TxOut};
|
||||
use bitcoin::blockdata::transaction::{Transaction, TxOut, SigHashType};
|
||||
use bitcoin::blockdata::constants::genesis_block;
|
||||
use bitcoin::blockdata::opcodes;
|
||||
use bitcoin::network::constants::Network;
|
||||
|
|
@ -4545,7 +4543,7 @@ mod tests {
|
|||
// Now change the fee so we can check that the fee in the open_channel message is the
|
||||
// same as the old fee.
|
||||
fee_est.fee_est = 500;
|
||||
let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.bitcoin_hash());
|
||||
let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.block_hash());
|
||||
assert_eq!(open_channel_msg.feerate_per_kw, original_fee);
|
||||
}
|
||||
|
||||
|
|
@ -4566,7 +4564,7 @@ mod tests {
|
|||
let mut node_a_chan = Channel::<EnforcingChannelKeys>::new_outbound(&&feeest, &&keys_provider, node_a_node_id, 10000000, 100000, 42, &config).unwrap();
|
||||
|
||||
// Create Node B's channel by receiving Node A's open_channel message
|
||||
let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.bitcoin_hash());
|
||||
let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.block_hash());
|
||||
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
|
||||
let mut node_b_chan = Channel::<EnforcingChannelKeys>::new_from_req(&&feeest, &&keys_provider, node_b_node_id, InitFeatures::known(), &open_channel_msg, 7, &config).unwrap();
|
||||
|
||||
|
|
@ -4693,7 +4691,7 @@ mod tests {
|
|||
};
|
||||
let redeemscript = chan.get_funding_redeemscript();
|
||||
let their_signature = Signature::from_der(&hex::decode($their_sig_hex).unwrap()[..]).unwrap();
|
||||
let sighash = Message::from_slice(&bip143::SighashComponents::new(&unsigned_tx.0).sighash_all(&unsigned_tx.0.input[0], &redeemscript, chan.channel_value_satoshis)[..]).unwrap();
|
||||
let sighash = Message::from_slice(&bip143::SigHashCache::new(&unsigned_tx.0).signature_hash(0, &redeemscript, chan.channel_value_satoshis, SigHashType::All)[..]).unwrap();
|
||||
secp_ctx.verify(&sighash, &their_signature, chan.their_funding_pubkey()).unwrap();
|
||||
|
||||
let mut per_htlc = Vec::new();
|
||||
|
|
@ -4720,7 +4718,7 @@ mod tests {
|
|||
let ref htlc = unsigned_tx.1[$htlc_idx];
|
||||
let htlc_tx = chan.build_htlc_transaction(&unsigned_tx.0.txid(), &htlc, true, &keys, chan.feerate_per_kw);
|
||||
let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &keys);
|
||||
let htlc_sighash = Message::from_slice(&bip143::SighashComponents::new(&htlc_tx).sighash_all(&htlc_tx.input[0], &htlc_redeemscript, htlc.amount_msat / 1000)[..]).unwrap();
|
||||
let htlc_sighash = Message::from_slice(&bip143::SigHashCache::new(&htlc_tx).signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, SigHashType::All)[..]).unwrap();
|
||||
secp_ctx.verify(&htlc_sighash, &remote_signature, &keys.b_htlc_key).unwrap();
|
||||
|
||||
let mut preimage: Option<PaymentPreimage> = None;
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@ use bitcoin::blockdata::block::BlockHeader;
|
|||
use bitcoin::blockdata::transaction::Transaction;
|
||||
use bitcoin::blockdata::constants::genesis_block;
|
||||
use bitcoin::network::constants::Network;
|
||||
use bitcoin::util::hash::BitcoinHash;
|
||||
|
||||
use bitcoin::hashes::{Hash, HashEngine};
|
||||
use bitcoin::hashes::hmac::{Hmac, HmacEngine};
|
||||
|
|
@ -724,7 +723,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
|
|||
|
||||
ChannelManager {
|
||||
default_configuration: config.clone(),
|
||||
genesis_hash: genesis_block(network).header.bitcoin_hash(),
|
||||
genesis_hash: genesis_block(network).header.block_hash(),
|
||||
fee_estimator: fee_est,
|
||||
monitor,
|
||||
tx_broadcaster,
|
||||
|
|
@ -3060,7 +3059,7 @@ impl<ChanSigner: ChannelKeys, M: Deref + Sync + Send, T: Deref + Sync + Send, K:
|
|||
L::Target: Logger,
|
||||
{
|
||||
fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[usize]) {
|
||||
let header_hash = header.bitcoin_hash();
|
||||
let header_hash = header.block_hash();
|
||||
log_trace!(self.logger, "Block {} at height {} connected with {} txn matched", header_hash, height, txn_matched.len());
|
||||
let _ = self.total_consistency_lock.read().unwrap();
|
||||
let mut failed_channels = Vec::new();
|
||||
|
|
@ -3200,7 +3199,7 @@ impl<ChanSigner: ChannelKeys, M: Deref + Sync + Send, T: Deref + Sync + Send, K:
|
|||
self.finish_force_close_channel(failure);
|
||||
}
|
||||
self.latest_block_height.fetch_sub(1, Ordering::AcqRel);
|
||||
*self.last_block_hash.try_lock().expect("block_(dis)connected must not be called in parallel") = header.bitcoin_hash();
|
||||
*self.last_block_hash.try_lock().expect("block_(dis)connected must not be called in parallel") = header.block_hash();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@ use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint;
|
|||
use bitcoin::blockdata::script::{Script, Builder};
|
||||
use bitcoin::blockdata::opcodes;
|
||||
use bitcoin::consensus::encode;
|
||||
use bitcoin::util::hash::BitcoinHash;
|
||||
|
||||
use bitcoin::hashes::Hash;
|
||||
use bitcoin::hashes::sha256::Hash as Sha256;
|
||||
|
|
@ -203,7 +202,7 @@ impl<Key : Send + cmp::Eq + hash::Hash, ChanSigner: ChannelKeys, T: Deref + Sync
|
|||
C::Target: ChainWatchInterface,
|
||||
{
|
||||
fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], _indexes_of_txn_matched: &[usize]) {
|
||||
let block_hash = header.bitcoin_hash();
|
||||
let block_hash = header.block_hash();
|
||||
{
|
||||
let mut monitors = self.monitors.lock().unwrap();
|
||||
for monitor in monitors.values_mut() {
|
||||
|
|
@ -219,7 +218,7 @@ impl<Key : Send + cmp::Eq + hash::Hash, ChanSigner: ChannelKeys, T: Deref + Sync
|
|||
}
|
||||
|
||||
fn block_disconnected(&self, header: &BlockHeader, disconnected_height: u32) {
|
||||
let block_hash = header.bitcoin_hash();
|
||||
let block_hash = header.block_hash();
|
||||
let mut monitors = self.monitors.lock().unwrap();
|
||||
for monitor in monitors.values_mut() {
|
||||
monitor.block_disconnected(disconnected_height, &block_hash, &*self.broadcaster, &*self.fee_estimator, &*self.logger);
|
||||
|
|
@ -2706,33 +2705,33 @@ mod tests {
|
|||
let mut sum_actual_sigs = 0;
|
||||
|
||||
macro_rules! sign_input {
|
||||
($sighash_parts: expr, $input: expr, $idx: expr, $amount: expr, $input_type: expr, $sum_actual_sigs: expr) => {
|
||||
($sighash_parts: expr, $idx: expr, $amount: expr, $input_type: expr, $sum_actual_sigs: expr) => {
|
||||
let htlc = HTLCOutputInCommitment {
|
||||
offered: if *$input_type == InputDescriptors::RevokedOfferedHTLC || *$input_type == InputDescriptors::OfferedHTLC { true } else { false },
|
||||
amount_msat: 0,
|
||||
cltv_expiry: 2 << 16,
|
||||
payment_hash: PaymentHash([1; 32]),
|
||||
transaction_output_index: Some($idx),
|
||||
transaction_output_index: Some($idx as u32),
|
||||
};
|
||||
let redeem_script = if *$input_type == InputDescriptors::RevokedOutput { chan_utils::get_revokeable_redeemscript(&pubkey, 256, &pubkey) } else { chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, &pubkey, &pubkey, &pubkey) };
|
||||
let sighash = hash_to_message!(&$sighash_parts.sighash_all(&$input, &redeem_script, $amount)[..]);
|
||||
let sighash = hash_to_message!(&$sighash_parts.signature_hash($idx, &redeem_script, $amount, SigHashType::All)[..]);
|
||||
let sig = secp_ctx.sign(&sighash, &privkey);
|
||||
$input.witness.push(sig.serialize_der().to_vec());
|
||||
$input.witness[0].push(SigHashType::All as u8);
|
||||
sum_actual_sigs += $input.witness[0].len();
|
||||
$sighash_parts.access_witness($idx).push(sig.serialize_der().to_vec());
|
||||
$sighash_parts.access_witness($idx)[0].push(SigHashType::All as u8);
|
||||
sum_actual_sigs += $sighash_parts.access_witness($idx)[0].len();
|
||||
if *$input_type == InputDescriptors::RevokedOutput {
|
||||
$input.witness.push(vec!(1));
|
||||
$sighash_parts.access_witness($idx).push(vec!(1));
|
||||
} else if *$input_type == InputDescriptors::RevokedOfferedHTLC || *$input_type == InputDescriptors::RevokedReceivedHTLC {
|
||||
$input.witness.push(pubkey.clone().serialize().to_vec());
|
||||
$sighash_parts.access_witness($idx).push(pubkey.clone().serialize().to_vec());
|
||||
} else if *$input_type == InputDescriptors::ReceivedHTLC {
|
||||
$input.witness.push(vec![0]);
|
||||
$sighash_parts.access_witness($idx).push(vec![0]);
|
||||
} else {
|
||||
$input.witness.push(PaymentPreimage([1; 32]).0.to_vec());
|
||||
$sighash_parts.access_witness($idx).push(PaymentPreimage([1; 32]).0.to_vec());
|
||||
}
|
||||
$input.witness.push(redeem_script.into_bytes());
|
||||
println!("witness[0] {}", $input.witness[0].len());
|
||||
println!("witness[1] {}", $input.witness[1].len());
|
||||
println!("witness[2] {}", $input.witness[2].len());
|
||||
$sighash_parts.access_witness($idx).push(redeem_script.into_bytes());
|
||||
println!("witness[0] {}", $sighash_parts.access_witness($idx)[0].len());
|
||||
println!("witness[1] {}", $sighash_parts.access_witness($idx)[1].len());
|
||||
println!("witness[2] {}", $sighash_parts.access_witness($idx)[2].len());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2757,10 +2756,12 @@ mod tests {
|
|||
value: 0,
|
||||
});
|
||||
let base_weight = claim_tx.get_weight();
|
||||
let sighash_parts = bip143::SighashComponents::new(&claim_tx);
|
||||
let inputs_des = vec![InputDescriptors::RevokedOutput, InputDescriptors::RevokedOfferedHTLC, InputDescriptors::RevokedOfferedHTLC, InputDescriptors::RevokedReceivedHTLC];
|
||||
for (idx, inp) in claim_tx.input.iter_mut().zip(inputs_des.iter()).enumerate() {
|
||||
sign_input!(sighash_parts, inp.0, idx as u32, 0, inp.1, sum_actual_sigs);
|
||||
{
|
||||
let mut sighash_parts = bip143::SigHashCache::new(&mut claim_tx);
|
||||
for (idx, inp) in inputs_des.iter().enumerate() {
|
||||
sign_input!(sighash_parts, idx, 0, inp, sum_actual_sigs);
|
||||
}
|
||||
}
|
||||
assert_eq!(base_weight + OnchainTxHandler::<InMemoryChannelKeys>::get_witnesses_weight(&inputs_des[..]), claim_tx.get_weight() + /* max_length_sig */ (73 * inputs_des.len() - sum_actual_sigs));
|
||||
|
||||
|
|
@ -2779,10 +2780,12 @@ mod tests {
|
|||
});
|
||||
}
|
||||
let base_weight = claim_tx.get_weight();
|
||||
let sighash_parts = bip143::SighashComponents::new(&claim_tx);
|
||||
let inputs_des = vec![InputDescriptors::OfferedHTLC, InputDescriptors::ReceivedHTLC, InputDescriptors::ReceivedHTLC, InputDescriptors::ReceivedHTLC];
|
||||
for (idx, inp) in claim_tx.input.iter_mut().zip(inputs_des.iter()).enumerate() {
|
||||
sign_input!(sighash_parts, inp.0, idx as u32, 0, inp.1, sum_actual_sigs);
|
||||
{
|
||||
let mut sighash_parts = bip143::SigHashCache::new(&mut claim_tx);
|
||||
for (idx, inp) in inputs_des.iter().enumerate() {
|
||||
sign_input!(sighash_parts, idx, 0, inp, sum_actual_sigs);
|
||||
}
|
||||
}
|
||||
assert_eq!(base_weight + OnchainTxHandler::<InMemoryChannelKeys>::get_witnesses_weight(&inputs_des[..]), claim_tx.get_weight() + /* max_length_sig */ (73 * inputs_des.len() - sum_actual_sigs));
|
||||
|
||||
|
|
@ -2799,10 +2802,12 @@ mod tests {
|
|||
witness: Vec::new(),
|
||||
});
|
||||
let base_weight = claim_tx.get_weight();
|
||||
let sighash_parts = bip143::SighashComponents::new(&claim_tx);
|
||||
let inputs_des = vec![InputDescriptors::RevokedOutput];
|
||||
for (idx, inp) in claim_tx.input.iter_mut().zip(inputs_des.iter()).enumerate() {
|
||||
sign_input!(sighash_parts, inp.0, idx as u32, 0, inp.1, sum_actual_sigs);
|
||||
{
|
||||
let mut sighash_parts = bip143::SigHashCache::new(&mut claim_tx);
|
||||
for (idx, inp) in inputs_des.iter().enumerate() {
|
||||
sign_input!(sighash_parts, idx, 0, inp, sum_actual_sigs);
|
||||
}
|
||||
}
|
||||
assert_eq!(base_weight + OnchainTxHandler::<InMemoryChannelKeys>::get_witnesses_weight(&inputs_des[..]), claim_tx.get_weight() + /* max_length_isg */ (73 * inputs_des.len() - sum_actual_sigs));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,7 +27,6 @@ use util::errors::APIError;
|
|||
use util::config::UserConfig;
|
||||
use util::ser::{ReadableArgs, Writeable, Readable};
|
||||
|
||||
use bitcoin::util::hash::BitcoinHash;
|
||||
use bitcoin::blockdata::block::BlockHeader;
|
||||
use bitcoin::blockdata::transaction::{Transaction, TxOut};
|
||||
use bitcoin::network::constants::Network;
|
||||
|
|
@ -45,12 +44,12 @@ use std::mem;
|
|||
use std::collections::HashMap;
|
||||
|
||||
pub const CHAN_CONFIRM_DEPTH: u32 = 100;
|
||||
pub fn confirm_transaction<'a, 'b: 'a>(notifier: &'a chaininterface::BlockNotifierRef<'b, &chaininterface::ChainWatchInterfaceUtil>, chain: &chaininterface::ChainWatchInterfaceUtil, tx: &Transaction, chan_id: u32) {
|
||||
pub fn confirm_transaction<'a, 'b: 'a>(notifier: &'a chaininterface::BlockNotifierRef<'b, &chaininterface::ChainWatchInterfaceUtil>, chain: &chaininterface::ChainWatchInterfaceUtil, tx: &Transaction, chan_id: i32) {
|
||||
assert!(chain.does_match_tx(tx));
|
||||
let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
notifier.block_connected_checked(&header, 1, &[tx; 1], &[chan_id as usize; 1]);
|
||||
for i in 2..CHAN_CONFIRM_DEPTH {
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
notifier.block_connected_checked(&header, i, &vec![], &[0; 0]);
|
||||
}
|
||||
}
|
||||
|
|
@ -59,10 +58,10 @@ pub fn connect_blocks<'a, 'b>(notifier: &'a chaininterface::BlockNotifierRef<'b,
|
|||
let mut header = BlockHeader { version: 0x2000000, prev_blockhash: if parent { prev_blockhash } else { Default::default() }, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
notifier.block_connected_checked(&header, height + 1, &Vec::new(), &Vec::new());
|
||||
for i in 2..depth + 1 {
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
notifier.block_connected_checked(&header, height + i, &Vec::new(), &Vec::new());
|
||||
}
|
||||
header.bitcoin_hash()
|
||||
header.block_hash()
|
||||
}
|
||||
|
||||
pub struct TestChanMonCfg {
|
||||
|
|
@ -324,7 +323,7 @@ pub fn create_funding_transaction<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, expected_
|
|||
assert_eq!(*channel_value_satoshis, expected_chan_value);
|
||||
assert_eq!(user_channel_id, expected_user_chan_id);
|
||||
|
||||
let tx = Transaction { version: chan_id as u32, lock_time: 0, input: Vec::new(), output: vec![TxOut {
|
||||
let tx = Transaction { version: chan_id as i32, lock_time: 0, input: Vec::new(), output: vec![TxOut {
|
||||
value: *channel_value_satoshis, script_pubkey: output_script.clone(),
|
||||
}]};
|
||||
let funding_outpoint = OutPoint { txid: tx.txid(), index: 0 };
|
||||
|
|
|
|||
|
|
@ -32,7 +32,6 @@ use util::errors::APIError;
|
|||
use util::ser::{Writeable, Writer, ReadableArgs, Readable};
|
||||
use util::config::UserConfig;
|
||||
|
||||
use bitcoin::util::hash::BitcoinHash;
|
||||
use bitcoin::hashes::sha256d::Hash as Sha256dHash;
|
||||
use bitcoin::hashes::HashEngine;
|
||||
use bitcoin::hash_types::{Txid, BlockHash, WPubkeyHash};
|
||||
|
|
@ -2424,7 +2423,7 @@ fn channel_monitor_network_test() {
|
|||
let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[3].block_notifier.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
|
||||
for i in 3..TEST_FINAL_CLTV + 2 + LATENCY_GRACE_PERIOD_BLOCKS + 1 {
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[3].block_notifier.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
|
||||
}
|
||||
let events = nodes[3].node.get_and_clear_pending_msg_events();
|
||||
|
|
@ -2456,7 +2455,7 @@ fn channel_monitor_network_test() {
|
|||
|
||||
nodes[4].block_notifier.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
|
||||
for i in 3..TEST_FINAL_CLTV + 2 - CLTV_CLAIM_BUFFER + 1 {
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[4].block_notifier.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
|
||||
}
|
||||
let events = nodes[4].node.get_and_clear_pending_msg_events();
|
||||
|
|
@ -2470,7 +2469,7 @@ fn channel_monitor_network_test() {
|
|||
check_added_monitors!(nodes[4], 1);
|
||||
test_txn_broadcast(&nodes[4], &chan_4, None, HTLCType::SUCCESS);
|
||||
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[4].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, TEST_FINAL_CLTV - 5);
|
||||
|
||||
check_preimage_claim(&nodes[4], &node_txn);
|
||||
|
|
@ -2533,7 +2532,7 @@ fn test_justice_tx() {
|
|||
nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
|
||||
// Verify broadcast of revoked HTLC-timeout
|
||||
let node_txn = test_txn_broadcast(&nodes[0], &chan_5, Some(revoked_local_txn[0].clone()), HTLCType::TIMEOUT);
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
// Broadcast revoked HTLC-timeout on node 1
|
||||
nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[1].clone()] }, 1);
|
||||
|
|
@ -2578,7 +2577,7 @@ fn test_justice_tx() {
|
|||
|
||||
nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
|
||||
let node_txn = test_txn_broadcast(&nodes[1], &chan_6, Some(revoked_local_txn[0].clone()), HTLCType::SUCCESS);
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[1].clone()] }, 1);
|
||||
test_revoked_htlc_claim_txn_broadcast(&nodes[0], node_txn[1].clone(), revoked_local_txn[0].clone());
|
||||
|
|
@ -2657,7 +2656,7 @@ fn claim_htlc_outputs_shared_tx() {
|
|||
check_added_monitors!(nodes[0], 1);
|
||||
nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
expect_payment_failed!(nodes[1], payment_hash_2, true);
|
||||
|
||||
let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
|
||||
|
|
@ -2722,7 +2721,7 @@ fn claim_htlc_outputs_single_tx() {
|
|||
check_added_monitors!(nodes[1], 1);
|
||||
expect_pending_htlcs_forwardable_ignore!(nodes[0]);
|
||||
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 200, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 200, true, header.block_hash());
|
||||
expect_payment_failed!(nodes[1], payment_hash_2, true);
|
||||
|
||||
let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
|
||||
|
|
@ -3019,7 +3018,7 @@ fn test_htlc_on_chain_timeout() {
|
|||
}
|
||||
|
||||
nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![timeout_tx]}, 1);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
check_closed_broadcast!(nodes[1], false);
|
||||
|
||||
|
|
@ -3081,7 +3080,7 @@ fn test_simple_commitment_revoked_fail_backward() {
|
|||
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
|
||||
nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
check_closed_broadcast!(nodes[1], false);
|
||||
|
||||
|
|
@ -3235,7 +3234,7 @@ fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use
|
|||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
|
||||
nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
|
||||
let events = nodes[1].node.get_and_clear_pending_events();
|
||||
assert_eq!(events.len(), if deliver_bs_raa { 1 } else { 2 });
|
||||
|
|
@ -3535,7 +3534,7 @@ fn test_unconf_chan() {
|
|||
let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
headers.push(header.clone());
|
||||
for _i in 2..100 {
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
headers.push(header.clone());
|
||||
}
|
||||
let mut height = 99;
|
||||
|
|
@ -4088,7 +4087,7 @@ fn do_test_htlc_timeout(send_partial_mpp: bool) {
|
|||
nodes[0].block_notifier.block_connected_checked(&header, 101, &[], &[]);
|
||||
nodes[1].block_notifier.block_connected_checked(&header, 101, &[], &[]);
|
||||
for i in 102..TEST_FINAL_CLTV + 100 + 1 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS {
|
||||
header.prev_blockhash = header.bitcoin_hash();
|
||||
header.prev_blockhash = header.block_hash();
|
||||
nodes[0].block_notifier.block_connected_checked(&header, i, &[], &[]);
|
||||
nodes[1].block_notifier.block_connected_checked(&header, i, &[], &[]);
|
||||
}
|
||||
|
|
@ -4158,14 +4157,14 @@ fn do_test_holding_cell_htlc_add_timeouts(forwarded_htlc: bool) {
|
|||
let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].block_notifier.block_connected_checked(&header, 101, &[], &[]);
|
||||
for i in 102..TEST_FINAL_CLTV + 100 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS {
|
||||
header.prev_blockhash = header.bitcoin_hash();
|
||||
header.prev_blockhash = header.block_hash();
|
||||
nodes[1].block_notifier.block_connected_checked(&header, i, &[], &[]);
|
||||
}
|
||||
|
||||
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
|
||||
assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
|
||||
|
||||
header.prev_blockhash = header.bitcoin_hash();
|
||||
header.prev_blockhash = header.block_hash();
|
||||
nodes[1].block_notifier.block_connected_checked(&header, TEST_FINAL_CLTV + 100 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS, &[], &[]);
|
||||
|
||||
if forwarded_htlc {
|
||||
|
|
@ -4232,7 +4231,7 @@ fn test_invalid_channel_announcement() {
|
|||
() => {
|
||||
msgs::UnsignedChannelAnnouncement {
|
||||
features: ChannelFeatures::known(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: as_chan.get_short_channel_id().unwrap(),
|
||||
node_id_1: if were_node_one { as_network_key } else { bs_network_key },
|
||||
node_id_2: if were_node_one { bs_network_key } else { as_network_key },
|
||||
|
|
@ -4267,7 +4266,7 @@ fn test_invalid_channel_announcement() {
|
|||
|
||||
// Configured with Network::Testnet
|
||||
let mut unsigned_msg = dummy_unsigned_msg!();
|
||||
unsigned_msg.chain_hash = genesis_block(Network::Bitcoin).header.bitcoin_hash();
|
||||
unsigned_msg.chain_hash = genesis_block(Network::Bitcoin).header.block_hash();
|
||||
sign_msg!(unsigned_msg);
|
||||
assert!(nodes[0].net_graph_msg_handler.handle_channel_announcement(&chan_announcement).is_err());
|
||||
|
||||
|
|
@ -4691,7 +4690,7 @@ macro_rules! check_spendable_outputs {
|
|||
let keys = $keysinterface.derive_channel_keys($chan_value, key_derivation_params.0, key_derivation_params.1);
|
||||
let remotepubkey = keys.pubkeys().payment_point;
|
||||
let witness_script = Address::p2pkh(&::bitcoin::PublicKey{compressed: true, key: remotepubkey}, Network::Testnet).script_pubkey();
|
||||
let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
|
||||
let sighash = Message::from_slice(&bip143::SigHashCache::new(&spend_tx).signature_hash(0, &witness_script, output.value, SigHashType::All)[..]).unwrap();
|
||||
let remotesig = secp_ctx.sign(&sighash, &keys.inner.payment_key);
|
||||
spend_tx.input[0].witness.push(remotesig.serialize_der().to_vec());
|
||||
spend_tx.input[0].witness[0].push(SigHashType::All as u8);
|
||||
|
|
@ -4721,7 +4720,7 @@ macro_rules! check_spendable_outputs {
|
|||
|
||||
let delayed_payment_pubkey = PublicKey::from_secret_key(&secp_ctx, &delayed_payment_key);
|
||||
let witness_script = chan_utils::get_revokeable_redeemscript(remote_revocation_pubkey, *to_self_delay, &delayed_payment_pubkey);
|
||||
let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
|
||||
let sighash = Message::from_slice(&bip143::SigHashCache::new(&spend_tx).signature_hash(0, &witness_script, output.value, SigHashType::All)[..]).unwrap();
|
||||
let local_delayedsig = secp_ctx.sign(&sighash, &delayed_payment_key);
|
||||
spend_tx.input[0].witness.push(local_delayedsig.serialize_der().to_vec());
|
||||
spend_tx.input[0].witness[0].push(SigHashType::All as u8);
|
||||
|
|
@ -4761,7 +4760,7 @@ macro_rules! check_spendable_outputs {
|
|||
};
|
||||
let pubkey = ExtendedPubKey::from_private(&secp_ctx, &secret).public_key;
|
||||
let witness_script = Address::p2pkh(&pubkey, Network::Testnet).script_pubkey();
|
||||
let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
|
||||
let sighash = Message::from_slice(&bip143::SigHashCache::new(&spend_tx).signature_hash(0, &witness_script, output.value, SigHashType::All)[..]).unwrap();
|
||||
let sig = secp_ctx.sign(&sighash, &secret.private_key.key);
|
||||
spend_tx.input[0].witness.push(sig.serialize_der().to_vec());
|
||||
spend_tx.input[0].witness[0].push(SigHashType::All as u8);
|
||||
|
|
@ -4798,7 +4797,7 @@ fn test_claim_sizeable_push_msat() {
|
|||
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
|
||||
let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
|
||||
assert_eq!(spend_txn.len(), 1);
|
||||
|
|
@ -4828,7 +4827,7 @@ fn test_claim_on_remote_sizeable_push_msat() {
|
|||
nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
|
||||
check_closed_broadcast!(nodes[1], false);
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
|
||||
let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
|
||||
assert_eq!(spend_txn.len(), 2);
|
||||
|
|
@ -4859,9 +4858,9 @@ fn test_claim_on_remote_revoked_sizeable_push_msat() {
|
|||
check_added_monitors!(nodes[1], 1);
|
||||
|
||||
let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
|
||||
let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
|
||||
assert_eq!(spend_txn.len(), 3);
|
||||
|
|
@ -4910,9 +4909,9 @@ fn test_static_spendable_outputs_preimage_tx() {
|
|||
check_spends!(node_txn[1], chan_1.3);
|
||||
check_spends!(node_txn[2], node_txn[1]);
|
||||
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
|
||||
let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
|
||||
assert_eq!(spend_txn.len(), 1);
|
||||
|
|
@ -4956,9 +4955,9 @@ fn test_static_spendable_outputs_timeout_tx() {
|
|||
check_spends!(node_txn[1], chan_1.3.clone());
|
||||
check_spends!(node_txn[2], node_txn[1]);
|
||||
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
expect_payment_failed!(nodes[1], our_payment_hash, true);
|
||||
|
||||
let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
|
||||
|
|
@ -4993,9 +4992,9 @@ fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() {
|
|||
assert_eq!(node_txn[0].input.len(), 2);
|
||||
check_spends!(node_txn[0], revoked_local_txn[0]);
|
||||
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
|
||||
let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
|
||||
assert_eq!(spend_txn.len(), 1);
|
||||
|
|
@ -5047,9 +5046,9 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
|
|||
assert_eq!(node_txn[3].input.len(), 1);
|
||||
check_spends!(node_txn[3], revoked_local_txn[0]);
|
||||
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone(), node_txn[2].clone()] }, 1);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
|
||||
// Check B's ChannelMonitor was able to generate the right spendable output descriptor
|
||||
let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
|
||||
|
|
@ -5097,9 +5096,9 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
|
|||
assert_eq!(node_txn[2].input.len(), 1);
|
||||
check_spends!(node_txn[2], revoked_htlc_txn[0]);
|
||||
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[0].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone(), node_txn[2].clone()] }, 1);
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
|
||||
// Check A's ChannelMonitor was able to generate the right spendable output descriptor
|
||||
let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
|
||||
|
|
@ -5283,7 +5282,7 @@ fn test_duplicate_payment_hash_one_failure_one_success() {
|
|||
check_spends!(htlc_success_txn[1], commitment_txn[0]);
|
||||
|
||||
nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![htlc_timeout_tx] }, 200);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 200, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 200, true, header.block_hash());
|
||||
expect_pending_htlcs_forwardable!(nodes[1]);
|
||||
let htlc_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
|
||||
assert!(htlc_updates.update_add_htlcs.is_empty());
|
||||
|
|
@ -5367,9 +5366,9 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
|
|||
vec![node_txn[0].clone(), node_txn[2].clone()]
|
||||
};
|
||||
|
||||
let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].block_notifier.block_connected(&Block { header: header_201, txdata: node_txn.clone() }, 201);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.block_hash());
|
||||
|
||||
// Verify that B is able to spend its own HTLC-Success tx thanks to spendable output event given back by its ChannelMonitor
|
||||
let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
|
||||
|
|
@ -5513,7 +5512,7 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno
|
|||
} else {
|
||||
nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![ds_prev_commitment_tx[0].clone()]}, 1);
|
||||
}
|
||||
connect_blocks(&nodes[2].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[2].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
check_closed_broadcast!(nodes[2], false);
|
||||
expect_pending_htlcs_forwardable!(nodes[2]);
|
||||
check_added_monitors!(nodes[2], 3);
|
||||
|
|
@ -5663,9 +5662,9 @@ fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() {
|
|||
node_txn[0].clone()
|
||||
};
|
||||
|
||||
let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[0].block_notifier.block_connected(&Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201);
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.block_hash());
|
||||
expect_payment_failed!(nodes[0], our_payment_hash, true);
|
||||
|
||||
// Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor
|
||||
|
|
@ -5733,9 +5732,9 @@ fn test_key_derivation_params() {
|
|||
node_txn[0].clone()
|
||||
};
|
||||
|
||||
let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[0].block_notifier.block_connected(&Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201);
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.block_hash());
|
||||
expect_payment_failed!(nodes[0], our_payment_hash, true);
|
||||
|
||||
// Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor
|
||||
|
|
@ -5761,14 +5760,14 @@ fn test_static_output_closing_tx() {
|
|||
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![closing_tx.clone()] }, 0);
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.block_hash());
|
||||
|
||||
let spend_txn = check_spendable_outputs!(nodes[0], 2, node_cfgs[0].keys_manager, 100000);
|
||||
assert_eq!(spend_txn.len(), 1);
|
||||
check_spends!(spend_txn[0], closing_tx);
|
||||
|
||||
nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![closing_tx.clone()] }, 0);
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.block_hash());
|
||||
|
||||
let spend_txn = check_spendable_outputs!(nodes[1], 2, node_cfgs[1].keys_manager, 100000);
|
||||
assert_eq!(spend_txn.len(), 1);
|
||||
|
|
@ -5809,7 +5808,7 @@ fn do_htlc_claim_local_commitment_only(use_dust: bool) {
|
|||
let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
for i in 1..TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + CHAN_CONFIRM_DEPTH + 1 {
|
||||
nodes[1].block_notifier.block_connected_checked(&header, i, &Vec::new(), &Vec::new());
|
||||
header.prev_blockhash = header.bitcoin_hash();
|
||||
header.prev_blockhash = header.block_hash();
|
||||
}
|
||||
test_txn_broadcast(&nodes[1], &chan, None, if use_dust { HTLCType::NONE } else { HTLCType::SUCCESS });
|
||||
check_closed_broadcast!(nodes[1], false);
|
||||
|
|
@ -5840,7 +5839,7 @@ fn do_htlc_claim_current_remote_commitment_only(use_dust: bool) {
|
|||
|
||||
for i in 1..TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + CHAN_CONFIRM_DEPTH + 1 {
|
||||
nodes[0].block_notifier.block_connected(&Block { header, txdata: Vec::new()}, i);
|
||||
header.prev_blockhash = header.bitcoin_hash();
|
||||
header.prev_blockhash = header.block_hash();
|
||||
}
|
||||
test_txn_broadcast(&nodes[0], &chan, None, HTLCType::NONE);
|
||||
check_closed_broadcast!(nodes[0], false);
|
||||
|
|
@ -5883,7 +5882,7 @@ fn do_htlc_claim_previous_remote_commitment_only(use_dust: bool, check_revoke_no
|
|||
let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
for i in 1..TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + CHAN_CONFIRM_DEPTH + 1 {
|
||||
nodes[0].block_notifier.block_connected_checked(&header, i, &Vec::new(), &Vec::new());
|
||||
header.prev_blockhash = header.bitcoin_hash();
|
||||
header.prev_blockhash = header.block_hash();
|
||||
}
|
||||
if !check_revoke_no_close {
|
||||
test_txn_broadcast(&nodes[0], &chan, None, HTLCType::NONE);
|
||||
|
|
@ -6427,7 +6426,7 @@ fn bolt2_open_channel_sending_node_checks_part2() {
|
|||
assert!(node0_to_1_send_open_channel.to_self_delay==BREAKDOWN_TIMEOUT);
|
||||
|
||||
// BOLT #2 spec: Sending node must ensure the chain_hash value identifies the chain it wishes to open the channel within.
|
||||
let chain_hash=genesis_block(Network::Testnet).header.bitcoin_hash();
|
||||
let chain_hash=genesis_block(Network::Testnet).header.block_hash();
|
||||
assert_eq!(node0_to_1_send_open_channel.chain_hash,chain_hash);
|
||||
|
||||
// BOLT #2 spec: Sending node must set funding_pubkey, revocation_basepoint, htlc_basepoint, payment_basepoint, and delayed_payment_basepoint to valid DER-encoded, compressed, secp256k1 pubkeys.
|
||||
|
|
@ -7519,7 +7518,7 @@ fn do_test_failure_delay_dust_htlc_local_commitment(announce_latest: bool) {
|
|||
check_added_monitors!(nodes[0], 1);
|
||||
|
||||
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.block_hash());
|
||||
let events = nodes[0].node.get_and_clear_pending_events();
|
||||
// Only 2 PaymentFailed events should show up, over-dust HTLC has to be failed by timeout tx
|
||||
assert_eq!(events.len(), 2);
|
||||
|
|
@ -7591,7 +7590,7 @@ fn test_no_failure_dust_htlc_local_commitment() {
|
|||
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
|
||||
assert_eq!(nodes[0].node.get_and_clear_pending_msg_events().len(), 0);
|
||||
// We broadcast a few more block to check everything is all right
|
||||
connect_blocks(&nodes[0].block_notifier, 20, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[0].block_notifier, 20, 1, true, header.block_hash());
|
||||
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
|
||||
assert_eq!(nodes[0].node.get_and_clear_pending_msg_events().len(), 0);
|
||||
|
||||
|
|
@ -7636,15 +7635,15 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
|
|||
check_added_monitors!(nodes[0], 1);
|
||||
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
|
||||
timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone());
|
||||
let parent_hash = connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 2, true, header.bitcoin_hash());
|
||||
let parent_hash = connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 2, true, header.block_hash());
|
||||
expect_payment_failed!(nodes[0], dust_hash, true);
|
||||
assert_eq!(timeout_tx[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
|
||||
// We fail non-dust-HTLC 2 by broadcast of local HTLC-timeout tx on local commitment tx
|
||||
let header_2 = BlockHeader { version: 0x20000000, prev_blockhash: parent_hash, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
|
||||
nodes[0].block_notifier.block_connected(&Block { header: header_2, txdata: vec![timeout_tx[0].clone()]}, 7);
|
||||
let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 8, true, header_3.bitcoin_hash());
|
||||
let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 8, true, header_3.block_hash());
|
||||
expect_payment_failed!(nodes[0], non_dust_hash, true);
|
||||
} else {
|
||||
// We fail dust-HTLC 1 by broadcast of remote commitment tx. If revoked, fail also non-dust HTLC
|
||||
|
|
@ -7653,7 +7652,7 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
|
|||
check_added_monitors!(nodes[0], 1);
|
||||
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
|
||||
timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone());
|
||||
let parent_hash = connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 2, true, header.bitcoin_hash());
|
||||
let parent_hash = connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 2, true, header.block_hash());
|
||||
let header_2 = BlockHeader { version: 0x20000000, prev_blockhash: parent_hash, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
if !revoked {
|
||||
expect_payment_failed!(nodes[0], dust_hash, true);
|
||||
|
|
@ -7661,8 +7660,8 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
|
|||
// We fail non-dust-HTLC 2 by broadcast of local timeout tx on remote commitment tx
|
||||
nodes[0].block_notifier.block_connected(&Block { header: header_2, txdata: vec![timeout_tx[0].clone()]}, 7);
|
||||
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
|
||||
let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 8, true, header_3.bitcoin_hash());
|
||||
let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 8, true, header_3.block_hash());
|
||||
expect_payment_failed!(nodes[0], non_dust_hash, true);
|
||||
} else {
|
||||
// If revoked, both dust & non-dust HTLCs should have been failed after ANTI_REORG_DELAY confs of revoked
|
||||
|
|
@ -7950,7 +7949,7 @@ fn test_data_loss_protect() {
|
|||
assert_eq!(node_txn[0].output.len(), 2);
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
|
||||
nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()]}, 0);
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.block_hash());
|
||||
let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
|
||||
assert_eq!(spend_txn.len(), 1);
|
||||
check_spends!(spend_txn[0], node_txn[0]);
|
||||
|
|
@ -8122,7 +8121,7 @@ fn test_bump_penalty_txn_on_revoked_commitment() {
|
|||
};
|
||||
|
||||
// After exhaustion of height timer, a new bumped justice tx should have been broadcast, check it
|
||||
let header = connect_blocks(&nodes[1].block_notifier, 3, 115, true, header.bitcoin_hash());
|
||||
let header = connect_blocks(&nodes[1].block_notifier, 3, 115, true, header.block_hash());
|
||||
let mut penalty_2 = penalty_1;
|
||||
let mut feerate_2 = 0;
|
||||
{
|
||||
|
|
@ -8216,7 +8215,7 @@ fn test_bump_penalty_txn_on_revoked_htlcs() {
|
|||
}
|
||||
|
||||
// Broadcast set of revoked txn on A
|
||||
let header_128 = connect_blocks(&nodes[0].block_notifier, 128, 0, true, header.bitcoin_hash());
|
||||
let header_128 = connect_blocks(&nodes[0].block_notifier, 128, 0, true, header.block_hash());
|
||||
expect_pending_htlcs_forwardable_ignore!(nodes[0]);
|
||||
|
||||
let header_129 = BlockHeader { version: 0x20000000, prev_blockhash: header_128, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
|
|
@ -8240,7 +8239,7 @@ fn test_bump_penalty_txn_on_revoked_htlcs() {
|
|||
}
|
||||
|
||||
// Connect three more block to see if bumped penalty are issued for HTLC txn
|
||||
let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[0].block_notifier.block_connected(&Block { header: header_130, txdata: penalty_txn }, 130);
|
||||
{
|
||||
let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
|
||||
|
|
@ -8253,7 +8252,7 @@ fn test_bump_penalty_txn_on_revoked_htlcs() {
|
|||
};
|
||||
|
||||
// Few more blocks to confirm penalty txn
|
||||
let header_135 = connect_blocks(&nodes[0].block_notifier, 5, 130, true, header_130.bitcoin_hash());
|
||||
let header_135 = connect_blocks(&nodes[0].block_notifier, 5, 130, true, header_130.block_hash());
|
||||
assert!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty());
|
||||
let header_144 = connect_blocks(&nodes[0].block_notifier, 9, 135, true, header_135);
|
||||
let node_txn = {
|
||||
|
|
@ -8274,7 +8273,7 @@ fn test_bump_penalty_txn_on_revoked_htlcs() {
|
|||
// Broadcast claim txn and confirm blocks to avoid further bumps on this outputs
|
||||
let header_145 = BlockHeader { version: 0x20000000, prev_blockhash: header_144, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[0].block_notifier.block_connected(&Block { header: header_145, txdata: node_txn }, 145);
|
||||
connect_blocks(&nodes[0].block_notifier, 20, 145, true, header_145.bitcoin_hash());
|
||||
connect_blocks(&nodes[0].block_notifier, 20, 145, true, header_145.block_hash());
|
||||
{
|
||||
let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
|
||||
// We verify than no new transaction has been broadcast because previously
|
||||
|
|
@ -8362,7 +8361,7 @@ fn test_bump_penalty_txn_on_remote_commitment() {
|
|||
assert_ne!(feerate_preimage, 0);
|
||||
|
||||
// After exhaustion of height timer, new bumped claim txn should have been broadcast, check it
|
||||
connect_blocks(&nodes[1].block_notifier, 15, 1, true, header.bitcoin_hash());
|
||||
connect_blocks(&nodes[1].block_notifier, 15, 1, true, header.block_hash());
|
||||
{
|
||||
let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
|
||||
assert_eq!(node_txn.len(), 2);
|
||||
|
|
@ -8468,7 +8467,7 @@ fn test_set_outpoints_partial_claiming() {
|
|||
};
|
||||
|
||||
// Broadcast partial claim on node A, should regenerate a claiming tx with HTLC dropped
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![partial_claim_tx.clone()] }, 102);
|
||||
{
|
||||
let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
|
||||
|
|
@ -8568,9 +8567,9 @@ fn test_bump_txn_sanitize_tracking_maps() {
|
|||
node_txn.clear();
|
||||
penalty_txn
|
||||
};
|
||||
let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[0].block_notifier.block_connected(&Block { header: header_130, txdata: penalty_txn }, 130);
|
||||
connect_blocks(&nodes[0].block_notifier, 5, 130, false, header_130.bitcoin_hash());
|
||||
connect_blocks(&nodes[0].block_notifier, 5, 130, false, header_130.block_hash());
|
||||
{
|
||||
let monitors = nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap();
|
||||
if let Some(monitor) = monitors.get(&OutPoint { txid: chan.3.txid(), index: 0 }) {
|
||||
|
|
|
|||
|
|
@ -35,12 +35,18 @@ mod channel;
|
|||
mod onion_utils;
|
||||
mod wire;
|
||||
|
||||
// Older rustc (which we support) refuses to let us call the get_payment_preimage_hash!() macro
|
||||
// without the node parameter being mut. This is incorrect, and thus newer rustcs will complain
|
||||
// about an unnecessary mut. Thus, we silence the unused_mut warning in two test modules below.
|
||||
|
||||
#[cfg(test)]
|
||||
#[macro_use]
|
||||
pub(crate) mod functional_test_utils;
|
||||
#[cfg(test)]
|
||||
#[allow(unused_mut)]
|
||||
mod functional_tests;
|
||||
#[cfg(test)]
|
||||
#[allow(unused_mut)]
|
||||
mod chanmon_update_fail_tests;
|
||||
#[cfg(test)]
|
||||
mod reorg_tests;
|
||||
|
|
|
|||
|
|
@ -1963,7 +1963,11 @@ mod tests {
|
|||
let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
|
||||
let shutdown = msgs::Shutdown {
|
||||
channel_id: [2; 32],
|
||||
scriptpubkey: if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, key: pubkey_1}, Network::Testnet).script_pubkey() } else if script_type == 2 { Address::p2sh(&script, Network::Testnet).script_pubkey() } else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, key: pubkey_1}, Network::Testnet).script_pubkey() } else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
|
||||
scriptpubkey:
|
||||
if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, key: pubkey_1}, Network::Testnet).script_pubkey() }
|
||||
else if script_type == 2 { Address::p2sh(&script, Network::Testnet).script_pubkey() }
|
||||
else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, key: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
|
||||
else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
|
||||
};
|
||||
let encoded_value = shutdown.encode();
|
||||
let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
|
||||
|
|
|
|||
|
|
@ -14,7 +14,6 @@ use ln::features::InitFeatures;
|
|||
use ln::msgs::{ChannelMessageHandler, ErrorAction, HTLCFailChannelUpdate};
|
||||
use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
|
||||
|
||||
use bitcoin::util::hash::BitcoinHash;
|
||||
use bitcoin::blockdata::block::{Block, BlockHeader};
|
||||
|
||||
use std::default::Default;
|
||||
|
|
@ -106,7 +105,7 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) {
|
|||
// At CHAN_CONFIRM_DEPTH + 1 we have a confirmation count of 1, so CHAN_CONFIRM_DEPTH +
|
||||
// ANTI_REORG_DELAY - 1 will give us a confirmation count of ANTI_REORG_DELAY - 1.
|
||||
for i in CHAN_CONFIRM_DEPTH + 2..CHAN_CONFIRM_DEPTH + ANTI_REORG_DELAY - 1 {
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].block_notifier.block_connected_checked(&header, i, &vec![], &[0; 0]);
|
||||
headers.push(header.clone());
|
||||
}
|
||||
|
|
@ -127,7 +126,7 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) {
|
|||
assert_eq!(nodes[1].node.get_and_clear_pending_events().len(), 0);
|
||||
} else {
|
||||
// Confirm the timeout tx and check that we fail the HTLC backwards
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].block_notifier.block_connected_checked(&header, CHAN_CONFIRM_DEPTH + ANTI_REORG_DELAY, &vec![], &[0; 0]);
|
||||
expect_pending_htlcs_forwardable!(nodes[1]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -838,7 +838,6 @@ mod tests {
|
|||
use bitcoin::blockdata::constants::genesis_block;
|
||||
use bitcoin::blockdata::script::Builder;
|
||||
use bitcoin::blockdata::opcodes;
|
||||
use bitcoin::util::hash::BitcoinHash;
|
||||
|
||||
use hex;
|
||||
|
||||
|
|
@ -906,7 +905,7 @@ mod tests {
|
|||
// Announce a channel to add a corresponding node.
|
||||
let unsigned_announcement = UnsignedChannelAnnouncement {
|
||||
features: ChannelFeatures::known(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 0,
|
||||
node_id_1,
|
||||
node_id_2,
|
||||
|
|
@ -996,7 +995,7 @@ mod tests {
|
|||
|
||||
let mut unsigned_announcement = UnsignedChannelAnnouncement {
|
||||
features: ChannelFeatures::known(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 0,
|
||||
node_id_1,
|
||||
node_id_2,
|
||||
|
|
@ -1176,7 +1175,7 @@ mod tests {
|
|||
|
||||
let zero_hash = Sha256dHash::hash(&[0; 32]);
|
||||
let short_channel_id = 0;
|
||||
let chain_hash = genesis_block(Network::Testnet).header.bitcoin_hash();
|
||||
let chain_hash = genesis_block(Network::Testnet).header.block_hash();
|
||||
let amount_sats = 1000_000;
|
||||
|
||||
{
|
||||
|
|
@ -1339,7 +1338,7 @@ mod tests {
|
|||
let node_2_btckey = &SecretKey::from_slice(&[39; 32]).unwrap();
|
||||
|
||||
let short_channel_id = 0;
|
||||
let chain_hash = genesis_block(Network::Testnet).header.bitcoin_hash();
|
||||
let chain_hash = genesis_block(Network::Testnet).header.block_hash();
|
||||
|
||||
{
|
||||
// There is no nodes in the table at the beginning.
|
||||
|
|
@ -1454,7 +1453,7 @@ mod tests {
|
|||
let node_2_btckey = &SecretKey::from_slice(&[39; 32]).unwrap();
|
||||
|
||||
let short_channel_id = 1;
|
||||
let chain_hash = genesis_block(Network::Testnet).header.bitcoin_hash();
|
||||
let chain_hash = genesis_block(Network::Testnet).header.block_hash();
|
||||
|
||||
// Channels were not announced yet.
|
||||
let channels_with_announcements = net_graph_msg_handler.get_next_channel_announcements(0, 1);
|
||||
|
|
@ -1588,7 +1587,7 @@ mod tests {
|
|||
let node_2_btckey = &SecretKey::from_slice(&[39; 32]).unwrap();
|
||||
|
||||
let short_channel_id = 1;
|
||||
let chain_hash = genesis_block(Network::Testnet).header.bitcoin_hash();
|
||||
let chain_hash = genesis_block(Network::Testnet).header.block_hash();
|
||||
|
||||
// No nodes yet.
|
||||
let next_announcements = net_graph_msg_handler.get_next_node_announcements(None, 10);
|
||||
|
|
@ -1708,7 +1707,7 @@ mod tests {
|
|||
let node_id_2 = PublicKey::from_secret_key(&secp_ctx, node_2_privkey);
|
||||
let unsigned_announcement = UnsignedChannelAnnouncement {
|
||||
features: ChannelFeatures::known(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 0,
|
||||
node_id_1,
|
||||
node_id_2,
|
||||
|
|
|
|||
|
|
@ -424,7 +424,6 @@ mod tests {
|
|||
use bitcoin::hashes::Hash;
|
||||
use bitcoin::network::constants::Network;
|
||||
use bitcoin::blockdata::constants::genesis_block;
|
||||
use bitcoin::util::hash::BitcoinHash;
|
||||
|
||||
use hex;
|
||||
|
||||
|
|
@ -441,7 +440,7 @@ mod tests {
|
|||
|
||||
let unsigned_announcement = UnsignedChannelAnnouncement {
|
||||
features,
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id,
|
||||
node_id_1,
|
||||
node_id_2,
|
||||
|
|
@ -598,7 +597,7 @@ mod tests {
|
|||
|
||||
add_channel(&net_graph_msg_handler, &secp_ctx, &our_privkey, &privkeys[0], ChannelFeatures::from_le_bytes(id_to_feature_flags(1)), 1);
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[0], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 1,
|
||||
timestamp: 1,
|
||||
flags: 1,
|
||||
|
|
@ -614,7 +613,7 @@ mod tests {
|
|||
|
||||
add_channel(&net_graph_msg_handler, &secp_ctx, &our_privkey, &privkeys[1], ChannelFeatures::from_le_bytes(id_to_feature_flags(2)), 2);
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &our_privkey, UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 2,
|
||||
timestamp: 1,
|
||||
flags: 0,
|
||||
|
|
@ -626,7 +625,7 @@ mod tests {
|
|||
excess_data: Vec::new()
|
||||
});
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[1], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 2,
|
||||
timestamp: 1,
|
||||
flags: 1,
|
||||
|
|
@ -642,7 +641,7 @@ mod tests {
|
|||
|
||||
add_channel(&net_graph_msg_handler, &secp_ctx, &our_privkey, &privkeys[7], ChannelFeatures::from_le_bytes(id_to_feature_flags(12)), 12);
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &our_privkey, UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 12,
|
||||
timestamp: 1,
|
||||
flags: 0,
|
||||
|
|
@ -654,7 +653,7 @@ mod tests {
|
|||
excess_data: Vec::new()
|
||||
});
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[7], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 12,
|
||||
timestamp: 1,
|
||||
flags: 1,
|
||||
|
|
@ -670,7 +669,7 @@ mod tests {
|
|||
|
||||
add_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[0], &privkeys[2], ChannelFeatures::from_le_bytes(id_to_feature_flags(3)), 3);
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[0], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 3,
|
||||
timestamp: 1,
|
||||
flags: 0,
|
||||
|
|
@ -682,7 +681,7 @@ mod tests {
|
|||
excess_data: Vec::new()
|
||||
});
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[2], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 3,
|
||||
timestamp: 1,
|
||||
flags: 1,
|
||||
|
|
@ -696,7 +695,7 @@ mod tests {
|
|||
|
||||
add_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[1], &privkeys[2], ChannelFeatures::from_le_bytes(id_to_feature_flags(4)), 4);
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[1], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 4,
|
||||
timestamp: 1,
|
||||
flags: 0,
|
||||
|
|
@ -708,7 +707,7 @@ mod tests {
|
|||
excess_data: Vec::new()
|
||||
});
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[2], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 4,
|
||||
timestamp: 1,
|
||||
flags: 1,
|
||||
|
|
@ -722,7 +721,7 @@ mod tests {
|
|||
|
||||
add_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[7], &privkeys[2], ChannelFeatures::from_le_bytes(id_to_feature_flags(13)), 13);
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[7], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 13,
|
||||
timestamp: 1,
|
||||
flags: 0,
|
||||
|
|
@ -734,7 +733,7 @@ mod tests {
|
|||
excess_data: Vec::new()
|
||||
});
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[2], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 13,
|
||||
timestamp: 1,
|
||||
flags: 1,
|
||||
|
|
@ -750,7 +749,7 @@ mod tests {
|
|||
|
||||
add_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[2], &privkeys[4], ChannelFeatures::from_le_bytes(id_to_feature_flags(6)), 6);
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[2], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 6,
|
||||
timestamp: 1,
|
||||
flags: 0,
|
||||
|
|
@ -762,7 +761,7 @@ mod tests {
|
|||
excess_data: Vec::new()
|
||||
});
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[4], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 6,
|
||||
timestamp: 1,
|
||||
flags: 1,
|
||||
|
|
@ -776,7 +775,7 @@ mod tests {
|
|||
|
||||
add_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[4], &privkeys[3], ChannelFeatures::from_le_bytes(id_to_feature_flags(11)), 11);
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[4], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 11,
|
||||
timestamp: 1,
|
||||
flags: 0,
|
||||
|
|
@ -788,7 +787,7 @@ mod tests {
|
|||
excess_data: Vec::new()
|
||||
});
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[3], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 11,
|
||||
timestamp: 1,
|
||||
flags: 1,
|
||||
|
|
@ -806,7 +805,7 @@ mod tests {
|
|||
|
||||
add_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[2], &privkeys[5], ChannelFeatures::from_le_bytes(id_to_feature_flags(7)), 7);
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[2], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 7,
|
||||
timestamp: 1,
|
||||
flags: 0,
|
||||
|
|
@ -818,7 +817,7 @@ mod tests {
|
|||
excess_data: Vec::new()
|
||||
});
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[5], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 7,
|
||||
timestamp: 1,
|
||||
flags: 1,
|
||||
|
|
@ -866,7 +865,7 @@ mod tests {
|
|||
|
||||
// // Disable channels 4 and 12 by flags=2
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &privkeys[1], UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 4,
|
||||
timestamp: 2,
|
||||
flags: 2, // to disable
|
||||
|
|
@ -878,7 +877,7 @@ mod tests {
|
|||
excess_data: Vec::new()
|
||||
});
|
||||
update_channel(&net_graph_msg_handler, &secp_ctx, &our_privkey, UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(Network::Testnet).header.block_hash(),
|
||||
short_channel_id: 12,
|
||||
timestamp: 2,
|
||||
flags: 2, // to disable
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ use chain::keysinterface::{ChannelKeys, InMemoryChannelKeys};
|
|||
use std::cmp;
|
||||
use std::sync::{Mutex, Arc};
|
||||
|
||||
use bitcoin::blockdata::transaction::Transaction;
|
||||
use bitcoin::blockdata::transaction::{Transaction, SigHashType};
|
||||
use bitcoin::util::bip143;
|
||||
|
||||
use bitcoin::secp256k1;
|
||||
|
|
@ -108,7 +108,7 @@ impl ChannelKeys for EnforcingChannelKeys {
|
|||
|
||||
let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&this_htlc.0, &local_commitment_tx.local_keys);
|
||||
|
||||
let sighash = hash_to_message!(&bip143::SighashComponents::new(&htlc_tx).sighash_all(&htlc_tx.input[0], &htlc_redeemscript, this_htlc.0.amount_msat / 1000)[..]);
|
||||
let sighash = hash_to_message!(&bip143::SigHashCache::new(&htlc_tx).signature_hash(0, &htlc_redeemscript, this_htlc.0.amount_msat / 1000, SigHashType::All)[..]);
|
||||
secp_ctx.verify(&sighash, this_htlc.1.as_ref().unwrap(), &local_commitment_tx.local_keys.b_htlc_key).unwrap();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@ use util::events;
|
|||
use util::logger::{Logger, Level, Record};
|
||||
use util::ser::{Readable, Writer, Writeable};
|
||||
|
||||
use bitcoin::BitcoinHash;
|
||||
use bitcoin::blockdata::constants::genesis_block;
|
||||
use bitcoin::blockdata::transaction::Transaction;
|
||||
use bitcoin::blockdata::script::{Builder, Script};
|
||||
|
|
@ -196,7 +195,7 @@ fn get_dummy_channel_announcement(short_chan_id: u64) -> msgs::ChannelAnnounceme
|
|||
let node_2_btckey = SecretKey::from_slice(&[39; 32]).unwrap();
|
||||
let unsigned_ann = msgs::UnsignedChannelAnnouncement {
|
||||
features: ChannelFeatures::known(),
|
||||
chain_hash: genesis_block(network).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(network).header.block_hash(),
|
||||
short_channel_id: short_chan_id,
|
||||
node_id_1: PublicKey::from_secret_key(&secp_ctx, &node_1_privkey),
|
||||
node_id_2: PublicKey::from_secret_key(&secp_ctx, &node_2_privkey),
|
||||
|
|
@ -220,7 +219,7 @@ fn get_dummy_channel_update(short_chan_id: u64) -> msgs::ChannelUpdate {
|
|||
msgs::ChannelUpdate {
|
||||
signature: Signature::from(FFISignature::new()),
|
||||
contents: msgs::UnsignedChannelUpdate {
|
||||
chain_hash: genesis_block(network).header.bitcoin_hash(),
|
||||
chain_hash: genesis_block(network).header.block_hash(),
|
||||
short_channel_id: short_chan_id,
|
||||
timestamp: 0,
|
||||
flags: 0,
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue