Inside Bitcoin

1001        self.move_tip(65)
1002        self.next_block(67)
1003        tx1 = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue)
1004        tx2 = self.create_and_sign_transaction(tx1, 1)
1005        tx3 = self.create_and_sign_transaction(tx1, 2)
1006        b67 = self.update_block(67, [tx1, tx2, tx3])
1007        self.send_blocks([b67], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
1008
1009        # More tests of block subsidy
1010        #
1011        # -> b64 (18) -> b65 (19) -> b69 (20)
1012        #                        \-> b68 (20)
1013        #
1014        # b68 - coinbase with an extra 10 satoshis,
1015        #       creates a tx that has 9 satoshis from out[20] go to fees
1016        #       this fails because the coinbase is trying to claim 1 satoshi too much in fees
1017        #
1018        # b69 - coinbase with extra 10 satoshis, and a tx that gives a 10 satoshi fee
1019        #       this succeeds
1020        #
1021        self.log.info("Reject a block trying to claim too much subsidy in the coinbase transaction")
1022        self.move_tip(65)
1023        self.next_block(68, additional_coinbase_value=10)
1024        tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue - 9)
1025        b68 = self.update_block(68, [tx])
1026        self.send_blocks([b68], success=False, reject_reason='bad-cb-amount', reconnect=True)
1027
1028        self.log.info("Accept a block claiming the correct subsidy in the coinbase transaction")
1029        self.move_tip(65)
1030        b69 = self.next_block(69, additional_coinbase_value=10)
1031        tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue - 10)
1032        self.update_block(69, [tx])
1033        self.send_blocks([b69], True)
1034        self.save_spendable_output()
1035
1036        # Test spending the outpoint of a non-existent transaction
1037        #
1038        # -> b65 (19) -> b69 (20)
1039        #                        \-> b70 (21)
1040        #
1041        self.log.info("Reject a block containing a transaction spending from a non-existent input")
1042        self.move_tip(69)
1043        self.next_block(70, spend=out[21])
1044        bogus_txid_int = uint256_from_str(b"23c70ed7c0506e9178fc1a987f40a33946d4ad4c962b5ae3a52546da53af0c5c")
1045        tx = CTransaction()
1046        tx.vin.append(CTxIn(COutPoint(bogus_txid_int, 0), b"", SEQUENCE_FINAL))
1047        tx.vout.append(CTxOut(1, b""))
1048        b70 = self.update_block(70, [tx])
1049        self.send_blocks([b70], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
1050
1051        # Test accepting an invalid block which has the same hash as a valid one (via merkle tree tricks)
1052        #
1053        #  -> b65 (19) -> b69 (20) -> b72 (21)
1054        #                          \-> b71 (21)
1055        #
1056        # b72 is a good block.
1057        # b71 is a copy of 72, but re-adds one of its transactions.  However, it has the same hash as b72.
1058        self.log.info("Reject a block containing a duplicate transaction but with the same Merkle root (Merkle tree malleability")
1059        self.move_tip(69)
1060        self.next_block(72)
1061        tx1 = self.create_and_sign_transaction(out[21], 2)
1062        tx2 = self.create_and_sign_transaction(tx1, 1)
1063        b72 = self.update_block(72, [tx1, tx2])  # now tip is 72
1064        b71 = copy.deepcopy(b72)
1065        b71.vtx.append(tx2)   # add duplicate tx2
1066        self.block_heights[b71.hash_int] = self.block_heights[b69.hash_int] + 1  # b71 builds off b69
1067        self.blocks[71] = b71
1068
1069        assert_equal(len(b71.vtx), 4)
1070        assert_equal(len(b72.vtx), 3)
1071        assert_equal(b72.hash_int, b71.hash_int)
1072
1073        self.move_tip(71)
1074        self.send_blocks([b71], success=False, reject_reason='bad-txns-duplicate', reconnect=True)
1075
1076        self.move_tip(72)
1077        self.send_blocks([b72], True)
1078        self.save_spendable_output()
1079
1080        # Test some invalid scripts and MAX_BLOCK_SIGOPS
1081        #
1082        # -> b69 (20) -> b72 (21)
1083        #                        \-> b** (22)
1084        #
1085
1086        # b73 - tx with excessive sigops that are placed after an excessively large script element.
1087        #       The purpose of the test is to make sure those sigops are counted.
1088        #
1089        #       script is a bytearray of size 20,526
1090        #
1091        #       bytearray[0-19,998]     : OP_CHECKSIG
1092        #       bytearray[19,999]       : OP_PUSHDATA4
1093        #       bytearray[20,000-20,003]: 521  (max_script_element_size+1, in little-endian format)
1094        #       bytearray[20,004-20,525]: unread data (script_element)
1095        #       bytearray[20,526]       : OP_CHECKSIG (this puts us over the limit)
1096        self.log.info("Reject a block containing too many sigops after a large script element")
1097        self.move_tip(72)
1098        self.next_block(73)
1099        size = MAX_BLOCK_SIGOPS - 1 + MAX_SCRIPT_ELEMENT_SIZE + 1 + 5 + 1
1100        a = bytearray([OP_CHECKSIG] * size)
1101        a[MAX_BLOCK_SIGOPS - 1] = int("4e", 16)  # OP_PUSHDATA4
1102
1103        element_size = MAX_SCRIPT_ELEMENT_SIZE + 1
1104        a[MAX_BLOCK_SIGOPS] = element_size % 256
1105        a[MAX_BLOCK_SIGOPS + 1] = element_size // 256
1106        a[MAX_BLOCK_SIGOPS + 2] = 0
1107        a[MAX_BLOCK_SIGOPS + 3] = 0
1108
1109        tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
1110        b73 = self.update_block(73, [tx])
1111        assert_equal(get_legacy_sigopcount_block(b73), MAX_BLOCK_SIGOPS + 1)
1112        self.send_blocks([b73], success=False, reject_reason='bad-blk-sigops', reconnect=True)
1113
1114        # b74/75 - if we push an invalid script element, all previous sigops are counted,
1115        #          but sigops after the element are not counted.
1116        #
1117        #       The invalid script element is that the push_data indicates that
1118        #       there will be a large amount of data (0xffffff bytes), but we only
1119        #       provide a much smaller number.  These bytes are CHECKSIGS so they would
1120        #       cause b75 to fail for excessive sigops, if those bytes were counted.
1121        #
1122        #       b74 fails because we put MAX_BLOCK_SIGOPS+1 before the element
1123        #       b75 succeeds because we put MAX_BLOCK_SIGOPS before the element
1124        self.log.info("Check sigops are counted correctly after an invalid script element")
1125        self.move_tip(72)
1126        self.next_block(74)
1127        size = MAX_BLOCK_SIGOPS - 1 + MAX_SCRIPT_ELEMENT_SIZE + 42  # total = 20,561
1128        a = bytearray([OP_CHECKSIG] * size)
1129        a[MAX_BLOCK_SIGOPS] = 0x4e
1130        a[MAX_BLOCK_SIGOPS + 1] = 0xfe
1131        a[MAX_BLOCK_SIGOPS + 2] = 0xff
1132        a[MAX_BLOCK_SIGOPS + 3] = 0xff
1133        a[MAX_BLOCK_SIGOPS + 4] = 0xff
1134        tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
1135        b74 = self.update_block(74, [tx])
1136        self.send_blocks([b74], success=False, reject_reason='bad-blk-sigops', reconnect=True)
1137
1138        self.move_tip(72)
1139        self.next_block(75)
1140        size = MAX_BLOCK_SIGOPS - 1 + MAX_SCRIPT_ELEMENT_SIZE + 42
1141        a = bytearray([OP_CHECKSIG] * size)
1142        a[MAX_BLOCK_SIGOPS - 1] = 0x4e
1143        a[MAX_BLOCK_SIGOPS] = 0xff
1144        a[MAX_BLOCK_SIGOPS + 1] = 0xff
1145        a[MAX_BLOCK_SIGOPS + 2] = 0xff
1146        a[MAX_BLOCK_SIGOPS + 3] = 0xff
1147        tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
1148        b75 = self.update_block(75, [tx])
1149        self.send_blocks([b75], True)
1150        self.save_spendable_output()
1151
1152        # Check that if we push an element filled with CHECKSIGs, they are not counted
1153        self.move_tip(75)
1154        self.next_block(76)
1155        size = MAX_BLOCK_SIGOPS - 1 + MAX_SCRIPT_ELEMENT_SIZE + 1 + 5
1156        a = bytearray([OP_CHECKSIG] * size)
1157        a[MAX_BLOCK_SIGOPS - 1] = 0x4e  # PUSHDATA4, but leave the following bytes as just checksigs
1158        tx = self.create_and_sign_transaction(out[23], 1, CScript(a))
1159        b76 = self.update_block(76, [tx])
1160        self.send_blocks([b76], True)
1161        self.save_spendable_output()
1162
1163        # Test transaction resurrection
1164        #
1165        # -> b77 (24) -> b78 (25) -> b79 (26)
1166        #            \-> b80 (25) -> b81 (26) -> b82 (27)
1167        #
1168        #    b78 creates a tx, which is spent in b79. After b82, both should be in mempool
1169        #
1170        #    The resurrected transactions must pass the node's mempool policy, so create
1171        #    and spend standard outputs (P2PK using the coinbase pubkey to keep it simple).
1172        self.log.info("Test transaction resurrection during a re-org")
1173        standard_output_script = key_to_p2pk_script(self.coinbase_pubkey)
1174        self.move_tip(76)
1175        self.next_block(77)
1176        tx77 = self.create_and_sign_transaction(out[24], 10 * COIN, standard_output_script)
1177        b77 = self.update_block(77, [tx77])
1178        self.send_blocks([b77], True)
1179        self.save_spendable_output()
1180
1181        self.next_block(78)
1182        tx78 = self.create_and_sign_transaction(tx77, 9 * COIN, standard_output_script)
1183        b78 = self.update_block(78, [tx78])
1184        self.send_blocks([b78], True)
1185
1186        self.next_block(79)
1187        tx79 = self.create_and_sign_transaction(tx78, 8 * COIN, standard_output_script)
1188        b79 = self.update_block(79, [tx79])
1189        self.send_blocks([b79], True)
1190
1191        # mempool should be empty
1192        assert_equal(len(self.nodes[0].getrawmempool()), 0)
1193
1194        self.move_tip(77)
1195        b80 = self.next_block(80, spend=out[25])
1196        self.send_blocks([b80], False, force_send=True)
1197        self.save_spendable_output()
1198
1199        b81 = self.next_block(81, spend=out[26])
1200        self.send_blocks([b81], False, force_send=True)  # other chain is same length
1201        self.save_spendable_output()
1202
1203        b82 = self.next_block(82, spend=out[27])
1204        self.send_blocks([b82], True)  # now this chain is longer, triggers re-org
1205        self.save_spendable_output()
1206
1207        # now check that tx78 and tx79 have been put back into the peer's mempool
1208        mempool = self.nodes[0].getrawmempool()
1209        assert_equal(len(mempool), 2)
1210        assert tx78.txid_hex in mempool
1211        assert tx79.txid_hex in mempool
1212
1213        # Test invalid opcodes in dead execution paths.
1214        #
1215        #  -> b81 (26) -> b82 (27) -> b83 (28)
1216        #
1217        self.log.info("Accept a block with invalid opcodes in dead execution paths")
1218        self.next_block(83)
1219        op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF]
1220        script = CScript(op_codes)
1221        tx1 = self.create_and_sign_transaction(out[28], out[28].vout[0].nValue, script)
1222
1223        tx2 = self.create_and_sign_transaction(tx1, 0, CScript([OP_TRUE]))
1224        tx2.vin[0].scriptSig = CScript([OP_FALSE])
1225
1226        b83 = self.update_block(83, [tx1, tx2])
1227        self.send_blocks([b83], True)
1228        self.save_spendable_output()
1229
1230        # Reorg on/off blocks that have OP_RETURN in them (and try to spend them)
1231        #
1232        #  -> b81 (26) -> b82 (27) -> b83 (28) -> b84 (29) -> b87 (30) -> b88 (31)
1233        #                                    \-> b85 (29) -> b86 (30)            \-> b89a (32)
1234        #
1235        self.log.info("Test re-orging blocks with OP_RETURN in them")
1236        self.next_block(84)
1237        tx1 = self.create_tx(out[29], 0, 0, CScript([OP_RETURN]))
1238        tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
1239        tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
1240        tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
1241        tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
1242        self.sign_tx(tx1, out[29])
1243        tx2 = self.create_tx(tx1, 1, 0, CScript([OP_RETURN]))
1244        tx2.vout.append(CTxOut(0, CScript([OP_RETURN])))
1245        tx3 = self.create_tx(tx1, 2, 0, CScript([OP_RETURN]))
1246        tx3.vout.append(CTxOut(0, CScript([OP_TRUE])))
1247        tx4 = self.create_tx(tx1, 3, 0, CScript([OP_TRUE]))
1248        tx4.vout.append(CTxOut(0, CScript([OP_RETURN])))
1249        tx5 = self.create_tx(tx1, 4, 0, CScript([OP_RETURN]))
1250