def release_order(order): from core.models import Transaction from nexchange.api_clients.factory import ApiClientFactory order.refresh_from_db() if order.status >= order.RELEASED: return currency = order.withdraw_currency amount = order.withdraw_amount address = order.withdraw_address factory = ApiClientFactory() api = factory.get_api_client(currency.wallet) txid, b = api.release_coins(currency, address, amount) order.status = order.RELEASED order.save() tx, created = Transaction.objects.get_or_create(**{ convert_camel_to_snake_case(order.__class__.__name__): order, 'type': 'W', 'address_to': address, 'amount': amount }) tx.tx_id = txid tx.save() order.refresh_from_db() tx.refresh_from_db() print(order) print(tx) print(tx.tx_id) return order, tx
def _update_pending_transaction(tx, logger, next_tasks=None): currency_to = tx.currency api = ApiClientFactory.get_api_client(currency_to.wallet) order = tx.order if tx.order else tx.limit_order logger.info('Look-up transaction with txid api {} '.format(tx.tx_id_api)) tx_completed, num_confirmations = api.check_tx(tx, currency_to) # Uphold is shit, fall back to external source to confirm tx # num_confirmations < 2 is to fix the uphold bug that returns # 1 for any amount of confirmations # TODO: remove, if and when Uphold API gets better tx_completed, num_confirmations = check_uphold_txn_status_with_blockchain( tx, tx_completed, num_confirmations, logger) tx.confirmations = num_confirmations with transaction.atomic(): tx.save() order_closed = True if isinstance(order, LimitOrder) \ and tx.address_to.type == Address.DEPOSIT: tx_order_book_completed = \ tx.confirmations >= currency_to.min_order_book_confirmations order_is_fresh = \ order.status == order.PAID_UNCONFIRMED \ and order.book_status == order.NEW to_order_book = tx_order_book_completed and order_is_fresh if to_order_book: order.open(tx) order.refresh_from_db() order_closed = order.book_status == order.CLOSED withdrawal_completed = tx.type == Address.WITHDRAW and \ tx_completed and order.status != order.COMPLETED deposit_completed = \ tx.type == Address.DEPOSIT and tx_completed and \ order.status not in order.IN_PAID and order_closed if withdrawal_completed: order.complete(tx) if deposit_completed: confirm_res = order.confirm_deposit(tx) order.refresh_from_db() confirm_status_ok = confirm_res.get('status') == 'OK' if confirm_status_ok and order.status == order.PAID: card_check_time = settings.CARD_CHECK_TIME_BTC \ if tx.currency.code == 'USDT' \ else settings.CARD_CHECK_TIME app.send_task(CHECK_CARD_BALANCE_TASK, [tx.pk], countdown=card_check_time) if tx.currency.is_token: app.send_task(SEND_GAS_TASK, [tx.pk]) if tx.currency.code == "USDT": app.send_task(SEND_BTC_TASK, [tx.pk])
def get_wallet_transactions( self, currency=None, tx_count=settings.RPC_IMPORT_TRANSACTIONS_VALIDATION_COUNT): factory = ApiClientFactory() client = factory.get_api_client(currency.wallet) accounts, name = self.set_client_accounts_name(currency, client) if all([client, accounts, name]): action = 'txlist' if not currency.is_token else 'tokentx' txs = client._list_txs(currency.wallet, tx_count=tx_count, action=action) process_txs_func = getattr(self, 'process_{}_txs'.format(name)) out_txs, in_txs, other_txs = process_txs_func(txs, accounts, client=client, currency=currency) else: return None return {'out_txs': out_txs, 'in_txs': in_txs, 'other_txs': other_txs}
def setUpClass(cls): cls.ENABLED_TICKER_PAIRS = ['USDTBTC', 'BTCUSDT'] super(OmniRawE2ETestCase, cls).setUpClass() cls.import_txs_task = import_transaction_deposit_crypto_invoke cls.update_confirmation_task = update_pending_transactions_invoke cls.factory = ApiClientFactory() cls.api_client = APIClient() cls.USDT = Currency.objects.get(code='USDT') cls.reserves = Reserve.objects.all() for r in cls.reserves: for account in r.account_set.filter(disabled=False): if account.wallet != 'rpc10': account.disabled = True account.save()
class ApiClientsTestCase(TestCase): fixtures = [ 'currency_algorithm.json', 'transaction_price.json', 'currency_crypto.json' ] def __init__(self, *args, **kwargs): super(ApiClientsTestCase, self).__init__(*args, **kwargs) self.factory = ApiClientFactory() def setUp(self): self.BTC = Currency.objects.get(code='BTC') @data_provider(lambda: ( scrypt_check_tx_params(case_name='1 Confirmation, not confirmed', tx_count=1, min_confs=12, expected_return=(False, 1)), scrypt_check_tx_params(case_name='Min Confirmations, confirmed', tx_count=12, min_confs=12, expected_return=(True, 12)), scrypt_check_tx_params(case_name='Min Confirmations 0, not confirmed', tx_count=0, min_confs=0, expected_return=(False, 0)), )) @patch(SCRYPT_ROOT + '_get_tx') def test_check_tx_scrypt(self, get_tx, **kwargs): tx = Transaction(tx_id='123') self.BTC.min_confirmations = kwargs['min_confs'] self.BTC.save() api = self.factory.get_api_client(self.BTC.wallet) get_tx.return_value = {'confirmations': kwargs['tx_count']} res = api.check_tx(tx, self.BTC) self.assertEqual(res, kwargs['expected_return'], kwargs['case_name'])
from functools import wraps from nexchange.api_clients.factory import ApiClientFactory from .models import Order, LimitOrder from nexchange.utils import get_nexchange_logger factory = ApiClientFactory() logger = get_nexchange_logger('Orders Decorator logger') def get_task(**kwargs): def _get_task(task_fn): @wraps(task_fn) def _wrapped_fn(search_val): Task = kwargs.get('task_cls') key = kwargs.get('key') lookup = {key: [search_val]} try: order = Order.objects.get(**lookup) except Order.DoesNotExist: order = None try: limit_order = LimitOrder.objects.get(**lookup) except LimitOrder.DoesNotExist: limit_order = None if bool(limit_order) == bool(order): logger.error( '{} lookup for order found both Order and ' 'LimitOrder'.format(lookup) ) return _order = order if order else limit_order
def __init__(self, *args, **kwargs): super(ApiClientsTestCase, self).__init__(*args, **kwargs) self.factory = ApiClientFactory()
from decimal import Decimal from django.utils.translation import ugettext as _ from django_fsm import FSMIntegerField, transition from django.core.exceptions import ValidationError from django.db.models import Sum from django.utils.timezone import now, timedelta from copy import deepcopy from nexchange.api_clients.bittrex import BittrexApiClient from payments.utils import money_format from audit_log.models import AuthStampedModel from nexchange.api_clients.factory import ApiClientFactory from .utils import get_native_pairs from django.core.exceptions import ObjectDoesNotExist BITTREX_API = BittrexApiClient() API_FACTORY = ApiClientFactory() class Reserve(TimeStampedModel): currency = models.OneToOneField(Currency, on_delete=models.DO_NOTHING) is_limit_reserve = models.BooleanField(default=False) target_level = models.DecimalField(max_digits=18, decimal_places=8, default=Decimal('0')) allowed_diff = models.DecimalField(max_digits=18, decimal_places=8, default=Decimal('0')) maximum_level = models.DecimalField(max_digits=18, decimal_places=8, default=Decimal('0')) minimum_level = models.DecimalField(max_digits=18,