regtests: add test "lnwatcher_waits_until_fees_go_down"

reproduces #9980

Author: SomberNight

electrum/commands.py

@@ -1643,7 +1643,8 @@ async def add_peer(self, connection_string, timeout=20, gossip=False, wallet: Ab
         arg:int:timeout:Timeout in seconds (default=20)
         """
         lnworker = self.network.lngossip if gossip else wallet.lnworker
-        await lnworker.add_peer(connection_string)
+        async with util.async_timeout(timeout):
+            await lnworker.add_peer(connection_string)
         return True
 
     @command('wnl')
@@ -1719,19 +1720,20 @@ async def decode_invoice(self, invoice: str):
         return invoice.to_debug_json()
 
     @command('wnpl')
-    async def lnpay(self, invoice, timeout=120, password=None, wallet: Abstract_Wallet = None):
+    async def lnpay(self, invoice, timeout=0, password=None, wallet: Abstract_Wallet = None):
         """
         Pay a lightning invoice
 
         arg:str:invoice:Lightning invoice (bolt 11)
-        arg:int:timeout:Timeout in seconds (default=20)
+        arg:int:timeout:Timeout in seconds. Note: *not* safe to try paying same invoice multiple times with a timeout.
         """
         lnworker = wallet.lnworker
         lnaddr = lnworker._check_bolt11_invoice(invoice)
         payment_hash = lnaddr.paymenthash
         invoice_obj = Invoice.from_bech32(invoice)
         wallet.save_invoice(invoice_obj)
-        success, log = await lnworker.pay_invoice(invoice_obj)
+        async with util.async_timeout(timeout or None):
+            success, log = await lnworker.pay_invoice(invoice_obj)
         return {
             'payment_hash': payment_hash.hex(),
             'success': success,

tests/regtest.py

@@ -82,6 +82,9 @@ def test_breach_with_unspent_htlc(self):
     def test_breach_with_spent_htlc(self):
         self.run_shell(['breach_with_spent_htlc'])
 
+    def test_lnwatcher_waits_until_fees_go_down(self):
+        self.run_shell(['lnwatcher_waits_until_fees_go_down'])
+
 
 class TestLightningSwapserver(TestLightning):
     agents = {

tests/regtest/regtest.sh

@@ -90,6 +90,15 @@ function wait_until_spent()
     printf "\n"
 }
 
+function assert_utxo_exists()
+{
+    utxo=$($bitcoin_cli gettxout $1 $2)
+    if [[ -z "$utxo" ]]; then
+        echo "utxo $1:$2 does not exist"
+        exit 1
+    fi
+}
+
 if [[ $# -eq 0 ]]; then
     echo "syntax: init|start|open|status|pay|close|stop"
     exit 1
@@ -308,6 +317,71 @@ if [[ $1 == "swapserver_refund" ]]; then
 fi
 
 
+if [[ $1 == "lnwatcher_waits_until_fees_go_down" ]]; then
+    # Alice sends two HTLCs to Bob (one for small invoice, one for large invoice), which Bob will hold.
+    # Alice requests Bob to force-close the channel, while the HTLCs are pending. Bob force-closes.
+    # Fee levels rise, to the point where the small HTLC is not economical to claim.
+    #                  Alice sweeps the large HTLC (via onchain timeout), but not the small one.
+    # Then, fee levels go back down, and Alice sweeps the small HTLC.
+    # This test checks Alice does not abandon channel outputs that are temporarily ~dust due to
+    # mempool spikes, and keeps watching the channel in hope of fees going down.
+    $alice setconfig test_force_disable_mpp true
+    $alice setconfig test_force_mpp false
+    wait_for_balance alice 1
+    $alice test_inject_fee_etas "{2:1000}"
+    $bob test_inject_fee_etas "{2:1000}"
+    echo "alice opens channel"
+    bob_node=$($bob nodeid)
+    channel=$($alice open_channel $bob_node 0.15 --password='')
+    chan_funding_txid=$(echo "$channel" | cut -d ":" -f 1)
+    chan_funding_outidx=$(echo "$channel" | cut -d ":" -f 2)
+    new_blocks 3
+    wait_until_channel_open alice
+    # Alice sends an HTLC to Bob, which Bob will hold indefinitely. Alice's lnpay will time out.
+    invoice1=$($bob add_hold_invoice deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbee1 \
+                    --amount 0.0004 --min_final_cltv_expiry_delta 300 | jq -r ".invoice")
+    invoice2=$($bob add_hold_invoice deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbee2 \
+                    --amount 0.04 --min_final_cltv_expiry_delta 300 | jq -r ".invoice")
+    set +e
+    $alice lnpay $invoice1 --timeout 3
+    $alice lnpay $invoice2 --timeout 3
+    set -e
+    # After a while, Alice gets impatient and gets Bob to close the channel.
+    new_blocks 20
+    $alice request_force_close $channel
+    wait_until_spent $chan_funding_txid $chan_funding_outidx
+    $bob stop  # bob closes and then disappears. FIXME this is a hack to prevent Bob claiming the fake-hold-invoice-htlc onchain
+    new_blocks 1
+    wait_until_channel_closed alice
+    ctx_id=$($alice list_channels | jq -r ".[0].closing_txid")
+    if [ $TEST_ANCHOR_CHANNELS = True ] ; then
+        htlc_output_index1=2
+        htlc_output_index2=3
+        to_alice_index=4  # Bob's to_remote
+        wait_until_spent $ctx_id $to_alice_index
+    else
+        htlc_output_index1=0
+        htlc_output_index2=1
+        to_alice_index=2
+    fi
+    new_blocks 1
+    assert_utxo_exists $ctx_id $htlc_output_index1
+    assert_utxo_exists $ctx_id $htlc_output_index2
+    # fee levels rise. now small htlc is ~dust
+    $alice test_inject_fee_etas "{2:300000}"
+    new_blocks 300  # this goes past the CLTV of the HTLC-output in ctx
+    wait_until_spent $ctx_id $htlc_output_index2
+    assert_utxo_exists $ctx_id $htlc_output_index1
+    new_blocks 1
+    # fee levels go down. time to claim the small htlc
+    $alice test_inject_fee_etas "{2:1000}"
+    new_blocks 1
+    wait_until_spent $ctx_id $htlc_output_index1
+    new_blocks 1
+    wait_for_balance alice 0.9995
+fi
+
+
 if [[ $1 == "extract_preimage" ]]; then
     # Alice sends htlc1 to Bob.  Bob sends htlc2 to Alice.
     # Neither one of them settles, they hold the htlcs, and Bob force-closes.