Esempio n. 1
0
def getBalance():
    """
    返回 btc/usdt/ft的持仓信息
    :return:
    """
    public_balance_deal = Fcoin()
    public_balance_deal.auth(accessKey, secretyKey)
    result, data = public_balance_deal.get_balance()

    btc_num = 0
    usdt_num = 0
    ft_num = 0
    if str(data["status"]) == "0":
        for info in data["data"]:
            currency = info["currency"].lower()
            if currency == "btc":
                btc_num = float(info["balance"])

            if currency == "usdt":
                usdt_num = float(info["balance"])

            if currency == "ft":
                ft_num = float(info["balance"])

        return btc_num, usdt_num, ft_num

    else:
        return btc_num, usdt_num, ft_num
Esempio n. 2
0
# # -*- coding: utf-8 -*-
"""

"""


import pandas as pd 
from fcoin import Fcoin
import os,csv,time

fcoin = Fcoin()
fcoin.auth('key ', 'secret')
sylist = ['btcusdt','ethusdt','bchusdt','ltcusdt','ftusdt','fteth','etcusdt','ftbtc','bnbusdt','btmusdt','zrxeth']
sDir = os.path.join(os.path.abspath('..'),'..','Fcoin_DL','KLine')
stime = time.strftime('%Y-%m-%d',time.localtime())

# 获取最新的深度明细
# 买(卖)1价, 买(卖)1量
# The ask price is what sellers are willing to take for it.
# If you are selling a stock, you are going to get the bid price,
# if you are buying a stock you are going to get the ask price.
bids_head = ['买1价','买的量数']
bids_flag = '买1价'
asks_head = ['卖1价','卖的量数']
asks_flag = '卖1价'
for sy in sylist:
    bidsfile = '{0}_{1}_{2}'.format(stime,sy, 'bids_depth.csv')
    bidspath = os.path.join(sDir, bidsfile)

    asksfile = '{0}_{1}_{2}'.format(stime, sy, 'asks_depth.csv')
    askspath = os.path.join(sDir, asksfile)
Esempio n. 3
0
from fcoin import Fcoin
#if python3 use fcoin3
#from fcoin3 import Fcoin

fcoin = Fcoin()

print(fcoin.get_symbols())

print(fcoin.get_currencies())

fcoin.auth('you-key', 'you-secret')

print(fcoin.get_balance())

print(fcoin.buy('fteth', 0.0001, 10))
#print(fcoin.sell('fteth', 0.002, 5))
#print(fcoin.cancel_order('6TfBZ-eORp4_2nO5ar6zhg0gLLvuWzTTmL1OzOy9OYg='))
#print(fcoin.get_candle('M1','fteth'))
Esempio n. 4
0
from fcoin import Fcoin

fcoin = Fcoin()
fcoin.auth('6b709e792d484932a06298e0f408692b',
           '8fc3e8dc802548788f2c55287c16d021')

balance = fcoin.get_balance()

FT_USDT_QTY = 10
FT_ETH_QTY = 10

ETH_USDT_QTY = 10
'''

balance_ft = 0
balance_usdt = 0
balance_eth = 0

for data in balance["data"]:
    if(data["currency"] == "usdt"):
        balance_usdt = float(data["available"])
    if(data["currency"] == "ft"):
        balance_ft = float(data["available"])
    if(data["currency"] == "eth"):
        balance_eth = float(data["available"])


print("balance-FT  :"+str(balance_ft))
print("balance-USDT:"+str(balance_usdt))
print("balance-ETH  :"+str(balance_eth))
'''
Esempio n. 5
0
def cancelAll():
    print("cancelAll")
    sleep(1.5)

    cancel_order_nums = 3
    public_order_deal = Fcoin()
    public_order_deal.auth(accessKey, secretyKey)

    all_orders = []

    for state in ["submitted", "partial_filled"]:
        result, data = public_order_deal.list_orders(symbol="btcusdt",
                                                     states=state)

        if str(data["status"]) == "0":
            orders = data["data"]

            for use_order in orders:
                all_orders.append(use_order)

        sleep(2)

    if len(all_orders) > 0:
        buy_order_array = []
        sell_order_array = []

        for use_order in all_orders:
            systemID = str(use_order["id"])
            status = use_order["state"]
            tradedVolume = float(use_order["filled_amount"])
            totalVolume = float(use_order["amount"])
            price = float(use_order["price"])
            side = use_order["side"]

            if status in ["partial_filled", "submitted", "partial_canceled"]:
                if side == "buy":
                    buy_order_array.append([price, systemID])
                else:
                    sell_order_array.append([price, systemID])

        all_need_cancel = []
        if len(buy_order_array) > cancel_order_nums:
            sort_buy_arr = sorted(buy_order_array,
                                  key=lambda price_pair: price_pair[0])
            sort_buy_arr.reverse()

            print('sort_buy_arr :{}'.format(sort_buy_arr))

            for i in range(cancel_order_nums, len(sort_buy_arr)):
                all_need_cancel.append(str(sort_buy_arr[i][1]))
                # public_order_deal.cancel_order( str(sort_buy_arr[i][1]))

        if len(sell_order_array) > cancel_order_nums:
            sort_sell_arr = sorted(sell_order_array,
                                   key=lambda price_pair: price_pair[0])

            print(u'sort_sell_arr'.format(sort_sell_arr))

            for i in range(cancel_order_nums, len(sell_order_array)):
                all_need_cancel.append(str(sort_sell_arr[i][1]))

        for systemID in all_need_cancel:
            try:
                print(public_order_deal.cancel_order(systemID))
                sleep(1.5)
            except Exception as ex:
                print(ex, file=sys.stderr)

    else:
        print("order_all is not ")
Esempio n. 6
0
def runSell(accessKey, secretyKey, price, volume):
    fcoin = Fcoin()
    fcoin.auth(accessKey, secretyKey)

    return fcoin.sell('btcusdt', price, volume)
