AaronFiore/electrum
1
0
Fork 0
Code Activity

rename lnworker._pay to pay_invoice, call it directly from GUIs

Browse Source
This commit is contained in:
ThomasV
2021-02-07 12:09:37 +01:00
parent 9c4807644b
commit 0c93394513
6 changed files with 19 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
electrum/commands.py
View File

@@ -1011,7 +1011,7 @@ class Commands:
lnaddr = lnworker._check_invoice(invoice)
payment_hash = lnaddr.paymenthash
wallet.save_invoice(LNInvoice.from_bech32(invoice))
success, log = await lnworker._pay(invoice, attempts=attempts)
success, log = await lnworker.pay_invoice(invoice, attempts=attempts)
return {
'payment_hash': payment_hash.hex(),
'success': success,

4
electrum/gui/kivy/uix/screens.py
View File

@@ -367,7 +367,9 @@ class SendScreen(CScreen, Logger):
def _do_pay_lightning(self, invoice: LNInvoice, pw) -> None:
def pay_thread():
try:
self.app.wallet.lnworker.pay(invoice.invoice, attempts=10)
coro = self.app.wallet.lnworker.pay_invoice(invoice.invoice, attempts=10)
fut = asyncio.run_coroutine_threadsafe(coro, self.app.network.asyncio_loop)
fut.result()
except Exception as e:
self.app.show_error(repr(e))
self.save_invoice(invoice)

5
electrum/gui/qt/main_window.py
View File

@@ -1523,9 +1523,10 @@ class ElectrumWindow(QMainWindow, MessageBoxMixin, Logger):
if not self.question(msg):
return
self.save_pending_invoice()
attempts = LN_NUM_PAYMENT_ATTEMPTS
def task():
self.wallet.lnworker.pay(invoice, amount_msat=amount_msat, attempts=attempts)
coro = self.wallet.lnworker.pay_invoice(invoice, amount_msat=amount_msat, attempts=LN_NUM_PAYMENT_ATTEMPTS)
fut = asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)
return fut.result()
self.wallet.thread.add(task)
def on_request_status(self, wallet, key, status):

10
electrum/lnworker.py
View File

