lukechilds
/
electrum
mirror of https://github.com/lukechilds/electrum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

save timestamps in htlc log

dependabot/pip/contrib/deterministic-build/ecdsa-0.13.3
ThomasV 6 years ago
parent
ecd9508233
commit
8d77a7ecd8
6 changed files with 40 additions and 39 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      electrum/gui/qt/invoice_list.py
  2. 6
      electrum/gui/qt/request_list.py
  3. 6
      electrum/lnchannel.py
  4. 6
      electrum/lnpeer.py
  5. 2
      electrum/lnutil.py
  6. 53
      electrum/lnworker.py

6
electrum/gui/qt/invoice_list.py
View File

@ -31,7 +31,7 @@ from PyQt5.QtWidgets import QHeaderView, QMenu
from electrum.i18n import _ from electrum.i18n import _
from electrum.util import format_time, pr_tooltips, PR_UNPAID from electrum.util import format_time, pr_tooltips, PR_UNPAID
from electrum.lnutil import lndecode from electrum.lnutil import lndecode, RECEIVED
from electrum.bitcoin import COIN from electrum.bitcoin import COIN
from electrum import constants from electrum import constants
@ -92,8 +92,8 @@ class InvoiceList(MyTreeView):
self.model().insertRow(idx, items) self.model().insertRow(idx, items)
lnworker = self.parent.wallet.lnworker lnworker = self.parent.wallet.lnworker
for key, (invoice, is_received) in lnworker.invoices.items(): for key, (invoice, direction, is_paid) in lnworker.invoices.items():
if is_received: if direction == RECEIVED:
continue continue
status = lnworker.get_invoice_status(key) status = lnworker.get_invoice_status(key)
lnaddr = lndecode(invoice, expected_hrp=constants.net.SEGWIT_HRP) lnaddr = lndecode(invoice, expected_hrp=constants.net.SEGWIT_HRP)

6
electrum/gui/qt/request_list.py
View File

@ -94,7 +94,7 @@ class RequestList(MyTreeView):
return return
req = self.parent.get_request_URI(key) req = self.parent.get_request_URI(key)
elif request_type == REQUEST_TYPE_LN: elif request_type == REQUEST_TYPE_LN:
req, is_received = self.wallet.lnworker.invoices.get(key) or (None, None) req, direction, is_paid = self.wallet.lnworker.invoices.get(key) or (None, None)
if req is None: if req is None:
self.update() self.update()
return return
@ -136,8 +136,8 @@ class RequestList(MyTreeView):
self.filter() self.filter()
# lightning # lightning
lnworker = self.wallet.lnworker lnworker = self.wallet.lnworker
for key, (invoice, is_received) in lnworker.invoices.items(): for key, (invoice, direction, is_paid) in lnworker.invoices.items():
if not is_received: if direction == SENT:
continue continue
status = lnworker.get_invoice_status(key) status = lnworker.get_invoice_status(key)
lnaddr = lndecode(invoice, expected_hrp=constants.net.SEGWIT_HRP) lnaddr = lndecode(invoice, expected_hrp=constants.net.SEGWIT_HRP)

6
electrum/lnchannel.py
View File

@ -613,9 +613,8 @@ class Channel(PrintError):
assert htlc.payment_hash == sha256(preimage) assert htlc.payment_hash == sha256(preimage)
assert htlc_id not in log['settles'] assert htlc_id not in log['settles']
self.hm.send_settle(htlc_id) self.hm.send_settle(htlc_id)
# save timestamp in LNWorker.preimages
if self.lnworker: if self.lnworker:
self.lnworker.save_preimage(htlc.payment_hash, preimage, timestamp=int(time.time())) self.lnworker.set_paid(htlc.payment_hash)
def receive_htlc_settle(self, preimage, htlc_id): def receive_htlc_settle(self, preimage, htlc_id):
self.print_error("receive_htlc_settle") self.print_error("receive_htlc_settle")
@ -625,7 +624,8 @@ class Channel(PrintError):
assert htlc_id not in log['settles'] assert htlc_id not in log['settles']
self.hm.recv_settle(htlc_id) self.hm.recv_settle(htlc_id)
if self.lnworker: if self.lnworker:
self.lnworker.save_preimage(htlc.payment_hash, preimage, timestamp=int(time.time())) self.lnworker.save_preimage(htlc.payment_hash, preimage)
self.lnworker.set_paid(htlc.payment_hash)
def fail_htlc(self, htlc_id): def fail_htlc(self, htlc_id):
self.print_error("fail_htlc") self.print_error("fail_htlc")

