tests: Add explicit preapprove{invoice,keysend} calls before sendpay

Author: ksedgwic

tests/test_closing.py

@@ -1834,6 +1834,7 @@ def test_onchaind_replay(node_factory, bitcoind):
         'delay': 101,
         'channel': first_scid(l1, l2)
     }
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
     l1.daemon.wait_for_log('sendrawtx exit 0')
     bitcoind.generate_block(1, wait_for_mempool=1)
@@ -1979,6 +1980,7 @@ def test_onchain_timeout(node_factory, bitcoind, executor, chainparams, anchors)
         'channel': first_scid(l1, l2)
     }
 
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'], groupid=1)
     with pytest.raises(RpcError):
         l1.rpc.waitsendpay(rhash)
@@ -2114,6 +2116,7 @@ def test_onchain_middleman_simple(node_factory, bitcoind, chainparams, anchors):
 
     q = queue.Queue()
 
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     def try_pay():
         try:
             l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
@@ -2254,6 +2257,7 @@ def test_onchain_middleman_their_unilateral_in(node_factory, bitcoind, chainpara
 
     q = queue.Queue()
 
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     def try_pay():
         try:
             l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
@@ -2365,6 +2369,8 @@ def try_pay():
         try:
             # rhash is fake (so is payment_secret)
             rhash = 'B1' * 32
+            # let the signer know this payment is coming
+            l1.rpc.preapprovekeysend(l2.info['id'], rhash, 10**8)
             l1.rpc.sendpay(route, rhash, payment_secret=rhash)
             q.put(None)
         except Exception as err:
@@ -2506,6 +2512,7 @@ def test_onchain_feechange(node_factory, bitcoind, executor):
         'channel': first_scid(l1, l2)
     }
 
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     executor.submit(l1.rpc.sendpay, [routestep], rhash, payment_secret=inv['payment_secret'])
 
     # l2 will drop to chain.
@@ -2587,6 +2594,7 @@ def test_onchain_all_dust(node_factory, bitcoind, executor):
         'channel': first_scid(l1, l2)
     }
 
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     executor.submit(l1.rpc.sendpay, [routestep], rhash, payment_secret=inv['payment_secret'])
 
     # l2 will drop to chain.

tests/test_connection.py

@@ -857,6 +857,7 @@ def test_reconnect_sender_add1(node_factory):
         l1.daemon.wait_for_log('Already have funding locked in')
 
     # This will send commit, so will reconnect as required.
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
 
 
@@ -888,6 +889,7 @@ def test_reconnect_sender_add(node_factory):
     route = [{'amount_msat': amt, 'id': l2.info['id'], 'delay': 5, 'channel': first_scid(l1, l2)}]
 
     # This will send commit, so will reconnect as required.
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
     # Should have printed this for every reconnect.
     for i in range(0, len(disconnects)):
@@ -920,6 +922,7 @@ def test_reconnect_receiver_add(node_factory):
     assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['status'] == 'unpaid'
 
     route = [{'amount_msat': amt, 'id': l2.info['id'], 'delay': 5, 'channel': first_scid(l1, l2)}]
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
     for i in range(len(disconnects)):
         l1.daemon.wait_for_log('Already have funding locked in')
@@ -950,6 +953,7 @@ def test_reconnect_receiver_fulfill(node_factory):
     assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['status'] == 'unpaid'
 
     route = [{'amount_msat': amt, 'id': l2.info['id'], 'delay': 5, 'channel': first_scid(l1, l2)}]
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
     for i in range(len(disconnects)):
         l1.daemon.wait_for_log('Already have funding locked in')
@@ -4248,6 +4252,7 @@ def test_multichan(node_factory, executor, bitcoind):
 
     before = l2.rpc.listpeerchannels(l3.info['id'])['channels']
     inv1 = l3.rpc.invoice(100000000, "invoice", "invoice")