@@ -930,21 +930,13 @@ class LNWallet(LNWorker):
return chan, funding_tx
def pay(self, invoice: str, *, amount_msat: int = None, attempts: int = 1) -> Tuple[bool, List[HtlcLog]]:
"""
Can be called from other threads
"""
coro = self._pay(invoice, amount_msat=amount_msat, attempts=attempts)
fut = asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)
return fut.result()
def get_channel_by_short_id(self, short_channel_id: bytes) -> Optional[Channel]:
for chan in self.channels.values():
if chan.short_channel_id == short_channel_id:
return chan
@log_exceptions
async def _pay(
async def pay_invoice(
self, invoice: str, *,
amount_msat: int = None,
attempts: int = 1,

4
electrum/submarine_swaps.py
View File

@@ -418,9 +418,9 @@ class SwapManager(Logger):
# initiate payment.
if fee_invoice:
self.prepayments[prepay_hash] = preimage_hash
asyncio.ensure_future(self.lnworker._pay(fee_invoice, attempts=10))
asyncio.ensure_future(self.lnworker.pay_invoice(fee_invoice, attempts=10))
# initiate payment.
success, log = await self.lnworker._pay(invoice, attempts=10)
success, log = await self.lnworker.pay_invoice(invoice, attempts=10)
return success
async def get_pairs(self) -> None:

18
electrum/tests/test_lnpeer.py
View File

@@ -178,7 +178,7 @@ class MockLNWallet(Logger, NetworkRetryManager[LNPeerAddr]):
create_routes_from_invoice = LNWallet.create_routes_from_invoice
_check_invoice = staticmethod(LNWallet._check_invoice)
pay_to_route = LNWallet.pay_to_route
_pay = LNWallet._pay
pay_invoice = LNWallet.pay_invoice
force_close_channel = LNWallet.force_close_channel
try_force_closing = LNWallet.try_force_closing
get_first_timestamp = lambda self: 0
@@ -422,7 +422,7 @@ class TestPeer(ElectrumTestCase):
p1, p2, w1, w2, _q1, _q2 = self.prepare_peers(alice_channel, bob_channel)
pay_req = run(self.prepare_invoice(w2))
async def pay():
result, log = await w1._pay(pay_req)
result, log = await w1.pay_invoice(pay_req)
self.assertEqual(result, True)
gath.cancel()
gath = asyncio.gather(pay(), p1._message_loop(), p2._message_loop(), p1.htlc_switch(), p2.htlc_switch())
@@ -454,7 +454,7 @@ class TestPeer(ElectrumTestCase):
alice_channel, bob_channel = create_test_channels()
p1, p2, w1, w2, _q1, _q2 = self.prepare_peers(alice_channel, bob_channel)
async def pay(pay_req):
result, log = await w1._pay(pay_req)
result, log = await w1.pay_invoice(pay_req)
self.assertTrue(result)
raise PaymentDone()
async def f():
@@ -547,7 +547,7 @@ class TestPeer(ElectrumTestCase):
max_htlcs_in_flight = asyncio.Semaphore(5)
async def single_payment(pay_req):
async with max_htlcs_in_flight:
await w1._pay(pay_req)
await w1.pay_invoice(pay_req)
async def many_payments():
async with TaskGroup() as group:
pay_reqs_tasks = [await group.spawn(self.prepare_invoice(w2, amount_msat=payment_value_msat))
@@ -572,7 +572,7 @@ class TestPeer(ElectrumTestCase):
graph = self.prepare_chans_and_peers_in_square()
peers = graph.all_peers()
async def pay(pay_req):
result, log = await graph.w_a._pay(pay_req)
result, log = await graph.w_a.pay_invoice(pay_req)
self.assertTrue(result)
raise PaymentDone()
async def f():
@@ -595,15 +595,15 @@ class TestPeer(ElectrumTestCase):
path = [PathEdge(node_id=graph.w_c.node_keypair.pubkey, short_channel_id=graph.chan_ab.short_channel_id),
PathEdge(node_id=graph.w_d.node_keypair.pubkey, short_channel_id=graph.chan_bd.short_channel_id)]
with self.assertRaises(LNPathInconsistent):
await graph.w_a._pay(pay_req, full_path=path)
await graph.w_a.pay_invoice(pay_req, full_path=path)
with self.subTest(msg="bad path: last node id differs from invoice pubkey"):
path = [PathEdge(node_id=graph.w_b.node_keypair.pubkey, short_channel_id=graph.chan_ab.short_channel_id)]
with self.assertRaises(LNPathInconsistent):
await graph.w_a._pay(pay_req, full_path=path)
await graph.w_a.pay_invoice(pay_req, full_path=path)
with self.subTest(msg="good path"):
path = [PathEdge(node_id=graph.w_b.node_keypair.pubkey, short_channel_id=graph.chan_ab.short_channel_id),
PathEdge(node_id=graph.w_d.node_keypair.pubkey, short_channel_id=graph.chan_bd.short_channel_id)]
result, log = await graph.w_a._pay(pay_req, full_path=path)
result, log = await graph.w_a.pay_invoice(pay_req, full_path=path)
self.assertTrue(result)
self.assertEqual(
[edge.short_channel_id for edge in path],
@@ -627,7 +627,7 @@ class TestPeer(ElectrumTestCase):
graph.w_c.network.config.set_key('test_fail_htlcs_with_temp_node_failure', True)
peers = graph.all_peers()
async def pay(pay_req):
result, log = await graph.w_a._pay(pay_req)
result, log = await graph.w_a.pay_invoice(pay_req)
self.assertFalse(result)
self.assertEqual(OnionFailureCode.TEMPORARY_NODE_FAILURE, log[0].failure_msg.code)
raise PaymentDone()