def freeze_payments(amount, network):
if network == 'EOS_MAINNET':
#if currency in ('EOS', 'EOSISH'):
value = amount * 0.15 * NET_DECIMALS['EOSISH'] / NET_DECIMALS['ETH']
value *= rate('WISH', 'EOSISH').value
#value = float(':.4f'.format(value)
FreezeBalance.objects.select_for_update().filter(id=1).update(
eosish=F('eosish') + value)
print('FREEZE', value, 'EOSISH', flush=True)
elif network == 'TRON_MAINNET':
#elif currency in ('TRON', 'TRONISH'):
value = amount * 0.10 * NET_DECIMALS['TRX'] / NET_DECIMALS['ETH']
value *= rate('WISH', 'TRONISH').value
FreezeBalance.objects.select_for_update().filter(id=1).update(
tronish=F('tronish') + int(value))
wish_value = amount * 0.10
FreezeBalance.objects.select_for_update().filter(id=1).update(
wish=F('wish') + wish_value)
print('FREEZE', int(value), 'TRONISH', flush=True)
#print('FREEZE', wish_value, 'WISH', flush=True)
#elif currency in ('BNB', 'BWISH'):
else:
value = amount * 0.10
FreezeBalance.objects.select_for_update().filter(id=1).update(
bwish=F('bwish') + value)
print('FREEZE', value, 'BWISH', flush=True)
def calculate_cost_eos_account(request):
'''
calculate cost eos account with getting params
cpu, net, ram
:param request: contain cpu, net, ram
:return: cost
'''
token = request.META['HTTP_TOKEN']
if not token:
raise ValidationError({'result': 'Token not found'}, code=404)
get_user_for_token(token)
log_userinfo('calculate_cost_eos_account', token)
print('data in request', request.data, flush=True)
ram = request.data['buy_ram_kbytes']
net = request.data['stake_net_value']
cpu = request.data['stake_cpu_value']
eos_cost = calc_eos_cost(cpu, net, ram)
print('eos cost', eos_cost, flush=True)
return JsonResponse({
'EOS': str(eos_cost),
'EOSISH': str(eos_cost * rate('EOS', 'EOSISH').value),
'ETH': str(eos_cost * rate('EOS', 'ETH').value),
'WISH': str(eos_cost * rate('EOS', 'WISH').value),
'BTC': str(eos_cost * rate('EOS', 'BTC').value),
})
def exc_rate(request):
fsym = request.query_params['fsym']
tsyms = request.query_params['tsyms'].split(',')
response = {}
for tsym in tsyms:
response[tsym] = rate(fsym, tsym).value
print(f'{fsym} -> {tsym} rate(s) is', response, flush=True)
return Response(response)
def calculate_cost_eos_account_contract(request):
'''
calculate cost eos account
:param request: contain contract_id
:return: cost
'''
token = request.META['HTTP_TOKEN']
if not token:
raise ValidationError({'result': 'Token not found'}, code=404)
user = get_user_for_token(token)
contract_id = int(request.data['contract_id'])
log_action_name = 'calculate_cost_eos_account_contract'
log_userinfo(log_action_name, token, user, contract_id)
contract = Contract.objects.get(id=contract_id)
if contract.state != 'CREATED':
raise ValidationError({'result': 'Wrong status in contract'}, code=404)
if contract.contract_type != 11:
raise ValidationError({'result': 'Wrong contract_type'}, code=404)
if contract.user != user:
raise ValidationError({'result': 'Wrong token'}, code=404)
if contract.invisible:
raise ValidationError({'result': 'Contract is deleted'}, code=404)
details = contract.get_details()
log_additions(log_action_name, details)
network = Network.objects.get(name='EOS_MAINNET')
params = {
'stake_net_value': details.stake_net_value,
'stake_cpu_value': details.stake_cpu_value,
'buy_ram_kbytes': details.buy_ram_kbytes
}
eos_cost = ContractDetailsEOSAccount.calc_cost_eos(params, network) / 10**4
print('eos cost', eos_cost, flush=True)
return JsonResponse({
'EOS': str(eos_cost),
'EOSISH': str(eos_cost * rate('EOS', 'EOSISH').value),
'ETH': str(eos_cost * rate('EOS', 'ETH').value),
'WISH': str(eos_cost * rate('EOS', 'WISH').value),
'BTC': str(eos_cost * rate('EOS', 'BTC').value),
})
def advanced_rate_view(request):
fsyms = request.query_params['fsyms'].split(',')
tsyms = request.query_params['tsyms'].split(',')
response = {}
for fsym in fsyms:
rates = {}
for tsym in tsyms:
rate_obj = rate(fsym, tsym)
rates[tsym] = {
'rate': rate_obj.value,
'is_24h_up': rate_obj.is_up_24h,
}
response[fsym] = rates
return JsonResponse(response)
def calc_cost(kwargs, network):
if NETWORKS[network.name]['is_free']:
return 0
eos_cost_base = CONTRACT_PRICE_USDT['EOS_ACCOUNT'] * NET_DECIMALS[
'USDT']
eos_cost = ContractDetailsEOSAccount.calc_cost_eos(
kwargs, network) / NET_DECIMALS['EOS']
cost = eos_cost * rate('EOS', 'ETH').value
print('convert eos cost', cost, flush=True)
converted_cost = round(cost, 2) * NET_DECIMALS['USDT']
if converted_cost < eos_cost_base:
final_cost = eos_cost_base
else:
final_cost = converted_cost
return final_cost
def deploy_eos_account(request):
'''
view for deploy eos ac count
:param request: contain contract id
:return:
'''
token = request.META['HTTP_TOKEN']
if not token:
raise ValidationError({'result': 'Token not found'}, code=404)
user = get_user_for_token(token)
log_action_name = 'deploy_eos_account'
contract_id = int(request.data.get('contract_id'))
log_userinfo(log_action_name, token, user, contract_id)
contract = Contract.objects.get(id=contract_id)
if contract.user != user:
raise ValidationError({'result': 'Wrong contract_id'}, code=404)
if contract.invisible:
raise ValidationError({'result': 'Contract is deleted'}, code=404)
if contract.state != 'CREATED':
raise ValidationError({'result': 'Wrong state'}, code=404)
contract_details = contract.get_details()
log_additions(log_action_name, request.data)
check_account_name(contract_details.account_name, contract.network.id)
contract_details.predeploy_validate()
if contract.network.id == 10:
network = Network.objects.get(name='EOS_MAINNET')
params = {
'stake_net_value': contract_details.stake_net_value,
'stake_cpu_value': contract_details.stake_cpu_value,
'buy_ram_kbytes': contract_details.buy_ram_kbytes
}
eosish_cost = contract_details.calc_cost_eos(params, network)
eos_cost = (int(eosish_cost) * rate('EOS', 'EOSISH').value)
if 'promo' in request.data:
promo = request.data['promo'].upper()
user_balance = UserSiteBalance.objects.get(
user=user, subsite__site_name=EOSISH_URL).balance
eos_cost = check_promocode_in_api(promo, 10, user, user_balance,
contract.id, eos_cost)
if not UserSiteBalance.objects.select_for_update().filter(
user=user, subsite__site_name=EOSISH_URL,
balance__gte=eos_cost).update(balance=F('balance') - eos_cost):
raise ValidationError({'result': 'You have not money'}, code=400)
contract.state = 'WAITING_FOR_DEPLOYMENT'
contract.save()
queue = NETWORKS[contract.network.name]['queue']
send_in_queue(contract.id, 'launch', queue)
return Response({'id': contract.id, 'state': contract.state})
def get_discount(request):
if request.user.is_anonymous:
raise PermissionDenied()
host = request.META['HTTP_HOST']
user = request.user
contract_type = request.query_params['contract_type']
promo_str = request.query_params['promo']
discount = check_and_get_discount(promo_str, contract_type, user)
answer = {'discount': discount}
if 'contract_id' in request.query_params:
contract = Contract.objects.get(id=request.query_params['contract_id'])
contract_details = contract.get_details()
if host == EOSISH_URL:
kwargs = ContractSerializer().get_details_serializer(
contract.contract_type)().to_representation(contract_details)
cost = contract_details.calc_cost_eos(
kwargs, contract.network) * (100 - discount) / 100
answer['discount_price'] = {
'EOS': cost,
'EOSISH': str(float(cost) * rate('EOS', 'EOSISH').value)
}
elif host == MY_WISH_URL:
options_cost = 0
if contract.contract_type in (5, 28) and contract_details.authio:
options_cost += AUTHIO_PRICE_USDT * NET_DECIMALS['USDT']
if contract.contract_type in VERIFICATION_CONTRACTS_IDS and contract_details.verification:
options_cost += VERIFICATION_PRICE_USDT * NET_DECIMALS['USDT']
cost = (contract.cost -
options_cost) * (100 - discount) / 100 + options_cost
answer['discount_price'] = {
'USDT':
str(cost),
'ETH':
str(int(
int(cost) / 10**6 * rate('USDT', 'ETH').value * 10**18)),
'WISH':
str(
int(
int(cost) / 10**6 * rate('USDT', 'WISH').value *
10**18)),
'BTC':
str(int(int(cost) / 10**6 * rate('USDT', 'BTC').value *
10**8)),
'TRX':
str(int(int(cost) * rate('ETH', 'TRX').value)),
'TRONISH':
str(int(int(cost) * rate('ETH', 'TRX').value))
}
elif host == TRON_URL:
kwargs = ContractSerializer().get_details_serializer(
contract.contract_type)().to_representation(contract_details)
cost = contract_details.calc_cost_tron(
kwargs, contract.network) * (100 - discount) / 100
answer['discount_price'] = {'TRX': int(cost), 'TRONISH': int(cost)}
elif host == WAVES_URL:
kwargs = ContractSerializer().get_details_serializer(
contract.contract_type)().to_representation(contract_details)
cost = contract_details.calc_cost(
kwargs, contract.network) * (100 - discount) / 100
answer['discount_price'] = {
'USDT':
str(cost),
'ETH':
str(int(
int(cost) / 10**6 * rate('USDT', 'ETH').value * 10**18)),
'WISH':
str(
int(
int(cost) / 10**6 * rate('USDT', 'WISH').value *
10**18)),
'BTC':
str(int(int(cost) / 10**6 * rate('USDT', 'BTC').value *
10**8)),
'TRX':
str(int(int(cost) * rate('ETH', 'TRX').value)),
'TRONISH':
str(int(int(cost) * rate('ETH', 'TRX').value))
}
else:
kwargs = ContractSerializer().get_details_serializer(
contract.contract_type)().to_representation(contract_details)
cost = contract_details.calc_cost(
kwargs, contract.network) * (100 - discount) / 100
answer['discount_price'] = {
'ETH':
str(cost),
'WISH':
str(int(cost * rate('ETH', 'WISH').value)),
'BTC':
str(int(cost * rate('ETH', 'BTC').value)),
'TRX':
str(int(cost) / 10**18 * rate('ETH', 'TRX').value * 10**6),
'TRONISH':
str(int(cost) / 10**18 * rate('ETH', 'TRONISH').value * 10**6)
}
return Response(answer)
def eth2rub(request):
return Response({'RUB': rate('ETH', 'RUB').value})
def profile_view(request):
site_name = request.META['HTTP_HOST']
print('site is', site_name, flush=True)
if request.user.is_anonymous:
print('anonymous', flush=True)
raise PermissionDenied()
if site_name.startswith('cn'):
site_name = site_name[2:]
if site_name.startswith('local'):
print('cut local')
site_name = site_name[5:]
if site_name.startswith('trondev'):
site_name = site_name.replace('trondev', 'dev')
if site_name == WAVES_URL:
site_name = MY_WISH_URL
if site_name == RUBIC_EXC_URL:
site_name = SWAPS_URL
site = SubSite.objects.get(site_name=site_name)
user_balance = UserSiteBalance.objects.get(subsite=site, user=request.user)
if request.user.email:
user_name = request.user.email
elif request.user.first_name or request.user.last_name:
user_name = '{} {}'.format(request.user.first_name, request.user.last_name)
else:
user_name = request.user.username
swaps_notifications = None
swaps_notification_email = None
swaps_notification_telegram_name = None
swaps_notification_type = None
swaps_notification_set = request.user.swapsnotificationdefaults_set.all()
if swaps_notification_set:
swaps_notification_set = swaps_notification_set.first()
swaps_notification_email = swaps_notification_set.email
swaps_notification_telegram_name = swaps_notification_set.telegram_name
swaps_notification_type = swaps_notification_set.notification
swaps_notifications = {
'email': swaps_notification_email,
'telegram_name': swaps_notification_telegram_name,
'notification': swaps_notification_type
}
answer = {
'username': user_name,
'contracts': Contract.objects.filter(user=request.user).count(),
'balance': str(user_balance.balance),
'internal_address': user_balance.eth_address,
'internal_btc_address': user_balance.btc_address,
'use_totp': request.user.profile.use_totp,
'is_social': request.user.profile.is_social,
'id': request.user.id,
'lang': request.user.profile.lang,
'memo': user_balance.memo,
'eos_address': 'mywishcoming',
'bnb_address': BINANCE_PAYMENT_ADDRESS,
'tron_address': hex2tronwif(user_balance.tron_address) if user_balance.tron_address else '',
'usdt_balance': str(int(int(user_balance.balance) / 10 ** 18 * rate('WISH', 'USDT').value * 10 ** 6)),
'is_swaps_admin': request.user.profile.is_swaps_admin,
'swaps_notifications': swaps_notifications
}
return Response(answer)
def create_payment(uid, tx, currency, amount, site_id, network=None):
amount = float(amount)
if amount == 0.0:
return
print('create payment')
if (SubSite.objects.get(id=site_id).site_name == MY_WISH_URL
or SubSite.objects.get(id=site_id).site_name == TRON_URL):
if currency in ['BWISH', 'BBNB', 'BSCWISH', 'WWISH']:
amount = amount * 10**10
if currency == 'BBNB':
currency = 'BNB'
else:
amount *= 1.1
value = amount if (currency in [
'WISH', 'BWISH', 'BSCWISH', 'WWISH'
]) else amount * rate(currency, 'WISH').value
if currency == 'BTC':
value = value * NET_DECIMALS['ETH'] / NET_DECIMALS['BTC']
if currency in ['TRON', 'TRX', 'TRONISH']:
value = value * NET_DECIMALS['ETH'] / NET_DECIMALS['TRX']
if currency in ['EOS', 'EOSISH']:
value = value * NET_DECIMALS['ETH'] / NET_DECIMALS['EOS']
if currency == 'USDT':
value = value * NET_DECIMALS['ETH'] / NET_DECIMALS['USDT']
elif SubSite.objects.get(id=site_id).site_name in [
SWAPS_URL, RUBIC_EXC_URL, RUBIC_FIN_URL
]:
value = amount if currency == 'USDT' else amount * float(
rate(currency,
'USDT').value) / NET_DECIMALS[currency] * NET_DECIMALS['USDT']
elif SubSite.objects.get(id=site_id).site_name == TOKEN_PROTECTOR_URL:
value = amount if currency == 'USDT' else amount * float(
rate(currency,
'USDT').value) / NET_DECIMALS[currency] * NET_DECIMALS['USDT']
else:
amount = calculate_decimals(currency, amount)
value = amount if currency == 'EOSISH' else amount * rate(
currency, 'EOSISH').value * NET_DECIMALS['EOSISH']
amount = add_decimals(currency, amount)
user = User.objects.get(id=uid)
if amount < 0.0:
if site_id == 4 or site_id == 5:
try:
negative_payment(user, -value, site_id, network)
except:
print('-5% payment', flush=True)
value = value * 0.95
negative_payment(user, -value, site_id, network)
else:
negative_payment(user, -value, site_id, network)
else:
positive_payment(user, value, site_id, currency, amount)
site = SubSite.objects.get(id=site_id)
InternalPayment(user_id=uid,
delta=value,
tx_hash=tx,
original_currency=currency,
original_delta=str(amount),
site=site).save()
print('PAYMENT: Created', flush=True)
print(
'PAYMENT: Received {amount} {curr} ({wish_value} WISH) from user {email}, id {user_id} with TXID: {txid} at site: {sitename}'
.format(amount=amount,
curr=currency,
wish_value=value,
email=user,
user_id=uid,
txid=tx,
sitename=site_id),
flush=True)
def create_payment(uid, tx, currency, amount, site_id, network=None):
amount = float(amount)
if amount == 0.0:
return
print('create payment')
if tx and InternalPayment.objects.filter(
tx_hash=tx).count(): # tx='' if payment received from frontend
print(f'tx hash {tx} already processed')
raise PaymentAlreadyRegistered
if (SubSite.objects.get(id=site_id).site_name == MY_WISH_URL
or SubSite.objects.get(id=site_id).site_name == TRON_URL):
if currency in ['BWISH', 'BBNB', 'BSCWISH', 'WWISH']:
amount = amount * 10**10
if currency == 'BBNB':
currency = 'BNB'
else:
amount *= 1.1
value = amount if (currency in [
'WISH', 'BWISH', 'BSCWISH', 'WWISH'
]) else amount * rate(currency, 'WISH').value
if currency == 'BTC':
value = value * NET_DECIMALS['ETH'] / NET_DECIMALS['BTC']
if currency in ['TRON', 'TRX', 'TRONISH']:
value = value * NET_DECIMALS['ETH'] / NET_DECIMALS['TRX']
if currency in ['EOS', 'EOSISH']:
value = value * NET_DECIMALS['ETH'] / NET_DECIMALS['EOS']
if currency == 'USDT':
value = value * NET_DECIMALS['ETH'] / NET_DECIMALS['USDT']
elif SubSite.objects.get(id=site_id).site_name in [
SWAPS_URL, RUBIC_EXC_URL, RUBIC_FIN_URL
]:
value = amount if currency == 'USDT' else amount * float(
rate(currency,
'USDT').value) / NET_DECIMALS[currency] * NET_DECIMALS['USDT']
elif SubSite.objects.get(id=site_id).site_name == TOKEN_PROTECTOR_URL:
value = amount if currency == 'USDT' else amount * float(
rate(currency,
'USDT').value) / NET_DECIMALS[currency] * NET_DECIMALS['USDT']
else:
amount = calculate_decimals(currency, amount)
value = amount if currency == 'EOSISH' else amount * rate(
currency, 'EOSISH').value * NET_DECIMALS['EOSISH']
amount = add_decimals(currency, amount)
user = User.objects.get(id=uid)
if amount < 0.0:
if site_id == 4 or site_id == 5:
try:
negative_payment(user, -value, site_id, network)
except:
print('-5% payment', flush=True)
value = value * 0.95
negative_payment(user, -value, site_id, network)
else:
negative_payment(user, -value, site_id, network)
else:
positive_payment(user, value, site_id, currency, amount)
link = NETWORKS.get(network, '').get('link_tx', '').format(tx=tx)
text = tx if not link else 'hash'
msg = '<a>[RECEIVED NEW PAYMENT]\n{amount} {curr}\n({wish_value} WISH)\nfrom user {email}, id {user_id}</a><a href="{url}">\n{text}</a>' \
.format(amount=make_readable(amount, currency), wish_value=make_readable(value, 'WISH'),
curr=currency, email=user, user_id=uid, url=link, text=text)
transaction.on_commit(lambda: send_message_to_subs.delay(msg, True))
site = SubSite.objects.get(id=site_id)
InternalPayment(user_id=uid,
delta=value,
tx_hash=tx,
original_currency=currency,
original_delta=str(amount),
site=site).save()
print('PAYMENT: Created', flush=True)
print(
'PAYMENT: Received {amount} {curr} ({wish_value} WISH) from user {email}, id {user_id} with TXID: {txid} at site: {sitename}'
.format(amount=amount,
curr=currency,
wish_value=value,
email=user,
user_id=uid,
txid=tx,
sitename=site_id),
flush=True)
