Track anchor reserves for unresolved monitors

Anchor reserve accounting only looked at channels returned by the
ChannelManager. That misses an important force-close transition:
ChannelManager::list_channels can stop returning a channel before
its commitment transaction confirms. During that window the
ChannelMonitor can still broadcast, rebroadcast, or fee-bump the
holder commitment and its anchor spend, so the wallet's emergency
reserve must remain available.

We now require a anchor reserve to be kept for non-trusted channels
where the type is not yet known; we've recently made anchor channels
always supported in ldk-node, so at this point it is safe to assume most
channels of ldk-node will be anchor channels.

We now no longer count existing 0FC channels to validate support
for submitpackage on the chain source if those channels are in the
trusted peers list.

Co-Authored-By: HAL 9000

Author: tankyleo

bindings/kotlin/ldk-node-jvm/lib/src/test/kotlin/org/lightningdevkit/ldknode/LibraryTest.kt

@@ -55,6 +55,40 @@ fun mineAndWait(esploraEndpoint: String, blocks: UInt) {
     waitForBlock(esploraEndpoint, lastBlockHash)
 }
 
+fun mineChannelClosureUntilSpendable(esploraEndpoint: String, nodes: List<Node>) {
+    var blocksToMine = 0u
+    nodes.forEach { node ->
+        val currentHeight = node.status().currentBestBlock.height
+        node.listBalances().lightningBalances.forEach { balance ->
+            val confirmationHeight = when (balance) {
+                is LightningBalance.ClaimableAwaitingConfirmations -> balance.confirmationHeight
+                else -> error("Unexpected balance after cooperative close: $balance")
+            }
+            val blocksForNode =
+                if (confirmationHeight > currentHeight) {
+                    confirmationHeight - currentHeight
+                } else {
+                    0u
+                }
+            if (blocksForNode > blocksToMine) {
+                blocksToMine = blocksForNode
+            }
+        }
+    }
+
+    if (blocksToMine > 0u) {
+        mineAndWait(esploraEndpoint, blocksToMine)
+        nodes.forEach { it.syncWallets() }
+    }
+
+    nodes.forEach { node ->
+        val balances = node.listBalances()
+        val failureMessage = "Unexpected balances after cooperative close: $balances"
+        assertTrue(balances.lightningBalances.isEmpty(), failureMessage)
+        assertTrue(balances.pendingBalancesFromChannelClosures.isEmpty(), failureMessage)
+    }
+}
+
 fun sendToAddress(address: String, amountSats: UInt): String {
     val amountBtc = amountSats.toDouble() / 100000000.0
     val output = bitcoinCli("sendtoaddress", address, amountBtc.toString())
@@ -77,6 +111,23 @@ fun waitForTx(esploraEndpoint: String, txid: String) {
     }
 }
 