Esempio n. 7
0
def runBuy(accessKey, secretyKey, price, volume):
    fcoin = Fcoin()
    fcoin.auth(accessKey, secretyKey)

    return fcoin.buy('btcusdt', price, volume)
Esempio n. 8
0
from fcoin import Fcoin
#if python3 use fcoin3
#from fcoin3 import Fcoin


fcoin = Fcoin()

print(fcoin.get_symbols())

print(fcoin.get_currencies())

fcoin.auth('you-key', 'you-secret') 

print(fcoin.get_balance())

print(fcoin.buy('fteth', 0.0001, 10))
#print(fcoin.sell('fteth', 0.002, 5))
#print(fcoin.cancel_order('6TfBZ-eORp4_2nO5ar6zhg0gLLvuWzTTmL1OzOy9OYg='))
#print(fcoin.get_candle('M1','fteth'))
Esempio n. 9
0
from fcoin import Fcoin
#if python3 use fcoin3
#from fcoin3 import Fcoin

fcoin = Fcoin()

print(fcoin.get_symbols())

print(fcoin.get_currencies())

fcoin.auth('', '')

print(fcoin.get_balance())

#print(fcoin.buy('fteth', 0.0001, 10))
#print(fcoin.sell('fteth', 0.002, 5))
#print(fcoin.cancel_order('6TfBZ-eORp4_2nO5ar6zhg0gLLvuWzTTmL1OzOy9OYg='))
#print(fcoin.get_candle('M1','fteth'))
Esempio n. 10
0
class MarketApp:
    """
    """
    def __init__(self):
        self.client = FcoinClient()
        self.fcoin = Fcoin()
        self.fcoin.auth(config.key, config.secret)
        self._sender = MqSender('fcoin', 'kline')
        self.sym = ''
        self.wdata = {}
        self._init_log()

    # self.deleteFromMmap(sfilepath, size-iseekpos,size)
    def deleteFromMmap(self, filename, start, end, lastline=False):
        self.sym = self.sym  # acutally it will not be used just for fix the warnning error
        f = open(filename, "r+")
        VDATA = mmap.mmap(f.fileno(), 0)
        size = len(VDATA)
        if lastline is True:
            start = size - start
            end = size
        else:
            pass
        length = end - start
        newsize = size - length
        VDATA.move(start, end, size - end)
        VDATA.flush()
        VDATA.close()
        f.truncate(newsize)
        f.close()

    def candle(self, data):
        # print('数据:', data)
        name, ml, sym = self.client.channel_config[0].split('.')
        ts = int(round(data['id'] * 1000))  # self.client.get_ts()
        # send to mq
        try:
            mqdata = {}
            tdata = {
                'symbol': sym,
                'ts': ts,
                'tm_intv': m_interval,
                'exchange': config.exchange
            }
            mqdata.update(tdata)
            mqdata.update(data)
            # print(mqdata)
            self._sender.send(str(mqdata))
        except Exception as error:
            print(error)
            self._sender.close()
        # send to mq

        # print('symbol: ', sym)
        # create the no-exist folder to save date
        stime = time.strftime('%Y%m%d', time.localtime())
        stradeDir = os.path.join(sDir, stime, config.exchange, config.klinedir)
        if not os.path.exists(stradeDir):
            os.makedirs(stradeDir)

        # for original data
        sTfile = '{0}_{1}_{2}{3}'.format(config.klinedir, stime, sym, '.txt')
        sTfilepath = os.path.join(stradeDir, sTfile)
        # write original data to txt files
        with open(sTfilepath, 'a+', encoding='utf-8') as tf:
            tf.writelines(json.dumps(data) + '\n')
        # for no-duplicated csv data
        sfile = '{0}_{1}_{2}{3}'.format(config.klinedir, stime, sym, '.csv')
        sfilepath = os.path.join(stradeDir, sfile)
        if self.wdata:
            if ts in self.wdata.values():
                # self.wdata['ts'] = ts
                pass
            else:
                self.wdata['ts'] = ts
                self.wdata['wlen'] = 0
            # write the current data sent from server to the csv but the position will be changed
        else:
            self.wdata['ts'] = ts
            self.wdata['wlen'] = 0
        self.w2csv(sfilepath, ts, sym, data)

    def w2csv(self, sfilepath, ts, sym, data):
        sflag = 'close'
        rFind = False
        kklist = []
        vvlist = []
        # will delete the data from the end if the ts is the same to the previous data
        iseekpos = self.wdata['wlen']
        # print('iseekpos= '+'{0}'.format(iseekpos))
        if iseekpos > 0:
            # print('will call deleteFromMmap')
            self.deleteFromMmap(sfilepath, iseekpos, 0, True)
        # will delete the data from the end if the ts is the same to the one of the previous data
        else:
            pass
        if os.path.exists(sfilepath):
            with open(sfilepath, 'r', encoding='utf-8') as f:
                first_line = f.readline()  # 取第一行
                rFind = sflag in first_line
        with open(sfilepath, 'a+', encoding='utf-8', newline='') as f:
            w = csv.writer(f)
            if rFind is True:
                vlist = list(data.values())
                self.additem2list(ts, vvlist, sym, m_interval, vlist)
                w.writerow(vvlist)
            else:  # khead = ['symbol', 'ts', 'tm_intv', 'id', 'open', 'close', 'low', 'high', 'amount', 'vol', 'count']
                klist = list(data.keys())
                # open,close,high,quote_vol,id,count,low,seq,base_vol
                kklist.insert(0, 'symbol')
                kklist.insert(1, 'ts')
                kklist.insert(2, 'tm_intv')
                kklist.insert(3, klist[4])
                kklist.insert(4, klist[0])
                kklist.insert(5, klist[1])
                kklist.insert(6, klist[6])
                kklist.insert(7, klist[2])
                kklist.insert(8, 'amount')
                kklist.insert(9, 'vol')
                kklist.insert(10, klist[5])
                w.writerow(kklist)
                vlist = list(data.values())
                self.additem2list(ts, vvlist, sym, m_interval, vlist)
                w.writerow(vvlist)

        # update the lenth of data wroten to csv
        prelen = len('{0},{1},{2}'.format(sym, ts, m_interval))
        # print('prelen= ' + '{0}'.format(prelen))
        for i in dkey:
            ss = '{0}{1}'.format(',', data[i])
            prelen += len(ss)
        prelen += len(
            '\t\n')  # because there is a extra '\t\n' which is equal 2 bytes
        # print('w2csv prelen= ' + '{0}'.format(prelen))
        self.wdata['wlen'] = prelen
        # print('w2csv after prelen= ' + '{0}'.format(self.wdata['wlen']))
        # update the lenth of data wroten to csv

    # add extral items to the original list
    def additem2list(self, ts, vvlist, sym, ml, vlist):
        self.sym = sym  # acutally it will not be used just for fix the warnning error
        vvlist.insert(0, sym)
        vvlist.insert(1, ts)
        vvlist.insert(2, ml)
        vvlist.insert(3, vlist[4])
        vvlist.insert(4, vlist[0])
        vvlist.insert(5, vlist[1])
        vvlist.insert(6, vlist[6])
        vvlist.insert(7, vlist[2])
        vvlist.insert(8, vlist[3])
        vvlist.insert(9, vlist[8])
        vvlist.insert(10, vlist[5])

    # 循环
    def loop(self):
        self.client.start()

        while not self.client.isConnected:
            self._log.info('waitting……')
            time.sleep(1)

        self.sync_kline(self.sym)
        while True:
            try:
                pass
            except Exception as error:
                print(error)
            time.sleep(1)

    # sync_trades
    def sync_kline(self, sym):
        self.client.stream.stream_klines.subscribe(self.candle)
        self.client.subscribe_candle(sym, config.mflag)

    # 日志初始化
    def _init_log(self):
        self._log = logging.getLogger(__name__)
        self._log.setLevel(level=logging.INFO)
        formatter = logging.Formatter('%(asctime)s - %(message)s')  # 格式
        '''
        保存文档
        '''
        handler = logging.FileHandler("app.log")
        handler.setLevel(logging.INFO)
        handler.setFormatter(formatter)
        self._log.addHandler(handler)
        '''
        控制台显示
        '''
        console = logging.StreamHandler()
        console.setLevel(logging.INFO)
        console.setFormatter(formatter)
        self._log.addHandler(console)
