def cover_order(order: Order):
base_currency = Currency[order.base_currency]
quote = LpClient().get_quote(
CurrencyPair(base=base_currency, quote=INVENTORY_COVER_CURRENCY),
amount=order.amount,
)
update_order(
order_id=OrderId(UUID(order.id)),
quote_id=str(quote.quote_id),
quote_expiration=quote.expires_at,
rate=quote.rate.rate,
cover_status=CoverStatus.PendingCoverWithQuote,
)
covered = False
if Direction[order.direction] == Direction.Sell:
covered = _cover_sell(order, quote)
elif Direction[order.direction] == Direction.Buy:
covered = _cover_buy(order, quote)
if covered:
update_order(order_id=OrderId(UUID(order.id)), cover_status=CoverStatus.Covered)
def run(
db_session,
buy_amount: int,
buy_currency: DiemCurrency,
pay_currency: FiatCurrency,
pay_price: int,
) -> Tuple[int, int, OrderId]:
user = deepcopy(prototypes.user)
user.account = Account(name="fake_account_seed")
inventory_account = Account(name=INVENTORY_ACCOUNT_NAME)
db_session.add(user)
db_session.add(inventory_account)
db_session.commit()
order = Order(
amount=buy_amount,
direction=Direction.Buy,
base_currency=buy_currency,
quote_currency=pay_currency,
order_status=OrderStatus.PendingExecution,
cover_status=CoverStatus.PendingCover,
exchange_amount=pay_price,
order_expiration=datetime.utcnow() + timedelta(minutes=10),
order_type=OrderType.Trade,
)
user.orders.append(order)
db_session.add(order)
db_session.commit()
return inventory_account.id, user.account.id, OrderId(UUID(order.id))
def test_update_order(clean_db: None) -> None:
user_id, order_id = OneUserWithOneOrder().run(db_session)
update_order(OrderId(UUID(order_id)),
order_status=OrderStatus.FailedCredit)
order = get_order(order_id)
assert order.order_status == OrderStatus.FailedCredit.value
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 _cover_sell(order: Order, quote: QuoteData) -> bool:
transfer_to_lp_blockchain_version = _transfer_funds_to_lp(order)
if transfer_to_lp_blockchain_version == -1:
update_order(
order_id=OrderId(UUID(order.id)),
cover_status=CoverStatus.FailedCoverTransactionError,
)
return False
trade_info = LpClient().trade_and_execute(
quote_id=quote.quote_id,
direction=Direction[order.direction],
tx_version=transfer_to_lp_blockchain_version,
)
if not trade_info:
update_order(
order_id=OrderId(UUID(order.id)),
cover_status=CoverStatus.FailedCoverLPTradeError,
)
return False
return True
def run(
db_session,
buy_amount: int,
buy_currency: DiemCurrency,
pay_currency: FiatCurrency,
pay_price: int,
) -> Tuple[int, int, OrderId]:
user = deepcopy(prototypes.user)
user.account = Account(name="fake_account_seed")
inventory_account = Account(name=INVENTORY_ACCOUNT_NAME)
db_session.add(user)
db_session.add(inventory_account)
db_session.commit()
inventory_income = Transaction(
created_timestamp=datetime.now(),
amount=buy_amount,
currency=buy_currency,
type=TransactionType.EXTERNAL,
status=TransactionStatus.COMPLETED,
source_address="lp",
destination_id=inventory_account.id,
)
inventory_account.received_transactions.append(inventory_income)
order = Order(
amount=buy_amount,
direction=Direction.Buy,
base_currency=buy_currency,
quote_currency=pay_currency,
order_status=OrderStatus.PendingExecution,
cover_status=CoverStatus.PendingCover,
exchange_amount=pay_price,
order_expiration=datetime.utcnow() + timedelta(minutes=10),
order_type=OrderType.Trade,
)
user.orders.append(order)
db_session.add(order)
db_session.commit()
return inventory_account.id, user.account.id, OrderId(UUID(order.id))
def test_get_order(clean_db: None) -> None:
user_id, order_id = OneUserWithOneOrder().run(db_session)
order = get_order(OrderId(UUID(order_id)))
assert order