def get_tests(self):
self.tip = int ("0x" + self.nodes[0].getbestblockhash() + "l", 0)
self.block_time = 1333230000 # before the bip16 switchover
'''
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()
self.tip = block.sha256
yield testinstance(objects=[[block, true]])
'''
build out to 100 blocks total, maturing the coinbase.
'''
test = testinstance(objects=[], sync_every_block=false, sync_every_tx=false)
for i in xrange(100):
b = create_block(self.tip, create_coinbase(), self.block_time)
b.solve()
test.blocks_and_transactions.append([b, true])
self.tip = b.sha256
self.block_time += 1
yield test
''' iterate through script tests. '''
counter = 0
for script_test in self.scripts.get_records():
''' reset the blockchain to genesis block + 100 blocks. '''
if self.nodes[0].getblockcount() > 101:
self.nodes[0].invalidateblock(self.nodes[0].getblockhash(102))
self.nodes[1].invalidateblock(self.nodes[1].getblockhash(102))
self.tip = int ("0x" + self.nodes[0].getbestblockhash() + "l", 0)
[scriptsig, scriptpubkey, flags] = script_test[0:3]
flags = parsescriptflags(flags)
# we can use block time to determine whether the nodes should be
# enforcing bip16.
#
# we intentionally let the block time grow by 1 each time.
# this forces the block hashes to differ between tests, so that
# a call to invalidateblock doesn't interfere with a later test.
if (flags & script_verify_p2sh):
self.block_time = 1333238400 + counter # advance to enforcing bip16
else:
self.block_time = 1333230000 + counter # before the bip16 switchover
print "script test: [%s]" % script_test
yield self.generate_test_instance(scriptpubkey, scriptsig)
counter += 1
def generate_test_instance(self, pubkeystring, scriptsigstring):
scriptpubkey = parsescript(pubkeystring)
scriptsig = parsescript(scriptsigstring)
test = testinstance(sync_every_block=false)
test_build = testbuilder()
test_build.create_credit_tx(scriptpubkey)
test_build.create_spend_tx(scriptsig)
test_build.rehash()
block = create_block(self.tip, test_build.tx1, self.block_time)
self.block_time += 1
block.solve()
self.tip = block.sha256
test.blocks_and_transactions = [[block, true]]
for i in xrange(100):
block = create_block(self.tip, create_coinbase(), self.block_time)
self.block_time += 1
block.solve()
self.tip = block.sha256
test.blocks_and_transactions.append([block, true])
block = create_block(self.tip, create_coinbase(), self.block_time)
self.block_time += 1
block.vtx.append(test_build.tx2)
block.hashmerkleroot = block.calc_merkle_root()
block.rehash()
block.solve()
test.blocks_and_transactions.append([block, none])
return test
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]])
def get_tests(self):
self.coinbase_blocks = self.nodes[0].generate(2)
self.tip = int("0x" + self.nodes[0].getbestblockhash() + "l", 0)
self.nodeaddress = self.nodes[0].getnewaddress()
self.last_block_time = time.time()
""" 98 more version 2 blocks """
test_blocks = []
for i in xrange(98):
block = create_block(self.tip, create_coinbase(2), self.last_block_time + 1)
block.nversion = 2
block.rehash()
block.solve()
test_blocks.append([block, true])
self.last_block_time += 1
self.tip = block.sha256
yield testinstance(test_blocks, sync_every_block=false)
""" mine 749 version 3 blocks """
test_blocks = []
for i in xrange(749):
block = create_block(self.tip, create_coinbase(2), self.last_block_time + 1)
block.nversion = 3
block.rehash()
block.solve()
test_blocks.append([block, true])
self.last_block_time += 1
self.tip = block.sha256
yield testinstance(test_blocks, sync_every_block=false)
"""
check that the new dersig rules are not enforced in the 750th
version 3 block.
"""
spendtx = self.create_transaction(self.nodes[0], self.coinbase_blocks[0], self.nodeaddress, 1.0)
underify(spendtx)
spendtx.rehash()
block = create_block(self.tip, create_coinbase(2), self.last_block_time + 1)
block.nversion = 3
block.vtx.append(spendtx)
block.hashmerkleroot = block.calc_merkle_root()
block.rehash()
block.solve()
self.last_block_time += 1
self.tip = block.sha256
yield testinstance([[block, true]])
"""
check that the new dersig rules are enforced in the 751st version 3
block.
"""
spendtx = self.create_transaction(self.nodes[0], self.coinbase_blocks[1], self.nodeaddress, 1.0)
underify(spendtx)
spendtx.rehash()
block = create_block(self.tip, create_coinbase(1), self.last_block_time + 1)
block.nversion = 3
block.vtx.append(spendtx)
block.hashmerkleroot = block.calc_merkle_root()
block.rehash()
block.solve()
self.last_block_time += 1
yield testinstance([[block, false]])
""" mine 199 new version blocks on last valid tip """
test_blocks = []
for i in xrange(199):
block = create_block(self.tip, create_coinbase(1), self.last_block_time + 1)
block.nversion = 3
block.rehash()
block.solve()
test_blocks.append([block, true])
self.last_block_time += 1
self.tip = block.sha256
yield testinstance(test_blocks, sync_every_block=false)
""" mine 1 old version block """
block = create_block(self.tip, create_coinbase(1), self.last_block_time + 1)
block.nversion = 2
block.rehash()
block.solve()
self.last_block_time += 1
self.tip = block.sha256
yield testinstance([[block, true]])
""" mine 1 new version block """
block = create_block(self.tip, create_coinbase(1), self.last_block_time + 1)
block.nversion = 3
block.rehash()
block.solve()
self.last_block_time += 1
self.tip = block.sha256
yield testinstance([[block, true]])
""" mine 1 old version block, should be invalid """
block = create_block(self.tip, create_coinbase(1), self.last_block_time + 1)
block.nversion = 2
block.rehash()
block.solve()
self.last_block_time += 1
yield testinstance([[block, false]])
