Make use of txospender mandatory, remove block scanning code

sstone · sstone · commit cd31b1480266 · 2026-05-07T13:59:00.000+02:00
On startup, eclair will check that both txindex and txospenderindex are enabled and synced, and will stop if they're not.
Block scanning code used to find spending transactions is removed, we just use the txospenderindex now.
diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/Setup.scala b/eclair-core/src/main/scala/fr/acinq/eclair/Setup.scala
@@ -292,6 +292,9 @@ class Setup(val datadir: File,
         }
       }
       _ = if (bitcoinClient.useEclairSigner) logger.info("using eclair to sign bitcoin core transactions")
+      indexInfos <- bitcoinClient.getIndexInfo()
+      _ = if (!indexInfos.get("txindex").exists(_.synced)) throw new RuntimeException("txindex is disabled or not synchronized")
+      _ = if (!indexInfos.get("txospenderindex").exists(_.synced)) throw new RuntimeException("txospenderindex is disabled or not synchronized")
       // We use the default address type configured on the Bitcoin Core node.
       initialPubkeyScript <- bitcoinClient.getReceivePublicKeyScript(addressType_opt = None)
       _ = finalPubkeyScript.set(initialPubkeyScript)
diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/bitcoind/ZmqWatcher.scala b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/bitcoind/ZmqWatcher.scala
@@ -429,7 +429,6 @@ private class ZmqWatcher(nodeParams: NodeParams, blockHeight: AtomicLong, client
     }
   }
 
-  private def canUseTxoSpenderIndex: Future[Boolean] = client.getIndexInfo().map(_.get("txospenderindex").exists(_.synced))
 
   private def checkSpent(w: WatchSpent[_ <: WatchSpentTriggered]): Future[Unit] = {
     // First let's see if the parent tx was published or not before checking whether it has been spent.
@@ -447,8 +446,7 @@ private class ZmqWatcher(nodeParams: NodeParams, blockHeight: AtomicLong, client
         case _ =>
           // The parent tx was published, we need to make sure this particular output has not been spent.
           client.isTransactionOutputSpendable(w.outPoint, includeMempool = true).collect {
-            case false => canUseTxoSpenderIndex.foreach {
-              case true =>
+            case false =>
                 // The output has been spent, let's find the spending tx in the txospenderindex.
                 log.info("{} has already been spent, looking for the spending tx", w.outPoint)
                 client.findSpendingTx(w.outPoint) map {
@@ -461,42 +459,10 @@ private class ZmqWatcher(nodeParams: NodeParams, blockHeight: AtomicLong, client
                   case error =>
                     log.warn("error finding the spending tx of {}, funds are at risk", w.outPoint, error)
                 }
-              case false =>
-                // txospenderindex is not available, scan the mempool and the blockchain
-                // If we know some potential spending txs, we try to fetch them directly.
-                Future.sequence(w.hints.map(txid => client.getTransaction(txid).map(Some(_)).recover { case _ => None }))
-                  .map(_.flatten) // filter out errors and hint transactions that can't be found
-                  .map(hintTxs => {
-                    hintTxs.find(tx => tx.txIn.exists(i => i.outPoint.txid == w.txId && i.outPoint.index == w.outputIndex)) match {
-                      case Some(spendingTx) =>
-                        log.info("{}:{} has already been spent by a tx provided in hints: txid={}", w.txId, w.outputIndex, spendingTx.txid)
-                        context.self ! ProcessNewTransaction(spendingTx)
-                      case None =>
-                        // The hints didn't help us, let's search for the spending transaction in the mempool.
-                        log.info("{}:{} has already been spent, looking for the spending tx in the mempool", w.txId, w.outputIndex)
-                        client.lookForMempoolSpendingTx(w.outPoint).map(Some(_)).recover { case _ => None }.map {
-                          case Some(spendingTx) =>
-                            log.info("found tx spending {}:{} in the mempool: txid={}", w.txId, w.outputIndex, spendingTx.txid)
-                            context.self ! ProcessNewTransaction(spendingTx)
-                          case None =>
-                            // The spending transaction isn't in the mempool, so it must be a transaction that confirmed
-                            // before we set the watch. We have to scan the blockchain to find it, which is expensive
-                            // since bitcoind doesn't provide indexes for this scenario.
-                            log.warn("{}:{} has already been spent, spending tx not in the mempool, looking in the blockchain...", w.txId, w.outputIndex)
-                            client.lookForSpendingTx(None, w.outPoint, nodeParams.channelConf.maxChannelSpentRescanBlocks).map { spendingTx =>
-                              log.warn("found the spending tx of {}:{} in the blockchain: txid={}", w.txId, w.outputIndex, spendingTx.txid)
-                              context.self ! ProcessNewTransaction(spendingTx)
-                            }.recover {
-                              case _ => log.warn("could not find the spending tx of {}:{} in the blockchain, funds are at risk", w.txId, w.outputIndex)
-                            }
-                        }
-                    }
-                  })
             }
           }
       }
     }
-  }
 
   private def checkPublished(w: WatchPublished): Future[Unit] = {
     log.debug("checking publication of txid={}", w.txId)
diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/bitcoind/rpc/BitcoinCoreClient.scala b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/bitcoind/rpc/BitcoinCoreClient.scala
@@ -199,32 +199,6 @@ class BitcoinCoreClient(val rpcClient: BitcoinJsonRPCClient, val lockUtxos: Bool
     }
   }
 
