fn remove_terminal_channel_state(&mut self, channel_id: ChannelId) -> Option<u64> {

let intercept_scid = self.intercept_scid_by_channel_id.get(&channel_id).copied()?;

let should_remove = self

.outbound_channels_by_intercept_scid

.get(&intercept_scid)

.and_then(|entry| entry.get_channel_id())

.is_some_and(|existing_channel_id| existing_channel_id == channel_id);

if !should_remove {

return None;

}

self.outbound_channels_by_intercept_scid.remove(&intercept_scid);

self.intercept_scid_by_channel_id.remove(&channel_id);

self.intercept_scid_by_user_channel_id.retain(|_, iscid| *iscid != intercept_scid);

self.needs_persist = true;

Some(intercept_scid)

}

/// Forward [`Event::ChannelClosed`] event parameter into this function.

///

/// Will prune terminal JIT channel state once the corresponding channel has closed.

///

/// [`Event::ChannelClosed`]: lightning::events::Event::ChannelClosed

pub async fn channel_closed(&self, channel_id: ChannelId) -> Result<(), APIError> {

let counterparty_node_id =

self.peer_by_channel_id.read().unwrap().get(&channel_id).copied();

let Some(counterparty_node_id) = counterparty_node_id else {

return Ok(());

};

let removed_intercept_scid = {

let outer_state_lock = self.per_peer_state.read().unwrap();

match outer_state_lock.get(&counterparty_node_id) {

Some(inner_state_lock) => {

let mut peer_state = inner_state_lock.lock().unwrap();

peer_state.remove_terminal_channel_state(channel_id)

},

None => None,

}

};

if let Some(intercept_scid) = removed_intercept_scid {

self.peer_by_intercept_scid.write().unwrap().remove(&intercept_scid);

self.peer_by_channel_id.write().unwrap().remove(&channel_id);

self.persist().await.map_err(|e| APIError::APIMisuseError {

err: format!(

"Failed to persist peer state after channel {} closed: {}",

channel_id, e

),

})?;

}

Ok(())

}

/// Forward [`Event::ChannelClosed`] event parameter into this function.

///

/// Wraps [`LSPS2ServiceHandler::channel_closed`].

///

/// [`Event::ChannelClosed`]: lightning::events::Event::ChannelClosed

pub fn channel_closed(&self, channel_id: ChannelId) -> Result<(), APIError> {

let mut fut = pin!(self.inner.channel_closed(channel_id));

let mut waker = dummy_waker();

let mut ctx = task::Context::from_waker(&mut waker);

match fut.as_mut().poll(&mut ctx) {

task::Poll::Ready(result) => result,

task::Poll::Pending => {

// In a sync context, we can't wait for the future to complete.

unreachable!("Should not be pending in a sync context");

},

}

}

#[test]

fn removes_terminal_state_for_closed_channel() {

let opening_fee_params = LSPS2OpeningFeeParams {

min_fee_msat: 10_000_000,

proportional: 10_000,

valid_until: LSPSDateTime::from_str("2035-05-20T08:30:45Z").unwrap(),

min_lifetime: 4032,

max_client_to_self_delay: 2016,

min_payment_size_msat: 10_000_000,

max_payment_size_msat: 1_000_000_000,

promise: "ignore".to_string(),

};

let stale_intercept_scid = 42;

let stale_user_channel_id = 43;

let stale_channel_id = ChannelId([44; 32]);

let live_intercept_scid = 45;

let live_user_channel_id = 46;

let live_channel_id = ChannelId([47; 32]);

let mut stale_jit_channel =

OutboundJITChannel::new(None, opening_fee_params.clone(), stale_user_channel_id, false);

stale_jit_channel.state =

OutboundJITChannelState::PaymentForwarded { channel_id: stale_channel_id };

let mut live_jit_channel =

OutboundJITChannel::new(None, opening_fee_params, live_user_channel_id, false);

live_jit_channel.state =

OutboundJITChannelState::PaymentForwarded { channel_id: live_channel_id };

let mut peer_state = PeerState::new();

peer_state.insert_outbound_channel(stale_intercept_scid, stale_jit_channel);

peer_state.insert_outbound_channel(live_intercept_scid, live_jit_channel);

peer_state

.intercept_scid_by_user_channel_id

.insert(stale_user_channel_id, stale_intercept_scid);

peer_state

.intercept_scid_by_user_channel_id

.insert(live_user_channel_id, live_intercept_scid);

peer_state.intercept_scid_by_channel_id.insert(stale_channel_id, stale_intercept_scid);

peer_state.intercept_scid_by_channel_id.insert(live_channel_id, live_intercept_scid);

peer_state.needs_persist = false;

assert_eq!(

peer_state.remove_terminal_channel_state(stale_channel_id),

Some(stale_intercept_scid)

);

assert!(!peer_state

.outbound_channels_by_intercept_scid

.contains_key(&stale_intercept_scid));

assert!(peer_state.outbound_channels_by_intercept_scid.contains_key(&live_intercept_scid));

assert!(!peer_state.intercept_scid_by_user_channel_id.contains_key(&stale_user_channel_id));

assert_eq!(

peer_state.intercept_scid_by_user_channel_id.get(&live_user_channel_id),

Some(&live_intercept_scid)

);

assert!(!peer_state.intercept_scid_by_channel_id.contains_key(&stale_channel_id));

assert_eq!(

peer_state.intercept_scid_by_channel_id.get(&live_channel_id),

Some(&live_intercept_scid)

);

assert!(peer_state.needs_persist);

peer_state.needs_persist = false;

assert_eq!(peer_state.remove_terminal_channel_state(stale_channel_id), None);

assert!(!peer_state.needs_persist);

}