def infoParametersToSellBTC(btc, price, mk_tk, taker):
from function.transacFunction import presellBTC, sellBTC
step = 10
print('Продать btc:', btc)
btc_pre_n = presellBTC(btc, price)
x_n = sellBTC(btc_pre_n, price, mk_tk)['x']
print('btc_pre_0:', btc_pre_n, 'цена:', price, 'X_mt:', x_n, '%_mt', mk_tk)
for i in range(-5, 6):
dp = i * step
price_n = price + dp
btc_pre_n = presellBTC(btc, price_n)
x_n = sellBTC(btc_pre_n, price_n, mk_tk)['x']
x_n_taker = sellBTC(btc_pre_n, price_n, taker)['x']
print(
'btc_pre:',
btc_pre_n,
'цена:',
price_n,
' X_mt:',
x_n,
'X_tk:',
x_n_taker,
'%_mt:',
mk_tk,
)
def BTC_rub_OUT(self):
'''Вывод через USD'''
#Вывод через USD
btc_pre = transf.presellBTC(self.btc,
self.price_tosell_btcrub) # Предрасчет
rub = transf.sellBTC(btc_pre, self.price_tosell_btcrub,
self.mk_tk_rub)['x']
rub_sum = rub + self.x_rub
if (rub < self.limit_rub):
print('! меньше лимита', self.limit_rub)
rub_out = depof.X_WITHD(rub_sum, self.r_out_dep_prc,
self.r_out_dep_fix)
usd_r = exchf.buyUSD(rub_out,
self.usd_s) #Переводим RUB в USD на карте
usd_r2 = exchf.buyUSD(rub_out,
self.old_usd_s) # Переводим USD в рубли на карте
return {
'btc': self.btc,
'btcsell': btc_pre,
'mk_tk': self.mk_tk_rub,
'rub_resed': self.x_rub,
'rub': rub,
'rub_sum': rub_sum,
'rub_out': rub_out,
'usd_r': usd_r,
'usd_r2': usd_r2
}
def BTC_usd_OUT(self):
'''Вывод через USD'''
btc_pre = transf.presellBTC(self.btc, self.price_tosell_btcusd)
usd = transf.sellBTC(btc_pre, self.price_tosell_btcusd,
self.mk_tk_usd)['x'] #Получено при продаже
usd_sum = usd + self.x_usd
if (usd_sum < self.limit_usd):
print('! меньше лимита', self.limit_usd)
return
u_out = depof.X_WITHD(usd_sum, self.u_out_dep_prc,
self.u_out_dep_fix) # На карте
rub_u = exchf.sellUSD(u_out,
self.usd_b) #После перевода в USD на карте
rub_u2 = exchf.sellUSD(u_out, self.old_usd_b)
return {
'btc': self.btc,
'btcsell': btc_pre,
'mk_tk': self.mk_tk_usd,
'usd_resed': self.x_usd,
'usd': usd,
'usd_sum': usd_sum,
'u_out': u_out,
'rub_u': rub_u,
'rub_u2': rub_u2
}
def X_on_DEPOSIT_Y_out(self,
X,
price_tobuy,
price_tosell,
type_x='RUB',
type_y='RUB'):
'''
:param X: Сумма ввода с карты
:param price_tobuy: Цена покупки BTC
:param price_tosell: Цена продажи BTC
:param type_x: валюта ввода
:param type_y: валюта вывода
:return:
'''
dep_in_prc = 1
dep_in_fix = 0
dep_out_prc = 1
dep_out_fix = 0
mk_tk = 0
taker = 0
if (type_x == 'USD'):
dep_in_prc = self.u_in_dep_prc
dep_in_fix = self.u_in_dep_fix
taker = self.taker
elif (type_x == 'RUB'):
dep_in_prc = self.r_in_dep_prc
dep_in_fix = self.r_in_dep_fix
taker = self.taker
if (type_y == 'USD'):
dep_out_prc = self.u_out_dep_prc
dep_out_fix = self.u_out_dep_fix
mk_tk = self.mk_tk_usd
elif (type_y == 'RUB'):
dep_out_prc = self.r_out_dep_prc
dep_out_fix = self.r_out_dep_fix
mk_tk = self.mk_tk_usd
x_depo = depof.X_to_DEPO(X, dep_in_prc, dep_in_fix)
btc1 = transf.buyBTC(x_depo, price_tobuy, taker)['btc']
y2 = transf.sellBTC(btc1, price_tosell, mk_tk)['x']
y_out = depof.X_WITHD(y2, dep_out_prc, dep_out_fix)
dp = None
if (type_x == type_y):
dp = price_tosell - price_tobuy
return {
'x_depo': x_depo,
'btc': btc1,
'y_depo': y2,
'y_out': y_out,
'dp': dp
}
def deltaX(x0, current_price, expected_price, commis):
btc1 = maxBTC(x0, current_price)
x1 = X_for_buyBTC(btc1, current_price, commis)
#dx = x0 - x1 >0 # если комиссия меньше taker, то от x0 что-то должно остаться
x2 = sellBTC(btc1, expected_price, commis)['x'] #после продажи btc
#dX = x2-x0+dx = x2-x0+(x0-x1) = x2-x1
return np.round(x2 - x1, 2)
def BTC_WITHDR(btc, price_btc, mk_tk, comiss_out_pr, commis_out_f):
# mk_tk - коммиссия при транзакции
# comiss_out_pr - комиссия при выводе процент
# commis_out_f - комиссия при выводе фиксированная
#pre sell не использууется, т.к. результат r будет тем же
#т.к. идет просто расчет, с баланса btc не списывается
r = sellBTC(btc, price_btc, mk_tk)
X = r['x'] # сумма на балансе
#вывод с баланса
xOut = X_WITHD(X, comiss_out_pr, commis_out_f)
return xOut
def priceForExpectBTC(btc0, current_price, btc_expected, commis=0):
'''
Для получения btc_expected ждем, чтобы цена уменьшилась
:param btc0: данное кол-во.
:param current_price: текущая цена, по котрой продаем (возможно плюс некоторый процент к цене, чтобы комиссия была по maker)
:param btc_expected: желаемое кол-во BTC
:param commis: комиссия
'''
if (commis == 0):
commis = taker
x = sellBTC(btc0, current_price, commis)['x'] # получаем X при продаже
p = priceForBuyBTC(btc_expected, x)
return {'price', p, 'x', x}
def USD_btc_rub_OUT(self):
'''Вывод с депозита USD, предварительно переведя в RUB'''
add_usd_x = 0
add_rub_x = 0
if (self.add_usd > 0):
add_usd_x = depof.X_to_DEPO(self.add_usd, self.u_in_dep_prc,
self.u_in_dep_fix)
if (self.add_rub > 0):
add_rub_x = depof.X_to_DEPO(self.add_rub, self.r_in_dep_prc,
self.r_in_dep_fix)
#Второй вариант вывода
usd = self.x_usd + add_usd_x
btc = transf.buyBTC(usd, self.price_tobuy_btcusd)
btc_max = btc['btc'] #максимольное кол-во BTC
dx = btc['dx'] #Остаток USD
btc_sum = btc_max + self.btc
btc_pre = transf.presellBTC(btc_sum, self.price_tosell_btcrub)
rub = transf.sellBTC(btc_pre, self.price_tosell_btcrub, self.mk_tk_rub)
rub = rub + add_rub_x + self.x_rub
rub_out = depof.X_WITHD(rub, self.r_out_dep_prc,
self.r_out_dep_fix) #На карте
usd_r = exchf.buyUSD(rub_out, self.usd_s) #Перевести в USD на карте
usd_r_old = exchf.buyUSD(rub_out,
self.old_usd_s) # Перевести в USD на карте
return {
'usd': usd,
'btc_max': btc_max,
'dx': dx,
'btc_sum': btc_sum,
'btc_pre': btc_pre,
'mk_tk_rub': self.mk_tk_rub,
'rub': rub,
'rub_add': add_rub_x,
'rub_resed': self.x_rub,
'rub_out': rub_out,
'usd_r': usd_r,
'usd_r_old': usd_r_old
}
def deltaBTC(btc0, current_price, expected_price, commis=0):
'''
:param btc0: количество BTC на балансе
:param current_price: если продать по данной цене (например текущая)
:param expected_price: затем купить по этой цене
:param commis: комиссия при транзакциях. По умолчанию берется средняя. Можно рассчитать случай по текущей цене тогда комиссию надо брать максимальной по taker
:return: возвращает изменение BTC на балансе
так же расчитывает какое кол-во BTC теряется
'''
if (commis == 0):
commis = mk_tk
btc1 = presellBTC(btc0, current_price)
dbtc = btc0 - btc1 # остаток на балансе
x = sellBTC(btc0, current_price, commis)['x'] # получаем после продажи
btc = maxBTC(x, expected_price) # после покупки по новой цене
return {'delta': btc - btc0 + dbtc, 'btc': btc}
def RUB_btc_usd_OUT(self, add_rub=0, add_usd=0):
'''Вывод с депозита RUB, предварительно переведя в USD'''
add_usd_x = 0
add_rub_x = 0
if (add_usd > 0):
add_usd_x = depof.X_to_DEPO(add_usd, self.u_in_dep_prc,
self.u_in_dep_fix)
if (add_rub > 0):
add_rub_x = depof.X_to_DEPO(add_rub, self.r_in_dep_prc,
self.r_in_dep_fix)
rub = self.x_rub + add_rub_x
btc = transf.buyBTC(rub, self.price_tobuy_btcrub)
btc_max = btc['btc'] # максимольное кол-во BTC
dx = btc['dx'] # Остаток RUB
btc_sum = btc_max + self.btc
btc_pre = transf.presellBTC(btc_max, self.price_tosell_btcusd)
usd = transf.sellBTC(btc_pre, self.price_tosell_btcusd, self.mk_tk_usd)
usd = usd + add_usd_x + self.x_usd
usd_out = depof.X_WITHD(usd, self.u_out_dep_prc,
self.u_out_dep_fix) # USD на карте
rub_u = exchf.sellUSD(usd_out, self.usd_b) # Перевод в RUB
rub_u2 = exchf.sellUSD(usd_out, self.old_usd_b)
return {
'rub': rub,
'btc_max': btc_max,
'dx': dx,
'btc_sum': btc_sum,
'btc_pre': btc_pre,
'usd': usd,
'usd_add': add_usd_x,
'usd_resed': self.x_usd,
'usd_out': usd_out,
'rub_u': rub_u,
'rub_u2': rub_u2
}
def BTC_x_OUT(self, type):
#init
price_tosell_btc = 1
mk_tk = 1
x_lim = 0
x0 = 0
x_out_dep_prc = 1
x_out_dep_fix = 0
if (self.btc == 0):
print('На балансе 0 BTC')
return {'btc': 0}
'''Вывод через USD'''
if (type == 'USD'):
price_tosell_btc = self.price_tosell_btcusd
mk_tk = self.mk_tk_usd
x_lim = self.limit_usd
x0 = self.x_usd
x_out_dep_prc = self.u_out_dep_prc
x_out_dep_fix = self.u_out_dep_fix
exch_price = self.usd_b
exch_price2 = self.old_usd_b
def exch_curr(x, exch_price):
return exchf.sellUSD(x, exch_price)
'''Вывод через RUB'''
if (type == 'RUB'):
price_tosell_btc = self.price_tosell_btcrub
mk_tk = self.mk_tk_rub
x_lim = self.limit_rub
x0 = self.x_rub
x_out_dep_prc = self.r_out_dep_prc
x_out_dep_fix = self.r_out_dep_fix
exch_price = self.usd_s
exch_price2 = self.old_usd_s
def exch_curr(x, exch_price):
return exchf.buyUSD(x, exch_price)
btc_pre = transf.presellBTC(self.btc, price_tosell_btc)
x = transf.sellBTC(btc_pre, price_tosell_btc,
mk_tk)['x'] #Получено при продаже
x_sum = x + x0
if (x_sum < x_lim):
print('! меньше лимита', x_lim)
return
x_out = depof.X_WITHD(x_sum, x_out_dep_prc, x_out_dep_fix) # На карте
x_cur = exch_curr(x_out, exch_price) #После перевода в USD на карте
x_cur2 = exch_curr(x_out, exch_price2)
return {
'btc': self.btc,
'btcsell': btc_pre,
'mk_tk': mk_tk,
'x_resed': x0,
'x': x #сумма после продажи btc
,
'x_sum': x_sum #с учетом остатка на депозите
,
'x_out': x_out #вывелось на карту
,
'x_cur': x_cur #после перевода в другую валюту
,
'x_cur2': x_cur2 #перевод в другую валюту по старому курсу
}