@@ -3242,6 +3242,23 @@ macro_rules! convert_channel_err {
3242
3242
},
3243
3243
}
3244
3244
};
3245
+ ($self: ident, $peer_state: expr, $shutdown_result: expr, $funded_channel: expr, $channel_id: expr, COOP_CLOSED) => { {
3246
+ let reason = ChannelError::Close(("Coop Closed".to_owned(), $shutdown_result.closure_reason.clone()));
3247
+ let do_close = |_| {
3248
+ (
3249
+ $shutdown_result,
3250
+ $self.get_channel_update_for_broadcast(&$funded_channel).ok(),
3251
+ )
3252
+ };
3253
+ let mut locked_close = |shutdown_res_mut: &mut ShutdownResult, funded_channel: &mut FundedChannel<_>| {
3254
+ locked_close_channel!($self, $peer_state, funded_channel, shutdown_res_mut, FUNDED);
3255
+ };
3256
+ let (close, mut err) =
3257
+ convert_channel_err!($self, $peer_state, reason, $funded_channel, do_close, locked_close, $channel_id, _internal);
3258
+ err.dont_send_error_message();
3259
+ debug_assert!(close);
3260
+ (close, err)
3261
+ } };
3245
3262
($self: ident, $peer_state: expr, $err: expr, $funded_channel: expr, $channel_id: expr, FUNDED_CHANNEL) => { {
3246
3263
let mut do_close = |reason| {
3247
3264
(
@@ -9283,13 +9300,14 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
9283
9300
msg.channel_id,
9284
9301
)
9285
9302
})?;
9286
- let (tx, chan_option, shutdown_result) = {
9303
+ let logger;
9304
+ let tx_err: Option<(_, Result<Infallible, _>)> = {
9287
9305
let mut peer_state_lock = peer_state_mutex.lock().unwrap();
9288
9306
let peer_state = &mut *peer_state_lock;
9289
9307
match peer_state.channel_by_id.entry(msg.channel_id.clone()) {
9290
9308
hash_map::Entry::Occupied(mut chan_entry) => {
9291
9309
if let Some(chan) = chan_entry.get_mut().as_funded_mut() {
9292
- let logger = WithChannelContext::from(&self.logger, &chan.context, None);
9310
+ logger = WithChannelContext::from(&self.logger, &chan.context, None);
9293
9311
let res = chan.closing_signed(&self.fee_estimator, &msg, &&logger);
9294
9312
let (closing_signed, tx_shutdown_result) =
9295
9313
try_channel_entry!(self, peer_state, res, chan_entry);
@@ -9300,16 +9318,17 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
9300
9318
msg,
9301
9319
});
9302
9320
}
9303
- if let Some((tx, mut close_res)) = tx_shutdown_result {
9321
+ if let Some((tx, close_res)) = tx_shutdown_result {
9304
9322
// We're done with this channel, we've got a signed closing transaction and
9305
9323
// will send the closing_signed back to the remote peer upon return. This
9306
9324
// also implies there are no pending HTLCs left on the channel, so we can
9307
9325
// fully delete it from tracking (the channel monitor is still around to
9308
9326
// watch for old state broadcasts)!
9309
- locked_close_channel!(self, peer_state, chan, close_res, FUNDED);
9310
- (Some(tx), Some(chan_entry.remove()), Some(close_res))
9327
+ let (_, err) = convert_channel_err!(self, peer_state, close_res, chan, &msg.channel_id, COOP_CLOSED);
9328
+ chan_entry.remove();
9329
+ Some((tx, Err(err)))
9311
9330
} else {
9312
- ( None, None, None)
9331
+ None
9313
9332
}
9314
9333
} else {
9315
9334
return try_channel_entry!(self, peer_state, Err(ChannelError::close(
@@ -9319,26 +9338,15 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
9319
9338
hash_map::Entry::Vacant(_) => return Err(MsgHandleErrInternal::send_err_msg_no_close(format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", counterparty_node_id), msg.channel_id))
9320
9339
}
9321
9340
};
9322
- if let Some(broadcast_tx) = tx {
9323
- let channel_id = chan_option.as_ref().map(|channel| channel.context().channel_id());
9341
+ mem::drop(per_peer_state);
9342
+ if let Some((broadcast_tx, err)) = tx_err {
9324
9343
log_info!(
9325
- WithContext::from(&self. logger, Some(*counterparty_node_id), channel_id, None) ,
9344
+ logger,
9326
9345
"Broadcasting {}",
9327
9346
log_tx!(broadcast_tx)
9328
9347
);
9329
9348
self.tx_broadcaster.broadcast_transactions(&[&broadcast_tx]);
9330
- }
9331
- if let Some(chan) = chan_option.as_ref().and_then(Channel::as_funded) {
9332
- if let Ok(update) = self.get_channel_update_for_broadcast(chan) {
9333
- let mut pending_broadcast_messages =
9334
- self.pending_broadcast_messages.lock().unwrap();
9335
- pending_broadcast_messages
9336
- .push(MessageSendEvent::BroadcastChannelUpdate { msg: update });
9337
- }
9338
- }
9339
- mem::drop(per_peer_state);
9340
- if let Some(shutdown_result) = shutdown_result {
9341
- self.finish_close_channel(shutdown_result);
9349
+ let _ = handle_error!(self, err, *counterparty_node_id);
9342
9350
}
9343
9351
Ok(())
9344
9352
}
@@ -10433,12 +10441,6 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
10433
10441
if let Some(broadcast_tx) = msgs.signed_closing_tx {
10434
10442
log_info!(logger, "Broadcasting closing tx {}", log_tx!(broadcast_tx));
10435
10443
self.tx_broadcaster.broadcast_transactions(&[&broadcast_tx]);
10436
-
10437
- if let Ok(update) = self.get_channel_update_for_broadcast(&funded_chan) {
10438
- pending_msg_events.push(MessageSendEvent::BroadcastChannelUpdate {
10439
- msg: update
10440
- });
10441
- }
10442
10444
}
10443
10445
} else {
10444
10446
// We don't know how to handle a channel_ready or signed_closing_tx for a
@@ -10452,40 +10454,45 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
10452
10454
}
10453
10455
};
10454
10456
10455
- let mut shutdown_results = Vec::new();
10457
+ let mut shutdown_results: Vec<(Result<Infallible, _>, _)> = Vec::new();
10456
10458
let per_peer_state = self.per_peer_state.read().unwrap();
10457
10459
let per_peer_state_iter = per_peer_state.iter().filter(|(cp_id, _)| {
10458
10460
if let Some((counterparty_node_id, _)) = channel_opt {
10459
10461
**cp_id == counterparty_node_id
10460
10462
} else { true }
10461
10463
});
10462
- for (_cp_id , peer_state_mutex) in per_peer_state_iter {
10464
+ for (cp_id , peer_state_mutex) in per_peer_state_iter {
10463
10465
let mut peer_state_lock = peer_state_mutex.lock().unwrap();
10464
10466
let peer_state = &mut *peer_state_lock;
10465
10467
peer_state.channel_by_id.retain(|_, chan| {
10466
10468
let shutdown_result = match channel_opt {
10467
10469
Some((_, channel_id)) if chan.context().channel_id() != channel_id => None,
10468
10470
_ => unblock_chan(chan, &mut peer_state.pending_msg_events),
10469
10471
};
10470
- if let Some(mut shutdown_result ) = shutdown_result {
10472
+ if let Some(shutdown_res ) = shutdown_result {
10471
10473
let context = chan.context();
10472
10474
let logger = WithChannelContext::from(&self.logger, context, None);
10473
- log_trace!(logger, "Removing channel {} now that the signer is unblocked", context.channel_id());
10474
- if let Some(funded_channel) = chan.as_funded_mut() {
10475
- locked_close_channel!(self, peer_state, funded_channel, shutdown_result, FUNDED);
10475
+ let chan_id = context.channel_id();
10476
+ log_trace!(logger, "Removing channel {} now that the signer is unblocked", chan_id);
10477
+ let (remove, err) = if let Some(funded_channel) = chan.as_funded_mut() {
10478
+ convert_channel_err!(self, peer_state, shutdown_res, funded_channel, &chan_id, COOP_CLOSED)
10476
10479
} else {
10477
- locked_close_channel!(self, chan.context(), UNFUNDED);
10478
- }
10479
- shutdown_results.push(shutdown_result);
10480
+ debug_assert!(false);
10481
+ let reason = shutdown_res.closure_reason.clone();
10482
+ let err = ChannelError::Close((reason.to_string(), reason));
10483
+ convert_channel_err!(self, peer_state, err, chan, &chan_id, UNFUNDED_CHANNEL)
10484
+ };
10485
+ debug_assert!(remove);
10486
+ shutdown_results.push((Err(err), *cp_id));
10480
10487
false
10481
10488
} else {
10482
10489
true
10483
10490
}
10484
10491
});
10485
10492
}
10486
10493
drop(per_peer_state);
10487
- for shutdown_result in shutdown_results.drain(..) {
10488
- self.finish_close_channel(shutdown_result );
10494
+ for (err, counterparty_node_id) in shutdown_results {
10495
+ let _ = handle_error!(self, err, counterparty_node_id );
10489
10496
}
10490
10497
}
10491
10498
@@ -10496,11 +10503,10 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
10496
10503
fn maybe_generate_initial_closing_signed(&self) -> bool {
10497
10504
let mut handle_errors: Vec<(PublicKey, Result<(), _>)> = Vec::new();
10498
10505
let mut has_update = false;
10499
- let mut shutdown_results = Vec::new();
10500
10506
{
10501
10507
let per_peer_state = self.per_peer_state.read().unwrap();
10502
10508
10503
- for (_cp_id , peer_state_mutex) in per_peer_state.iter() {
10509
+ for (cp_id , peer_state_mutex) in per_peer_state.iter() {
10504
10510
let mut peer_state_lock = peer_state_mutex.lock().unwrap();
10505
10511
let peer_state = &mut *peer_state_lock;
10506
10512
let pending_msg_events = &mut peer_state.pending_msg_events;
@@ -10517,17 +10523,11 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
10517
10523
});
10518
10524
}
10519
10525
debug_assert_eq!(tx_shutdown_result_opt.is_some(), funded_chan.is_shutdown());
10520
- if let Some((tx, mut shutdown_res)) = tx_shutdown_result_opt {
10521
- locked_close_channel!(self, peer_state, funded_chan, shutdown_res, FUNDED);
10522
- shutdown_results.push(shutdown_res);
10526
+ if let Some((tx, shutdown_res)) = tx_shutdown_result_opt {
10523
10527
// We're done with this channel. We got a closing_signed and sent back
10524
10528
// a closing_signed with a closing transaction to broadcast.
10525
- if let Ok(update) = self.get_channel_update_for_broadcast(&funded_chan) {
10526
- let mut pending_broadcast_messages = self.pending_broadcast_messages.lock().unwrap();
10527
- pending_broadcast_messages.push(MessageSendEvent::BroadcastChannelUpdate {
10528
- msg: update
10529
- });
10530
- }
10529
+ let (_, err) = convert_channel_err!(self, peer_state, shutdown_res, funded_chan, channel_id, COOP_CLOSED);
10530
+ handle_errors.push((*cp_id, Err(err)));
10531
10531
10532
10532
log_info!(logger, "Broadcasting {}", log_tx!(tx));
10533
10533
self.tx_broadcaster.broadcast_transactions(&[&tx]);
@@ -10548,14 +10548,10 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
10548
10548
}
10549
10549
}
10550
10550
10551
- for (counterparty_node_id, err) in handle_errors.drain(..) {
10551
+ for (counterparty_node_id, err) in handle_errors {
10552
10552
let _ = handle_error!(self, err, counterparty_node_id);
10553
10553
}
10554
10554
10555
- for shutdown_result in shutdown_results.drain(..) {
10556
- self.finish_close_channel(shutdown_result);
10557
- }
10558
-
10559
10555
has_update
10560
10556
}
10561
10557
0 commit comments