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

Author: ksedgwic

tests/test_closing.py

@@ -1811,6 +1811,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)
@@ -1954,6 +1955,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)
@@ -2088,6 +2090,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'])
@@ -2227,6 +2230,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'])
@@ -2339,6 +2343,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:
@@ -2479,6 +2485,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.
@@ -2559,6 +2566,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.
@@ -3740,6 +3748,7 @@ def test_closing_anchorspend_htlc_tx_rbf(node_factory, bitcoind):
         'delay': 12,
         'channel': first_scid(l1, l2)
     }
+    l1.rpc.preapprovekeysend(routestep['id'], rhash, routestep['amount_msat'])
     l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
     l2.daemon.wait_for_log('dev_disconnect')
     l2.stop()
@@ -3807,6 +3816,7 @@ def test_htlc_no_force_close(node_factory, bitcoind, anchors):
               'id': l3.info['id'],
               'delay': 10,
               'channel': first_scid(l2, l3)}]
+    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'])
     l3.daemon.wait_for_log('dev_disconnect')
@@ -3928,6 +3938,7 @@ def test_peer_anchor_push(node_factory, bitcoind, executor, chainparams):
     amt = 100_000_000
     sticky_inv = l3.rpc.invoice(amt, 'sticky', 'sticky')
     route = l1.rpc.getroute(l3.info['id'], amt, 1)['route']
+    l1.rpc.preapproveinvoice(bolt11=sticky_inv['bolt11']) # let the signer know this payment is coming
     l1.rpc.sendpay(route, sticky_inv['payment_hash'], payment_secret=sticky_inv['payment_secret'])
     l3.daemon.wait_for_log('dev_disconnect: -WIRE_UPDATE_FULFILL_HTLC')
 

tests/test_connection.py

@@ -844,6 +844,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'])
 
 
@@ -874,6 +875,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)):
@@ -905,6 +907,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')
@@ -934,6 +937,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')
@@ -4165,6 +4169,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'])
 
@@ -4192,6 +4197,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
@@ -4236,6 +4242,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

@@ -574,6 +574,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')
@@ -582,6 +583,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')
@@ -590,6 +592,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')
@@ -599,17 +602,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)
@@ -625,6 +631,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']
@@ -667,6 +674,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'
@@ -702,6 +710,7 @@ def test_repay(node_factory):
         '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], inv['payment_hash'], payment_secret=inv['payment_secret'])
     l1.daemon.wait_for_log("Sending 200000000msat over 1 hops to deliver 200000000msat")
     l1.rpc.waitsendpay(inv['payment_hash'])['payment_preimage']
@@ -730,6 +739,7 @@ def test_wait_sendpay(node_factory, executor):
         '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], inv['payment_hash'], payment_secret=inv['payment_secret'])
     assert wait_created.result(TIMEOUT) == {'subsystem': 'sendpays',
                                             'created': 1,
@@ -1157,6 +1167,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)
@@ -1559,6 +1570,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)
@@ -1584,6 +1596,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)
@@ -1610,6 +1623,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)
@@ -1633,6 +1647,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)
@@ -1660,6 +1675,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')
@@ -1715,6 +1731,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
@@ -1723,6 +1740,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
@@ -1731,6 +1749,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.
@@ -1796,6 +1815,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'])
 
@@ -2513,6 +2533,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
@@ -2538,6 +2559,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
@@ -2697,6 +2719,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'])
@@ -2706,20 +2729,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'])