def test_complex_methods(self): from pypoptools.pypopminer import MockMiner, PublicationData m = MockMiner() last_known_btc_hash = m.btcTip.getHash() m.mineBtcBlocks(1) endorsed_block = m.vbkTip vbk_pop_tx = m.createVbkPopTxEndorsingVbkBlock(endorsed_block, last_known_btc_hash) self.assertEqual(vbk_pop_tx.publishedBlock.getHash(), endorsed_block.getHash()) self.assertEqual(len(vbk_pop_tx.blockOfProofContext), 1) last_known_vbk_hash = m.vbkTip.getHash() m.mineVbkBlocks(1, [vbk_pop_tx], True) endorsed_block = m.vbkTip vtb = m.endorseVbkBlock(endorsed_block, last_known_btc_hash) self.assertEqual(vtb.transaction.publishedBlock.getHash(), endorsed_block.getHash()) self.assertEqual(len(vtb.transaction.blockOfProofContext), 2) pub_data = PublicationData() pub_data.identifier = 1337 pub_data.header = "0011223344" pub_data.payoutInfo = "0014aaddff" pop_data = m.endorseAltBlock(pub_data, last_known_vbk_hash) self.assertEqual(len(pop_data.atvs), 1) self.assertEqual(len(pop_data.vtbs), 2) self.assertEqual(len(pop_data.context), 2)
def run_test(self): from pypoptools.pypopminer import MockMiner, PublicationData apm = MockMiner() self._assert_nodes_peer_info() vbk_blocks_amount = 100 self.log.info("generate vbk blocks on node0, amount {}".format( vbk_blocks_amount)) vbk_blocks = [] for i in range(vbk_blocks_amount): vbk_blocks.append(apm.mineVbkBlocks(1)) assert len(vbk_blocks) == vbk_blocks_amount vtbs_amount = 20 self.log.info("generate vtbs on node0, amount {}".format(vtbs_amount)) for i in range(vtbs_amount): apm.endorseVbkBlock(apm.vbkTip, apm.btcTip.getHash(), 1) self.nodes[0].generate(nblocks=10) last_block = self.nodes[0].getblockcount() assert last_block >= 5 self.log.info("endorse {} alt block".format(last_block - 5)) endorse_block(self.nodes[0], apm, last_block - 5) self._assert_nodes_peer_info() containing_block_hash = self.nodes[0].generate(nblocks=1)[0] containing_block = self.nodes[0].getblock(containing_block_hash) assert len(containing_block.containingVTBs) == vtbs_amount assert len(containing_block.containingVBKs ) == vbk_blocks_amount + vtbs_amount + 1 assert last_block >= 6 self.log.info("endorse {} alt block".format(last_block - 6)) endorse_block(self.nodes[0], apm, last_block - 6) self._assert_nodes_peer_info() self.nodes[0].generate(nblocks=1) time.sleep(5) self.log.info("sync all nodes") sync_all(self.nodes) self._assert_nodes_peer_info()
def run_test(self): self.sync_all(self.nodes[0:2]) lastblock = self.nodes[0].getblockcount() self.log.info("nodes synced with block height %d", lastblock) from pypoptools.pypopminer import MockMiner self.apm = MockMiner() disconnect_nodes(self.nodes[0], 1) lastblock = self.nodes[1].getblockcount() self.nodes[1].generate(nblocks=1000) self.log.info("node1 disconnected and generating more blocks") self.nodes[1].waitforblockheight(lastblock + 1000) lastblock = self.nodes[1].getblockcount() self.log.info("node1 reached block height %d", lastblock) connect_nodes(self.nodes[0], 1) self.log.info("node1 reconnected") time.sleep(1) # Sleep for 1 second to let headers sync lastblock = self.get_best_block(self.nodes[0]) self.stop_node(0) self.log.info("node0 stopped with block {}".format(lastblock)) self.start_node(0) connect_nodes(self.nodes[0], 1) self.log.info("node0 restarted") self.sync_all(self.nodes[0:2])
def run_test(self): from pypoptools.pypopminer import MockMiner apm = MockMiner() size = 20 # 100 blocks without endorsements self.nodes[0].generate(nblocks=100) self.log.info( "node0 started mining of {} endorsed blocks".format(size)) create_endorsed_chain(self.nodes[0], apm, size) self.log.info( "node0 finished creation of {} endorsed blocks".format(size)) sync_blocks(self.nodes) self.log.info("nodes are in sync") # stop node0 self.nodes[0].restart() self.nodes[1].restart() self.log.info("nodes[0,1] restarted") sync_all(self.nodes, timeout=30) self.log.info("nodes are in sync") best_blocks = [node.getbestblock() for node in self.nodes] pop_data = [ node.getpopdatabyheight(best_blocks[0].height) for node in self.nodes ] # when node0 stops, its VBK/BTC trees get cleared. When we start it again, it MUST load payloads into trees. # if this assert fails, it means that node restarted, but NOT loaded its VBK/BTC state into memory. # node[2] is a control node that has never been shut down. assert pop_data[0] == pop_data[2] assert pop_data[1] == pop_data[2]
def run_test(self): """Main test logic""" from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self.addrs = [x.getnewaddress() for x in self.nodes] self.endorsed_length = 100 assert_pop_state_equal(self.nodes) create_endorsed_chain(self.nodes[0], self.apm, self.endorsed_length, self.addrs[0]) self.sync_all(self.nodes, timeout=20) assert_pop_state_equal(self.nodes) checkblocks = 0 # all blocks # 0, 1, 2, 3, 4 for checklevel in range(5): self.log.info("checkblocks={} checklevel={}".format(checkblocks, checklevel)) self.restart_node(0, extra_args=[ "-checkblocks={}".format(checkblocks), "-checklevel={}".format(checklevel) ]) connect_nodes(self.nodes[0], 1) self.sync_all(self.nodes, timeout=120) assert_pop_state_equal(self.nodes) self.log.info("success")
def run_test(self): """Main test logic""" from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self._cannot_endorse() self.restart_node(0) self._can_endorse()
def run_test(self): """Main test logic""" from pypoptools.pypopminer import MockMiner self.apm = MockMiner() node = self.nodes[0] addr = node.getnewaddress() # stop 1 block behind activation self.log.info("Mining blocks until activation -5 blocks") self.log.info("Current node[0] height {}".format(node.getblockcount())) mine_until_pop_active(node, addr, delta=-5) self.log.info("Current node[0] height {}".format(node.getblockcount())) # check that getblocktemplate does NOT have pop-related fields before POP activation self.log.info("Check that getblocktemplate does not have POP fields") resp = self.getblocktemplate() assert_no_field(resp, 'pop_data') assert_no_field(resp, 'pop_data_root') assert_no_field(resp, 'pop_first_previous_keystone') assert_no_field(resp, 'pop_second_previous_keystone') assert_no_field(resp, 'pop_rewards') self.log.info("Mining blocks until activation +5 blocks") self.log.info("Current node[0] height {}".format(node.getblockcount())) mine_until_pop_active(node, addr, delta=+5) self.log.info("Current node[0] height {}".format(node.getblockcount())) self.log.info("Mine chain of {} consecutive endorsed blocks".format( POP_PAYOUT_DELAY)) create_endorsed_chain(node, self.apm, POP_PAYOUT_DELAY, addr) self.log.info("Current node[0] height {}".format(node.getblockcount())) endorse_block(self.nodes[0], self.apm, node.getblockcount() - 5, addr) self.log.info("Current node[0] height {}".format(node.getblockcount())) self.log.info("Check that getblocktemplate does have POP fields") resp = self.getblocktemplate() is_dict = lambda x: isinstance(x, dict) is_list = lambda x: isinstance(x, list) is_int = lambda x: isinstance(x, int) is_hex = lambda x: bytes.fromhex(x) is_payload = lambda x: is_dict(x) and "id" in x and "serialized" in x is_payload_list = lambda x: is_list(x) and all( is_payload(p) for p in x) assert_field_exists(resp, 'pop_data', type=is_dict) assert_field_exists(resp['pop_data'], 'atvs', type=is_payload_list) assert_field_exists(resp['pop_data'], 'vtbs', type=is_payload_list) assert_field_exists(resp['pop_data'], 'vbkblocks', type=is_payload_list) assert_field_exists(resp['pop_data'], 'version', type=is_int) assert_field_exists(resp, 'pop_data_root', type=is_hex) assert_field_exists(resp, 'pop_first_previous_keystone', type=is_hex) assert_field_exists(resp, 'pop_second_previous_keystone', type=is_hex) assert_field_exists(resp, 'pop_rewards', type=is_list) for reward in resp['pop_rewards']: assert_field_exists(reward, 'amount', type=is_int) assert_field_exists(reward, 'payout_info', type=is_hex) self.log.info("Current node[0] height {}".format(node.getblockcount()))
def run_test(self): """Main test logic""" from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self._invalidate_works() self._reconsider_works()
def run_test(self): """Main test logic""" from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self._find_best_chain_on_unconnected_block() self._find_best_chain_on_filling_gap_block()
def run_test(self): """Main test logic""" from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self.node = self.nodes[0] self.bootstrap_block_exists()
def run_test(self): from pypoptools.pypopminer import MockMiner apm = MockMiner() assert self.nodes[0].getblockcount() == 0 pop_activation_height = self.nodes[0].getpopparams( ).popActivationHeight assert pop_activation_height == 200 # node0 start with 100 blocks self.nodes[0].generate(nblocks=100) wait_for_block_height(self.nodes[0], 100) assert self.nodes[0].getblockcount() == 100 self.log.info("node0 mined 100 blocks") # endorse block 100 (fork A tip) self.log.info( 'Should not accept POP data before activation block height') try: endorse_block(self.nodes[0], apm, 100) assert False except: self.log.info("Endorse block failed as expected") pass self.nodes[0].restart() self.nodes[0].connect(self.nodes[1]) sync_all(self.nodes) self.nodes[1].disconnect(self.nodes[0]) mine_until_pop_enabled(self.nodes[0]) tip_height = self.nodes[0].getblockcount() # endorse block 200 (fork A tip) endorse_block(self.nodes[0], apm, tip_height) self.log.info( "node0 endorsed block {} (fork A tip)".format(tip_height)) # mine pop tx on node0 self.nodes[0].generate(nblocks=1) tip = self.nodes[0].getbestblock() self.log.info("node0 tip is {}".format(tip.height)) self.nodes[1].generate(nblocks=250) tip2 = self.nodes[1].getbestblock() self.log.info("node1 tip is {}".format(tip2.height)) self.nodes[0].connect(self.nodes[1]) sync_all(self.nodes) best_blocks = [node.getbestblock() for node in self.nodes] assert best_blocks[0].hash == best_blocks[1].hash self.log.info("all nodes switched to common block") for i in range(len(best_blocks)): assert best_blocks[i].height == tip.height, \ "node[{}] expected to select shorter chain ({}) with higher pop score\n" \ "but selected longer chain ({})".format(i, tip.height, best_blocks[i].height) self.log.info("all nodes selected fork A as best chain")
def run_test(self): """Main test logic""" self.sync_all(self.nodes) from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self._restart_init_test()
def run_test(self): """Main test logic""" self.sync_all(self.nodes) from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self._case1_endorse_keystone_get_paid()
def run_test(self): """Main test logic""" self.sync_all(self.nodes) from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self._one_by_one() self._check_pop_sync()
def run_test(self): """Main test logic""" self.sync_all(self.nodes[0:4]) from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self._shorter_endorsed_chain_wins() self._4_chains_converge()
def run_test(self): """Main test logic""" self.nodes[0].generate(nblocks=10) self.sync_all(self.nodes) from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self._test_case()
def run_test(self): """Main test logic""" self.nodes[0].generate(nblocks=10) self.sync_all(self.nodes) from pypoptools.pypopminer import MockMiner self.apm = MockMiner() self._run_sync_case() self.restart_node(0) self._run_sync_after_generating()
def run_test(self): from pypoptools.pypopminer import MockMiner apm = MockMiner() self.nodes[0].generate(nblocks=10) sync_all(self.nodes) self.log.info("disconnect nodes 0 and 1") self.nodes[0].disconnect(self.nodes[1]) vbk_blocks_amount = 10 self.log.info("generate {} vbk blocks".format(vbk_blocks_amount)) vbk_blocks = mine_vbk_blocks(self.nodes[0], apm, vbk_blocks_amount) # mine a block on node[0] with these vbk blocks self.nodes[0].generate(nblocks=1) node0_tip = self.nodes[0].getbestblock() assert len(vbk_blocks) == vbk_blocks_amount assert len(node0_tip.containingVBKs) == vbk_blocks_amount assert node0_tip == self.nodes[0].getbestblock() node1_tip = self.nodes[1].getbestblock() assert node1_tip.hash != node0_tip.hash self.log.info("node 1 mine 10 blocks") self.nodes[1].generate(nblocks=10) assert self.nodes[1].getbestblock() != self.nodes[0].getbestblock() self.log.info("node 1 and node 0 have different tips") self.nodes[0].connect(self.nodes[1]) self.log.info("connect node 1 and node 0") sync_all(self.nodes, timeout=60) self.log.info("nodes[0,1] are in sync") assert self.nodes[1].getbestblock() == self.nodes[0].getbestblock() assert len( self.nodes[0].getrawpopmempool().vbkblocks) == vbk_blocks_amount assert len( self.nodes[1].getrawpopmempool().vbkblocks) == vbk_blocks_amount # mine a block on node[1] with these vbk blocks self.nodes[1].generate(nblocks=1) tip = self.nodes[1].getbestblock() assert len(vbk_blocks) == vbk_blocks_amount assert len(tip.containingVBKs) == vbk_blocks_amount
def run_test(self): self.nodes[0].generate(nblocks=10) sync_all(self.nodes) from pypoptools.pypopminer import MockMiner apm = MockMiner() self._test_case_vbk(apm, 113) self._test_case_vbk(apm, 13) self._test_case_vbk(apm, 75) self._test_case_atv(apm, 42) self._test_case_atv(apm, 135) self._test_case_atv(apm, 25)
def run_test(self): from pypoptools.pypopminer import MockMiner apm = MockMiner() keystone_interval = self.nodes[0].getpopparams().keystoneInterval for height in range(self.nodes[0].getblockcount(), 52): self.nodes[0].generate(nblocks=1) # endorse every block wait_for_block_height(self.nodes[2], height) self.log.info("node2 endorsing block {}".format(height)) node2_atv_id = endorse_block(self.nodes[2], apm, height) # endorse each keystone if height % keystone_interval == 0: wait_for_block_height(self.nodes[0], height) self.log.info("node0 endorsing block {}".format(height)) node0_atv_id = endorse_block(self.nodes[0], apm, height) wait_for_block_height(self.nodes[1], height) self.log.info("node1 endorsing block {}".format(height)) node1_atv_id = endorse_block(self.nodes[1], apm, height) # wait until node[1] gets relayed pop tx sync_all(self.nodes, timeout=20) self.log.info("transactions relayed") # mine a block on node[1] with this pop tx self.nodes[1].generate(nblocks=1) containing_block = self.nodes[1].getbestblock() self.log.info("node1 mined containing block={}".format( containing_block.hash)) wait_for_block_height(self.nodes[0], containing_block.height) wait_for_block_height(self.nodes[2], containing_block.height) self.log.info("node0 and node2 got containing block over p2p") # assert that all atv_ids exist in this block for node in self.nodes: block = node.getblock(containing_block_hash) for atv_id in [node0_atv_id, node1_atv_id, node2_atv_id]: assert atv_id in block.containingATVs, \ "containing block {} does not contain ATV {}".format(containing_block_hash, atv_id) # assert that node height matches assert self.nodes[0].getblockcount( ) == self.nodes[1].getblockcount() assert self.nodes[0].getblockcount( ) == self.nodes[2].getblockcount()
def run_test(self): from pypoptools.pypopminer import MockMiner apm = MockMiner() assert self.nodes[0].getblockcount() == 0 activation_height = self.nodes[0].getpopparams().popActivationHeight before_activation_height = activation_height - 50 almost_activation_height = activation_height - 1 after_activation_height = activation_height + 50 # mine before activation height self.nodes[0].generate(nblocks=before_activation_height) assert self.nodes[0].getblockcount() == before_activation_height self.log.info("node mined {} blocks".format(before_activation_height)) # endorse block before activation height try: endorse_block(self.nodes[0], apm, before_activation_height) assert False except Exception as e: assert isinstance(e, JsonRpcException) assert e.error['message'].startswith('POP protocol is not active') self.log.info("node failed endorse block {} as expected".format( before_activation_height)) # mine after activation height self.nodes[0].generate(nblocks=after_activation_height - before_activation_height) assert self.nodes[0].getblockcount() == after_activation_height self.log.info("node mined {} blocks".format(after_activation_height)) # endorse block before activation height endorse_block(self.nodes[0], apm, before_activation_height) self.nodes[0].generate(nblocks=1) self.log.info( "node endorsed block {}".format(before_activation_height)) # endorse block almost activation height endorse_block(self.nodes[0], apm, almost_activation_height) self.nodes[0].generate(nblocks=1) self.log.info( "node endorsed block {}".format(almost_activation_height)) # endorse block after activation height endorse_block(self.nodes[0], apm, after_activation_height) self.nodes[0].generate(nblocks=1) self.log.info("node endorsed block {}".format(after_activation_height))
def run_test(self): from pypoptools.pypopminer import MockMiner self.vbk_block = MockMiner().mineVbkBlocks(1).toVbkEncodingHex() node = self.nodes[0] mock_address = "bcrt1quc5k7w4692g0t0sfxc9xgcc25rzngu55zsfwp0" # height 0 self._check_pop_not_enabled() node.generatetoaddress(nblocks=100, address=mock_address) # height 100 self._check_pop_not_enabled() node.generatetoaddress(nblocks=400, address=mock_address) # height 500 self._check_pop_not_enabled() node.generatetoaddress(nblocks=499, address=mock_address) # height 999 self._check_pop_not_enabled() node.generatetoaddress(nblocks=1, address=mock_address) # height 1000 self._check_pop_enabled() self._check_pop_not_active() node.generatetoaddress(nblocks=100, address=mock_address) # height 1100 self._check_pop_enabled() self._check_pop_not_active() node.generatetoaddress(nblocks=99, address=mock_address) # height 1199 self._check_pop_enabled() self._check_pop_not_active() node.generatetoaddress(nblocks=1, address=mock_address) # height 1200 self._check_pop_enabled() self._check_pop_active()
def run_test(self): """Main test logic""" self.sync_all(self.nodes) from pypoptools.pypopminer import MockMiner self.apm = MockMiner() addr0 = self.nodes[0].getnewaddress() self.log.info("node0 endorses block 5") self.nodes[0].generate(nblocks=10) tipheight = self.nodes[0].getblock( self.nodes[0].getbestblockhash())['height'] atvid = endorse_block(self.nodes[0], self.apm, tipheight - 5, addr0) self.sync_pop_mempools(self.nodes, timeout=60) self.log.info("nodes[0,1] have syncd pop mempools") rawpopmempool1 = self.nodes[1].getrawpopmempool() assert atvid in rawpopmempool1['atvs'] self.log.info("node1 contains atv1 in its pop mempool") self.restart_node(1) self.log.info("node1 has been restarted") rawpopmempool1 = self.nodes[1].getrawpopmempool() assert atvid not in rawpopmempool1['atvs'] self.log.info( "node1 does not contain atv1 in its pop mempool after restart") connect_nodes(self.nodes[0], 1) self.log.info("node1 connect to node0") self.sync_pop_mempools(self.nodes, timeout=60) self.log.info("nodes[0,1] have syncd pop mempools") rawpopmempool1 = self.nodes[1].getrawpopmempool() assert atvid in rawpopmempool1['atvs']
def run_test(self): from pypoptools.pypopminer import MockMiner apm = MockMiner() self.log.info("node0 endorses block 5") self.nodes[0].generate(nblocks=10) tip_height = self.nodes[0].getblockcount() atv_id = endorse_block(self.nodes[0], apm, tip_height - 5) rawpopmempool1 = self.nodes[1].getrawpopmempool() assert atv_id not in rawpopmempool1.atvs self.log.info( "node1 does not contain atv1 in its pop mempool after restart") self.nodes[0].connect(self.nodes[1]) sync_pop_mempools(self.nodes, timeout=20) self.log.info("nodes[0,1] have synced pop mempools") rawpopmempool1 = self.nodes[1].getrawpopmempool() assert atv_id in rawpopmempool1.atvs self.log.info("node1 contains atv1 in its pop mempool") self.nodes[1].restart() self.log.info("node1 has been restarted") rawpopmempool1 = self.nodes[1].getrawpopmempool() assert atv_id not in rawpopmempool1.atvs self.log.info( "node1 does not contain atv1 in its pop mempool after restart") self.nodes[0].connect(self.nodes[1]) self.log.info("node1 connect to node0") sync_pop_mempools(self.nodes, timeout=20) self.log.info("nodes[0,1] have synced pop mempools") rawpopmempool1 = self.nodes[1].getrawpopmempool() assert atv_id in rawpopmempool1.atvs
def run_test(self): from pypoptools.pypopminer import MockMiner apm = MockMiner() mock_address = "bcrt1quc5k7w4692g0t0sfxc9xgcc25rzngu55zsfwp0" self.nodes[0].generatetoaddress(nblocks=900, address=mock_address) assert self.nodes[0].getblockcount() == 900 assert_raises_rpc_error(-1, 'POP protocol is not enabled. Current=900, bootstrap height=1000', endorse_block, self.nodes[0], apm, 800, mock_address) connect_nodes(self.nodes[0], 1) self.sync_blocks() assert self.nodes[1].getblockcount() == 900 assert_raises_rpc_error(-1, 'POP protocol is not enabled. Current=900, bootstrap height=1000', endorse_block, self.nodes[1], apm, 800, mock_address) disconnect_nodes(self.nodes[0], 1) self.nodes[0].generatetoaddress(nblocks=200, address=mock_address) assert self.nodes[0].getblockcount() == 1100 assert_raises_rpc_error(-1, 'POP protocol is not active. Current=1100, activation height=1200', endorse_block, self.nodes[0], apm, 1100, mock_address) connect_nodes(self.nodes[0], 1) self.sync_blocks() assert self.nodes[1].getblockcount() == 1100 assert_raises_rpc_error(-1, 'POP protocol is not active. Current=1100, activation height=1200', endorse_block, self.nodes[1], apm, 1100, mock_address) disconnect_nodes(self.nodes[0], 1) self.nodes[0].generatetoaddress(nblocks=200, address=mock_address) assert self.nodes[0].getblockcount() == 1300 endorse_block(self.nodes[0], apm, 1300, mock_address) connect_nodes(self.nodes[0], 1) self.sync_blocks() assert self.nodes[1].getblockcount() == 1300 endorse_block(self.nodes[1], apm, 1300, mock_address)
def test_mock_miner_can_produce_publications(self): from pypoptools.pypopminer import MockMiner, PublicationData m = MockMiner() self.assertEqual(m.vbkTip.previousBlock, "000000000000000000000000") self.assertEqual(m.vbkTip.height, 0) endorsed = m.mineVbkBlocks(100) self.assertEqual(endorsed.height, 100) m.endorseVbkBlock(endorsed, m.btcTip.getHash()) p = PublicationData() p.identifier = 1337 p.header = "0011223344" p.payoutInfo = "0014aaddff" payloads = m.endorseAltBlock(p, endorsed.getHash()) print(repr(payloads)) self.assertEqual(len(payloads.vtbs), 1) self.assertEqual(m.vbkTip.height, 102)
def run_test(self): from pypoptools.pypopminer import MockMiner apm = MockMiner() self._shorter_endorsed_chain_wins(apm) self._4_chains_converge(apm)
def test_atomic_methods(self): from pypoptools.pypopminer import MockMiner, PublicationData m = MockMiner() last_known_btc_hash = m.btcTip.getHash() last_known_vbk_hash = m.vbkTip.getHash() m.mineBtcBlocks(1) m.mineVbkBlocks(1) endorsed_block = m.vbkTip btc_tx = m.createBtcTxEndorsingVbkBlock(endorsed_block) btc_block_of_proof = m.mineBtcBlocks(1, [btc_tx]) vbk_pop_tx = m.createVbkPopTxEndorsingVbkBlock(btc_block_of_proof, btc_tx, endorsed_block, last_known_btc_hash) self.assertEqual(vbk_pop_tx.publishedBlock.toHex(), endorsed_block.toHex()) self.assertEqual(vbk_pop_tx.bitcoinTransaction.getHash(), btc_tx.getHash()) self.assertEqual(vbk_pop_tx.blockOfProof.getHash(), btc_block_of_proof.getHash()) self.assertEqual(len(vbk_pop_tx.blockOfProofContext), 1) vbk_containing_block = m.mineVbkBlocks(1, [vbk_pop_tx], True) vtb = m.createVTB(vbk_containing_block, vbk_pop_tx) self.assertEqual(vtb.transaction.getHash(), vbk_pop_tx.getHash()) self.assertEqual(vtb.containingBlock.getHash(), vbk_containing_block.getHash()) pub_data = PublicationData() pub_data.identifier = 1337 pub_data.header = "0011223344" pub_data.payoutInfo = "0014aaddff" vbk_tx = m.createVbkTxEndorsingAltBlock(pub_data) vbk_block_of_proof = m.mineVbkBlocks(1, [vbk_tx], False) atv = m.createATV(vbk_block_of_proof, vbk_tx) self.assertEqual(atv.transaction.getHash(), vbk_tx.getHash()) self.assertEqual(atv.blockOfProof.getHash(), vbk_block_of_proof.getHash()) pop_data = m.createPopDataEndorsingAltBlock(vbk_block_of_proof, vbk_tx, last_known_vbk_hash) self.assertEqual(len(pop_data.atvs), 1) self.assertEqual(len(pop_data.vtbs), 1) self.assertEqual(len(pop_data.context), 2)
def test_entities_default_constructible(self): from pypoptools.pypopminer import MockMiner, PublicationData, BtcBlock, VbkBlock a = MockMiner() b = PublicationData() c = BtcBlock() d = VbkBlock()
def main(): parser = argparse.ArgumentParser(prog=os.path.basename(sys.argv[0]), usage='python3 %(prog)s [options]') parser.add_argument( '--alt-blocks', type=int, default=10, nargs='?', help='Maximum blocks to generate in ALT blockchain (default: 10)') parser.add_argument( '--vbk-blocks', type=int, default=10, nargs='?', help='Maximum blocks to generate in VBK blockchain (default: 10)') parser.add_argument( '--btc-blocks', type=int, default=10, nargs='?', help='Maximum blocks to generate in BTC blockchain (default: 10)') parser.add_argument( '--atvs', type=int, default=10, nargs='?', help='Maximum ATVs to endorse ALT blockchain (default: 10)') parser.add_argument( '--vtbs', type=int, default=10, nargs='?', help='Maximum VTBs to endorse VBK blockchain (default: 10)') parser.add_argument('--timeout', type=int, default=60, nargs='?', help='Maximum execution time in seconds (default: 60)') parser.add_argument( '--seed', type=int, nargs='?', help='Seed to instantiate random generator (default: random)') args = parser.parse_args() seed = args.seed or random.randrange(0, 2**32) print('Configuration:') print('- Max ALT blocks: {}'.format(args.alt_blocks)) print('- Max VBK blocks: {}'.format(args.vbk_blocks)) print('- Max BTC blocks: {}'.format(args.btc_blocks)) print('- Max VTBs: {}'.format(args.vtbs)) print('- Max ATVs: {}'.format(args.vtbs)) print('- Timeout: {} secs'.format(args.timeout)) print('- Seed: {}'.format(seed)) datadir = tempfile.mkdtemp() node = VBitcoindNode(0, pathlib.Path(datadir)) print('Node logs available at {}'.format(datadir)) mock_miner = MockMiner() try: print('Load test started') node.start() mine_until_pop_enabled(node) start = time.time() generate_endorsed(node, mock_miner, alt_blocks=args.alt_blocks, vbk_blocks=args.vbk_blocks, btc_blocks=args.btc_blocks, vtbs=args.vtbs, atvs=args.vtbs, seed=seed, timeout=args.timeout) elapsed = time.time() - start print('Load test finished in {:.3f} sec'.format(elapsed)) except Exception: print(traceback.format_exc()) print('Load test failed') finally: node.stop()