cba073dfd1
Ideally, given an on-chain backup, after the remote force-closes, we should be able to spend our anchor output,
to CPFP the remote commitment tx (assuming the channel used OPTION_ANCHORS).
To spend the anchor output, we need to be able to sign with the local funding_privkey.
Previously we derived the funding_key from the channel_seed (which comes from os.urandom).
Prior to anchors, there was no use case for signing with the funding_key given a channel backup.
Now with anchors, we should make its derivation deterministic somehow, in a way so that it can
be derived given just an on-chain backup.
- one way would be to put some more data into the existing OP_RETURN
- uses block space
- the OP_RETURNs can be disabled via "use_recoverable_channels"
- only the initiator can use OP_RETURNs (so what if channel is in incoming dir?)
- instead, new scheme for our funding_key:
- we derive the funding_privkey from the lnworker root secret (derived from our bip32 seed)
- for outgoing channels:
- lnworker_root_secret + remote_node_id + funding_tx_nlocktime
- for incoming channels:
- lnworker_root_secret + remote_node_id + remote_funding_pubkey
- a check is added to avoid reusing the same key between channels:
not letting to user open more than one channel with the same peer in a single block
- only the first 16 bytes of the remote_node_id are used, as the onchain backup OP_RETURNs only contain that
- as the funding_privkey cannot be derived from the channel_seed anymore, it is included in the
imported channel backups, which in turn need a new version defined
- a wallet db upgrade is used to update already stored imported cbs
- alternatively we could keep the imported cbs as-is, so no new version, no new funding_privkey field, as it is clearly somewhat redundant given on-chain backups can reconstruct it
- however adding the field seems easier
- otherwise the existing code would try to derive the funding_privkey from the channel_seed
- also note: atm there is no field in the imported backups to distinguish anchor channels vs static-remotekey channels
375 lines
16 KiB
Python
375 lines
16 KiB
Python
# Copyright (C) 2018 The Electrum developers
|
|
# Distributed under the MIT software license, see the accompanying
|
|
# file LICENCE or http://www.opensource.org/licenses/mit-license.php
|
|
|
|
from typing import NamedTuple, Iterable, TYPE_CHECKING
|
|
import os
|
|
import copy
|
|
import asyncio
|
|
from enum import IntEnum, auto
|
|
from typing import NamedTuple, Dict
|
|
|
|
from . import util
|
|
from .wallet_db import WalletDB
|
|
from .util import bfh, log_exceptions, ignore_exceptions, TxMinedInfo, random_shuffled_copy
|
|
from .address_synchronizer import AddressSynchronizer, TX_HEIGHT_LOCAL, TX_HEIGHT_UNCONF_PARENT, TX_HEIGHT_UNCONFIRMED, TX_HEIGHT_FUTURE
|
|
from .transaction import Transaction, TxOutpoint, PartialTransaction
|
|
from .logging import Logger
|
|
|
|
|
|
if TYPE_CHECKING:
|
|
from .network import Network
|
|
from .lnsweep import SweepInfo
|
|
from .lnworker import LNWallet
|
|
|
|
class ListenerItem(NamedTuple):
|
|
# this is triggered when the lnwatcher is all done with the outpoint used as index in LNWatcher.tx_progress
|
|
all_done : asyncio.Event
|
|
# txs we broadcast are put on this queue so that the test can wait for them to get mined
|
|
tx_queue : asyncio.Queue
|
|
|
|
class TxMinedDepth(IntEnum):
|
|
""" IntEnum because we call min() in get_deepest_tx_mined_depth_for_txids """
|
|
DEEP = auto()
|
|
SHALLOW = auto()
|
|
MEMPOOL = auto()
|
|
FREE = auto()
|
|
|
|
|
|
|
|
|
|
from .util import EventListener, event_listener
|
|
|
|
class LNWatcher(Logger, EventListener):
|
|
|
|
LOGGING_SHORTCUT = 'W'
|
|
|
|
def __init__(self, adb: 'AddressSynchronizer', network: 'Network'):
|
|
|
|
Logger.__init__(self)
|
|
self.adb = adb
|
|
self.config = network.config
|
|
self.callbacks = {} # address -> lambda: coroutine
|
|
self.network = network
|
|
self.register_callbacks()
|
|
# status gets populated when we run
|
|
self.channel_status = {}
|
|
|
|
async def stop(self):
|
|
self.unregister_callbacks()
|
|
|
|
def get_channel_status(self, outpoint):
|
|
return self.channel_status.get(outpoint, 'unknown')
|
|
|
|
def add_channel(self, outpoint: str, address: str) -> None:
|
|
assert isinstance(outpoint, str)
|
|
assert isinstance(address, str)
|
|
cb = lambda: self.check_onchain_situation(address, outpoint)
|
|
self.add_callback(address, cb)
|
|
|
|
async def unwatch_channel(self, address, funding_outpoint):
|
|
self.logger.info(f'unwatching {funding_outpoint}')
|
|
self.remove_callback(address)
|
|
|
|
def remove_callback(self, address):
|
|
self.callbacks.pop(address, None)
|
|
|
|
def add_callback(self, address, callback):
|
|
self.adb.add_address(address)
|
|
self.callbacks[address] = callback
|
|
|
|
@event_listener
|
|
async def on_event_blockchain_updated(self, *args):
|
|
await self.trigger_callbacks()
|
|
|
|
@event_listener
|
|
async def on_event_adb_added_verified_tx(self, adb, tx_hash):
|
|
if adb != self.adb:
|
|
return
|
|
await self.trigger_callbacks()
|
|
|
|
@event_listener
|
|
async def on_event_adb_set_up_to_date(self, adb):
|
|
if adb != self.adb:
|
|
return
|
|
await self.trigger_callbacks()
|
|
|
|
@log_exceptions
|
|
async def trigger_callbacks(self):
|
|
if not self.adb.synchronizer:
|
|
self.logger.info("synchronizer not set yet")
|
|
return
|
|
for address, callback in list(self.callbacks.items()):
|
|
await callback()
|
|
|
|
async def check_onchain_situation(self, address, funding_outpoint):
|
|
# early return if address has not been added yet
|
|
if not self.adb.is_mine(address):
|
|
return
|
|
# inspect_tx_candidate might have added new addresses, in which case we return early
|
|
if not self.adb.is_up_to_date():
|
|
return
|
|
funding_txid = funding_outpoint.split(':')[0]
|
|
funding_height = self.adb.get_tx_height(funding_txid)
|
|
closing_txid = self.get_spender(funding_outpoint)
|
|
closing_height = self.adb.get_tx_height(closing_txid)
|
|
if closing_txid:
|
|
closing_tx = self.adb.get_transaction(closing_txid)
|
|
if closing_tx:
|
|
keep_watching = await self.sweep_commitment_transaction(funding_outpoint, closing_tx)
|
|
else:
|
|
self.logger.info(f"channel {funding_outpoint} closed by {closing_txid}. still waiting for tx itself...")
|
|
keep_watching = True
|
|
else:
|
|
keep_watching = True
|
|
await self.update_channel_state(
|
|
funding_outpoint=funding_outpoint,
|
|
funding_txid=funding_txid,
|
|
funding_height=funding_height,
|
|
closing_txid=closing_txid,
|
|
closing_height=closing_height,
|
|
keep_watching=keep_watching)
|
|
if not keep_watching:
|
|
await self.unwatch_channel(address, funding_outpoint)
|
|
|
|
async def sweep_commitment_transaction(self, funding_outpoint: str, closing_tx: Transaction) -> bool:
|
|
raise NotImplementedError() # implemented by subclasses
|
|
|
|
async def update_channel_state(self, *, funding_outpoint: str, funding_txid: str,
|
|
funding_height: TxMinedInfo, closing_txid: str,
|
|
closing_height: TxMinedInfo, keep_watching: bool) -> None:
|
|
raise NotImplementedError() # implemented by subclasses
|
|
|
|
|
|
def get_spender(self, outpoint) -> str:
|
|
"""
|
|
returns txid spending outpoint.
|
|
subscribes to addresses as a side effect.
|
|
"""
|
|
prev_txid, index = outpoint.split(':')
|
|
spender_txid = self.adb.db.get_spent_outpoint(prev_txid, int(index))
|
|
if not spender_txid:
|
|
return
|
|
spender_tx = self.adb.get_transaction(spender_txid)
|
|
for i, o in enumerate(spender_tx.outputs()):
|
|
if o.address is None:
|
|
continue
|
|
if not self.adb.is_mine(o.address):
|
|
self.adb.add_address(o.address)
|
|
return spender_txid
|
|
|
|
def get_tx_mined_depth(self, txid: str):
|
|
if not txid:
|
|
return TxMinedDepth.FREE
|
|
tx_mined_depth = self.adb.get_tx_height(txid)
|
|
height, conf = tx_mined_depth.height, tx_mined_depth.conf
|
|
if conf > 100:
|
|
return TxMinedDepth.DEEP
|
|
elif conf > 0:
|
|
return TxMinedDepth.SHALLOW
|
|
elif height in (TX_HEIGHT_UNCONFIRMED, TX_HEIGHT_UNCONF_PARENT):
|
|
return TxMinedDepth.MEMPOOL
|
|
elif height in (TX_HEIGHT_LOCAL, TX_HEIGHT_FUTURE):
|
|
return TxMinedDepth.FREE
|
|
elif height > 0 and conf == 0:
|
|
# unverified but claimed to be mined
|
|
return TxMinedDepth.MEMPOOL
|
|
else:
|
|
raise NotImplementedError()
|
|
|
|
def is_deeply_mined(self, txid):
|
|
return self.get_tx_mined_depth(txid) == TxMinedDepth.DEEP
|
|
|
|
|
|
|
|
|
|
class LNWalletWatcher(LNWatcher):
|
|
|
|
def __init__(self, lnworker: 'LNWallet', network: 'Network'):
|
|
self.network = network
|
|
self.lnworker = lnworker
|
|
LNWatcher.__init__(self, lnworker.wallet.adb, network)
|
|
|
|
@event_listener
|
|
async def on_event_blockchain_updated(self, *args):
|
|
# overload parent method with cache invalidation
|
|
# we invalidate the cache on each new block because
|
|
# some processes affect the list of sweep transactions
|
|
# (hold invoice preimage revealed, MPP completed, etc)
|
|
for chan in self.lnworker.channels.values():
|
|
chan._sweep_info.clear()
|
|
await self.trigger_callbacks()
|
|
|
|
def diagnostic_name(self):
|
|
return f"{self.lnworker.wallet.diagnostic_name()}-LNW"
|
|
|
|
@ignore_exceptions
|
|
@log_exceptions
|
|
async def update_channel_state(self, *, funding_outpoint: str, funding_txid: str,
|
|
funding_height: TxMinedInfo, closing_txid: str,
|
|
closing_height: TxMinedInfo, keep_watching: bool) -> None:
|
|
chan = self.lnworker.channel_by_txo(funding_outpoint)
|
|
if not chan:
|
|
return
|
|
chan.update_onchain_state(
|
|
funding_txid=funding_txid,
|
|
funding_height=funding_height,
|
|
closing_txid=closing_txid,
|
|
closing_height=closing_height,
|
|
keep_watching=keep_watching)
|
|
await self.lnworker.handle_onchain_state(chan)
|
|
|
|
@log_exceptions
|
|
async def sweep_commitment_transaction(self, funding_outpoint, closing_tx) -> bool:
|
|
"""This function is called when a channel was closed. In this case
|
|
we need to check for redeemable outputs of the commitment transaction
|
|
or spenders down the line (HTLC-timeout/success transactions).
|
|
|
|
Returns whether we should continue to monitor."""
|
|
chan = self.lnworker.channel_by_txo(funding_outpoint)
|
|
if not chan:
|
|
return False
|
|
chan_id_for_log = chan.get_id_for_log()
|
|
# detect who closed and get information about how to claim outputs
|
|
sweep_info_dict = chan.sweep_ctx(closing_tx)
|
|
self.logger.info(f"do_breach_remedy: {[x.name for x in sweep_info_dict.values()]}")
|
|
keep_watching = False if sweep_info_dict else not self.is_deeply_mined(closing_tx.txid())
|
|
|
|
# create and broadcast transactions
|
|
for prevout, sweep_info in sweep_info_dict.items():
|
|
prev_txid, prev_index = prevout.split(':')
|
|
name = sweep_info.name + ' ' + chan.get_id_for_log()
|
|
self.lnworker.wallet.set_default_label(prevout, name)
|
|
if not self.adb.get_transaction(prev_txid):
|
|
# do not keep watching if prevout does not exist
|
|
self.logger.info(f'prevout does not exist for {name}: {prev_txid}')
|
|
continue
|
|
spender_txid = self.get_spender(prevout)
|
|
spender_tx = self.adb.get_transaction(spender_txid) if spender_txid else None
|
|
if spender_tx:
|
|
# the spender might be the remote, revoked or not
|
|
htlc_sweepinfo = chan.maybe_sweep_htlcs(closing_tx, spender_tx)
|
|
for prevout2, htlc_sweep_info in htlc_sweepinfo.items():
|
|
htlc_tx_spender = self.get_spender(prevout2)
|
|
self.lnworker.wallet.set_default_label(prevout2, htlc_sweep_info.name)
|
|
if htlc_tx_spender:
|
|
keep_watching |= not self.is_deeply_mined(htlc_tx_spender)
|
|
else:
|
|
keep_watching = True
|
|
await self.maybe_redeem(prevout2, htlc_sweep_info, name)
|
|
else:
|
|
keep_watching |= not self.is_deeply_mined(spender_txid)
|
|
txin_idx = spender_tx.get_input_idx_that_spent_prevout(TxOutpoint.from_str(prevout))
|
|
assert txin_idx is not None
|
|
spender_txin = spender_tx.inputs()[txin_idx]
|
|
chan.extract_preimage_from_htlc_txin(spender_txin)
|
|
else:
|
|
keep_watching = True
|
|
# broadcast or maybe update our own tx
|
|
await self.maybe_redeem(prevout, sweep_info, name)
|
|
|
|
return keep_watching
|
|
|
|
def get_redeem_tx(self, prevout: str, sweep_info: 'SweepInfo', name: str):
|
|
# check if redeem tx needs to be updated
|
|
# if it is in the mempool, we need to check fee rise
|
|
txid = self.get_spender(prevout)
|
|
old_tx = self.adb.get_transaction(txid)
|
|
assert old_tx is not None or txid is None
|
|
tx_depth = self.get_tx_mined_depth(txid) if txid else None
|
|
if txid and tx_depth not in [TxMinedDepth.FREE, TxMinedDepth.MEMPOOL]:
|
|
assert old_tx is not None
|
|
return old_tx, None
|
|
# fixme: deepcopy is needed because tx.serialize() is destructive
|
|
inputs = [copy.deepcopy(sweep_info.txin)]
|
|
outputs = [sweep_info.txout] if sweep_info.txout else []
|
|
if sweep_info.name == 'first-stage-htlc':
|
|
new_tx = PartialTransaction.from_io(inputs, outputs, locktime=sweep_info.cltv_abs, version=2)
|
|
self.lnworker.wallet.sign_transaction(new_tx, password=None, ignore_warnings=True)
|
|
else:
|
|
# password is needed for 1st stage htlc tx with anchors because we add inputs
|
|
password = self.lnworker.wallet.get_unlocked_password()
|
|
new_tx = self.lnworker.wallet.create_transaction(
|
|
inputs = inputs,
|
|
outputs = outputs,
|
|
password = password,
|
|
locktime = sweep_info.cltv_abs,
|
|
BIP69_sort=False,
|
|
)
|
|
if new_tx is None:
|
|
self.logger.info(f'{name} could not claim output: {prevout}, dust')
|
|
assert old_tx is not None
|
|
return old_tx, None
|
|
if txid is None:
|
|
return None, new_tx
|
|
elif tx_depth == TxMinedDepth.MEMPOOL:
|
|
delta = new_tx.get_fee() - self.adb.get_tx_fee(txid)
|
|
if delta > 1:
|
|
self.logger.info(f'increasing fee of mempool tx {name}: {prevout}')
|
|
return old_tx, new_tx
|
|
else:
|
|
assert old_tx is not None
|
|
return old_tx, None
|
|
elif tx_depth == TxMinedDepth.FREE:
|
|
# return new tx, even if it is equal to old_tx,
|
|
# because we need to test if it can be broadcast
|
|
return old_tx, new_tx
|
|
else:
|
|
assert old_tx is not None
|
|
return old_tx, None
|
|
|
|
async def maybe_redeem(self, prevout, sweep_info: 'SweepInfo', name: str) -> None:
|
|
old_tx, new_tx = self.get_redeem_tx(prevout, sweep_info, name)
|
|
if new_tx is None:
|
|
return
|
|
prev_txid, prev_index = prevout.split(':')
|
|
can_broadcast = True
|
|
local_height = self.network.get_local_height()
|
|
if sweep_info.cltv_abs:
|
|
wanted_height = sweep_info.cltv_abs
|
|
if wanted_height - local_height > 0:
|
|
can_broadcast = False
|
|
# self.logger.debug(f"pending redeem for {prevout}. waiting for {name}: CLTV ({local_height=}, {wanted_height=})")
|
|
if sweep_info.csv_delay:
|
|
prev_height = self.adb.get_tx_height(prev_txid)
|
|
if prev_height.height > 0:
|
|
wanted_height = prev_height.height + sweep_info.csv_delay - 1
|
|
else:
|
|
wanted_height = local_height + sweep_info.csv_delay
|
|
if wanted_height - local_height > 0:
|
|
can_broadcast = False
|
|
# self.logger.debug(
|
|
# f"pending redeem for {prevout}. waiting for {name}: CSV "
|
|
# f"({local_height=}, {wanted_height=}, {prev_height.height=}, {sweep_info.csv_delay=})")
|
|
if not (sweep_info.cltv_abs or sweep_info.csv_delay):
|
|
# used to control settling of htlcs onchain for testing purposes
|
|
# careful, this prevents revocation as well
|
|
if not self.lnworker.enable_htlc_settle_onchain:
|
|
return
|
|
if can_broadcast:
|
|
self.logger.info(f'we can broadcast: {name}')
|
|
if await self.network.try_broadcasting(new_tx, name):
|
|
tx_was_added = self.adb.add_transaction(new_tx, is_new=(old_tx is None))
|
|
else:
|
|
tx_was_added = False
|
|
else:
|
|
# we may have a tx with a different fee, in which case it will be replaced
|
|
if not old_tx or (old_tx and old_tx.txid() != new_tx.txid()):
|
|
try:
|
|
tx_was_added = self.adb.add_transaction(new_tx, is_new=(old_tx is None))
|
|
except Exception as e:
|
|
self.logger.info(f'could not add future tx: {name}. prevout: {prevout} {str(e)}')
|
|
tx_was_added = False
|
|
if tx_was_added:
|
|
self.logger.info(f'added redeem tx: {name}. prevout: {prevout}')
|
|
else:
|
|
tx_was_added = False
|
|
# set future tx regardless of tx_was_added, because it is not persisted
|
|
# (and wanted_height can change if input of CSV was not mined before)
|
|
self.adb.set_future_tx(new_tx.txid(), wanted_height=wanted_height)
|
|
if tx_was_added:
|
|
self.lnworker.wallet.set_label(new_tx.txid(), name)
|
|
if old_tx and old_tx.txid() != new_tx.txid():
|
|
self.lnworker.wallet.set_label(old_tx.txid(), None)
|
|
util.trigger_callback('wallet_updated', self.lnworker.wallet)
|