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]])