def _test_para(i, f2h, s_token, d_token, src_acc, dst_acc, src_key, amount):
'''Test Token Transfer Cross Chain'''
s_src_b = s_token.balance_of(src_acc)
d_dst_b = d_token.balance_of(dst_acc)
LOG.info("Src account balance - %s: %s", i, s_src_b)
LOG.info("Dst account balance - %s: %s", i, d_dst_b)
if (s_src_b < amount):
LOG.info("Balance of source account is lower than the amount to transfer.")
return 'Error'
if f2h:
extra_data = '0x000000000000000000000000%s' % dst_acc[2:]
LOG.info("%s", token_f.transfer(src_key, fb_addr, amount, extra_data))
else:
if amount < 1 * 10 ** decimals:
LOG.info("Amount to transfer is lower than 1 unit.")
return 'Error'
extra_data = HexBytes.fromhex('000000000000000000000000%s' % dst_acc[2:])
LOG.info("%s", token_h.transfer_call(src_key, hb_addr, amount, bytes(extra_data)))
time.sleep(30)
s_src_a = s_token.balance_of(src_acc)
d_dst_a = d_token.balance_of(dst_acc)
LOG.info("Src account balance - %s: %s", i, s_src_a)
LOG.info("Dst account balance - %s: %s", i, d_dst_a)
fee = 0
if f2h:
fee = hfee * amount / 10000
else:
fee = ffee * amount / 10000
return s_src_b - s_src_a == amount and d_dst_a - d_dst_b == amount - fee
def from_private_key(private_key: str):
pr_key = keys.PrivateKey(HexBytes.fromhex(private_key))
return Wallet(pr_key.public_key.to_address(), private_key)
def distribute(task_declaration, verification_assignment):
from tatau_core.models import TaskAssignment, WorkerPayment
logger.info('Distribute {}'.format(task_declaration))
iteration = task_declaration.current_iteration
iteration_retry = task_declaration.current_iteration_retry
good_worker_ids = []
fake_worker_ids = []
# if verification was failed or task was canceled
if verification_assignment.verification_result.result:
for r in verification_assignment.verification_result.result:
if r['is_fake']:
fake_worker_ids.append(r['worker_id'])
else:
good_worker_ids.append(r['worker_id'])
amount_for_worker = int(task_declaration.iteration_cost_in_wei /
task_declaration.workers_requested)
distribute_history = verification_assignment.distribute_history
distribute_transactions = distribute_history.distribute_transactions
iteration_data = distribute_transactions.get(str(iteration))
if not iteration_data:
distribute_transactions[str(iteration)] = {}
iteration_retry_data = distribute_transactions[str(iteration)].get(
str(iteration_retry))
if not iteration_retry_data:
distribute_transactions[str(iteration)][str(iteration_retry)] = {
'workers': [],
'transaction': None
}
already_payed_workers = []
for retry, value in distribute_transactions[str(iteration)].items():
already_payed_workers += value['workers']
distribute_data = distribute_transactions[str(iteration)][str(
iteration_retry)]
if distribute_data['transaction'] is not None:
tx_hash_str = distribute_data['transaction']
logger.info('Transaction for {} for iteration {} is {}'.format(
task_declaration, task_declaration.current_iteration, tx_hash_str))
tx_hash = HexBytes.fromhex(tx_hash_str)
if NodeContractInfo.get_contract().is_transaction_mined(tx_hash):
logger.info('Distribute for {} for iteration {} is mined'.format(
task_declaration, task_declaration.current_iteration))
return
else:
if task_declaration.last_iteration:
NodeContractInfo.get_contract().wait_for_transaction_mined(
tx_hash)
logger.info(
'Distribute for {} for iteration {} is mined'.format(
task_declaration, task_declaration.current_iteration))
else:
logger.info(
'Distribute for {} for iteration {} is not mined'.format(
task_declaration, task_declaration.current_iteration))
return
if len(good_worker_ids) == 0:
logger.info('No targets for distribute')
return
worker_addresses = []
amounts = []
distribute_total_amount = 0.0
worker_payments = []
for task_assignment in task_declaration.get_task_assignments(
states=(TaskAssignment.State.FINISHED, )):
if task_assignment.worker.asset_id in fake_worker_ids:
continue
if task_assignment.worker.asset_id in already_payed_workers:
continue
worker_addresses.append(task_assignment.worker.account_address)
amounts.append(amount_for_worker)
distribute_total_amount += float(
web3.fromWei(amount_for_worker, 'ether'))
worker_payments.append(
WorkerPayment(
db=verification_assignment.db,
encryption=verification_assignment.encryption,
producer_id=task_declaration.producer_id,
worker_id=task_assignment.worker.asset_id,
task_declaration_id=task_declaration.asset_id,
train_iteration=task_declaration.current_iteration,
train_iteration_retry=task_declaration.current_iteration_retry,
tflops=task_assignment.train_result.tflops,
tokens=float(web3.fromWei(amount_for_worker, 'ether'))))
NodeContractInfo.unlock_account()
logger.info(
'Job balance: {:.5f} ETH distribute: {:.5f} ETH worker addresses: {}'.
format(task_declaration.balance, distribute_total_amount,
worker_addresses))
tx_hash = NodeContractInfo.get_contract().distribute_async(
task_declaration_id=task_declaration.asset_id,
workers=worker_addresses,
amounts=amounts)
distribute_data['workers'] = good_worker_ids
distribute_data['transaction'] = ''.join('{:02x}'.format(x)
for x in tx_hash)
distribute_history.save()
for worker_payment in worker_payments:
logger.info('Save payments for worker: {}, tokens: {}'.format(
worker_payment.worker_id, worker_payment.tokens))
worker_payment.save()
if task_declaration.last_iteration:
logger.info(
'Wait for distribute of last iteration for task: {} balance: {:.5f} ETH distribute: {:.5f} ETH'
.format(task_declaration, task_declaration.balance,
distribute_total_amount))
NodeContractInfo.get_contract().wait_for_transaction_mined(tx_hash)
logger.info('Job {} distributed async'.format(task_declaration))
