aljaz/lightning
1
0
Fork 0
mirror of https://github.com/aljazceru/lightning.git synced 2025-12-19 15:14:23 +01:00
Code Issues Packages Projects Releases Wiki Activity

pytest: always provide payment_secret when making payments.

Browse Source 
They're about to become compulsory.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell
2021-07-12 16:19:19 +09:30
committed by neil saitug
parent 3f5d5a1de5
commit 4e881e56ce
7 changed files with 212 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
contrib/pyln-testing/pyln/testing/utils.py
View File

@@ -996,7 +996,10 @@ class LightningNode(object):
assert len(self.rpc.listpeers(dst_id).get('peers')) == 1 assert len(self.rpc.listpeers(dst_id).get('peers')) == 1
# make an invoice # make an invoice
rhash = dst.rpc.invoice(amt, label, label)['payment_hash'] inv = dst.rpc.invoice(amt, label, label)
# FIXME: pre 0.10.1 invoice calls didn't have payment_secret field
psecret = dst.rpc.decodepay(inv['bolt11'])['payment_secret']
rhash = inv['payment_hash']
invoices = dst.rpc.listinvoices(label)['invoices'] invoices = dst.rpc.listinvoices(label)['invoices']
assert len(invoices) == 1 and invoices[0]['status'] == 'unpaid' assert len(invoices) == 1 and invoices[0]['status'] == 'unpaid'
@@ -1008,7 +1011,7 @@ class LightningNode(object):
} }
# sendpay is async now # sendpay is async now
self.rpc.sendpay([routestep], rhash) self.rpc.sendpay([routestep], rhash, payment_secret=psecret)
# wait for sendpay to comply # wait for sendpay to comply
result = self.rpc.waitsendpay(rhash) result = self.rpc.waitsendpay(rhash)
assert(result.get('status') == 'complete') assert(result.get('status') == 'complete')

11
tests/benchmark.py
View File

@@ -30,19 +30,20 @@ def test_single_hop(node_factory, executor):
fs = [] fs = []
invoices = [] invoices = []
for i in tqdm(range(num_payments)): for i in tqdm(range(num_payments)):
invoices.append(l2.rpc.invoice(1000, 'invoice-%d' % (i), 'desc')['payment_hash']) inv = l2.rpc.invoice(1000, 'invoice-%d' % (i), 'desc')
invoices.append((inv['payment_hash'], inv['payment_secret']))
route = l1.rpc.getroute(l2.rpc.getinfo()['id'], 1000, 1)['route'] route = l1.rpc.getroute(l2.rpc.getinfo()['id'], 1000, 1)['route']
print("Sending payments") print("Sending payments")
start_time = time() start_time = time()
def do_pay(i): def do_pay(i, s):
p = l1.rpc.sendpay(route, i) p = l1.rpc.sendpay(route, i, payment_secret=s)
r = l1.rpc.waitsendpay(p['payment_hash']) r = l1.rpc.waitsendpay(p['payment_hash'])
return r return r
for i in invoices: for i, s in invoices:
fs.append(executor.submit(do_pay, i)) fs.append(executor.submit(do_pay, i, s))
for f in tqdm(futures.as_completed(fs), total=len(fs)): for f in tqdm(futures.as_completed(fs), total=len(fs)):
f.result() f.result()

70
tests/test_closing.py
View File

