LBRYFoundation/LBRY-Vault
1
0
Fork 0
mirror of https://github.com/LBRYFoundation/LBRY-Vault.git synced 2025-08-23 17:47:31 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

lnworker: return error reason in await_payment

Browse source
This commit is contained in:
ThomasV 2019-10-11 13:37:54 +02:00
parent 0557738a6b
commit d6d644190e
2 changed files with 21 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
electrum/lnpeer.py
View file

@ -1091,19 +1091,20 @@ class Peer(Logger):
def on_update_fail_htlc(self, payload): def on_update_fail_htlc(self, payload):
channel_id = payload["channel_id"] channel_id = payload["channel_id"]
htlc_id = int.from_bytes(payload["id"], "big") htlc_id = int.from_bytes(payload["id"], "big")
reason = payload["reason"]
chan = self.channels[channel_id] chan = self.channels[channel_id]
self.logger.info(f"on_update_fail_htlc. chan {chan.short_channel_id}. htlc_id {htlc_id}") self.logger.info(f"on_update_fail_htlc. chan {chan.short_channel_id}. htlc_id {htlc_id}")
chan.receive_fail_htlc(htlc_id) chan.receive_fail_htlc(htlc_id)
local_ctn = chan.get_latest_ctn(LOCAL) local_ctn = chan.get_latest_ctn(LOCAL)
asyncio.ensure_future(self._handle_error_code_from_failed_htlc(payload, channel_id, htlc_id)) asyncio.ensure_future(self._handle_error_code_from_failed_htlc(payload, channel_id, htlc_id))
asyncio.ensure_future(self._on_update_fail_htlc(channel_id, htlc_id, local_ctn)) asyncio.ensure_future(self._on_update_fail_htlc(channel_id, htlc_id, local_ctn, reason))
@log_exceptions @log_exceptions
async def _on_update_fail_htlc(self, channel_id, htlc_id, local_ctn): async def _on_update_fail_htlc(self, channel_id, htlc_id, local_ctn, reason):
chan = self.channels[channel_id] chan = self.channels[channel_id]
await self.await_local(chan, local_ctn) await self.await_local(chan, local_ctn)
payment_hash = chan.get_payment_hash(htlc_id) payment_hash = chan.get_payment_hash(htlc_id)
self.lnworker.payment_sent(payment_hash, False) self.lnworker.payment_failed(payment_hash, reason)
@log_exceptions @log_exceptions
async def _handle_error_code_from_failed_htlc(self, payload, channel_id, htlc_id): async def _handle_error_code_from_failed_htlc(self, payload, channel_id, htlc_id):
@ -1273,7 +1274,7 @@ class Peer(Logger):
@log_exceptions @log_exceptions
async def _on_update_fulfill_htlc(self, chan, local_ctn, payment_hash): async def _on_update_fulfill_htlc(self, chan, local_ctn, payment_hash):
await self.await_local(chan, local_ctn) await self.await_local(chan, local_ctn)
self.lnworker.payment_sent(payment_hash, True) self.lnworker.payment_sent(payment_hash)
def on_update_fail_malformed_htlc(self, payload): def on_update_fail_malformed_htlc(self, payload):
self.logger.info(f"on_update_fail_malformed_htlc. error {payload['data'].decode('ascii')}") self.logger.info(f"on_update_fail_malformed_htlc. error {payload['data'].decode('ascii')}")
@ -1391,13 +1392,13 @@ class Peer(Logger):
onion_routing_packet=processed_onion.next_packet.to_bytes() onion_routing_packet=processed_onion.next_packet.to_bytes()
) )
await next_peer.await_remote(next_chan, next_remote_ctn) await next_peer.await_remote(next_chan, next_remote_ctn)
success, preimage = await self.lnworker.await_payment(next_htlc.payment_hash) success, preimage, reason = await self.lnworker.await_payment(next_htlc.payment_hash)
if success: if success:
await self._fulfill_htlc(chan, htlc.htlc_id, preimage) await self._fulfill_htlc(chan, htlc.htlc_id, preimage)
self.logger.info("htlc forwarded successfully") self.logger.info("htlc forwarded successfully")
else: else:
self.logger.info("htlc not fulfilled") # TODO: test this
# TODO: Read error code and forward it, as follows: self.logger.info(f"forwarded htlc has failed, {reason}")
await self.fail_htlc(chan, htlc.htlc_id, onion_packet, reason) await self.fail_htlc(chan, htlc.htlc_id, onion_packet, reason)
@log_exceptions @log_exceptions

23
electrum/lnworker.py
View file

@ -862,7 +862,8 @@ class LNWallet(LNWorker):
for i in range(attempts): for i in range(attempts):
route = await self._create_route_from_invoice(decoded_invoice=lnaddr) route = await self._create_route_from_invoice(decoded_invoice=lnaddr)
self.network.trigger_callback('payment_status', key, 'progress', i) self.network.trigger_callback('payment_status', key, 'progress', i)
if await self._pay_to_route(route, lnaddr): success, preimage, reason = await self._pay_to_route(route, lnaddr)
if success:
return True return True
return False return False
@ -876,8 +877,7 @@ class LNWallet(LNWorker):
peer = self.peers[route[0].node_id] peer = self.peers[route[0].node_id]
htlc = await peer.pay(route, chan, int(lnaddr.amount * COIN * 1000), lnaddr.paymenthash, lnaddr.get_min_final_cltv_expiry()) htlc = await peer.pay(route, chan, int(lnaddr.amount * COIN * 1000), lnaddr.paymenthash, lnaddr.get_min_final_cltv_expiry())
self.network.trigger_callback('htlc_added', htlc, lnaddr, SENT) self.network.trigger_callback('htlc_added', htlc, lnaddr, SENT)
success, preimage = await self.await_payment(lnaddr.paymenthash) return await self.await_payment(lnaddr.paymenthash)
return success
@staticmethod @staticmethod
def _check_invoice(invoice, amount_sat=None): def _check_invoice(invoice, amount_sat=None):
@ -1028,10 +1028,9 @@ class LNWallet(LNWorker):
return status return status
async def await_payment(self, payment_hash): async def await_payment(self, payment_hash):
success = await self.pending_payments[payment_hash] success, preimage, reason = await self.pending_payments[payment_hash]
self.pending_payments.pop(payment_hash) self.pending_payments.pop(payment_hash)
preimage = self.get_preimage(payment_hash) return success, preimage, reason
return success, preimage
def set_payment_status(self, payment_hash: bytes, status): def set_payment_status(self, payment_hash: bytes, status):
try: try:
@ -1042,10 +1041,14 @@ class LNWallet(LNWorker):
info = info._replace(status=status) info = info._replace(status=status)
self.save_payment_info(info) self.save_payment_info(info)
def payment_sent(self, payment_hash: bytes, success): def payment_failed(self, payment_hash: bytes, reason):
status = PR_PAID if success else PR_UNPAID self.set_payment_status(payment_hash, PR_UNPAID)
self.set_payment_status(payment_hash, status) self.pending_payments[payment_hash].set_result((False, None, reason))
self.pending_payments[payment_hash].set_result(success)
def payment_sent(self, payment_hash: bytes):
self.set_payment_status(payment_hash, PR_PAID)
preimage = self.get_preimage(payment_hash)
self.pending_payments[payment_hash].set_result((True, preimage, None))
def payment_received(self, payment_hash: bytes): def payment_received(self, payment_hash: bytes):
self.set_payment_status(payment_hash, PR_PAID) self.set_payment_status(payment_hash, PR_PAID)