Esempio n. 11
0
class wss_app():
    def __init__(self):
        self.client = fcoin_client()
        self.client.stream.stream_depth.subscribe(self.depth)
        self.client.stream.stream_klines.subscribe(self.candle)
        self.client.stream.stream_ticker.subscribe(self.ticker)
        self.fcoin = Fcoin()
        self.fcoin.auth(config.key, config.secret)

        self.buy_price = None  # 买1价
        self.buy_amount = None  # 买1量
        self.sell_price = None  # 卖1价
        self.sell_amount = None  # 卖1量
        self.ts = None  # 深度更新时间

        self.market_price = None  # 市价

        self.total_bids = 0
        self.total_asks = 0

        self.filled_buy_order_list = []
        self.order_list = defaultdict(lambda: None)
        self.buy_order_id = None
        self.dic_balance = defaultdict(lambda: None)
        self.time_order = time.time()

        self.price_list = []
        self.candle_list = None
        self.SMA = None
        self._init_log()

    # 日志初始化
    def _init_log(self):
        self._log = logging.getLogger(__name__)
        self._log.setLevel(level=logging.INFO)
        formatter = logging.Formatter('%(asctime)s - %(message)s')  # 格式
        '''
        保存文档
        '''
        handler = logging.FileHandler("app.log")
        handler.setLevel(logging.INFO)
        handler.setFormatter(formatter)
        self._log.addHandler(handler)
        '''
        控制台显示
        '''
        console = logging.StreamHandler()
        console.setLevel(logging.INFO)
        console.setFormatter(formatter)
        self._log.addHandler(console)

    # 精度控制,直接抹除多余位数,非四舍五入
    def digits(self, num, digit):
        site = pow(10, digit)
        tmp = num * site
        tmp = math.floor(tmp) / site
        return tmp

    # wss订阅深度接收
    def depth(self, data):
        bids = data['bids']
        asks = data['asks']

        self.ts = time.time()

        self.buy_price = bids[0]  # 买
        self.buy_amount = bids[1]
        self.sell_price = asks[0]  # 卖
        self.sell_amount = asks[1]

        for i in range(3):
            self.total_bids += bids[2 * i - 1]
            self.total_asks += asks[2 * i - 1]

    # wss订阅K线接收
    def candle(self, data):
        if self.candle_list is None:
            self.candle_list = [{
                'timestamp': data['id'],
                'open': data['open'],
                'high': data['high'],
                'low': data['low'],
                'close': data['close'],
                'volume': data['base_vol']
            }]
        else:
            last_candle = self.candle_list[-1]
            if last_candle['timestamp'] == data['id']:
                self.candle_list[-1] = {
                    'timestamp': data['id'],
                    'open': data['open'],
                    'high': data['high'],
                    'low': data['low'],
                    'close': data['close'],
                    'volume': data['base_vol']
                }
            else:
                self.candle_list.append({
                    'timestamp': data['id'],
                    'open': data['open'],
                    'high': data['high'],
                    'low': data['low'],
                    'close': data['close'],
                    'volume': data['base_vol']
                })

            if len(self.candle_list) > 10:
                self.candle_list.pop(0)

        if len(self.candle_list) >= 7:
            close_array = np.array(
                [item['close'] for item in self.candle_list])
            self.SMA = talib.SMA(close_array, timeperiod=7)

    # 市价
    def ticker(self, data):
        self.ts = time.time()
        self.market_price = data['ticker'][0]

    # 刷单流程
    def process(self):

        if self.ts and time.time(
        ) - self.ts < 10 and self.buy_price and self.market_price:
            price = self.market_price if config.fix_price == 0 else config.fix_price
            amount = 0
            '''
            挂卖单
            '''
            success_item_list = []
            for item in self.filled_buy_order_list:
                amount = self.digits(item['amount'],
                                     config.symbol['amount_precision'])
                price = self.digits(max(item['price'], price),
                                    config.symbol['price_precision'])
                order = [amount, price]
                if amount >= config.symbol['min_amount']:
                    success, data = self.fcoin.sell(config.symbol['name'],
                                                    price, amount)  # 卖
                    if success:
                        success_item_list.append(item)
                        self.order_list[data['data']] = order
                        self._log.info('挂卖单成功[%s:%s]' % (amount, price))
            '''
            删除已成功订单
            '''
            for item in success_item_list:
                self.filled_buy_order_list.remove(item)

            keys = []
            for key in self.order_list.keys():
                success, data = self.fcoin.get_order(key)
                if success:
                    state = data['data']['state']
                    if state == 'filled':
                        keys.append([0, key])
                    elif state in ('partial_canceled', 'canceled'):
                        keys.append([1, key])

            for tag, key in keys:
                self.order_list.pop(key)
                if tag == 0:
                    self._log.info('已经成交:' + key)
                else:
                    self._log.info('已经撤单:' + key)
            '''
            买单不存在时
            '''
            if not self.buy_order_id:
                '''
                 价格异动识别,可以根据实际情况改动,价格固定时无效
                 '''
                if config.fix_price == 0:
                    if abs(self.buy_price - self.sell_price) > 0.5:
                        self._log.info('价格异动买卖差价:%s' %
                                       abs(self.buy_price - self.sell_price))
                        return
                    elif self.SMA is None:
                        if len(self.price_list) > 0:
                            avg = sum(self.price_list) / len(self.price_list)
                            if abs(avg - self.buy_price) > 10:
                                self._log.info('价格异动avg:%s [%s]' %
                                               (avg, self.buy_price))
                                self.price_list.append(self.buy_price)
                                self.price_list.append(self.sell_price)
                                if len(self.price_list) >= 120:
                                    self.price_list.pop(0)
                                return
                        else:
                            self.price_list.append(self.buy_price)
                            self.price_list.append(self.sell_price)
                    else:
                        last = self.SMA[-2]
                        if not np.isnan(last):
                            if abs(self.buy_price - last) >= 0.5:
                                self._log.info('价格异动:%s' %
                                               abs(self.buy_price - last))
                                return
                '''
                查询余额度
                '''
                self.dic_balance = self.get_balance()
                '''
                判断币种持仓量,到设定值停止买入。
                '''
                coin = self.dic_balance[config.symbol['coin']]
                if coin and coin.balance > config.limit_amount:
                    self._log.info('%s余额度达到最大值[%s]' %
                                   (config.symbol['coin'], coin.balance))
                    return
                '''
                挂买单
                '''
                usdt = self.dic_balance['usdt']
                if usdt:
                    if config.fix_price:
                        diff = abs(config.fix_price - self.market_price)
                        if config.diff_price < diff:
                            self._log.info('固定价格模式差价异常[%-0.2f]' % diff)
                            return

                    price = self.market_price if config.fix_price == 0 else config.fix_price
                    if usdt.available > price * config.max_amount:
                        amount = config.max_amount if self.total_bids > config.total_amount and self.total_asks > config.total_amount else config.min_amount
                    else:
                        amount = usdt.available / price
                    amount = self.digits(amount,
                                         config.symbol['amount_precision'])
                    if amount >= config.symbol['min_amount']:
                        price = self.digits(price,
                                            config.symbol['price_precision'])
                        success, data = self.fcoin.buy(config.symbol['name'],
                                                       price, amount)  # 买
                        if success:
                            self.time_order = time.time()
                            self.buy_order_id = data['data']
                            self._log.info('挂买单成功[%s:%s]' % (amount, price))
                    else:
                        self._log.info('usdt不足[%s]' % (usdt.available))
                else:
                    self._log.info('查询余额错误')
            else:
                '''
                买单ID存在时查询订单状态
                '''
                success, data = self.fcoin.get_order(self.buy_order_id)
                if success:
                    state = data['data']['state']
                    amount = float(data['data']['filled_amount']) - float(
                        data['data']['fill_fees'])
                    price = float(data['data']['price'])

                    if amount > 0 and state in ('filled', 'partial_canceled'):
                        self.filled_buy_order_list.append({
                            'price': price,
                            'amount': amount
                        })

                    if state == 'filled':
                        self.buy_order_id = None
                        self._log.info('买单已成交')

                    elif state == 'canceled' or state == 'partial_canceled':
                        self.buy_order_id = None
                        self._log.info('买单已撤单')

                    elif state not in ('pending_cancel'):
                        '''
                        超时判断
                        '''
                        if time.time() - self.time_order >= config.delay:
                            self.fcoin.cancel_order(self.buy_order_id)
                            self._log.info('%s秒超时撤单' % config.delay)
        else:
            self._log.info('等待WebSocket数据……')

    # 循环
    def loop(self):

        if config.min_amount < config.symbol[
                'min_amount'] or config.min_amount < config.symbol[
                    'min_amount']:
            self._log.info('max_amount,min_amount ≥ 规定的最小数量[%s]' %
                           (config.symbol['min_amount']))
            return

        self.client.start()

        while not self.client.isConnected:
            self._log.info('waitting……')
            time.sleep(1)

        self.client.subscribe_depth(config.symbol['name'], 'L20')
        self.client.subscribe_candle(config.symbol['name'], 'M1')
        self.client.subscribe_ticker(config.symbol['name'])
        while True:
            try:
                self.process()
            except Exception as error:
                self._log.info('未知错误')
            time.sleep(0.5)

    # 获取余额
    def get_balance(self):
        dic_balance = defaultdict(lambda: None)
        success, data = self.fcoin.get_balance()
        if success:
            for item in data['data']:
                dic_balance[item['currency']] = balance(
                    float(item['available']), float(item['frozen']),
                    float(item['balance']))
        return dic_balance

    # 获取订单
    def get_orders(self, symbol, states, limit=1):
        '''
        :param symbol:
        :param states: submitted/partial_filled/partial_canceled/canceled/pending_cancel/filled
        :return:
        '''
        success, data = self.fcoin.list_orders(symbol=symbol,
                                               states=states,
                                               limit=limit)
        if success:
            return data['data']
        else:
            print(data)
            return None
