Startup sync can re-confirm a transaction without first unconfirming it #1076

use std::future::Future;

use bitcoin::block::{Block, Header, Version};
use bitcoin::constants::genesis_block;
use bitcoin::hash_types::{BlockHash, TxMerkleNode};
use bitcoin::hashes::Hash;
use bitcoin::{
	absolute::LockTime, Amount, Network, OutPoint, ScriptBuf, Sequence, Transaction, TxIn, TxOut,
	Witness,
};
use lightning::chain::{BlockLocator, Listen};
use lightning::ln::functional_test_utils::{
	create_channel_manual_funding, create_chanmon_cfgs, create_network, create_node_cfgs,
	create_node_chanmgrs, test_legacy_channel_config,
};
use lightning::util::test_utils::TestChainMonitor;
use lightning_block_sync::init::synchronize_listeners;
use lightning_block_sync::{BlockData, BlockHeaderData, BlockSource, BlockSourceError};

struct TestBlockSource {
	blocks: Vec<Block>,
}

impl TestBlockSource {
	fn block_header_data(&self, height: usize) -> BlockHeaderData {
		let mut chainwork = self.blocks[0].header.work();
		for block in self.blocks.iter().take(height + 1).skip(1) {
			chainwork = chainwork + block.header.work();
		}
		BlockHeaderData { header: self.blocks[height].header, height: height as u32, chainwork }
	}
}

impl BlockSource for TestBlockSource {
	fn get_header<'a>(
		&'a self, header_hash: &'a BlockHash, _height_hint: Option<u32>,
	) -> impl Future<Output = Result<BlockHeaderData, BlockSourceError>> + Send + 'a {
		async move {
			self.blocks
				.iter()
				.enumerate()
				.find(|(_, block)| block.block_hash() == *header_hash)
				.map(|(height, _)| self.block_header_data(height))
				.ok_or_else(|| BlockSourceError::transient("header not found"))
		}
	}

	fn get_block<'a>(
		&'a self, header_hash: &'a BlockHash,
	) -> impl Future<Output = Result<BlockData, BlockSourceError>> + Send + 'a {
		async move {
			self.blocks
				.iter()
				.find(|block| block.block_hash() == *header_hash)
				.cloned()
				.map(BlockData::FullBlock)
				.ok_or_else(|| BlockSourceError::transient("block not found"))
		}
	}

	fn get_best_block<'a>(
		&'a self,
	) -> impl Future<Output = Result<(BlockHash, Option<u32>), BlockSourceError>> + Send + 'a {
		async move {
			let height = self.blocks.len().checked_sub(1).expect("test chain has a genesis block");
			Ok((self.blocks[height].block_hash(), Some(height as u32)))
		}
	}
}

fn mine_block(prev_blockhash: BlockHash, time: u32, transactions: Vec<Transaction>) -> Block {
	let mut coinbase_witness = Witness::new();
	let witness_reserved_value = [0; 32];
	coinbase_witness.push(witness_reserved_value);
	let coinbase = Transaction {
		version: bitcoin::transaction::Version::TWO,
		lock_time: LockTime::ZERO,
		input: vec![TxIn {
			previous_output: OutPoint::null(),
			script_sig: ScriptBuf::new(),
			sequence: Sequence::MAX,
			witness: coinbase_witness,
		}],
		output: Vec::new(),
	};
	let mut txdata = vec![coinbase];
	txdata.extend(transactions);
	let mut block = Block {
		header: Header {
			version: Version::NO_SOFT_FORK_SIGNALLING,
			prev_blockhash,
			merkle_root: TxMerkleNode::all_zeros(),
			time,
			bits: bitcoin::Target::from_be_bytes([0xff; 32]).to_compact_lossy(),
			nonce: 0,
		},
		txdata,
	};
	let witness_root = block.witness_root().expect("test block has transactions");
	let witness_commitment = Block::compute_witness_commitment(&witness_root, &witness_reserved_value);
	let mut witness_commitment_script = vec![0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed];
	witness_commitment_script.extend(witness_commitment.to_byte_array());
	block.txdata[0].output.push(TxOut {
		value: Amount::ZERO,
		script_pubkey: ScriptBuf::from_bytes(witness_commitment_script),
	});
	block.header.merkle_root = block.compute_merkle_root().expect("test block has a transaction");
	while block.header.validate_pow(block.header.target()).is_err() {
		block.header.nonce = block.header.nonce.wrapping_add(1);
	}
	block
}

#[tokio::test]
#[should_panic(expected = "was already confirmed and is being re-confirmed in a different block")]
async fn initial_sync_reconfirms_transaction_in_heterogeneous_channel_monitors() {
	let chanmon_cfgs = create_chanmon_cfgs(3);
	let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
	let legacy_config = test_legacy_channel_config();
	let node_chanmgrs = create_node_chanmgrs(
		3,
		&node_cfgs,
		&[Some(legacy_config.clone()), Some(legacy_config.clone()), Some(legacy_config)],
	);
	let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
	let (channel_id_a, _, _) =
		create_channel_manual_funding(&nodes, 0, 1, 100_000, 10_001, true);
	let (channel_id_b, _, _) =
		create_channel_manual_funding(&nodes, 0, 2, 100_000, 10_001, true);

	let node_0_id = nodes[0].node.get_our_node_id();
	nodes[1]
		.node
		.force_close_broadcasting_latest_txn(&channel_id_a, &node_0_id, "test".to_owned())
		.unwrap();
	let mut broadcasts = nodes[1].tx_broadcaster.txn_broadcast();
	assert_eq!(broadcasts.len(), 1);
	let commitment_tx = broadcasts.pop().unwrap();

	let monitor_at_fork = nodes[0].chain_monitor.chain_monitor.remove_monitor(&channel_id_b);
	let old_block = mine_block(nodes[0].best_block_hash(), 1, vec![commitment_tx.clone()]);
	nodes[0].chain_monitor.chain_monitor.block_connected(&old_block, 1);
	let monitor_with_old_confirmation =
		nodes[0].chain_monitor.chain_monitor.remove_monitor(&channel_id_a);

	let restarted_chain_monitor = TestChainMonitor::new(
		Some(&chanmon_cfgs[0].chain_source),
		&chanmon_cfgs[0].tx_broadcaster,
		&chanmon_cfgs[0].logger,
		&chanmon_cfgs[0].fee_estimator,
		&chanmon_cfgs[0].persister,
		&chanmon_cfgs[0].keys_manager,
	);
	restarted_chain_monitor
		.load_existing_monitor(channel_id_a, monitor_with_old_confirmation)
		.unwrap();
	restarted_chain_monitor.load_existing_monitor(channel_id_b, monitor_at_fork).unwrap();

	let worst_monitor_best_block = restarted_chain_monitor
		.chain_monitor
		.list_monitors()
		.iter()
		.flat_map(|channel_id| restarted_chain_monitor.chain_monitor.get_monitor(*channel_id))
		.map(|monitor| monitor.current_best_block())
		.min_by_key(|best_block| best_block.height)
		.unwrap();
	assert_eq!(worst_monitor_best_block, BlockLocator::from_network(Network::Testnet));

	let replacement_block =
		mine_block(genesis_block(Network::Testnet).block_hash(), 2, vec![commitment_tx]);
	let chain = TestBlockSource { blocks: vec![genesis_block(Network::Testnet), replacement_block] };
	synchronize_listeners(
		&chain,
		Network::Testnet,
		vec![(
			worst_monitor_best_block,
			&restarted_chain_monitor.chain_monitor as &(dyn Listen + Send + Sync),
		)],
	)
	.await
	.unwrap();
}