commit befa8ea771a6ed3494cc9ba9061d8fbaa9e0807d
parent e5502a58ba8fb7302f9b869981f6b23637daa6f9
Author: SomberNight <somber.night@protonmail.com>
Date: Mon, 9 Sep 2019 19:38:35 +0200
transaction: kill "name", "csv_delay", "cltv_expiry" fields
Diffstat:
9 files changed, 81 insertions(+), 75 deletions(-)
diff --git a/electrum/lnchannel.py b/electrum/lnchannel.py
@@ -49,7 +49,7 @@ from .lnutil import (Outpoint, LocalConfig, RemoteConfig, Keypair, OnlyPubkeyKey
ShortChannelID, map_htlcs_to_ctx_output_idxs)
from .lnutil import FeeUpdate
from .lnsweep import create_sweeptxs_for_our_ctx, create_sweeptxs_for_their_ctx
-from .lnsweep import create_sweeptx_for_their_revoked_htlc
+from .lnsweep import create_sweeptx_for_their_revoked_htlc, SweepInfo
from .lnhtlc import HTLCManager
@@ -146,7 +146,7 @@ class Channel(Logger):
self._is_funding_txo_spent = None # "don't know"
self._state = None
self.set_state('DISCONNECTED')
- self.sweep_info = {}
+ self.sweep_info = {} # type: Dict[str, Dict[str, SweepInfo]]
self._outgoing_channel_update = None # type: Optional[bytes]
def get_feerate(self, subject, ctn):
@@ -756,7 +756,7 @@ class Channel(Logger):
assert tx.is_complete()
return tx
- def sweep_ctx(self, ctx: Transaction):
+ def sweep_ctx(self, ctx: Transaction) -> Dict[str, SweepInfo]:
txid = ctx.txid()
if self.sweep_info.get(txid) is None:
our_sweep_info = create_sweeptxs_for_our_ctx(chan=self, ctx=ctx, sweep_address=self.sweep_address)
diff --git a/electrum/lnsweep.py b/electrum/lnsweep.py
@@ -26,6 +26,11 @@ if TYPE_CHECKING:
_logger = get_logger(__name__)
+class SweepInfo(NamedTuple):
+ name: str
+ csv_delay: int
+ cltv_expiry: int
+ gen_tx: Callable[[], Optional[Transaction]]
def create_sweeptxs_for_watchtower(chan: 'Channel', ctx: Transaction, per_commitment_secret: bytes,
@@ -70,7 +75,6 @@ def create_sweeptxs_for_watchtower(chan: 'Channel', ctx: Transaction, per_commit
htlc=htlc,
ctx_output_idx=ctx_output_idx)
return create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
- 'sweep_from_their_ctx_htlc_',
to_self_delay=0,
htlc_tx=htlc_tx,
htlctx_witness_script=htlc_tx_witness_script,
@@ -122,7 +126,7 @@ def create_sweeptx_for_their_revoked_ctx(chan: 'Channel', ctx: Transaction, per_
return None
def create_sweeptx_for_their_revoked_htlc(chan: 'Channel', ctx: Transaction, htlc_tx: Transaction,
- sweep_address: str) -> Optional[Tuple[str, int, int, Callable]]:
+ sweep_address: str) -> Optional[SweepInfo]:
x = analyze_ctx(chan, ctx)
if not x:
return
@@ -153,12 +157,15 @@ def create_sweeptx_for_their_revoked_htlc(chan: 'Channel', ctx: Transaction, htl
privkey=other_revocation_privkey,
is_revocation=True)
- return 'redeem_htlc2', 0, 0, gen_tx
+ return SweepInfo(name='redeem_htlc2',
+ csv_delay=0,
+ cltv_expiry=0,
+ gen_tx=gen_tx)
def create_sweeptxs_for_our_ctx(*, chan: 'Channel', ctx: Transaction,
- sweep_address: str) -> Optional[Dict[str, Tuple]]:
+ sweep_address: str) -> Optional[Dict[str, SweepInfo]]:
"""Handle the case where we force close unilaterally with our latest ctx.
Construct sweep txns for 'to_local', and for all HTLCs (2 txns each).
'to_local' can be swept even if this is a breach (by us),
@@ -194,7 +201,7 @@ def create_sweeptxs_for_our_ctx(*, chan: 'Channel', ctx: Transaction,
if ctn < chan.get_oldest_unrevoked_ctn(LOCAL):
_logger.info("we breached.")
return {}
- txs = {}
+ txs = {} # type: Dict[str, SweepInfo]
# to_local
output_idxs = ctx.get_output_idxs_from_address(to_local_address)
if output_idxs:
@@ -208,7 +215,10 @@ def create_sweeptxs_for_our_ctx(*, chan: 'Channel', ctx: Transaction,
is_revocation=False,
to_self_delay=to_self_delay)
prevout = ctx.txid() + ':%d'%output_idx
- txs[prevout] = ('our_ctx_to_local', to_self_delay, 0, sweep_tx)
+ txs[prevout] = SweepInfo(name='our_ctx_to_local',
+ csv_delay=to_self_delay,
+ cltv_expiry=0,
+ gen_tx=sweep_tx)
# HTLCs
def create_txns_for_htlc(*, htlc: 'UpdateAddHtlc', htlc_direction: Direction,
ctx_output_idx: int, htlc_relative_idx: int):
@@ -231,7 +241,6 @@ def create_sweeptxs_for_our_ctx(*, chan: 'Channel', ctx: Transaction,
ctx_output_idx=ctx_output_idx,
htlc_relative_idx=htlc_relative_idx)
sweep_tx = lambda: create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
- 'our_ctx_htlc_',
to_self_delay=to_self_delay,
htlc_tx=htlc_tx,
htlctx_witness_script=htlctx_witness_script,
@@ -239,8 +248,14 @@ def create_sweeptxs_for_our_ctx(*, chan: 'Channel', ctx: Transaction,
privkey=our_localdelayed_privkey.get_secret_bytes(),
is_revocation=False)
# side effect
- txs[htlc_tx.prevout(0)] = ('first-stage-htlc', 0, htlc_tx.cltv_expiry, lambda: htlc_tx)
- txs[htlc_tx.txid() + ':0'] = ('second-stage-htlc', to_self_delay, 0, sweep_tx)
+ txs[htlc_tx.prevout(0)] = SweepInfo(name='first-stage-htlc',
+ csv_delay=0,
+ cltv_expiry=htlc_tx.locktime,
+ gen_tx=lambda: htlc_tx)
+ txs[htlc_tx.txid() + ':0'] = SweepInfo(name='second-stage-htlc',
+ csv_delay=to_self_delay,
+ cltv_expiry=0,
+ gen_tx=sweep_tx)
# offered HTLCs, in our ctx --> "timeout"
# received HTLCs, in our ctx --> "success"
@@ -285,12 +300,12 @@ def analyze_ctx(chan: 'Channel', ctx: Transaction):
return ctn, their_pcp, is_revocation, per_commitment_secret
def create_sweeptxs_for_their_ctx(*, chan: 'Channel', ctx: Transaction,
- sweep_address: str) -> Optional[Dict[str,Tuple]]:
+ sweep_address: str) -> Optional[Dict[str,SweepInfo]]:
"""Handle the case when the remote force-closes with their ctx.
Sweep outputs that do not have a CSV delay ('to_remote' and first-stage HTLCs).
Outputs with CSV delay ('to_local' and second-stage HTLCs) are redeemed by LNWatcher.
"""
- txs = {}
+ txs = {} # type: Dict[str, SweepInfo]
our_conf, their_conf = get_ordered_channel_configs(chan=chan, for_us=True)
x = analyze_ctx(chan, ctx)
if not x:
@@ -315,7 +330,10 @@ def create_sweeptxs_for_their_ctx(*, chan: 'Channel', ctx: Transaction,
gen_tx = create_sweeptx_for_their_revoked_ctx(chan, ctx, per_commitment_secret, chan.sweep_address)
if gen_tx:
tx = gen_tx()
- txs[tx.prevout(0)] = ('to_local_for_revoked_ctx', 0, 0, gen_tx)
+ txs[tx.prevout(0)] = SweepInfo(name='to_local_for_revoked_ctx',
+ csv_delay=0,
+ cltv_expiry=0,
+ gen_tx=gen_tx)
# prep
our_htlc_privkey = derive_privkey(secret=int.from_bytes(our_conf.htlc_basepoint.privkey, 'big'), per_commitment_point=their_pcp)
our_htlc_privkey = ecc.ECPrivkey.from_secret_scalar(our_htlc_privkey)
@@ -335,7 +353,10 @@ def create_sweeptxs_for_their_ctx(*, chan: 'Channel', ctx: Transaction,
ctx=ctx,
output_idx=output_idx,
our_payment_privkey=our_payment_privkey)
- txs[prevout] = ('their_ctx_to_remote', 0, 0, sweep_tx)
+ txs[prevout] = SweepInfo(name='their_ctx_to_remote',
+ csv_delay=0,
+ cltv_expiry=0,
+ gen_tx=sweep_tx)
# HTLCs
def create_sweeptx_for_htlc(htlc: 'UpdateAddHtlc', is_received_htlc: bool,
ctx_output_idx: int) -> None:
@@ -366,8 +387,10 @@ def create_sweeptxs_for_their_ctx(*, chan: 'Channel', ctx: Transaction,
privkey=our_revocation_privkey if is_revocation else our_htlc_privkey.get_secret_bytes(),
is_revocation=is_revocation,
cltv_expiry=cltv_expiry)
- name = f'their_ctx_htlc_{ctx_output_idx}'
- txs[prevout] = (name, 0, cltv_expiry, sweep_tx)
+ txs[prevout] = SweepInfo(name=f'their_ctx_htlc_{ctx_output_idx}',
+ csv_delay=0,
+ cltv_expiry=cltv_expiry,
+ gen_tx=sweep_tx)
# received HTLCs, in their ctx --> "timeout"
# offered HTLCs, in their ctx --> "success"
@@ -429,10 +452,7 @@ def create_sweeptx_their_ctx_htlc(ctx: Transaction, witness_script: bytes, sweep
outvalue = val - fee
if outvalue <= dust_threshold(): return None
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
- tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2
- , name=f'their_ctx_htlc_{output_idx}'
- # note that cltv_expiry, and therefore also locktime will be zero when breach!
- , cltv_expiry=cltv_expiry, locktime=cltv_expiry)
+ tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2, locktime=cltv_expiry)
sig = bfh(tx.sign_txin(0, privkey))
if not is_revocation:
witness = construct_witness([sig, preimage, witness_script])
@@ -463,7 +483,7 @@ def create_sweeptx_their_ctx_to_remote(sweep_address: str, ctx: Transaction, out
outvalue = val - fee
if outvalue <= dust_threshold(): return None
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
- sweep_tx = Transaction.from_io(sweep_inputs, sweep_outputs, name='their_ctx_to_remote')
+ sweep_tx = Transaction.from_io(sweep_inputs, sweep_outputs)
sweep_tx.set_rbf(True)
sweep_tx.sign({our_payment_pubkey: (our_payment_privkey.get_secret_bytes(), True)})
if not sweep_tx.is_complete():
@@ -501,17 +521,14 @@ def create_sweeptx_ctx_to_local(sweep_address: str, ctx: Transaction, output_idx
if outvalue <= dust_threshold():
return None
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
- name = 'their_ctx_to_local' if is_revocation else 'our_ctx_to_local'
- csv_delay = 0 if is_revocation else to_self_delay
- sweep_tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2, name=name, csv_delay=csv_delay)
+ sweep_tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2)
sig = sweep_tx.sign_txin(0, privkey)
witness = construct_witness([sig, int(is_revocation), witness_script])
sweep_tx.inputs()[0]['witness'] = witness
return sweep_tx
-def create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
- name_prefix: str,
+def create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(*,
htlc_tx: Transaction, htlctx_witness_script: bytes, sweep_address: str,
privkey: bytes, is_revocation: bool, to_self_delay: int) -> Optional[Transaction]:
val = htlc_tx.outputs()[0].value
@@ -534,8 +551,7 @@ def create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
outvalue = val - fee
if outvalue <= dust_threshold(): return None
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
- name = name_prefix + htlc_tx.txid()[0:4]
- tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2, name=name, csv_delay=to_self_delay)
+ tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2)
sig = bfh(tx.sign_txin(0, privkey))
witness = construct_witness([sig, int(is_revocation), htlctx_witness_script])
diff --git a/electrum/lnutil.py b/electrum/lnutil.py
@@ -318,10 +318,10 @@ def make_htlc_tx_inputs(htlc_output_txid: str, htlc_output_index: int,
}]
return c_inputs
-def make_htlc_tx(cltv_timeout, inputs, output, name, cltv_expiry):
- assert type(cltv_timeout) is int
+def make_htlc_tx(*, cltv_expiry: int, inputs, output) -> Transaction:
+ assert type(cltv_expiry) is int
c_outputs = [output]
- tx = Transaction.from_io(inputs, c_outputs, locktime=cltv_timeout, version=2, name=name, cltv_expiry=cltv_expiry)
+ tx = Transaction.from_io(inputs, c_outputs, locktime=cltv_expiry, version=2)
return tx
def make_offered_htlc(revocation_pubkey: bytes, remote_htlcpubkey: bytes,
@@ -468,8 +468,7 @@ def make_htlc_tx_with_open_channel(*, chan: 'Channel', pcp: bytes, subject: 'HTL
witness_script=bh2u(preimage_script))
if is_htlc_success:
cltv_expiry = 0
- htlc_tx = make_htlc_tx(cltv_expiry, inputs=htlc_tx_inputs, output=htlc_tx_output,
- name=name, cltv_expiry=cltv_expiry)
+ htlc_tx = make_htlc_tx(cltv_expiry=cltv_expiry, inputs=htlc_tx_inputs, output=htlc_tx_output)
return witness_script_of_htlc_tx_output, htlc_tx
def make_funding_input(local_funding_pubkey: bytes, remote_funding_pubkey: bytes,
@@ -672,7 +671,8 @@ def get_compressed_pubkey_from_bech32(bech32_pubkey: str) -> bytes:
def make_closing_tx(local_funding_pubkey: bytes, remote_funding_pubkey: bytes,
- funding_txid: bytes, funding_pos: int, funding_sat: int, outputs: List[TxOutput]):
+ funding_txid: bytes, funding_pos: int, funding_sat: int,
+ outputs: List[TxOutput]) -> Transaction:
c_input = make_funding_input(local_funding_pubkey, remote_funding_pubkey,
funding_pos, funding_txid, funding_sat)
c_input['sequence'] = 0xFFFF_FFFF
diff --git a/electrum/lnwatcher.py b/electrum/lnwatcher.py
@@ -268,16 +268,16 @@ class WatchTower(LNWatcher):
for tx in sweep_txns:
await self.broadcast_or_log(funding_outpoint, tx)
- async def broadcast_or_log(self, funding_outpoint, tx):
+ async def broadcast_or_log(self, funding_outpoint: str, tx: Transaction):
height = self.get_tx_height(tx.txid()).height
if height != TX_HEIGHT_LOCAL:
return
try:
txid = await self.network.broadcast_transaction(tx)
except Exception as e:
- self.logger.info(f'broadcast failure: {tx.name}: {repr(e)}')
+ self.logger.info(f'broadcast failure: txid={tx.txid()}, funding_outpoint={funding_outpoint}: {repr(e)}')
else:
- self.logger.info(f'broadcast success: {tx.name}')
+ self.logger.info(f'broadcast success: txid={tx.txid()}, funding_outpoint={funding_outpoint}')
if funding_outpoint in self.tx_progress:
await self.tx_progress[funding_outpoint].tx_queue.put(tx)
return txid
diff --git a/electrum/lnworker.py b/electrum/lnworker.py
@@ -56,6 +56,7 @@ from .lnwatcher import LNWatcher
if TYPE_CHECKING:
from .network import Network
from .wallet import Abstract_Wallet
+ from .lnsweep import SweepInfo
NUM_PEERS_TARGET = 4
@@ -601,11 +602,11 @@ class LNWallet(LNWorker):
if chan.short_channel_id is not None:
self.channel_db.remove_channel(chan.short_channel_id)
# detect who closed and set sweep_info
- sweep_info = chan.sweep_ctx(closing_tx)
- self.logger.info(f'sweep_info length: {len(sweep_info)}')
+ sweep_info_dict = chan.sweep_ctx(closing_tx)
+ self.logger.info(f'sweep_info_dict length: {len(sweep_info_dict)}')
# create and broadcast transaction
- for prevout, e_tx in sweep_info.items():
- name, csv_delay, cltv_expiry, gen_tx = e_tx
+ for prevout, sweep_info in sweep_info_dict.items():
+ name = sweep_info.name
spender = spenders.get(prevout)
if spender is not None:
spender_tx = await self.network.get_transaction(spender)
@@ -622,31 +623,31 @@ class LNWallet(LNWorker):
self.logger.info(f'outpoint already spent {name}: {prevout}')
else:
self.logger.info(f'trying to redeem {name}: {prevout}')
- await self.try_redeem(prevout, e_tx)
+ await self.try_redeem(prevout, sweep_info)
@log_exceptions
- async def try_redeem(self, prevout, e_tx):
- name, csv_delay, cltv_expiry, gen_tx = e_tx
+ async def try_redeem(self, prevout: str, sweep_info: 'SweepInfo') -> None:
+ name = sweep_info.name
prev_txid, prev_index = prevout.split(':')
broadcast = True
- if cltv_expiry:
+ if sweep_info.cltv_expiry:
local_height = self.network.get_local_height()
- remaining = cltv_expiry - local_height
+ remaining = sweep_info.cltv_expiry - local_height
if remaining > 0:
self.logger.info('waiting for {}: CLTV ({} > {}), prevout {}'
- .format(name, local_height, cltv_expiry, prevout))
+ .format(name, local_height, sweep_info.cltv_expiry, prevout))
broadcast = False
- if csv_delay:
+ if sweep_info.csv_delay:
prev_height = self.lnwatcher.get_tx_height(prev_txid)
- remaining = csv_delay - prev_height.conf
+ remaining = sweep_info.csv_delay - prev_height.conf
if remaining > 0:
self.logger.info('waiting for {}: CSV ({} >= {}), prevout: {}'
- .format(name, prev_height.conf, csv_delay, prevout))
+ .format(name, prev_height.conf, sweep_info.csv_delay, prevout))
broadcast = False
- tx = gen_tx()
- self.wallet.set_label(tx.txid(), name)
+ tx = sweep_info.gen_tx()
if tx is None:
self.logger.info(f'{name} could not claim output: {prevout}, dust')
+ self.wallet.set_label(tx.txid(), name)
if broadcast:
try:
await self.network.broadcast_transaction(tx)
diff --git a/electrum/network.py b/electrum/network.py
@@ -62,6 +62,8 @@ from .logging import get_logger, Logger
if TYPE_CHECKING:
from .channel_db import ChannelDB
+ from .lnworker import LNGossip
+ from .lnwatcher import WatchTower
_logger = get_logger(__name__)
@@ -311,8 +313,8 @@ class Network(Logger):
self.local_watchtower = lnwatcher.WatchTower(self) if self.config.get('local_watchtower', False) else None
else:
self.channel_db = None # type: Optional[ChannelDB]
- self.lngossip = None
- self.local_watchtower = None
+ self.lngossip = None # type: Optional[LNGossip]
+ self.local_watchtower = None # type: Optional[WatchTower]
def run_from_another_thread(self, coro, *, timeout=None):
assert self._loop_thread != threading.current_thread(), 'must not be called from network thread'
diff --git a/electrum/tests/test_lnutil.py b/electrum/tests/test_lnutil.py
@@ -553,11 +553,10 @@ class TestLNUtil(unittest.TestCase):
htlc_output_index=htlc_output_index,
amount_msat=amount_msat,
witness_script=bh2u(htlc))
- our_htlc_tx = make_htlc_tx(cltv_timeout,
+ our_htlc_tx = make_htlc_tx(
+ cltv_expiry=cltv_timeout,
inputs=our_htlc_tx_inputs,
- output=our_htlc_tx_output,
- name='test',
- cltv_expiry=0)
+ output=our_htlc_tx_output)
local_sig = our_htlc_tx.sign_txin(0, local_privkey[:-1])
diff --git a/electrum/tests/test_transaction.py b/electrum/tests/test_transaction.py
@@ -86,7 +86,7 @@ class TestTransaction(SequentialTestCase):
self.assertEqual(tx.deserialize(), expected)
self.assertEqual(tx.deserialize(), None)
- self.assertEqual(tx.as_dict(), {'hex': unsigned_blob, 'complete': False, 'final': True, 'csv_delay': 0, 'cltv_expiry': 0, 'name': None})
+ self.assertEqual(tx.as_dict(), {'hex': unsigned_blob, 'complete': False, 'final': True})
self.assertEqual(tx.get_outputs_for_UI(), [TxOutputForUI('14CHYaaByjJZpx4oHBpfDMdqhTyXnZ3kVs', 1000000)])
self.assertTrue(tx.has_address('14CHYaaByjJZpx4oHBpfDMdqhTyXnZ3kVs'))
@@ -127,7 +127,7 @@ class TestTransaction(SequentialTestCase):
tx = transaction.Transaction(signed_blob)
self.assertEqual(tx.deserialize(), expected)
self.assertEqual(tx.deserialize(), None)
- self.assertEqual(tx.as_dict(), {'hex': signed_blob, 'complete': True, 'final': True, 'csv_delay': 0, 'cltv_expiry': 0, 'name': None})
+ self.assertEqual(tx.as_dict(), {'hex': signed_blob, 'complete': True, 'final': True})
self.assertEqual(tx.serialize(), signed_blob)
diff --git a/electrum/transaction.py b/electrum/transaction.py
@@ -607,9 +607,6 @@ class Transaction:
self._outputs = None # type: List[TxOutput]
self.locktime = 0
self.version = 2
- self.name = None
- self.csv_delay = 0
- self.cltv_expiry = 0
# by default we assume this is a partial txn;
# this value will get properly set when deserializing
self.is_partial_originally = True
@@ -720,16 +717,13 @@ class Transaction:
return d
@classmethod
- def from_io(klass, inputs, outputs, locktime=0, version=None, name=None, csv_delay=0, cltv_expiry=0):
+ def from_io(klass, inputs, outputs, *, locktime=0, version=None):
self = klass(None)
self._inputs = inputs
self._outputs = outputs
self.locktime = locktime
if version is not None:
self.version = version
- self.name = name
- self.csv_delay = csv_delay
- self.cltv_expiry = cltv_expiry
self.BIP69_sort()
return self
@@ -1229,9 +1223,6 @@ class Transaction:
'hex': self.raw,
'complete': self.is_complete(),
'final': self.is_final(),
- 'name': self.name,
- 'csv_delay': self.csv_delay,
- 'cltv_expiry': self.cltv_expiry,
}
return out
@@ -1239,9 +1230,6 @@ class Transaction:
def from_dict(cls, d):
tx = cls(d['hex'])
tx.deserialize(True)
- tx.name = d.get('name')
- tx.csv_delay = d.get('csv_delay', 0)
- tx.cltv_expiry = d.get('cltv_expiry', 0)
return tx
