mirror of
https://github.com/lightningdevkit/rust-lightning.git
synced 2025-03-15 15:39:09 +01:00
Merge pull request #2212 from wpaulino/off-by-one-locktime
Fix off-by-one finalized transaction locktime
This commit is contained in:
Matt Corallo
GitHub
commit
bc54441424
12 changed files with 87 additions and 71 deletions
|
|
@ -1033,12 +1033,12 @@ mod tests {
|
|||
}
|
||||
|
||||
fn create_nodes(num_nodes: usize, persist_dir: String) -> Vec<Node> {
|
||||
let network = Network::Testnet;
|
||||
let mut nodes = Vec::new();
|
||||
for i in 0..num_nodes {
|
||||
let tx_broadcaster = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), blocks: Arc::new(Mutex::new(Vec::new()))});
|
||||
let tx_broadcaster = Arc::new(test_utils::TestBroadcaster::new(network));
|
||||
let fee_estimator = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) });
|
||||
let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
|
||||
let network = Network::Testnet;
|
||||
let genesis_block = genesis_block(network);
|
||||
let network_graph = Arc::new(NetworkGraph::new(network, logger.clone()));
|
||||
let scorer = Arc::new(Mutex::new(TestScorer::new()));
|
||||
|
|
|
|||
|
|
@ -4169,7 +4169,7 @@ mod tests {
|
|||
replay_update.updates.push(ChannelMonitorUpdateStep::PaymentPreimage { payment_preimage: payment_preimage_1 });
|
||||
replay_update.updates.push(ChannelMonitorUpdateStep::PaymentPreimage { payment_preimage: payment_preimage_2 });
|
||||
|
||||
let broadcaster = TestBroadcaster::new(Arc::clone(&nodes[1].blocks));
|
||||
let broadcaster = TestBroadcaster::with_blocks(Arc::clone(&nodes[1].blocks));
|
||||
assert!(
|
||||
pre_update_monitor.update_monitor(&replay_update, &&broadcaster, &chanmon_cfgs[1].fee_estimator, &nodes[1].logger)
|
||||
.is_err());
|
||||
|
|
@ -4195,10 +4195,7 @@ mod tests {
|
|||
fn test_prune_preimages() {
|
||||
let secp_ctx = Secp256k1::new();
|
||||
let logger = Arc::new(TestLogger::new());
|
||||
let broadcaster = Arc::new(TestBroadcaster {
|
||||
txn_broadcasted: Mutex::new(Vec::new()),
|
||||
blocks: Arc::new(Mutex::new(Vec::new()))
|
||||
});
|
||||
let broadcaster = Arc::new(TestBroadcaster::new(Network::Testnet));
|
||||
let fee_estimator = TestFeeEstimator { sat_per_kw: Mutex::new(253) };
|
||||
|
||||
let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
|
||||
|
|
|
|||
|
|
@ -748,8 +748,8 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
|
|||
preprocessed_requests.push(req);
|
||||
}
|
||||
|
||||
// Claim everything up to and including cur_height + 1
|
||||
let remaining_locked_packages = self.locktimed_packages.split_off(&(cur_height + 2));
|
||||
// Claim everything up to and including `cur_height`
|
||||
let remaining_locked_packages = self.locktimed_packages.split_off(&(cur_height + 1));
|
||||
for (pop_height, mut entry) in self.locktimed_packages.iter_mut() {
|
||||
log_trace!(logger, "Restoring delayed claim of package(s) at their timelock at {}.", pop_height);
|
||||
preprocessed_requests.append(&mut entry);
|
||||
|
|
@ -1036,8 +1036,10 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
|
|||
}
|
||||
}
|
||||
for ((_package_id, _), ref mut request) in bump_candidates.iter_mut() {
|
||||
// `height` is the height being disconnected, so our `current_height` is 1 lower.
|
||||
let current_height = height - 1;
|
||||
if let Some((new_timer, new_feerate, bump_claim)) = self.generate_claim(
|
||||
height, &request, true /* force_feerate_bump */, fee_estimator, &&*logger
|
||||
current_height, &request, true /* force_feerate_bump */, fee_estimator, &&*logger
|
||||
) {
|
||||
request.set_timer(new_timer);
|
||||
request.set_feerate(new_feerate);
|
||||
|
|
|
|||
|
|
@ -460,13 +460,13 @@ impl PackageSolvingData {
|
|||
}
|
||||
}
|
||||
fn absolute_tx_timelock(&self, current_height: u32) -> u32 {
|
||||
// We use `current_height + 1` as our default locktime to discourage fee sniping and because
|
||||
// We use `current_height` as our default locktime to discourage fee sniping and because
|
||||
// transactions with it always propagate.
|
||||
let absolute_timelock = match self {
|
||||
PackageSolvingData::RevokedOutput(_) => current_height + 1,
|
||||
PackageSolvingData::RevokedHTLCOutput(_) => current_height + 1,
|
||||
PackageSolvingData::CounterpartyOfferedHTLCOutput(_) => current_height + 1,
|
||||
PackageSolvingData::CounterpartyReceivedHTLCOutput(ref outp) => cmp::max(outp.htlc.cltv_expiry, current_height + 1),
|
||||
PackageSolvingData::RevokedOutput(_) => current_height,
|
||||
PackageSolvingData::RevokedHTLCOutput(_) => current_height,
|
||||
PackageSolvingData::CounterpartyOfferedHTLCOutput(_) => current_height,
|
||||
PackageSolvingData::CounterpartyReceivedHTLCOutput(ref outp) => cmp::max(outp.htlc.cltv_expiry, current_height),
|
||||
// HTLC timeout/success transactions rely on a fixed timelock due to the counterparty's
|
||||
// signature.
|
||||
PackageSolvingData::HolderHTLCOutput(ref outp) => {
|
||||
|
|
@ -475,7 +475,7 @@ impl PackageSolvingData {
|
|||
}
|
||||
outp.cltv_expiry
|
||||
},
|
||||
PackageSolvingData::HolderFundingOutput(_) => current_height + 1,
|
||||
PackageSolvingData::HolderFundingOutput(_) => current_height,
|
||||
};
|
||||
absolute_timelock
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3026,10 +3026,11 @@ where
|
|||
}
|
||||
{
|
||||
let height = self.best_block.read().unwrap().height();
|
||||
// Transactions are evaluated as final by network mempools at the next block. However, the modules
|
||||
// constituting our Lightning node might not have perfect sync about their blockchain views. Thus, if
|
||||
// the wallet module is in advance on the LDK view, allow one more block of headroom.
|
||||
if !funding_transaction.input.iter().all(|input| input.sequence == Sequence::MAX) && LockTime::from(funding_transaction.lock_time).is_block_height() && funding_transaction.lock_time.0 > height + 2 {
|
||||
// Transactions are evaluated as final by network mempools if their locktime is strictly
|
||||
// lower than the next block height. However, the modules constituting our Lightning
|
||||
// node might not have perfect sync about their blockchain views. Thus, if the wallet
|
||||
// module is ahead of LDK, only allow one more block of headroom.
|
||||
if !funding_transaction.input.iter().all(|input| input.sequence == Sequence::MAX) && LockTime::from(funding_transaction.lock_time).is_block_height() && funding_transaction.lock_time.0 > height + 1 {
|
||||
return Err(APIError::APIMisuseError {
|
||||
err: "Funding transaction absolute timelock is non-final".to_owned()
|
||||
});
|
||||
|
|
@ -9054,7 +9055,7 @@ pub mod bench {
|
|||
// calls per node.
|
||||
let network = bitcoin::Network::Testnet;
|
||||
|
||||
let tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), blocks: Arc::new(Mutex::new(Vec::new()))};
|
||||
let tx_broadcaster = test_utils::TestBroadcaster::new(network);
|
||||
let fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) };
|
||||
let logger_a = test_utils::TestLogger::with_id("node a".to_owned());
|
||||
let scorer = Mutex::new(test_utils::TestScorer::new());
|
||||
|
|
|
|||
|
|
@ -230,6 +230,9 @@ fn do_connect_block<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, block: Block, sk
|
|||
#[cfg(feature = "std")] {
|
||||
eprintln!("Connecting block using Block Connection Style: {:?}", *node.connect_style.borrow());
|
||||
}
|
||||
// Update the block internally before handing it over to LDK, to ensure our assertions regarding
|
||||
// transaction broadcast are correct.
|
||||
node.blocks.lock().unwrap().push((block.clone(), height));
|
||||
if !skip_intermediaries {
|
||||
let txdata: Vec<_> = block.txdata.iter().enumerate().collect();
|
||||
match *node.connect_style.borrow() {
|
||||
|
|
@ -279,7 +282,6 @@ fn do_connect_block<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, block: Block, sk
|
|||
}
|
||||
call_claimable_balances(node);
|
||||
node.node.test_process_background_events();
|
||||
node.blocks.lock().unwrap().push((block, height));
|
||||
}
|
||||
|
||||
pub fn disconnect_blocks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, count: u32) {
|
||||
|
|
@ -2435,10 +2437,7 @@ pub fn fail_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path: &
|
|||
pub fn create_chanmon_cfgs(node_count: usize) -> Vec<TestChanMonCfg> {
|
||||
let mut chan_mon_cfgs = Vec::new();
|
||||
for i in 0..node_count {
|
||||
let tx_broadcaster = test_utils::TestBroadcaster {
|
||||
txn_broadcasted: Mutex::new(Vec::new()),
|
||||
blocks: Arc::new(Mutex::new(vec![(genesis_block(Network::Testnet), 0)])),
|
||||
};
|
||||
let tx_broadcaster = test_utils::TestBroadcaster::new(Network::Testnet);
|
||||
let fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) };
|
||||
let chain_source = test_utils::TestChainSource::new(Network::Testnet);
|
||||
let logger = test_utils::TestLogger::with_id(format!("node {}", i));
|
||||
|
|
|
|||
|
|
@ -1284,7 +1284,7 @@ fn test_duplicate_htlc_different_direction_onchain() {
|
|||
mine_transaction(&nodes[0], &remote_txn[0]);
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
|
||||
|
||||
let claim_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
|
||||
assert_eq!(claim_txn.len(), 3);
|
||||
|
|
@ -2438,7 +2438,7 @@ fn test_justice_tx_htlc_timeout() {
|
|||
test_txn_broadcast(&nodes[1], &chan_5, Some(revoked_local_txn[0].clone()), HTLCType::NONE);
|
||||
|
||||
mine_transaction(&nodes[0], &revoked_local_txn[0]);
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
|
||||
// Verify broadcast of revoked HTLC-timeout
|
||||
let node_txn = test_txn_broadcast(&nodes[0], &chan_5, Some(revoked_local_txn[0].clone()), HTLCType::TIMEOUT);
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
|
|
@ -2765,7 +2765,7 @@ fn test_htlc_on_chain_success() {
|
|||
// Verify that B's ChannelManager is able to extract preimage from HTLC Success tx and pass it backward
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[1].best_block_hash(), merkle_root: TxMerkleNode::all_zeros(), time: 42, bits: 42, nonce: 42};
|
||||
connect_block(&nodes[1], &Block { header, txdata: vec![commitment_tx[0].clone(), node_txn[0].clone(), node_txn[1].clone()]});
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
|
||||
{
|
||||
let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
|
||||
assert_eq!(added_monitors.len(), 1);
|
||||
|
|
@ -2894,7 +2894,7 @@ fn test_htlc_on_chain_success() {
|
|||
assert_eq!(commitment_spend.input.len(), 2);
|
||||
assert_eq!(commitment_spend.input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
|
||||
assert_eq!(commitment_spend.input[1].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
|
||||
assert_eq!(commitment_spend.lock_time.0, nodes[1].best_block_info().1 + 1);
|
||||
assert_eq!(commitment_spend.lock_time.0, nodes[1].best_block_info().1);
|
||||
assert!(commitment_spend.output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
|
||||
// We don't bother to check that B can claim the HTLC output on its commitment tx here as
|
||||
// we already checked the same situation with A.
|
||||
|
|
@ -2902,7 +2902,7 @@ fn test_htlc_on_chain_success() {
|
|||
// Verify that A's ChannelManager is able to extract preimage from preimage tx and generate PaymentSent
|
||||
let mut header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[0].best_block_hash(), merkle_root: TxMerkleNode::all_zeros(), time: 42, bits: 42, nonce: 42};
|
||||
connect_block(&nodes[0], &Block { header, txdata: vec![node_a_commitment_tx[0].clone(), commitment_spend.clone()] });
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV + MIN_CLTV_EXPIRY_DELTA as u32 - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV + MIN_CLTV_EXPIRY_DELTA as u32); // Confirm blocks until the HTLC expires
|
||||
check_closed_broadcast!(nodes[0], true);
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
let events = nodes[0].node.get_and_clear_pending_events();
|
||||
|
|
@ -3024,7 +3024,7 @@ fn do_test_htlc_on_chain_timeout(connect_style: ConnectStyle) {
|
|||
check_spends!(commitment_tx[0], chan_1.3);
|
||||
|
||||
mine_transaction(&nodes[0], &commitment_tx[0]);
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV + MIN_CLTV_EXPIRY_DELTA as u32 - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV + MIN_CLTV_EXPIRY_DELTA as u32); // Confirm blocks until the HTLC expires
|
||||
|
||||
check_closed_broadcast!(nodes[0], true);
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
|
|
@ -4446,7 +4446,7 @@ fn test_static_spendable_outputs_timeout_tx() {
|
|||
MessageSendEvent::BroadcastChannelUpdate { .. } => {},
|
||||
_ => panic!("Unexpected event"),
|
||||
}
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
|
||||
|
||||
// Check B's monitor was able to send back output descriptor event for timeout tx on A's commitment tx
|
||||
let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
|
||||
|
|
@ -4524,7 +4524,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
|
|||
check_closed_broadcast!(nodes[0], true);
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
|
||||
|
||||
let revoked_htlc_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
|
||||
assert_eq!(revoked_htlc_txn.len(), 1);
|
||||
|
|
@ -4756,7 +4756,7 @@ fn test_onchain_to_onchain_claim() {
|
|||
check_spends!(b_txn[0], commitment_tx[0]);
|
||||
assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
|
||||
assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
|
||||
assert_eq!(b_txn[0].lock_time.0, nodes[1].best_block_info().1 + 1); // Success tx
|
||||
assert_eq!(b_txn[0].lock_time.0, nodes[1].best_block_info().1); // Success tx
|
||||
|
||||
check_closed_broadcast!(nodes[1], true);
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
|
|
@ -4807,7 +4807,7 @@ fn test_duplicate_payment_hash_one_failure_one_success() {
|
|||
check_closed_broadcast!(nodes[1], true);
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV - 40 + MIN_CLTV_EXPIRY_DELTA as u32 - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV - 40 + MIN_CLTV_EXPIRY_DELTA as u32); // Confirm blocks until the HTLC expires
|
||||
|
||||
let htlc_timeout_tx;
|
||||
{ // Extract one of the two HTLC-Timeout transaction
|
||||
|
|
@ -5287,7 +5287,7 @@ fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() {
|
|||
check_closed_broadcast!(nodes[0], true);
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
|
||||
|
||||
let htlc_timeout = {
|
||||
let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
|
||||
|
|
@ -5370,7 +5370,7 @@ fn test_key_derivation_params() {
|
|||
|
||||
// Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
|
||||
mine_transaction(&nodes[0], &local_txn_1[0]);
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
|
||||
check_closed_broadcast!(nodes[0], true);
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
|
||||
|
|
@ -6927,7 +6927,7 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
|
|||
check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
|
||||
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
|
||||
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
|
||||
timeout_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().drain(..)
|
||||
.filter(|tx| tx.input[0].previous_output.txid == bs_commitment_tx[0].txid()).collect();
|
||||
check_spends!(timeout_tx[0], bs_commitment_tx[0]);
|
||||
|
|
@ -6938,7 +6938,7 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
|
|||
if !revoked {
|
||||
assert_eq!(timeout_tx[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
|
||||
} else {
|
||||
assert_eq!(timeout_tx[0].lock_time.0, 12);
|
||||
assert_eq!(timeout_tx[0].lock_time.0, 11);
|
||||
}
|
||||
// We fail non-dust-HTLC 2 by broadcast of local timeout/revocation-claim tx
|
||||
mine_transaction(&nodes[0], &timeout_tx[0]);
|
||||
|
|
@ -7318,7 +7318,7 @@ fn test_bump_penalty_txn_on_revoked_htlcs() {
|
|||
check_closed_broadcast!(nodes[1], true);
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed);
|
||||
connect_blocks(&nodes[1], 49); // Confirm blocks until the HTLC expires (note CLTV was explicitly 50 above)
|
||||
connect_blocks(&nodes[1], 50); // Confirm blocks until the HTLC expires (note CLTV was explicitly 50 above)
|
||||
|
||||
let revoked_htlc_txn = {
|
||||
let txn = nodes[1].tx_broadcaster.unique_txn_broadcast();
|
||||
|
|
@ -7464,7 +7464,7 @@ fn test_bump_penalty_txn_on_remote_commitment() {
|
|||
expect_payment_claimed!(nodes[1], payment_hash, 3_000_000);
|
||||
mine_transaction(&nodes[1], &remote_txn[0]);
|
||||
check_added_monitors!(nodes[1], 2);
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
|
||||
|
||||
// One or more claim tx should have been broadcast, check it
|
||||
let timeout;
|
||||
|
|
@ -8434,7 +8434,7 @@ fn test_update_err_monitor_lockdown() {
|
|||
let block = Block { header, txdata: vec![] };
|
||||
// Make the tx_broadcaster aware of enough blocks that it doesn't think we're violating
|
||||
// transaction lock time requirements here.
|
||||
chanmon_cfgs[0].tx_broadcaster.blocks.lock().unwrap().resize(200, (block.clone(), 0));
|
||||
chanmon_cfgs[0].tx_broadcaster.blocks.lock().unwrap().resize(200, (block.clone(), 200));
|
||||
watchtower.chain_monitor.block_connected(&block, 200);
|
||||
|
||||
// Try to update ChannelMonitor
|
||||
|
|
@ -8486,6 +8486,9 @@ fn test_concurrent_monitor_claim() {
|
|||
let chain_source = test_utils::TestChainSource::new(Network::Testnet);
|
||||
let logger = test_utils::TestLogger::with_id(format!("node {}", "Alice"));
|
||||
let persister = test_utils::TestPersister::new();
|
||||
let alice_broadcaster = test_utils::TestBroadcaster::with_blocks(
|
||||
Arc::new(Mutex::new(nodes[0].blocks.lock().unwrap().clone())),
|
||||
);
|
||||
let watchtower_alice = {
|
||||
let new_monitor = {
|
||||
let monitor = nodes[0].chain_monitor.chain_monitor.get_monitor(outpoint).unwrap();
|
||||
|
|
@ -8494,20 +8497,21 @@ fn test_concurrent_monitor_claim() {
|
|||
assert!(new_monitor == *monitor);
|
||||
new_monitor
|
||||
};
|
||||
let watchtower = test_utils::TestChainMonitor::new(Some(&chain_source), &chanmon_cfgs[0].tx_broadcaster, &logger, &chanmon_cfgs[0].fee_estimator, &persister, &node_cfgs[0].keys_manager);
|
||||
let watchtower = test_utils::TestChainMonitor::new(Some(&chain_source), &alice_broadcaster, &logger, &chanmon_cfgs[0].fee_estimator, &persister, &node_cfgs[0].keys_manager);
|
||||
assert_eq!(watchtower.watch_channel(outpoint, new_monitor), ChannelMonitorUpdateStatus::Completed);
|
||||
watchtower
|
||||
};
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: BlockHash::all_zeros(), merkle_root: TxMerkleNode::all_zeros(), time: 42, bits: 42, nonce: 42 };
|
||||
let block = Block { header, txdata: vec![] };
|
||||
// Make the tx_broadcaster aware of enough blocks that it doesn't think we're violating
|
||||
// transaction lock time requirements here.
|
||||
chanmon_cfgs[0].tx_broadcaster.blocks.lock().unwrap().resize((CHAN_CONFIRM_DEPTH + 1 + TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS) as usize, (block.clone(), 0));
|
||||
watchtower_alice.chain_monitor.block_connected(&block, CHAN_CONFIRM_DEPTH + 1 + TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS);
|
||||
// Make Alice aware of enough blocks that it doesn't think we're violating transaction lock time
|
||||
// requirements here.
|
||||
const HTLC_TIMEOUT_BROADCAST: u32 = CHAN_CONFIRM_DEPTH + 1 + TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS;
|
||||
alice_broadcaster.blocks.lock().unwrap().resize((HTLC_TIMEOUT_BROADCAST) as usize, (block.clone(), HTLC_TIMEOUT_BROADCAST));
|
||||
watchtower_alice.chain_monitor.block_connected(&block, HTLC_TIMEOUT_BROADCAST);
|
||||
|
||||
// Watchtower Alice should have broadcast a commitment/HTLC-timeout
|
||||
let alice_state = {
|
||||
let mut txn = chanmon_cfgs[0].tx_broadcaster.txn_broadcast();
|
||||
let mut txn = alice_broadcaster.txn_broadcast();
|
||||
assert_eq!(txn.len(), 2);
|
||||
txn.remove(0)
|
||||
};
|
||||
|
|
@ -8516,6 +8520,7 @@ fn test_concurrent_monitor_claim() {
|
|||
let chain_source = test_utils::TestChainSource::new(Network::Testnet);
|
||||
let logger = test_utils::TestLogger::with_id(format!("node {}", "Bob"));
|
||||
let persister = test_utils::TestPersister::new();
|
||||
let bob_broadcaster = test_utils::TestBroadcaster::with_blocks(Arc::clone(&alice_broadcaster.blocks));
|
||||
let watchtower_bob = {
|
||||
let new_monitor = {
|
||||
let monitor = nodes[0].chain_monitor.chain_monitor.get_monitor(outpoint).unwrap();
|
||||
|
|
@ -8524,12 +8529,12 @@ fn test_concurrent_monitor_claim() {
|
|||
assert!(new_monitor == *monitor);
|
||||
new_monitor
|
||||
};
|
||||
let watchtower = test_utils::TestChainMonitor::new(Some(&chain_source), &chanmon_cfgs[0].tx_broadcaster, &logger, &chanmon_cfgs[0].fee_estimator, &persister, &node_cfgs[0].keys_manager);
|
||||
let watchtower = test_utils::TestChainMonitor::new(Some(&chain_source), &bob_broadcaster, &logger, &chanmon_cfgs[0].fee_estimator, &persister, &node_cfgs[0].keys_manager);
|
||||
assert_eq!(watchtower.watch_channel(outpoint, new_monitor), ChannelMonitorUpdateStatus::Completed);
|
||||
watchtower
|
||||
};
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: BlockHash::all_zeros(), merkle_root: TxMerkleNode::all_zeros(), time: 42, bits: 42, nonce: 42 };
|
||||
watchtower_bob.chain_monitor.block_connected(&Block { header, txdata: vec![] }, CHAN_CONFIRM_DEPTH + TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS);
|
||||
watchtower_bob.chain_monitor.block_connected(&Block { header, txdata: vec![] }, HTLC_TIMEOUT_BROADCAST - 1);
|
||||
|
||||
// Route another payment to generate another update with still previous HTLC pending
|
||||
let (route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[1], nodes[0], 3000000);
|
||||
|
|
@ -8556,21 +8561,26 @@ fn test_concurrent_monitor_claim() {
|
|||
|
||||
//// Provide one more block to watchtower Bob, expect broadcast of commitment and HTLC-Timeout
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: BlockHash::all_zeros(), merkle_root: TxMerkleNode::all_zeros(), time: 42, bits: 42, nonce: 42 };
|
||||
watchtower_bob.chain_monitor.block_connected(&Block { header, txdata: vec![] }, CHAN_CONFIRM_DEPTH + 1 + TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS);
|
||||
watchtower_bob.chain_monitor.block_connected(&Block { header, txdata: vec![] }, HTLC_TIMEOUT_BROADCAST);
|
||||
|
||||
// Watchtower Bob should have broadcast a commitment/HTLC-timeout
|
||||
let bob_state_y;
|
||||
{
|
||||
let mut txn = chanmon_cfgs[0].tx_broadcaster.txn_broadcast();
|
||||
let mut txn = bob_broadcaster.txn_broadcast();
|
||||
assert_eq!(txn.len(), 2);
|
||||
bob_state_y = txn.remove(0);
|
||||
};
|
||||
|
||||
// We confirm Bob's state Y on Alice, she should broadcast a HTLC-timeout
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: BlockHash::all_zeros(), merkle_root: TxMerkleNode::all_zeros(), time: 42, bits: 42, nonce: 42 };
|
||||
watchtower_alice.chain_monitor.block_connected(&Block { header, txdata: vec![bob_state_y.clone()] }, CHAN_CONFIRM_DEPTH + 2 + TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS);
|
||||
let height = HTLC_TIMEOUT_BROADCAST + 1;
|
||||
connect_blocks(&nodes[0], height - nodes[0].best_block_info().1);
|
||||
check_closed_broadcast(&nodes[0], 1, true);
|
||||
check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, false);
|
||||
watchtower_alice.chain_monitor.block_connected(&Block { header, txdata: vec![bob_state_y.clone()] }, height);
|
||||
check_added_monitors(&nodes[0], 1);
|
||||
{
|
||||
let htlc_txn = chanmon_cfgs[0].tx_broadcaster.txn_broadcast();
|
||||
let htlc_txn = alice_broadcaster.txn_broadcast();
|
||||
assert_eq!(htlc_txn.len(), 2);
|
||||
check_spends!(htlc_txn[0], bob_state_y);
|
||||
// Alice doesn't clean up the old HTLC claim since it hasn't seen a conflicting spend for
|
||||
|
|
@ -8650,7 +8660,7 @@ fn test_htlc_no_detection() {
|
|||
check_closed_broadcast!(nodes[0], true);
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1);
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV);
|
||||
|
||||
let htlc_timeout = {
|
||||
let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
|
||||
|
|
@ -9826,8 +9836,8 @@ fn test_non_final_funding_tx() {
|
|||
assert_eq!(events.len(), 1);
|
||||
let mut tx = match events[0] {
|
||||
Event::FundingGenerationReady { ref channel_value_satoshis, ref output_script, .. } => {
|
||||
// Timelock the transaction _beyond_ the best client height + 2.
|
||||
Transaction { version: chan_id as i32, lock_time: PackedLockTime(best_height + 3), input: vec![input], output: vec![TxOut {
|
||||
// Timelock the transaction _beyond_ the best client height + 1.
|
||||
Transaction { version: chan_id as i32, lock_time: PackedLockTime(best_height + 2), input: vec![input], output: vec![TxOut {
|
||||
value: *channel_value_satoshis, script_pubkey: output_script.clone(),
|
||||
}]}
|
||||
},
|
||||
|
|
@ -9841,7 +9851,7 @@ fn test_non_final_funding_tx() {
|
|||
_ => panic!()
|
||||
}
|
||||
|
||||
// However, transaction should be accepted if it's in a +2 headroom from best block.
|
||||
// However, transaction should be accepted if it's in a +1 headroom from best block.
|
||||
tx.lock_time = PackedLockTime(tx.lock_time.0 - 1);
|
||||
assert!(nodes[0].node.funding_transaction_generated(&temp_channel_id, &nodes[1].node.get_our_node_id(), tx.clone()).is_ok());
|
||||
get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id());
|
||||
|
|
|
|||
|
|
@ -497,7 +497,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
|
|||
nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
|
||||
|
||||
// When the HTLC timeout output is spendable in the next block, A should broadcast it
|
||||
connect_blocks(&nodes[0], htlc_cltv_timeout - nodes[0].best_block_info().1 - 1);
|
||||
connect_blocks(&nodes[0], htlc_cltv_timeout - nodes[0].best_block_info().1);
|
||||
let a_broadcast_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
|
||||
assert_eq!(a_broadcast_txn.len(), 2);
|
||||
assert_eq!(a_broadcast_txn[0].input.len(), 1);
|
||||
|
|
@ -887,7 +887,7 @@ fn test_no_preimage_inbound_htlc_balances() {
|
|||
// HTLC has been spent, even after the HTLC expires. We'll also fail the inbound HTLC, but it
|
||||
// won't do anything as the channel is already closed.
|
||||
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1);
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV);
|
||||
let as_htlc_timeout_claim = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
|
||||
assert_eq!(as_htlc_timeout_claim.len(), 1);
|
||||
check_spends!(as_htlc_timeout_claim[0], as_txn[0]);
|
||||
|
|
@ -908,7 +908,7 @@ fn test_no_preimage_inbound_htlc_balances() {
|
|||
|
||||
// The next few blocks for B look the same as for A, though for the opposite HTLC
|
||||
nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV - (ANTI_REORG_DELAY - 1) - 1);
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV - (ANTI_REORG_DELAY - 1));
|
||||
expect_pending_htlcs_forwardable_conditions!(nodes[1],
|
||||
[HTLCDestination::FailedPayment { payment_hash: to_b_failed_payment_hash }]);
|
||||
let bs_htlc_timeout_claim = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
|
||||
|
|
@ -1734,7 +1734,7 @@ fn do_test_restored_packages_retry(check_old_monitor_retries_after_upgrade: bool
|
|||
mine_transaction(&nodes[0], &commitment_tx);
|
||||
|
||||
// Connect blocks until the HTLC's expiration is met, expecting a transaction broadcast.
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1);
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV);
|
||||
let htlc_timeout_tx = {
|
||||
let mut txn = nodes[0].tx_broadcaster.txn_broadcast();
|
||||
assert_eq!(txn.len(), 1);
|
||||
|
|
@ -1885,7 +1885,7 @@ fn do_test_monitor_rebroadcast_pending_claims(anchors: bool) {
|
|||
};
|
||||
|
||||
// Connect blocks up to one before the HTLC expires. This should not result in a claim/retry.
|
||||
connect_blocks(&nodes[0], htlc_expiry - nodes[0].best_block_info().1 - 2);
|
||||
connect_blocks(&nodes[0], htlc_expiry - nodes[0].best_block_info().1 - 1);
|
||||
check_htlc_retry(false, false);
|
||||
|
||||
// Connect one more block, producing our first claim.
|
||||
|
|
|
|||
|
|
@ -562,8 +562,8 @@ fn do_test_completed_payment_not_retryable_on_reload(use_dust: bool) {
|
|||
mine_transaction(&nodes[0], &bs_commitment_tx[0]);
|
||||
mine_transaction(&nodes[1], &bs_commitment_tx[0]);
|
||||
if !use_dust {
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1 + (MIN_CLTV_EXPIRY_DELTA as u32));
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV - 1 + (MIN_CLTV_EXPIRY_DELTA as u32));
|
||||
connect_blocks(&nodes[0], TEST_FINAL_CLTV + (MIN_CLTV_EXPIRY_DELTA as u32));
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV + (MIN_CLTV_EXPIRY_DELTA as u32));
|
||||
let as_htlc_timeout = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
|
||||
check_spends!(as_htlc_timeout[0], bs_commitment_tx[0]);
|
||||
assert_eq!(as_htlc_timeout.len(), 1);
|
||||
|
|
|
|||
|
|
@ -948,7 +948,7 @@ fn do_forwarded_payment_no_manager_persistence(use_cs_commitment: bool, claim_ht
|
|||
if claim_htlc {
|
||||
confirm_transaction(&nodes[1], &cs_commitment_tx[1]);
|
||||
} else {
|
||||
connect_blocks(&nodes[1], htlc_expiry - nodes[1].best_block_info().1);
|
||||
connect_blocks(&nodes[1], htlc_expiry - nodes[1].best_block_info().1 + 1);
|
||||
let bs_htlc_timeout_tx = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
|
||||
assert_eq!(bs_htlc_timeout_tx.len(), 1);
|
||||
confirm_transaction(&nodes[1], &bs_htlc_timeout_tx[0]);
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) {
|
|||
|
||||
// Give node 1 node 2's commitment transaction and get its response (timing the HTLC out)
|
||||
mine_transaction(&nodes[1], &node_2_commitment_txn[0]);
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires
|
||||
connect_blocks(&nodes[1], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
|
||||
let node_1_commitment_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
|
||||
assert_eq!(node_1_commitment_txn.len(), 1); // ChannelMonitor: 1 offered HTLC-Timeout
|
||||
check_spends!(node_1_commitment_txn[0], node_2_commitment_txn[0]);
|
||||
|
|
|
|||
|
|
@ -308,8 +308,15 @@ pub struct TestBroadcaster {
|
|||
}
|
||||
|
||||
impl TestBroadcaster {
|
||||
pub fn new(blocks: Arc<Mutex<Vec<(Block, u32)>>>) -> TestBroadcaster {
|
||||
TestBroadcaster { txn_broadcasted: Mutex::new(Vec::new()), blocks }
|
||||
pub fn new(network: Network) -> Self {
|
||||
Self {
|
||||
txn_broadcasted: Mutex::new(Vec::new()),
|
||||
blocks: Arc::new(Mutex::new(vec![(genesis_block(network), 0)])),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn with_blocks(blocks: Arc<Mutex<Vec<(Block, u32)>>>) -> Self {
|
||||
Self { txn_broadcasted: Mutex::new(Vec::new()), blocks }
|
||||
}
|
||||
|
||||
pub fn txn_broadcast(&self) -> Vec<Transaction> {
|
||||
|
|
@ -328,7 +335,7 @@ impl chaininterface::BroadcasterInterface for TestBroadcaster {
|
|||
fn broadcast_transaction(&self, tx: &Transaction) {
|
||||
let lock_time = tx.lock_time.0;
|
||||
assert!(lock_time < 1_500_000_000);
|
||||
if lock_time > self.blocks.lock().unwrap().len() as u32 + 1 && lock_time < 500_000_000 {
|
||||
if bitcoin::LockTime::from(tx.lock_time).is_block_height() && lock_time > self.blocks.lock().unwrap().last().unwrap().1 {
|
||||
for inp in tx.input.iter() {
|
||||
if inp.sequence != Sequence::MAX {
|
||||
panic!("We should never broadcast a transaction before its locktime ({})!", tx.lock_time);
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue