Example #1
0
    def USD_DEPO_BTC_v2(self):
        '''
        Перевод USD в RUB
        Перевод RUB на депозит
        Покупка BTC
        :return:
        '''

        if (self.x_usd == 0):
            print("Для USD_DEPO_BTC_v2 не заданы параметры setX")
            return

        if (self.price_tobuy_btcrub == 0):
            print("Для USD_DEPO_BTC_v2 не заданы параметры setRubPrmt")

        rub = exchf.sellUSD(self.x_usd,
                            self.usd_b)  # перевод USD в RUB до депозита

        x_depo = depof.X_to_DEPO(rub, self.r_dep_prc,
                                 self.r_dep_fix)  # перевод на депозит
        x_depo_sum = x_depo + self.resedual_rub
        btc_buy = transf.buyBTC(x_depo_sum, self.price_tobuy_btcrub,
                                self.mk_tk_rub)  # покупка BTC
        btc = btc_buy['btc']
        x_resed = btc_buy['dx']  # остаток X

        return {
            'x': self.x_usd,
            'x_exch': rub,
            'x_depo': x_depo,
            'x_depo_sum': x_depo_sum,
            'btc': btc,
            'x_resed': x_resed,
            'price_r': self.price_tobuy_btcrub
        }
Example #2
0
    def USD_DEPO_BTC(self):
        '''
        Перевод USD с карты
        и покупка BTC
        :return:
        '''

        if (self.x_usd == 0):
            print("Для USD_DEPO_BTC не заданы параметры setUsdPrmt и setX")
            return

        # Покупка BTC за USD Первоначальная
        # на депозит
        x_depo = depof.X_to_DEPO(self.x_usd, self.u_dep_prc,
                                 self.u_dep_fix)  # перевод на депозит
        x_depo_sum = x_depo + self.resedual_usd
        btc_buy = transf.buyBTC(
            x_depo_sum, self.price_tobuy_btcusd,
            self.mk_tk_usd)  # покупка BTC максимальное кол-во
        btc = btc_buy['btc']
        x_resed = btc_buy['dx']  #остаток X

        return {
            'x': self.x_usd,
            'x_depo': x_depo,
            'x_depo_sum': x_depo_sum,
            'btc': btc,
            'x_resed': x_resed,
            'price_u': self.price_tobuy_btcusd
        }
Example #3
0
    def RUB_DEPO_BTC_v2(self):
        '''
        Перевод RUB в USD
        Перевод USD на депозит
        Покупка BTC
        '''

        usd = exchf.buyUSD(self.x_rub, self.usd_s)  # покупка USD

        x_depo = depof.X_to_DEPO(usd, self.u_dep_prc,
                                 self.u_dep_fix)  # перевод на депозит
        x_depo_sum = x_depo + self.resedual_usd
        btc0_u = transf.buyBTC(x_depo_sum, self.price_tobuy_btcusd,
                               self.mk_tk_usd)  # покупка BTC
        btc = btc0_u['btc']
        x_resed = btc0_u['dx']  # остаток X

        return {
            'x': self.x_rub,
            'x_exch': usd,
            'x_depo': x_depo,
            'x_depo_sum': x_depo_sum,
            'btc': btc,
            'x_resed': x_resed,
            'price_u': self.price_tobuy_btcusd
        }
Example #4
0
    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
        }
Example #5
0
    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
        }
Example #6
0
    def X_DEPO_BTC(self, type='USD'):
        '''
        Перевод USD с карты
        и покупка BTC
        :return:
        '''

        #init
        x = 1
        dep_prc = 1
        dep_fix = 0
        resedual_x = 0
        price_tobuy_btc = 1
        mk_tk = 0

        if (type == 'USD'):
            x = self.x_usd
            dep_prc = self.u_dep_prc
            dep_fix = self.u_dep_fix
            resedual_x = self.resedual_usd
            price_tobuy_btc = self.price_tobuy_btcusd
            mk_tk = self.mk_tk_usd

            if (self.x_usd == 0):
                print("Для USD_DEPO_BTC не заданы параметры setUsdPrmt и setX")
                return

        if ('type' == 'RUB'):
            x = self.x_rub
            dep_prc = self.r_dep_prc
            dep_fix = self.r_dep_fix
            resedual_x = self.resedual_rub
            price_tobuy_btc = self.price_tobuy_btcrub
            mk_tk = self.mk_tk_rub

            if (self.x_rub == 0):
                print("Для RUB_DEPO_BTC не заданы параметры setRubPrmt и setX")
                return

        # Покупка BTC за USD Первоначальная
        # на депозит
        x_depo = depof.X_to_DEPO(x, dep_prc, dep_fix)  # перевод на депозит
        x_depo_sum = x_depo + resedual_x
        btc_buy = transf.buyBTC(x_depo_sum, price_tobuy_btc,
                                mk_tk)  # покупка BTC максимальное кол-во
        btc = btc_buy['btc']
        x_resed = btc_buy['dx']  #остаток X

        return {
            'x': x,
            'x_depo': x_depo,
            'x_depo_sum': x_depo_sum,
            'btc': btc,
            'x_resed': x_resed,
            'price': price_tobuy_btc
        }
Example #7
0
    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
        }
Example #8
0
    def USD_OUT(self):

        add_usd_d = 0
        if (self.add_usd > 0):
            add_usd_d = depof.X_to_DEPO(self.add_usd, self.u_in_dep_prc,
                                        self.u_in_dep_fix)  #уйдет на депозит

        usd = self.x_usd + add_usd_d
        usd_out = depof.X_WITHD(usd, self.u_out_dep_prc,
                                self.u_out_dep_fix)  #USD на карте

        rub_x = exchf.sellUSD(usd_out, self.usd_b)  #Перевод в RUB
        rub_x2 = exchf.sellUSD(usd_out, self.old_usd_b)  # Перевод в RUB

        return {
            'x': usd,
            'add_usd': self.add_usd,
            'add_usd_dep': add_usd_d,
            'usd_out': usd_out,
            'rub': rub_x,
            'rub2': rub_x2
        }
Example #9
0
    def RUB_OUT(self):
        '''Вывод с депозита RUB'''

        add_rub_x = 0

        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)

        rub = self.x_rub + add_rub_x
        rub_out = depof.X_WITHD(rub, self.r_out_dep_prc,
                                self.r_out_dep_fix)  # RUB на карте

        usd_r = exchf.buyUSD(rub_out, self.usd_s)
        usd_r2 = exchf.buyUSD(rub_out, self.old_usd_s)

        return {
            'x': rub,
            'add_rub': self.add_rub,
            'add_rub_x': add_rub_x,
            'rub_out': rub_out,
            'usd': usd_r,
            'usd2': usd_r2
        }
Example #10
0
    def RUB_DEPO_BTC(self):
        '''
        Перевод RUB с карты
        и покупка BTC
        :return:
        '''

        # Покупка BTC за RUB Первый вариант
        x_depo = depof.X_to_DEPO(self.x_rub, self.r_dep_prc,
                                 self.r_dep_fix)  # RUB на депозите
        x_depo_sum = x_depo + self.resedual_rub
        btc_r = transf.buyBTC(x_depo_sum, self.price_tobuy_btcrub,
                              self.mk_tk_rub)  # покупка BTC.
        btc = btc_r['btc']
        x_res = btc_r['dx']  # остаток X

        return {
            'x': self.x_rub,
            'x_depo': x_depo,
            'x_depo_sum': x_depo_sum,
            'btc': btc,
            'x_resed': x_res,
            'price_r': self.price_tobuy_btcrub
        }
