WIP DROPME

We're failing fee calculation because we're missing information on the counterparty's
change output.

Author: tnull

src/event.rs

@@ -1387,6 +1387,7 @@ where
 				former_temporary_channel_id,
 				counterparty_node_id,
 				funding_txo,
+				funding_redeem_script,
 				..
 			} => {
 				log_info!(
@@ -1396,6 +1397,24 @@ where
 					counterparty_node_id,
 				);
 
+				if let Some(channel_details) = self
+					.channel_manager
+					.list_channels()
+					.iter()
+					.find(|c| c.user_channel_id == user_channel_id)
+				{
+					let channel_value_satoshis = channel_details.channel_value_satoshis;
+					eprintln!("REDEEM: {:?}", funding_redeem_script);
+					if let Some(redeem_script) = funding_redeem_script {
+						let funding_output = bitcoin::TxOut {
+							value: bitcoin::Amount::from_sat(channel_value_satoshis),
+							script_pubkey: redeem_script.to_p2wsh(),
+						};
+						eprintln!("FUNDING_TXO: {:?}", funding_txo);
+						let res = self.wallet.insert_txo(funding_txo, funding_output);
+						eprintln!("RES: {:?}", res);
+					}
+				}
 				let event = Event::ChannelPending {
 					channel_id,
 					user_channel_id: UserChannelId(user_channel_id),

src/wallet/mod.rs

@@ -240,6 +240,7 @@ impl Wallet {
 		for event in events {
 			match event {
 				WalletEvent::TxConfirmed { txid, tx, block_time, .. } => {
+					eprintln!("TX_CONFIRMED: {}", txid);
 					let cur_height = locked_wallet.latest_checkpoint().height();
 					let confirmation_height = block_time.block_id.height;
 					let payment_status = if cur_height >= confirmation_height + ANTI_REORG_DELAY - 1
@@ -275,6 +276,7 @@ impl Wallet {
 					self.pending_payment_store.insert_or_update(pending_payment)?;
 				},
 				WalletEvent::ChainTipChanged { new_tip, .. } => {
+					eprint!(".");
 					// Get all payments that are Pending with Confirmed status
 					let pending_payments: Vec<PendingPaymentDetails> =
 						self.pending_payment_store.list_filter(|p| {
@@ -304,6 +306,7 @@ impl Wallet {
 					}
 				},
 				WalletEvent::TxUnconfirmed { txid, tx, old_block_time: None } => {
+					eprintln!("TX_UNCONFIRMED: {}", txid);
 					let payment_id = self
 						.find_payment_by_txid(txid)
 						.unwrap_or_else(|| PaymentId(txid.to_byte_array()));
@@ -322,6 +325,7 @@ impl Wallet {
 					self.pending_payment_store.insert_or_update(pending_payment)?;
 				},
 				WalletEvent::TxReplaced { txid, conflicts, tx, .. } => {
+					eprintln!("TX_REPLACED: {}", txid);
 					let payment_id = self
 						.find_payment_by_txid(txid)
 						.unwrap_or_else(|| PaymentId(txid.to_byte_array()));
@@ -344,6 +348,7 @@ impl Wallet {
 					self.pending_payment_store.insert_or_update(pending_payment_details)?;
 				},
 				WalletEvent::TxDropped { txid, tx } => {
+					eprintln!("TX_DROPPED: {}", txid);
 					let payment_id = self
 						.find_payment_by_txid(txid)
 						.unwrap_or_else(|| PaymentId(txid.to_byte_array()));
@@ -404,17 +409,27 @@ impl Wallet {
 			},
 		}
 
+		let tx = psbt.extract_tx().map_err(|e| {
+			log_error!(self.logger, "Failed to extract transaction: {}", e);
+			e
+		})?;
+
+		eprintln!("FUNDING: {}", tx.txid());
+		log_error!(self.logger, "FUNDING: {}", tx.txid());
+
+		let now = std::time::SystemTime::now()
+			.duration_since(std::time::SystemTime::UNIX_EPOCH)
+			.unwrap()
+			.as_secs();
+		let unconfirmed_txs = vec![(Arc::new(tx.clone()), now)];
+		locked_wallet.apply_unconfirmed_txs(unconfirmed_txs);
+
 		let mut locked_persister = self.persister.lock().unwrap();
 		locked_wallet.persist(&mut locked_persister).map_err(|e| {
 			log_error!(self.logger, "Failed to persist wallet: {}", e);
 			Error::PersistenceFailed
 		})?;
 
-		let tx = psbt.extract_tx().map_err(|e| {
-			log_error!(self.logger, "Failed to extract transaction: {}", e);
-			e
-		})?;
-
 		Ok(tx)
 	}
 
@@ -956,7 +971,14 @@ impl Wallet {
 
 		let kind = PaymentKind::Onchain { txid, status: confirmation_status };
 
-		let fee = locked_wallet.calculate_fee(tx).unwrap_or(Amount::ZERO);
+		let fee = locked_wallet.calculate_fee(tx);
+		for out in &tx.input {
+			eprintln!("PREV_OUT: {:?}", out.previous_output);
+			log_error!(self.logger, "PREV_OUT: {:?}", out.previous_output);
+		}
+		eprintln!("FEE RES: {:?}", fee);
+		log_error!(self.logger, "FEE RES: {:?}", fee);
+		let fee = fee.unwrap_or(Amount::ZERO);
 		let (sent, received) = locked_wallet.sent_and_received(tx);
 		let fee_sat = fee.to_sat();
 

tests/common/mod.rs

@@ -607,6 +607,7 @@ pub(crate) async fn distribute_funds_unconfirmed<E: ElectrumApi>(
 		.unwrap()
 		.parse()
 		.unwrap();
+	eprintln!("DIST: {}", txid);
 
 	wait_for_tx(electrs, txid).await;
 

tests/integration_tests_rust.rs

@@ -293,7 +293,8 @@ async fn start_stop_reinit() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn onchain_send_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let chain_source = random_chain_source(&bitcoind, &electrsd);
+	//let chain_source = random_chain_source(&bitcoind, &electrsd);
+	let chain_source = TestChainSource::BitcoindRpcSync(&bitcoind);
 	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
 
 	let addr_a = node_a.onchain_payment().new_address().unwrap();
@@ -381,6 +382,7 @@ async fn onchain_send_receive() {
 	let txid =
 		node_b.onchain_payment().send_to_address(&addr_a, amount_to_send_sats, None).unwrap();
 	wait_for_tx(&electrsd.client, txid).await;
+	//generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 1).await;
 	node_a.sync_wallets().unwrap();
 	node_b.sync_wallets().unwrap();
 
@@ -407,7 +409,7 @@ async fn onchain_send_receive() {
 	assert_eq!(payment_a.amount_msat, payment_b.amount_msat);
 	assert_eq!(payment_a.fee_paid_msat, payment_b.fee_paid_msat);
 
-	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 5).await;
 	node_a.sync_wallets().unwrap();
 	node_b.sync_wallets().unwrap();