Use akka-typed for the ZmqWatcher actor.
It is probably best reviewed commit by commit.

• the first commit just moves to akka-typed with minimal changes
• the second commit adds tests (in particular for the subtle case of confirmed txs never seen in mempool).
• the third commit adds type constraints on the BitcoinEvent (even though they're actually dropped at runtime because of type erasure, but since the compiler enforces it it's enough). Note that this introduces compiler warnings in ZmqWatcher.scala that I don't know how to get rid of.

I tried to go even further and also constrain the replyTo for each Watch, something like:

  sealed trait WatchEvent[E <: BitcoinEvent] {
    def event: E
  }
  sealed trait Watch[E <: BitcoinEvent, R <: WatchEvent[E]] extends Command {
    def replyTo: ActorRef[R]
    def event: E
  }
  final case class WatchConfirmed[E <: BitcoinEvent](replyTo: ActorRef[WatchEventConfirmed[E]], txId: ByteVector32, minDepth: Long, event: E) extends Watch[E, WatchEventConfirmed[E]]
  final case class WatchEventConfirmed[E <: BitcoinEvent](event: E, blockHeight: Int, txIndex: Int, tx: Transaction) extends WatchEvent[E]

This would let us remove the unsafeUpcast in TxPublisher, but I lost to the compiler on that one...
Another reason I gave up this approach is that these type constraints aren't really enforced, they're basically hidden .asInstanceOf[E] that will only throw at runtime if we guessed wrong, but not at compile-time, so it may not be worth going in that direction...

This is why in the last commits I instead flattened the hierarchy to get rid of generic types as much as possible, which provides much better type safety.

EDIT: these caveats have eventually all been resolved in the last commits. We're now in a good state where we make the most of strong typing without bumping into type erasure!