6
electrum/lnpeer.py
View File

@ -864,7 +864,7 @@ class Peer(PrintError):
secret_key = os.urandom(32) secret_key = os.urandom(32)
onion = new_onion_packet([x.node_id for x in route], secret_key, hops_data, associated_data=payment_hash) onion = new_onion_packet([x.node_id for x in route], secret_key, hops_data, associated_data=payment_hash)
# create htlc # create htlc
htlc = UpdateAddHtlc(amount_msat=amount_msat, payment_hash=payment_hash, cltv_expiry=cltv) htlc = UpdateAddHtlc(amount_msat=amount_msat, payment_hash=payment_hash, cltv_expiry=cltv, timestamp=int(time.time()))
htlc = chan.add_htlc(htlc) htlc = chan.add_htlc(htlc)
remote_ctn = chan.get_current_ctn(REMOTE) remote_ctn = chan.get_current_ctn(REMOTE)
chan.onion_keys[htlc.htlc_id] = secret_key chan.onion_keys[htlc.htlc_id] = secret_key
@ -943,7 +943,7 @@ class Peer(PrintError):
if cltv_expiry >= 500_000_000: if cltv_expiry >= 500_000_000:
pass # TODO fail the channel pass # TODO fail the channel
# add htlc # add htlc
htlc = UpdateAddHtlc(amount_msat=amount_msat_htlc, payment_hash=payment_hash, cltv_expiry=cltv_expiry) htlc = UpdateAddHtlc(amount_msat=amount_msat_htlc, payment_hash=payment_hash, cltv_expiry=cltv_expiry, timestamp=int(time.time()))
htlc = chan.receive_htlc(htlc) htlc = chan.receive_htlc(htlc)
local_ctn = chan.get_current_ctn(LOCAL) local_ctn = chan.get_current_ctn(LOCAL)
remote_ctn = chan.get_current_ctn(REMOTE) remote_ctn = chan.get_current_ctn(REMOTE)
@ -980,7 +980,7 @@ class Peer(PrintError):
self.print_error('forwarding htlc to', next_chan.node_id) self.print_error('forwarding htlc to', next_chan.node_id)
next_cltv_expiry = int.from_bytes(dph.outgoing_cltv_value, 'big') next_cltv_expiry = int.from_bytes(dph.outgoing_cltv_value, 'big')
next_amount_msat_htlc = int.from_bytes(dph.amt_to_forward, 'big') next_amount_msat_htlc = int.from_bytes(dph.amt_to_forward, 'big')
next_htlc = UpdateAddHtlc(amount_msat=next_amount_msat_htlc, payment_hash=htlc.payment_hash, cltv_expiry=next_cltv_expiry) next_htlc = UpdateAddHtlc(amount_msat=next_amount_msat_htlc, payment_hash=htlc.payment_hash, cltv_expiry=next_cltv_expiry, timestamp=int(time.time()))
next_htlc = next_chan.add_htlc(next_htlc) next_htlc = next_chan.add_htlc(next_htlc)
next_remote_ctn = next_chan.get_current_ctn(REMOTE) next_remote_ctn = next_chan.get_current_ctn(REMOTE)
next_peer.send_message( next_peer.send_message(

2
electrum/lnutil.py
View File

@ -666,7 +666,7 @@ def format_short_channel_id(short_channel_id: Optional[bytes]):
+ 'x' + str(int.from_bytes(short_channel_id[6:], 'big')) + 'x' + str(int.from_bytes(short_channel_id[6:], 'big'))
class UpdateAddHtlc(namedtuple('UpdateAddHtlc', ['amount_msat', 'payment_hash', 'cltv_expiry', 'htlc_id'])): class UpdateAddHtlc(namedtuple('UpdateAddHtlc', ['amount_msat', 'payment_hash', 'cltv_expiry', 'htlc_id', 'timestamp'])):
# note: typing.NamedTuple cannot be used because we are overriding __new__ # note: typing.NamedTuple cannot be used because we are overriding __new__
__slots__ = () __slots__ = ()

53
electrum/lnworker.py
View File

@ -71,8 +71,8 @@ class LNWorker(PrintError):
def __init__(self, wallet: 'Abstract_Wallet'): def __init__(self, wallet: 'Abstract_Wallet'):
self.wallet = wallet self.wallet = wallet
self.storage = wallet.storage self.storage = wallet.storage
self.invoices = self.storage.get('lightning_invoices', {}) # RHASH -> (invoice, is_received) self.invoices = self.storage.get('lightning_invoices', {}) # RHASH -> (invoice, direction, is_paid)
self.preimages = self.storage.get('lightning_preimages', {}) # RHASH -> (preimage, timestamp) self.preimages = self.storage.get('lightning_preimages', {}) # RHASH -> preimage
self.sweep_address = wallet.get_receiving_address() self.sweep_address = wallet.get_receiving_address()
self.lock = threading.RLock() self.lock = threading.RLock()
self.ln_keystore = self._read_ln_keystore() self.ln_keystore = self._read_ln_keystore()
@ -133,13 +133,11 @@ class LNWorker(PrintError):
timestamp = int(time.time()) timestamp = int(time.time())
self.network.trigger_callback('ln_payment_completed', timestamp, direction, htlc, preimage, chan_id) self.network.trigger_callback('ln_payment_completed', timestamp, direction, htlc, preimage, chan_id)
def get_invoice_status(self, payment_hash): def get_invoice_status(self, key):
if payment_hash not in self.preimages: if key not in self.invoices:
return PR_UNKNOWN return PR_UNKNOWN
preimage, timestamp = self.preimages.get(payment_hash) invoice, direction, is_paid = self.invoices[key]
if timestamp is None: return PR_PAID if is_paid else PR_UNPAID
return PR_UNPAID
return PR_PAID
def get_payments(self): def get_payments(self):
# return one item per payment_hash # return one item per payment_hash
@ -159,14 +157,15 @@ class LNWorker(PrintError):
direction = 'sent' if _direction == SENT else 'received' direction = 'sent' if _direction == SENT else 'received'
amount_msat= int(_direction) * htlc.amount_msat amount_msat= int(_direction) * htlc.amount_msat
label = '' label = ''
timestamp = htlc.timestamp
else: else:
# assume forwarding # assume forwarding
direction = 'forwarding' direction = 'forwarding'
amount_msat = sum([int(_direction) * htlc.amount_msat for chan_id, htlc, _direction, status in plist]) amount_msat = sum([int(_direction) * htlc.amount_msat for chan_id, htlc, _direction, status in plist])
status = '' status = ''
label = _('Forwarding') label = _('Forwarding')
timestamp = min([htlc.timestamp for chan_id, htlc, _direction, status in plist])
timestamp = self.preimages[payment_hash][1] if payment_hash in self.preimages else None
item = { item = {
'type': 'payment', 'type': 'payment',
'label': label, 'label': label,
@ -490,7 +489,7 @@ class LNWorker(PrintError):
if not chan: if not chan:
raise Exception("PathFinder returned path with short_channel_id {} that is not in channel list".format(bh2u(short_channel_id))) raise Exception("PathFinder returned path with short_channel_id {} that is not in channel list".format(bh2u(short_channel_id)))
peer = self.peers[route[0].node_id] peer = self.peers[route[0].node_id]
self.save_invoice(addr.paymenthash, pay_req, SENT) self.save_invoice(addr.paymenthash, pay_req, SENT, is_paid=False)
htlc = await peer.pay(route, chan, int(addr.amount * COIN * 1000), addr.paymenthash, addr.get_min_final_cltv_expiry()) htlc = await peer.pay(route, chan, int(addr.amount * COIN * 1000), addr.paymenthash, addr.get_min_final_cltv_expiry())
self.network.trigger_callback('htlc_added', htlc, addr, SENT) self.network.trigger_callback('htlc_added', htlc, addr, SENT)
@ -574,40 +573,42 @@ class LNWorker(PrintError):
('c', MIN_FINAL_CLTV_EXPIRY_FOR_INVOICE)] ('c', MIN_FINAL_CLTV_EXPIRY_FOR_INVOICE)]
+ routing_hints), + routing_hints),
self.node_keypair.privkey) self.node_keypair.privkey)
self.save_invoice(payment_hash, invoice, RECEIVED) self.save_invoice(payment_hash, invoice, RECEIVED, is_paid=False)
self.save_preimage(payment_hash, payment_preimage, timestamp=None) self.save_preimage(payment_hash, payment_preimage)
return invoice return invoice
def save_preimage(self, payment_hash: bytes, preimage: bytes, *, timestamp: Optional[int]): def save_preimage(self, payment_hash: bytes, preimage: bytes):
assert sha256(preimage) == payment_hash assert sha256(preimage) == payment_hash
if timestamp is not None:
timestamp = int(timestamp)
key = bh2u(payment_hash) key = bh2u(payment_hash)
self.preimages[key] = bh2u(preimage), timestamp self.preimages[key] = bh2u(preimage)
self.storage.put('lightning_preimages', self.preimages) self.storage.put('lightning_preimages', self.preimages)
self.storage.write() self.storage.write()
def get_preimage_and_timestamp(self, payment_hash: bytes) -> Tuple[bytes, int]: def get_preimage(self, payment_hash: bytes) -> bytes:
try: try:
preimage_hex, timestamp = self.preimages[bh2u(payment_hash)] preimage = bfh(self.preimages[bh2u(payment_hash)])
preimage = bfh(preimage_hex)
assert sha256(preimage) == payment_hash assert sha256(preimage) == payment_hash
return preimage, timestamp return preimage
except KeyError as e: except KeyError as e:
raise UnknownPaymentHash(payment_hash) from e raise UnknownPaymentHash(payment_hash) from e
def get_preimage(self, payment_hash: bytes) -> bytes: def save_invoice(self, payment_hash:bytes, invoice, direction, *, is_paid=False):
return self.get_preimage_and_timestamp(payment_hash)[0]
def save_invoice(self, payment_hash:bytes, invoice, direction):
key = bh2u(payment_hash) key = bh2u(payment_hash)
self.invoices[key] = invoice, direction==RECEIVED self.invoices[key] = invoice, direction, is_paid
self.storage.put('lightning_invoices', self.invoices) self.storage.put('lightning_invoices', self.invoices)
self.storage.write() self.storage.write()
def set_paid(self, payment_hash):
key = bh2u(payment_hash)
if key not in self.invoices:
# if we are forwarding
return
invoice, direction, _ = self.invoices[key]
self.save_invoice(payment_hash, invoice, direction, is_paid=True)
def get_invoice(self, payment_hash: bytes) -> LnAddr: def get_invoice(self, payment_hash: bytes) -> LnAddr:
try: try:
invoice, is_received = self.invoices[bh2u(payment_hash)] invoice, direction, is_paid = self.invoices[bh2u(payment_hash)]
return lndecode(invoice, expected_hrp=constants.net.SEGWIT_HRP) return lndecode(invoice, expected_hrp=constants.net.SEGWIT_HRP)
except KeyError as e: except KeyError as e:
raise UnknownPaymentHash(payment_hash) from e raise UnknownPaymentHash(payment_hash) from e

Write Preview
Loading…
Cancel
Save