RanchiMall/flo-electrum
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ln: store HTLCStateMachine in lnworker.channels

Browse Source
This commit is contained in:
Janus 2018-06-27 18:33:55 +02:00
parent 2e52899d6f
commit 93b8567de4
7 changed files with 176 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
electrum/commands.py
View File

@ -684,7 +684,7 @@ class Commands:
# lightning network commands # lightning network commands
@command('wpn') @command('wpn')
def open_channel(self, node_id, amount, channel_push=0, password=None): 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() return f.result()
@command('wn') @command('wn')

7
gui/qt/channels_list.py
View File

@ -33,7 +33,8 @@ class ChannelsList(MyTreeWidget):
channel_id = self.currentItem().data(0, QtCore.Qt.UserRole) channel_id = self.currentItem().data(0, QtCore.Qt.UserRole)
print('ID', bh2u(channel_id)) print('ID', bh2u(channel_id))
def close(): 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.addAction(_("Close channel"), close)
menu.exec_(self.viewport().mapToGlobal(position)) menu.exec_(self.viewport().mapToGlobal(position))
@ -49,8 +50,8 @@ class ChannelsList(MyTreeWidget):
def do_update_rows(self): def do_update_rows(self):
self.clear() self.clear()
for chan in self.parent.wallet.lnworker.channels.values(): for chan in self.parent.wallet.lnworker.channels.values():
item = SortableTreeWidgetItem(self.format_fields(chan)) item = SortableTreeWidgetItem(self.format_fields(chan.state))
item.setData(0, QtCore.Qt.UserRole, chan.channel_id) item.setData(0, QtCore.Qt.UserRole, chan.state.channel_id)
self.insertTopLevelItem(0, item) self.insertTopLevelItem(0, item)
def get_toolbar(self): def get_toolbar(self):

173
lib/lnbase.py
View File