Esempio n. 12
0
class wss_app:

    def __init__(self):
        self.client = fcoin_client()
        self.client.stream.stream_depth.subscribe(self.depth)
        self.client.stream.stream_klines.subscribe(self.candle)
        self.client.stream.stream_ticker.subscribe(self.ticker)
        self.fcoin = Fcoin()
        self.fcoin.auth(config.key, config.secret)

        self.buy_price = None  # 买1价
        self.buy_amount = None  # 买1量
        self.sell_price = None  # 卖1价
        self.sell_amount = None  # 卖1量
        self.ts = None  # 深度更新时间

        self.market_price = None  # 市价

        self.total_bids = 0
        self.total_asks = 0

        self.filled_buy_order_list = []
        self.order_list = defaultdict(lambda: None)
        self.buy_order_id = None
        self.dic_balance = defaultdict(lambda: None)
        self.time_order = time.time()

        self.price_list = []
        self.candle_list = None
        self.SMA = None
        self._init_log()

    # 日志初始化
    def _init_log(self):
        self._log = logging.getLogger(__name__)
        self._log.setLevel(level=logging.INFO)
        formatter = logging.Formatter("%(asctime)s - %(message)s")  # 格式

        """
        保存文档
        """
        handler = logging.FileHandler("app.log")
        handler.setLevel(logging.INFO)
        handler.setFormatter(formatter)
        self._log.addHandler(handler)

        """
        控制台显示
        """
        console = logging.StreamHandler()
        console.setLevel(logging.INFO)
        console.setFormatter(formatter)
        self._log.addHandler(console)

    # 精度控制,直接抹除多余位数,非四舍五入
    def digits(self, num, digit):
        site = pow(10, digit)
        tmp = num * site
        tmp = math.floor(tmp) / site
        return tmp

    # wss订阅深度接收
    def depth(self, data):
        bids = data["bids"]
        asks = data["asks"]

        self.ts = time.time()

        self.buy_price = bids[0]  # 买
        self.buy_amount = bids[1]
        self.sell_price = asks[0]  # 卖
        self.sell_amount = asks[1]

        for i in range(3):
            self.total_bids += bids[2 * i - 1]
            self.total_asks += asks[2 * i - 1]

    # wss订阅K线接收
    def candle(self, data):
        if self.candle_list is None:
            self.candle_list = [
                {
                    "timestamp": data["id"],
                    "open": data["open"],
                    "high": data["high"],
                    "low": data["low"],
                    "close": data["close"],
                    "volume": data["base_vol"],
                }
            ]
        else:
            last_candle = self.candle_list[-1]
            if last_candle["timestamp"] == data["id"]:
                self.candle_list[-1] = {
                    "timestamp": data["id"],
                    "open": data["open"],
                    "high": data["high"],
                    "low": data["low"],
                    "close": data["close"],
                    "volume": data["base_vol"],
                }
            else:
                self.candle_list.append(
                    {
                        "timestamp": data["id"],
                        "open": data["open"],
                        "high": data["high"],
                        "low": data["low"],
                        "close": data["close"],
                        "volume": data["base_vol"],
                    }
                )

            if len(self.candle_list) > 10:
                self.candle_list.pop(0)

        if len(self.candle_list) >= 7:
            close_array = np.array([item["close"] for item in self.candle_list])
            self.SMA = talib.SMA(close_array, timeperiod=7)

    # 市价
    def ticker(self, data):
        self.ts = time.time()
        self.market_price = data["ticker"][0]

    # 刷单流程
    def process(self):

        if (
            self.ts
            and time.time() - self.ts < 10
            and self.buy_price
            and self.market_price
        ):
            price = self.market_price if config.fix_price == 0 else config.fix_price
            amount = 0

            """
            挂卖单
            """
            success_item_list = []
            for item in self.filled_buy_order_list:
                amount = self.digits(item["amount"], config.symbol["amount_precision"])
                price = self.digits(
                    max(item["price"], price), config.symbol["price_precision"]
                )
                order = [amount, price]
                if amount >= config.symbol["min_amount"]:
                    success, data = self.fcoin.sell(
                        config.symbol["name"], price, amount
                    )  # 卖
                    if success:
                        success_item_list.append(item)
                        self.order_list[data["data"]] = order
                        self._log.info("挂卖单成功[%s:%s]" % (amount, price))

            """
            删除已成功订单
            """
            for item in success_item_list:
                self.filled_buy_order_list.remove(item)

            keys = []
            for key in self.order_list.keys():
                success, data = self.fcoin.get_order(key)
                if success:
                    state = data["data"]["state"]
                    if state == "filled":
                        keys.append([0, key])
                    elif state in ("partial_canceled", "canceled"):
                        keys.append([1, key])

            for tag, key in keys:
                self.order_list.pop(key)
                if tag == 0:
                    self._log.info("已经成交:" + key)
                else:
                    self._log.info("已经撤单:" + key)

            """
            买单不存在时
            """
            if not self.buy_order_id:
                """
                 价格异动识别,可以根据实际情况改动,价格固定时无效
                 """
                if config.fix_price == 0:
                    if abs(self.buy_price - self.sell_price) > 0.5:
                        self._log.info(
                            "价格异动买卖差价:%s" % abs(self.buy_price - self.sell_price)
                        )
                        return
                    elif self.SMA is None:
                        if len(self.price_list) > 0:
                            avg = sum(self.price_list) / len(self.price_list)
                            if abs(avg - self.buy_price) > 10:
                                self._log.info(
                                    "价格异动avg:%s [%s]" % (avg, self.buy_price)
                                )
                                self.price_list.append(self.buy_price)
                                self.price_list.append(self.sell_price)
                                if len(self.price_list) >= 120:
                                    self.price_list.pop(0)
                                return
                        else:
                            self.price_list.append(self.buy_price)
                            self.price_list.append(self.sell_price)
                    else:
                        last = self.SMA[-2]
                        if not np.isnan(last):
                            if abs(self.buy_price - last) >= 0.5:
                                self._log.info("价格异动:%s" % abs(self.buy_price - last))
                                return

                """
                查询余额度
                """
                self.dic_balance = self.get_balance()

                """
                判断币种持仓量,到设定值停止买入。
                """
                coin = self.dic_balance[config.symbol["coin"]]
                if coin and coin.balance > config.limit_amount:
                    self._log.info(
                        "%s余额度达到最大值[%s]" % (config.symbol["coin"], coin.balance)
                    )
                    return
                """
                挂买单
                """
                usdt = self.dic_balance["usdt"]
                if usdt:
                    if config.fix_price:
                        diff = abs(config.fix_price - self.market_price)
                        if config.diff_price < diff:
                            self._log.info("固定价格模式差价异常[%-0.2f]" % diff)
                            return

                    price = (
                        self.market_price if config.fix_price == 0 else config.fix_price
                    )
                    if usdt.available > price * config.max_amount:
                        amount = (
                            config.max_amount
                            if self.total_bids > config.total_amount
                            and self.total_asks > config.total_amount
                            else config.min_amount
                        )
                    else:
                        amount = usdt.available / price
                    amount = self.digits(amount, config.symbol["amount_precision"])
                    if amount >= config.symbol["min_amount"]:
                        price = self.digits(price, config.symbol["price_precision"])
                        success, data = self.fcoin.buy(
                            config.symbol["name"], price, amount
                        )  # 买
                        if success:
                            self.time_order = time.time()
                            self.buy_order_id = data["data"]
                            self._log.info("挂买单成功[%s:%s]" % (amount, price))
                    else:
                        self._log.info("usdt不足[%s]" % (usdt.available))
                else:
                    self._log.info("查询余额错误")
            else:
                """
                买单ID存在时查询订单状态
                """
                success, data = self.fcoin.get_order(self.buy_order_id)
                if success:
                    state = data["data"]["state"]
                    amount = float(data["data"]["filled_amount"]) - float(
                        data["data"]["fill_fees"]
                    )
                    price = float(data["data"]["price"])

                    if amount > 0 and state in ("filled", "partial_canceled"):
                        self.filled_buy_order_list.append(
                            {"price": price, "amount": amount}
                        )

                    if state == "filled":
                        self.buy_order_id = None
                        self._log.info("买单已成交")

                    elif state == "canceled" or state == "partial_canceled":
                        self.buy_order_id = None
                        self._log.info("买单已撤单")

                    elif state not in ("pending_cancel"):
                        """
                        超时判断
                        """
                        if time.time() - self.time_order >= config.delay:
                            self.fcoin.cancel_order(self.buy_order_id)
                            self._log.info("%s秒超时撤单" % config.delay)
        else:
            self._log.info("等待WebSocket数据……")

    # 循环
    def loop(self):

        if (
            config.min_amount < config.symbol["min_amount"]
            or config.min_amount < config.symbol["min_amount"]
        ):
            self._log.info(
                "max_amount,min_amount ≥ 规定的最小数量[%s]" % (config.symbol["min_amount"])
            )
            return

        self.client.start()

        while not self.client.isConnected:
            self._log.info("waitting……")
            time.sleep(1)

        self.client.subscribe_depth(config.symbol["name"], "L20")
        self.client.subscribe_candle(config.symbol["name"], "M1")
        self.client.subscribe_ticker(config.symbol["name"])
        while True:
            try:
                self.process()
            except Exception as error:
                self._log.info("未知错误")
            time.sleep(0.5)

    # 获取余额
    def get_balance(self):
        dic_balance = defaultdict(lambda: None)
        success, data = self.fcoin.get_balance()
        if success:
            for item in data["data"]:
                dic_balance[item["currency"]] = balance(
                    float(item["available"]),
                    float(item["frozen"]),
                    float(item["balance"]),
                )
        return dic_balance

    # 获取订单
    def get_orders(self, symbol, states, limit=1):
        """
        :param symbol:
        :param states: submitted/partial_filled/partial_canceled/canceled/pending_cancel/filled
        :return:
        """
        success, data = self.fcoin.list_orders(
            symbol=symbol, states=states, limit=limit
        )
        if success:
            return data["data"]
        else:
            print(data)
            return None
