Inside Bitcoin

251        assert_equal(len(alice.getrawmempool()), 0)
252        assert_equal(len(bob.getrawmempool()), 3)
253
254        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("49.99900000"))
255
256        # bob broadcasts tx_1 conflict
257        tx1_conflict_txid = bob.sendrawtransaction(tx1_conflict)
258        assert_equal(len(alice.getrawmempool()), 0)
259        assert_equal(len(bob.getrawmempool()), 2) # tx1_conflict kicks out both tx1, and its child tx3
260
261        assert tx2_txid in bob.getrawmempool()
262        assert tx1_conflict_txid in bob.getrawmempool()
263
264        assert_equal(bob.gettransaction(tx1_txid)["mempoolconflicts"], [tx1_conflict_txid])
265        assert_equal(bob.gettransaction(tx2_txid)["mempoolconflicts"], [])
266        assert_equal(bob.gettransaction(tx3_txid)["mempoolconflicts"], [tx1_conflict_txid])
267
268        # check that tx3 is now conflicted, so the output from tx2 can now be spent
269        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("24.99990000"))
270
271        # we will be disconnecting this block in the future
272        alice.sendrawtransaction(tx2_conflict)
273        assert_equal(len(alice.getrawmempool()), 1) # currently alice's mempool is only aware of tx2_conflict
274        # 11 blocks are mined so that when they are invalidated, tx_2
275        # does not get put back into the mempool
276        blk = self.generate(self.nodes[0], 11, sync_fun=self.no_op)[0]
277        assert_equal(len(alice.getrawmempool()), 0) # tx2_conflict is now mined
278
279        self.connect_nodes(0, 1)
280        self.sync_blocks()
281        assert_equal(alice.getbestblockhash(), bob.getbestblockhash())
282
283        # now that tx2 has a block conflict, tx1_conflict should be the only tx in bob's mempool
284        assert tx1_conflict_txid in bob.getrawmempool()
285        assert_equal(len(bob.getrawmempool()), 1)
286
287        # tx3 should now also be block-conflicted by tx2_conflict
288        assert_equal(bob.gettransaction(tx3_txid)["confirmations"], -11)
289        # bob has no pending funds, since tx1, tx2, and tx3 are all conflicted
290        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
291        bob.invalidateblock(blk) # remove tx2_conflict
292        # bob should still have no pending funds because tx1 and tx3 are still conflicted, and tx2 has not been re-broadcast
293        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
294        assert_equal(len(bob.getrawmempool()), 1)
295        # check that tx3 is no longer block-conflicted
296        assert_equal(bob.gettransaction(tx3_txid)["confirmations"], 0)
297
298        bob.sendrawtransaction(raw_tx2)
299        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("24.99990000"))
300
301        # create a conflict to previous tx (also spends unspents[2]), but don't broadcast, sends funds back to alice
302        raw_tx = alice.createrawtransaction(inputs=[unspents[2]], outputs=[{alice.getnewaddress() : 24.99}])
303        tx1_conflict_conflict = alice.signrawtransactionwithwallet(raw_tx)['hex']
304
305        bob.sendrawtransaction(tx1_conflict_conflict) # kick tx1_conflict out of the mempool
306        bob.sendrawtransaction(raw_tx1) #re-broadcast tx1 because it is no longer conflicted
307
308        # Now bob has pending funds because tx1 and tx2 are spent by tx3, which hasn't been re-broadcast yet
309        bob_bal = bob.getbalances()["mine"]
310        assert_equal(bob_bal["untrusted_pending"], -bob_bal["nonmempool"])
311
312        bob.sendrawtransaction(raw_tx3)
313        assert_equal(len(bob.getrawmempool()), 4) # The mempool contains: tx1, tx2, tx1_conflict_conflict, tx3
314        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("49.99900000"))
315
316        # Clean up for next test
317        bob.reconsiderblock(blk)
318        assert_equal(alice.getbestblockhash(), bob.getbestblockhash())
319        self.sync_mempools()
320        self.generate(self.nodes[2], 1)
321
322        alice.unloadwallet()
323
324    def test_descendants_with_mempool_conflicts(self):
325        self.nodes[0].createwallet("alice_3")
326        alice = self.nodes[0].get_wallet_rpc("alice_3")
327
328        self.nodes[2].send(outputs=[{alice.getnewaddress() : 25} for _ in range(2)])
329        self.generate(self.nodes[2], 1)
330
331        self.nodes[1].createwallet("bob_1")
332        bob = self.nodes[1].get_wallet_rpc("bob_1")
333
334        self.nodes[2].createwallet("carol")
335        carol = self.nodes[2].get_wallet_rpc("carol")
336
337        self.log.info("Test a scenario where a transaction's parent has a mempool conflict")
338
339        unspents = alice.listunspent()
340        assert_equal(len(unspents), 2)
341        for tx in unspents:
342            assert_equal(tx["amount"], 25)
343
344        assert_equal(alice.getrawmempool(), [])
345
346        # Alice spends first utxo to bob in tx1
347        raw_tx = alice.createrawtransaction(inputs=[unspents[0]], outputs=[{bob.getnewaddress() : 24.9999}])
348        tx1 = alice.signrawtransactionwithwallet(raw_tx)['hex']
349        tx1_txid = alice.sendrawtransaction(tx1)
350
351        self.sync_mempools()
352
353        assert_equal(alice.getbalance(), 25)
354        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("24.99990000"))
355
356        assert_equal(bob.gettransaction(tx1_txid)["mempoolconflicts"],  [])
357
358        raw_tx = bob.createrawtransaction(inputs=[bob.listunspent(minconf=0)[0]], outputs=[{carol.getnewaddress() : 24.999}])
359        # Bob creates a child to tx1
360        tx1_child = bob.signrawtransactionwithwallet(raw_tx)['hex']
361        tx1_child_txid = bob.sendrawtransaction(tx1_child)
362
363        self.sync_mempools()
364
365        # Currently neither tx1 nor tx1_child should have any conflicts
366        assert_equal(bob.gettransaction(tx1_txid)["mempoolconflicts"],  [])
367        assert_equal(bob.gettransaction(tx1_child_txid)["mempoolconflicts"],  [])
368        assert tx1_txid in bob.getrawmempool()
369        assert tx1_child_txid in bob.getrawmempool()
370        assert_equal(len(bob.getrawmempool()), 2)
371
372        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
373        assert_equal(carol.getbalances()["mine"]["untrusted_pending"], Decimal("24.99900000"))
374
375        # Alice spends first unspent again, conflicting with tx1
376        raw_tx = alice.createrawtransaction(inputs=[unspents[0], unspents[1]], outputs=[{carol.getnewaddress() : 49.99}])
377        tx1_conflict = alice.signrawtransactionwithwallet(raw_tx)['hex']
378        tx1_conflict_txid = alice.sendrawtransaction(tx1_conflict)
379
380        self.sync_mempools()
381
382        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
383        assert_equal(carol.getbalances()["mine"]["untrusted_pending"], Decimal("49.99000000"))
384
385        assert tx1_txid not in bob.getrawmempool()
386        assert tx1_child_txid not in bob.getrawmempool()
387        assert tx1_conflict_txid in bob.getrawmempool()
388        assert_equal(len(bob.getrawmempool()), 1)
389
390        # Now both tx1 and tx1_child are conflicted by tx1_conflict
391        assert_equal(bob.gettransaction(tx1_txid)["mempoolconflicts"],  [tx1_conflict_txid])
392        assert_equal(bob.gettransaction(tx1_child_txid)["mempoolconflicts"],  [tx1_conflict_txid])
393
394        # Now create a conflict to tx1_conflict, so that it gets kicked out of the mempool
395        raw_tx = alice.createrawtransaction(inputs=[unspents[1]], outputs=[{carol.getnewaddress() : 24.9895}])
396        tx1_conflict_conflict = alice.signrawtransactionwithwallet(raw_tx)['hex']
397        tx1_conflict_conflict_txid = alice.sendrawtransaction(tx1_conflict_conflict)
398
399        self.sync_mempools()
400
401        # Now that tx1_conflict has been removed, both tx1 and tx1_child
402        assert_equal(bob.gettransaction(tx1_txid)["mempoolconflicts"],  [])
403        assert_equal(bob.gettransaction(tx1_child_txid)["mempoolconflicts"],  [])
404
405        # Both tx1 and tx1_child are still not in the mempool because they have not be re-broadcasted
406        assert tx1_txid not in bob.getrawmempool()
407        assert tx1_child_txid not in bob.getrawmempool()
408        assert tx1_conflict_txid not in bob.getrawmempool()
409        assert tx1_conflict_conflict_txid in bob.getrawmempool()
410        assert_equal(len(bob.getrawmempool()), 1)
411
412        assert_equal(alice.getbalance(), 0)
413        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
414        assert_equal(carol.getbalances()["mine"]["untrusted_pending"], Decimal("24.98950000"))
415
416        # Both tx1 and tx1_child can now be re-broadcasted
417        bob.sendrawtransaction(tx1)
418        bob.sendrawtransaction(tx1_child)
419        assert_equal(len(bob.getrawmempool()), 3)
420
421        alice.unloadwallet()
422        bob.unloadwallet()
423        carol.unloadwallet()
424
425if __name__ == '__main__':
426    TxConflicts(__file__).main()
427