@ -776,7 +776,7 @@ class Peer(PrintError):
def on_announcement_signatures(self, payload): def on_announcement_signatures(self, payload):
channel_id = payload['channel_id'] channel_id = payload['channel_id']
chan = self.channels[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) h, local_node_sig, local_bitcoin_sig = self.send_announcement_signatures(chan)
else: else:
self.announcement_signatures[channel_id].put_nowait(payload) self.announcement_signatures[channel_id].put_nowait(payload)
@ -927,22 +927,23 @@ class Peer(PrintError):
# broadcast funding tx # broadcast funding tx
success, _txid = self.network.broadcast_transaction(funding_tx) success, _txid = self.network.broadcast_transaction(funding_tx)
assert success, success 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 @aiosafe
async def reestablish_channel(self, chan): async def reestablish_channel(self, chan):
await self.initialized await self.initialized
chan_id = chan.channel_id chan_id = chan.state.channel_id
self.channel_state[chan_id] = 'REESTABLISHING' self.channel_state[chan_id] = 'REESTABLISHING'
self.network.trigger_callback('channel', chan) self.network.trigger_callback('channel', chan)
self.send_message(gen_msg("channel_reestablish", self.send_message(gen_msg("channel_reestablish",
channel_id=chan_id, channel_id=chan_id,
next_local_commitment_number=chan.local_state.ctn+1, next_local_commitment_number=chan.state.local_state.ctn+1,
next_remote_revocation_number=chan.remote_state.ctn next_remote_revocation_number=chan.state.remote_state.ctn
)) ))
await self.channel_reestablished[chan_id] await self.channel_reestablished[chan_id]
self.channel_state[chan_id] = 'OPENING' 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.mark_open(chan)
self.network.trigger_callback('channel', chan) self.network.trigger_callback('channel', chan)
@ -955,26 +956,26 @@ class Peer(PrintError):
return return
channel_reestablish_msg = payload channel_reestablish_msg = payload
remote_ctn = int.from_bytes(channel_reestablish_msg["next_local_commitment_number"], 'big') remote_ctn = int.from_bytes(channel_reestablish_msg["next_local_commitment_number"], 'big')
if remote_ctn != chan.remote_state.ctn + 1: if remote_ctn != chan.state.remote_state.ctn + 1:
raise Exception("expected remote ctn {}, got {}".format(chan.remote_state.ctn + 1, remote_ctn)) 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') local_ctn = int.from_bytes(channel_reestablish_msg["next_remote_revocation_number"], 'big')
if local_ctn != chan.local_state.ctn: if local_ctn != chan.state.local_state.ctn:
raise Exception("expected local ctn {}, got {}".format(chan.local_state.ctn, local_ctn)) raise Exception("expected local ctn {}, got {}".format(chan.state.local_state.ctn, local_ctn))
their = channel_reestablish_msg["my_current_per_commitment_point"] 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: if our is None:
our = chan.remote_state.next_per_commitment_point our = chan.state.remote_state.next_per_commitment_point
if our != their: if our != their:
raise Exception("Remote PCP mismatch: {} {}".format(bh2u(our), bh2u(their))) raise Exception("Remote PCP mismatch: {} {}".format(bh2u(our), bh2u(their)))
self.channel_reestablished[chan_id].set_result(True) self.channel_reestablished[chan_id].set_result(True)
def funding_locked(self, chan): 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_secret_index = 2**48 - 2
per_commitment_point_second = secret_to_pubkey(int.from_bytes( 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)) 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) self.mark_open(chan)
def on_funding_locked(self, payload): def on_funding_locked(self, payload):
@ -982,14 +983,14 @@ class Peer(PrintError):
chan = self.channels.get(channel_id) chan = self.channels.get(channel_id)
if not chan: if not chan:
raise Exception("Got unknown funding_locked", channel_id) raise Exception("Got unknown funding_locked", channel_id)
if not chan.local_state.funding_locked_received: if not chan.state.local_state.funding_locked_received:
our_next_point = chan.remote_state.next_per_commitment_point our_next_point = chan.state.remote_state.next_per_commitment_point
their_next_point = payload["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_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.local_state._replace(funding_locked_received = True) new_local_state = chan.state.local_state._replace(funding_locked_received = True)
chan = chan._replace(remote_state=new_remote_state, local_state=new_local_state) chan.state = chan.state._replace(remote_state=new_remote_state, local_state=new_local_state)
self.lnworker.save_channel(chan) self.lnworker.save_channel(chan)
if chan.short_channel_id: if chan.state.short_channel_id:
self.mark_open(chan) self.mark_open(chan)
def on_network_update(self, chan, funding_tx_depth): def on_network_update(self, chan, funding_tx_depth):
@ -998,8 +999,8 @@ class Peer(PrintError):
Runs on the Network thread. Runs on the Network thread.
""" """
if not chan.local_state.was_announced and funding_tx_depth >= 6: if not chan.state.local_state.was_announced and funding_tx_depth >= 6:
chan = chan._replace(local_state=chan.local_state._replace(was_announced=True)) chan.state = chan.state._replace(local_state=chan.state.local_state._replace(was_announced=True))
coro = self.handle_announcements(chan) coro = self.handle_announcements(chan)
self.lnworker.save_channel(chan) self.lnworker.save_channel(chan)
asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop) asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)
@ -1007,10 +1008,10 @@ class Peer(PrintError):
@aiosafe @aiosafe
async def handle_announcements(self, chan): async def handle_announcements(self, chan):
h, local_node_sig, local_bitcoin_sig = self.send_announcement_signatures(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_node_sig = announcement_signatures_msg["node_signature"]
remote_bitcoin_sig = announcement_signatures_msg["bitcoin_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") raise Exception("bitcoin_sig invalid in announcement_signatures")
if not ecc.verify_signature(self.pubkey, remote_node_sig, h): if not ecc.verify_signature(self.pubkey, remote_node_sig, h):
raise Exception("node_sig invalid in announcement_signatures") raise Exception("node_sig invalid in announcement_signatures")
@ -1018,7 +1019,7 @@ class Peer(PrintError):
node_sigs = [local_node_sig, remote_node_sig] node_sigs = [local_node_sig, remote_node_sig]
bitcoin_sigs = [local_bitcoin_sig, remote_bitcoin_sig] bitcoin_sigs = [local_bitcoin_sig, remote_bitcoin_sig]
node_ids = [privkey_to_pubkey(self.privkey), self.pubkey] 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]: if node_ids[0] > node_ids[1]:
node_sigs.reverse() node_sigs.reverse()
@ -1034,7 +1035,7 @@ class Peer(PrintError):
len=0, len=0,
#features not set (defaults to zeros) #features not set (defaults to zeros)
chain_hash=bytes.fromhex(rev_hex(constants.net.GENESIS)), 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_1=node_ids[0],
node_id_2=node_ids[1], node_id_2=node_ids[1],
bitcoin_key_1=bitcoin_keys[0], bitcoin_key_1=bitcoin_keys[0],
@ -1046,23 +1047,23 @@ class Peer(PrintError):
print("SENT CHANNEL ANNOUNCEMENT") print("SENT CHANNEL ANNOUNCEMENT")
def mark_open(self, chan): def mark_open(self, chan):
if self.channel_state[chan.channel_id] == "OPEN": if self.channel_state[chan.state.channel_id] == "OPEN":
return return
assert chan.local_state.funding_locked_received assert chan.state.local_state.funding_locked_received
self.channel_state[chan.channel_id] = "OPEN" self.channel_state[chan.state.channel_id] = "OPEN"
self.network.trigger_callback('channel', chan) self.network.trigger_callback('channel', chan.state)
# add channel to database # add channel to database
sorted_keys = list(sorted([self.pubkey, self.lnworker.pubkey])) 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_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.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'\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_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") self.print_error("CHANNEL OPENING COMPLETED")
def send_announcement_signatures(self, chan): def send_announcement_signatures(self, chan):
bitcoin_keys = [chan.local_config.multisig_key.pubkey, bitcoin_keys = [chan.state.local_config.multisig_key.pubkey,
chan.remote_config.multisig_key.pubkey] chan.state.remote_config.multisig_key.pubkey]
node_ids = [privkey_to_pubkey(self.privkey), node_ids = [privkey_to_pubkey(self.privkey),
self.pubkey] self.pubkey]
@ -1076,7 +1077,7 @@ class Peer(PrintError):
len=0, len=0,
#features not set (defaults to zeros) #features not set (defaults to zeros)
chain_hash=bytes.fromhex(rev_hex(constants.net.GENESIS)), 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_1=node_ids[0],
node_id_2=node_ids[1], node_id_2=node_ids[1],
bitcoin_key_1=bitcoin_keys[0], bitcoin_key_1=bitcoin_keys[0],
@ -1084,11 +1085,11 @@ class Peer(PrintError):
) )
to_hash = chan_ann[256+2:] to_hash = chan_ann[256+2:]
h = bitcoin.Hash(to_hash) 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) node_signature = ecc.ECPrivkey(self.privkey).sign(h, sigencode_string_canonize, sigdecode_string)
self.send_message(gen_msg("announcement_signatures", self.send_message(gen_msg("announcement_signatures",
channel_id=chan.channel_id, channel_id=chan.state.channel_id,
short_channel_id=chan.short_channel_id, short_channel_id=chan.state.short_channel_id,
node_signature=node_signature, node_signature=node_signature,
bitcoin_signature=bitcoin_signature bitcoin_signature=bitcoin_signature
)) ))
@ -1123,7 +1124,7 @@ class Peer(PrintError):
@aiosafe @aiosafe
async def pay(self, path, chan, amount_msat, payment_hash, pubkey_in_invoice, min_final_cltv_expiry): 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" assert amount_msat > 0, "amount_msat is not greater zero"
height = self.network.get_local_height() height = self.network.get_local_height()
route = self.network.path_finder.create_route_from_path(path, self.lnworker.pubkey) route = self.network.path_finder.create_route_from_path(path, self.lnworker.pubkey)
@ -1139,62 +1140,61 @@ class Peer(PrintError):
self.secret_key = os.urandom(32) 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")))] 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) 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_local = chan.state.local_state.amount_msat - (amount_msat + total_fee)
msat_remote = chan.remote_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) htlc = UpdateAddHtlc(amount_msat, payment_hash, final_cltv_expiry_with_deltas, total_fee)
amount_msat += 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) chan.add_htlc(htlc)
m.add_htlc(htlc) self.attempted_route[(chan.state.channel_id, htlc.htlc_id)] = route
self.attempted_route[(chan.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] 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()) fulfill_coro = asyncio.ensure_future(self.update_fulfill_htlc[chan.state.channel_id].get())
failure_coro = asyncio.ensure_future(self.update_fail_htlc[chan.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) done, pending = await asyncio.wait([fulfill_coro, failure_coro], return_when=FIRST_COMPLETED)
if failure_coro.done(): if failure_coro.done():
sig_64, htlc_sigs = m.sign_next_commitment() sig_64, htlc_sigs = chan.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])) 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.channel_id].get())["htlc_signature"] != b"": while (await self.commitment_signed[chan.state.channel_id].get())["htlc_signature"] != b"":
self.revoke(m) self.revoke(chan)
await self.receive_revoke(m) await self.receive_revoke(chan)
m.fail_htlc(htlc) chan.fail_htlc(htlc)
sig_64, htlc_sigs = m.sign_next_commitment() sig_64, htlc_sigs = chan.sign_next_commitment()
self.send_message(gen_msg("commitment_signed", channel_id=chan.channel_id, signature=sig_64, num_htlcs=0)) 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)
fulfill_coro.cancel() fulfill_coro.cancel()
self.lnworker.save_channel(m.state) self.lnworker.save_channel(chan)
return failure_coro.result() return failure_coro.result()
if fulfill_coro.done(): if fulfill_coro.done():
failure_coro.cancel() failure_coro.cancel()
update_fulfill_htlc_msg = fulfill_coro.result() 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"": while (await self.commitment_signed[chan.state.channel_id].get())["htlc_signature"] != b"":
self.revoke(m) self.revoke(chan)
# TODO process above commitment transactions # 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) msat_remote, msat_local)
sig_64 = sign_and_get_sig_string(bare_ctx, chan.local_config, chan.remote_config) 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.channel_id, signature=sig_64, num_htlcs=0)) 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): async def receive_revoke(self, m):
revoke_and_ack_msg = await self.revoke_and_ack[m.state.channel_id].get() revoke_and_ack_msg = await self.revoke_and_ack[m.state.channel_id].get()
@ -1217,10 +1217,10 @@ class Peer(PrintError):
@aiosafe @aiosafe
async def receive_commitment_revoke_ack(self, htlc, decoded, payment_preimage): async def receive_commitment_revoke_ack(self, htlc, decoded, payment_preimage):
chan = self.channels[htlc['channel_id']] 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) expected_received_msat = int(decoded.amount * COIN * 1000)
htlc_id = int.from_bytes(htlc["id"], 'big') 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" assert self.channel_state[channel_id] == "OPEN"
@ -1232,19 +1232,17 @@ class Peer(PrintError):
htlc = UpdateAddHtlc(amount_msat, payment_hash, cltv_expiry, 0) htlc = UpdateAddHtlc(amount_msat, payment_hash, cltv_expiry, 0)
m = HTLCStateMachine(chan) chan.receive_htlc(htlc)
m.receive_htlc(htlc) assert (await self.receive_commitment(chan)) == 1
assert (await self.receive_commitment(m)) == 1 self.revoke(chan)
self.revoke(m) sig_64, htlc_sigs = chan.sign_next_commitment()
sig_64, htlc_sigs = m.sign_next_commitment()
htlc_sig = htlc_sigs[0] 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)) 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) 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)) self.send_message(gen_msg("update_fulfill_htlc", channel_id=channel_id, id=htlc_id, payment_preimage=payment_preimage))
@ -1255,19 +1253,20 @@ class Peer(PrintError):
sig_64 = sign_and_get_sig_string(bare_ctx, m.state.local_config, m.state.remote_config) 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)) 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): def on_commitment_signed(self, payload):
self.print_error("commitment_signed", payload) self.print_error("commitment_signed", payload)
channel_id = payload['channel_id'] channel_id = payload['channel_id']
chan = self.channels[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) self.commitment_signed[channel_id].put_nowait(payload)
def on_update_fulfill_htlc(self, payload): def on_update_fulfill_htlc(self, payload):
@ -1298,6 +1297,10 @@ class Peer(PrintError):
channel_id = payload["channel_id"] channel_id = payload["channel_id"]
self.revoke_and_ack[channel_id].put_nowait(payload) 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): def count_trailing_zeros(index):
""" BOLT-03 (where_to_put_secret) """ """ BOLT-03 (where_to_put_secret) """