Esempio n. 13
0
    def fteth(self, profit_margin, volumn_rate):
        fcoin = Fcoin()
        #print(fcoin.get_symbols())

        fcoin.auth(key, secret)

        balance = (fcoin.get_balance())['data']

        for i in balance:
            if i['currency'] == u'eth':
                #print i
                eth_balance = i['balance']
                eth_available = i['available']
                if eth_balance != eth_available:
                    print('Warning: Some ETH frozen: ', i)
                    sys.exit(0)

        for i in balance:
            if i['currency'] == u'ft':
                #print i
                ft_balance = i['balance']
                ft_available = i['available']
                if ft_available != ft_balance:
                    print('Warning: Some FT frozen: ', i)
                    sys.exit(0)

        result = (fcoin.get_market_ticker(u'fteth'))
        #result=(fcoin.get_currencies())
        #print(result)
        #print(result['status'])
        #print(result['data']['ticker'])

        _latest_trans_price = result['data']['ticker'][0]
        _latest_volumn = result['data']['ticker'][1]
        _max_buy_price = result['data']['ticker'][2]
        _max_buy_volumn = result['data']['ticker'][3]
        _min_sell_price = result['data']['ticker'][4]
        _min_sell_volumn = result['data']['ticker'][5]

        #buy_price 	=	_latest_trans_price*0.92
        buy_price = _latest_trans_price * 1.0
        buy_price = round(buy_price, 8)  ## keep 8 decimal
        can_buy_ft = int(float(eth_available) / buy_price)
        buy_volumn = int(float(can_buy_ft) * float(volumn_rate))

        result = fcoin.buy('fteth', buy_price, buy_volumn)

        sell_price = buy_price * (1.0 + profit_margin)
        sell_price = round(sell_price, 8)  ## keep 8 decimal
        sell_volumn = buy_volumn  # sell all

        print('ticker fteth latest price:', _latest_trans_price)
        print("order_price = ", buy_price, "order_volumn = ", buy_volumn)
        print("sell_price  = ", sell_price)

        #print result
        buy_id = result['data']
        buy_order_done = 0
        sell_order_done = 0
        #buy_id_decode = base64.b64decode(bytes(buy_id))
        print buy_id
        #print buy_id_decode
        buy_cycle_time = 3  ## wait 5 seconds * 3 times = 15 seconds
        sell_cycle_time = 180  ## wait 10 seconds  * 180 times = 30 mins
        while (buy_cycle_time > 0):
            time.sleep(5)
            result = fcoin.get_order(buy_id)
            #result	= fcoin.show_orders('fteth')
            #print result
            filled = result['data']['filled_amount']
            #print int(filled)
            if int(float(filled)) == buy_volumn:
                print('buy order done !')
                buy_order_done = 1
                break
            buy_cycle_time = buy_cycle_time - 1
        if buy_cycle_time == 0:
            print 'Timeout!! Buy price is too low, please try again'
            print 'Cancel buy order!'
            fcoin.cancel_order(buy_id)

        if buy_order_done == 1:
            result = fcoin.sell('fteth', sell_price, sell_volumn)
            sell_id = result['data']
            while (sell_cycle_time > 0):
                time.sleep(20)
                result = fcoin.get_order(sell_id)
                #print result
                filled = result['data']['filled_amount']
                if int(float(filled)) == sell_volumn:
                    print('sell order done !')
                    sell_order_done = 1
                    break
                sell_cycle_time = sell_cycle_time - 1
                if sell_cycle_time % 5 == 0:
                    print 'Sell price is too high, cancel order,try again'
                    fcoin.cancel_order(sell_id)
                    time.sleep(1)
                    sell_price = sell_price * 0.999  ## price down 0.001
                    sell_price = round(sell_price, 8)  ## keep 8 decimal
                    sell_volumn = sell_volumn - int(float(filled))
                    result = fcoin.sell('fteth', sell_price, sell_volumn)
                    sell_id = result['data']
                    print('sell_price  = ', sell_price)
                    print('sell_volumn = ', sell_volumn)