+fun waitForOutpointSpend(esploraEndpoint: String, outpoint: OutPoint) {
+    var esploraPickedUpOutpointSpend = false
+    val re = Regex("\"spent\"\\s*:\\s*true")
+    while (!esploraPickedUpOutpointSpend) {
+        val client = HttpClient.newBuilder().build()
+        val url = esploraEndpoint + "/tx/" + outpoint.txid + "/outspend/" + outpoint.vout
+        val request = HttpRequest.newBuilder()
+            .uri(URI.create(url))
+            .build()
+
+        val response = client.send(request, HttpResponse.BodyHandlers.ofString())
+
+        esploraPickedUpOutpointSpend = re.containsMatchIn(response.body())
+        Thread.sleep(500)
+    }
+}
+
 fun waitForBlock(esploraEndpoint: String, blockHash: String) {
     var esploraPickedUpBlock = false
     val re = Regex("\"in_best_chain\":true")
@@ -251,11 +302,13 @@ class LibraryTest {
         assert(channelPendingEvent2 is Event.ChannelPending)
         node2.eventHandled()
 
-        val fundingTxid = when (channelPendingEvent1) {
-            is Event.ChannelPending -> channelPendingEvent1.fundingTxo.txid
+        val fundingTxo = when (channelPendingEvent1) {
+            is Event.ChannelPending -> channelPendingEvent1.fundingTxo
             else -> return
         }
 
+        val fundingTxid = fundingTxo.txid
+
         waitForTx(esploraEndpoint, fundingTxid)
 
         mineAndWait(esploraEndpoint, 6u)
@@ -316,11 +369,15 @@ class LibraryTest {
         assert(channelClosedEvent2 is Event.ChannelClosed)
         node2.eventHandled()
 
+        waitForOutpointSpend(esploraEndpoint, fundingTxo)
+
         mineAndWait(esploraEndpoint, 1u)
 
         node1.syncWallets()
         node2.syncWallets()
 
+        mineChannelClosureUntilSpendable(esploraEndpoint, listOf(node1, node2))
+
         val spendableBalance1AfterClose = node1.listBalances().spendableOnchainBalanceSats
         val spendableBalance2AfterClose = node2.listBalances().spendableOnchainBalanceSats
         println("Spendable balance 1 after close: $spendableBalance1AfterClose")

bindings/python/src/ldk_node/test_ldk_node.py

@@ -89,6 +89,26 @@ def wait_for_tx(esplora_endpoint, txid):
 
     raise Exception(f"Failed to confirm transaction {txid} after {max_attempts} attempts")
 
+def wait_for_outpoint_spend(esplora_endpoint, outpoint):
+    url = esplora_endpoint + "/tx/" + outpoint.txid + "/outspend/" + str(outpoint.vout)
+    attempts = 0
+    max_attempts = 30
+
+    while attempts < max_attempts:
+        try:
+            res = requests.get(url, timeout=10)
+            json = res.json()
+            if json.get('spent'):
+                return
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+        attempts += 1
+        time.sleep(0.5)
+
+    raise Exception(f"Failed to confirm outpoint spend {outpoint} after {max_attempts} attempts")
+
 def send_to_address(address, amount_sats):
     amount_btc = amount_sats/100000000.0
     cmd = "sendtoaddress " + str(address) + " " + str(amount_btc)
@@ -175,6 +195,29 @@ def open_channel_and_wait_ready(node_1, node_2, node_id_2, listening_address_2,
     channel_ready_event_2 = expect_event(node_2, Event.CHANNEL_READY)
     return channel_ready_event_1, channel_ready_event_2, funding_txid
 
+def mine_channel_closure_until_spendable(nodes, esplora_endpoint):
+    blocks_to_mine = 0
+    for node in nodes:
+        current_height = node.status().current_best_block.height
+        balances = node.list_balances()
+        for lightning_balance in balances.lightning_balances:
+            confirmation_height = getattr(lightning_balance, "confirmation_height", None)
+            assert confirmation_height is not None, (
+                f"Unexpected balance after cooperative close: {lightning_balance}"
+            )
+            blocks_to_mine = max(blocks_to_mine, confirmation_height - current_height)
+
+    if blocks_to_mine > 0:
+        mine_and_wait(esplora_endpoint, blocks_to_mine)
+        for node in nodes:
+            node.sync_wallets()
+
+    for node in nodes:
+        balances = node.list_balances()
+        failure_message = f"Unexpected balances after cooperative close: {balances}"
+        assert len(balances.lightning_balances) == 0, failure_message
+        assert len(balances.pending_balances_from_channel_closures) == 0, failure_message
+
 def stop_and_cleanup(node_1, node_2, tmp_dir_1, tmp_dir_2):
     node_1.stop()
     node_2.stop()
@@ -307,11 +350,15 @@ def test_channel_full_cycle(self):
 
         expect_event(node_2, Event.CHANNEL_CLOSED)
 
+        wait_for_outpoint_spend(esplora_endpoint, channel_ready_event_1.funding_txo)
+
         mine_and_wait(esplora_endpoint, 1)
 
         node_1.sync_wallets()
         node_2.sync_wallets()
 
+        mine_channel_closure_until_spendable([node_1, node_2], esplora_endpoint)
+
         spendable_balance_after_close_1 = node_1.list_balances().spendable_onchain_balance_sats
         assert spendable_balance_after_close_1 > 95000
         assert spendable_balance_after_close_1 < 100000

src/builder.rs

@@ -2103,6 +2103,7 @@ fn build_with_store_internal(
 			Arc::clone(&wallet),
 			Arc::clone(&channel_manager),
 			Arc::clone(&keys_manager),
+			Arc::clone(&chain_monitor),
 			Arc::clone(&tx_broadcaster),
 			Arc::clone(&kv_store),
 			Arc::clone(&config),

src/event.rs

@@ -55,7 +55,8 @@ use crate::payment::PaymentMetadata;
 use crate::probing::Prober;
 use crate::runtime::Runtime;
 use crate::types::{
-	CustomTlvRecord, DynStore, KeysManager, OnionMessenger, PaymentStore, Sweeper, Wallet,
+	ChainMonitor, CustomTlvRecord, DynStore, KeysManager, OnionMessenger, PaymentStore, Sweeper,
+	Wallet,
 };
 use crate::{
 	hex_utils, BumpTransactionEventHandler, ChannelManager, Error, Graph, PeerInfo, PeerStore,
@@ -530,6 +531,7 @@ where
 	wallet: Arc<Wallet>,
 	bump_tx_event_handler: Arc<BumpTransactionEventHandler>,
 	channel_manager: Arc<ChannelManager>,
+	chain_monitor: Arc<ChainMonitor>,
 	connection_manager: Arc<ConnectionManager<L>>,
 	output_sweeper: Arc<Sweeper>,
 	network_graph: Arc<Graph>,
@@ -553,19 +555,20 @@ where
 	pub fn new(
 		event_queue: Arc<EventQueue<L>>, wallet: Arc<Wallet>,
 		bump_tx_event_handler: Arc<BumpTransactionEventHandler>,
-		channel_manager: Arc<ChannelManager>, connection_manager: Arc<ConnectionManager<L>>,
-		output_sweeper: Arc<Sweeper>, network_graph: Arc<Graph>,
-		liquidity_source: Arc<LiquiditySource<Arc<Logger>>>, payment_store: Arc<PaymentStore>,
-		peer_store: Arc<PeerStore<L>>, keys_manager: Arc<KeysManager>,
-		static_invoice_store: Option<StaticInvoiceStore>, onion_messenger: Arc<OnionMessenger>,
-		om_mailbox: Option<Arc<OnionMessageMailbox>>, prober: Option<Arc<Prober>>,
-		runtime: Arc<Runtime>, logger: L, config: Arc<Config>,
+		channel_manager: Arc<ChannelManager>, chain_monitor: Arc<ChainMonitor>,
+		connection_manager: Arc<ConnectionManager<L>>, output_sweeper: Arc<Sweeper>,
+		network_graph: Arc<Graph>, liquidity_source: Arc<LiquiditySource<Arc<Logger>>>,
+		payment_store: Arc<PaymentStore>, peer_store: Arc<PeerStore<L>>,
+		keys_manager: Arc<KeysManager>, static_invoice_store: Option<StaticInvoiceStore>,
+		onion_messenger: Arc<OnionMessenger>, om_mailbox: Option<Arc<OnionMessageMailbox>>,
+		prober: Option<Arc<Prober>>, runtime: Arc<Runtime>, logger: L, config: Arc<Config>,
 	) -> Self {
 		Self {
 			event_queue,
 			wallet,
 			bump_tx_event_handler,
 			channel_manager,
+			chain_monitor,
 			connection_manager,
 			output_sweeper,
 			network_graph,
@@ -1276,6 +1279,7 @@ where
 				if required_reserve_sats > 0 {
 					let cur_anchor_reserve_sats = crate::total_anchor_channels_reserve_sats(
 						&self.channel_manager,
+						&self.chain_monitor,
 						&self.config,
 					);
 					let spendable_amount_sats =