+    l1.rpc.preapproveinvoice(bolt11=inv1['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, inv1['payment_hash'], payment_secret=inv1['payment_secret'])
     l1.rpc.waitsendpay(inv1['payment_hash'])
 
@@ -4275,6 +4280,7 @@ def test_multichan(node_factory, executor, bitcoind):
     before = l2.rpc.listpeerchannels(l3.info['id'])['channels']
     route[1]['channel'] = scid23b
     inv2 = l3.rpc.invoice(100000000, "invoice2", "invoice2")
+    l1.rpc.preapproveinvoice(bolt11=inv2['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, inv2['payment_hash'], payment_secret=inv2['payment_secret'])
     l1.rpc.waitsendpay(inv2['payment_hash'])
     # Wait until HTLCs fully settled
@@ -4319,6 +4325,7 @@ def test_multichan(node_factory, executor, bitcoind):
     # We can actually pay by *closed* scid (at least until it's completely forgotten)
     route[1]['channel'] = scid23a
     inv3 = l3.rpc.invoice(100000000, "invoice3", "invoice3")
+    l1.rpc.preapproveinvoice(bolt11=inv3['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, inv3['payment_hash'], payment_secret=inv3['payment_secret'])
     l1.rpc.waitsendpay(inv3['payment_hash'])
 

tests/test_pay.py

@@ -584,6 +584,7 @@ def invoice_unpaid(dst, label):
     with pytest.raises(RpcError):
         rs = copy.deepcopy(routestep)
         rs['amount_msat'] = rs['amount_msat'] - 1
+        l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
         l1.rpc.sendpay([rs], rhash, payment_secret=inv['payment_secret'])
         l1.rpc.waitsendpay(rhash)
     assert invoice_unpaid(l2, 'testpayment2')
@@ -592,6 +593,7 @@ def invoice_unpaid(dst, label):
     with pytest.raises(RpcError):
         rs = copy.deepcopy(routestep)
         rs['amount_msat'] = rs['amount_msat'] * 2 + 1
+        l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
         l1.rpc.sendpay([rs], rhash, payment_secret=inv['payment_secret'])
         l1.rpc.waitsendpay(rhash)
     assert invoice_unpaid(l2, 'testpayment2')
@@ -600,6 +602,7 @@ def invoice_unpaid(dst, label):
     with pytest.raises(RpcError):
         rs = copy.deepcopy(routestep)
         rs['delay'] = rs['delay'] - 2
+        l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
         l1.rpc.sendpay([rs], rhash, payment_secret=inv['payment_secret'])
         l1.rpc.waitsendpay(rhash)
     assert invoice_unpaid(l2, 'testpayment2')
@@ -609,17 +612,20 @@ def invoice_unpaid(dst, label):
     with pytest.raises(RpcError):
         rs = copy.deepcopy(routestep)
         rs['id'] = '00000000000000000000000000000000'
+        l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
         l1.rpc.sendpay([rs], rhash, payment_secret=inv['payment_secret'])
     assert invoice_unpaid(l2, 'testpayment2')
     l1.rpc.check_request_schemas = True
 
     # Bad payment_secret
+    l1.rpc.preapprovekeysend(l2.info['id'], rhash, routestep['amount_msat'])
     l1.rpc.sendpay([routestep], rhash, payment_secret="00" * 32)
     with pytest.raises(RpcError):
         l1.rpc.waitsendpay(rhash)
     assert invoice_unpaid(l2, 'testpayment2')
 
     # Missing payment_secret
+    l1.rpc.preapprovekeysend(l2.info['id'], rhash, routestep['amount_msat'])
     l1.rpc.sendpay([routestep], rhash)
     with pytest.raises(RpcError):
         l1.rpc.waitsendpay(rhash)
@@ -635,6 +641,7 @@ def invoice_unpaid(dst, label):
 
     # This works.
     before = int(time.time())
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     details = l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
     after = int(time.time())
     preimage = l1.rpc.waitsendpay(rhash)['payment_preimage']
@@ -677,6 +684,7 @@ def check_balances():
     rhash = inv['payment_hash']
     assert only_one(l2.rpc.listinvoices('testpayment3')['invoices'])['status'] == 'unpaid'
     routestep = {'amount_msat': amt * 2, 'id': l2.info['id'], 'delay': 5, 'channel': first_scid(l1, l2)}
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
     preimage3 = l1.rpc.waitsendpay(rhash)['payment_preimage']
     assert only_one(l2.rpc.listinvoices('testpayment3')['invoices'])['status'] == 'paid'
@@ -1112,6 +1120,7 @@ def test_forward(node_factory, bitcoind):
     # Unknown other peer
     route = copy.deepcopy(baseroute)
     route[1]['id'] = '031a8dc444e41bb989653a4501e11175a488a57439b0c4947704fd6e3de5dca607'
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
     with pytest.raises(RpcError):
         l1.rpc.waitsendpay(rhash)
@@ -1518,6 +1527,7 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
 
     l2.rpc.close(c23, 1)
 
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     with pytest.raises(RpcError):
         l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
         l1.rpc.waitsendpay(payment_hash)
@@ -1543,6 +1553,7 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
               'delay': 6,
               'channel': c24}]
 
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     with pytest.raises(RpcError):
         l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
         l1.rpc.waitsendpay(payment_hash)
@@ -1569,6 +1580,7 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
               'delay': 6,
               'channel': c25}]
 
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     with pytest.raises(RpcError):
         l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
         l1.rpc.waitsendpay(payment_hash)
@@ -1592,6 +1604,7 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
     # Replace id with a different pubkey, so onion encoded badly at l2 hop.
     route[1]['id'] = mangled_nodeid
 
+    l6.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     with pytest.raises(RpcError):
         l6.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
         l6.rpc.waitsendpay(payment_hash)
@@ -1619,6 +1632,7 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
               'delay': 5,
               'channel': c24}]
 
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     executor.submit(l1.rpc.sendpay, route, payment_hash, payment_secret=inv['payment_secret'])
 
     l4.daemon.wait_for_log('permfail')
