fix output index, lnwatcher

Author: ecdsa

electrum/lnsweep.py

@@ -319,14 +319,14 @@ def sweep_our_ctx(
         found_to_remote = False
     if not found_to_local and not found_to_remote:
         return {}
-    chan.logger.debug(f'(lnsweep) found our ctx: {to_local_address} {to_remote_address}')
+    #chan.logger.debug(f'(lnsweep) found our ctx: {to_local_address} {to_remote_address}')
     # other outputs are htlcs
     # if they are spent, we need to generate the script
     # so, second-stage htlc sweep should not be returned here
     txs = {}  # type: Dict[str, SweepInfo]
     # to_local
     output_idxs = ctx.get_output_idxs_from_address(to_local_address)
-    if output_idxs:
+    if known_htlc_tx is None and output_idxs:
         output_idx = output_idxs.pop()
         txin = sweep_ctx_to_local(
             ctx=ctx,
@@ -377,19 +377,20 @@ def txs_htlc(
         else:
             # second-stage
             address = bitcoin.script_to_p2wsh(htlctx_witness_script)
-            output_idx = htlc_tx.get_output_idxs_from_address(address).pop()
-            sweep_txin = sweep_htlctx_output(
-                to_self_delay=to_self_delay,
-                htlc_tx=known_htlc_tx,
-                output_idx=output_idx,
-                htlctx_witness_script=htlctx_witness_script,
-                privkey=our_localdelayed_privkey.get_secret_bytes(),
-                is_revocation=False,
-                config=chan.lnworker.config)
-            txs[known_htlc_tx.txid() + f':{output_idx}'] = SweepInfo(
-                name='second-stage-htlc',
-                csv_delay=to_self_delay,
-                cltv_abs=0,
+            output_idxs = known_htlc_tx.get_output_idxs_from_address(address)
+            for output_idx in output_idxs:
+                sweep_txin = sweep_htlctx_output(
+                    to_self_delay=to_self_delay,
+                    htlc_tx=known_htlc_tx,
+                    output_idx=output_idx,
+                    htlctx_witness_script=htlctx_witness_script,
+                    privkey=our_localdelayed_privkey.get_secret_bytes(),
+                    is_revocation=False,
+                    config=chan.lnworker.config)
+                txs[known_htlc_tx.txid() + f':{output_idx}'] = SweepInfo(
+                    name='second-stage-htlc',
+                    csv_delay=to_self_delay,
+                    cltv_abs=0,
                 txin=sweep_txin)
 
     # offered HTLCs, in our ctx --> "timeout"

electrum/lnwatcher.py

@@ -464,13 +464,13 @@ async def sweep_commitment_transaction(self, funding_outpoint, closing_tx, spend
             if spender_tx:
                 # the spender might be the remote, revoked or not
                 htlc_sweepinfo = chan.maybe_sweep_htlcs(closing_tx, spender_tx)
-                for prevout, htlc_sweep_info in htlc_sweepinfo.items():
-                    htlc_tx_spender = spenders.get(prevout)
+                for prevout2, htlc_sweep_info in htlc_sweepinfo.items():
+                    htlc_tx_spender = spenders.get(prevout2)
                     if htlc_tx_spender:
                         keep_watching |= not self.is_deeply_mined(htlc_tx_spender)
                     else:
                         keep_watching = True
-                        await self.maybe_redeem(spenders, prevout, htlc_sweep_info, name)
+                        await self.maybe_redeem(spenders, prevout2, htlc_sweep_info, name)
                 # extract preimage
                 keep_watching |= not self.is_deeply_mined(spender_txid)
                 txin_idx = spender_tx.get_input_idx_that_spent_prevout(TxOutpoint.from_str(prevout))
@@ -484,44 +484,12 @@ async def sweep_commitment_transaction(self, funding_outpoint, closing_tx, spend
 
         return keep_watching
 
-    def get_redeem_tx(self, spenders, 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 = spenders.get(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
-        new_tx = sweep_info.gen_tx()
-        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, spenders, prevout, sweep_info: 'SweepInfo', name: str) -> None:
-        #old_tx, new_tx = self.get_redeem_tx(spenders, prevout, sweep_info, name)
-        #if new_tx is None:
-        #    return
-        prev_txid, prev_index = prevout.split(':')
+        # early return if it is spent. rbf is handled by the wallet
+        prev_txid, index = prevout.split(':')
+        if self.adb.db.get_spent_outpoint(prev_txid, int(index)):
+            return
         can_broadcast = True
         local_height = self.network.get_local_height()
         if sweep_info.cltv_abs:
@@ -546,7 +514,7 @@ async def maybe_redeem(self, spenders, prevout, sweep_info: 'SweepInfo', name: s
             if not self.lnworker.enable_htlc_settle_onchain:
                 return
         if can_broadcast:
-            self.logger.info(f'we can broadcast: {name}')
+            self.logger.info(f'we can broadcast: {sweep_info.name}')
             if sweep_info.name == 'first-stage-htlc':
                 tx = sweep_info.txin
                 txin = tx.inputs()[0]

tests/regtest/regtest.sh

@@ -250,6 +250,8 @@ if [[ $1 == "swapserver_forceclose" ]]; then
     new_blocks 1
     wait_until_spent $funding_txid 0 # alice reveals preimage
     new_blocks 1
+    sleep 2
+    new_blocks 144
     wait_for_balance bob 0.999
 fi