-  /**
-   * Iterate over blocks to find the transaction that has spent a given output.
-   * It isn't useful to look at the whole blockchain history: if the transaction was confirmed long ago, an attacker
-   * will have already claimed all possible outputs and there's nothing we can do about it.
-   *
-   * @param blockHash_opt hash of a block *after* the output has been spent. If not provided, we will use the blockchain tip.
-   * @param outPoint      transaction output that has been spent.
-   * @param limit         maximum number of previous blocks to scan.
-   * @return the transaction spending the given output.
-   */
-  def lookForSpendingTx(blockHash_opt: Option[BlockHash], outPoint: OutPoint, limit: Int)(implicit ec: ExecutionContext): Future[Transaction] = {
-    for {
-      blockId <- blockHash_opt match {
-        case Some(blockHash) => Future.successful(BlockId(blockHash))
-        // NB: bitcoind confusingly returns the blockId instead of the blockHash.
-        case None => rpcClient.invoke("getbestblockhash").collect { case JString(blockId) => BlockId(ByteVector32.fromValidHex(blockId)) }
-      }
-      block <- getBlock(blockId)
-      res <- block.tx.asScala.find(tx => tx.txIn.asScala.exists(i => i.outPoint == KotlinUtils.scala2kmp(outPoint))) match {
-        case Some(tx) => Future.successful(KotlinUtils.kmp2scala(tx))
-        case None if limit > 0 => lookForSpendingTx(Some(KotlinUtils.kmp2scala(block.header.hashPreviousBlock)), outPoint, limit - 1)
-        case None => Future.failed(new RuntimeException(s"couldn't find tx spending $outPoint in the blockchain"))
-      }
-    } yield res
-  }
-
   def listTransactions(count: Int, skip: Int)(implicit ec: ExecutionContext): Future[List[WalletTx]] = rpcClient.invoke("listtransactions", "*", count, skip).map {
     case JArray(txs) => txs.map(tx => {
       val JString(address) = tx \ "address"
diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/bitcoind/BitcoinCoreClientSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/bitcoind/BitcoinCoreClientSpec.scala
@@ -1745,6 +1745,8 @@ class BitcoinCoreClientSpec extends TestKitBaseClass with BitcoindService with A
     generateBlocks(1)
     bitcoinClient.getBlockHeight().pipeTo(sender.ref)
     val blockHeight1 = sender.expectMsgType[BlockHeight]
+    bitcoinClient.getBlockId(blockHeight1.toInt).pipeTo(sender.ref)
+    val blockId = sender.expectMsgType[BlockId]
     assert(blockHeight1 == blockHeight + 1)
     bitcoinClient.getTxConfirmations(tx1.txid).pipeTo(sender.ref)
     sender.expectMsg(Some(1))
@@ -1756,10 +1758,8 @@ class BitcoinCoreClientSpec extends TestKitBaseClass with BitcoindService with A
     generateBlocks(10)
     bitcoinClient.lookForMempoolSpendingTx(tx1.txIn.head.outPoint).pipeTo(sender.ref)
     sender.expectMsgType[Failure]
-    bitcoinClient.lookForSpendingTx(None, tx1.txIn.head.outPoint, limit = 5).pipeTo(sender.ref)
-    sender.expectMsgType[Failure]
-    bitcoinClient.lookForSpendingTx(None, tx1.txIn.head.outPoint, limit = 15).pipeTo(sender.ref)
-    sender.expectMsg(tx1)
+    bitcoinClient.findSpendingTx(tx1.txIn.head.outPoint).pipeTo(sender.ref)
+    sender.expectMsg(Some(tx1, Some(blockId)))
   }
 
   test("get index information") {
diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/bitcoind/ZmqWatcherSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/bitcoind/ZmqWatcherSpec.scala
@@ -72,7 +72,7 @@ class ZmqWatcherSpec extends TestKitBaseClass with AnyFunSuiteLike with Bitcoind
   case class Fixture(blockHeight: AtomicLong, bitcoinClient: BitcoinCoreClient, watcher: typed.ActorRef[ZmqWatcher.Command], probe: TestProbe, listener: TestProbe)
 
   // NB: we can't use ScalaTest's fixtures, they would see uninitialized bitcoind fields because they sandbox each test.
-  private def withWatcher(testFun: Fixture => Any, scanPastBlock: Boolean = false, useTxoSpenderIndex: Boolean = false): Unit = {
+  private def withWatcher(testFun: Fixture => Any, scanPastBlock: Boolean = false): Unit = {
     val blockCount = new AtomicLong()
     val probe = TestProbe()
     val listener = TestProbe()
@@ -85,7 +85,6 @@ class ZmqWatcherSpec extends TestKitBaseClass with AnyFunSuiteLike with Bitcoind
       // We enable it and use a faster (randomized) delay when requested.
       .modify(_.channelConf.scanPreviousBlocksDepth).setToIf(scanPastBlock)(6)
       .modify(_.channelConf.maxBlockProcessingDelay).setToIf(scanPastBlock)(10 millis)
-    //.modify(_.channelConf.useTxoSpenderIndex).setTo(useTxoSpenderIndex)
     val watcher = system.spawn(ZmqWatcher(nodeParams, blockCount, bitcoinClient), UUID.randomUUID().toString)
     try {
       testFun(Fixture(blockCount, bitcoinClient, watcher, probe, listener))
@@ -246,86 +245,80 @@ class ZmqWatcherSpec extends TestKitBaseClass with AnyFunSuiteLike with Bitcoind
     })
   }
 
-  def watchForSpentTransactions(f: Fixture): Unit = {
-    import f._
-
-    val (priv, address) = createExternalAddress()
-    val tx = sendToAddress(address, Btc(1), probe)
-    val outputIndex = tx.txOut.indexWhere(_.publicKeyScript == Script.write(Script.pay2wpkh(priv.publicKey)))
-    val (tx1, tx2) = createUnspentTxChain(tx, priv)
-
-    watcher ! WatchExternalChannelSpent(probe.ref, tx.txid, outputIndex, RealShortChannelId(5))
-    watcher ! WatchFundingSpent(probe.ref, tx.txid, outputIndex, Set.empty)
-    probe.expectNoMessage(100 millis)
-
-    watcher ! ListWatches(probe.ref)
-    assert(probe.expectMsgType[Set[Watch[_]]].size == 2)
-
-    bitcoinClient.publishTransaction(tx1)
-    // tx and tx1 aren't confirmed yet, but we trigger the WatchSpentTriggered event when we see tx1 in the mempool.
-    probe.expectMsgAllOf(
-      WatchExternalChannelSpentTriggered(RealShortChannelId(5), Some(tx1)),
-      WatchFundingSpentTriggered(tx1)
-    )
-    // Let's confirm tx and tx1: seeing tx1 in a block should trigger both WatchSpentTriggered events again.
-    bitcoinClient.getBlockHeight().pipeTo(probe.ref)
-    val initialBlockHeight = probe.expectMsgType[BlockHeight]
-    generateBlocks(1)
-    probe.expectMsgAllOf(
-      WatchExternalChannelSpentTriggered(RealShortChannelId(5), Some(tx1)),
-      WatchFundingSpentTriggered(tx1)
-    )
-    probe.expectNoMessage(100 millis)
-
-    watcher ! ListWatches(probe.ref)
-    val watches1 = probe.expectMsgType[Set[Watch[_]]]
-    assert(watches1.size == 2)
-    assert(watches1.forall(_.isInstanceOf[WatchSpent[_]]))
-
-    // Let's submit tx2, and set a watch after it has been confirmed this time.
-    bitcoinClient.publishTransaction(tx2)
-    probe.expectNoMessage(100 millis)
-
-    system.eventStream.subscribe(probe.ref, classOf[CurrentBlockHeight])
-    generateBlocks(1)
-    awaitCond(probe.expectMsgType[CurrentBlockHeight].blockHeight >= initialBlockHeight + 2)
-
-    watcher ! ListWatches(probe.ref)
-    val watches2 = probe.expectMsgType[Set[Watch[_]]]
-    assert(watches2.size == 2)
-    assert(watches2.forall(_.isInstanceOf[WatchSpent[_]]))
-    watcher ! StopWatching(probe.ref)
-
-    // We use hints and see if we can find tx2
-    watcher ! WatchFundingSpent(probe.ref, tx1.txid, 0, Set(tx2.txid))
-    probe.expectMsg(WatchFundingSpentTriggered(tx2))
-    watcher ! StopWatching(probe.ref)
-
-    // We should still find tx2 if the provided hint is wrong
-    watcher ! WatchOutputSpent(probe.ref, tx1.txid, 0, tx1.txOut(0).amount, Set(randomTxId()))
-    probe.fishForMessage() { case m: WatchOutputSpentTriggered => m.spendingTx.txid == tx2.txid }
-    watcher ! StopWatching(probe.ref)
-
-    // We should find txs that have already been confirmed
-    watcher ! WatchOutputSpent(probe.ref, tx.txid, outputIndex, tx.txOut(outputIndex).amount, Set.empty)
-    probe.fishForMessage() { case m: WatchOutputSpentTriggered => m.spendingTx.txid == tx1.txid }
-    watcher ! StopWatching(probe.ref)
-
-    // If we watch after being spent by a confirmed transaction, we immediately trigger the watch without fetching
-    // the spending transaction.
-    watcher ! WatchExternalChannelSpent(probe.ref, tx1.txid, 0, RealShortChannelId(1))
-    probe.expectMsg(WatchExternalChannelSpentTriggered(RealShortChannelId(1), None))
-    watcher ! StopWatching(probe.ref)
-    watcher ! WatchFundingSpent(probe.ref, tx1.txid, 0, Set.empty)
-    probe.expectMsg(WatchFundingSpentTriggered(tx2))
-  }
-
   test("watch for spent transactions") {
-    withWatcher(f => watchForSpentTransactions(f))
-  }
+    withWatcher(f => {
+      import f._
+
+      val (priv, address) = createExternalAddress()
+      val tx = sendToAddress(address, Btc(1), probe)
+      val outputIndex = tx.txOut.indexWhere(_.publicKeyScript == Script.write(Script.pay2wpkh(priv.publicKey)))
+      val (tx1, tx2) = createUnspentTxChain(tx, priv)
+
+      watcher ! WatchExternalChannelSpent(probe.ref, tx.txid, outputIndex, RealShortChannelId(5))
+      watcher ! WatchFundingSpent(probe.ref, tx.txid, outputIndex, Set.empty)
+      probe.expectNoMessage(100 millis)
+
+      watcher ! ListWatches(probe.ref)
+      assert(probe.expectMsgType[Set[Watch[_]]].size == 2)
+
+      bitcoinClient.publishTransaction(tx1)
+      // tx and tx1 aren't confirmed yet, but we trigger the WatchSpentTriggered event when we see tx1 in the mempool.
+      probe.expectMsgAllOf(
+        WatchExternalChannelSpentTriggered(RealShortChannelId(5), Some(tx1)),
+        WatchFundingSpentTriggered(tx1)
+      )
+      // Let's confirm tx and tx1: seeing tx1 in a block should trigger both WatchSpentTriggered events again.
+      bitcoinClient.getBlockHeight().pipeTo(probe.ref)
+      val initialBlockHeight = probe.expectMsgType[BlockHeight]
+      generateBlocks(1)
+      probe.expectMsgAllOf(
+        WatchExternalChannelSpentTriggered(RealShortChannelId(5), Some(tx1)),
+        WatchFundingSpentTriggered(tx1)
+      )
+      probe.expectNoMessage(100 millis)
 
-  test("watch for spent transactions with txospenderindex") {
-    withWatcher(f => watchForSpentTransactions(f), useTxoSpenderIndex = true)
+      watcher ! ListWatches(probe.ref)
+      val watches1 = probe.expectMsgType[Set[Watch[_]]]
+      assert(watches1.size == 2)
+      assert(watches1.forall(_.isInstanceOf[WatchSpent[_]]))
+
+      // Let's submit tx2, and set a watch after it has been confirmed this time.
+      bitcoinClient.publishTransaction(tx2)
+      probe.expectNoMessage(100 millis)
+
+      system.eventStream.subscribe(probe.ref, classOf[CurrentBlockHeight])
+      generateBlocks(1)
+      awaitCond(probe.expectMsgType[CurrentBlockHeight].blockHeight >= initialBlockHeight + 2)
+
+      watcher ! ListWatches(probe.ref)
+      val watches2 = probe.expectMsgType[Set[Watch[_]]]
+      assert(watches2.size == 2)
+      assert(watches2.forall(_.isInstanceOf[WatchSpent[_]]))
+      watcher ! StopWatching(probe.ref)
+
+      // We use hints and see if we can find tx2
+      watcher ! WatchFundingSpent(probe.ref, tx1.txid, 0, Set(tx2.txid))
+      probe.expectMsg(WatchFundingSpentTriggered(tx2))
+      watcher ! StopWatching(probe.ref)
+
+      // We should still find tx2 if the provided hint is wrong
+      watcher ! WatchOutputSpent(probe.ref, tx1.txid, 0, tx1.txOut(0).amount, Set(randomTxId()))
+      probe.fishForMessage() { case m: WatchOutputSpentTriggered => m.spendingTx.txid == tx2.txid }
+      watcher ! StopWatching(probe.ref)
+
+      // We should find txs that have already been confirmed
+      watcher ! WatchOutputSpent(probe.ref, tx.txid, outputIndex, tx.txOut(outputIndex).amount, Set.empty)
+      probe.fishForMessage() { case m: WatchOutputSpentTriggered => m.spendingTx.txid == tx1.txid }
+      watcher ! StopWatching(probe.ref)
+
+      // If we watch after being spent by a confirmed transaction, we immediately trigger the watch without fetching
+      // the spending transaction.
+      watcher ! WatchExternalChannelSpent(probe.ref, tx1.txid, 0, RealShortChannelId(1))
+      probe.expectMsg(WatchExternalChannelSpentTriggered(RealShortChannelId(1), None))
+      watcher ! StopWatching(probe.ref)
+      watcher ! WatchFundingSpent(probe.ref, tx1.txid, 0, Set.empty)
+      probe.expectMsg(WatchFundingSpentTriggered(tx2))
+    })
   }
 
   test("unwatch external channel") {

Original file line number	Diff line number	Diff line change
`@@ -292,6 +292,9 @@ class Setup(val datadir: File,`
`292`	`292`	`}`
`293`	`293`	`}`
`294`	`294`	`_ = if (bitcoinClient.useEclairSigner) logger.info("using eclair to sign bitcoin core transactions")`
	`295`	`+ indexInfos <- bitcoinClient.getIndexInfo()`
	`296`	`+ _ = if (!indexInfos.get("txindex").exists(_.synced)) throw new RuntimeException("txindex is disabled or not synchronized")`
	`297`	`+ _ = if (!indexInfos.get("txospenderindex").exists(_.synced)) throw new RuntimeException("txospenderindex is disabled or not synchronized")`
`295`	`298`	`// We use the default address type configured on the Bitcoin Core node.`
`296`	`299`	`initialPubkeyScript <- bitcoinClient.getReceivePublicKeyScript(addressType_opt = None)`
`297`	`300`	`_ = finalPubkeyScript.set(initialPubkeyScript)`