Inside Bitcoin

251        # parent_normal can be relayed again even though parent1_witness_stripped was rejected
252        self.relay_transaction(peer1, parent_normal["tx"])
253        assert_equal(set(node.getrawmempool()), set([parent_normal["txid"], child_invalid_witness["txid"]]))
254
255    @cleanup
256    def test_orphan_multiple_parents(self):
257        node = self.nodes[0]
258        peer = node.add_p2p_connection(PeerTxRelayer())
259
260        self.log.info("Test orphan parent requests with a mixture of confirmed, in-mempool and missing parents")
261        # This UTXO confirmed a long time ago.
262        utxo_conf_old = self.wallet.send_self_transfer(from_node=node)["new_utxo"]
263        txid_conf_old = utxo_conf_old["txid"]
264        self.generate(self.wallet, 10)
265
266        # Create a fake reorg to trigger BlockDisconnected, which resets the rolling bloom filter.
267        # The alternative is to mine thousands of transactions to push it out of the filter.
268        last_block = node.getbestblockhash()
269        node.invalidateblock(last_block)
270        node.preciousblock(last_block)
271        node.syncwithvalidationinterfacequeue()
272
273        # This UTXO confirmed recently.
274        utxo_conf_recent = self.wallet.send_self_transfer(from_node=node)["new_utxo"]
275        self.generate(node, 1)
276
277        # This UTXO is unconfirmed and in the mempool.
278        assert_equal(len(node.getrawmempool()), 0)
279        mempool_tx = self.wallet.send_self_transfer(from_node=node)
280        utxo_unconf_mempool = mempool_tx["new_utxo"]
281
282        # This UTXO is unconfirmed and missing.
283        missing_tx = self.wallet.create_self_transfer()
284        utxo_unconf_missing = missing_tx["new_utxo"]
285        assert missing_tx["txid"] not in node.getrawmempool()
286
287        orphan = self.wallet.create_self_transfer_multi(utxos_to_spend=[utxo_conf_old,
288            utxo_conf_recent, utxo_unconf_mempool, utxo_unconf_missing])
289
290        self.relay_transaction(peer, orphan["tx"])
291        self.nodes[0].bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY)
292        peer.sync_with_ping()
293        assert tx_in_orphanage(node, orphan["tx"])
294        assert_equal(len(peer.last_message["getdata"].inv), 2)
295        peer.wait_for_parent_requests([int(txid_conf_old, 16), int(missing_tx["txid"], 16)])
296
297        # Even though the peer would send a notfound for the "old" confirmed transaction, the node
298        # doesn't give up on the orphan. Once all of the missing parents are received, it should be
299        # submitted to mempool.
300        peer.send_without_ping(msg_notfound(vec=[CInv(MSG_WITNESS_TX, int(txid_conf_old, 16))]))
301        # Sync with ping to ensure orphans are reconsidered
302        peer.send_and_ping(msg_tx(missing_tx["tx"]))
303        assert_equal(node.getmempoolentry(orphan["txid"])["ancestorcount"], 3)
304
305    @cleanup
306    def test_orphans_overlapping_parents(self):
307        node = self.nodes[0]
308        # In the process of relaying inflight_parent_AB
309        peer_txrequest = node.add_p2p_connection(PeerTxRelayer())
310        # Sends the orphans
311        peer_orphans = node.add_p2p_connection(PeerTxRelayer())
312
313        confirmed_utxos = [self.wallet_nonsegwit.get_utxo() for _ in range(4)]
314        assert all([utxo["confirmations"] > 0 for utxo in confirmed_utxos])
315        self.log.info("Test handling of multiple orphans with missing parents that are already being requested")
316        # Parent of child_A only
317        missing_parent_A = self.wallet_nonsegwit.create_self_transfer(utxo_to_spend=confirmed_utxos[0])
318        # Parents of child_A and child_B
319        missing_parent_AB = self.wallet_nonsegwit.create_self_transfer(utxo_to_spend=confirmed_utxos[1])
320        inflight_parent_AB = self.wallet_nonsegwit.create_self_transfer(utxo_to_spend=confirmed_utxos[2])
321        # Parent of child_B only
322        missing_parent_B = self.wallet_nonsegwit.create_self_transfer(utxo_to_spend=confirmed_utxos[3])
323        child_A = self.wallet_nonsegwit.create_self_transfer_multi(
324            utxos_to_spend=[missing_parent_A["new_utxo"], missing_parent_AB["new_utxo"], inflight_parent_AB["new_utxo"]]
325        )
326        child_B = self.wallet_nonsegwit.create_self_transfer_multi(
327            utxos_to_spend=[missing_parent_B["new_utxo"], missing_parent_AB["new_utxo"], inflight_parent_AB["new_utxo"]]
328        )
329
330        # The wtxid and txid need to be the same for the node to recognize that the missing input
331        # and in-flight request for inflight_parent_AB are the same transaction.
332        assert_equal(inflight_parent_AB["txid"], inflight_parent_AB["wtxid"])
333
334        # Announce inflight_parent_AB and wait for getdata
335        peer_txrequest.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=inflight_parent_AB["tx"].wtxid_int)]))
336        self.nodes[0].bumpmocktime(NONPREF_PEER_TX_DELAY)
337        peer_txrequest.wait_for_getdata([inflight_parent_AB["tx"].wtxid_int])
338
339        self.log.info("Test that the node does not request a parent if it has an in-flight txrequest")
340        # Relay orphan child_A
341        self.relay_transaction(peer_orphans, child_A["tx"])
342        self.nodes[0].bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY)
343        assert tx_in_orphanage(node, child_A["tx"])
344        # There are 3 missing parents. missing_parent_A and missing_parent_AB should be requested.
345        # But inflight_parent_AB should not, because there is already an in-flight request for it.
346        peer_orphans.wait_for_parent_requests([int(missing_parent_A["txid"], 16), int(missing_parent_AB["txid"], 16)])
347
348        self.log.info("Test that the node does not request a parent if it has an in-flight orphan parent request")
349        # Relay orphan child_B
350        self.relay_transaction(peer_orphans, child_B["tx"])
351        self.nodes[0].bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY)
352        assert tx_in_orphanage(node, child_B["tx"])
353        # Only missing_parent_B should be requested. Not inflight_parent_AB or missing_parent_AB
354        # because they are already being requested from peer_txrequest and peer_orphans respectively.
355        peer_orphans.wait_for_parent_requests([int(missing_parent_B["txid"], 16)])
356        peer_orphans.assert_never_requested(int(inflight_parent_AB["txid"], 16))
357
358        # But inflight_parent_AB will be requested eventually if original peer doesn't respond
359        node.bumpmocktime(GETDATA_TX_INTERVAL)
360        peer_orphans.wait_for_parent_requests([int(inflight_parent_AB["txid"], 16)])
361
362    @cleanup
363    def test_orphan_of_orphan(self):
364        node = self.nodes[0]
365        peer = node.add_p2p_connection(PeerTxRelayer())
366
367        self.log.info("Test handling of an orphan with a parent who is another orphan")
368        missing_grandparent = self.wallet_nonsegwit.create_self_transfer()
369        missing_parent_orphan = self.wallet_nonsegwit.create_self_transfer(utxo_to_spend=missing_grandparent["new_utxo"])
370        missing_parent = self.wallet_nonsegwit.create_self_transfer()
371        orphan = self.wallet_nonsegwit.create_self_transfer_multi(utxos_to_spend=[missing_parent["new_utxo"], missing_parent_orphan["new_utxo"]])
372
373        # The node should put missing_parent_orphan into the orphanage and request missing_grandparent
374        self.relay_transaction(peer, missing_parent_orphan["tx"])
375        self.nodes[0].bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY)
376        assert tx_in_orphanage(node, missing_parent_orphan["tx"])
377        peer.wait_for_parent_requests([int(missing_grandparent["txid"], 16)])
378
379        # The node should put the orphan into the orphanage and request missing_parent, skipping
380        # missing_parent_orphan because it already has it in the orphanage.
381        self.relay_transaction(peer, orphan["tx"])
382        self.nodes[0].bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY)
383        assert tx_in_orphanage(node, orphan["tx"])
384        peer.wait_for_parent_requests([int(missing_parent["txid"], 16)])
385
386    @cleanup
387    def test_orphan_parent_confirmed(self):
388        node = self.nodes[0]
389        peer = node.add_p2p_connection(PeerTxRelayer())
390
391        parent = self.wallet.create_self_transfer(fee_rate=0)
392        child = self.wallet.create_self_transfer(utxo_to_spend=parent["new_utxo"])
393
394        self.log.info("Test orphan reconsideration when its missing parent is confirmed")
395        self.relay_transaction(peer, child["tx"])
396        assert tx_in_orphanage(node, child["tx"])
397
398        # Withhold the requested parent so it can only become available through the block.
399        node.bumpmocktime(TXREQUEST_TIME_SKIP)
400        peer.wait_for_parent_requests([parent["tx"].txid_int])
401        assert_equal(node.getrawmempool(), [])
402
403        self.generateblock(
404            node,
405            output=self.wallet.get_address(),
406            transactions=[parent["hex"]],
407        )
408        self.wait_until(lambda: child["txid"] in node.getrawmempool())
409        assert not tx_in_orphanage(node, child["tx"])
410
411    @cleanup
412    def test_orphan_inherit_rejection(self):
413        node = self.nodes[0]
414        peer1 = node.add_p2p_connection(PeerTxRelayer())
415        peer2 = node.add_p2p_connection(PeerTxRelayer())
416        peer3 = node.add_p2p_connection(PeerTxRelayer(wtxidrelay=False))
417
418        self.log.info("Test that an orphan with rejected parents, along with any descendants, cannot be retried with an alternate witness")
419        parent_overly_large_nonsegwit = self.wallet_nonsegwit.create_self_transfer(target_vsize=int(MAX_STANDARD_TX_WEIGHT / 4) + 1)
420        assert_equal(parent_overly_large_nonsegwit["txid"], parent_overly_large_nonsegwit["tx"].wtxid_hex)
421        child = self.wallet.create_self_transfer(utxo_to_spend=parent_overly_large_nonsegwit["new_utxo"])
422        grandchild = self.wallet.create_self_transfer(utxo_to_spend=child["new_utxo"])
423        assert_not_equal(child["txid"], child["tx"].wtxid_hex)
424        assert_not_equal(grandchild["txid"], grandchild["tx"].wtxid_hex)
425
426        # Relay the parent. It should be rejected because it pays 0 fees.
427        self.relay_transaction(peer1, parent_overly_large_nonsegwit["tx"])
428        assert parent_overly_large_nonsegwit["txid"] not in node.getrawmempool()
429
430        # Relay the child. It should be rejected for having missing parents, and this rejection is
431        # cached by txid and wtxid.
432        self.relay_transaction(peer1, child["tx"])
433        assert_equal(0, len(node.getrawmempool()))
434        assert not tx_in_orphanage(node, child["tx"])
435        peer1.assert_never_requested(parent_overly_large_nonsegwit["txid"])
436
437        # Grandchild should also not be kept in orphanage because its parent has been rejected.
438        self.relay_transaction(peer2, grandchild["tx"])
439        assert_equal(0, len(node.getrawmempool()))
440        assert not tx_in_orphanage(node, grandchild["tx"])
441        peer2.assert_never_requested(child["txid"])
442        peer2.assert_never_requested(child["tx"].wtxid_hex)
443
444        # The child should never be requested, even if announced again with potentially different witness.
445        # Sync with ping to ensure orphans are reconsidered
446        peer3.send_and_ping(msg_inv([CInv(t=MSG_TX, h=int(child["txid"], 16))]))
447        self.nodes[0].bumpmocktime(TXREQUEST_TIME_SKIP)
448        peer3.assert_never_requested(child["txid"])
449
450    @cleanup
451    def test_same_txid_orphan(self):
452        self.log.info("Check what happens when orphan with same txid is already in orphanage")
453        node = self.nodes[0]
454
455        tx_parent = self.wallet.create_self_transfer()
456
457        # Create the real child
458        tx_child = self.wallet.create_self_transfer(utxo_to_spend=tx_parent["new_utxo"])
459
460        # Create a fake version of the child
461        tx_orphan_bad_wit = malleate_tx_to_invalid_witness(tx_child)
462
463        bad_peer = node.add_p2p_connection(P2PInterface())
464        honest_peer = node.add_p2p_connection(P2PInterface())
465
466        # 1. Fake orphan is received first. It is missing an input.
467        bad_peer.send_and_ping(msg_tx(tx_orphan_bad_wit))
468        assert tx_in_orphanage(node, tx_orphan_bad_wit)
469
470        # 2. Node requests the missing parent by txid.
471        parent_txid_int = int(tx_parent["txid"], 16)
472        node.bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY)
473        bad_peer.wait_for_getdata([parent_txid_int])
474
475        # 3. Honest peer relays the real child, which is also missing parents and should be placed
476        # in the orphanage.
477        with node.assert_debug_log(["missingorspent"]):
478            honest_peer.send_and_ping(msg_tx(tx_child["tx"]))
479        assert tx_in_orphanage(node, tx_child["tx"])
480
481        # Time out the previous request for the parent (node will not request the same transaction
482        # from multiple nodes at the same time)
483        node.bumpmocktime(GETDATA_TX_INTERVAL)
484
485        # 4. The parent is requested. Honest peer sends it.
486        honest_peer.wait_for_getdata([parent_txid_int])
487        # Sync with ping to ensure orphans are reconsidered
488        honest_peer.send_and_ping(msg_tx(tx_parent["tx"]))
489
490        # 5. After parent is accepted, orphans should be reconsidered.
491        # The real child should be accepted and the fake one rejected.
492        node_mempool = node.getrawmempool()
493        assert tx_parent["txid"] in node_mempool
494        assert tx_child["txid"] in node_mempool
495        assert_equal(node.getmempoolentry(tx_child["txid"])["wtxid"], tx_child["wtxid"])
496
497    @cleanup
498    def test_same_txid_orphan_of_orphan(self):
499        self.log.info("Check what happens when orphan's parent with same txid is already in orphanage")
500        node = self.nodes[0]