async def fetch_candles(from_date, end_date, symbol, tf): bfx = Client(logLevel='DEBUG') candles = [] minutes = tf_to_minutes(tf) print( f'Fetching from {mts_to_datetime(from_date)} to {mts_to_datetime(end_date)} | {symbol} | {tf}' ) step = math.floor(10000 * minutes) while from_date < end_date: end_of_interval = mts_to_datetime(from_date) + datetime.timedelta( minutes=step) now = datetime.datetime.now() if end_of_interval > now: end_of_interval_ts = datetime_to_mts(now) else: end_of_interval_ts = datetime_to_mts(end_of_interval) response = None while not response: try: response = await bfx.rest.get_public_candles( symbol=symbol, start=from_date, end=end_of_interval_ts, tf=tf, limit=10000) print(f'Fetched {len(response)} candles') except: print('Rate limit reached | Sleeping and trying again...') candles += response from_date = end_of_interval_ts store_candles(candles, symbol, tf) return candles
def readAccounts(): file = open('./data.txt',mode='r') data = file.read().splitlines() for line in data: acc = line.split(';') user = Client(API_KEY=acc[0],API_SECRET=acc[1],logLevel='DEBUG') users.append(user)
def backtestLive(strategy): backtesting = True bfx = Client() strategy.OrderManager = OrderManager(bfx.ws, backtesting=backtesting, logLevel='INFO') t = asyncio.ensure_future(_seed_candles(strategy, bfx)) asyncio.get_event_loop().run_until_complete(t) _start_bfx_ws(strategy)
async def create_funding(message: types.Message): bfx = Client(API_KEY=API_KEY, API_SECRET=API_SECRET, logLevel='INFO') try: response = await bfx.rest.submit_funding_offer("fUSD", 100, 0.00042, 3) except Exception as Argument: response = Argument print("Offer: ", response) await message.reply(response)
def executeLive(strategy, API_KEY, API_SECRET): backtesting = False bfx = Client(API_KEY=API_KEY, API_SECRET=API_SECRET) strategy.OrderManager = OrderManager(bfx.ws, backtesting=backtesting, logLevel='INFO') t = asyncio.ensure_future(_seed_candles(strategy, bfx)) asyncio.get_event_loop().run_until_complete(t) bfx.ws.run() bfx.ws.on('new_candle', strategy._process_new_candle) bfx.ws.on('new_trade', strategy._process_new_trade)
def _start_bfx_ws(strategy, API_KEY=None, API_SECRET=None): bfx = Client(API_KEY, API_SECRET, manageOrderBooks=True) async def subscribe(): await bfx.ws.subscribe('candles', strategy.symbol, timeframe='1m') await bfx.ws.subscribe('trades', strategy.symbol) await bfx.ws.subscribe('book', strategy.symbol) bfx.ws.on('connected', subscribe) bfx.ws.on('new_candle', strategy._process_new_candle) bfx.ws.on('new_trade', strategy._process_new_trade) bfx.ws.run()
def __init__(self, url4report, API_KEY, API_SECRET, start=0, end=10, limit='100', sort=-1): self._bfx = Client(logLevel='DEBUG', API_KEY=API_KEY, API_SECRET=API_SECRET) self._url4report = url4report self._taskStop = False now = int(round(time() * 1000)) self._then = now - (1000 * 60 * 60 * 24 * end) # (end) days ago self.start()
def _start_bfx_ws(self, API_KEY=None, API_SECRET=None, backtesting=False): bfx = Client( API_KEY, API_SECRET, manageOrderBooks=True, # verify orderbook locally dead_man_switch=True, # Kill all orders on disconnect logLevel=self.strategy.logLevel, max_retries= 120, # connection retry 120 times before exiting (10 mins) # stop the client creating a seperate thread for the event emitter and # use the strategies event emitter create_event_emitter=lambda: self.strategy.events) # use mock order manager if in backtest mode if backtesting: bfxOrderManager = MockOrderManager(bfx, logLevel=self.strategy.logLevel) bfx.ws.on('connected', self.strategy._ready) else: bfxOrderManager = OrderManager(bfx, logLevel=self.strategy.logLevel) bfx.ws.on('authenticated', self.strategy._ready) self.strategy.set_order_manager(bfxOrderManager) # Start seeding cancles t = asyncio.ensure_future( _seed_candles(self.strategy, bfx, self.timeframe)) asyncio.get_event_loop().run_until_complete(t) async def subscribe(): await bfx.ws.subscribe('candles', self.strategy.symbol, timeframe=self.timeframe) await bfx.ws.subscribe('trades', self.strategy.symbol) await bfx.ws.subscribe('book', self.strategy.symbol) # bind events bfx.ws.on('connected', subscribe) bfx.ws.on('connected', self.strategy._connected) bfx.ws.on('new_candle', self.strategy._process_new_candle) bfx.ws.on('new_candle', self._store_candle_price) bfx.ws.on('new_trade', self.strategy._process_new_trade) bfx.ws.run()
async def get_price(): bfx = Client() ticker = await bfx.rest.get_public_ticker('tETHUSD') # price is the 6th element of the ticker array # https://github.com/bitfinexcom/bitfinex-api-py/blob/729019b4c492a822d7074a8d21e274a3fbc6fab7/bfxapi/rest/bfx_rest.py#L152 return round(ticker[6], 2) # async def run(): # # ticker = await get_price() # ticker = await get_price() # print(ticker) # return(ticker[6]) # if __name__ == "__main__": # asyncio.run(main()) # t = asyncio.ensure_future(run()) # asyncio.get_event_loop().run_until_complete(t)
import os import sys sys.path.append('../../../') from bfxapi import Client API_KEY = os.getenv("BFX_KEY") API_SECRET = os.getenv("BFX_SECRET") bfx = Client(API_KEY=API_KEY, API_SECRET=API_SECRET, logLevel='INFO') @bfx.ws.on('wallet_snapshot') def log_snapshot(wallets): for wallet in wallets: print(wallet) # or bfx.ws.wallets.get_wallets() @bfx.ws.on('wallet_update') def log_update(wallet): print("Balance updates: {}".format(wallet)) @bfx.ws.on('error') def log_error(msg): print("Error: {}".format(msg)) bfx.ws.run()
import os import sys sys.path.append('../') from bfxapi import Client bfx = Client(logLevel='INFO') @bfx.ws.on('error') def log_error(err): print("Error: {}".format(err)) @bfx.ws.on('status_update') def log_msg(msg): print(msg) async def start(): await bfx.ws.subscribe_derivative_status('tBTCF0:USTF0') bfx.ws.on('connected', start) bfx.ws.run()
import os import sys sys.path.append('../../../') from bfxapi import Client, Order API_KEY = os.getenv("BFX_KEY") API_SECRET = os.getenv("BFX_SECRET") bfx = Client( API_KEY=API_KEY, API_SECRET=API_SECRET, logLevel='DEBUG', dead_man_switch=True, # <-- kill all orders if this connection drops channel_filter=['wallet'] # <-- only receive wallet updates ) @bfx.ws.on('error') def log_error(msg): print("Error: {}".format(msg)) @bfx.ws.on('authenticated') async def submit_order(auth_message): print("Authenticated!!")
'LTC', 'NEO', 'OMG', 'SAN', 'TRX', 'XLM', 'XMR', 'XRP', 'XTZ', 'ZEC', 'ZRX' ] sym2 = [ 'BTC', 'ETH', 'XRP', 'LTC', 'NEO', 'BSV', 'EOS', 'ETC', 'XMR', 'TRX', 'ZEC' ] tickerDataFields = [ 'daily_change', 'daily_change_relative', 'last_price', 'volume', 'high', 'low' ] # tickerDict = {} tickerArrayDict = {} bfx = Client( # API_KEY=API_KEY, # API_SECRET=API_SECRET, logLevel='INFO', dead_man_switch=True, channel_filter=['ticker', 'candle'], ) @bfx.ws.on('error') def log_error(msg): log.error(msg) @bfx.ws.on('subscribed') def show_channel(sub): symbol = sub.symbol channel_name = sub.channel_name log.info(f"{symbol} subscribed - channel: {channel_name}")
def __init__(self, _id): self.id = _id self.bfx = Client(logLevel='INFO') self.subscriptions = {'trades': {}, 'ticker': {}} self.is_ready = False
def __init__(self, *args, **params): # self._client = BfxRest(API_KEY=params.get('api_key', None), # API_SECRET=params.get('api_secret', None)) self._client = Client(API_KEY=params.get('api_key', None), API_SECRET=params.get('api_secret', None)).rest
import os import sys sys.path.append('../') from bfxapi import Client, Order API_KEY=os.getenv("BFX_KEY") API_SECRET=os.getenv("BFX_SECRET") bfx = Client( API_KEY=' logLevel='DEBUG' ) # def sell(client, price): @bfx.ws.on('order_snapshot') async def cancel_all(data): await bfx.ws.cancel_all_orders() @bfx.ws.on('order_confirmed') async def trade_completed(order): print ("Order confirmed.") print (order) ## close the order # await order.close() # or # await bfx.ws.cancel_order(order.id)
import os import sys from bfxapi import Client, Order import ssl symbol = 'tBTCUSD' bfx = Client( API_KEY=os.getenv('API_KEY'), API_SECRET=os.getenv('API_SECRET'), logLevel='INFO' ) print('API_KEY: {}'.format(os.getenv('API_KEY'))) print('API_SECRET: {}'.format(os.getenv('API_SECRET'))) print(bfx) @bfx.ws.on('authenticated') async def submit_order(auth_message): # await bfx.ws.submit_order(symbol, 19000, 0.01, Order.Type.EXCHANGE_MARKET) print('Authz: {}'.format(auth_message)) @bfx.ws.on('seed_candle') async def seed_candle(o): print('seed_candle: {}'.format(o)) @bfx.ws.on('new_candle') async def new_candle(arr): print('new_candle: {}'.format(arr))
import os import sys import asyncio import time sys.path.append('../') from bfxapi import Client API_KEY=os.getenv("BFX_KEY") API_SECRET=os.getenv("BFX_SECRET") bfx = Client( API_KEY=API_KEY, API_SECRET=API_SECRET, logLevel='DEBUG' ) now = int(round(time.time() * 1000)) then = now - (1000 * 60 * 60 * 24 * 10) # 10 days ago async def log_wallets(): wallets = await bfx.rest.get_wallets() print ("Wallets:") [ print (w) for w in wallets ] async def log_active_orders(): orders = await bfx.rest.get_active_orders('tBTCUSD') print ("Orders:") [ print (o) for o in orders ] async def log_orders_history():
import os, sys from datetime import datetime import asyncio import requests import json from bfxapi import Client API_KEY = os.environ.get('API_KEY', None) API_SECRET = os.environ.get('API_SECRET', None) SLACK_URL = os.environ.get('SLACK_URL', None) bfx = Client( API_KEY=API_KEY, API_SECRET=API_SECRET, logLevel='WARNING', ) # event type FUNDING_ORDER_CANCEL = 'foc' HEARTBEAT = 'hb' FUNDING_LOAN_CLOSED = 'flc' if API_KEY == None or API_SECRET == None: print("API_KEY and API_SECRET should not be None") sys.exit() if SLACK_URL == None: print("SLACK_URL should not be None") sys.exit() @bfx.ws.on('wallet_update')
import os import sys import asyncio import time sys.path.append('../../../') from bfxapi import Client bfx = Client(logLevel='DEBUG', ) out_path = "/Users/leek/code/python/btc_price/btc_price2.txt" start_time = 1358179200 * 1000 # 2013/01/15, the first date's btc price step_time = 86400 * 1000 end_time = 1611331200 * 1000 # 2021/01/23, the end date's btc price def get_write_last_time(): if not os.path.exists(out_path): return "" with open(out_path, "r") as read_file: last_line = read_file.readlines()[-1] if len(last_line) != 0: return last_line.split(" ")[0] else: return "" async def get_btc_price(): progress_time = start_time write_last_time = get_write_last_time() if write_last_time != "": progress_time = int(write_last_time)
def conect(API_KEY, API_SECRET): bfx = Client(API_KEY, API_SECRET) return (bfx)
import os import sys import asyncio import time sys.path.append('../') from bfxapi import Client API_KEY=os.getenv("BFX_KEY") API_SECRET=os.getenv("BFX_SECRET") bfx = Client( API_KEY=API_KEY, API_SECRET=API_SECRET, logLevel='DEBUG', rest_host='https://test.bitfinex.com/v2' ) now = int(round(time.time() * 1000)) then = now - (1000 * 60 * 60 * 24 * 10) # 10 days ago async def log_wallets(): wallets = await bfx.rest.get_wallets() print ("Wallets:") [ print (w) for w in wallets ] async def log_active_orders(): orders = await bfx.rest.get_active_orders('tBTCUSD') print ("Orders:") [ print (o) for o in orders ]
import collections import kafka from bfxapi import Client from order_book import OrderBook from order_book import kafka_send bfx = Client() exchange = "Bitfinex" host = ['localhost:9092'] producer = kafka.KafkaProducer(bootstrap_servers=host) kafka.KafkaClient(bootstrap_servers=host).add_topic('all') with open('./trading_pairs/bitfinex.pair', 'r') as f: pairs = [e.replace('\n', '') for e in f.readlines()] pairs = list(map(lambda x: 't' + x, pairs)) local_book = collections.defaultdict(OrderBook) @bfx.ws.on('error') def log_error(err): print("Error: {}".format(err)) @bfx.ws.on('order_book_update') def log_update(data): ob = local_book[data['symbol']] order_change = ob.update_order(data['data']) if order_change:
websocketLogger = logging.getLogger('websockets') websocketLogger.setLevel(logging.INFO) websocketLogger.addHandler(logging.StreamHandler()) sys.path.append('bfxapi') listTrades = [] keepingBooksBids = [] keepingBooksAsks = [] lockTrades = threading.Lock() lockBooks = threading.Lock() bfx = Client( # logLevel='DEBUG', logLevel='INFO', # Verifies that the local orderbook is up to date # with the bitfinex servers manageOrderBooks=True, ) @bfx.ws.on('error') def log_error(err): log.error("Error: {}".format(err)) @bfx.ws.on('order_book_snapshot') def log_snapshot(data): pass # log.debug("Initial book: {}".format(data)) # with lockBooks:
import time import math import asyncio import os import sys import json import logging logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s : %(message)s', filename='auto_lend.log') with open('config.json', 'r') as reader: config = json.loads(reader.read()) bfx = Client(config['API_KEY'], config['API_SECRET'], logLevel='DEBUG') now = int(round(time.time() * 1000)) then = now - (1000 * 60 * 60 * 24 * 10) # 10 days ago async def wallet_available_balance(): try: balance = await bfx.rest.get_available_balance('fUSD', 1, 800, 'FUNDING') return round(balance[0] * (-1), 3) - 0.001 except Exception as e: logging.error(e) return 0 async def get_books():