@@ -777,7 +777,7 @@ def test_penalty_htlc_tx_fulfill(node_factory, bitcoind, chainparams):
amt = 10**8 // 2 amt = 10**8 // 2
sticky_inv = l1.rpc.invoice(amt, '2', 'sticky') sticky_inv = l1.rpc.invoice(amt, '2', 'sticky')
route = l4.rpc.getroute(l1.info['id'], amt, 1)['route'] route = l4.rpc.getroute(l1.info['id'], amt, 1)['route']
l4.rpc.sendpay(route, sticky_inv['payment_hash']) l4.rpc.sendpay(route, sticky_inv['payment_hash'], payment_secret=sticky_inv['payment_secret'])
l1.daemon.wait_for_log('dev_disconnect: -WIRE_UPDATE_FULFILL_HTLC') l1.daemon.wait_for_log('dev_disconnect: -WIRE_UPDATE_FULFILL_HTLC')
wait_for(lambda: len(l2.rpc.listpeers(l3.info['id'])['peers'][0]['channels'][0]['htlcs']) == 1) wait_for(lambda: len(l2.rpc.listpeers(l3.info['id'])['peers'][0]['channels'][0]['htlcs']) == 1)
@@ -927,12 +927,12 @@ def test_penalty_htlc_tx_timeout(node_factory, bitcoind, chainparams):
amt = 10**8 // 2 amt = 10**8 // 2
sticky_inv_1 = l5.rpc.invoice(amt, '2', 'sticky') sticky_inv_1 = l5.rpc.invoice(amt, '2', 'sticky')
route = l1.rpc.getroute(l5.info['id'], amt, 1)['route'] route = l1.rpc.getroute(l5.info['id'], amt, 1)['route']
l1.rpc.sendpay(route, sticky_inv_1['payment_hash']) l1.rpc.sendpay(route, sticky_inv_1['payment_hash'], payment_secret=sticky_inv_1['payment_secret'])
l5.daemon.wait_for_log('dev_disconnect: -WIRE_UPDATE_FULFILL_HTLC') l5.daemon.wait_for_log('dev_disconnect: -WIRE_UPDATE_FULFILL_HTLC')
sticky_inv_2 = l1.rpc.invoice(amt, '2', 'sticky') sticky_inv_2 = l1.rpc.invoice(amt, '2', 'sticky')
route = l4.rpc.getroute(l1.info['id'], amt, 1)['route'] route = l4.rpc.getroute(l1.info['id'], amt, 1)['route']
l4.rpc.sendpay(route, sticky_inv_2['payment_hash']) l4.rpc.sendpay(route, sticky_inv_2['payment_hash'], payment_secret=sticky_inv_2['payment_secret'])
l1.daemon.wait_for_log('dev_disconnect: -WIRE_UPDATE_FULFILL_HTLC') l1.daemon.wait_for_log('dev_disconnect: -WIRE_UPDATE_FULFILL_HTLC')
wait_for(lambda: len(l2.rpc.listpeers(l3.info['id'])['peers'][0]['channels'][0]['htlcs']) == 2) wait_for(lambda: len(l2.rpc.listpeers(l3.info['id'])['peers'][0]['channels'][0]['htlcs']) == 2)
@@ -1350,14 +1350,15 @@ def test_onchaind_replay(node_factory, bitcoind):
'feerates': (7500, 7500, 7500, 7500)}, 'feerates': (7500, 7500, 7500, 7500)},
{'watchtime-blocks': 201, 'cltv-delta': 101}]) {'watchtime-blocks': 201, 'cltv-delta': 101}])
rhash = l2.rpc.invoice(10**8, 'onchaind_replay', 'desc')['payment_hash'] inv = l2.rpc.invoice(10**8, 'onchaind_replay', 'desc')
rhash = inv['payment_hash']
routestep = { routestep = {
'msatoshi': 10**8 - 1, 'msatoshi': 10**8 - 1,
'id': l2.info['id'], 'id': l2.info['id'],
'delay': 101, 'delay': 101,
'channel': '1x1x1' 'channel': '1x1x1'
} }
l1.rpc.sendpay([routestep], rhash) l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
l1.daemon.wait_for_log('sendrawtx exit 0') l1.daemon.wait_for_log('sendrawtx exit 0')
bitcoind.generate_block(1, wait_for_mempool=1) bitcoind.generate_block(1, wait_for_mempool=1)
@@ -1409,7 +1410,8 @@ def test_onchain_dust_out(node_factory, bitcoind, executor):
channel_id = first_channel_id(l1, l2) channel_id = first_channel_id(l1, l2)
# Must be dust! # Must be dust!
rhash = l2.rpc.invoice(1, 'onchain_dust_out', 'desc')['payment_hash'] inv = l2.rpc.invoice(1, 'onchain_dust_out', 'desc')
rhash = inv['payment_hash']
routestep = { routestep = {
'msatoshi': 1, 'msatoshi': 1,
'id': l2.info['id'], 'id': l2.info['id'],
@@ -1417,7 +1419,7 @@ def test_onchain_dust_out(node_factory, bitcoind, executor):
'channel': '1x1x1' 'channel': '1x1x1'
} }
l1.rpc.sendpay([routestep], rhash) l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
payfuture = executor.submit(l1.rpc.waitsendpay, rhash) payfuture = executor.submit(l1.rpc.waitsendpay, rhash)
# l1 will drop to chain. # l1 will drop to chain.
@@ -1437,7 +1439,7 @@ def test_onchain_dust_out(node_factory, bitcoind, executor):
# Retry payment, this should fail (and, as a side-effect, tickle a # Retry payment, this should fail (and, as a side-effect, tickle a
# bug). # bug).
with pytest.raises(RpcError, match=r'WIRE_UNKNOWN_NEXT_PEER'): with pytest.raises(RpcError, match=r'WIRE_UNKNOWN_NEXT_PEER'):
l1.rpc.sendpay([routestep], rhash) l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
# 6 later, l1 should collect its to-self payment. # 6 later, l1 should collect its to-self payment.
bitcoind.generate_block(6) bitcoind.generate_block(6)
@@ -1479,7 +1481,8 @@ def test_onchain_timeout(node_factory, bitcoind, executor):
channel_id = first_channel_id(l1, l2) channel_id = first_channel_id(l1, l2)
rhash = l2.rpc.invoice(10**8, 'onchain_timeout', 'desc')['payment_hash'] inv = l2.rpc.invoice(10**8, 'onchain_timeout', 'desc')
rhash = inv['payment_hash']
# We underpay, so it fails. # We underpay, so it fails.
routestep = { routestep = {
'msatoshi': 10**8 - 1, 'msatoshi': 10**8 - 1,
@@ -1488,7 +1491,7 @@ def test_onchain_timeout(node_factory, bitcoind, executor):
'channel': '1x1x1' 'channel': '1x1x1'
} }
l1.rpc.sendpay([routestep], rhash) l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
@@ -1497,7 +1500,7 @@ def test_onchain_timeout(node_factory, bitcoind, executor):
sync_blockheight(bitcoind, [l1]) sync_blockheight(bitcoind, [l1])
# Second one will cause drop to chain. # Second one will cause drop to chain.
l1.rpc.sendpay([routestep], rhash) l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
payfuture = executor.submit(l1.rpc.waitsendpay, rhash) payfuture = executor.submit(l1.rpc.waitsendpay, rhash)
# l1 will drop to chain. # l1 will drop to chain.
@@ -1575,7 +1578,8 @@ def test_onchain_middleman(node_factory, bitcoind):
l2.pay(l1, 2 * 10**8) l2.pay(l1, 2 * 10**8)
# Must be bigger than dust! # Must be bigger than dust!
rhash = l3.rpc.invoice(10**8, 'middleman', 'desc')['payment_hash'] inv = l3.rpc.invoice(10**8, 'middleman', 'desc')
rhash = inv['payment_hash']
route = l1.rpc.getroute(l3.info['id'], 10**8, 1)["route"] route = l1.rpc.getroute(l3.info['id'], 10**8, 1)["route"]
assert len(route) == 2 assert len(route) == 2
@@ -1584,7 +1588,7 @@ def test_onchain_middleman(node_factory, bitcoind):
def try_pay(): def try_pay():
try: try:
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
q.put(None) q.put(None)
except Exception as err: except Exception as err:
@@ -1665,7 +1669,8 @@ def test_onchain_middleman_their_unilateral_in(node_factory, bitcoind):
l2.pay(l1, 2 * 10**8) l2.pay(l1, 2 * 10**8)
# Must be bigger than dust! # Must be bigger than dust!
rhash = l3.rpc.invoice(10**8, 'middleman', 'desc')['payment_hash'] inv = l3.rpc.invoice(10**8, 'middleman', 'desc')
rhash = inv['payment_hash']
route = l1.rpc.getroute(l3.info['id'], 10**8, 1)["route"] route = l1.rpc.getroute(l3.info['id'], 10**8, 1)["route"]
assert len(route) == 2 assert len(route) == 2
@@ -1674,7 +1679,7 @@ def test_onchain_middleman_their_unilateral_in(node_factory, bitcoind):
def try_pay(): def try_pay():
try: try:
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
q.put(None) q.put(None)
except Exception as err: except Exception as err:
@@ -1743,9 +1748,9 @@ def test_onchain_their_unilateral_out(node_factory, bitcoind):
def try_pay(): def try_pay():
try: try:
# rhash is fake # rhash is fake (so is payment_secret)
rhash = 'B1' * 32 rhash = 'B1' * 32
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=rhash)
q.put(None) q.put(None)
except Exception as err: except Exception as err:
q.put(err) q.put(err)
@@ -1834,7 +1839,8 @@ def test_onchain_feechange(node_factory, bitcoind, executor):
} }
]) ])
rhash = l2.rpc.invoice(10**8, 'onchain_timeout', 'desc')['payment_hash'] inv = l2.rpc.invoice(10**8, 'onchain_timeout', 'desc')
rhash = inv['payment_hash']
# We underpay, so it fails. # We underpay, so it fails.
routestep = { routestep = {
'msatoshi': 10**8 - 1, 'msatoshi': 10**8 - 1,
@@ -1843,7 +1849,7 @@ def test_onchain_feechange(node_factory, bitcoind, executor):
'channel': '1x1x1' 'channel': '1x1x1'
} }
executor.submit(l1.rpc.sendpay, [routestep], rhash) executor.submit(l1.rpc.sendpay, [routestep], rhash, payment_secret=inv['payment_secret'])
# l2 will drop to chain. # l2 will drop to chain.
l2.daemon.wait_for_log('permfail') l2.daemon.wait_for_log('permfail')
@@ -1917,7 +1923,8 @@ def test_onchain_all_dust(node_factory, bitcoind, executor):
l1.fundchannel(l2, 10**6) l1.fundchannel(l2, 10**6)
channel_id = first_channel_id(l1, l2) channel_id = first_channel_id(l1, l2)
rhash = l2.rpc.invoice(10**8, 'onchain_timeout', 'desc')['payment_hash'] inv = l2.rpc.invoice(10**8, 'onchain_timeout', 'desc')
rhash = inv['payment_hash']
# We underpay, so it fails. # We underpay, so it fails.
routestep = { routestep = {
'msatoshi': 10**7 - 1, 'msatoshi': 10**7 - 1,
@@ -1926,7 +1933,7 @@ def test_onchain_all_dust(node_factory, bitcoind, executor):
'channel': '1x1x1' 'channel': '1x1x1'
} }
executor.submit(l1.rpc.sendpay, [routestep], rhash) executor.submit(l1.rpc.sendpay, [routestep], rhash, payment_secret=inv['payment_secret'])
# l2 will drop to chain. # l2 will drop to chain.
l2.daemon.wait_for_log('permfail') l2.daemon.wait_for_log('permfail')
@@ -2088,19 +2095,20 @@ def setup_multihtlc_test(node_factory, bitcoind):
nodes[-1].rpc.dev_ignore_htlcs(id=nodes[-2].info['id'], ignore=True) nodes[-1].rpc.dev_ignore_htlcs(id=nodes[-2].info['id'], ignore=True)
preimage = "0" * 64 preimage = "0" * 64
h = nodes[0].rpc.invoice(msatoshi=10**8, label='x', description='desc', inv = nodes[0].rpc.invoice(msatoshi=10**8, label='x', description='desc',
preimage=preimage)['payment_hash'] preimage=preimage)
h = inv['payment_hash']
nodes[-1].rpc.invoice(msatoshi=10**8, label='x', description='desc', nodes[-1].rpc.invoice(msatoshi=10**8, label='x', description='desc',
preimage=preimage)['payment_hash'] preimage=preimage)['payment_hash']
# First, the failed attempts (paying wrong node). CLTV1 # First, the failed attempts (paying wrong node). CLTV1
r = nodes[0].rpc.getroute(nodes[-2].info['id'], 10**8, 1)["route"] r = nodes[0].rpc.getroute(nodes[-2].info['id'], 10**8, 1)["route"]
nodes[0].rpc.sendpay(r, h) nodes[0].rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
with pytest.raises(RpcError, match=r'INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS'): with pytest.raises(RpcError, match=r'INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS'):
nodes[0].rpc.waitsendpay(h) nodes[0].rpc.waitsendpay(h)
r = nodes[-1].rpc.getroute(nodes[1].info['id'], 10**8, 1)["route"] r = nodes[-1].rpc.getroute(nodes[1].info['id'], 10**8, 1)["route"]
nodes[-1].rpc.sendpay(r, h) nodes[-1].rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
with pytest.raises(RpcError, match=r'INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS'): with pytest.raises(RpcError, match=r'INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS'):
nodes[-1].rpc.waitsendpay(h) nodes[-1].rpc.waitsendpay(h)
@@ -2110,25 +2118,25 @@ def setup_multihtlc_test(node_factory, bitcoind):
# Now, the live attempts with CLTV2 (blackholed by end nodes) # Now, the live attempts with CLTV2 (blackholed by end nodes)
r = nodes[0].rpc.getroute(nodes[-1].info['id'], 10**8, 1)["route"] r = nodes[0].rpc.getroute(nodes[-1].info['id'], 10**8, 1)["route"]
nodes[0].rpc.sendpay(r, h) nodes[0].rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
r = nodes[-1].rpc.getroute(nodes[0].info['id'], 10**8, 1)["route"] r = nodes[-1].rpc.getroute(nodes[0].info['id'], 10**8, 1)["route"]
nodes[-1].rpc.sendpay(r, h) nodes[-1].rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
# We send second HTLC from different node, since they refuse to send # We send second HTLC from different node, since they refuse to send
# multiple with same hash. # multiple with same hash.
r = nodes[1].rpc.getroute(nodes[-1].info['id'], 10**8, 1)["route"] r = nodes[1].rpc.getroute(nodes[-1].info['id'], 10**8, 1)["route"]
nodes[1].rpc.sendpay(r, h) nodes[1].rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
r = nodes[-2].rpc.getroute(nodes[0].info['id'], 10**8, 1)["route"] r = nodes[-2].rpc.getroute(nodes[0].info['id'], 10**8, 1)["route"]
nodes[-2].rpc.sendpay(r, h) nodes[-2].rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
# Now increment CLTV -> CLTV3. # Now increment CLTV -> CLTV3.
bitcoind.generate_block(1) bitcoind.generate_block(1)
sync_blockheight(bitcoind, nodes) sync_blockheight(bitcoind, nodes)
r = nodes[2].rpc.getroute(nodes[-1].info['id'], 10**8, 1)["route"] r = nodes[2].rpc.getroute(nodes[-1].info['id'], 10**8, 1)["route"]
nodes[2].rpc.sendpay(r, h) nodes[2].rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
r = nodes[-3].rpc.getroute(nodes[0].info['id'], 10**8, 1)["route"] r = nodes[-3].rpc.getroute(nodes[0].info['id'], 10**8, 1)["route"]
nodes[-3].rpc.sendpay(r, h) nodes[-3].rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
# Make sure HTLCs have reached the end. # Make sure HTLCs have reached the end.
nodes[0].daemon.wait_for_logs(['peer_in WIRE_UPDATE_ADD_HTLC'] * 3) nodes[0].daemon.wait_for_logs(['peer_in WIRE_UPDATE_ADD_HTLC'] * 3)

63
tests/test_connection.py
View File