Esempio n. 14
0
                self.refresh_unit()
                try:
                    self.place_order(limit=self.limit)
                except InsufficientAccountError:
                    self.get_balance()
                    amount = round(self.quote_balance * 0.9, 1)
                    self.client.create_order(side="buy",
                                             amount=amount,
                                             type="market",
                                             symbol=self.symbol)
                    print("{}不足,购买{} {}".format(self.base_currency, amount,
                                                self.quote_currency))
                    self.sleep(10)
                    self.get_balance()
                    self.refresh_unit()
                self.sleep(1)
                self.round += 1
                # while not self.finish_sell or not self.finish_buy:
                #     self.order_complete()


if __name__ == "__main__":
    fclient = Fcoin(use_proxy=False)

    key = os.environ.get("FCOIN_KEY")
    secret = os.environ.get("FCOIN_SECRET")
    fclient.auth([(key, secret)])
    robot = FcoinRobot(fclient, 'eth', 'usdt', unit=4, decimal=2, limit=False)
    robot.sleep(5)
    robot.start()
Esempio n. 15
0
try:
    cf.read("fcoin.conf")
    key = cf.get('api', 'key')
    secret = cf.get('api', 'secret')
    symbol = cf.get('brush', 'symbol')
    currency = cf.get('brush', 'currency')
    addr = cf.get('peer', 'addr')
    server_port = cf.get('peer', 'server_port')
    peer_port = cf.get('peer', 'peer_port')
    actor = cf.get('peer', 'actor')