16
lib/lnhtlc.py
View File

@ -60,6 +60,7 @@ class HTLCStateMachine(PrintError):
self.total_msat_sent = 0 self.total_msat_sent = 0
self.total_msat_received = 0 self.total_msat_received = 0
self.pending_feerate = None
def add_htlc(self, htlc): def add_htlc(self, htlc):
""" """
@ -188,9 +189,17 @@ class HTLCStateMachine(PrintError):
last_secret, this_point, next_point = self.points 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( self.state = self.state._replace(
local_state=self.state.local_state._replace( local_state=self.state.local_state._replace(
ctn=self.state.local_state.ctn + 1 ctn=self.state.local_state.ctn + 1
),
constraints=self.state.constraints._replace(
feerate=new_feerate
) )
) )
@ -432,3 +441,10 @@ class HTLCStateMachine(PrintError):
@property @property
def local_commit_fee(self): def local_commit_fee(self):
return self.state.constraints.capacity - sum(x[2] for x in self.local_commitment.outputs()) 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

2
lib/lnwatcher.py
View File

@ -15,7 +15,7 @@ class LNWatcher(PrintError):
return response['params'], response['result'] return response['params'], response['result']
def watch_channel(self, chan, callback): 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) funding_address = redeem_script_to_address('p2wsh', script)
self.watched_channels[funding_address] = chan, callback self.watched_channels[funding_address] = chan, callback
self.network.subscribe_to_addresses([funding_address], self.on_address_status) self.network.subscribe_to_addresses([funding_address], self.on_address_status)