@@ -668,21 +668,22 @@ def test_reconnect_sender_add1(node_factory):
l1.fundchannel(l2, 10**6) l1.fundchannel(l2, 10**6)
amt = 200000000 amt = 200000000
rhash = l2.rpc.invoice(amt, 'test_reconnect_sender_add1', 'desc')['payment_hash'] inv = l2.rpc.invoice(amt, 'test_reconnect_sender_add1', 'desc')
rhash = inv['payment_hash']
assert only_one(l2.rpc.listinvoices('test_reconnect_sender_add1')['invoices'])['status'] == 'unpaid' assert only_one(l2.rpc.listinvoices('test_reconnect_sender_add1')['invoices'])['status'] == 'unpaid'
route = [{'msatoshi': amt, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}] route = [{'msatoshi': amt, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}]
for i in range(0, len(disconnects)): for i in range(0, len(disconnects)):
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
# Wait for reconnection. # Wait for reconnection.
l1.daemon.wait_for_log('Already have funding locked in') l1.daemon.wait_for_log('Already have funding locked in')
# This will send commit, so will reconnect as required. # This will send commit, so will reconnect as required.
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
@pytest.mark.developer @pytest.mark.developer
@@ -708,13 +709,14 @@ def test_reconnect_sender_add(node_factory):
l1.fundchannel(l2, 10**6) l1.fundchannel(l2, 10**6)
amt = 200000000 amt = 200000000
rhash = l2.rpc.invoice(amt, 'testpayment', 'desc')['payment_hash'] inv = l2.rpc.invoice(amt, 'testpayment', 'desc')
rhash = inv['payment_hash']
assert only_one(l2.rpc.listinvoices('testpayment')['invoices'])['status'] == 'unpaid' assert only_one(l2.rpc.listinvoices('testpayment')['invoices'])['status'] == 'unpaid'
route = [{'msatoshi': amt, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}] route = [{'msatoshi': amt, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}]
# This will send commit, so will reconnect as required. # This will send commit, so will reconnect as required.
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
# Should have printed this for every reconnect. # Should have printed this for every reconnect.
for i in range(0, len(disconnects)): for i in range(0, len(disconnects)):
l1.daemon.wait_for_log('Already have funding locked in') l1.daemon.wait_for_log('Already have funding locked in')
@@ -743,11 +745,12 @@ def test_reconnect_receiver_add(node_factory):
l1.fundchannel(l2, 10**6) l1.fundchannel(l2, 10**6)
amt = 200000000 amt = 200000000
rhash = l2.rpc.invoice(amt, 'testpayment2', 'desc')['payment_hash'] inv = l2.rpc.invoice(amt, 'testpayment2', 'desc')
rhash = inv['payment_hash']
assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['status'] == 'unpaid' assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['status'] == 'unpaid'
route = [{'msatoshi': amt, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}] route = [{'msatoshi': amt, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}]
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
for i in range(len(disconnects)): for i in range(len(disconnects)):
l1.daemon.wait_for_log('Already have funding locked in') l1.daemon.wait_for_log('Already have funding locked in')
assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['status'] == 'paid' assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['status'] == 'paid'
@@ -775,11 +778,12 @@ def test_reconnect_receiver_fulfill(node_factory):
l1.fundchannel(l2, 10**6) l1.fundchannel(l2, 10**6)
amt = 200000000 amt = 200000000
rhash = l2.rpc.invoice(amt, 'testpayment2', 'desc')['payment_hash'] inv = l2.rpc.invoice(amt, 'testpayment2', 'desc')
rhash = inv['payment_hash']
assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['status'] == 'unpaid' assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['status'] == 'unpaid'
route = [{'msatoshi': amt, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}] route = [{'msatoshi': amt, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}]
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
for i in range(len(disconnects)): for i in range(len(disconnects)):
l1.daemon.wait_for_log('Already have funding locked in') l1.daemon.wait_for_log('Already have funding locked in')
assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['status'] == 'paid' assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['status'] == 'paid'
@@ -2980,7 +2984,7 @@ def test_restart_many_payments(node_factory, bitcoind):
wait_for(lambda: [c['public'] for c in n.rpc.listchannels()['channels']] == [True] * len(nodes) * 2) wait_for(lambda: [c['public'] for c in n.rpc.listchannels()['channels']] == [True] * len(nodes) * 2)
# Manually create routes, get invoices # Manually create routes, get invoices
Payment = namedtuple('Payment', ['innode', 'route', 'payment_hash']) Payment = namedtuple('Payment', ['innode', 'route', 'payment_hash', 'payment_secret'])
to_pay = [] to_pay = []
for i in range(len(innodes)): for i in range(len(innodes)):
@@ -2993,8 +2997,9 @@ def test_restart_many_payments(node_factory, bitcoind):
'id': outnodes[i].info['id'], 'id': outnodes[i].info['id'],
'delay': 5, 'delay': 5,
'channel': outchans[i]}] 'channel': outchans[i]}]
payment_hash = outnodes[i].rpc.invoice(100000000, "invoice", "invoice")['payment_hash'] inv = outnodes[i].rpc.invoice(100000000, "invoice", "invoice")
to_pay.append(Payment(innodes[i], route, payment_hash)) payment_hash = inv['payment_hash']
to_pay.append(Payment(innodes[i], route, payment_hash, inv['payment_secret']))
# This one should be routed through to the outnode. # This one should be routed through to the outnode.
route = [{'msatoshi': 100001001, route = [{'msatoshi': 100001001,
@@ -3005,12 +3010,13 @@ def test_restart_many_payments(node_factory, bitcoind):
'id': outnodes[i].info['id'], 'id': outnodes[i].info['id'],
'delay': 5, 'delay': 5,
'channel': outchans[i]}] 'channel': outchans[i]}]
payment_hash = outnodes[i].rpc.invoice(100000000, "invoice2", "invoice2")['payment_hash'] inv = outnodes[i].rpc.invoice(100000000, "invoice2", "invoice2")
to_pay.append(Payment(innodes[i], route, payment_hash)) payment_hash = inv['payment_hash']
to_pay.append(Payment(innodes[i], route, payment_hash, inv['payment_secret']))
# sendpay is async. # sendpay is async.
for p in to_pay: for p in to_pay:
p.innode.rpc.sendpay(p.route, p.payment_hash) p.innode.rpc.sendpay(p.route, p.payment_hash, p.payment_secret)
# Now restart l1 while traffic is flowing... # Now restart l1 while traffic is flowing...
l1.restart() l1.restart()
@@ -3247,14 +3253,15 @@ def test_pay_disconnect_stress(node_factory, executor):
routel2l1 = [{'msatoshi': '10000msat', 'id': l1.info['id'], 'delay': 5, 'channel': scid12}] routel2l1 = [{'msatoshi': '10000msat', 'id': l1.info['id'], 'delay': 5, 'channel': scid12}]
# Get invoice from l1 to pay. # Get invoice from l1 to pay.
payhash1 = l1.rpc.invoice(10000, "invoice", "invoice")['payment_hash'] inv = l1.rpc.invoice(10000, "invoice", "invoice")
payhash1 = inv['payment_hash']
# Start balancing payment. # Start balancing payment.
fut = executor.submit(l1.pay, l2, 10**9 // 2) fut = executor.submit(l1.pay, l2, 10**9 // 2)
# As soon as reverse payment is accepted, reconnect. # As soon as reverse payment is accepted, reconnect.
while True: while True:
l2.rpc.sendpay(routel2l1, payhash1) l2.rpc.sendpay(routel2l1, payhash1, payment_secret=inv['payment_secret'])
try: try:
# This will usually fail with Capacity exceeded # This will usually fail with Capacity exceeded
l2.rpc.waitsendpay(payhash1, timeout=TIMEOUT) l2.rpc.waitsendpay(payhash1, timeout=TIMEOUT)
@@ -3406,7 +3413,7 @@ def test_htlc_retransmit_order(node_factory, executor):
'=WIRE_UPDATE_ADD_HTLC*' + str(NUM_HTLCS - 1), '=WIRE_UPDATE_ADD_HTLC*' + str(NUM_HTLCS - 1),
'-WIRE_COMMITMENT_SIGNED']}, '-WIRE_COMMITMENT_SIGNED']},
{'may_reconnect': True}]) {'may_reconnect': True}])
payment_hashes = [l2.rpc.invoice(1000, str(x), str(x))['payment_hash'] for x in range(NUM_HTLCS)] invoices = [l2.rpc.invoice(1000, str(x), str(x)) for x in range(NUM_HTLCS)]
routestep = { routestep = {
'msatoshi': 1000, 'msatoshi': 1000,
@@ -3414,8 +3421,8 @@ def test_htlc_retransmit_order(node_factory, executor):
'delay': 5, 'delay': 5,
'channel': '1x1x1' # note: can be bogus for 1-hop direct payments 'channel': '1x1x1' # note: can be bogus for 1-hop direct payments
} }
for p in payment_hashes: for inv in invoices:
executor.submit(l1.rpc.sendpay, [routestep], p) executor.submit(l1.rpc.sendpay, [routestep], inv['payment_hash'], payment_secret=inv['payment_secret'])
l1.daemon.wait_for_logs(['dev_disconnect'] * 2) l1.daemon.wait_for_logs(['dev_disconnect'] * 2)
l1.rpc.call('dev-reenable-commit', [l2.info['id']]) l1.rpc.call('dev-reenable-commit', [l2.info['id']])
@@ -3424,8 +3431,8 @@ def test_htlc_retransmit_order(node_factory, executor):
# Now reconnect. # Now reconnect.
l1.rpc.connect(l2.info['id'], 'localhost', port=l2.port) l1.rpc.connect(l2.info['id'], 'localhost', port=l2.port)
for p in payment_hashes: for inv in invoices:
result = l1.rpc.waitsendpay(p) result = l1.rpc.waitsendpay(inv['payment_hash'])
assert(result['status'] == 'complete') assert(result['status'] == 'complete')
# If order was wrong, we'll get a LOG_BROKEN and fixtures will complain. # If order was wrong, we'll get a LOG_BROKEN and fixtures will complain.
@@ -3631,7 +3638,7 @@ def test_upgrade_statickey_fail(node_factory, executor, bitcoind):
'disconnect': l2_disconnects}]) 'disconnect': l2_disconnects}])
# This HTLC will fail # This HTLC will fail
l1.rpc.sendpay([{'msatoshi': 1000, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}], '00' * 32) l1.rpc.sendpay([{'msatoshi': 1000, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}], '00' * 32, payment_secret='00' * 32)
# Each one should cause one disconnection, no upgrade. # Each one should cause one disconnection, no upgrade.
for d in l1_disconnects + l2_disconnects[:-1]: for d in l1_disconnects + l2_disconnects[:-1]:
@@ -3681,7 +3688,7 @@ def test_htlc_failed_noclose(node_factory):
"""Test a bug where the htlc timeout would kick in even if the HTLC failed""" """Test a bug where the htlc timeout would kick in even if the HTLC failed"""
l1, l2 = node_factory.line_graph(2) l1, l2 = node_factory.line_graph(2)
payment_hash = l2.rpc.invoice(1000, "test", "test")['payment_hash'] inv = l2.rpc.invoice(1000, "test", "test")
routestep = { routestep = {
'msatoshi': FUNDAMOUNT * 1000, 'msatoshi': FUNDAMOUNT * 1000,
'id': l2.info['id'], 'id': l2.info['id'],
@@ -3690,14 +3697,14 @@ def test_htlc_failed_noclose(node_factory):
} }
# This fails at channeld # This fails at channeld
l1.rpc.sendpay([routestep], payment_hash) l1.rpc.sendpay([routestep], inv['payment_hash'], payment_secret=inv['payment_secret'])
with pytest.raises(RpcError, match="Capacity exceeded"): with pytest.raises(RpcError, match="Capacity exceeded"):
l1.rpc.waitsendpay(payment_hash) l1.rpc.waitsendpay(inv['payment_hash'])
# Send a second one, too: make sure we don't crash. # Send a second one, too: make sure we don't crash.
l1.rpc.sendpay([routestep], payment_hash) l1.rpc.sendpay([routestep], inv['payment_hash'], payment_secret=inv['payment_secret'])
with pytest.raises(RpcError, match="Capacity exceeded"): with pytest.raises(RpcError, match="Capacity exceeded"):
l1.rpc.waitsendpay(payment_hash) l1.rpc.waitsendpay(inv['payment_hash'])
time.sleep(35) time.sleep(35)
assert l1.rpc.getpeer(l2.info['id'])['connected'] assert l1.rpc.getpeer(l2.info['id'])['connected']