except Exception:
    print('please check the config file <fcoin.conf> in parent direction')
    exit(1)

fcoin = Fcoin()
fcoin.auth(key, secret)
symbols = fcoin.get_symbols()
send_queue = Queue.Queue(maxsize=1)
recv_queue = Queue.Queue(maxsize=1)
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_socket.bind((addr, int(server_port)))

serial = 0


class Sender(threading.Thread):
    def run(self):
        while True:
            data_obj = send_queue.get()
            data = pickle.dumps(data_obj)
            udp_socket.sendto(data.encode('utf-8'), (addr, int(peer_port)))
Esempio n. 16
0
class app():
    def __init__(self):
        self.key = config.key
        self.secret = config.secret

        self._log = None
        self.dic_balance = defaultdict(lambda: None)
        self.order_list = defaultdict(lambda: None)
        self.stop = False

        self.buy_order_id = None
        self.sell_order_id = None
        self.time_order = time.time()

        self.db = mongodb()
        self.fcoin = Fcoin()
        self.fcoin.auth(self.key, self.secret)
        self._init_log()

    def _init_log(self):
        self._log = logging.getLogger(__name__)
        self._log.setLevel(level=logging.INFO)
        formatter = logging.Formatter('%(asctime)s - %(message)s')

        handler = logging.FileHandler("app.log")
        handler.setLevel(logging.INFO)
        handler.setFormatter(formatter)
        self._log.addHandler(handler)


        console = logging.StreamHandler()
        console.setLevel(logging.INFO)
        console.setFormatter(formatter)
        self._log.addHandler(console)

    #查询订单
    def get_orders(self, symbol, states, limit=1):
        '''
        :param symbol:
        :param states: submitted/partial_filled/partial_canceled/canceled/pending_cancel/filled
        :return:
        '''
        success, data = self.fcoin.list_orders(symbol=symbol, states=states, limit=limit)
        if success:
            return data['data']
        else:
            print(data)
            return None
    #获取余额
    def get_blance(self):
        dic_blance = defaultdict(lambda: None)
        success, data = self.fcoin.get_balance()
        if success:
            for item in data['data']:
                dic_blance[item['currency']] = balance(float(item['available']), float(item['frozen']),float(item['balance']))
        return dic_blance
    #精度
    def digits(self,num, digit):
        site = pow(10, digit)
        tmp = num * site
        tmp = math.floor(tmp) / site
        return tmp
    #过程
    def process(self):
        if self.buy_order_id is None and self.sell_order_id is None:
            success, data = self.fcoin.get_market_depth('L20', config.symbol)
            if success:
                bids = data['data']['bids']  # 买
                asks = data['data']['asks']  # 卖
                total_bids = 0
                total_asks = 0

                for i in range(3):
                    total_bids += bids[2*i - 1]
                    total_asks += asks[2*i - 1]

                buy_price = bids[0]
                buy_amount = bids[1]

                sell_price = asks[0]
                sell_amount = asks[1]

                usdt = self.dic_balance['usdt']
                btc = self.dic_balance['btc']
                amount = 0
                price = 0
                order = None
                if btc:
                    r = self.db.get('buy',buy_price)
                    if r:
                        amount = self.digits(r['amount'], 4)
                        order = {'id': r['_id'], 'amount': amount, 'price': r['price']}

                    #if btc.available >= 0.001 and amount < 0.001:
                    #    amount = self.digits(btc.available, 4)

                    if amount >= 0.001:
                        price = self.digits(sell_price, 2)
                        success, data = self.fcoin.sell(config.symbol, price, amount)#卖
                        if success:
                            self.time_order = time.time()
                            self.sell_order_id = data['data']
                            self._log.info('挂卖单成功[%s:%s]' % (amount, price))
                            if order:
                                self.order_list[self.sell_order_id] = order
                            return
                if usdt:

                    if btc and btc.available >= config.limit_account:
                        self.dic_balance = self.get_blance()
                        self._log.info('余额度超过%s个BTC,停止买入[%s]' % (config.limit_account, btc.available))
                        return

                    if usdt.available > buy_price * config.max_amount:
                        amount = config.max_amount if total_bids > config.total_amount and total_asks > config.total_amount else config.min_amount
                    else:
                        amount = usdt.available/buy_price
                    amount = self.digits(amount, 4)
                    price = self.digits(buy_price, 2)
                    success, data = self.fcoin.buy(config.symbol, price, amount)#买
                    if success:
                        self.time_order = time.time()
                        self.buy_order_id = data['data']
                        self._log.info('挂买单成功[%s:%s]' % (amount, price))

                else:
                    self._log.info('余额错误')
                    self.dic_balance = self.get_blance()
        else:
            if self.sell_order_id:
                success, data = self.fcoin.get_order(self.sell_order_id)
                if success:
                    state = data['data']['state']
                    amount = float(data['data']['filled_amount'])

                    if state in ('filled','partial_canceled'):
                        order = self.order_list[self.sell_order_id]
                        if order:
                            self.db.update( order['id'], amount)

                    if state == 'filled':
                        self.sell_order_id = None
                        self._log.info('卖单已成交')
                        self.dic_balance = self.get_blance()

                    elif state == 'canceled' or state == 'partial_canceled':
                        self.sell_order_id = None
                        self._log.info('卖单已撤单')
                        self.dic_balance = self.get_blance()

                    elif state not in ('pending_cancel'):
                        if time.time() - self.time_order >= 15:
                            self.fcoin.cancel_order(self.sell_order_id)
                            self._log.info('15秒超时撤单')

            if self.buy_order_id:
                success, data = self.fcoin.get_order(self.buy_order_id)
                if success:
                    state = data['data']['state']
                    amount = float(data['data']['filled_amount']) - float(data['data']['fill_fees'])
                    price = float(data['data']['price'])

                    if amount > 0 and state in ('filled','partial_canceled'):
                        self.db.add('buy', price, amount)

                    if state == 'filled':
                        self.buy_order_id = None
                        self._log.info('买单已成交')
                        self.dic_balance = self.get_blance()

                    elif state == 'canceled' or state == 'partial_canceled':

                        self.buy_order_id = None
                        self._log.info('买单已撤单')
                        self.dic_balance = self.get_blance()

                    elif state not in ('pending_cancel'):
                        if time.time() - self.time_order >= 15:
                            self.fcoin.cancel_order(self.buy_order_id)
                            self._log.info('15秒超时撤单')

    def task(self):

        dic = self.get_orders(config.symbol, 'submitted', 20)
        for item in dic:
            self.fcoin.cancel_order(item['id'])
        self.dic_balance = self.get_blance()

        self.loop()

    def loop(self):
        while not self.stop:
            self.process()
            time.sleep(1)
