Inside Bitcoin

1251        b84 = self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
1252        self.send_blocks([b84], True)
1253        self.save_spendable_output()
1254
1255        self.move_tip(83)
1256        b85 = self.next_block(85, spend=out[29])
1257        self.send_blocks([b85], False)  # other chain is same length
1258
1259        b86 = self.next_block(86, spend=out[30])
1260        self.send_blocks([b86], True)
1261
1262        self.move_tip(84)
1263        b87 = self.next_block(87, spend=out[30])
1264        self.send_blocks([b87], False)  # other chain is same length
1265        self.save_spendable_output()
1266
1267        b88 = self.next_block(88, spend=out[31])
1268        self.send_blocks([b88], True)
1269        self.save_spendable_output()
1270
1271        # trying to spend the OP_RETURN output is rejected
1272        self.next_block("89a", spend=out[32])
1273        tx = self.create_tx(tx1, 0, 0, CScript([OP_TRUE]))
1274        b89a = self.update_block("89a", [tx])
1275        self.send_blocks([b89a], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
1276
1277        self.move_tip(88)
1278        self.log.info("Reject a block with an invalid block header version")
1279        b_v1 = self.next_block('b_v1', version=1)
1280        self.send_blocks([b_v1], success=False, force_send=True, reject_reason='bad-version(0x00000001)', reconnect=True)
1281
1282        self.move_tip(87)
1283        b_cb34 = self.next_block('b_cb34')
1284        b_cb34.vtx[0].vin[0].scriptSig = b_cb34.vtx[0].vin[0].scriptSig[:-1]
1285        b_cb34.hashMerkleRoot = b_cb34.calc_merkle_root()
1286        b_cb34.solve()
1287        self.send_blocks([b_cb34], success=False, reject_reason='bad-cb-height', reconnect=True)
1288
1289        # Don't use v2transport for the large reorg, which is too slow with the unoptimized python ChaCha20 implementation
1290        if self.options.v2transport:
1291            self.nodes[0].disconnect_p2ps()
1292            self.helper_peer = self.nodes[0].add_p2p_connection(P2PDataStore(), supports_v2_p2p=False)
1293
1294        self.move_tip(88)
1295        if not self.options.skip_reorg:
1296            self.log.info("Test a re-org of one week's worth of blocks (1088 blocks)")
1297            LARGE_REORG_SIZE = 1088
1298            blocks = []
1299            spend = out[32]
1300            for i in range(89, LARGE_REORG_SIZE + 89):
1301                b = self.next_block(i, spend)
1302                tx = CTransaction()
1303                script_length = (MAX_BLOCK_WEIGHT - b.get_weight() - 276) // 4
1304                script_output = CScript([b'\x00' * script_length])
1305                tx.vout.append(CTxOut(0, script_output))
1306                tx.vin.append(CTxIn(COutPoint(b.vtx[1].txid_int, 0)))
1307                b = self.update_block(i, [tx])
1308                assert_equal(b.get_weight(), MAX_BLOCK_WEIGHT)
1309                blocks.append(b)
1310                self.save_spendable_output()
1311                spend = self.get_spendable_output()
1312
1313            self.send_blocks(blocks, True, timeout=2440)
1314            chain1_tip = i
1315
1316            # now create alt chain of same length
1317            self.move_tip(88)
1318            blocks2 = []
1319            for i in range(89, LARGE_REORG_SIZE + 89):
1320                blocks2.append(self.next_block("alt" + str(i)))
1321            self.send_blocks(blocks2, False, force_send=False)
1322
1323            # extend alt chain to trigger re-org
1324            block = self.next_block("alt" + str(chain1_tip + 1))
1325            self.send_blocks([block], True, timeout=2440)
1326
1327            # ... and re-org back to the first chain
1328            self.move_tip(chain1_tip)
1329            block = self.next_block(chain1_tip + 1)
1330            self.send_blocks([block], False, force_send=True)
1331            block = self.next_block(chain1_tip + 2)
1332            self.send_blocks([block], True, timeout=2440)
1333
1334    # Helper methods
1335    ################
1336
1337    def add_transactions_to_block(self, block, tx_list):
1338        block.vtx.extend(tx_list)
1339
1340    # this is a little handier to use than the version in blocktools.py
1341    def create_tx(self, spend_tx, n, value, output_script=None):
1342        if output_script is None:
1343            output_script = CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])
1344        return create_tx_with_script(spend_tx, n, amount=value, output_script=output_script)
1345
1346    # sign a transaction, using the key we know about
1347    # this signs input 0 in tx, which is assumed to be spending output 0 in spend_tx
1348    def sign_tx(self, tx, spend_tx):
1349        scriptPubKey = bytearray(spend_tx.vout[0].scriptPubKey)
1350        if (scriptPubKey[0] == OP_TRUE):  # an anyone-can-spend
1351            tx.vin[0].scriptSig = CScript()
1352            return
1353        sign_input_legacy(tx, 0, spend_tx.vout[0].scriptPubKey, self.coinbase_key)
1354
1355    def create_and_sign_transaction(self, spend_tx, value, output_script=None):
1356        if output_script is None:
1357            output_script = CScript([OP_TRUE])
1358        tx = self.create_tx(spend_tx, 0, value, output_script=output_script)
1359        self.sign_tx(tx, spend_tx)
1360        return tx
1361
1362    def next_block(self, number, spend=None, additional_coinbase_value=0, *, script=None, version=4, additional_output_scripts=None):
1363        if script is None:
1364            script = CScript([OP_TRUE])
1365        if additional_output_scripts is None:
1366            additional_output_scripts = []
1367        if self.tip is None:
1368            base_block_hash = self.genesis_hash
1369            block_time = int(time.time()) + 1
1370        else:
1371            base_block_hash = self.tip.hash_int
1372            block_time = self.tip.nTime + 1
1373        # First create the coinbase
1374        height = self.block_heights[base_block_hash] + 1
1375        coinbase = create_coinbase(height, self.coinbase_pubkey)
1376        coinbase.vout[0].nValue += additional_coinbase_value
1377        for additional_script in additional_output_scripts:
1378            coinbase.vout.append(CTxOut(0, additional_script))
1379        if spend is None:
1380            block = create_block(base_block_hash, coinbase, ntime=block_time, version=version)
1381        else:
1382            coinbase.vout[0].nValue += spend.vout[0].nValue - 1  # all but one satoshi to fees
1383            tx = self.create_tx(spend, 0, 1, output_script=script)  # spend 1 satoshi
1384            self.sign_tx(tx, spend)
1385            block = create_block(base_block_hash, coinbase, ntime=block_time, version=version, txlist=[tx])
1386        # Block is created. Find a valid nonce.
1387        block.solve()
1388        self.tip = block
1389        self.block_heights[block.hash_int] = height
1390        assert number not in self.blocks
1391        self.blocks[number] = block
1392        return block
1393
1394    # save the current tip so it can be spent by a later block
1395    def save_spendable_output(self):
1396        self.log.debug(f"saving spendable output {self.tip.vtx[0]}")
1397        self.spendable_outputs.append(self.tip)
1398
1399    # get an output that we previously marked as spendable
1400    def get_spendable_output(self):
1401        self.log.debug(f"getting spendable output {self.spendable_outputs[0].vtx[0]}")
1402        return self.spendable_outputs.pop(0).vtx[0]
1403
1404    # move the tip back to a previous block
1405    def move_tip(self, number):
1406        self.tip = self.blocks[number]
1407
1408    # adds transactions to the block and updates state
1409    def update_block(self, block_number, new_transactions, *, nTime=None):
1410        block = self.blocks[block_number]
1411        self.add_transactions_to_block(block, new_transactions)
1412        old_hash_int = block.hash_int
1413        if nTime is not None:
1414            block.nTime = nTime
1415        block.hashMerkleRoot = block.calc_merkle_root()
1416        has_witness_tx = any(not tx.wit.is_null() for tx in block.vtx)
1417        if has_witness_tx:
1418            add_witness_commitment(block)
1419        block.solve()
1420        # Update the internal state just like in next_block
1421        self.tip = block
1422        if block.hash_int != old_hash_int:
1423            self.block_heights[block.hash_int] = self.block_heights[old_hash_int]
1424            del self.block_heights[old_hash_int]
1425        self.blocks[block_number] = block
1426        return block
1427
1428    def bootstrap_p2p(self, timeout=10):
1429        """Add a P2P connection to the node.
1430
1431        Helper to connect and wait for version handshake."""
1432        self.helper_peer = self.nodes[0].add_p2p_connection(P2PDataStore())
1433        # We need to wait for the initial getheaders from the peer before we
1434        # start populating our blockstore. If we don't, then we may run ahead
1435        # to the next subtest before we receive the getheaders. We'd then send
1436        # an INV for the next block and receive two getheaders - one for the
1437        # IBD and one for the INV. We'd respond to both and could get
1438        # unexpectedly disconnected if the DoS score for that error is 50.
1439        self.helper_peer.wait_for_getheaders(timeout=timeout)
1440
1441    def reconnect_p2p(self, timeout=60):
1442        """Tear down and bootstrap the P2P connection to the node.
1443
1444        The node gets disconnected several times in this test. This helper
1445        method reconnects the p2p and restarts the network thread."""
1446        self.nodes[0].disconnect_p2ps()
1447        self.bootstrap_p2p(timeout=timeout)
1448
1449    def send_blocks(self, blocks, success=True, reject_reason=None, force_send=False, reconnect=False, timeout=960):
1450        """Sends blocks to test node. Syncs and verifies that tip has advanced to most recent block.
1451
1452        Call with success = False if the tip shouldn't advance to the most recent block."""
1453        self.helper_peer.send_blocks_and_test(blocks, self.nodes[0], success=success, reject_reason=reject_reason, force_send=force_send, timeout=timeout, expect_disconnect=reconnect)
1454
1455        if reconnect:
1456            self.reconnect_p2p(timeout=timeout)
1457
1458
1459if __name__ == '__main__':
1460    FullBlockTest(__file__).main()
1461