def setUp(self):
self.ctx = zmq.asyncio.Context()
self.w = Wallet()
masternodes = [
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
]
delegates = [
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
]
self.c = ContractingClient()
self.c.flush()
sync.submit_from_genesis_json_file(cilantro_ee.contracts.__path__[0] +
'/genesis.json',
client=self.c)
sync.submit_node_election_contracts(initial_masternodes=masternodes,
boot_mns=1,
initial_delegates=delegates,
boot_dels=1,
client=self.c)
self.s = SocketAuthenticator(ctx=self.ctx)
def setUp(self):
self.wallet = Wallet()
# Wallets for VKs
self.test_wallet_1 = Wallet()
self.test_wallet_2 = Wallet()
self.peer_table = {
self.test_wallet_1.verifying_key().hex(): 'ipc:///tmp/n1',
self.test_wallet_2.verifying_key().hex(): 'ipc:///tmp/n2',
}
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
self.contacts = MockContacts(
masters=[self.test_wallet_1.verifying_key().hex()],
delegates=[self.test_wallet_2.verifying_key().hex()])
self.paramaters = Parameters(socket_base='tcp://127.0.0.1',
wallet=self.wallet,
ctx=self.ctx,
contacts=self.contacts)
self.authenticator = SocketAuthenticator(wallet=self.wallet,
contacts=self.contacts,
ctx=self.ctx)
asyncio.set_event_loop(self.loop)
class TestPeers(TestCase):
def setUp(self):
self.wallet = Wallet()
# Wallets for VKs
self.test_wallet_1 = Wallet()
self.test_wallet_2 = Wallet()
self.peer_table = {
self.test_wallet_1.verifying_key().hex(): 'ipc:///tmp/n1',
self.test_wallet_2.verifying_key().hex(): 'ipc:///tmp/n2',
}
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
self.contacts = MockContacts(
masters=[self.test_wallet_1.verifying_key().hex()],
delegates=[self.test_wallet_2.verifying_key().hex()])
self.paramaters = Parameters(socket_base='tcp://127.0.0.1',
wallet=self.wallet,
ctx=self.ctx,
contacts=self.contacts)
self.authenticator = SocketAuthenticator(wallet=self.wallet,
contacts=self.contacts,
ctx=self.ctx)
asyncio.set_event_loop(self.loop)
def tearDown(self):
self.ctx.destroy()
self.loop.close()
def testInit(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=DEL,
service_type=ServiceType.INCOMING_WORK)
def test_connect_test_wallet(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=DEL,
service_type=ServiceType.INCOMING_WORK)
self.authenticator.sync_certs()
p.connect(SocketStruct.from_string('ipc:///tmp/n1'),
self.test_wallet_1.verifying_key().hex())
socket = p.sockets.get(self.test_wallet_1.verifying_key().hex())
self.assertIsNotNone(socket)
def test_connect_twice_doesnt_modify_socket_object(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=DEL,
service_type=ServiceType.INCOMING_WORK)
self.authenticator.sync_certs()
p.connect(SocketStruct.from_string('ipc:///tmp/n1'),
self.test_wallet_1.verifying_key().hex())
socket = p.sockets.get(self.test_wallet_1.verifying_key().hex())
self.assertIsNotNone(socket)
p.connect(SocketStruct.from_string('ipc:///tmp/n1'),
self.test_wallet_1.verifying_key().hex())
socket2 = p.sockets.get(self.test_wallet_1.verifying_key().hex())
self.assertEqual(socket, socket2)
def test_sync_adds_two_sockets_from_network_peer_table(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=ALL,
service_type=ServiceType.INCOMING_WORK)
self.authenticator.sync_certs()
async def late_refresh():
await asyncio.sleep(0.3)
await self.paramaters.refresh()
p.sync_sockets()
async def stop():
await asyncio.sleep(0.5)
p1.stop()
tasks = asyncio.gather(p1.start(discover=False), late_refresh(),
stop())
self.loop.run_until_complete(tasks)
socket_1 = p.sockets.get(self.test_wallet_1.verifying_key().hex())
socket_2 = p.sockets.get(self.test_wallet_2.verifying_key().hex())
self.assertIsNotNone(socket_1)
self.assertIsNotNone(socket_2)
def test_sync_adds_del_if_peers_del(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=DEL,
service_type=ServiceType.INCOMING_WORK)
self.authenticator.sync_certs()
async def late_refresh():
await asyncio.sleep(0.3)
await self.paramaters.refresh()
p.sync_sockets()
async def stop():
await asyncio.sleep(0.5)
p1.stop()
tasks = asyncio.gather(p1.start(discover=False), late_refresh(),
stop())
self.loop.run_until_complete(tasks)
socket_2 = p.sockets.get(self.test_wallet_2.verifying_key().hex())
self.assertIsNotNone(socket_2)
def test_sync_adds_del_if_peers_mn(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=MN,
service_type=ServiceType.INCOMING_WORK)
self.authenticator.sync_certs()
async def late_refresh():
await asyncio.sleep(0.3)
await self.paramaters.refresh()
p.sync_sockets()
async def stop():
await asyncio.sleep(0.5)
p1.stop()
tasks = asyncio.gather(p1.start(discover=False), late_refresh(),
stop())
self.loop.run_until_complete(tasks)
socket_1 = p.sockets.get(self.test_wallet_1.verifying_key().hex())
self.assertIsNotNone(socket_1)
def test_resync_adds_new_contacts(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=MN,
service_type=ServiceType.INCOMING_WORK)
self.authenticator.sync_certs()
async def late_refresh():
await asyncio.sleep(0.3)
await self.paramaters.refresh()
p.sync_sockets()
async def stop():
await asyncio.sleep(0.5)
p1.stop()
tasks = asyncio.gather(p1.start(discover=False), late_refresh(),
stop())
self.loop.run_until_complete(tasks)
socket_1 = p.sockets.get(self.test_wallet_1.verifying_key().hex())
self.assertIsNotNone(socket_1)
new_wallet = Wallet()
p1.peer_service.table[
new_wallet.verifying_key().hex()] = 'ipc:///tmp/n3'
self.contacts.masternodes.append(new_wallet.verifying_key().hex())
self.authenticator.sync_certs()
async def late_refresh():
await asyncio.sleep(0.3)
await self.paramaters.refresh()
p.sync_sockets()
async def stop():
await asyncio.sleep(0.5)
p1.stop()
tasks = asyncio.gather(p1.start(discover=False), late_refresh(),
stop())
self.loop.run_until_complete(tasks)
socket_1 = p.sockets.get(new_wallet.verifying_key().hex())
self.assertIsNotNone(socket_1)
def test_resync_removes_old_contact(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
new_wallet = Wallet()
p1.peer_service.table[
new_wallet.verifying_key().hex()] = 'ipc:///tmp/n3'
self.contacts.masternodes.append(new_wallet.verifying_key().hex())
self.authenticator.sync_certs()
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=MN,
service_type=ServiceType.INCOMING_WORK)
async def late_refresh():
await asyncio.sleep(0.3)
await self.paramaters.refresh()
p.sync_sockets()
async def stop():
await asyncio.sleep(0.5)
p1.stop()
tasks = asyncio.gather(p1.start(discover=False), late_refresh(),
stop())
self.loop.run_until_complete(tasks)
socket_1 = p.sockets.get(new_wallet.verifying_key().hex())
self.assertIsNotNone(socket_1)
del p1.peer_service.table[new_wallet.verifying_key().hex()]
self.contacts.masternodes.remove(new_wallet.verifying_key().hex())
self.authenticator.sync_certs()
async def late_refresh():
await asyncio.sleep(0.3)
await self.paramaters.refresh()
p.sync_sockets()
async def stop():
await asyncio.sleep(0.5)
p1.stop()
tasks = asyncio.gather(p1.start(discover=False), late_refresh(),
stop())
self.loop.run_until_complete(tasks)
socket_1 = p.sockets.get(new_wallet.verifying_key().hex())
self.assertIsNone(socket_1)
def test_double_init(self):
w = Wallet()
with self.assertRaises(Exception):
b = SocketAuthenticator(ctx=self.ctx)
class TestAuthenticator(TestCase):
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.w = Wallet()
masternodes = [
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
]
delegates = [
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
]
self.c = ContractingClient()
self.c.flush()
sync.submit_from_genesis_json_file(cilantro_ee.contracts.__path__[0] +
'/genesis.json',
client=self.c)
sync.submit_node_election_contracts(initial_masternodes=masternodes,
boot_mns=1,
initial_delegates=delegates,
boot_dels=1,
client=self.c)
self.s = SocketAuthenticator(ctx=self.ctx)
def tearDown(self):
self.ctx.destroy()
self.c.flush()
def test_double_init(self):
w = Wallet()
with self.assertRaises(Exception):
b = SocketAuthenticator(ctx=self.ctx)
def test_add_verifying_key_as_bytes(self):
sk = SigningKey.generate()
self.s.add_verifying_key(sk.verify_key.encode())
self.assertTrue(
os.path.exists(
os.path.join(self.s.cert_dir,
f'{sk.verify_key.encode().hex()}.key')))
def test_sync_certs_creates_files(self):
self.s.sync_certs()
for m in self.s.contacts.masternodes:
self.assertTrue(
os.path.exists(os.path.join(self.s.cert_dir, f'{m}.key')))
for d in self.s.contacts.delegates:
self.assertTrue(
os.path.exists(os.path.join(self.s.cert_dir, f'{d}.key')))
def test_add_governance_sockets_all_creates_files(self):
fake_mns = [
Wallet().verifying_key(),
Wallet().verifying_key(),
Wallet().verifying_key()
]
fake_od_m = Wallet().verifying_key()
fake_dels = [Wallet().verifying_key(), Wallet().verifying_key()]
fake_od_d = Wallet().verifying_key()
self.s.add_governance_sockets(masternode_list=fake_mns,
on_deck_masternode=fake_od_m,
delegate_list=fake_dels,
on_deck_delegate=fake_od_d)
for m in fake_mns:
self.assertTrue(
os.path.exists(os.path.join(self.s.cert_dir,
f'{m.hex()}.key')))
for d in fake_dels:
self.assertTrue(
os.path.exists(os.path.join(self.s.cert_dir,
f'{d.hex()}.key')))
self.assertTrue(
os.path.exists(
os.path.join(self.s.cert_dir, f'{fake_od_m.hex()}.key')))
self.assertTrue(
os.path.exists(
os.path.join(self.s.cert_dir, f'{fake_od_d.hex()}.key')))
def __init__(self,
socket_base,
ctx: zmq.asyncio.Context,
wallet,
constitution: dict,
overwrite=False,
bootnodes=[],
network_parameters=NetworkParameters(),
driver=BlockchainDriver(),
mn_seed=None,
debug=True,
store=False):
self.driver = driver
self.store = store
self.blocks = None
if self.store:
self.blocks = MasterStorage()
self.waiting_for_confirmation = False
self.log = get_logger('NODE')
self.log.propagate = debug
self.log.info(constitution)
self.socket_base = socket_base
self.wallet = wallet
self.ctx = ctx
self.ctx.max_sockets = 50_000
self.client = ContractingClient(
driver=self.driver,
submission_filename=cilantro_ee.contracts.__path__[0] +
'/submission.s.py')
# Sync contracts
sync.submit_from_genesis_json_file(cilantro_ee.contracts.__path__[0] +
'/genesis.json',
client=self.client)
sync.submit_node_election_contracts(
initial_masternodes=constitution['masternodes'],
boot_mns=constitution['masternode_min_quorum'],
initial_delegates=constitution['delegates'],
boot_dels=constitution['delegate_min_quorum'],
client=self.client)
self.driver.commit()
self.driver.clear_pending_state()
self.contacts = VKBook(
client=self.client,
boot_mn=constitution['masternode_min_quorum'],
boot_del=constitution['delegate_min_quorum'],
)
self.current_masters = deepcopy(self.contacts.masternodes)
self.current_delegates = deepcopy(self.contacts.delegates)
self.parameters = Parameters(socket_base,
ctx,
wallet,
contacts=self.contacts)
self.socket_authenticator = SocketAuthenticator(ctx=self.ctx)
self.elect_masternodes = self.client.get_contract('elect_masternodes')
self.elect_delegates = self.client.get_contract('elect_delegates')
self.masternode_contract = self.client.get_contract('masternodes')
self.delegate_contract = self.client.get_contract('delegates')
self.update_sockets()
# Cilantro version / upgrade
self.version_state = self.client.get_contract('upgrade')
self.active_upgrade = self.version_state.quick_read('upg_lock')
self.tol_mn = self.version_state.quick_read('tol_mn')
self.tot_dl = self.version_state.quick_read('tot_dl')
if self.tol_mn is None:
self.tol_mn = 0
if self.tot_dl is None:
self.tot_dl = 0
self.all_votes = self.tol_mn + self.tot_dl
self.mn_votes = self.version_state.quick_read('mn_vote')
self.dl_votes = self.version_state.quick_read('dl_vote')
# self.pending_cnt = self.all_votes - self.vote_cnt
# stuff
self.network_parameters = network_parameters
self.bootnodes = bootnodes
self.constitution = constitution
self.overwrite = overwrite
# Should have a function to get the current NBN
self.block_fetcher = BlockFetcher(
wallet=self.wallet,
ctx=self.ctx,
parameters=self.parameters,
)
self.network = Network(
wallet=self.wallet,
ctx=self.ctx,
socket_base=socket_base,
bootnodes=self.bootnodes,
params=self.network_parameters,
initial_del_quorum=deepcopy(self.contacts.delegate_quorum_min),
initial_mn_quorum=deepcopy(self.contacts.masternode_quorum_min),
mn_to_find=deepcopy(self.contacts.masternodes),
del_to_find=deepcopy(self.contacts.delegates),
mn_seed=mn_seed)
self.nbn_inbox = NBNInbox(socket_id=self.network_parameters.resolve(
self.socket_base,
service_type=ServiceType.BLOCK_NOTIFICATIONS,
bind=True),
ctx=self.ctx,
driver=self.driver,
contacts=self.contacts,
wallet=wallet)
self.reward_manager = RewardManager(driver=self.driver, debug=True)
self.running = False
class Node:
def __init__(self,
socket_base,
ctx: zmq.asyncio.Context,
wallet,
constitution: dict,
overwrite=False,
bootnodes=[],
network_parameters=NetworkParameters(),
driver=BlockchainDriver(),
mn_seed=None,
debug=True,
store=False):
self.driver = driver
self.store = store
self.blocks = None
if self.store:
self.blocks = MasterStorage()
self.waiting_for_confirmation = False
self.log = get_logger('NODE')
self.log.propagate = debug
self.log.info(constitution)
self.socket_base = socket_base
self.wallet = wallet
self.ctx = ctx
self.ctx.max_sockets = 50_000
self.client = ContractingClient(
driver=self.driver,
submission_filename=cilantro_ee.contracts.__path__[0] +
'/submission.s.py')
# Sync contracts
sync.submit_from_genesis_json_file(cilantro_ee.contracts.__path__[0] +
'/genesis.json',
client=self.client)
sync.submit_node_election_contracts(
initial_masternodes=constitution['masternodes'],
boot_mns=constitution['masternode_min_quorum'],
initial_delegates=constitution['delegates'],
boot_dels=constitution['delegate_min_quorum'],
client=self.client)
self.driver.commit()
self.driver.clear_pending_state()
self.contacts = VKBook(
client=self.client,
boot_mn=constitution['masternode_min_quorum'],
boot_del=constitution['delegate_min_quorum'],
)
self.current_masters = deepcopy(self.contacts.masternodes)
self.current_delegates = deepcopy(self.contacts.delegates)
self.parameters = Parameters(socket_base,
ctx,
wallet,
contacts=self.contacts)
self.socket_authenticator = SocketAuthenticator(ctx=self.ctx)
self.elect_masternodes = self.client.get_contract('elect_masternodes')
self.elect_delegates = self.client.get_contract('elect_delegates')
self.masternode_contract = self.client.get_contract('masternodes')
self.delegate_contract = self.client.get_contract('delegates')
self.update_sockets()
# Cilantro version / upgrade
self.version_state = self.client.get_contract('upgrade')
self.active_upgrade = self.version_state.quick_read('upg_lock')
self.tol_mn = self.version_state.quick_read('tol_mn')
self.tot_dl = self.version_state.quick_read('tot_dl')
if self.tol_mn is None:
self.tol_mn = 0
if self.tot_dl is None:
self.tot_dl = 0
self.all_votes = self.tol_mn + self.tot_dl
self.mn_votes = self.version_state.quick_read('mn_vote')
self.dl_votes = self.version_state.quick_read('dl_vote')
# self.pending_cnt = self.all_votes - self.vote_cnt
# stuff
self.network_parameters = network_parameters
self.bootnodes = bootnodes
self.constitution = constitution
self.overwrite = overwrite
# Should have a function to get the current NBN
self.block_fetcher = BlockFetcher(
wallet=self.wallet,
ctx=self.ctx,
parameters=self.parameters,
)
self.network = Network(
wallet=self.wallet,
ctx=self.ctx,
socket_base=socket_base,
bootnodes=self.bootnodes,
params=self.network_parameters,
initial_del_quorum=deepcopy(self.contacts.delegate_quorum_min),
initial_mn_quorum=deepcopy(self.contacts.masternode_quorum_min),
mn_to_find=deepcopy(self.contacts.masternodes),
del_to_find=deepcopy(self.contacts.delegates),
mn_seed=mn_seed)
self.nbn_inbox = NBNInbox(socket_id=self.network_parameters.resolve(
self.socket_base,
service_type=ServiceType.BLOCK_NOTIFICATIONS,
bind=True),
ctx=self.ctx,
driver=self.driver,
contacts=self.contacts,
wallet=wallet)
self.reward_manager = RewardManager(driver=self.driver, debug=True)
self.running = False
async def catchup(self, mn_seed):
current = self.driver.get_latest_block_num()
latest = await self.block_fetcher.get_latest_block_height(mn_seed)
if current == 0:
current = 1
for i in range(current, latest):
block = await self.block_fetcher.get_block_from_master(i, mn_seed)
block = block.to_dict()
self.process_block(block)
while len(self.nbn_inbox.q) > 0:
block = self.nbn_inbox.q.pop(0)
self.process_block(block)
def should_process(self, block):
if self.waiting_for_confirmation:
return self.driver.latest_block_num <= block['blockNum'] and block[
'hash'] != 'f' * 64
else:
return self.driver.latest_block_num < block['blockNum'] and block[
'hash'] != 'f' * 64
def process_block(self, block):
# self.driver.reads.clear()
# self.driver.cache.clear()
#
# self.log.info(f'PENDING WRITES :{self.driver.pending_writes}')
# self.driver.pending_writes.clear()
if self.should_process(block):
self.log.info('Processing new block...')
self.driver.update_with_block(block)
self.reward_manager.issue_rewards(block=block)
self.update_sockets()
if self.store:
self.blocks.store_block(block)
#self.reward_manager.issue_rewards(block=block)
#self.update_sockets()
else:
self.log.error('Could not store block...')
if self.driver.latest_block_num >= block['blockNum']:
self.log.error(
f'Latest block num = {self.driver.latest_block_num}')
self.log.error(f'New block num = {block["blockNum"]}')
if block['hash'] == 'f' * 64:
self.log.error(f'Block hash = {block["hash"]}')
self.driver.delete_pending_nonces()
self.driver.cache.clear()
self.nbn_inbox.clean()
self.nbn_inbox.update_signers()
self.version_check()
async def start(self):
await self.network.start()
# Start block server
asyncio.ensure_future(self.nbn_inbox.serve())
# Catchup when joining the network
if self.network.mn_seed is not None:
await self.catchup(
self.network_parameters.resolve(self.network.mn_seed,
ServiceType.BLOCK_SERVER))
self.log.info(self.network.peers())
self.parameters.sockets.update(self.network.peers())
# Start block server
#asyncio.ensure_future(self.nbn_inbox.serve())
self.running = True
def stop(self):
self.network.stop()
self.nbn_inbox.stop()
self.running = False
def update_sockets(self):
od_mn = self.elect_masternodes.quick_read('top_candidate')
od_dl = self.elect_delegates.quick_read('top_candidate')
masternodes = self.masternode_contract.quick_read('S', 'members')
delegates = self.delegate_contract.quick_read('S', 'members')
self.socket_authenticator.add_governance_sockets(
masternode_list=masternodes,
delegate_list=delegates,
on_deck_masternode=od_mn,
on_deck_delegate=od_dl)
def version_check(self):
# check for trigger
self.version_state = self.client.get_contract('upgrade')
self.mn_votes = self.version_state.quick_read('mn_vote')
self.dl_votes = self.version_state.quick_read('dl_vote')
if self.version_state:
self.log.info('Waiting for Consensys on vote')
self.log.info('num masters voted -> {}'.format(self.mn_votes))
self.log.info('num delegates voted -> {}'.format(self.dl_votes))
# Given node is either master or delegate default assumes it to be valid
# delegate
node_type = False
for key in self.contacts.masternodes:
if self.wallet.verifying_key().hex() == key:
self.log.info("Node Type : Master")
node_type = True
# check for vote consensys
vote_consensus = self.version_state.quick_read('upg_consensus')
if vote_consensus:
self.log.error('Rebooting Node with new version')
version_reboot(bn=self.bootnodes, is_master=node_type)
else:
self.log.info(
'{} waiting for vote on upgrade'.format(node_type))
def get_update_state(self):
self.active_upgrade = self.version_state.quick_read('upg_lock')
start_time = self.version_state.quick_read('upg_init_time')
window = self.version_state.quick_read('upg_window')
pepper = self.version_state.quick_read('upg_pepper')
self.mn_votes = self.version_state.quick_read('mn_vote')
self.dl_votes = self.version_state.quick_read('dl_vote')
consensus = self.version_state.quick_read('upg_consensus')
print("Upgrade -> {} Cil Pepper -> {}\n"
"Init time -> {}, Time Window -> {}\n"
"Masters -> {}\n"
"Delegates -> {}\n"
"Votes -> {}\n "
"MN-Votes -> {}\n "
"DL-Votes -> {}\n "
"Consensus -> {}\n".format(self.active_upgrade, pepper,
start_time, window, self.tol_mn,
self.tot_dl, self.all_votes,
self.mn_votes, self.dl_votes,
consensus))