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():
