This is a really cool idea! I have often wondered how easy it is to identify which node is the original broadcaster of a specific transaction, especially in the case of a clearnet node. It seems like it would be a pretty bad thing if someone could tie a transaction to an IP address.

But now it looks like we have a nice defensive measure (and we will hopefully get it in one of the upcoming Core releases):

To improve privacy, broadcast locally submitted transactions (from the sendrawtransaction RPC) to the P2P network only via Tor or I2P short-lived connections, or to IPv4/IPv6 peers but through the Tor network.

• Introduce a new connection type for private broadcast of transactions with the following properties:
  • started whenever there are local transactions to be sent
  • opened to Tor or I2P peers or IPv4/IPv6 via the Tor proxy
  • opened regardless of max connections limits
  • after handshake is completed one local transaction is pushed to the peer, PING is sent and after receiving PONG the connection is closed
  • ignore all incoming messages after handshake is completed (except PONG)
  • Broadcast transactions submitted via sendrawtransaction using this new mechanism, to a few peers. Keep doing this until we receive back this transaction from one of our ordinary peers (this takes about 1 second on mainnet).
• The transaction is stored in peerman and does not enter the mempool.
• Once we get an INV from one of our ordinary peers, then the normal flow executes: we request the transaction with GETDATA, receive it with a TX message, put it in our mempool and broadcast it to all our existent connections (as if we see it for the first time).
• After we receive the full transaction as a TX message, in reply to our GETDATA request, only then consider the transaction has propagated through the network and remove it from the storage in peerman, ending the private broadcast attempts.

Basically, instead of just putting the transaction you want to broadcast into your own mempool and spreading them from there, this lets your node spin up a temporary tor connection (or I2P) and give the transaction to some other node so that the first time it shows up in a mempool it won't be yours. Then when you learn about your own transaction from someone else, you can treat like any other transaction you see.

Very cool!

h/t to Jon Atak (One of the BIP repository maintainers) for highlighting this on X.