24
tests/test_misc.py
View File

@@ -1700,7 +1700,7 @@ def test_bad_onion(node_factory, bitcoind):
l1, l2, l3, l4 = node_factory.line_graph(4, wait_for_announce=True, l1, l2, l3, l4 = node_factory.line_graph(4, wait_for_announce=True,
opts={'log-level': 'io'}) opts={'log-level': 'io'})
h = l4.rpc.invoice(123000, 'test_bad_onion', 'description')['payment_hash'] inv = l4.rpc.invoice(123000, 'test_bad_onion', 'description')
route = l1.rpc.getroute(l4.info['id'], 123000, 1)['route'] route = l1.rpc.getroute(l4.info['id'], 123000, 1)['route']
assert len(route) == 3 assert len(route) == 3
@@ -1709,9 +1709,9 @@ def test_bad_onion(node_factory, bitcoind):
# Replace id with a different pubkey, so onion encoded badly at third hop. # Replace id with a different pubkey, so onion encoded badly at third hop.
route[2]['id'] = mangled_nodeid route[2]['id'] = mangled_nodeid
l1.rpc.sendpay(route, h) l1.rpc.sendpay(route, inv['payment_hash'], payment_secret=inv['payment_secret'])
with pytest.raises(RpcError) as err: with pytest.raises(RpcError) as err:
l1.rpc.waitsendpay(h) l1.rpc.waitsendpay(inv['payment_hash'])
# FIXME: #define PAY_TRY_OTHER_ROUTE 204 # FIXME: #define PAY_TRY_OTHER_ROUTE 204
PAY_TRY_OTHER_ROUTE = 204 PAY_TRY_OTHER_ROUTE = 204
@@ -1733,9 +1733,9 @@ def test_bad_onion(node_factory, bitcoind):
# Replace id with a different pubkey, so onion encoded badly at second hop. # Replace id with a different pubkey, so onion encoded badly at second hop.
route[1]['id'] = mangled_nodeid route[1]['id'] = mangled_nodeid
l1.rpc.sendpay(route, h) l1.rpc.sendpay(route, inv['payment_hash'], payment_secret=inv['payment_secret'])
with pytest.raises(RpcError) as err: with pytest.raises(RpcError) as err:
l1.rpc.waitsendpay(h) l1.rpc.waitsendpay(inv['payment_hash'])
# FIXME: #define PAY_TRY_OTHER_ROUTE 204 # FIXME: #define PAY_TRY_OTHER_ROUTE 204
PAY_TRY_OTHER_ROUTE = 204 PAY_TRY_OTHER_ROUTE = 204
@@ -1750,13 +1750,13 @@ def test_bad_onion_immediate_peer(node_factory, bitcoind):
"""Test that we handle the malformed msg when we're the origin""" """Test that we handle the malformed msg when we're the origin"""
l1, l2 = node_factory.line_graph(2, opts={'dev-fail-process-onionpacket': None}) l1, l2 = node_factory.line_graph(2, opts={'dev-fail-process-onionpacket': None})
h = l2.rpc.invoice(123000, 'test_bad_onion_immediate_peer', 'description')['payment_hash'] inv = l2.rpc.invoice(123000, 'test_bad_onion_immediate_peer', 'description')
route = l1.rpc.getroute(l2.info['id'], 123000, 1)['route'] route = l1.rpc.getroute(l2.info['id'], 123000, 1)['route']
assert len(route) == 1 assert len(route) == 1
l1.rpc.sendpay(route, h) l1.rpc.sendpay(route, inv['payment_hash'], payment_secret=inv['payment_secret'])
with pytest.raises(RpcError) as err: with pytest.raises(RpcError) as err:
l1.rpc.waitsendpay(h) l1.rpc.waitsendpay(inv['payment_hash'])
# FIXME: #define PAY_UNPARSEABLE_ONION 202 # FIXME: #define PAY_UNPARSEABLE_ONION 202
PAY_UNPARSEABLE_ONION = 202 PAY_UNPARSEABLE_ONION = 202
@@ -2478,14 +2478,14 @@ def test_listforwards(node_factory, bitcoind):
l1.rpc.pay(i41['bolt11']) l1.rpc.pay(i41['bolt11'])
# failed payment # failed payment
failed_payment_hash = l3.rpc.invoice(4000, 'failed', 'desc')['payment_hash'] failed_inv = l3.rpc.invoice(4000, 'failed', 'desc')
failed_route = l1.rpc.getroute(l3.info['id'], 4000, 1)['route'] failed_route = l1.rpc.getroute(l3.info['id'], 4000, 1)['route']
l2.rpc.close(c23, 1) l2.rpc.close(c23, 1)
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.sendpay(failed_route, failed_payment_hash) l1.rpc.sendpay(failed_route, failed_inv['payment_hash'], payment_secret=failed_inv['payment_secret'])
l1.rpc.waitsendpay(failed_payment_hash) l1.rpc.waitsendpay(failed_inv['payment_hash'])
all_forwards = l2.rpc.listforwards()['forwards'] all_forwards = l2.rpc.listforwards()['forwards']
print(json.dumps(all_forwards, indent=True)) print(json.dumps(all_forwards, indent=True))
@@ -2493,7 +2493,7 @@ def test_listforwards(node_factory, bitcoind):
assert len(all_forwards) == 3 assert len(all_forwards) == 3
assert i31['payment_hash'] in map(lambda x: x['payment_hash'], all_forwards) assert i31['payment_hash'] in map(lambda x: x['payment_hash'], all_forwards)
assert i41['payment_hash'] in map(lambda x: x['payment_hash'], all_forwards) assert i41['payment_hash'] in map(lambda x: x['payment_hash'], all_forwards)
assert failed_payment_hash in map(lambda x: x['payment_hash'], all_forwards) assert failed_inv['payment_hash'] in map(lambda x: x['payment_hash'], all_forwards)
# status=settled # status=settled
settled_forwards = l2.rpc.listforwards(status='settled')['forwards'] settled_forwards = l2.rpc.listforwards(status='settled')['forwards']

142
tests/test_pay.py
View File