@@ -1675,6 +1689,7 @@ def test_htlcs_cltv_only_difference(node_factory, bitcoind):
 
     # L2 tries to pay
     r = l2.rpc.getroute(l4.info['id'], 10**8, 1)["route"]
+    l2.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l2.rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
 
     # Now increment CLTV
@@ -1683,6 +1698,7 @@ def test_htlcs_cltv_only_difference(node_factory, bitcoind):
 
     # L1 tries to pay
     r = l1.rpc.getroute(l4.info['id'], 10**8, 1)["route"]
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
 
     # Now increment CLTV
@@ -1691,6 +1707,7 @@ def test_htlcs_cltv_only_difference(node_factory, bitcoind):
 
     # L3 tries to pay
     r = l3.rpc.getroute(l4.info['id'], 10**8, 1)["route"]
+    l3.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l3.rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
 
     # Give them time to go through.
@@ -1757,6 +1774,7 @@ def exhaust_channel(opener, peer, scid, already_spent=0):
             'delay': 10,
             'channel': scid
         }
+        opener.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
         opener.rpc.sendpay([routestep], inv['payment_hash'], payment_secret=inv['payment_secret'])
         opener.rpc.waitsendpay(inv['payment_hash'])
 
@@ -2484,6 +2502,7 @@ def test_channel_spendable(node_factory, bitcoind):
 
     # Exact amount should succeed.
     route = l1.rpc.getroute(l2.info['id'], amount, riskfactor=1, fuzzpercent=0)['route']
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
 
     # Amount should drop to 0 once HTLC is sent; we have time, thanks to
@@ -2509,6 +2528,7 @@ def test_channel_spendable(node_factory, bitcoind):
 
     # Exact amount should succeed.
     route = l2.rpc.getroute(l1.info['id'], amount, riskfactor=1, fuzzpercent=0)['route']
+    l2.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l2.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
 
     # Amount should drop to 0 once HTLC is sent; we have time, thanks to
@@ -2671,6 +2691,7 @@ def test_htlc_too_dusty_outgoing(node_factory, bitcoind, chainparams):
     route = l1.rpc.getroute(l2.info['id'], non_dust_htlc_val_sat * 1000, 1)['route']
     for i in range(0, 3):
         inv = l2.rpc.invoice((non_dust_htlc_val_sat * 1000), str(i + 100), str(i + 100))
+        l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
         l1.rpc.sendpay(route, inv['payment_hash'], payment_secret=inv['payment_secret'])
         l2.daemon.wait_for_log(r'their htlc .* dev_ignore_htlcs')
         res = only_one(l1.rpc.listsendpays(payment_hash=inv['payment_hash'])['payments'])
@@ -2680,20 +2701,23 @@ def test_htlc_too_dusty_outgoing(node_factory, bitcoind, chainparams):
     route = l1.rpc.getroute(l2.info['id'], htlc_val_msat, 1)['route']
     for i in range(0, num_dusty_htlcs):
         inv = l2.rpc.invoice(htlc_val_msat, str(i), str(i))
+        l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
         l1.rpc.sendpay(route, inv['payment_hash'], payment_secret=inv['payment_secret'])
         l2.daemon.wait_for_log(r'their htlc .* dev_ignore_htlcs')
         res = only_one(l1.rpc.listsendpays(payment_hash=inv['payment_hash'])['payments'])
         assert res['status'] == 'pending'
 
     # one more should tip it over, and return a payment failure
     inv = l2.rpc.invoice(htlc_val_msat, str(num_dusty_htlcs), str(num_dusty_htlcs))
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, inv['payment_hash'], payment_secret=inv['payment_secret'])
     l1.daemon.wait_for_log('CHANNEL_ERR_DUST_FAILURE')
     wait_for(lambda: only_one(l1.rpc.listsendpays(payment_hash=inv['payment_hash'])['payments'])['status'] == 'failed')
 
     # but we can still add a non dust htlc
     route = l1.rpc.getroute(l2.info['id'], non_dust_htlc_val_sat * 1000, 1)['route']
     inv = l2.rpc.invoice((10000 * 1000), str(120), str(120))
+    l1.rpc.preapproveinvoice(bolt11=inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, inv['payment_hash'], payment_secret=inv['payment_secret'])
     l2.daemon.wait_for_log(r'their htlc .* dev_ignore_htlcs')
     res = only_one(l1.rpc.listsendpays(payment_hash=inv['payment_hash'])['payments'])