77
lib/lnworker.py
View File

@ -14,6 +14,7 @@ from .lnbase import Peer, Outpoint, ChannelConfig, LocalState, RemoteState, Keyp
from .lightning_payencode.lnaddr import lnencode, LnAddr, lndecode from .lightning_payencode.lnaddr import lnencode, LnAddr, lndecode
from .ecc import ECPrivkey, CURVE_ORDER, der_sig_from_sig_string from .ecc import ECPrivkey, CURVE_ORDER, der_sig_from_sig_string
from .transaction import Transaction from .transaction import Transaction
from .lnhtlc import HTLCStateMachine
is_key = lambda k: k.endswith("_basepoint") or k.endswith("_key") is_key = lambda k: k.endswith("_basepoint") or k.endswith("_key")
@ -53,7 +54,7 @@ def serialize_channels(channels_dict):
serialized_channels = [] serialized_channels = []
for chan in channels_dict.values(): 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()} 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): class MyJsonEncoder(json.JSONEncoder):
def default(self, o): def default(self, o):
if isinstance(o, bytes): if isinstance(o, bytes):
@ -64,8 +65,8 @@ def serialize_channels(channels_dict):
dumped = MyJsonEncoder().encode(serialized_channels) dumped = MyJsonEncoder().encode(serialized_channels)
roundtripped = json.loads(dumped) roundtripped = json.loads(dumped)
reconstructed = set(reconstruct_namedtuples(x) for x in roundtripped) reconstructed = set(reconstruct_namedtuples(x) for x in roundtripped)
if reconstructed != set(channels_dict.values()): 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)) raise Exception("Channels did not roundtrip serialization without changes:\n" + repr(reconstructed) + "\n" + repr(channels_dict))
return roundtripped return roundtripped
@ -90,10 +91,10 @@ class LNWorker(PrintError):
self.pubkey = ECPrivkey(self.privkey).get_public_key_bytes() self.pubkey = ECPrivkey(self.privkey).get_public_key_bytes()
self.config = network.config self.config = network.config
self.peers = {} 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', {}) self.invoices = wallet.storage.get('lightning_invoices', {})
peer_list = network.config.get('lightning_peers', node_list) 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(): for chan_id, chan in self.channels.items():
self.network.lnwatcher.watch_channel(chan, self.on_channel_utxos) self.network.lnwatcher.watch_channel(chan, self.on_channel_utxos)
for host, port, pubkey in peer_list: for host, port, pubkey in peer_list:
@ -104,7 +105,7 @@ class LNWorker(PrintError):
def channels_for_peer(self, node_id): def channels_for_peer(self, node_id):
assert type(node_id) is bytes 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): 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)) peer = Peer(self, host, int(port), node_id, request_initial_sync=self.config.get("request_initial_sync", True))
@ -113,17 +114,18 @@ class LNWorker(PrintError):
self.lock = threading.Lock() self.lock = threading.Lock()
def save_channel(self, openchannel): def save_channel(self, openchannel):
if openchannel.channel_id not in self.channel_state: assert type(openchannel) is HTLCStateMachine
self.channel_state[openchannel.channel_id] = "OPENING" if openchannel.state.channel_id not in self.channel_state:
self.channels[openchannel.channel_id] = openchannel self.channel_state[openchannel.state.channel_id] = "OPENING"
self.channels[openchannel.state.channel_id] = openchannel
for node_id, peer in self.peers.items(): for node_id, peer in self.peers.items():
peer.channels = self.channels_for_peer(node_id) 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") raise Exception("Tried to save channel with next_point == current_point, this should not happen")
dumped = serialize_channels(self.channels) dumped = serialize_channels(self.channels)
self.wallet.storage.put("channels", dumped) self.wallet.storage.put("channels", dumped)
self.wallet.storage.write() self.wallet.storage.write()
self.network.trigger_callback('channel', openchannel) self.network.trigger_callback('channel', openchannel.state)
def save_short_chan_id(self, chan): def save_short_chan_id(self, chan):
""" """
@ -131,48 +133,48 @@ class LNWorker(PrintError):
If the Funding TX has not been mined, return None If the Funding TX has not been mined, return None
""" """
assert self.channel_state[chan.channel_id] in ["OPEN", "OPENING"] assert self.channel_state[chan.state.channel_id] in ["OPEN", "OPENING"]
peer = self.peers[chan.node_id] peer = self.peers[chan.state.node_id]
conf = self.wallet.get_tx_height(chan.funding_outpoint.txid)[1] conf = self.wallet.get_tx_height(chan.state.funding_outpoint.txid)[1]
if conf >= chan.constraints.funding_txn_minimum_depth: if conf >= chan.state.constraints.funding_txn_minimum_depth:
block_height, tx_pos = self.wallet.get_txpos(chan.funding_outpoint.txid) block_height, tx_pos = self.wallet.get_txpos(chan.state.funding_outpoint.txid)
if tx_pos == -1: if tx_pos == -1:
self.print_error('funding tx is not yet SPV verified.. but there are ' self.print_error('funding tx is not yet SPV verified.. but there are '
'already enough confirmations (currently {})'.format(conf)) 'already enough confirmations (currently {})'.format(conf))
return None return False
chan = chan._replace(short_channel_id = calc_short_channel_id(block_height, tx_pos, chan.funding_outpoint.output_index)) 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) self.save_channel(chan)
return chan return True
return None return False
def on_channel_utxos(self, chan, utxos): def on_channel_utxos(self, chan, utxos):
outpoints = [Outpoint(x["tx_hash"], x["tx_pos"]) for x in utxos] outpoints = [Outpoint(x["tx_hash"], x["tx_pos"]) for x in utxos]
if chan.funding_outpoint not in outpoints: if chan.state.funding_outpoint not in outpoints:
self.channel_state[chan.channel_id] = "CLOSED" self.channel_state[chan.state.channel_id] = "CLOSED"
elif self.channel_state[chan.channel_id] == 'DISCONNECTED': elif self.channel_state[chan.state.channel_id] == 'DISCONNECTED':
peer = self.peers[chan.node_id] peer = self.peers[chan.state.node_id]
coro = peer.reestablish_channel(chan) coro = peer.reestablish_channel(chan)
asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop) asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)
def on_network_update(self, event, *args): def on_network_update(self, event, *args):
for chan in self.channels.values(): for chan in self.channels.values():
peer = self.peers[chan.node_id] peer = self.peers[chan.state.node_id]
if self.channel_state[chan.channel_id] == "OPENING": if self.channel_state[chan.state.channel_id] == "OPENING":
chan = self.save_short_chan_id(chan) res = self.save_short_chan_id(chan)
if not chan: if not res:
self.print_error("network update but funding tx is still not at sufficient depth") self.print_error("network update but funding tx is still not at sufficient depth")
continue continue
# this results in the channel being marked OPEN # this results in the channel being marked OPEN
peer.funding_locked(chan) peer.funding_locked(chan)
elif self.channel_state[chan.channel_id] == "OPEN": elif self.channel_state[chan.state.channel_id] == "OPEN":
conf = self.wallet.get_tx_height(chan.funding_outpoint.txid)[1] conf = self.wallet.get_tx_height(chan.state.funding_outpoint.txid)[1]
peer.on_network_update(chan, conf) peer.on_network_update(chan, conf)
async def _open_channel_coroutine(self, node_id, amount_sat, push_sat, password): async def _open_channel_coroutine(self, node_id, amount_sat, push_sat, password):
if node_id not in self.peers: if node_id not in self.peers:
node = self.network.lightning_nodes.get(node_id) node = self.network.lightning_nodes.get(node_id)
if node is None: if node is None:
return False return "node not found, peers available are: " + str(self.network.lightning_nodes.keys())
host, port = node['addresses'][0] host, port = node['addresses'][0]
self.add_peer(host, port, node_id) self.add_peer(host, port, node_id)
peer = self.peers[node_id] peer = self.peers[node_id]
@ -198,7 +200,7 @@ class LNWorker(PrintError):
node_id, short_channel_id = path[0] node_id, short_channel_id = path[0]
peer = self.peers[node_id] peer = self.peers[node_id]
for chan in self.channels.values(): for chan in self.channels.values():
if chan.short_channel_id == short_channel_id: if chan.state.short_channel_id == short_channel_id:
break break
else: else:
raise Exception("ChannelDB returned path with short_channel_id that is not in channel list") raise Exception("ChannelDB returned path with short_channel_id that is not in channel list")
@ -206,7 +208,6 @@ class LNWorker(PrintError):
return asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop) return asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)
def add_invoice(self, amount_sat, message): def add_invoice(self, amount_sat, message):
is_open = lambda chan: self.channel_state[chan.channel_id] == "OPEN"
payment_preimage = os.urandom(32) payment_preimage = os.urandom(32)
RHASH = sha256(payment_preimage) RHASH = sha256(payment_preimage)
amount_btc = amount_sat/Decimal(COIN) if amount_sat else None amount_btc = amount_sat/Decimal(COIN) if amount_sat else None
@ -230,13 +231,15 @@ class LNWorker(PrintError):
return serialize_channels(self.channels) return serialize_channels(self.channels)
def close_channel(self, chan_id): def close_channel(self, chan_id):
from .lnhtlc import HTLCStateMachine
chan = self.channels[chan_id] chan = self.channels[chan_id]
# local_commitment always gives back the next expected local_commitment, # local_commitment always gives back the next expected local_commitment,
# but in this case, we want the current one. So substract one ctn number # 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 old_state = chan.state
tx.sign({bh2u(chan.local_config.multisig_key.pubkey): (chan.local_config.multisig_key.privkey, True)}) chan.state = chan.state._replace(local_state=chan.state.local_state._replace(ctn=chan.state.local_state.ctn - 1))
remote_sig = chan.local_state.current_commitment_signature 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" remote_sig = der_sig_from_sig_string(remote_sig) + b"\x01"
none_idx = tx._inputs[0]["signatures"].index(None) none_idx = tx._inputs[0]["signatures"].index(None)
tx.add_signature_to_txin(0, none_idx, bh2u(remote_sig)) tx.add_signature_to_txin(0, none_idx, bh2u(remote_sig))