Esempio n. 17
0
# -*- coding: utf-8 -*-
# !/usr/bin/env python

import logging
import os
from config import kline_interval
import time
from fcoin import Fcoin
import config
import mmap
from config import sdb, mdb

fcoin = Fcoin()
fcoin.auth(config.key, config.secret)
sDir = os.path.join(os.path.abspath('..'), config.sD)


class BaseSync(object):
    def __init__(self, platform, data_type, interval=''):
        self.data_type = data_type
        self.platform = platform
        self.interval = interval
        # self._init_log()

    def run(self, *args):
        self.client.start()
        while not self.client.isConnected:
            self._log.info('waitting……')
            time.sleep(0.5)
        self.sync_data(*args)
        while True:
Esempio n. 18
0
# encoding=utf8
from fcoin import Fcoin
import time
import datetime
import sys

fcoin = Fcoin()

# 订单取消时间
timeout = 300

# 交易对
symbol = "ltcusdt"

# 设置appkey/appsecret
fcoin.auth('appkey', 'appsecret')

# 格式
tradeIDs = []

#ltcusdt信息
ltcusdt_ticket = {
    "cur_price": 0,
    "cur_price_count": 0,
    "buy_price": 0,
    "buy_price_count": 0,
    "sale_price": 0,
    "sale_price_count": 0,
    # 默认为安全值
    "real_sale_price": 1000,
}