@@ -228,7 +228,7 @@ def test_pay0(node_factory):
} }
# Amount must be nonzero! # Amount must be nonzero!
l1.rpc.sendpay([routestep], rhash) l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
with pytest.raises(RpcError, match=r'WIRE_AMOUNT_BELOW_MINIMUM'): with pytest.raises(RpcError, match=r'WIRE_AMOUNT_BELOW_MINIMUM'):
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
@@ -256,7 +256,7 @@ def test_pay_disconnect(node_factory, bitcoind):
# Can't pay while its offline. # Can't pay while its offline.
with pytest.raises(RpcError, match=r'failed: WIRE_TEMPORARY_CHANNEL_FAILURE \(First peer not ready\)'): with pytest.raises(RpcError, match=r'failed: WIRE_TEMPORARY_CHANNEL_FAILURE \(First peer not ready\)'):
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
l2.start() l2.start()
l1.daemon.wait_for_log('peer_out WIRE_CHANNEL_REESTABLISH') l1.daemon.wait_for_log('peer_out WIRE_CHANNEL_REESTABLISH')
@@ -275,7 +275,7 @@ def test_pay_disconnect(node_factory, bitcoind):
# Should fail due to permenant channel fail # Should fail due to permenant channel fail
with pytest.raises(RpcError, match=r'WIRE_UNKNOWN_NEXT_PEER'): with pytest.raises(RpcError, match=r'WIRE_UNKNOWN_NEXT_PEER'):
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
assert not l1.daemon.is_in_log('Payment is still in progress') assert not l1.daemon.is_in_log('Payment is still in progress')
@@ -512,7 +512,8 @@ def test_sendpay(node_factory):
l1, l2 = node_factory.line_graph(2, fundamount=10**6) l1, l2 = node_factory.line_graph(2, fundamount=10**6)
amt = 200000000 amt = 200000000
rhash = l2.rpc.invoice(amt, 'testpayment2', 'desc')['payment_hash'] inv = l2.rpc.invoice(amt, 'testpayment2', 'desc')
rhash = inv['payment_hash']
def invoice_unpaid(dst, label): def invoice_unpaid(dst, label):
invoices = dst.rpc.listinvoices(label)['invoices'] invoices = dst.rpc.listinvoices(label)['invoices']
@@ -533,7 +534,7 @@ def test_sendpay(node_factory):
with pytest.raises(RpcError): with pytest.raises(RpcError):
rs = copy.deepcopy(routestep) rs = copy.deepcopy(routestep)
rs['msatoshi'] = rs['msatoshi'] - 1 rs['msatoshi'] = rs['msatoshi'] - 1
l1.rpc.sendpay([rs], rhash) l1.rpc.sendpay([rs], rhash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
assert invoice_unpaid(l2, 'testpayment2') assert invoice_unpaid(l2, 'testpayment2')
@@ -541,7 +542,7 @@ def test_sendpay(node_factory):
with pytest.raises(RpcError): with pytest.raises(RpcError):
rs = copy.deepcopy(routestep) rs = copy.deepcopy(routestep)
rs['msatoshi'] = rs['msatoshi'] * 2 + 1 rs['msatoshi'] = rs['msatoshi'] * 2 + 1
l1.rpc.sendpay([rs], rhash) l1.rpc.sendpay([rs], rhash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
assert invoice_unpaid(l2, 'testpayment2') assert invoice_unpaid(l2, 'testpayment2')
@@ -549,7 +550,7 @@ def test_sendpay(node_factory):
with pytest.raises(RpcError): with pytest.raises(RpcError):
rs = copy.deepcopy(routestep) rs = copy.deepcopy(routestep)
rs['delay'] = rs['delay'] - 2 rs['delay'] = rs['delay'] - 2
l1.rpc.sendpay([rs], rhash) l1.rpc.sendpay([rs], rhash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
assert invoice_unpaid(l2, 'testpayment2') assert invoice_unpaid(l2, 'testpayment2')
@@ -557,7 +558,7 @@ def test_sendpay(node_factory):
with pytest.raises(RpcError): with pytest.raises(RpcError):
rs = copy.deepcopy(routestep) rs = copy.deepcopy(routestep)
rs['id'] = '00000000000000000000000000000000' rs['id'] = '00000000000000000000000000000000'
l1.rpc.sendpay([rs], rhash) l1.rpc.sendpay([rs], rhash, payment_secret=inv['payment_secret'])
assert invoice_unpaid(l2, 'testpayment2') assert invoice_unpaid(l2, 'testpayment2')
# FIXME: test paying via another node, should fail to pay twice. # FIXME: test paying via another node, should fail to pay twice.
@@ -570,7 +571,7 @@ def test_sendpay(node_factory):
# This works. # This works.
before = int(time.time()) before = int(time.time())
details = l1.rpc.sendpay([routestep], rhash) details = l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
after = int(time.time()) after = int(time.time())
preimage = l1.rpc.waitsendpay(rhash)['payment_preimage'] preimage = l1.rpc.waitsendpay(rhash)['payment_preimage']
# Check details # Check details
@@ -599,7 +600,7 @@ def test_sendpay(node_factory):
# Repeat will "succeed", but won't actually send anything (duplicate) # Repeat will "succeed", but won't actually send anything (duplicate)
assert not l1.daemon.is_in_log('Payment 0/1: .* COMPLETE') assert not l1.daemon.is_in_log('Payment 0/1: .* COMPLETE')
details = l1.rpc.sendpay([routestep], rhash) details = l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
assert details['status'] == "complete" assert details['status'] == "complete"
preimage2 = details['payment_preimage'] preimage2 = details['payment_preimage']
assert preimage == preimage2 assert preimage == preimage2
@@ -608,10 +609,11 @@ def test_sendpay(node_factory):
assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['msatoshi_received'] == rs['msatoshi'] assert only_one(l2.rpc.listinvoices('testpayment2')['invoices'])['msatoshi_received'] == rs['msatoshi']
# Overpaying by "only" a factor of 2 succeeds. # Overpaying by "only" a factor of 2 succeeds.
rhash = l2.rpc.invoice(amt, 'testpayment3', 'desc')['payment_hash'] inv = l2.rpc.invoice(amt, 'testpayment3', 'desc')
rhash = inv['payment_hash']
assert only_one(l2.rpc.listinvoices('testpayment3')['invoices'])['status'] == 'unpaid' assert only_one(l2.rpc.listinvoices('testpayment3')['invoices'])['status'] == 'unpaid'
routestep = {'msatoshi': amt * 2, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'} routestep = {'msatoshi': amt * 2, 'id': l2.info['id'], 'delay': 5, 'channel': '1x1x1'}
l1.rpc.sendpay([routestep], rhash) l1.rpc.sendpay([routestep], rhash, payment_secret=inv['payment_secret'])
preimage3 = l1.rpc.waitsendpay(rhash)['payment_preimage'] preimage3 = l1.rpc.waitsendpay(rhash)['payment_preimage']
assert only_one(l2.rpc.listinvoices('testpayment3')['invoices'])['status'] == 'paid' assert only_one(l2.rpc.listinvoices('testpayment3')['invoices'])['status'] == 'paid'
assert only_one(l2.rpc.listinvoices('testpayment3')['invoices'])['msatoshi_received'] == amt * 2 assert only_one(l2.rpc.listinvoices('testpayment3')['invoices'])['msatoshi_received'] == amt * 2
@@ -1030,7 +1032,8 @@ def test_forward(node_factory, bitcoind):
assert only_one(l2.rpc.getpeer(l1.info['id'])['channels'])['short_channel_id'] == chanid1 assert only_one(l2.rpc.getpeer(l1.info['id'])['channels'])['short_channel_id'] == chanid1
assert only_one(l3.rpc.getpeer(l2.info['id'])['channels'])['short_channel_id'] == chanid2 assert only_one(l3.rpc.getpeer(l2.info['id'])['channels'])['short_channel_id'] == chanid2
rhash = l3.rpc.invoice(100000000, 'testpayment1', 'desc')['payment_hash'] inv = l3.rpc.invoice(100000000, 'testpayment1', 'desc')
rhash = inv['payment_hash']
assert only_one(l3.rpc.listinvoices('testpayment1')['invoices'])['status'] == 'unpaid' assert only_one(l3.rpc.listinvoices('testpayment1')['invoices'])['status'] == 'unpaid'
# Fee for node2 is 10 millionths, plus 1. # Fee for node2 is 10 millionths, plus 1.
@@ -1049,27 +1052,27 @@ def test_forward(node_factory, bitcoind):
# Unknown other peer # Unknown other peer
route = copy.deepcopy(baseroute) route = copy.deepcopy(baseroute)
route[1]['id'] = '031a8dc444e41bb989653a4501e11175a488a57439b0c4947704fd6e3de5dca607' route[1]['id'] = '031a8dc444e41bb989653a4501e11175a488a57439b0c4947704fd6e3de5dca607'
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
# Delay too short (we always add one internally anyway, so subtract 2 here). # Delay too short (we always add one internally anyway, so subtract 2 here).
route = copy.deepcopy(baseroute) route = copy.deepcopy(baseroute)
route[0]['delay'] = 8 route[0]['delay'] = 8
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
# Final delay too short # Final delay too short
route = copy.deepcopy(baseroute) route = copy.deepcopy(baseroute)
route[1]['delay'] = 3 route[1]['delay'] = 3
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
# This one works # This one works
route = copy.deepcopy(baseroute) route = copy.deepcopy(baseroute)
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
@@ -1181,11 +1184,12 @@ def test_forward_different_fees_and_cltv(node_factory, bitcoind):
assert route[1]['msatoshi'] == 4999999 assert route[1]['msatoshi'] == 4999999
assert route[1]['delay'] == 9 + shadow_route assert route[1]['delay'] == 9 + shadow_route
rhash = l3.rpc.invoice(4999999, 'test_forward_different_fees_and_cltv', 'desc')['payment_hash'] inv = l3.rpc.invoice(4999999, 'test_forward_different_fees_and_cltv', 'desc')
rhash = inv['payment_hash']
assert only_one(l3.rpc.listinvoices('test_forward_different_fees_and_cltv')['invoices'])['status'] == 'unpaid' assert only_one(l3.rpc.listinvoices('test_forward_different_fees_and_cltv')['invoices'])['status'] == 'unpaid'
# This should work. # This should work.
l1.rpc.sendpay(route, rhash) l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
# We add one to the blockcount for a bit of fuzz (FIXME: Shadowroute would fix this!) # We add one to the blockcount for a bit of fuzz (FIXME: Shadowroute would fix this!)
@@ -1254,8 +1258,9 @@ def test_forward_pad_fees_and_cltv(node_factory, bitcoind):
route[1]['delay'] += 10 route[1]['delay'] += 10
# This should work. # This should work.
rhash = l3.rpc.invoice(4999999, 'test_forward_pad_fees_and_cltv', 'desc')['payment_hash'] inv = l3.rpc.invoice(4999999, 'test_forward_pad_fees_and_cltv', 'desc')
l1.rpc.sendpay(route, rhash) rhash = inv['payment_hash']
l1.rpc.sendpay(route, rhash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(rhash) l1.rpc.waitsendpay(rhash)
assert only_one(l3.rpc.listinvoices('test_forward_pad_fees_and_cltv')['invoices'])['status'] == 'paid' assert only_one(l3.rpc.listinvoices('test_forward_pad_fees_and_cltv')['invoices'])['status'] == 'paid'
@@ -1282,24 +1287,26 @@ def test_forward_stats(node_factory, bitcoind):
wait_for(lambda: len(l1.rpc.listchannels()['channels']) == 8) wait_for(lambda: len(l1.rpc.listchannels()['channels']) == 8)
payment_hash = l3.rpc.invoice(amount, "first", "desc")['payment_hash'] inv = l3.rpc.invoice(amount, "first", "desc")
payment_hash = inv['payment_hash']
route = l1.rpc.getroute(l3.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l3.info['id'], amount, 1)['route']
l1.rpc.sendpay(route, payment_hash) l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash) l1.rpc.waitsendpay(payment_hash)
# l4 rejects since it doesn't know the payment_hash # l4 rejects since it doesn't know the payment_hash
route = l1.rpc.getroute(l4.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l4.info['id'], amount, 1)['route']
payment_hash = "F" * 64 payment_hash = "F" * 64
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.sendpay(route, payment_hash) l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash) l1.rpc.waitsendpay(payment_hash)
# l5 will hold the HTLC hostage. # l5 will hold the HTLC hostage.
l5.rpc.dev_ignore_htlcs(id=l2.info['id'], ignore=True) l5.rpc.dev_ignore_htlcs(id=l2.info['id'], ignore=True)
route = l1.rpc.getroute(l5.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l5.info['id'], amount, 1)['route']
payment_hash = l5.rpc.invoice(amount, "first", "desc")['payment_hash'] inv = l5.rpc.invoice(amount, "first", "desc")
l1.rpc.sendpay(route, payment_hash) payment_hash = inv['payment_hash']
l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
l5.daemon.wait_for_log(r'their htlc .* dev_ignore_htlcs') l5.daemon.wait_for_log(r'their htlc .* dev_ignore_htlcs')
@@ -1420,13 +1427,14 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
because of WIRE_UNKNOWN_NEXT_PEER; because of WIRE_UNKNOWN_NEXT_PEER;
""" """
payment_hash = l3.rpc.invoice(amount, "first", "desc")['payment_hash'] inv = l3.rpc.invoice(amount, "first", "desc")
payment_hash = inv['payment_hash']
route = l1.rpc.getroute(l3.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l3.info['id'], amount, 1)['route']
l2.rpc.close(c23, 1) l2.rpc.close(c23, 1)
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.sendpay(route, payment_hash) l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash) l1.rpc.waitsendpay(payment_hash)
"""2. When Master handle the forward process with the htlc_in and """2. When Master handle the forward process with the htlc_in and
@@ -1437,7 +1445,8 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
payment will fail in l2 becase of WIRE_FEE_INSUFFICIENT; payment will fail in l2 becase of WIRE_FEE_INSUFFICIENT;
""" """
payment_hash = l4.rpc.invoice(amount, "third", "desc")['payment_hash'] inv = l4.rpc.invoice(amount, "third", "desc")
payment_hash = inv['payment_hash']
fee = amount * 10 // 1000000 + 1 fee = amount * 10 // 1000000 + 1
route = [{'msatoshi': amount, route = [{'msatoshi': amount,
@@ -1450,7 +1459,7 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
'channel': c24}] 'channel': c24}]
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.sendpay(route, payment_hash) l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash) l1.rpc.waitsendpay(payment_hash)
"""3. When we send htlc_out, Master asks Channeld to add a new htlc """3. When we send htlc_out, Master asks Channeld to add a new htlc
@@ -1462,7 +1471,8 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
fail in l2 because of CHANNEL_ERR_MAX_HTLC_VALUE_EXCEEDED; fail in l2 because of CHANNEL_ERR_MAX_HTLC_VALUE_EXCEEDED;
""" """
payment_hash = l5.rpc.invoice(amount, "second", "desc")['payment_hash'] inv = l5.rpc.invoice(amount, "second", "desc")
payment_hash = inv['payment_hash']
fee = amount * 10 // 1000000 + 1 fee = amount * 10 // 1000000 + 1
route = [{'msatoshi': amount + fee, route = [{'msatoshi': amount + fee,
@@ -1475,7 +1485,7 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
'channel': c25}] 'channel': c25}]
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.sendpay(route, payment_hash) l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash) l1.rpc.waitsendpay(payment_hash)
"""4. When Channeld receives a new revoke message, if the state of """4. When Channeld receives a new revoke message, if the state of
@@ -1488,7 +1498,8 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
fail in l2 because of WIRE_INVALID_ONION_KEY; fail in l2 because of WIRE_INVALID_ONION_KEY;
""" """
payment_hash = l4.rpc.invoice(amount, 'fourth', 'desc')['payment_hash'] inv = l4.rpc.invoice(amount, 'fourth', 'desc')
payment_hash = inv['payment_hash']
route = l6.rpc.getroute(l4.info['id'], amount, 1)['route'] route = l6.rpc.getroute(l4.info['id'], amount, 1)['route']
mangled_nodeid = '0265b6ab5ec860cd257865d61ef0bbf5b3339c36cbda8b26b74e7f1dca490b6510' mangled_nodeid = '0265b6ab5ec860cd257865d61ef0bbf5b3339c36cbda8b26b74e7f1dca490b6510'
@@ -1497,7 +1508,7 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
route[1]['id'] = mangled_nodeid route[1]['id'] = mangled_nodeid
with pytest.raises(RpcError): with pytest.raises(RpcError):
l6.rpc.sendpay(route, payment_hash) l6.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
l6.rpc.waitsendpay(payment_hash) l6.rpc.waitsendpay(payment_hash)
"""5. When Onchaind finds the htlc time out or missing htlc, Master """5. When Onchaind finds the htlc time out or missing htlc, Master
@@ -1509,7 +1520,8 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
before sending update_fail_htlc, so the htlc will be holding until l2 before sending update_fail_htlc, so the htlc will be holding until l2
meets timeout and handle it as local_fail. meets timeout and handle it as local_fail.
""" """
payment_hash = l4.rpc.invoice(amount, 'onchain_timeout', 'desc')['payment_hash'] inv = l4.rpc.invoice(amount, 'onchain_timeout', 'desc')
payment_hash = inv['payment_hash']
fee = amount * 10 // 1000000 + 1 fee = amount * 10 // 1000000 + 1
# We underpay, so it fails. # We underpay, so it fails.
@@ -1522,7 +1534,7 @@ def test_forward_local_failed_stats(node_factory, bitcoind, executor):
'delay': 5, 'delay': 5,
'channel': c24}] 'channel': c24}]
executor.submit(l1.rpc.sendpay, route, payment_hash) executor.submit(l1.rpc.sendpay, route, payment_hash, payment_secret=inv['payment_secret'])
l4.daemon.wait_for_log('permfail') l4.daemon.wait_for_log('permfail')
l4.wait_for_channel_onchain(l2.info['id']) l4.wait_for_channel_onchain(l2.info['id'])
@@ -1568,12 +1580,13 @@ def test_htlcs_cltv_only_difference(node_factory, bitcoind):
# l3 will see a reconnect from l4 when l4 restarts. # l3 will see a reconnect from l4 when l4 restarts.
l1, l2, l3, l4 = node_factory.line_graph(4, wait_for_announce=True, opts=[{}] * 2 + [{'dev-no-reconnect': None, 'may_reconnect': True}] * 2) l1, l2, l3, l4 = node_factory.line_graph(4, wait_for_announce=True, opts=[{}] * 2 + [{'dev-no-reconnect': None, 'may_reconnect': True}] * 2)
h = l4.rpc.invoice(msatoshi=10**8, label='x', description='desc')['payment_hash'] inv = l4.rpc.invoice(msatoshi=10**8, label='x', description='desc')
h = inv['payment_hash']
l4.rpc.dev_ignore_htlcs(id=l3.info['id'], ignore=True) l4.rpc.dev_ignore_htlcs(id=l3.info['id'], ignore=True)
# L2 tries to pay # L2 tries to pay
r = l2.rpc.getroute(l4.info['id'], 10**8, 1)["route"] r = l2.rpc.getroute(l4.info['id'], 10**8, 1)["route"]
l2.rpc.sendpay(r, h) l2.rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
# Now increment CLTV # Now increment CLTV
bitcoind.generate_block(1) bitcoind.generate_block(1)
@@ -1581,7 +1594,7 @@ def test_htlcs_cltv_only_difference(node_factory, bitcoind):
# L1 tries to pay # L1 tries to pay
r = l1.rpc.getroute(l4.info['id'], 10**8, 1)["route"] r = l1.rpc.getroute(l4.info['id'], 10**8, 1)["route"]
l1.rpc.sendpay(r, h) l1.rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
# Now increment CLTV # Now increment CLTV
bitcoind.generate_block(1) bitcoind.generate_block(1)
@@ -1589,7 +1602,7 @@ def test_htlcs_cltv_only_difference(node_factory, bitcoind):
# L3 tries to pay # L3 tries to pay
r = l3.rpc.getroute(l4.info['id'], 10**8, 1)["route"] r = l3.rpc.getroute(l4.info['id'], 10**8, 1)["route"]
l3.rpc.sendpay(r, h) l3.rpc.sendpay(r, h, payment_secret=inv['payment_secret'])
# Give them time to go through. # Give them time to go through.
time.sleep(5) time.sleep(5)
@@ -1656,7 +1669,7 @@ def test_pay_retry(node_factory, bitcoind, executor, chainparams):
'delay': 10, 'delay': 10,
'channel': scid 'channel': scid
} }
opener.rpc.sendpay([routestep], inv['payment_hash']) opener.rpc.sendpay([routestep], inv['payment_hash'], payment_secret=inv['payment_secret'])
opener.rpc.waitsendpay(inv['payment_hash']) opener.rpc.waitsendpay(inv['payment_hash'])
# We connect every node to l5; in a line and individually. # We connect every node to l5; in a line and individually.
@@ -2240,12 +2253,13 @@ def test_channel_spendable(node_factory, bitcoind):
l1, l2 = node_factory.line_graph(2, fundamount=sats, wait_for_announce=True, l1, l2 = node_factory.line_graph(2, fundamount=sats, wait_for_announce=True,
opts={'plugin': os.path.join(os.getcwd(), 'tests/plugins/hold_invoice.py'), 'holdtime': '30'}) opts={'plugin': os.path.join(os.getcwd(), 'tests/plugins/hold_invoice.py'), 'holdtime': '30'})
payment_hash = l2.rpc.invoice('any', 'inv', 'for testing')['payment_hash'] inv = l2.rpc.invoice('any', 'inv', 'for testing')
payment_hash = inv['payment_hash']
# We should be able to spend this much, and not one msat more! # We should be able to spend this much, and not one msat more!
amount = l1.rpc.listpeers()['peers'][0]['channels'][0]['spendable_msat'] amount = l1.rpc.listpeers()['peers'][0]['channels'][0]['spendable_msat']
route = l1.rpc.getroute(l2.info['id'], amount + 1, riskfactor=1, fuzzpercent=0)['route'] route = l1.rpc.getroute(l2.info['id'], amount + 1, riskfactor=1, fuzzpercent=0)['route']
l1.rpc.sendpay(route, payment_hash) l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
# This should fail locally with "capacity exceeded" # This should fail locally with "capacity exceeded"
with pytest.raises(RpcError, match=r"Capacity exceeded.*'erring_index': 0"): with pytest.raises(RpcError, match=r"Capacity exceeded.*'erring_index': 0"):
@@ -2253,7 +2267,7 @@ def test_channel_spendable(node_factory, bitcoind):
# Exact amount should succeed. # Exact amount should succeed.
route = l1.rpc.getroute(l2.info['id'], amount, riskfactor=1, fuzzpercent=0)['route'] route = l1.rpc.getroute(l2.info['id'], amount, riskfactor=1, fuzzpercent=0)['route']
l1.rpc.sendpay(route, payment_hash) 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 # Amount should drop to 0 once HTLC is sent; we have time, thanks to
# hold_invoice.py plugin. # hold_invoice.py plugin.
@@ -2264,12 +2278,13 @@ def test_channel_spendable(node_factory, bitcoind):
# Make sure l2 thinks it's all over. # Make sure l2 thinks it's all over.
wait_for(lambda: len(l2.rpc.listpeers()['peers'][0]['channels'][0]['htlcs']) == 0) wait_for(lambda: len(l2.rpc.listpeers()['peers'][0]['channels'][0]['htlcs']) == 0)
# Now, reverse should work similarly. # Now, reverse should work similarly.
payment_hash = l1.rpc.invoice('any', 'inv', 'for testing')['payment_hash'] inv = l1.rpc.invoice('any', 'inv', 'for testing')
payment_hash = inv['payment_hash']
amount = l2.rpc.listpeers()['peers'][0]['channels'][0]['spendable_msat'] amount = l2.rpc.listpeers()['peers'][0]['channels'][0]['spendable_msat']
# Turns out we won't route this, as it's over max - reserve: # Turns out we won't route this, as it's over max - reserve:
route = l2.rpc.getroute(l1.info['id'], amount + 1, riskfactor=1, fuzzpercent=0)['route'] route = l2.rpc.getroute(l1.info['id'], amount + 1, riskfactor=1, fuzzpercent=0)['route']
l2.rpc.sendpay(route, payment_hash) l2.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
# This should fail locally with "capacity exceeded" # This should fail locally with "capacity exceeded"
with pytest.raises(RpcError, match=r"Capacity exceeded.*'erring_index': 0"): with pytest.raises(RpcError, match=r"Capacity exceeded.*'erring_index': 0"):
@@ -2277,7 +2292,7 @@ def test_channel_spendable(node_factory, bitcoind):
# Exact amount should succeed. # Exact amount should succeed.
route = l2.rpc.getroute(l1.info['id'], amount, riskfactor=1, fuzzpercent=0)['route'] route = l2.rpc.getroute(l1.info['id'], amount, riskfactor=1, fuzzpercent=0)['route']
l2.rpc.sendpay(route, payment_hash) 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 # Amount should drop to 0 once HTLC is sent; we have time, thanks to
# hold_invoice.py plugin. # hold_invoice.py plugin.
@@ -2293,12 +2308,13 @@ def test_channel_receivable(node_factory, bitcoind):
l1, l2 = node_factory.line_graph(2, fundamount=sats, wait_for_announce=True, l1, l2 = node_factory.line_graph(2, fundamount=sats, wait_for_announce=True,
opts={'plugin': os.path.join(os.getcwd(), 'tests/plugins/hold_invoice.py'), 'holdtime': '30'}) opts={'plugin': os.path.join(os.getcwd(), 'tests/plugins/hold_invoice.py'), 'holdtime': '30'})
payment_hash = l2.rpc.invoice('any', 'inv', 'for testing')['payment_hash'] inv = l2.rpc.invoice('any', 'inv', 'for testing')
payment_hash = inv['payment_hash']
# We should be able to receive this much, and not one msat more! # We should be able to receive this much, and not one msat more!
amount = l2.rpc.listpeers()['peers'][0]['channels'][0]['receivable_msat'] amount = l2.rpc.listpeers()['peers'][0]['channels'][0]['receivable_msat']
route = l1.rpc.getroute(l2.info['id'], amount + 1, riskfactor=1, fuzzpercent=0)['route'] route = l1.rpc.getroute(l2.info['id'], amount + 1, riskfactor=1, fuzzpercent=0)['route']
l1.rpc.sendpay(route, payment_hash) l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
# This should fail locally with "capacity exceeded" # This should fail locally with "capacity exceeded"
with pytest.raises(RpcError, match=r"Capacity exceeded.*'erring_index': 0"): with pytest.raises(RpcError, match=r"Capacity exceeded.*'erring_index': 0"):
@@ -2306,7 +2322,7 @@ def test_channel_receivable(node_factory, bitcoind):
# Exact amount should succeed. # Exact amount should succeed.
route = l1.rpc.getroute(l2.info['id'], amount, riskfactor=1, fuzzpercent=0)['route'] route = l1.rpc.getroute(l2.info['id'], amount, riskfactor=1, fuzzpercent=0)['route']
l1.rpc.sendpay(route, payment_hash) 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 # Amount should drop to 0 once HTLC is sent; we have time, thanks to
# hold_invoice.py plugin. # hold_invoice.py plugin.
@@ -2317,12 +2333,13 @@ def test_channel_receivable(node_factory, bitcoind):
# Make sure l2 thinks it's all over. # Make sure l2 thinks it's all over.
wait_for(lambda: len(l2.rpc.listpeers()['peers'][0]['channels'][0]['htlcs']) == 0) wait_for(lambda: len(l2.rpc.listpeers()['peers'][0]['channels'][0]['htlcs']) == 0)
# Now, reverse should work similarly. # Now, reverse should work similarly.
payment_hash = l1.rpc.invoice('any', 'inv', 'for testing')['payment_hash'] inv = l1.rpc.invoice('any', 'inv', 'for testing')
payment_hash = inv['payment_hash']
amount = l1.rpc.listpeers()['peers'][0]['channels'][0]['receivable_msat'] amount = l1.rpc.listpeers()['peers'][0]['channels'][0]['receivable_msat']
# Turns out we won't route this, as it's over max - reserve: # Turns out we won't route this, as it's over max - reserve:
route = l2.rpc.getroute(l1.info['id'], amount + 1, riskfactor=1, fuzzpercent=0)['route'] route = l2.rpc.getroute(l1.info['id'], amount + 1, riskfactor=1, fuzzpercent=0)['route']
l2.rpc.sendpay(route, payment_hash) l2.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
# This should fail locally with "capacity exceeded" # This should fail locally with "capacity exceeded"
with pytest.raises(RpcError, match=r"Capacity exceeded.*'erring_index': 0"): with pytest.raises(RpcError, match=r"Capacity exceeded.*'erring_index': 0"):
@@ -2330,7 +2347,7 @@ def test_channel_receivable(node_factory, bitcoind):
# Exact amount should succeed. # Exact amount should succeed.
route = l2.rpc.getroute(l1.info['id'], amount, riskfactor=1, fuzzpercent=0)['route'] route = l2.rpc.getroute(l1.info['id'], amount, riskfactor=1, fuzzpercent=0)['route']
l2.rpc.sendpay(route, payment_hash) 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 # Amount should drop to 0 once HTLC is sent; we have time, thanks to
# hold_invoice.py plugin. # hold_invoice.py plugin.
@@ -2354,7 +2371,8 @@ def test_channel_spendable_large(node_factory, bitcoind):
} }
) )
payment_hash = l2.rpc.invoice('any', 'inv', 'for testing')['payment_hash'] inv = l2.rpc.invoice('any', 'inv', 'for testing')
payment_hash = inv['payment_hash']
# We should be able to spend this much, and not one msat more! # We should be able to spend this much, and not one msat more!
spendable = l1.rpc.listpeers()['peers'][0]['channels'][0]['spendable_msat'] spendable = l1.rpc.listpeers()['peers'][0]['channels'][0]['spendable_msat']
@@ -2366,12 +2384,12 @@ def test_channel_spendable_large(node_factory, bitcoind):
# route or waitsendpay fill fail. # route or waitsendpay fill fail.
with pytest.raises(RpcError): with pytest.raises(RpcError):
route = l1.rpc.getroute(l2.info['id'], spendable + 1, riskfactor=1, fuzzpercent=0)['route'] route = l1.rpc.getroute(l2.info['id'], spendable + 1, riskfactor=1, fuzzpercent=0)['route']
l1.rpc.sendpay(route, payment_hash) l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash, TIMEOUT) l1.rpc.waitsendpay(payment_hash, TIMEOUT)
# Exact amount should succeed. # Exact amount should succeed.
route = l1.rpc.getroute(l2.info['id'], spendable, riskfactor=1, fuzzpercent=0)['route'] route = l1.rpc.getroute(l2.info['id'], spendable, riskfactor=1, fuzzpercent=0)['route']
l1.rpc.sendpay(route, payment_hash) l1.rpc.sendpay(route, payment_hash, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash, TIMEOUT) l1.rpc.waitsendpay(payment_hash, TIMEOUT)
@@ -2417,7 +2435,7 @@ def test_error_returns_blockheight(node_factory, bitcoind):
'id': l2.info['id'], 'id': l2.info['id'],
'delay': 10, 'delay': 10,
'channel': l1.get_channel_scid(l2)}], 'channel': l1.get_channel_scid(l2)}],
'00' * 32) '00' * 32, payment_secret='00' * 32)
with pytest.raises(RpcError, match=r"INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS.*'erring_index': 1") as err: with pytest.raises(RpcError, match=r"INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS.*'erring_index': 1") as err:
l1.rpc.waitsendpay('00' * 32, TIMEOUT) l1.rpc.waitsendpay('00' * 32, TIMEOUT)
@@ -2925,18 +2943,18 @@ caused a crash in 0.8.0, so we then disallowed it.
with pytest.raises(RpcError, match=r'Do not specify msatoshi \(1001msat\) without' with pytest.raises(RpcError, match=r'Do not specify msatoshi \(1001msat\) without'
' partid: if you do, it must be exactly' ' partid: if you do, it must be exactly'
r' the final amount \(1000msat\)'): r' the final amount \(1000msat\)'):
l1.rpc.sendpay(route=l1.rpc.getroute(l2.info['id'], 1000, 1)['route'], payment_hash=inv['payment_hash'], msatoshi=1001, bolt11=inv['bolt11']) l1.rpc.sendpay(route=l1.rpc.getroute(l2.info['id'], 1000, 1)['route'], payment_hash=inv['payment_hash'], msatoshi=1001, bolt11=inv['bolt11'], payment_secret=inv['payment_secret'])
with pytest.raises(RpcError, match=r'Do not specify msatoshi \(999msat\) without' with pytest.raises(RpcError, match=r'Do not specify msatoshi \(999msat\) without'
' partid: if you do, it must be exactly' ' partid: if you do, it must be exactly'
r' the final amount \(1000msat\)'): r' the final amount \(1000msat\)'):
l1.rpc.sendpay(route=l1.rpc.getroute(l2.info['id'], 1000, 1)['route'], payment_hash=inv['payment_hash'], msatoshi=999, bolt11=inv['bolt11']) l1.rpc.sendpay(route=l1.rpc.getroute(l2.info['id'], 1000, 1)['route'], payment_hash=inv['payment_hash'], msatoshi=999, bolt11=inv['bolt11'], payment_secret=inv['payment_secret'])
# Can't send MPP payment which pays any more than amount. # Can't send MPP payment which pays any more than amount.
with pytest.raises(RpcError, match=r'Final amount 1001msat is greater than 1000msat, despite MPP'): with pytest.raises(RpcError, match=r'Final amount 1001msat is greater than 1000msat, despite MPP'):
l1.rpc.sendpay(route=l1.rpc.getroute(l2.info['id'], 1001, 1)['route'], payment_hash=inv['payment_hash'], msatoshi=1000, bolt11=inv['bolt11'], partid=1) l1.rpc.sendpay(route=l1.rpc.getroute(l2.info['id'], 1001, 1)['route'], payment_hash=inv['payment_hash'], msatoshi=1000, bolt11=inv['bolt11'], partid=1, payment_secret=inv['payment_secret'])
# But this works # But this works
l1.rpc.sendpay(route=l1.rpc.getroute(l2.info['id'], 1001, 1)['route'], payment_hash=inv['payment_hash'], msatoshi=1001, bolt11=inv['bolt11']) l1.rpc.sendpay(route=l1.rpc.getroute(l2.info['id'], 1001, 1)['route'], payment_hash=inv['payment_hash'], msatoshi=1001, bolt11=inv['bolt11'], payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(inv['payment_hash']) l1.rpc.waitsendpay(inv['payment_hash'])
inv = only_one(l2.rpc.listinvoices('inv')['invoices']) inv = only_one(l2.rpc.listinvoices('inv')['invoices'])
@@ -3017,7 +3035,7 @@ def test_sendpay_blinding(node_factory):
'style': 'tlv'}] 'style': 'tlv'}]
l1.rpc.sendpay(route=route, l1.rpc.sendpay(route=route,
payment_hash=inv['payment_hash'], payment_hash=inv['payment_hash'],
bolt11=inv['bolt11']) bolt11=inv['bolt11'], payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(inv['payment_hash']) l1.rpc.waitsendpay(inv['payment_hash'])

59
tests/test_plugin.py
View File

@@ -1001,13 +1001,14 @@ def test_htlc_accepted_hook_fail(node_factory):
], wait_for_announce=True) ], wait_for_announce=True)
# This must fail # This must fail
phash = l2.rpc.invoice(1000, "lbl", "desc")['payment_hash'] inv = l2.rpc.invoice(1000, "lbl", "desc")
phash = inv['payment_hash']
route = l1.rpc.getroute(l2.info['id'], 1000, 1)['route'] route = l1.rpc.getroute(l2.info['id'], 1000, 1)['route']
# Here shouldn't use `pay` command because l2 rejects with WIRE_TEMPORARY_NODE_FAILURE, # Here shouldn't use `pay` command because l2 rejects with WIRE_TEMPORARY_NODE_FAILURE,
# then it will be excluded when l1 try another pay attempt. # then it will be excluded when l1 try another pay attempt.
# Note if the destination is excluded, the route result is undefined. # Note if the destination is excluded, the route result is undefined.
l1.rpc.sendpay(route, phash) l1.rpc.sendpay(route, phash, payment_secret=inv['payment_secret'])
with pytest.raises(RpcError) as excinfo: with pytest.raises(RpcError) as excinfo:
l1.rpc.waitsendpay(phash) l1.rpc.waitsendpay(phash)
assert excinfo.value.error['data']['failcode'] == 0x2002 assert excinfo.value.error['data']['failcode'] == 0x2002
@@ -1231,22 +1232,24 @@ def test_forward_event_notification(node_factory, bitcoind, executor):
wait_for(lambda: len(l1.rpc.listchannels()['channels']) == 8) wait_for(lambda: len(l1.rpc.listchannels()['channels']) == 8)
payment_hash13 = l3.rpc.invoice(amount, "first", "desc")['payment_hash'] inv = l3.rpc.invoice(amount, "first", "desc")
payment_hash13 = inv['payment_hash']
route = l1.rpc.getroute(l3.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l3.info['id'], amount, 1)['route']
# status: offered -> settled # status: offered -> settled
l1.rpc.sendpay(route, payment_hash13) l1.rpc.sendpay(route, payment_hash13, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash13) l1.rpc.waitsendpay(payment_hash13)
# status: offered -> failed # status: offered -> failed
route = l1.rpc.getroute(l4.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l4.info['id'], amount, 1)['route']
payment_hash14 = "f" * 64 payment_hash14 = "f" * 64
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.sendpay(route, payment_hash14) l1.rpc.sendpay(route, payment_hash14, payment_secret="f" * 64)
l1.rpc.waitsendpay(payment_hash14) l1.rpc.waitsendpay(payment_hash14)
# status: offered -> local_failed # status: offered -> local_failed
payment_hash15 = l5.rpc.invoice(amount, 'onchain_timeout', 'desc')['payment_hash'] inv = l5.rpc.invoice(amount, 'onchain_timeout', 'desc')
payment_hash15 = inv['payment_hash']
fee = amount * 10 // 1000000 + 1 fee = amount * 10 // 1000000 + 1
c12 = l1.get_channel_scid(l2) c12 = l1.get_channel_scid(l2)
c25 = l2.get_channel_scid(l5) c25 = l2.get_channel_scid(l5)
@@ -1259,7 +1262,7 @@ def test_forward_event_notification(node_factory, bitcoind, executor):
'delay': 5, 'delay': 5,
'channel': c25}] 'channel': c25}]
executor.submit(l1.rpc.sendpay, route, payment_hash15) executor.submit(l1.rpc.sendpay, route, payment_hash15, payment_secret=inv['payment_secret'])
l5.daemon.wait_for_log('permfail') l5.daemon.wait_for_log('permfail')
l5.wait_for_channel_onchain(l2.info['id']) l5.wait_for_channel_onchain(l2.info['id'])
@@ -1320,16 +1323,18 @@ def test_sendpay_notifications(node_factory, bitcoind):
l1, l2, l3 = node_factory.line_graph(3, opts=opts, wait_for_announce=True) l1, l2, l3 = node_factory.line_graph(3, opts=opts, wait_for_announce=True)
chanid23 = l2.get_channel_scid(l3) chanid23 = l2.get_channel_scid(l3)
payment_hash1 = l3.rpc.invoice(amount, "first", "desc")['payment_hash'] inv1 = l3.rpc.invoice(amount, "first", "desc")
payment_hash2 = l3.rpc.invoice(amount, "second", "desc")['payment_hash'] payment_hash1 = inv1['payment_hash']
inv2 = l3.rpc.invoice(amount, "second", "desc")
payment_hash2 = inv2['payment_hash']
route = l1.rpc.getroute(l3.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l3.info['id'], amount, 1)['route']
l1.rpc.sendpay(route, payment_hash1) l1.rpc.sendpay(route, payment_hash1, payment_secret=inv1['payment_secret'])
response1 = l1.rpc.waitsendpay(payment_hash1) response1 = l1.rpc.waitsendpay(payment_hash1)
l2.rpc.close(chanid23, 1) l2.rpc.close(chanid23, 1)
l1.rpc.sendpay(route, payment_hash2) l1.rpc.sendpay(route, payment_hash2, payment_secret=inv2['payment_secret'])
with pytest.raises(RpcError) as err: with pytest.raises(RpcError) as err:
l1.rpc.waitsendpay(payment_hash2) l1.rpc.waitsendpay(payment_hash2)
@@ -1349,16 +1354,18 @@ def test_sendpay_notifications_nowaiter(node_factory):
chanid23 = l2.get_channel_scid(l3) chanid23 = l2.get_channel_scid(l3)
amount = 10**8 amount = 10**8
payment_hash1 = l3.rpc.invoice(amount, "first", "desc")['payment_hash'] inv1 = l3.rpc.invoice(amount, "first", "desc")
payment_hash2 = l3.rpc.invoice(amount, "second", "desc")['payment_hash'] payment_hash1 = inv1['payment_hash']
inv2 = l3.rpc.invoice(amount, "second", "desc")
payment_hash2 = inv2['payment_hash']
route = l1.rpc.getroute(l3.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l3.info['id'], amount, 1)['route']
l1.rpc.sendpay(route, payment_hash1) l1.rpc.sendpay(route, payment_hash1, payment_secret=inv1['payment_secret'])
l1.daemon.wait_for_log(r'Received a sendpay_success') l1.daemon.wait_for_log(r'Received a sendpay_success')
l2.rpc.close(chanid23, 1) l2.rpc.close(chanid23, 1)
l1.rpc.sendpay(route, payment_hash2) l1.rpc.sendpay(route, payment_hash2, payment_secret=inv2['payment_secret'])
l1.daemon.wait_for_log(r'Received a sendpay_failure') l1.daemon.wait_for_log(r'Received a sendpay_failure')
results = l1.rpc.call('listsendpays_plugin') results = l1.rpc.call('listsendpays_plugin')
@@ -1980,36 +1987,40 @@ def test_coin_movement_notices(node_factory, bitcoind, chainparams):
wait_for(lambda: len(l1.rpc.listchannels()['channels']) == 4) wait_for(lambda: len(l1.rpc.listchannels()['channels']) == 4)
amount = 10**8 amount = 10**8
payment_hash13 = l3.rpc.invoice(amount, "first", "desc")['payment_hash'] inv = l3.rpc.invoice(amount, "first", "desc")
payment_hash13 = inv['payment_hash']
route = l1.rpc.getroute(l3.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l3.info['id'], amount, 1)['route']
# status: offered -> settled # status: offered -> settled
l1.rpc.sendpay(route, payment_hash13) l1.rpc.sendpay(route, payment_hash13, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash13) l1.rpc.waitsendpay(payment_hash13)
# status: offered -> failed # status: offered -> failed
route = l1.rpc.getroute(l3.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l3.info['id'], amount, 1)['route']
payment_hash13 = "f" * 64 payment_hash13 = "f" * 64
with pytest.raises(RpcError): with pytest.raises(RpcError):
l1.rpc.sendpay(route, payment_hash13) l1.rpc.sendpay(route, payment_hash13, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash13) l1.rpc.waitsendpay(payment_hash13)
# go the other direction # go the other direction
payment_hash31 = l1.rpc.invoice(amount // 2, "first", "desc")['payment_hash'] inv = l1.rpc.invoice(amount // 2, "first", "desc")
payment_hash31 = inv['payment_hash']
route = l3.rpc.getroute(l1.info['id'], amount // 2, 1)['route'] route = l3.rpc.getroute(l1.info['id'], amount // 2, 1)['route']
l3.rpc.sendpay(route, payment_hash31) l3.rpc.sendpay(route, payment_hash31, payment_secret=inv['payment_secret'])
l3.rpc.waitsendpay(payment_hash31) l3.rpc.waitsendpay(payment_hash31)
# receive a payment (endpoint) # receive a payment (endpoint)
payment_hash12 = l2.rpc.invoice(amount, "first", "desc")['payment_hash'] inv = l2.rpc.invoice(amount, "first", "desc")
payment_hash12 = inv['payment_hash']
route = l1.rpc.getroute(l2.info['id'], amount, 1)['route'] route = l1.rpc.getroute(l2.info['id'], amount, 1)['route']
l1.rpc.sendpay(route, payment_hash12) l1.rpc.sendpay(route, payment_hash12, payment_secret=inv['payment_secret'])
l1.rpc.waitsendpay(payment_hash12) l1.rpc.waitsendpay(payment_hash12)
# send a payment (originator) # send a payment (originator)
payment_hash21 = l1.rpc.invoice(amount // 2, "second", "desc")['payment_hash'] inv = l1.rpc.invoice(amount // 2, "second", "desc")
payment_hash21 = inv['payment_hash']
route = l2.rpc.getroute(l1.info['id'], amount // 2, 1)['route'] route = l2.rpc.getroute(l1.info['id'], amount // 2, 1)['route']
l2.rpc.sendpay(route, payment_hash21) l2.rpc.sendpay(route, payment_hash21, payment_secret=inv['payment_secret'])
l2.rpc.waitsendpay(payment_hash21) l2.rpc.waitsendpay(payment_hash21)
# restart to test index # restart to test index