36
lib/tests/test_lnhtlc.py
View File

@ -250,28 +250,44 @@ class TestLNBaseHTLCStateMachine(unittest.TestCase):
) )
aliceHtlcIndex = alice_channel.add_htlc(htlc) aliceHtlcIndex = alice_channel.add_htlc(htlc)
bobHtlcIndex = bob_channel.receive_htlc(htlc) bobHtlcIndex = bob_channel.receive_htlc(htlc)
force_state_transition(alice_channel, bob_channel) force_state_transition(alice_channel, bob_channel)
self.assertEqual(len(alice_channel.local_commitment.outputs()), 3) self.assertEqual(len(alice_channel.local_commitment.outputs()), 3)
self.assertEqual(len(bob_channel.local_commitment.outputs()), 2) self.assertEqual(len(bob_channel.local_commitment.outputs()), 2)
default_fee = calc_static_fee(0) default_fee = calc_static_fee(0)
self.assertEqual(bob_channel.local_commit_fee, default_fee) self.assertEqual(bob_channel.local_commit_fee, default_fee)
bob_channel.settle_htlc(paymentPreimage, htlc.htlc_id) bob_channel.settle_htlc(paymentPreimage, htlc.htlc_id)
alice_channel.receive_htlc_settle(paymentPreimage, aliceHtlcIndex) alice_channel.receive_htlc_settle(paymentPreimage, aliceHtlcIndex)
force_state_transition(bob_channel, alice_channel) force_state_transition(bob_channel, alice_channel)
self.assertEqual(len(alice_channel.local_commitment.outputs()), 2) self.assertEqual(len(alice_channel.local_commitment.outputs()), 2)
self.assertEqual(alice_channel.total_msat_sent // 1000, htlcAmt) 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): def force_state_transition(chanA, chanB):
chanB.receive_new_commitment(*chanA.sign_next_commitment()) chanB.receive_new_commitment(*chanA.sign_next_commitment())
rev, _ = chanB.revoke_current_commitment() rev, _ = chanB.revoke_current_commitment()