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