Example #11
0
    def X_OUT(self, type):

        #init
        x0 = 0
        add_x = 0
        add_x_dep = 0
        out_dep_pr = 1
        out_dep_fix = 0
        in_dep_pr = 1
        in_dep_fix = 0

        if (type == 'USD'):
            x0 = self.x_usd
            add_x = self.add_usd

            out_dep_pr = self.u_out_dep_prc
            out_dep_fix = self.u_out_dep_fix
            in_dep_pr = self.u_in_dep_prc
            in_dep_fix = self.u_in_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)

        if (type == 'RUB'):
            x0 = self.x_rub
            add_x = self.add_rub

            out_dep_pr = self.r_out_dep_prc
            out_dep_fix = self.r_out_dep_fix
            in_dep_pr = self.r_in_dep_prc
            in_dep_fix = self.r_in_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)

        if (add_x > 0):
            add_x_dep = depof.X_to_DEPO(add_x, in_dep_pr,
                                        in_dep_fix)  #уйдет на депозит

        x = x0 + add_x_dep
        x_out = depof.X_WITHD(x, out_dep_pr, out_dep_fix)  #X на карте

        x_curr = exch_curr(x_out, exch_price)  #Перевод X в Другую валюту
        x_curr2 = exch_curr(
            x_out, exch_price2)  #Перевод X в Другую валюту по другому курсу

        return {
            'x': x,
            'add_usd': add_x  #сумма, добавленная на депозит
            ,
            'add_usd_dep': add_x_dep  #сумма надепозите
            ,
            'usd_out': x_out  #выедена с депозита
            ,
            'xcur': x_curr  #переведена в другую валюту
            ,
            'xcur2': x_curr2
        }  #по старому курсу
Example #12
0
 def d_deposit(r):
     return depof.X_to_DEPO(r, self.r_in_dep_prc, self.r_in_dep_fix)
Example #13
0
    def X_DEPO_BTC_v2(self, type='USD'):
        '''
        Перевод USD в RUB
        Перевод RUB на депозит
        Покупка BTC
        :return:
        '''

        #XB - валюта 1 базовая
        #XQ - валюта 2 (currency)

        # init
        x = 1
        dep_prc = 1
        dep_fix = 0
        resedual_x = 0
        price_tobuy_btc = 1
        mk_tk = 0

        if (type == 'USD'):
            x0 = self.x_usd
            dep_prc = self.u_dep_prc
            dep_fix = self.u_dep_fix
            resedual_x = self.resedual_usd
            price_tobuy_btc = self.price_tobuy_btcusd
            mk_tk = self.mk_tk_usd

            if (self.x_usd == 0):
                print("Для USD_DEPO_BTC_v2 не заданы параметры setX")
                return

            if (self.price_tobuy_btcrub == 0):
                print("Для USD_DEPO_BTC_v2 не заданы параметры setRubPrmt")

            x = exchf.sellUSD(x, self.usd_b)  # перевод USD в RUB до депозита

        if ('type' == 'RUB'):
            x0 = self.x_rub
            dep_prc = self.r_dep_prc
            dep_fix = self.r_dep_fix
            resedual_x = self.resedual_rub
            price_tobuy_btc = self.price_tobuy_btcrub
            mk_tk = self.mk_tk_rub

            if (self.x_rub == 0):
                print("Для RUB_DEPO_BTC_v2 не заданы параметры setX")
                return

            if (self.price_tobuy_btcusd == 0):
                print("Для RUB_DEPO_BTC_v2 не заданы параметры setUsdPrmt")

            x = exchf.buyUSD(x, self.usd_s)  # перевод RUB в USD до депозита

        x_depo = depof.X_to_DEPO(x, dep_prc, dep_fix)  # перевод на депозит
        x_depo_sum = x_depo + resedual_x
        btc_buy = transf.buyBTC(x_depo_sum, price_tobuy_btc,
                                mk_tk)  # покупка BTC
        btc = btc_buy['btc']
        x_resed = btc_buy['dx']  # остаток X

        return {
            'x': self.x_usd,
            'x_exch': x,
            'x_depo': x_depo,
            'x_depo_sum': x_depo_sum,
            'btc': btc,
            'x_resed': x_resed,
            'price': price_tobuy_btc
        }