def test_submit_txn_when_both_ready(monkeypatch): user = OneUser.run(db_session, account_amount=100_000_000_000, account_currency=currency) amount = 10_000_000_000 receiver = LocalAccount.generate() subaddress = identifier.gen_subaddress() txn = save_outbound_transaction(user.account_id, receiver.account_address, subaddress, amount, currency) cmd = _txn_payment_command(txn) receiver_cmd = dataclasses.replace( cmd, my_actor_address=cmd.payment.receiver.address) receiver_ready_cmd = receiver_cmd.new_command( recipient_signature=b"recipient_signature".hex(), status=offchain.Status.ready_for_settlement, kyc_data=_user_kyc_data(user.account_id), ) with monkeypatch.context() as m: client = context.get().offchain_client m.setattr( client, "process_inbound_request", lambda _, c: client.create_inbound_payment_command( c.cid, c.payment), ) code, resp = process_inbound_command(cmd.payment.receiver.address, receiver_ready_cmd) assert code == 200 assert resp txn = get_transaction_by_reference_id(cmd.reference_id()) assert txn assert txn.status == TransactionStatus.OFF_CHAIN_INBOUND cmd = _txn_payment_command(txn) assert cmd.is_inbound(), str(cmd) process_offchain_tasks() db_session.refresh(txn) assert txn.status == TransactionStatus.OFF_CHAIN_READY # sync command and submit with monkeypatch.context() as m: m.setattr( context.get().offchain_client, "send_command", lambda cmd, _: offchain.reply_request(cmd.cid), ) m.setattr( context.get(), "p2p_by_travel_rule", jsonrpc_txn_sample, ) process_offchain_tasks() db_session.refresh(txn) assert txn.status == TransactionStatus.COMPLETED assert txn.sequence == 5 assert txn.blockchain_version == 3232
def get_deposit_address(account_id: Optional[int] = None, account_name: Optional[str] = None): account = get_account(account_id=account_id, account_name=account_name) subaddress = generate_new_subaddress(account.id) return identifier.encode_account( context.get().config.vasp_account_address(), subaddress, context.get().config.diem_address_hrp(), )
def submit_onchain(transaction_id: int) -> None: transaction = get_transaction(transaction_id) if transaction.status == TransactionStatus.PENDING: try: diem_currency = DiemCurrency[transaction.currency] if transaction.type == TransactionType.EXTERNAL: jsonrpc_txn = context.get().p2p_by_general( currency=diem_currency.value, amount=transaction.amount, receiver_vasp_address=transaction.destination_address, receiver_sub_address=transaction.destination_subaddress, sender_sub_address=transaction.source_subaddress, ) update_transaction( transaction_id=transaction_id, status=TransactionStatus.COMPLETED, sequence=jsonrpc_txn.transaction.sequence_number, blockchain_tx_version=jsonrpc_txn.version, ) add_transaction_log( transaction_id, "On Chain Transfer of General Txn Complete") log_execution("On chain transfer complete " f"txid: {transaction_id} " f"v: {jsonrpc_txn.version} ") if transaction.type == TransactionType.REFUND: original_txn_version = get_transaction( transaction.original_txn_id).blockchain_version jsonrpc_txn = context.get().p2p_by_refund( currency=diem_currency.value, amount=transaction.amount, receiver_vasp_address=transaction.destination_address, original_txn_version=original_txn_version, ) update_transaction( transaction_id=transaction_id, status=TransactionStatus.COMPLETED, sequence=jsonrpc_txn.transaction.sequence_number, blockchain_tx_version=jsonrpc_txn.version, ) add_transaction_log( transaction_id, "On Chain Transfer of Refund Txn Complete") log_execution("On chain transfer complete " f"txid: {transaction_id} " f"v: {jsonrpc_txn.version} ") except Exception: logger.exception(f"Error in _async_start_onchain_transfer") add_transaction_log(transaction_id, "On Chain Transfer Failed") log_execution("On Chain Transfer Failed") update_transaction(transaction_id=transaction_id, status=TransactionStatus.CANCELED)
def get_transaction_response_object( cls, account_id: int, transaction: Transaction) -> Dict[str, str]: direction = get_transaction_direction(account_id=account_id, transaction=transaction) blockchain_tx = None if transaction.type == TransactionType.EXTERNAL: blockchain_tx = { "amount": transaction.amount, "source": transaction.source_address, "destination": transaction.destination_address, "expirationTime": "", "sequenceNumber": transaction.sequence, "status": transaction.status, "version": transaction.blockchain_version, } return { "id": transaction.id, "amount": transaction.amount, "currency": transaction.currency, "direction": direction.value.lower(), "status": transaction.status, "timestamp": transaction.created_timestamp.isoformat(), "source": { "vasp_name": transaction.source_address, "user_id": transaction.source_subaddress, "full_addr": identifier.encode_account( transaction.source_address, transaction.source_subaddress, context.get().config.diem_address_hrp(), ), }, "destination": { "vasp_name": transaction.destination_address, "user_id": transaction.destination_subaddress, "full_addr": identifier.encode_account( transaction.destination_address, transaction.destination_subaddress, context.get().config.diem_address_hrp(), ), }, "is_internal": transaction.type == TransactionType.INTERNAL, "blockchain_tx": blockchain_tx, }
def show_context(request, path): document_root = contrib.get_document_root(path) fullpath = contrib.get_full_path(document_root, path) log.debug('show context of %s (%s %s)' % (fullpath, document_root, path)) result = "" sections = config.sections(context.get(fullpath).inifile) for section_name in sections: ctx = context.get(fullpath, section=section_name) context_ini = context.render_ini(path, ctx, request.get_host(), section_name) result += context_ini return HttpResponse(result)
def test_process_inbound_command(monkeypatch): hrp = context.get().config.diem_address_hrp() user = OneUser.run(db_session, account_amount=100_000_000_000, account_currency=currency) amount = 10_000_000_000 sender = LocalAccount.generate() sender_subaddress = identifier.gen_subaddress() receiver_subaddress = generate_new_subaddress(user.account_id) cmd = offchain.PaymentCommand.init( identifier.encode_account(sender.account_address, sender_subaddress, hrp), _user_kyc_data(user.account_id), identifier.encode_account(context.get().config.vasp_address, receiver_subaddress, hrp), amount, currency.value, ) with monkeypatch.context() as m: client = context.get().offchain_client m.setattr( client, "process_inbound_request", lambda _, cmd: client.create_inbound_payment_command( cmd.cid, cmd.payment), ) code, resp = process_inbound_command(cmd.payment.sender.address, cmd) assert code == 200 assert resp txn = get_transaction_by_reference_id(cmd.reference_id()) assert txn assert txn.status == TransactionStatus.OFF_CHAIN_INBOUND cmd = _txn_payment_command(txn) assert cmd.is_inbound(), str(cmd) with monkeypatch.context() as m: m.setattr( context.get().offchain_client, "send_command", lambda cmd, _: offchain.reply_request(cmd.cid), ) process_offchain_tasks() db_session.refresh(txn) assert txn.status == TransactionStatus.OFF_CHAIN_OUTBOUND
def runTest(request, fullpath): path = contrib.normpath(request.REQUEST["path"]) context_name = request.REQUEST.get("context", None) ctx = context.get(fullpath, section=context_name) log.info('run test %s with context %s' % (path, context_name)) server = request.get_host() contextjs = context.render(path, ctx, server) log.debug('contextJS: '+ contextjs) clean_path = contrib.get_relative_clean_path(path) target = contrib.get_runner_url(ctx, server) log.info('target of test %s is %s' % (clean_path, target)) tools.savetest(request.REQUEST.get('content', None), fullpath) test_content = request.REQUEST.get("content", open(fullpath, 'r').read()) #if contrib.target_is_remote( target, server): # log.debug('TARGET: %s, %s' % ( target, server )) # url = "http://%s/%s" % (target, settings.UPLOAD_TESTS_CMD) # saveRemoteContext(os.path.dirname(clean_path), contextjs, url, ctx) # distributor.saveTestSatelliteScripts(url, path, ctx) # distributor.sendContentToRemote(clean_path, test_content, url, ctx) # url = "http://%s/%s?path=/%s" % (target, settings.EXEC_TESTS_CMD, clean_path) #else: # saveLocalContext(fullpath, contextjs) # url = "http://%s/%s?path=/%s" % (target, settings.EXEC_TESTS_CMD, clean_path) saveLocalContext(fullpath, contextjs) if coffee(path): path = coffeescript.compile(test_content, path, fullpath) url = "http://%s/%s?server=%s&path=/%s" % (target, settings.EXEC_TESTS_CMD, server, path) log.info("redirect to run test %s" % url) return HttpResponseRedirect(url)
def runSuite(request, fullpath): path = contrib.normpath(request.REQUEST["path"]) context_name = request.REQUEST["context"] ctx = context.get(fullpath, section=context_name) log.info('run suite %s with context %s' % (path, context_name)) server = request.get_host(); compileSuiteCoffee(path, fullpath) contextjs = context.render(path, ctx, server) clean_path = contrib.get_relative_clean_path(path) target = contrib.get_runner_url(ctx, server) log.info('target of suite %s is %s' % (clean_path, target)) #if contrib.target_is_remote( target, server): # url = "http://%s/%s" % (target, settings.UPLOAD_TESTS_CMD) # saveRemoteContext(clean_path, contextjs, url, ctx) # distributor.saveSuiteAllTests(url, path, ctx) # distributor.saveTestSatelliteScripts(url, path, ctx) # url = "http://%s/%s?suite=/%s" % ( target, settings.EXEC_TESTS_CMD, clean_path ) #else: # saveLocalContext(fullpath, contextjs) # url = "http://%s/%s?suite=/%s" % ( target, settings.EXEC_TESTS_CMD, clean_path ) saveLocalContext(fullpath, contextjs) url = "http://%s/%s?server=%s&path=/%s" % ( target, settings.EXEC_TESTS_CMD, server, path ) log.info("redirect to run suite %s" % url) return HttpResponseRedirect( url )
def save_outbound_transaction( sender_id: int, destination_address: str, destination_subaddress: str, amount: int, currency: DiemCurrency, ) -> Transaction: sender_onchain_address = context.get().config.vasp_address sender_subaddress = account.generate_new_subaddress(account_id=sender_id) return commit_transaction( _new_payment_command_transaction( offchain.PaymentCommand.init( identifier.encode_account( sender_onchain_address, sender_subaddress, _hrp() ), _user_kyc_data(sender_id), identifier.encode_account( destination_address, destination_subaddress, _hrp() ), amount, currency.value, ), TransactionStatus.OFF_CHAIN_OUTBOUND, ) )
def post(self): try: tx_params = request.json user = self.user account_id = user.account_id currency = DiemCurrency[tx_params["currency"]] amount = int(tx_params["amount"]) recv_address: str = tx_params["receiver_address"] dest_address, dest_subaddress = identifier.decode_account( recv_address, context.get().config.diem_address_hrp()) tx = transaction_service.send_transaction( sender_id=account_id, amount=amount, currency=currency, destination_address=utils.account_address_bytes( dest_address).hex(), destination_subaddress=dest_subaddress.hex() if dest_subaddress else None, ) transaction = AccountRoutes.get_transaction_response_object( user.account_id, tx) return transaction, HTTPStatus.OK except transaction_service.RiskCheckError as risk_check_failed_error: return self.respond_with_error(HTTPStatus.FAILED_DEPENDENCY, str(risk_check_failed_error)) except transaction_service.SelfAsDestinationError as send_to_self_error: return self.respond_with_error(HTTPStatus.FORBIDDEN, str(send_to_self_error))
def send_fake_tx(amount=100, send_to_self=False) -> Tuple[int, Transaction]: user = OneUser.run(db_session, account_amount=100_000_000_000, account_currency=DiemCurrency.XUS) account_id = user.account_id amount = amount payment_type = types.TransactionType.EXTERNAL currency = diem_utils.types.currencies.DiemCurrency.XUS destination_address = "receiver_address" destination_subaddress = "receiver_subaddress" if send_to_self: destination_address = account_address_hex( context.get().config.vasp_address) destination_subaddress = generate_new_subaddress(account_id) send_tx = send_transaction( sender_id=account_id, amount=amount, currency=currency, payment_type=payment_type, destination_address=destination_address, destination_subaddress=destination_subaddress, ) return account_id, get_transaction(send_tx.id) if send_tx else None
def submit_onchain(transaction_id: int) -> None: transaction = get_transaction(transaction_id) if transaction.status == TransactionStatus.PENDING: try: diem_currency = DiemCurrency[transaction.currency] jsonrpc_txn = context.get().p2p_by_general( currency=diem_currency.value, amount=transaction.amount, receiver_vasp_address=transaction.destination_address, receiver_sub_address=transaction.destination_subaddress, sender_sub_address=transaction.source_subaddress, ) update_transaction( transaction_id=transaction_id, status=TransactionStatus.COMPLETED, sequence=jsonrpc_txn.transaction.sequence_number, blockchain_tx_version=jsonrpc_txn.version, ) add_transaction_log(transaction_id, "On Chain Transfer Complete") log_execution("On Chain Transfer Complete") except Exception: logger.exception(f"Error in _async_start_onchain_transfer") add_transaction_log(transaction_id, "On Chain Transfer Failed") log_execution("On Chain Transfer Failed") update_transaction(transaction_id=transaction_id, status=TransactionStatus.CANCELED)
def enumerate_suites(request): """ Return a list of suite names. Arguments: ctx (optional) - filter suites containing supplied ctx name json (optional) - return result in JSON format """ ctx_name = request.REQUEST.get('context', None) as_json = request.REQUEST.get('json', False) target = request.REQUEST.get('target', False) suites = [] root = contrib.get_document_root(target) contextini = settings.TEST_CONTEXT_FILE_NAME for dirpath, dirnames, filenames in os.walk(root, followlinks=True): if not ( contextini in filenames ): continue if ctx_name: contextfile = os.path.join(dirpath, contextini) ctx = context.get(contextfile) ctx_sections = ctx.sections() if not ctx_name in ctx_sections: continue suites += [ dirpath.replace(root, '').replace('\\','/').lstrip('/') ] if as_json: return HttpResponse(json.dumps(suites)) return HttpResponse(str(suites).replace('[','').replace(']','').rstrip(',').replace('\'',''))
def get_dir_index(document_root, path, fullpath): files = [] dirs = [] def get_descriptor(title): fullpath = os.path.join(path, title) return { 'title': title, 'type': tools.get_type(contrib.get_full_path(document_root, fullpath)) } if not document_root: pagetype = 'front-page' for key in contrib.get_virtual_paths(): dir_descriptor = get_descriptor(key) dirs.append(dir_descriptor) else: pagetype = tools.get_type(fullpath) for f in sorted(os.listdir(fullpath)): if not f.startswith('.'): if os.path.isfile(os.path.join(fullpath, f)): files.append(get_descriptor(f)) else: f += '/' dirs.append(get_descriptor(f)) try: if tools.get_type(fullpath) == 'virtual': contexts = context.global_settings(fullpath).sections() else: contexts = context.get(fullpath).sections() log.debug(contexts) except Exception, e: log.error(e) contexts = []
def main(): import json import context ctx = context.get() t = list(totals(ctx)) t.sort(key=lambda c: c["receipts"], reverse=True) print(json.dumps(t, indent=4))
def external_transaction( sender_id: int, receiver_address: str, receiver_subaddress: str, amount: int, currency: DiemCurrency, payment_type: TransactionType, original_txn_id: int, ) -> Transaction: logger.info( f"external_transaction {sender_id} to receiver {receiver_address}, " f"receiver subaddress {receiver_subaddress}, amount {amount}") if not validate_balance(sender_id, amount, currency): raise BalanceError( f"Balance {account_service.get_account_balance_by_id(account_id=sender_id).total[currency]} " f"is less than amount needed {amount}") sender_onchain_address = context.get().config.vasp_address sender_subaddress = None if (payment_type == TransactionType.EXTERNAL or payment_type == TransactionType.REFUND): sender_subaddress = account_service.generate_new_subaddress( account_id=sender_id) transaction = add_transaction( amount=amount, currency=currency, payment_type=payment_type, status=TransactionStatus.PENDING, source_id=sender_id, source_address=sender_onchain_address, source_subaddress=sender_subaddress, destination_id=None, destination_address=receiver_address, destination_subaddress=receiver_subaddress, original_txn_id=original_txn_id, ) if services.run_bg_tasks(): from ..background_tasks.background import async_external_transaction async_external_transaction.send(transaction.id) else: submit_onchain(transaction_id=transaction.id) return transaction
def runSuite(request, fullpath): path = contrib.normpath(request.REQUEST["path"]) context_name = request.REQUEST["context"] ctx = context.get(fullpath, section=context_name) log.info('run suite %s with context %s' % (path, context_name)) server = request.get_host(); compileSuiteCoffee(path, fullpath) contextjs = context.render(path, ctx, server, context_name) clean_path = contrib.get_relative_clean_path(path) target = contrib.get_runner_url(ctx, server) log.info('target of suite %s is %s' % (clean_path, target)) saveLocalContext(fullpath, contextjs) url = "http://%s/%s?server=%s&path=/%s" % ( target, settings.EXEC_TESTS_CMD, server, path ) log.info("redirect to run suite %s" % url) return HttpResponseRedirect( url )
def submit_txn(txn, cmd, _) -> Transaction: if cmd.is_sender(): logger.info( f"Submitting transaction ID:{txn.id} {txn.amount} {txn.currency}" ) _offchain_client().send_command(cmd, _compliance_private_key().sign) rpc_txn = context.get().p2p_by_travel_rule( cmd.receiver_account_address(_hrp()), cmd.payment.action.currency, cmd.payment.action.amount, cmd.travel_rule_metadata(_hrp()), bytes.fromhex(cmd.payment.recipient_signature), ) txn.sequence = rpc_txn.transaction.sequence_number txn.blockchain_version = rpc_txn.version txn.status = TransactionStatus.COMPLETED logger.info( f"Submitted transaction ID:{txn.id} V:{txn.blockchain_version} {txn.amount} {txn.currency}" )
def body(parsed: Parsed, body_line: Line) -> Parsed: '''put body in context wrt head => parse create a "context" from the head and the body (given the parser that parsed the head). put the body into that context with formatting and parse it. ''' head_parser = parsed.parser definition = config.parsers[head_parser] body_parser = definition['body'] parse = parsers[body_parser] #HACK force body comment to be parsed (not joined with head) if re.search(config.parsers['comment']['regex'], body_line): return parsers['comment'](body_line) head_line = parsed.head holes = context.get(head_parser, head_line, body_line) line = holes % escape(body_line) line = Line(line, lineno=body_line.lineno, file=body_line.file) return parse(line)
def settle_offchain(transaction_id: int) -> None: transaction = get_transaction(transaction_id) logger.info(f"settle_offchain: {transaction_id}, " f"{transaction.status}, " f"{transaction.type}") if (transaction.status == TransactionStatus.READY_FOR_ON_CHAIN and transaction.type == TransactionType.OFFCHAIN): try: diem_currency = DiemCurrency[transaction.currency] logger.info( f"==============starting submit_onchain {diem_currency}, {transaction.amount}, " f"{transaction.destination_address}, {transaction.destination_subaddress}, " f"{transaction.source_subaddress}") reference_id = get_reference_id_from_transaction_id(transaction_id) jsonrpc_txn = context.get().p2p_by_travel_rule( currency=diem_currency.value, amount=transaction.amount, receiver_vasp_address=transaction.destination_address, off_chain_reference_id=reference_id, metadata_signature=bytes.fromhex( get_metadata_signature_from_reference_id(reference_id)), ) update_transaction( transaction_id=transaction_id, status=TransactionStatus.COMPLETED, sequence=jsonrpc_txn.transaction.sequence_number, blockchain_tx_version=jsonrpc_txn.version, ) add_transaction_log(transaction_id, "On Chain Transfer Complete") log_execution("On Chain Transfer Complete") except Exception as e: logger.exception(f"Error in settle_offchain: {e}") add_transaction_log(transaction_id, "Off Chain Settlement Failed") log_execution("Off Chain Settlement Failed") update_transaction(transaction_id=transaction_id, status=TransactionStatus.CANCELED)
def internal_transaction( sender_id: int, receiver_id: int, amount: int, currency: DiemCurrency, payment_type: TransactionType, ) -> Transaction: """Transfer transaction between accounts in the LRW internal ledger.""" log_execution("Enter internal_transaction") if not validate_balance(sender_id, amount, currency): raise BalanceError( f"Balance {account_service.get_account_balance_by_id(account_id=sender_id).total[currency]} " f"is less than amount needed {amount}") sender_subaddress = account_service.generate_new_subaddress(sender_id) receiver_subaddress = account_service.generate_new_subaddress(receiver_id) internal_vasp_address = context.get().config.vasp_address transaction = add_transaction( amount=amount, currency=currency, payment_type=payment_type, status=TransactionStatus.COMPLETED, source_id=sender_id, source_address=internal_vasp_address, source_subaddress=sender_subaddress, destination_id=receiver_id, destination_address=internal_vasp_address, destination_subaddress=receiver_subaddress, ) log_execution( f"Transfer from {sender_id} to {receiver_id} started with transaction id {transaction.id}" ) add_transaction_log(transaction.id, "Transfer completed") return transaction
def runTest(request, fullpath): path = contrib.normpath(request.REQUEST["path"]) context_name = request.REQUEST.get("context", None) ctx = context.get(fullpath, section=context_name) log.info('run test %s with context %s' % (path, context_name)) server = request.get_host() contextjs = context.render(path, ctx, server, context_name) log.debug('contextJS: '+ contextjs) clean_path = contrib.get_relative_clean_path(path) target = contrib.get_runner_url(ctx, server) log.info('target of test %s is %s' % (clean_path, target)) tools.savetest(request.REQUEST.get('content', None), fullpath) test_content = request.REQUEST.get("content", open(fullpath, 'r').read()) saveLocalContext(fullpath, contextjs) if coffee(path): path = coffeescript.compile2js(test_content, path, fullpath) url = "http://%s/%s?server=%s&path=/%s" % (target, settings.EXEC_TESTS_CMD, server, path) log.info("redirect to run test %s" % url) return HttpResponseRedirect(url)
def _cover_buy(order: Order, quote: QuoteData) -> bool: deposit_address = get_inventory_deposit_address() trade_id = LpClient().trade_and_execute( quote_id=quote.quote_id, direction=Direction[order.direction], diem_deposit_address=deposit_address, ) trade_info = _wait_for_trade(order=order, trade_id=trade_id) if not trade_info: update_order( order_id=OrderId(UUID(order.id)), cover_status=CoverStatus.FailedCoverLPTradeError, ) return False update_order( order_id=OrderId(UUID(order.id)), cover_status=CoverStatus.PendingCoverValidation, ) vasp_address, internal_subaddress = decode_account( deposit_address, context.get().config.diem_address_hrp() ) if not _validate_blockchain_transaction( blockchain_version=trade_info.tx_version, vasp_address=utils.account_address_hex(vasp_address), internal_subaddress=internal_subaddress.hex(), amount=round(trade_info.amount), ): update_order( order_id=OrderId(UUID(order.id)), cover_status=CoverStatus.FailedCoverTransactionError, ) return False return True
def test_save_outbound_transaction(monkeypatch): user = OneUser.run(db_session, account_amount=100_000_000_000, account_currency=currency) amount = 10_000_000_000 receiver = LocalAccount.generate() subaddress = identifier.gen_subaddress() txn = save_outbound_transaction(user.account_id, receiver.account_address, subaddress, amount, currency) assert txn.id in get_account_transaction_ids(user.account_id) assert txn.reference_id is not None assert txn.command_json is not None with monkeypatch.context() as m: m.setattr( context.get().offchain_client, "send_command", lambda cmd, _: offchain.reply_request(cmd.cid), ) process_offchain_tasks() db_session.refresh(txn) assert txn.status == TransactionStatus.OFF_CHAIN_WAIT
def test_get_set(): ctx = context.from_env() context.set(ctx) assert context.get() == ctx
def is_own_address(sender_id, receiver_vasp, receiver_subaddress) -> bool: return (receiver_vasp == context.get().config.vasp_address and get_account_id_from_subaddr(receiver_subaddress) == sender_id)
def is_in_wallet(receiver_subaddress, receiver_vasp) -> bool: return (get_account_id_from_subaddr(receiver_subaddress) is not None and receiver_vasp == context.get().config.vasp_address)
def _hrp() -> str: return context.get().config.diem_address_hrp()
def _compliance_private_key() -> Ed25519PrivateKey: return context.get().config.compliance_private_key()
def _account_address_and_subaddress( account_id: str) -> Tuple[str, Optional[str]]: account_address, sub = identifier.decode_account( account_id, context.get().config.diem_address_hrp()) return (account_address.to_hex(), sub.hex() if sub else None)
def execute(self, context=None): ''' Lookup of symbol values will start in the closest scope layer and proceed outward from there. Throws an exception if the symbol is not found in this context. ''' return context.get(self.symbol).execute(context)
def get_new_offchain_reference_id(sender_address_hex: str) -> str: address = LibraAddress.from_hex(context.get().config.diem_address_hrp(), sender_address_hex, None) id = uuid.uuid1().hex return f"{address.as_str()}_{id}"
print("2. Determine Best Options") print("3. Quit") print("") text = input("Please Enter Something : ") int_value = int(text) print("You entered " + str(int_value)) if int_value == 1: print("") print("") lst = [] cnt = int(0) for x in context.get(): if not isinstance(x, ibodypart.IBodyPart): raise Exception('Bad interface') lst.append(x) print(str(cnt) + ' -- ' + x.name()) cnt = cnt + 1 print("") text = input("Enter Which One : ") sel = int(text) lst[sel].setDate(datetime.date.today()) print("Date Set") if int_value == 2: print("") print("") for x in context.get():
def _init_offchain(): vasp = offchain_service.make_vasp(context.get()) offchain_service.launch(vasp) offchain_client.set(vasp)
def get_file_content_to_edit(path, fullpath, stubbed): try: contexts = context.get( fullpath ).sections() except Exception, e: log.exception(e) contexts = []
def external_offchain_transaction( sender_id: int, receiver_address: str, receiver_subaddress: str, amount: int, currency: DiemCurrency, payment_type: TransactionType, original_payment_reference_id: Optional[str] = None, description: Optional[str] = None, ) -> Transaction: sender_onchain_address = context.get().config.vasp_address logger.info( f"=================Start external_offchain_transaction " f"{sender_onchain_address}, {sender_id}, {receiver_address}, {receiver_subaddress}, " f"{amount}, {currency}, {payment_type}") if not validate_balance(sender_id, amount, currency): raise BalanceError( f"Balance {account_service.get_account_balance_by_id(account_id=sender_id).total[currency]} " f"is less than amount needed {amount}") sender_subaddress = account_service.generate_new_subaddress( account_id=sender_id) logger.info(f"======sender_subaddress: {sender_subaddress}") ref_id = get_new_offchain_reference_id(sender_onchain_address) transaction = add_transaction( amount=amount, currency=currency, payment_type=payment_type, status=TransactionStatus.PENDING, source_id=sender_id, source_address=sender_onchain_address, source_subaddress=sender_subaddress, destination_id=None, destination_address=receiver_address, destination_subaddress=receiver_subaddress, reference_id=ref_id, ) # off-chain logic sender_address = LibraAddress.from_bytes( context.get().config.diem_address_hrp(), bytes.fromhex(sender_onchain_address), bytes.fromhex(sender_subaddress), ) logger.info( f"sender address: {sender_onchain_address}, {sender_address.as_str()}, {sender_address.get_onchain().as_str()}" ) receiver_address = LibraAddress.from_bytes( context.get().config.diem_address_hrp(), bytes.fromhex(receiver_address), bytes.fromhex(receiver_subaddress), ) logger.info( f"receiver address: {receiver_address.as_str()}, {receiver_address.get_onchain().as_str()}", ) sender = PaymentActor( sender_address.as_str(), StatusObject(Status.needs_kyc_data), [], ) receiver = PaymentActor(receiver_address.as_str(), StatusObject(Status.none), []) action = PaymentAction(amount, currency, "charge", int(time())) reference_id = get_reference_id_from_transaction_id(transaction.id) payment = PaymentObject( sender=sender, receiver=receiver, reference_id=reference_id, original_payment_reference_id=original_payment_reference_id, description=description, action=action, ) cmd = PaymentCommand(payment) if not get_transaction_status(transaction.id) == TransactionStatus.PENDING: logger.info( "In external_offchain_transaction, payment status is not PENDING, abort" ) return update_transaction(transaction.id, TransactionStatus.OFF_CHAIN_STARTED) logger.info( "In external_offchain_transaction: Updated status to OFF_CHAIN_STARTED" ) result = (offchain_client.get().new_command(receiver_address.get_onchain(), cmd).result(timeout=300)) logger.info(f"Offchain Result: {result}") return transaction
def _offchain_client() -> offchain.Client: return context.get().offchain_client
def getRegistry(r): if r is None: return context.get(AdapterRegistry, theAdapterRegistry) else: return r