Inside Bitcoin

251                # sendrawtransaction should fail if the tx is in the mempool
252                assert_raises_rpc_error(-26, NOT_FINAL_ERROR, self.wallet.sendrawtransaction, from_node=node, tx_hex=tx.serialize().hex())
253            else:
254                # sendrawtransaction should succeed if the tx is not in the mempool
255                self.wallet.sendrawtransaction(from_node=node, tx_hex=tx.serialize().hex())
256
257            return tx
258
259        test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=True)
260        test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)
261
262        # Now mine some blocks, but make sure tx2 doesn't get mined.
263        # Use prioritisetransaction to lower the effective feerate to 0
264        self.nodes[0].prioritisetransaction(txid=tx2.txid_hex, fee_delta=int(-self.relayfee*COIN))
265        cur_time = int(time.time())
266        for _ in range(10):
267            self.nodes[0].setmocktime(cur_time + 600)
268            self.generate(self.wallet, 1, sync_fun=self.no_op)
269            cur_time += 600
270
271        assert tx2.txid_hex in self.nodes[0].getrawmempool()
272
273        test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=True)
274        test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)
275
276        # Mine tx2, and then try again
277        self.nodes[0].prioritisetransaction(txid=tx2.txid_hex, fee_delta=int(self.relayfee*COIN))
278
279        # Advance the time on the node so that we can test timelocks
280        self.nodes[0].setmocktime(cur_time+600)
281        # Save block template now to use for the reorg later
282        tmpl = self.nodes[0].getblocktemplate(NORMAL_GBT_REQUEST_PARAMS)
283        self.generate(self.nodes[0], 1)
284        assert tx2.txid_hex not in self.nodes[0].getrawmempool()
285
286        # Now that tx2 is not in the mempool, a sequence locked spend should
287        # succeed
288        tx3 = test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)
289        assert tx3.txid_hex in self.nodes[0].getrawmempool()
290
291        self.generate(self.nodes[0], 1)
292        assert tx3.txid_hex not in self.nodes[0].getrawmempool()
293
294        # One more test, this time using height locks
295        tx4 = test_nonzero_locks(tx3, self.nodes[0], self.relayfee, use_height_lock=True)
296        assert tx4.txid_hex in self.nodes[0].getrawmempool()
297
298        # Now try combining confirmed and unconfirmed inputs
299        tx5 = test_nonzero_locks(tx4, self.nodes[0], self.relayfee, use_height_lock=True)
300        assert tx5.txid_hex not in self.nodes[0].getrawmempool()
301
302        utxo = self.wallet.get_utxo()
303        tx5.vin.append(CTxIn(COutPoint(int(utxo["txid"], 16), utxo["vout"]), nSequence=1))
304        tx5.vout[0].nValue += int(utxo["value"]*COIN)
305        self.wallet.sign_tx(tx=tx5)
306
307        assert_raises_rpc_error(-26, NOT_FINAL_ERROR, self.wallet.sendrawtransaction, from_node=self.nodes[0], tx_hex=tx5.serialize().hex())
308
309        # Test mempool-BIP68 consistency after reorg
310        #
311        # State of the transactions in the last blocks:
312        # ... -> [ tx2 ] ->  [ tx3 ]
313        #         tip-1        tip
314        # And currently tx4 is in the mempool.
315        #
316        # If we invalidate the tip, tx3 should get added to the mempool, causing
317        # tx4 to be removed (fails sequence-lock).
318        self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
319        assert tx4.txid_hex not in self.nodes[0].getrawmempool()
320        assert tx3.txid_hex in self.nodes[0].getrawmempool()
321
322        # Now mine 2 empty blocks to reorg out the current tip (labeled tip-1 in
323        # diagram above).
324        # This would cause tx2 to be added back to the mempool, which in turn causes
325        # tx3 to be removed.
326        for i in range(2):
327            block = create_block(tmpl=tmpl, ntime=cur_time)
328            block.solve()
329            tip = block.hash_int
330            assert_equal(None if i == 1 else 'inconclusive', self.nodes[0].submitblock(block.serialize().hex()))
331            tmpl = self.nodes[0].getblocktemplate(NORMAL_GBT_REQUEST_PARAMS)
332            tmpl['previousblockhash'] = '%x' % tip
333            tmpl['transactions'] = []
334            cur_time += 1
335
336        mempool = self.nodes[0].getrawmempool()
337        assert tx3.txid_hex not in mempool
338        assert tx2.txid_hex in mempool
339
340        # Reset the chain and get rid of the mocktimed-blocks
341        self.nodes[0].setmocktime(0)
342        self.nodes[0].invalidateblock(self.nodes[0].getblockhash(cur_height+1))
343        self.generate(self.wallet, 10, sync_fun=self.no_op)
344
345    # Make sure that BIP68 isn't being used to validate blocks prior to
346    # activation height.  If more blocks are mined prior to this test
347    # being run, then it's possible the test has activated the soft fork, and
348    # this test should be moved to run earlier, or deleted.
349    def test_bip68_not_consensus(self):
350        assert not softfork_active(self.nodes[0], 'csv')
351
352        tx1 = self.wallet.send_self_transfer(from_node=self.nodes[0])["tx"]
353
354        # Make an anyone-can-spend transaction
355        tx2 = CTransaction()
356        tx2.version = 1
357        tx2.vin = [CTxIn(COutPoint(tx1.txid_int, 0), nSequence=0)]
358        tx2.vout = [CTxOut(int(tx1.vout[0].nValue - self.relayfee * COIN), SCRIPT_W0_SH_OP_TRUE)]
359
360        # sign tx2
361        self.wallet.sign_tx(tx=tx2)
362        tx2_raw = tx2.serialize().hex()
363        tx2 = tx_from_hex(tx2_raw)
364
365        self.wallet.sendrawtransaction(from_node=self.nodes[0], tx_hex=tx2_raw)
366
367        # Now make an invalid spend of tx2 according to BIP68
368        sequence_value = 100 # 100 block relative locktime
369
370        tx3 = CTransaction()
371        tx3.version = 2
372        tx3.vin = [CTxIn(COutPoint(tx2.txid_int, 0), nSequence=sequence_value)]
373        tx3.wit.vtxinwit = [CTxInWitness()]
374        tx3.wit.vtxinwit[0].scriptWitness.stack = [CScript([OP_TRUE])]
375        tx3.vout = [CTxOut(int(tx2.vout[0].nValue - self.relayfee * COIN), SCRIPT_W0_SH_OP_TRUE)]
376
377        assert_raises_rpc_error(-26, NOT_FINAL_ERROR, self.wallet.sendrawtransaction, from_node=self.nodes[0], tx_hex=tx3.serialize().hex())
378
379        # make a block that violates bip68; ensure that the tip updates
380        block = create_block(tmpl=self.nodes[0].getblocktemplate(NORMAL_GBT_REQUEST_PARAMS), txlist=[tx1, tx2, tx3])
381        add_witness_commitment(block)
382        block.solve()
383
384        assert_equal(None, self.nodes[0].submitblock(block.serialize().hex()))
385        assert_equal(self.nodes[0].getbestblockhash(), block.hash_hex)
386
387    def activateCSV(self):
388        # activation should happen at block height 432 (3 periods)
389        # getblockchaininfo will show CSV as active at block 431 (144 * 3 -1) since it's returning whether CSV is active for the next block.
390        min_activation_height = 432
391        height = self.nodes[0].getblockcount()
392        assert_greater_than(min_activation_height - height, 2)
393        self.generate(self.wallet, min_activation_height - height - 2, sync_fun=self.no_op)
394        assert not softfork_active(self.nodes[0], 'csv')
395        self.generate(self.wallet, 1, sync_fun=self.no_op)
396        assert softfork_active(self.nodes[0], 'csv')
397        self.sync_blocks()
398
399    # Use self.nodes[1] to test that version 2 transactions are standard.
400    def test_version2_relay(self):
401        mini_wallet = MiniWallet(self.nodes[1])
402        mini_wallet.send_self_transfer(from_node=self.nodes[1], version=2)
403
404
405if __name__ == '__main__':
406    BIP68Test(__file__).main()
407