def init():
database.flush_database()
queue_service.init()
eth_provider = EthProvider(node_key_store)
w3 = eth_provider.web3_provider()
contract_registry_address = common.contract_registry_address()
contract_registry_filter.init_contract_registry(w3,
contract_registry_address)
event_registry_abi = common.event_registry_contract_abi()
verity_event_abi = common.verity_event_contract_abi()
node_registry_abi = common.node_registry_contract_abi()
node_registry_address = database.ContractAddress.node_registry()
event_registry_address = database.ContractAddress.event_registry()
node_ip_port = common.node_ip_port()
node_websocket_ip_port = common.node_websocket_ip_port()
node_registry.register_node_ip(w3, node_registry_abi,
node_registry_address, node_ip_port,
common.AddressType.IP)
node_registry.register_node_ip(w3, node_registry_abi,
node_registry_address,
node_websocket_ip_port,
common.AddressType.WEBSOCKET)
scheduler.init(w3)
websocket.init(node_websocket_ip_port)
event_registry_filter.init_event_registry_filter(scheduler.scheduler, w3,
event_registry_abi,
verity_event_abi,
event_registry_address)
def event_data_to_blockchain(w3, event_id):
user_ids, eth_rewards, token_rewards = database.Rewards.get_lists(event_id)
contract_abi = common.verity_event_contract_abi()
contract_instance = w3.eth.contract(address=event_id, abi=contract_abi)
set_rewards_on_blockchain(w3, contract_instance, event_id, user_ids, eth_rewards, token_rewards)
set_result_on_blockchain(w3, contract_instance, event_id)
mark_rewards_on_blockchain(w3, contract_instance, event_id, user_ids, eth_rewards,
token_rewards)
def process_dispute_triggered(scheduler, w3, event_id, entries, should_log):
entry = entries[-1]
dispute_started_by = entry['args']['byAddress']
logger.info('[%s] Dispute started by %s', event_id, dispute_started_by)
event = database.VerityEvent.get(event_id)
if event is None:
logger.info('[%s] Event does not exist in the database', event_id)
return
contract_block_number = event.metadata().contract_block_number
VerityEvent.delete_all_event_data(w3, event_id)
event_registry_filter.init_event(scheduler, w3,
common.verity_event_contract_abi(),
event_id, contract_block_number,
should_log)
def validate_event_data_on_blockchain(w3, event_id, validation_round):
logger.info('[%s] Validating rewards for round %d', event_id, validation_round)
event_contract_abi = common.verity_event_contract_abi()
event_contract = w3.eth.contract(address=event_id, abi=event_contract_abi)
contract_reward_user_ids = event_contract.functions.getRewardsIndex().call()
contract_reward_ether, contract_reward_token = [], []
contract_reward_user_ids_chunks = common.list_to_chunks(contract_reward_user_ids)
for i, contract_reward_user_ids_chunk in enumerate(contract_reward_user_ids_chunks, 1):
logger.info('[%s] Requesting contract reward user ids for %d of %d chunks', event_id, i,
len(contract_reward_user_ids_chunks))
(contract_reward_ether_chunk, contract_reward_token_chunk
) = event_contract.functions.getRewards(contract_reward_user_ids_chunk).call()
contract_reward_ether.extend(contract_reward_ether_chunk)
contract_reward_token.extend(contract_reward_token_chunk)
contract_rewards_dict = database.Rewards.transform_lists_to_dict(
contract_reward_user_ids, contract_reward_ether, contract_reward_token)
node_rewards_dict = database.Rewards.get(event_id)
event_consensus_answer = common.consensus_answers_from_contract(event_contract)
consensus_answer = database.Vote.get_consensus_answers(event_id)
rewards_match = do_rewards_match(node_rewards_dict, contract_rewards_dict)
consensus_match = event_consensus_answer == consensus_answer
logger.info('[%s] Node rewards: %s', event_id, node_rewards_dict)
logger.info('[%s] Blockchain rewards: %s', event_id, contract_rewards_dict)
logger.info('[%s] Rewards DO%s match', event_id, '' if rewards_match else ' NOT')
logger.info('[%s] Consensus answers DO%s match. Contract: %s, node: %s', event_id,
'' if consensus_match else ' NOT', event_consensus_answer, consensus_answer)
if rewards_match and consensus_match:
logger.info('[%s] Approving rewards for round %d', event_id, validation_round)
approve_fun = event_contract.functions.approveRewards(validation_round)
transactions.queue_transaction(w3, approve_fun, event_id=event_id)
else:
logger.info('[%s] Rejecting rewards for round %d', event_id, validation_round)
(user_ids, eth_rewards,
token_rewards) = database.Rewards.transform_dict_to_lists(node_rewards_dict)
alt_hash = database.Rewards.hash(user_ids, eth_rewards, token_rewards)
reject_fun = event_contract.functions.rejectRewards(validation_round, alt_hash)
transactions.queue_transaction(w3, reject_fun, event_id=event_id)
def init(w3):
logger.info('Scheduler Init started')
configure_scheduler_logging()
node_registry_address = database.ContractAddress.node_registry()
event_registry_address = database.ContractAddress.event_registry()
event_registry_abi = common.event_registry_contract_abi()
verity_event_abi = common.verity_event_contract_abi()
node_registry_abi = common.node_registry_contract_abi()
event_registry_filter_names = [event_registry_filter.NEW_VERITY_EVENT]
event_registry_formatters = verity_event_filters.log_entry_formatters(
event_registry_abi, event_registry_filter_names)
verity_event_filter_names = list(verity_event_filters.EVENT_FILTERS.keys())
verity_event_formatters = verity_event_filters.log_entry_formatters(
verity_event_abi, verity_event_filter_names)
scheduler.add_job(verity_event_filters.filter_events,
'interval',
seconds=20,
args=[scheduler, w3, verity_event_formatters],
id='filter_events')
scheduler.add_job(event_registry_filter.filter_event_registry,
'interval',
seconds=30,
args=[
scheduler, w3, event_registry_address,
verity_event_abi, event_registry_formatters
],
id='event_registry_filter')
scheduler.add_job(node_registry.update_node_ips,
'interval',
seconds=60,
args=[w3, node_registry_abi, node_registry_address])
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
pass
logger.info('Scheduler Init done')
def recover_filter(scheduler,
w3,
event_id,
filter_name,
filter_func,
filter_id=None,
should_log=False):
try:
event = database.VerityEvent.get(event_id)
if event is None or event.state in FINAL_STATES:
logger.info('[%s] Event is finished. No need to recover %s filter',
event_id, filter_name)
return True
if filter_id is not None:
database.Filters.delete_filter(event_id, filter_id, filter_name)
contract_abi = common.verity_event_contract_abi()
contract_instance = w3.eth.contract(address=event_id, abi=contract_abi)
init_event_filter(scheduler, w3, filter_name, filter_func,
contract_instance, event_id, should_log)
except Exception as e:
logger.info('[%s] Exception %s with recovering %s filter', event_id,
e.__class__.__name__, filter_name)
return False
return True
def instance(w3, event_id):
contract_abi = common.verity_event_contract_abi()
return w3.eth.contract(address=event_id, abi=contract_abi)