tln: store HTLCStateMachine in lnworker.channels - electrum - Electrum Bitcoin wallet
HTML git clone https://git.parazyd.org/electrum
DIR Log
DIR Files
DIR Refs
DIR Submodules
---
DIR commit 77e9abc6552a71e2382c72a8a97aab782ba7e513
DIR parent 0d4593eebf84a13a8c8e351b66e817cc8c53ddbd
HTML Author: Janus <ysangkok@gmail.com>
Date: Wed, 27 Jun 2018 18:33:55 +0200
ln: store HTLCStateMachine in lnworker.channels
Diffstat:
M electrum/commands.py | 2 +-
M gui/qt/channels_list.py | 7 ++++---
M lib/lnbase.py | 173 ++++++++++++++++---------------
M lib/lnhtlc.py | 16 ++++++++++++++++
M lib/lnwatcher.py | 2 +-
M lib/lnworker.py | 77 ++++++++++++++++---------------
M lib/tests/test_lnhtlc.py | 36 ++++++++++++++++++++++---------
7 files changed, 176 insertions(+), 137 deletions(-)
---
DIR diff --git a/electrum/commands.py b/electrum/commands.py
t@@ -766,7 +766,7 @@ class Commands:
# lightning network commands
@command('wpn')
def open_channel(self, node_id, amount, channel_push=0, password=None):
- f = self.wallet.lnworker.open_channel(node_id, satoshis(amount), satoshis(channel_push), password)
+ f = self.wallet.lnworker.open_channel(bytes.fromhex(node_id), satoshis(amount), satoshis(channel_push), password)
return f.result()
@command('wn')
DIR diff --git a/gui/qt/channels_list.py b/gui/qt/channels_list.py
t@@ -33,7 +33,8 @@ class ChannelsList(MyTreeWidget):
channel_id = self.currentItem().data(0, QtCore.Qt.UserRole)
print('ID', bh2u(channel_id))
def close():
- self.parent.wallet.lnworker.close_channel(channel_id)
+ suc, msg = self.parent.wallet.lnworker.close_channel(channel_id)
+ assert suc # TODO show error message in dialog
menu.addAction(_("Close channel"), close)
menu.exec_(self.viewport().mapToGlobal(position))
t@@ -49,8 +50,8 @@ class ChannelsList(MyTreeWidget):
def do_update_rows(self):
self.clear()
for chan in self.parent.wallet.lnworker.channels.values():
- item = SortableTreeWidgetItem(self.format_fields(chan))
- item.setData(0, QtCore.Qt.UserRole, chan.channel_id)
+ item = SortableTreeWidgetItem(self.format_fields(chan.state))
+ item.setData(0, QtCore.Qt.UserRole, chan.state.channel_id)
self.insertTopLevelItem(0, item)
def get_toolbar(self):
DIR diff --git a/lib/lnbase.py b/lib/lnbase.py
t@@ -776,7 +776,7 @@ class Peer(PrintError):
def on_announcement_signatures(self, payload):
channel_id = payload['channel_id']
chan = self.channels[payload['channel_id']]
- if chan.local_state.was_announced:
+ if chan.state.local_state.was_announced:
h, local_node_sig, local_bitcoin_sig = self.send_announcement_signatures(chan)
else:
self.announcement_signatures[channel_id].put_nowait(payload)
t@@ -927,22 +927,23 @@ class Peer(PrintError):
# broadcast funding tx
success, _txid = self.network.broadcast_transaction(funding_tx)
assert success, success
- return chan._replace(remote_state=chan.remote_state._replace(ctn=0),local_state=chan.local_state._replace(ctn=0, current_commitment_signature=remote_sig))
+ m.state = chan._replace(remote_state=chan.remote_state._replace(ctn=0),local_state=chan.local_state._replace(ctn=0, current_commitment_signature=remote_sig))
+ return m
@aiosafe
async def reestablish_channel(self, chan):
await self.initialized
- chan_id = chan.channel_id
+ chan_id = chan.state.channel_id
self.channel_state[chan_id] = 'REESTABLISHING'
self.network.trigger_callback('channel', chan)
self.send_message(gen_msg("channel_reestablish",
channel_id=chan_id,
- next_local_commitment_number=chan.local_state.ctn+1,
- next_remote_revocation_number=chan.remote_state.ctn
+ next_local_commitment_number=chan.state.local_state.ctn+1,
+ next_remote_revocation_number=chan.state.remote_state.ctn
))
await self.channel_reestablished[chan_id]
self.channel_state[chan_id] = 'OPENING'
- if chan.local_state.funding_locked_received and chan.short_channel_id:
+ if chan.state.local_state.funding_locked_received and chan.state.short_channel_id:
self.mark_open(chan)
self.network.trigger_callback('channel', chan)
t@@ -955,26 +956,26 @@ class Peer(PrintError):
return
channel_reestablish_msg = payload
remote_ctn = int.from_bytes(channel_reestablish_msg["next_local_commitment_number"], 'big')
- if remote_ctn != chan.remote_state.ctn + 1:
- raise Exception("expected remote ctn {}, got {}".format(chan.remote_state.ctn + 1, remote_ctn))
+ if remote_ctn != chan.state.remote_state.ctn + 1:
+ raise Exception("expected remote ctn {}, got {}".format(chan.state.remote_state.ctn + 1, remote_ctn))
local_ctn = int.from_bytes(channel_reestablish_msg["next_remote_revocation_number"], 'big')
- if local_ctn != chan.local_state.ctn:
- raise Exception("expected local ctn {}, got {}".format(chan.local_state.ctn, local_ctn))
+ if local_ctn != chan.state.local_state.ctn:
+ raise Exception("expected local ctn {}, got {}".format(chan.state.local_state.ctn, local_ctn))
their = channel_reestablish_msg["my_current_per_commitment_point"]
- our = chan.remote_state.current_per_commitment_point
+ our = chan.state.remote_state.current_per_commitment_point
if our is None:
- our = chan.remote_state.next_per_commitment_point
+ our = chan.state.remote_state.next_per_commitment_point
if our != their:
raise Exception("Remote PCP mismatch: {} {}".format(bh2u(our), bh2u(their)))
self.channel_reestablished[chan_id].set_result(True)
def funding_locked(self, chan):
- channel_id = chan.channel_id
+ channel_id = chan.state.channel_id
per_commitment_secret_index = 2**48 - 2
per_commitment_point_second = secret_to_pubkey(int.from_bytes(
- get_per_commitment_secret_from_seed(chan.local_state.per_commitment_secret_seed, per_commitment_secret_index), 'big'))
+ get_per_commitment_secret_from_seed(chan.state.local_state.per_commitment_secret_seed, per_commitment_secret_index), 'big'))
self.send_message(gen_msg("funding_locked", channel_id=channel_id, next_per_commitment_point=per_commitment_point_second))
- if chan.local_state.funding_locked_received:
+ if chan.state.local_state.funding_locked_received:
self.mark_open(chan)
def on_funding_locked(self, payload):
t@@ -982,14 +983,14 @@ class Peer(PrintError):
chan = self.channels.get(channel_id)
if not chan:
raise Exception("Got unknown funding_locked", channel_id)
- if not chan.local_state.funding_locked_received:
- our_next_point = chan.remote_state.next_per_commitment_point
+ if not chan.state.local_state.funding_locked_received:
+ our_next_point = chan.state.remote_state.next_per_commitment_point
their_next_point = payload["next_per_commitment_point"]
- new_remote_state = chan.remote_state._replace(next_per_commitment_point=their_next_point, current_per_commitment_point=our_next_point)
- new_local_state = chan.local_state._replace(funding_locked_received = True)
- chan = chan._replace(remote_state=new_remote_state, local_state=new_local_state)
+ new_remote_state = chan.state.remote_state._replace(next_per_commitment_point=their_next_point, current_per_commitment_point=our_next_point)
+ new_local_state = chan.state.local_state._replace(funding_locked_received = True)
+ chan.state = chan.state._replace(remote_state=new_remote_state, local_state=new_local_state)
self.lnworker.save_channel(chan)
- if chan.short_channel_id:
+ if chan.state.short_channel_id:
self.mark_open(chan)
def on_network_update(self, chan, funding_tx_depth):
t@@ -998,8 +999,8 @@ class Peer(PrintError):
Runs on the Network thread.
"""
- if not chan.local_state.was_announced and funding_tx_depth >= 6:
- chan = chan._replace(local_state=chan.local_state._replace(was_announced=True))
+ if not chan.state.local_state.was_announced and funding_tx_depth >= 6:
+ chan.state = chan.state._replace(local_state=chan.state.local_state._replace(was_announced=True))
coro = self.handle_announcements(chan)
self.lnworker.save_channel(chan)
asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)
t@@ -1007,10 +1008,10 @@ class Peer(PrintError):
@aiosafe
async def handle_announcements(self, chan):
h, local_node_sig, local_bitcoin_sig = self.send_announcement_signatures(chan)
- announcement_signatures_msg = await self.announcement_signatures[chan.channel_id].get()
+ announcement_signatures_msg = await self.announcement_signatures[chan.state.channel_id].get()
remote_node_sig = announcement_signatures_msg["node_signature"]
remote_bitcoin_sig = announcement_signatures_msg["bitcoin_signature"]
- if not ecc.verify_signature(chan.remote_config.multisig_key.pubkey, remote_bitcoin_sig, h):
+ if not ecc.verify_signature(chan.state.remote_config.multisig_key.pubkey, remote_bitcoin_sig, h):
raise Exception("bitcoin_sig invalid in announcement_signatures")
if not ecc.verify_signature(self.pubkey, remote_node_sig, h):
raise Exception("node_sig invalid in announcement_signatures")
t@@ -1018,7 +1019,7 @@ class Peer(PrintError):
node_sigs = [local_node_sig, remote_node_sig]
bitcoin_sigs = [local_bitcoin_sig, remote_bitcoin_sig]
node_ids = [privkey_to_pubkey(self.privkey), self.pubkey]
- bitcoin_keys = [chan.local_config.multisig_key.pubkey, chan.remote_config.multisig_key.pubkey]
+ bitcoin_keys = [chan.state.local_config.multisig_key.pubkey, chan.state.remote_config.multisig_key.pubkey]
if node_ids[0] > node_ids[1]:
node_sigs.reverse()
t@@ -1034,7 +1035,7 @@ class Peer(PrintError):
len=0,
#features not set (defaults to zeros)
chain_hash=bytes.fromhex(rev_hex(constants.net.GENESIS)),
- short_channel_id=chan.short_channel_id,
+ short_channel_id=chan.state.short_channel_id,
node_id_1=node_ids[0],
node_id_2=node_ids[1],
bitcoin_key_1=bitcoin_keys[0],
t@@ -1046,23 +1047,23 @@ class Peer(PrintError):
print("SENT CHANNEL ANNOUNCEMENT")
def mark_open(self, chan):
- if self.channel_state[chan.channel_id] == "OPEN":
+ if self.channel_state[chan.state.channel_id] == "OPEN":
return
- assert chan.local_state.funding_locked_received
- self.channel_state[chan.channel_id] = "OPEN"
- self.network.trigger_callback('channel', chan)
+ assert chan.state.local_state.funding_locked_received
+ self.channel_state[chan.state.channel_id] = "OPEN"
+ self.network.trigger_callback('channel', chan.state)
# add channel to database
sorted_keys = list(sorted([self.pubkey, self.lnworker.pubkey]))
- self.channel_db.on_channel_announcement({"short_channel_id": chan.short_channel_id, "node_id_1": sorted_keys[0], "node_id_2": sorted_keys[1]})
- self.channel_db.on_channel_update({"short_channel_id": chan.short_channel_id, 'flags': b'\x01', 'cltv_expiry_delta': b'\x90', 'htlc_minimum_msat': b'\x03\xe8', 'fee_base_msat': b'\x03\xe8', 'fee_proportional_millionths': b'\x01'})
- self.channel_db.on_channel_update({"short_channel_id": chan.short_channel_id, 'flags': b'\x00', 'cltv_expiry_delta': b'\x90', 'htlc_minimum_msat': b'\x03\xe8', 'fee_base_msat': b'\x03\xe8', 'fee_proportional_millionths': b'\x01'})
+ self.channel_db.on_channel_announcement({"short_channel_id": chan.state.short_channel_id, "node_id_1": sorted_keys[0], "node_id_2": sorted_keys[1]})
+ self.channel_db.on_channel_update({"short_channel_id": chan.state.short_channel_id, 'flags': b'\x01', 'cltv_expiry_delta': b'\x90', 'htlc_minimum_msat': b'\x03\xe8', 'fee_base_msat': b'\x03\xe8', 'fee_proportional_millionths': b'\x01'})
+ self.channel_db.on_channel_update({"short_channel_id": chan.state.short_channel_id, 'flags': b'\x00', 'cltv_expiry_delta': b'\x90', 'htlc_minimum_msat': b'\x03\xe8', 'fee_base_msat': b'\x03\xe8', 'fee_proportional_millionths': b'\x01'})
self.print_error("CHANNEL OPENING COMPLETED")
def send_announcement_signatures(self, chan):
- bitcoin_keys = [chan.local_config.multisig_key.pubkey,
- chan.remote_config.multisig_key.pubkey]
+ bitcoin_keys = [chan.state.local_config.multisig_key.pubkey,
+ chan.state.remote_config.multisig_key.pubkey]
node_ids = [privkey_to_pubkey(self.privkey),
self.pubkey]
t@@ -1076,7 +1077,7 @@ class Peer(PrintError):
len=0,
#features not set (defaults to zeros)
chain_hash=bytes.fromhex(rev_hex(constants.net.GENESIS)),
- short_channel_id=chan.short_channel_id,
+ short_channel_id=chan.state.short_channel_id,
node_id_1=node_ids[0],
node_id_2=node_ids[1],
bitcoin_key_1=bitcoin_keys[0],
t@@ -1084,11 +1085,11 @@ class Peer(PrintError):
)
to_hash = chan_ann[256+2:]
h = bitcoin.Hash(to_hash)
- bitcoin_signature = ecc.ECPrivkey(chan.local_config.multisig_key.privkey).sign(h, sigencode_string_canonize, sigdecode_string)
+ bitcoin_signature = ecc.ECPrivkey(chan.state.local_config.multisig_key.privkey).sign(h, sigencode_string_canonize, sigdecode_string)
node_signature = ecc.ECPrivkey(self.privkey).sign(h, sigencode_string_canonize, sigdecode_string)
self.send_message(gen_msg("announcement_signatures",
- channel_id=chan.channel_id,
- short_channel_id=chan.short_channel_id,
+ channel_id=chan.state.channel_id,
+ short_channel_id=chan.state.short_channel_id,
node_signature=node_signature,
bitcoin_signature=bitcoin_signature
))
t@@ -1123,7 +1124,7 @@ class Peer(PrintError):
@aiosafe
async def pay(self, path, chan, amount_msat, payment_hash, pubkey_in_invoice, min_final_cltv_expiry):
- assert self.channel_state[chan.channel_id] == "OPEN"
+ assert self.channel_state[chan.state.channel_id] == "OPEN"
assert amount_msat > 0, "amount_msat is not greater zero"
height = self.network.get_local_height()
route = self.network.path_finder.create_route_from_path(path, self.lnworker.pubkey)
t@@ -1139,62 +1140,61 @@ class Peer(PrintError):
self.secret_key = os.urandom(32)
hops_data += [OnionHopsDataSingle(OnionPerHop(b"\x00"*8, amount_msat.to_bytes(8, "big"), (final_cltv_expiry_without_deltas).to_bytes(4, "big")))]
onion = new_onion_packet([x.node_id for x in route], self.secret_key, hops_data, associated_data)
- msat_local = chan.local_state.amount_msat - (amount_msat + total_fee)
- msat_remote = chan.remote_state.amount_msat + (amount_msat + total_fee)
+ msat_local = chan.state.local_state.amount_msat - (amount_msat + total_fee)
+ msat_remote = chan.state.remote_state.amount_msat + (amount_msat + total_fee)
htlc = UpdateAddHtlc(amount_msat, payment_hash, final_cltv_expiry_with_deltas, total_fee)
amount_msat += total_fee
- self.send_message(gen_msg("update_add_htlc", channel_id=chan.channel_id, id=chan.local_state.next_htlc_id, cltv_expiry=final_cltv_expiry_with_deltas, amount_msat=amount_msat, payment_hash=payment_hash, onion_routing_packet=onion.to_bytes()))
+ self.send_message(gen_msg("update_add_htlc", channel_id=chan.state.channel_id, id=chan.state.local_state.next_htlc_id, cltv_expiry=final_cltv_expiry_with_deltas, amount_msat=amount_msat, payment_hash=payment_hash, onion_routing_packet=onion.to_bytes()))
- m = HTLCStateMachine(chan)
- m.add_htlc(htlc)
- self.attempted_route[(chan.channel_id, htlc.htlc_id)] = route
+ chan.add_htlc(htlc)
+ self.attempted_route[(chan.state.channel_id, htlc.htlc_id)] = route
- sig_64, htlc_sigs = m.sign_next_commitment()
+ sig_64, htlc_sigs = chan.sign_next_commitment()
htlc_sig = htlc_sigs[0]
- self.send_message(gen_msg("commitment_signed", channel_id=chan.channel_id, signature=sig_64, num_htlcs=1, htlc_signature=htlc_sig))
+ self.send_message(gen_msg("commitment_signed", channel_id=chan.state.channel_id, signature=sig_64, num_htlcs=1, htlc_signature=htlc_sig))
- await self.receive_revoke(m)
+ await self.receive_revoke(chan)
- self.revoke(m)
+ self.revoke(chan)
- fulfill_coro = asyncio.ensure_future(self.update_fulfill_htlc[chan.channel_id].get())
- failure_coro = asyncio.ensure_future(self.update_fail_htlc[chan.channel_id].get())
+ fulfill_coro = asyncio.ensure_future(self.update_fulfill_htlc[chan.state.channel_id].get())
+ failure_coro = asyncio.ensure_future(self.update_fail_htlc[chan.state.channel_id].get())
done, pending = await asyncio.wait([fulfill_coro, failure_coro], return_when=FIRST_COMPLETED)
if failure_coro.done():
- sig_64, htlc_sigs = m.sign_next_commitment()
- self.send_message(gen_msg("commitment_signed", channel_id=chan.channel_id, signature=sig_64, num_htlcs=1, htlc_signature=htlc_sigs[0]))
- while (await self.commitment_signed[chan.channel_id].get())["htlc_signature"] != b"":
- self.revoke(m)
- await self.receive_revoke(m)
- m.fail_htlc(htlc)
- sig_64, htlc_sigs = m.sign_next_commitment()
- self.send_message(gen_msg("commitment_signed", channel_id=chan.channel_id, signature=sig_64, num_htlcs=0))
- await self.receive_revoke(m)
+ sig_64, htlc_sigs = chan.sign_next_commitment()
+ self.send_message(gen_msg("commitment_signed", channel_id=chan.state.channel_id, signature=sig_64, num_htlcs=1, htlc_signature=htlc_sigs[0]))
+ while (await self.commitment_signed[chan.state.channel_id].get())["htlc_signature"] != b"":
+ self.revoke(chan)
+ await self.receive_revoke(chan)
+ chan.fail_htlc(htlc)
+ sig_64, htlc_sigs = chan.sign_next_commitment()
+ self.send_message(gen_msg("commitment_signed", channel_id=chan.state.channel_id, signature=sig_64, num_htlcs=0))
+ await self.receive_revoke(chan)
fulfill_coro.cancel()
- self.lnworker.save_channel(m.state)
+ self.lnworker.save_channel(chan)
return failure_coro.result()
if fulfill_coro.done():
failure_coro.cancel()
update_fulfill_htlc_msg = fulfill_coro.result()
- m.receive_htlc_settle(update_fulfill_htlc_msg["payment_preimage"], int.from_bytes(update_fulfill_htlc_msg["id"], "big"))
+ chan.receive_htlc_settle(update_fulfill_htlc_msg["payment_preimage"], int.from_bytes(update_fulfill_htlc_msg["id"], "big"))
- while (await self.commitment_signed[chan.channel_id].get())["htlc_signature"] != b"":
- self.revoke(m)
+ while (await self.commitment_signed[chan.state.channel_id].get())["htlc_signature"] != b"":
+ self.revoke(chan)
# TODO process above commitment transactions
- bare_ctx = make_commitment_using_open_channel(m.state, m.state.remote_state.ctn + 1, False, m.state.remote_state.next_per_commitment_point,
+ bare_ctx = make_commitment_using_open_channel(chan.state, chan.state.remote_state.ctn + 1, False, chan.state.remote_state.next_per_commitment_point,
msat_remote, msat_local)
- sig_64 = sign_and_get_sig_string(bare_ctx, chan.local_config, chan.remote_config)
- self.send_message(gen_msg("commitment_signed", channel_id=chan.channel_id, signature=sig_64, num_htlcs=0))
+ sig_64 = sign_and_get_sig_string(bare_ctx, chan.state.local_config, chan.state.remote_config)
+ self.send_message(gen_msg("commitment_signed", channel_id=chan.state.channel_id, signature=sig_64, num_htlcs=0))
- await self.receive_revoke(m)
+ await self.receive_revoke(chan)
- self.lnworker.save_channel(m.state)
+ self.lnworker.save_channel(chan)
async def receive_revoke(self, m):
revoke_and_ack_msg = await self.revoke_and_ack[m.state.channel_id].get()
t@@ -1217,10 +1217,10 @@ class Peer(PrintError):
@aiosafe
async def receive_commitment_revoke_ack(self, htlc, decoded, payment_preimage):
chan = self.channels[htlc['channel_id']]
- channel_id = chan.channel_id
+ channel_id = chan.state.channel_id
expected_received_msat = int(decoded.amount * COIN * 1000)
htlc_id = int.from_bytes(htlc["id"], 'big')
- assert htlc_id == chan.remote_state.next_htlc_id, (htlc_id, chan.remote_state.next_htlc_id)
+ assert htlc_id == chan.state.remote_state.next_htlc_id, (htlc_id, chan.state.remote_state.next_htlc_id)
assert self.channel_state[channel_id] == "OPEN"
t@@ -1232,19 +1232,17 @@ class Peer(PrintError):
htlc = UpdateAddHtlc(amount_msat, payment_hash, cltv_expiry, 0)
- m = HTLCStateMachine(chan)
-
- m.receive_htlc(htlc)
+ chan.receive_htlc(htlc)
- assert (await self.receive_commitment(m)) == 1
+ assert (await self.receive_commitment(chan)) == 1
- self.revoke(m)
+ self.revoke(chan)
- sig_64, htlc_sigs = m.sign_next_commitment()
+ sig_64, htlc_sigs = chan.sign_next_commitment()
htlc_sig = htlc_sigs[0]
self.send_message(gen_msg("commitment_signed", channel_id=channel_id, signature=sig_64, num_htlcs=1, htlc_signature=htlc_sig))
- await self.receive_revoke(m)
+ await self.receive_revoke(chan)
m.settle_htlc(payment_preimage, htlc_id)
self.send_message(gen_msg("update_fulfill_htlc", channel_id=channel_id, id=htlc_id, payment_preimage=payment_preimage))
t@@ -1255,19 +1253,20 @@ class Peer(PrintError):
sig_64 = sign_and_get_sig_string(bare_ctx, m.state.local_config, m.state.remote_config)
self.send_message(gen_msg("commitment_signed", channel_id=channel_id, signature=sig_64, num_htlcs=0))
- await self.receive_revoke(m)
+ await self.receive_revoke(chan)
- assert (await self.receive_commitment(m)) == 0
+ assert (await self.receive_commitment(chan)) == 0
- self.revoke(m)
+ self.revoke(chan)
- self.lnworker.save_channel(m.state)
+ self.lnworker.save_channel(chan)
def on_commitment_signed(self, payload):
self.print_error("commitment_signed", payload)
channel_id = payload['channel_id']
chan = self.channels[channel_id]
- self.lnworker.save_channel(chan._replace(local_state=chan.local_state._replace(current_commitment_signature=payload['signature'])))
+ chan.state = chan.state._replace(local_state=chan.state.local_state._replace(current_commitment_signature=payload['signature']))
+ self.lnworker.save_channel(chan)
self.commitment_signed[channel_id].put_nowait(payload)
def on_update_fulfill_htlc(self, payload):
t@@ -1298,6 +1297,10 @@ class Peer(PrintError):
channel_id = payload["channel_id"]
self.revoke_and_ack[channel_id].put_nowait(payload)
+ def on_update_fee(self, payload):
+ channel_id = payload["channel_id"]
+ self.channels[channel_id].update_fee(int.from_bytes(payload["feerate_per_kw"], "big"))
+
def count_trailing_zeros(index):
""" BOLT-03 (where_to_put_secret) """
DIR diff --git a/lib/lnhtlc.py b/lib/lnhtlc.py
t@@ -60,6 +60,7 @@ class HTLCStateMachine(PrintError):
self.total_msat_sent = 0
self.total_msat_received = 0
+ self.pending_feerate = None
def add_htlc(self, htlc):
"""
t@@ -188,9 +189,17 @@ class HTLCStateMachine(PrintError):
last_secret, this_point, next_point = self.points
+ if self.pending_feerate is not None:
+ new_feerate = self.pending_feerate
+ else:
+ new_feerate = self.state.constraints.feerate
+
self.state = self.state._replace(
local_state=self.state.local_state._replace(
ctn=self.state.local_state.ctn + 1
+ ),
+ constraints=self.state.constraints._replace(
+ feerate=new_feerate
)
)
t@@ -432,3 +441,10 @@ class HTLCStateMachine(PrintError):
@property
def local_commit_fee(self):
return self.state.constraints.capacity - sum(x[2] for x in self.local_commitment.outputs())
+
+ def update_fee(self, fee):
+ self.pending_feerate = fee
+
+ def receive_update_fee(self, fee):
+ self.pending_feerate = fee
+
DIR diff --git a/lib/lnwatcher.py b/lib/lnwatcher.py
t@@ -15,7 +15,7 @@ class LNWatcher(PrintError):
return response['params'], response['result']
def watch_channel(self, chan, callback):
- script = funding_output_script(chan.local_config, chan.remote_config)
+ script = funding_output_script(chan.state.local_config, chan.state.remote_config)
funding_address = redeem_script_to_address('p2wsh', script)
self.watched_channels[funding_address] = chan, callback
self.network.subscribe_to_addresses([funding_address], self.on_address_status)
DIR diff --git a/lib/lnworker.py b/lib/lnworker.py
t@@ -14,6 +14,7 @@ from .lnbase import Peer, Outpoint, ChannelConfig, LocalState, RemoteState, Keyp
from .lightning_payencode.lnaddr import lnencode, LnAddr, lndecode
from .ecc import ECPrivkey, CURVE_ORDER, der_sig_from_sig_string
from .transaction import Transaction
+from .lnhtlc import HTLCStateMachine
is_key = lambda k: k.endswith("_basepoint") or k.endswith("_key")
t@@ -53,7 +54,7 @@ def serialize_channels(channels_dict):
serialized_channels = []
for chan in channels_dict.values():
namedtuples_to_dict = lambda v: {i: j._asdict() if isinstance(j, tuple) else j for i, j in v._asdict().items()}
- serialized_channels.append({k: namedtuples_to_dict(v) if isinstance(v, tuple) else v for k, v in chan._asdict().items()})
+ serialized_channels.append({k: namedtuples_to_dict(v) if isinstance(v, tuple) else v for k, v in chan.state._asdict().items()})
class MyJsonEncoder(json.JSONEncoder):
def default(self, o):
if isinstance(o, bytes):
t@@ -64,8 +65,8 @@ def serialize_channels(channels_dict):
dumped = MyJsonEncoder().encode(serialized_channels)
roundtripped = json.loads(dumped)
reconstructed = set(reconstruct_namedtuples(x) for x in roundtripped)
- if reconstructed != set(channels_dict.values()):
- raise Exception("Channels did not roundtrip serialization without changes:\n" + repr(reconstructed) + "\n" + repr(channels))
+ if reconstructed != set(x.state for x in channels_dict.values()):
+ raise Exception("Channels did not roundtrip serialization without changes:\n" + repr(reconstructed) + "\n" + repr(channels_dict))
return roundtripped
t@@ -90,10 +91,10 @@ class LNWorker(PrintError):
self.pubkey = ECPrivkey(self.privkey).get_public_key_bytes()
self.config = network.config
self.peers = {}
- self.channels = {x.channel_id: x for x in map(reconstruct_namedtuples, wallet.storage.get("channels", []))}
+ self.channels = {x.channel_id: HTLCStateMachine(x) for x in map(reconstruct_namedtuples, wallet.storage.get("channels", []))}
self.invoices = wallet.storage.get('lightning_invoices', {})
peer_list = network.config.get('lightning_peers', node_list)
- self.channel_state = {chan.channel_id: "DISCONNECTED" for chan in self.channels.values()}
+ self.channel_state = {chan.state.channel_id: "DISCONNECTED" for chan in self.channels.values()}
for chan_id, chan in self.channels.items():
self.network.lnwatcher.watch_channel(chan, self.on_channel_utxos)
for host, port, pubkey in peer_list:
t@@ -104,7 +105,7 @@ class LNWorker(PrintError):
def channels_for_peer(self, node_id):
assert type(node_id) is bytes
- return {x: y for (x, y) in self.channels.items() if y.node_id == node_id}
+ return {x: y for (x, y) in self.channels.items() if y.state.node_id == node_id}
def add_peer(self, host, port, node_id):
peer = Peer(self, host, int(port), node_id, request_initial_sync=self.config.get("request_initial_sync", True))
t@@ -113,17 +114,18 @@ class LNWorker(PrintError):
self.lock = threading.Lock()
def save_channel(self, openchannel):
- if openchannel.channel_id not in self.channel_state:
- self.channel_state[openchannel.channel_id] = "OPENING"
- self.channels[openchannel.channel_id] = openchannel
+ assert type(openchannel) is HTLCStateMachine
+ if openchannel.state.channel_id not in self.channel_state:
+ self.channel_state[openchannel.state.channel_id] = "OPENING"
+ self.channels[openchannel.state.channel_id] = openchannel
for node_id, peer in self.peers.items():
peer.channels = self.channels_for_peer(node_id)
- if openchannel.remote_state.next_per_commitment_point == openchannel.remote_state.current_per_commitment_point:
+ if openchannel.state.remote_state.next_per_commitment_point == openchannel.state.remote_state.current_per_commitment_point:
raise Exception("Tried to save channel with next_point == current_point, this should not happen")
dumped = serialize_channels(self.channels)
self.wallet.storage.put("channels", dumped)
self.wallet.storage.write()
- self.network.trigger_callback('channel', openchannel)
+ self.network.trigger_callback('channel', openchannel.state)
def save_short_chan_id(self, chan):
"""
t@@ -131,48 +133,48 @@ class LNWorker(PrintError):
If the Funding TX has not been mined, return None
"""
- assert self.channel_state[chan.channel_id] in ["OPEN", "OPENING"]
- peer = self.peers[chan.node_id]
- conf = self.wallet.get_tx_height(chan.funding_outpoint.txid)[1]
- if conf >= chan.constraints.funding_txn_minimum_depth:
- block_height, tx_pos = self.wallet.get_txpos(chan.funding_outpoint.txid)
+ assert self.channel_state[chan.state.channel_id] in ["OPEN", "OPENING"]
+ peer = self.peers[chan.state.node_id]
+ conf = self.wallet.get_tx_height(chan.state.funding_outpoint.txid)[1]
+ if conf >= chan.state.constraints.funding_txn_minimum_depth:
+ block_height, tx_pos = self.wallet.get_txpos(chan.state.funding_outpoint.txid)
if tx_pos == -1:
self.print_error('funding tx is not yet SPV verified.. but there are '
'already enough confirmations (currently {})'.format(conf))
- return None
- chan = chan._replace(short_channel_id = calc_short_channel_id(block_height, tx_pos, chan.funding_outpoint.output_index))
+ return False
+ chan.state = chan.state._replace(short_channel_id = calc_short_channel_id(block_height, tx_pos, chan.state.funding_outpoint.output_index))
self.save_channel(chan)
- return chan
- return None
+ return True
+ return False
def on_channel_utxos(self, chan, utxos):
outpoints = [Outpoint(x["tx_hash"], x["tx_pos"]) for x in utxos]
- if chan.funding_outpoint not in outpoints:
- self.channel_state[chan.channel_id] = "CLOSED"
- elif self.channel_state[chan.channel_id] == 'DISCONNECTED':
- peer = self.peers[chan.node_id]
+ if chan.state.funding_outpoint not in outpoints:
+ self.channel_state[chan.state.channel_id] = "CLOSED"
+ elif self.channel_state[chan.state.channel_id] == 'DISCONNECTED':
+ peer = self.peers[chan.state.node_id]
coro = peer.reestablish_channel(chan)
asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)
def on_network_update(self, event, *args):
for chan in self.channels.values():
- peer = self.peers[chan.node_id]
- if self.channel_state[chan.channel_id] == "OPENING":
- chan = self.save_short_chan_id(chan)
- if not chan:
+ peer = self.peers[chan.state.node_id]
+ if self.channel_state[chan.state.channel_id] == "OPENING":
+ res = self.save_short_chan_id(chan)
+ if not res:
self.print_error("network update but funding tx is still not at sufficient depth")
continue
# this results in the channel being marked OPEN
peer.funding_locked(chan)
- elif self.channel_state[chan.channel_id] == "OPEN":
- conf = self.wallet.get_tx_height(chan.funding_outpoint.txid)[1]
+ elif self.channel_state[chan.state.channel_id] == "OPEN":
+ conf = self.wallet.get_tx_height(chan.state.funding_outpoint.txid)[1]
peer.on_network_update(chan, conf)
async def _open_channel_coroutine(self, node_id, amount_sat, push_sat, password):
if node_id not in self.peers:
node = self.network.lightning_nodes.get(node_id)
if node is None:
- return False
+ return "node not found, peers available are: " + str(self.network.lightning_nodes.keys())
host, port = node['addresses'][0]
self.add_peer(host, port, node_id)
peer = self.peers[node_id]
t@@ -198,7 +200,7 @@ class LNWorker(PrintError):
node_id, short_channel_id = path[0]
peer = self.peers[node_id]
for chan in self.channels.values():
- if chan.short_channel_id == short_channel_id:
+ if chan.state.short_channel_id == short_channel_id:
break
else:
raise Exception("ChannelDB returned path with short_channel_id that is not in channel list")
t@@ -206,7 +208,6 @@ class LNWorker(PrintError):
return asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)
def add_invoice(self, amount_sat, message):
- is_open = lambda chan: self.channel_state[chan.channel_id] == "OPEN"
payment_preimage = os.urandom(32)
RHASH = sha256(payment_preimage)
amount_btc = amount_sat/Decimal(COIN) if amount_sat else None
t@@ -230,13 +231,15 @@ class LNWorker(PrintError):
return serialize_channels(self.channels)
def close_channel(self, chan_id):
- from .lnhtlc import HTLCStateMachine
chan = self.channels[chan_id]
# local_commitment always gives back the next expected local_commitment,
# but in this case, we want the current one. So substract one ctn number
- tx = HTLCStateMachine(chan._replace(local_state=chan.local_state._replace(ctn=chan.local_state.ctn - 1))).local_commitment
- tx.sign({bh2u(chan.local_config.multisig_key.pubkey): (chan.local_config.multisig_key.privkey, True)})
- remote_sig = chan.local_state.current_commitment_signature
+ old_state = chan.state
+ chan.state = chan.state._replace(local_state=chan.state.local_state._replace(ctn=chan.state.local_state.ctn - 1))
+ tx = chan.local_commitment
+ chan.state = old_state
+ tx.sign({bh2u(chan.state.local_config.multisig_key.pubkey): (chan.state.local_config.multisig_key.privkey, True)})
+ remote_sig = chan.state.local_state.current_commitment_signature
remote_sig = der_sig_from_sig_string(remote_sig) + b"\x01"
none_idx = tx._inputs[0]["signatures"].index(None)
tx.add_signature_to_txin(0, none_idx, bh2u(remote_sig))
DIR diff --git a/lib/tests/test_lnhtlc.py b/lib/tests/test_lnhtlc.py
t@@ -250,28 +250,44 @@ class TestLNBaseHTLCStateMachine(unittest.TestCase):
)
aliceHtlcIndex = alice_channel.add_htlc(htlc)
-
bobHtlcIndex = bob_channel.receive_htlc(htlc)
-
force_state_transition(alice_channel, bob_channel)
-
self.assertEqual(len(alice_channel.local_commitment.outputs()), 3)
-
self.assertEqual(len(bob_channel.local_commitment.outputs()), 2)
-
default_fee = calc_static_fee(0)
-
self.assertEqual(bob_channel.local_commit_fee, default_fee)
-
bob_channel.settle_htlc(paymentPreimage, htlc.htlc_id)
alice_channel.receive_htlc_settle(paymentPreimage, aliceHtlcIndex)
-
force_state_transition(bob_channel, alice_channel)
-
self.assertEqual(len(alice_channel.local_commitment.outputs()), 2)
-
self.assertEqual(alice_channel.total_msat_sent // 1000, htlcAmt)
+ def test_UpdateFeeSenderCommits(self):
+ alice_channel, bob_channel = create_test_channels()
+
+ paymentPreimage = b"\x01" * 32
+ paymentHash = bitcoin.sha256(paymentPreimage)
+ htlc = lnhtlc.UpdateAddHtlc(
+ payment_hash = paymentHash,
+ amount_msat = one_bitcoin_in_msat,
+ cltv_expiry = 5, # also in create_test_channels
+ total_fee = 0
+ )
+
+ aliceHtlcIndex = alice_channel.add_htlc(htlc)
+ bobHtlcIndex = bob_channel.receive_htlc(htlc)
+
+ fee = 111
+ alice_channel.update_fee(fee)
+ bob_channel.receive_update_fee(fee)
+
+ alice_sig, alice_htlc_sigs = alice_channel.sign_next_commitment()
+ bob_channel.receive_new_commitment(alice_sig, alice_htlc_sigs)
+ self.assertNotEqual(fee, alice_channel.state.constraints.feerate)
+ rev, _ = alice_channel.revoke_current_commitment()
+ self.assertEqual(fee, alice_channel.state.constraints.feerate)
+ bob_channel.receive_revocation(rev)
+
def force_state_transition(chanA, chanB):
chanB.receive_new_commitment(*chanA.sign_next_commitment())
rev, _ = chanB.revoke_current_commitment()