Inside Bitcoin

251        self.log.info(f"Created txid={txs[1]['txid']}: for broadcast with dependency in mempool + rebroadcast")
252        self.log.info(f"Created txid={txs[2]['txid']}: for broadcast with dependency not in mempool")
253        tx_originator.sendrawtransaction(hexstring=txs[0]["hex"], maxfeerate=0.1)
254
255        self.log.info("First private broadcast: waiting for the transaction to reach the recipient")
256        self.wait_until(lambda: len(tx_receiver.getrawmempool()) > 0)
257        self.log.info("First private broadcast: the recipient received the transaction")
258        far_observer.wait_for_tx(txs[0]["txid"])
259        self.log.info("First private broadcast: the recipient further relayed the transaction")
260
261        # One already checked above, check the other NUM_PRIVATE_BROADCAST_PER_TX - 1 broadcasts.
262        self.check_broadcasts("Basic", txs[0], NUM_PRIVATE_BROADCAST_PER_TX - 1, 0)
263
264        self.log.info("Resending the same transaction via RPC again (it is not in the mempool yet)")
265        ignoring_msg = f"Ignoring unnecessary request to schedule an already scheduled transaction: txid={txs[0]['txid']}, wtxid={txs[0]['wtxid']}"
266        with tx_originator.busy_wait_for_debug_log(expected_msgs=[ignoring_msg.encode()]):
267            tx_originator.sendrawtransaction(hexstring=txs[0]["hex"], maxfeerate=0)
268
269        self.log.info("Sending a malleated transaction with an invalid witness via RPC")
270        malleated_invalid = malleate_tx_to_invalid_witness(txs[0])
271        assert_raises_rpc_error(-26, "mempool-script-verify-flag-failed",
272                                tx_originator.sendrawtransaction,
273                                hexstring=malleated_invalid.serialize_with_witness().hex(),
274                                maxfeerate=0.1)
275
276        self.log.info("Checking that the transaction is not in the originator node's mempool")
277        assert_equal(len(tx_originator.getrawmempool()), 0)
278
279        wtxid_int = int(txs[0]["wtxid"], 16)
280        inv = CInv(MSG_WTX, wtxid_int)
281
282        tx_returner = None # First outbound-full-relay, will be P2PDataStore.
283        other_peer = None # Any other outbound-full-relay, we use the second one.
284
285        def set_tx_returner_and_other():
286            nonlocal tx_returner
287            nonlocal other_peer
288            tx_returner = None
289            other_peer = None
290            with self.destinations_lock:
291                for dest in self.destinations:
292                    if dest["conn_type"] == "outbound-full-relay" and dest["node"] is not None:
293                        if tx_returner is None:
294                            assert(type(dest["node"]) is P2PDataStore)
295                            tx_returner = dest["node"]
296                        else:
297                            assert(type(dest["node"]) is P2PInterface)
298                            other_peer = dest["node"]
299                            return True
300            return False
301
302        self.wait_until(set_tx_returner_and_other)
303
304        tx_returner.wait_for_connect()
305        other_peer.wait_for_connect()
306
307        self.log.info("Sending INV and waiting for GETDATA from node")
308        tx_returner.tx_store[wtxid_int] = txs[0]["tx"]
309        assert "getdata" not in tx_returner.last_message
310        received_back_msg = f"Received our privately broadcast transaction (txid={txs[0]['txid']}) from the network"
311        with tx_originator.assert_debug_log(expected_msgs=[received_back_msg]):
312            tx_returner.send_without_ping(msg_inv([inv]))
313            tx_returner.wait_until(lambda: "getdata" in tx_returner.last_message)
314            self.wait_until(lambda: len(tx_originator.getrawmempool()) > 0)
315
316        self.log.info("Waiting for normal broadcast to another peer")
317        other_peer.wait_for_inv([inv])
318
319        self.log.info("Checking getprivatebroadcastinfo no longer reports the transaction after it is received back")
320        pbinfo = tx_originator.getprivatebroadcastinfo()
321        pending = [t for t in pbinfo["transactions"] if t["txid"] == txs[0]["txid"] and t["wtxid"] == txs[0]["wtxid"]]
322        assert_equal(len(pending), 0)
323
324        self.log.info("Sending a transaction that is already in the mempool")
325        skip_destinations = len(self.destinations)
326        tx_originator.sendrawtransaction(hexstring=txs[0]["hex"], maxfeerate=0)
327        self.check_broadcasts("Broadcast of mempool transaction", txs[0], NUM_PRIVATE_BROADCAST_PER_TX, skip_destinations)
328
329        self.log.info("Sending a transaction with a dependency in the mempool")
330        skip_destinations = len(self.destinations)
331        tx_originator.sendrawtransaction(hexstring=txs[1]["hex"], maxfeerate=0.1)
332        self.check_broadcasts("Dependency in mempool", txs[1], NUM_PRIVATE_BROADCAST_PER_TX, skip_destinations)
333
334        self.log.info("Sending a transaction with a dependency not in the mempool (should be rejected)")
335        assert_equal(len(tx_originator.getrawmempool()), 1)
336        assert_raises_rpc_error(-25, "bad-txns-inputs-missingorspent",
337                                tx_originator.sendrawtransaction, hexstring=txs[2]["hex"], maxfeerate=0.1)
338        assert_raises_rpc_error(-25, "bad-txns-inputs-missingorspent",
339                                tx_originator.sendrawtransaction, hexstring=txs[2]["hex"], maxfeerate=0)
340
341        # Since txs[1] has not been received back by tx_originator,
342        # it should be re-broadcast after a while. Advance tx_originator's clock
343        # to trigger a re-broadcast. Should be more than the maximum returned by
344        # NextTxBroadcast() in net_processing.cpp.
345        self.log.info("Checking that rebroadcast works")
346        delta = 20 * 60 # 20min
347        skip_destinations = len(self.destinations)
348        rebroadcast_msg = f"Reattempting broadcast of stale txid={txs[1]['txid']}"
349        with tx_originator.busy_wait_for_debug_log(expected_msgs=[rebroadcast_msg.encode()]):
350            tx_originator.setmocktime(int(time.time()) + delta)
351            tx_originator.mockscheduler(delta)
352        self.check_broadcasts("Rebroadcast", txs[1], 1, skip_destinations)
353        tx_originator.setmocktime(0) # Let the clock tick again (it will go backwards due to this).
354
355        self.log.info("Sending a pair of transactions with the same txid but different valid wtxids via RPC")
356        parent = wallet.create_self_transfer()["tx"]
357        parent_amount = parent.vout[0].nValue - 10000
358        child_amount = parent_amount - 10000
359        siblings_parent, sibling1, sibling2 = build_malleated_tx_package(
360            parent=parent,
361            rebalance_parent_output_amount=parent_amount,
362            child_amount=child_amount)
363        self.log.info(f"  - sibling1: txid={sibling1.txid_hex}, wtxid={sibling1.wtxid_hex}")
364        self.log.info(f"  - sibling2: txid={sibling2.txid_hex}, wtxid={sibling2.wtxid_hex}")
365        assert_equal(sibling1.txid_hex, sibling2.txid_hex)
366        assert_not_equal(sibling1.wtxid_hex, sibling2.wtxid_hex)
367        assert_equal(len(tx_originator.getrawmempool()), 1)
368        tx_returner.send_without_ping(msg_tx(siblings_parent))
369        self.wait_until(lambda: len(tx_originator.getrawmempool()) > 1)
370        self.log.info("  - siblings' parent added to the mempool")
371        tx_originator.sendrawtransaction(hexstring=sibling1.serialize_with_witness().hex(), maxfeerate=0.1)
372        self.log.info("  - sent sibling1: ok")
373        tx_originator.sendrawtransaction(hexstring=sibling2.serialize_with_witness().hex(), maxfeerate=0.1)
374        self.log.info("  - sent sibling2: ok")
375
376        self.log.info("Checking abortprivatebroadcast removes a pending private-broadcast transaction")
377        tx_abort = wallet.create_self_transfer()
378        tx_originator.sendrawtransaction(hexstring=tx_abort["hex"], maxfeerate=0.1)
379        assert tx_abort["wtxid"] in [t["wtxid"] for t in tx_originator.getprivatebroadcastinfo()["transactions"]]
380        abort_res = tx_originator.abortprivatebroadcast(tx_abort["txid"])
381        assert_equal(len(abort_res["removed_transactions"]), 1)
382        assert_equal(abort_res["removed_transactions"][0]["txid"], tx_abort["txid"])
383        assert_equal(abort_res["removed_transactions"][0]["wtxid"], tx_abort["wtxid"])
384        assert_equal(abort_res["removed_transactions"][0]["hex"].lower(), tx_abort["hex"].lower())
385        assert all(t["wtxid"] != tx_abort["wtxid"] for t in tx_originator.getprivatebroadcastinfo()["transactions"])
386
387        self.log.info("Checking abortprivatebroadcast fails for non-existent transaction")
388        assert_raises_rpc_error(
389            -5,
390            "Transaction not in private broadcast queue",
391            tx_originator.abortprivatebroadcast,
392            "0" * 64,
393        )
394
395        self.log.info("Checking that a private broadcast destination signaling relay=false gets disconnected")
396        tx_no_relay = wallet.create_self_transfer()
397        disconnect_msg = "Disconnecting: does not support transaction relay (connected in vain)"
398        with tx_originator.assert_debug_log(expected_msgs=[disconnect_msg]):
399            with self.destinations_lock:
400                self.no_relay_peer = None
401                self.trigger_no_relay_peer = True
402            tx_originator.sendrawtransaction(hexstring=tx_no_relay["hex"], maxfeerate=0.1)
403            self.wait_until(lambda: self.no_relay_peer is not None)
404            self.no_relay_peer.wait_until(lambda: self.no_relay_peer.message_count["version"] == 1, check_connected=False)
405            self.no_relay_peer.wait_for_disconnect()
406        assert_equal(self.no_relay_peer.message_count, {"version": 1})
407
408        # Stop the SOCKS5 proxy server to avoid it being upset by the bitcoin
409        # node disconnecting in the middle of the SOCKS5 handshake when we
410        # restart below.
411        self.socks5_server.stop()
412
413        self.log.info("Trying to send a transaction when none of Tor or I2P is reachable")
414        self.restart_node(0, extra_args=[
415            "-privatebroadcast",
416            "-v2transport=0",
417            # A location where definitely a Tor control is not listening. This would allow
418            # Bitcoin Core to start, hoping/assuming that the location of the Tor proxy
419            # may be retrieved after startup from the Tor control, but it will not be, so
420            # the RPC should throw.
421            "-torcontrol=127.0.0.1:1",
422            "-listenonion",
423        ])
424        assert_raises_rpc_error(-1, "none of the Tor or I2P networks is reachable",
425                                tx_originator.sendrawtransaction, hexstring=txs[0]["hex"], maxfeerate=0.1)
426
427
428if __name__ == "__main__":
429    P2PPrivateBroadcast(__file__).main()
430