zebra.lucky
/
electrum
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

lnworker: do not create sweep transactions before outputs can be redeemed

master
ThomasV 7 years ago
parent
2b04cb3bc4
commit
81d340b19c
4 changed files with 59 additions and 53 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 72
      electrum/lnsweep.py
  2. 23
      electrum/lnworker.py
  3. 8
      electrum/simple_config.py
  4. 9
      electrum/tests/regtest/regtest.sh

72
electrum/lnsweep.py
Unescape View File

@ -15,7 +15,7 @@ from .lnutil import (make_commitment_output_to_remote_address, make_commitment_o
get_ordered_channel_configs, privkey_to_pubkey, get_per_commitment_secret_from_seed,
RevocationStore, extract_ctn_from_tx_and_chan, UnableToDeriveSecret, SENT, RECEIVED)
from .transaction import Transaction, TxOutput, construct_witness
from .simple_config import SimpleConfig, FEERATE_FALLBACK_STATIC_FEE
from .simple_config import estimate_fee
from .logging import get_logger
if TYPE_CHECKING:
@ -190,7 +190,7 @@ def create_sweeptxs_for_our_ctx(chan: 'Channel', ctx: Transaction,
to_local_address = redeem_script_to_address('p2wsh', to_local_witness_script)
output_idx = ctx.get_output_idx_from_address(to_local_address)
if output_idx is not None:
sweep_tx = create_sweeptx_ctx_to_local(
sweep_tx = lambda: create_sweeptx_ctx_to_local(
sweep_address=sweep_address,
ctx=ctx,
output_idx=output_idx,
@ -198,7 +198,8 @@ def create_sweeptxs_for_our_ctx(chan: 'Channel', ctx: Transaction,
privkey=our_localdelayed_privkey.get_secret_bytes(),
is_revocation=False,
to_self_delay=to_self_delay)
txs[sweep_tx.prevout(0)] = sweep_tx
prevout = ctx.txid() + ':%d'%output_idx
txs[prevout] = ('our_ctx_to_local', to_self_delay, 0, sweep_tx)
# HTLCs
def create_txns_for_htlc(htlc: 'UpdateAddHtlc', is_received_htlc: bool) -> Tuple[Optional[Transaction], Optional[Transaction]]:
if is_received_htlc:
@ -217,7 +218,7 @@ def create_sweeptxs_for_our_ctx(chan: 'Channel', ctx: Transaction,
local_htlc_privkey=this_htlc_privkey,
preimage=preimage,
is_received_htlc=is_received_htlc)
to_wallet_tx = create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
sweep_tx = lambda: create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
'sweep_from_our_ctx_htlc_',
to_self_delay=to_self_delay,
htlc_tx=htlc_tx,
@ -225,21 +226,17 @@ def create_sweeptxs_for_our_ctx(chan: 'Channel', ctx: Transaction,
sweep_address=sweep_address,
privkey=our_localdelayed_privkey.get_secret_bytes(),
is_revocation=False)
return htlc_tx, to_wallet_tx
# 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)
# offered HTLCs, in our ctx --> "timeout"
# received HTLCs, in our ctx --> "success"
offered_htlcs = chan.included_htlcs(LOCAL, SENT, ctn) # type: List[UpdateAddHtlc]
received_htlcs = chan.included_htlcs(LOCAL, RECEIVED, ctn) # type: List[UpdateAddHtlc]
for htlc in offered_htlcs:
htlc_tx, to_wallet_tx = create_txns_for_htlc(htlc, is_received_htlc=False)
if htlc_tx and to_wallet_tx:
txs[to_wallet_tx.prevout(0)] = to_wallet_tx
txs[htlc_tx.prevout(0)] = htlc_tx
create_txns_for_htlc(htlc, is_received_htlc=False)
for htlc in received_htlcs:
htlc_tx, to_wallet_tx = create_txns_for_htlc(htlc, is_received_htlc=True)
if htlc_tx and to_wallet_tx:
txs[to_wallet_tx.prevout(0)] = to_wallet_tx
txs[htlc_tx.prevout(0)] = htlc_tx
create_txns_for_htlc(htlc, is_received_htlc=True)
return txs
@ -286,12 +283,13 @@ def create_sweeptxs_for_their_ctx(chan: 'Channel', ctx: Transaction,
to_remote_address = make_commitment_output_to_remote_address(our_payment_pubkey)
output_idx = ctx.get_output_idx_from_address(to_remote_address)
if output_idx is not None:
sweep_tx = create_sweeptx_their_ctx_to_remote(
prevout = ctx.txid() + ':%d'%output_idx
sweep_tx = lambda: create_sweeptx_their_ctx_to_remote(
sweep_address=sweep_address,
ctx=ctx,
output_idx=output_idx,
our_payment_privkey=other_payment_privkey)
txs[sweep_tx.prevout(0)] = sweep_tx
txs[prevout] = ('their_ctx_to_remote', 0, 0, sweep_tx)
# HTLCs
def create_sweeptx_for_htlc(htlc: 'UpdateAddHtlc', is_received_htlc: bool) -> Optional[Transaction]:
if not is_received_htlc and not is_revocation:
@ -314,7 +312,9 @@ def create_sweeptxs_for_their_ctx(chan: 'Channel', ctx: Transaction,
# also: https://github.com/lightningnetwork/lightning-rfc/issues/448
output_idx = ctx.get_output_idx_from_address(htlc_address)
if output_idx is not None:
sweep_tx = create_sweeptx_their_ctx_htlc(
cltv_expiry = htlc.cltv_expiry if is_received_htlc and not is_revocation else 0
prevout = ctx.txid() + ':%d'%output_idx
sweep_tx = lambda: create_sweeptx_their_ctx_htlc(
ctx=ctx,
witness_script=htlc_output_witness_script,
sweep_address=sweep_address,
@ -322,20 +322,17 @@ def create_sweeptxs_for_their_ctx(chan: 'Channel', ctx: Transaction,
output_idx=output_idx,
privkey=other_revocation_privkey if is_revocation else other_htlc_privkey.get_secret_bytes(),
is_revocation=is_revocation,
cltv_expiry=htlc.cltv_expiry if is_received_htlc and not is_revocation else 0)
return sweep_tx
cltv_expiry=cltv_expiry)
name = f'their_ctx_sweep_htlc_{ctx.txid()[:8]}_{output_idx}'
txs[prevout] = (name, 0, cltv_expiry, sweep_tx)
# received HTLCs, in their ctx --> "timeout"
received_htlcs = chan.included_htlcs(REMOTE, RECEIVED, ctn=ctn) # type: List[UpdateAddHtlc]
for htlc in received_htlcs:
sweep_tx = create_sweeptx_for_htlc(htlc, is_received_htlc=True)
if sweep_tx:
txs[sweep_tx.prevout(0)] = sweep_tx
create_sweeptx_for_htlc(htlc, is_received_htlc=True)
# offered HTLCs, in their ctx --> "success"
offered_htlcs = chan.included_htlcs(REMOTE, SENT, ctn=ctn) # type: List[UpdateAddHtlc]
for htlc in offered_htlcs:
sweep_tx = create_sweeptx_for_htlc(htlc, is_received_htlc=False)
if sweep_tx:
txs[sweep_tx.prevout(0)] = sweep_tx
create_sweeptx_for_htlc(htlc, is_received_htlc=False)
return txs
@ -363,8 +360,8 @@ def create_htlctx_that_spends_from_our_ctx(chan: 'Channel', our_pcp: bytes,
def create_sweeptx_their_ctx_htlc(ctx: Transaction, witness_script: bytes, sweep_address: str,
preimage: Optional[bytes], output_idx: int,
privkey: bytes, is_revocation: bool, cltv_expiry: int,
fee_per_kb: int=None) -> Optional[Transaction]:
privkey: bytes, is_revocation: bool,
cltv_expiry: int) -> Optional[Transaction]:
assert type(cltv_expiry) is int
preimage = preimage or b'' # preimage is required iff (not is_revocation and htlc is offered)
val = ctx.outputs()[output_idx].value
@ -380,8 +377,7 @@ def create_sweeptx_their_ctx_htlc(ctx: Transaction, witness_script: bytes, sweep
'preimage_script': bh2u(witness_script),
}]
tx_size_bytes = 200 # TODO (depends on offered/received and is_revocation)
if fee_per_kb is None: fee_per_kb = FEERATE_FALLBACK_STATIC_FEE
fee = SimpleConfig.estimate_fee_for_feerate(fee_per_kb, tx_size_bytes)
fee = estimate_fee(tx_size_bytes)
outvalue = val - fee
if outvalue <= dust_threshold(): return None
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
@ -389,7 +385,6 @@ def create_sweeptx_their_ctx_htlc(ctx: Transaction, witness_script: bytes, sweep
, name=f'their_ctx_sweep_htlc_{ctx.txid()[:8]}_{output_idx}'
# note that cltv_expiry, and therefore also locktime will be zero when breach!
, cltv_expiry=cltv_expiry, locktime=cltv_expiry)
sig = bfh(tx.sign_txin(0, privkey))
if not is_revocation:
witness = construct_witness([sig, preimage, witness_script])
@ -402,8 +397,7 @@ def create_sweeptx_their_ctx_htlc(ctx: Transaction, witness_script: bytes, sweep
def create_sweeptx_their_ctx_to_remote(sweep_address: str, ctx: Transaction, output_idx: int,
our_payment_privkey: ecc.ECPrivkey,
fee_per_kb: int=None) -> Optional[Transaction]:
our_payment_privkey: ecc.ECPrivkey) -> Optional[Transaction]:
our_payment_pubkey = our_payment_privkey.get_public_key_hex(compressed=True)
val = ctx.outputs()[output_idx].value
sweep_inputs = [{
@ -417,8 +411,7 @@ def create_sweeptx_their_ctx_to_remote(sweep_address: str, ctx: Transaction, out
'signatures': [None],
}]
tx_size_bytes = 110 # approx size of p2wpkh->p2wpkh
if fee_per_kb is None: fee_per_kb = FEERATE_FALLBACK_STATIC_FEE
fee = SimpleConfig.estimate_fee_for_feerate(fee_per_kb, tx_size_bytes)
fee = estimate_fee(tx_size_bytes)
outvalue = val - fee
if outvalue <= dust_threshold(): return None
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
@ -432,8 +425,7 @@ def create_sweeptx_their_ctx_to_remote(sweep_address: str, ctx: Transaction, out
def create_sweeptx_ctx_to_local(sweep_address: str, ctx: Transaction, output_idx: int, witness_script: str,
privkey: bytes, is_revocation: bool,
to_self_delay: int=None,
fee_per_kb: int=None) -> Optional[Transaction]:
to_self_delay: int=None) -> Optional[Transaction]:
"""Create a txn that sweeps the 'to_local' output of a commitment
transaction into our wallet.
@ -456,9 +448,7 @@ def create_sweeptx_ctx_to_local(sweep_address: str, ctx: Transaction, output_idx
assert isinstance(to_self_delay, int)
sweep_inputs[0]['sequence'] = to_self_delay
tx_size_bytes = 121 # approx size of to_local -> p2wpkh
if fee_per_kb is None:
fee_per_kb = FEERATE_FALLBACK_STATIC_FEE
fee = SimpleConfig.estimate_fee_for_feerate(fee_per_kb, tx_size_bytes)
fee = estimate_fee(tx_size_bytes)
outvalue = val - fee
if outvalue <= dust_threshold():
return None
@ -475,8 +465,7 @@ def create_sweeptx_ctx_to_local(sweep_address: str, ctx: Transaction, output_idx
def create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
name_prefix: str,
htlc_tx: Transaction, htlctx_witness_script: bytes, sweep_address: str,
privkey: bytes, is_revocation: bool, to_self_delay: int,
fee_per_kb: int=None) -> Optional[Transaction]:
privkey: bytes, is_revocation: bool, to_self_delay: int) -> Optional[Transaction]:
val = htlc_tx.outputs()[0].value
sweep_inputs = [{
'scriptSig': '',
@ -493,8 +482,7 @@ def create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
assert isinstance(to_self_delay, int)
sweep_inputs[0]['sequence'] = to_self_delay
tx_size_bytes = 200 # TODO
if fee_per_kb is None: fee_per_kb = FEERATE_FALLBACK_STATIC_FEE
fee = SimpleConfig.estimate_fee_for_feerate(fee_per_kb, tx_size_bytes)
fee = estimate_fee(tx_size_bytes)
outvalue = val - fee
if outvalue <= dust_threshold(): return None
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]

23
electrum/lnworker.py
Unescape View File

@ -529,30 +529,35 @@ class LNWallet(LNWorker):
# create and broadcast transaction
for prevout, e_tx in chan.sweep_info.items():
name, csv_delay, cltv_expiry, gen_tx = e_tx
if spenders.get(prevout) is not None:
self.logger.info(f'outpoint already spent {prevout}')
continue
prev_txid, prev_index = prevout.split(':')
broadcast = True
if e_tx.cltv_expiry:
if cltv_expiry:
local_height = self.network.get_local_height()
remaining = e_tx.cltv_expiry - local_height
remaining = cltv_expiry - local_height
if remaining > 0:
self.logger.info('waiting for {}: CLTV ({} > {}), funding outpoint {} and tx {}'
.format(e_tx.name, local_height, e_tx.cltv_expiry, funding_outpoint[:8], prev_txid[:8]))
.format(name, local_height, cltv_expiry, funding_outpoint[:8], prev_txid[:8]))
broadcast = False
if e_tx.csv_delay:
if csv_delay:
prev_height = self.network.lnwatcher.get_tx_height(prev_txid)
remaining = e_tx.csv_delay - prev_height.conf
remaining = csv_delay - prev_height.conf
if remaining > 0:
self.logger.info('waiting for {}: CSV ({} >= {}), funding outpoint {} and tx {}'
.format(e_tx.name, prev_height.conf, e_tx.csv_delay, funding_outpoint[:8], prev_txid[:8]))
.format(name, prev_height.conf, csv_delay, funding_outpoint[:8], prev_txid[:8]))
broadcast = False
tx = gen_tx()
if tx is None:
self.logger.info(f'{name} could not claim output: {prevout}, dust')
if broadcast:
if not await self.network.lnwatcher.broadcast_or_log(funding_outpoint, e_tx):
self.logger.info(f'{e_tx.name} could not publish encumbered tx: {str(e_tx)}, prevout: {prevout}')
if not await self.network.lnwatcher.broadcast_or_log(funding_outpoint, tx):
self.logger.info(f'{name} could not publish encumbered tx: {str(tx)}, prevout: {prevout}')
else:
self.wallet.add_future_tx(e_tx, remaining)
# it's OK to add local transaction, the fee will be recomputed
self.wallet.add_future_tx(tx, remaining)
def is_dangerous(self, chan):
for x in chan.get_unfulfilled_htlcs():

8
electrum/simple_config.py
Unescape View File

@ -44,6 +44,14 @@ def set_config(c):
global config
config = c
def estimate_fee(tx_size_bytes):
global config
if config:
fee = config.estimate_fee(tx_size_bytes)
else:
fee_per_kb = FEERATE_FALLBACK_STATIC_FEE
fee = SimpleConfig.estimate_fee_for_feerate(fee_per_kb, tx_size_bytes)
return fee
FINAL_CONFIG_VERSION = 3

9
electrum/tests/regtest/regtest.sh
Unescape View File

@ -132,13 +132,18 @@ if [[ $1 == "redeem_htlcs" ]]; then
chan_id=$($alice list_channels | jq -r ".[0].channel_point")
$alice close_channel $chan_id --force
new_blocks 1
sleep 5
sleep 3
echo "alice balance after closing channel:" $($alice getbalance)
new_blocks 144
sleep 10
new_blocks 1
sleep 3
echo "alice balance after CLTV" $($alice getbalance)
new_blocks 144
sleep 10
echo "alice balance after 144 blocks:" $($alice getbalance)
new_blocks 1
sleep 3
echo "alice balance after CSV" $($alice getbalance)
balance_after=$($alice getbalance | jq '[.confirmed, .unconfirmed] | to_entries | map(select(.value != null).value) | map(tonumber) | add ')
if (( $(echo "$balance_before - $balance_after > 0.02" | bc -l) )); then
echo "htlc not redeemed."

Write Preview
Loading…
Cancel
Save