Inside Bitcoin

501        #           p2sh_script = OP_HASH160, ripemd160(sha256(script)), OP_EQUAL
502        #
503        self.log.info("Check P2SH SIGOPS are correctly counted")
504        self.move_tip(35)
505        self.next_block(39)
506        b39_outputs = 0
507        b39_sigops_per_output = 6
508
509        # Build the redeem script, hash it, use hash to create the p2sh script
510        redeem_script = CScript([self.coinbase_pubkey] + [OP_2DUP, OP_CHECKSIGVERIFY] * 5 + [OP_CHECKSIG])
511        p2sh_script = script_to_p2sh_script(redeem_script)
512
513        # Create a transaction that spends one satoshi to the p2sh_script, the rest to OP_TRUE
514        # This must be signed because it is spending a coinbase
515        spend = out[11]
516        tx = self.create_tx(spend, 0, 1, p2sh_script)
517        tx.vout.append(CTxOut(spend.vout[0].nValue - 1, CScript([OP_TRUE])))
518        self.sign_tx(tx, spend)
519        b39 = self.update_block(39, [tx])
520        b39_outputs += 1
521
522        # Until block is full, add tx's with 1 satoshi to p2sh_script, the rest to OP_TRUE
523        tx_new = None
524        tx_last = tx
525        total_weight = b39.get_weight()
526        while total_weight < MAX_BLOCK_WEIGHT:
527            tx_new = self.create_tx(tx_last, 1, 1, p2sh_script)
528            tx_new.vout.append(CTxOut(tx_last.vout[1].nValue - 1, CScript([OP_TRUE])))
529            total_weight += tx_new.get_weight()
530            if total_weight >= MAX_BLOCK_WEIGHT:
531                break
532            b39.vtx.append(tx_new)  # add tx to block
533            tx_last = tx_new
534            b39_outputs += 1
535
536        # The accounting in the loop above can be off, because it misses the
537        # compact size encoding of the number of transactions in the block.
538        # Make sure we didn't accidentally make too big a block. Note that the
539        # size of the block has non-determinism due to the ECDSA signature in
540        # the first transaction.
541        while b39.get_weight() >= MAX_BLOCK_WEIGHT:
542            del b39.vtx[-1]
543
544        b39 = self.update_block(39, [])
545        self.send_blocks([b39], True)
546        self.save_spendable_output()
547
548        # Test sigops in P2SH redeem scripts
549        #
550        # b40 creates 3333 tx's spending the 6-sigop P2SH outputs from b39 for a total of 19998 sigops.
551        # The first tx has one sigop and then at the end we add 2 more to put us just over the max.
552        #
553        # b41 does the same, less one, so it has the maximum sigops permitted.
554        #
555        self.log.info("Reject a block with too many P2SH sigops")
556        self.move_tip(39)
557        b40 = self.next_block(40, spend=out[12])
558        sigops = get_legacy_sigopcount_block(b40)
559        numTxes = (MAX_BLOCK_SIGOPS - sigops) // b39_sigops_per_output
560        assert_equal(numTxes <= b39_outputs, True)
561
562        lastOutpoint = COutPoint(b40.vtx[1].txid_int, 0)
563        new_txs = []
564        for i in range(1, numTxes + 1):
565            tx = CTransaction()
566            tx.vout.append(CTxOut(1, CScript([OP_TRUE])))
567            tx.vin.append(CTxIn(lastOutpoint, b''))
568            # second input is corresponding P2SH output from b39
569            tx.vin.append(CTxIn(COutPoint(b39.vtx[i].txid_int, 0), b''))
570            # Note: must pass the redeem_script (not p2sh_script) to the signature hash function
571            tx.vin[1].scriptSig = CScript([redeem_script])
572            sign_input_legacy(tx, 1, redeem_script, self.coinbase_key)
573            new_txs.append(tx)
574            lastOutpoint = COutPoint(tx.txid_int, 0)
575
576        b40_sigops_to_fill = MAX_BLOCK_SIGOPS - (numTxes * b39_sigops_per_output + sigops) + 1
577        tx = CTransaction()
578        tx.vin.append(CTxIn(lastOutpoint, b''))
579        tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b40_sigops_to_fill)))
580        new_txs.append(tx)
581        self.update_block(40, new_txs)
582        self.send_blocks([b40], success=False, reject_reason='bad-blk-sigops', reconnect=True)
583
584        # same as b40, but one less sigop
585        self.log.info("Accept a block with the max number of P2SH sigops")
586        self.move_tip(39)
587        b41 = self.next_block(41, spend=None)
588        self.update_block(41, b40.vtx[1:-1])
589        b41_sigops_to_fill = b40_sigops_to_fill - 1
590        tx = CTransaction()
591        tx.vin.append(CTxIn(lastOutpoint, b''))
592        tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b41_sigops_to_fill)))
593        self.update_block(41, [tx])
594        self.send_blocks([b41], True)
595
596        # Fork off of b39 to create a constant base again
597        #
598        # b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13)
599        #                                                                  \-> b41 (12)
600        #
601        self.move_tip(39)
602        b42 = self.next_block(42, spend=out[12])
603        self.save_spendable_output()
604
605        b43 = self.next_block(43, spend=out[13])
606        self.save_spendable_output()
607        self.send_blocks([b42, b43], True)
608
609        # Test a number of really invalid scenarios
610        #
611        #  -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b44 (14)
612        #                                                                                   \-> ??? (15)
613
614        # The next few blocks are going to be created "by hand" since they'll do funky things, such as having
615        # the first transaction be non-coinbase, etc.  The purpose of b44 is to make sure this works.
616        self.log.info("Build block 44 manually")
617        height = self.block_heights[self.tip.hash_int] + 1
618        coinbase = create_coinbase(height, self.coinbase_pubkey)
619        b44 = CBlock()
620        b44.nTime = self.tip.nTime + 1
621        b44.hashPrevBlock = self.tip.hash_int
622        b44.nBits = REGTEST_N_BITS
623        b44.vtx.append(coinbase)
624        tx = self.create_and_sign_transaction(out[14], 1)
625        b44.vtx.append(tx)
626        b44.hashMerkleRoot = b44.calc_merkle_root()
627        b44.solve()
628        self.tip = b44
629        self.block_heights[b44.hash_int] = height
630        self.blocks[44] = b44
631        self.send_blocks([b44], True)
632
633        self.log.info("Reject a block with a non-coinbase as the first tx")
634        non_coinbase = self.create_tx(out[15], 0, 1)
635        b45 = CBlock()
636        b45.nTime = self.tip.nTime + 1
637        b45.hashPrevBlock = self.tip.hash_int
638        b45.nBits = REGTEST_N_BITS
639        b45.vtx.append(non_coinbase)
640        b45.hashMerkleRoot = b45.calc_merkle_root()
641        b45.solve()
642        self.block_heights[b45.hash_int] = self.block_heights[self.tip.hash_int] + 1
643        self.tip = b45
644        self.blocks[45] = b45
645        self.send_blocks([b45], success=False, reject_reason='bad-cb-missing', reconnect=True)
646
647        self.log.info("Reject a block with no transactions")
648        self.move_tip(44)
649        b46 = CBlock()
650        b46.nTime = b44.nTime + 1
651        b46.hashPrevBlock = b44.hash_int
652        b46.nBits = REGTEST_N_BITS
653        b46.vtx = []
654        b46.hashMerkleRoot = 0
655        b46.solve()
656        self.block_heights[b46.hash_int] = self.block_heights[b44.hash_int] + 1
657        self.tip = b46
658        assert 46 not in self.blocks
659        self.blocks[46] = b46
660        self.send_blocks([b46], success=False, reject_reason='bad-blk-length', reconnect=True)
661
662        self.log.info("Reject a block with invalid work")
663        self.move_tip(44)
664        b47 = self.next_block(47)
665        target = uint256_from_compact(b47.nBits)
666        while b47.hash_int <= target:
667            # Rehash nonces until an invalid too-high-hash block is found.
668            b47.nNonce += 1
669        self.send_blocks([b47], False, force_send=True, reject_reason='high-hash', reconnect=True)
670
671        self.log.info("Reject a block with a timestamp >2 hours in the future")
672        self.move_tip(44)
673        b48 = self.next_block(48)
674        b48.nTime = int(time.time()) + 60 * 60 * 3
675        # Header timestamp has changed. Re-solve the block.
676        b48.solve()
677        self.send_blocks([b48], False, force_send=True, reject_reason='time-too-new')
678
679        self.log.info("Reject a block with invalid merkle hash")
680        self.move_tip(44)
681        b49 = self.next_block(49)
682        b49.hashMerkleRoot += 1
683        b49.solve()
684        self.send_blocks([b49], success=False, reject_reason='bad-txnmrklroot', reconnect=True)
685
686        self.log.info("Reject a block with incorrect POW limit")
687        self.move_tip(44)
688        b50 = self.next_block(50)
689        b50.nBits = b50.nBits - 1
690        b50.solve()
691        self.send_blocks([b50], False, force_send=True, reject_reason='bad-diffbits', reconnect=True)
692
693        self.log.info("Reject a block with two coinbase transactions")
694        self.move_tip(44)
695        self.next_block(51)
696        cb2 = create_coinbase(51, self.coinbase_pubkey)
697        b51 = self.update_block(51, [cb2])
698        self.send_blocks([b51], success=False, reject_reason='bad-cb-multiple', reconnect=True)
699
700        self.log.info("Reject a block with duplicate transactions")
701        # Note: txns have to be in the right position in the merkle tree to trigger this error
702        self.move_tip(44)
703        b52 = self.next_block(52, spend=out[15])
704        tx = self.create_tx(b52.vtx[1], 0, 1)
705        b52 = self.update_block(52, [tx, tx])
706        self.send_blocks([b52], success=False, reject_reason='bad-txns-duplicate', reconnect=True)
707
708        # Test block timestamps
709        #  -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15)
710        #                                                                                   \-> b54 (15)
711        #                                                                        -> b44 (14)\-> b48 ()
712        self.move_tip(43)
713        b53 = self.next_block(53, spend=out[14])
714        self.send_blocks([b53], False)
715        self.save_spendable_output()
716
717        self.log.info("Reject a block with timestamp before MedianTimePast")
718        b54 = self.next_block(54, spend=out[15])
719        b54.nTime = b35.nTime - 1
720        b54.solve()
721        self.send_blocks([b54], False, force_send=True, reject_reason='time-too-old', reconnect=True)
722
723        # valid timestamp
724        self.move_tip(53)
725        b55 = self.next_block(55, spend=out[15])
726        self.update_block(55, [], nTime=b35.nTime)
727        self.send_blocks([b55], True)
728        self.save_spendable_output()
729
730        # The block which was previously rejected because of being "too far(3 hours)" must be accepted 2 hours later.
731        # The new block is only 1 hour into future now and we must reorg onto to the new longer chain.
732        # The new bestblock b48p is invalidated manually.
733        #  -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15)
734        #                                                                                   \-> b54 (15)
735        #                                                                        -> b44 (14)\-> b48 () -> b48p ()
736        self.log.info("Accept a previously rejected future block at a later time")
737        node.setmocktime(int(time.time()) + 2*60*60)
738        self.move_tip(48)
739        self.block_heights[b48.hash_int] = self.block_heights[b44.hash_int] + 1 # b48 is a parent of b44
740        b48p = self.next_block("48p")
741        self.send_blocks([b48, b48p], success=True) # Reorg to the longer chain
742        node.invalidateblock(b48p.hash_hex) # mark b48p as invalid
743        node.setmocktime(0)
744
745        # Test Merkle tree malleability
746        #
747        # -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57p2 (16)
748        #                                                \-> b57   (16)
749        #                                                \-> b56p2 (16)
750        #                                                \-> b56   (16)