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