mirror of
https://github.com/dashpay/dash.git
synced 2024-12-29 05:49:11 +01:00
b93974c3f3
comptool.py creates a tool for running a test suite on top of the mininode p2p framework. It supports two types of tests: those for which we expect certain behavior (acceptance or rejection of a block or transaction) and those for which we are just comparing that the behavior of 2 or more nodes is the same. blockstore.py defines BlockStore and TxStore, which provide db-backed maps between block/tx hashes and the corresponding block or tx. blocktools.py defines utility functions for creating and manipulating blocks and transactions. invalidblockrequest.py is an example test in the comptool framework, which tests the behavior of a single node when sent two different types of invalid blocks (a block with a duplicated transaction and a block with a bad coinbase value).
116 lines
3.9 KiB
Python
Executable File
116 lines
3.9 KiB
Python
Executable File
#!/usr/bin/env python2
|
|
#
|
|
# Distributed under the MIT/X11 software license, see the accompanying
|
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
#
|
|
|
|
from test_framework import ComparisonTestFramework
|
|
from util import *
|
|
from comptool import TestManager, TestInstance
|
|
from mininode import *
|
|
from blocktools import *
|
|
import logging
|
|
import copy
|
|
import time
|
|
|
|
|
|
'''
|
|
In this test we connect to one node over p2p, and test block requests:
|
|
1) Valid blocks should be requested and become chain tip.
|
|
2) Invalid block with duplicated transaction should be re-requested.
|
|
3) Invalid block with bad coinbase value should be rejected and not
|
|
re-requested.
|
|
'''
|
|
|
|
# Use the ComparisonTestFramework with 1 node: only use --testbinary.
|
|
class InvalidBlockRequestTest(ComparisonTestFramework):
|
|
|
|
''' Can either run this test as 1 node with expected answers, or two and compare them.
|
|
Change the "outcome" variable from each TestInstance object to only do the comparison. '''
|
|
def __init__(self):
|
|
self.num_nodes = 1
|
|
|
|
def run_test(self):
|
|
test = TestManager(self, self.options.tmpdir)
|
|
test.add_all_connections(self.nodes)
|
|
self.tip = None
|
|
self.block_time = None
|
|
NetworkThread().start() # Start up network handling in another thread
|
|
test.run()
|
|
|
|
def get_tests(self):
|
|
if self.tip is None:
|
|
self.tip = int ("0x" + self.nodes[0].getbestblockhash() + "L", 0)
|
|
self.block_time = int(time.time())+1
|
|
|
|
'''
|
|
Create a new block with an anyone-can-spend coinbase
|
|
'''
|
|
block = create_block(self.tip, create_coinbase(), self.block_time)
|
|
self.block_time += 1
|
|
block.solve()
|
|
# Save the coinbase for later
|
|
self.block1 = block
|
|
self.tip = block.sha256
|
|
yield TestInstance([[block, True]])
|
|
|
|
'''
|
|
Now we need that block to mature so we can spend the coinbase.
|
|
'''
|
|
test = TestInstance(sync_every_block=False)
|
|
for i in xrange(100):
|
|
block = create_block(self.tip, create_coinbase(), self.block_time)
|
|
block.solve()
|
|
self.tip = block.sha256
|
|
self.block_time += 1
|
|
test.blocks_and_transactions.append([block, True])
|
|
yield test
|
|
|
|
'''
|
|
Now we use merkle-root malleability to generate an invalid block with
|
|
same blockheader.
|
|
Manufacture a block with 3 transactions (coinbase, spend of prior
|
|
coinbase, spend of that spend). Duplicate the 3rd transaction to
|
|
leave merkle root and blockheader unchanged but invalidate the block.
|
|
'''
|
|
block2 = create_block(self.tip, create_coinbase(), self.block_time)
|
|
self.block_time += 1
|
|
|
|
# chr(81) is OP_TRUE
|
|
tx1 = create_transaction(self.block1.vtx[0], 0, chr(81), 50*100000000)
|
|
tx2 = create_transaction(tx1, 0, chr(81), 50*100000000)
|
|
|
|
block2.vtx.extend([tx1, tx2])
|
|
block2.hashMerkleRoot = block2.calc_merkle_root()
|
|
block2.rehash()
|
|
block2.solve()
|
|
orig_hash = block2.sha256
|
|
block2_orig = copy.deepcopy(block2)
|
|
|
|
# Mutate block 2
|
|
block2.vtx.append(tx2)
|
|
assert_equal(block2.hashMerkleRoot, block2.calc_merkle_root())
|
|
assert_equal(orig_hash, block2.rehash())
|
|
assert(block2_orig.vtx != block2.vtx)
|
|
|
|
self.tip = block2.sha256
|
|
yield TestInstance([[block2, False], [block2_orig, True]])
|
|
|
|
'''
|
|
Make sure that a totally screwed up block is not valid.
|
|
'''
|
|
block3 = create_block(self.tip, create_coinbase(), self.block_time)
|
|
self.block_time += 1
|
|
block3.vtx[0].vout[0].nValue = 100*100000000 # Too high!
|
|
block3.vtx[0].sha256=None
|
|
block3.vtx[0].calc_sha256()
|
|
block3.hashMerkleRoot = block3.calc_merkle_root()
|
|
block3.rehash()
|
|
block3.solve()
|
|
|
|
yield TestInstance([[block3, False]])
|
|
|
|
|
|
if __name__ == '__main__':
|
|
InvalidBlockRequestTest().main()
|