def main():
console.log('Starting...')
exchanges['bitstamp'] = Exchange(
ccxt.bitstamp(config=config.bitstamp.to_dict()))
exchanges['binance'] = Exchange(
ccxt.binance(config=config.binance.to_dict()))
exchanges['bittrex'] = Exchange(
ccxt.bittrex(config=config.bittrex.to_dict()))
exchanges['cryptopia'] = Exchange(
ccxt.cryptopia(config=config.cryptopia.to_dict()))
exchanges['hitbtc'] = Exchange(
ccxt.hitbtc2(config=config.hitbtc.to_dict()))
telebot.add_handler(
telegram.CommandHandler(command='balance',
callback=TelegramCommands.get_balance))
telebot.add_handler(
telegram.CommandHandler(command='start',
callback=TelegramCommands.start))
telebot.add_handler(
telegram.CommandHandler(command='help',
callback=TelegramCommands.show_help))
telebot.start()
console.log('Ready...')
telebot.idle()
def load_datasets(symbols, timeframe, val_ratio, sequence_length):
# LOAD DAT
exchange = ccxt.bitstamp({"enableRateLimit": True, "rateLimit": 85})
trains, vals = [], []
for sym in symbols:
df = get_crypto_dataset(
exchange,
symbol=sym,
timeframe=timeframe,
start_date=datetime(2015, 1, 1),
max_per_page=1000,
)
df = process_dtypes(df)
df = add_time_idx(df)
df = df.iloc[len(df) // 10:]
print(sym, len(df))
val_size = int(len(df) * val_ratio)
train, val = StockDataset(df[:-val_size],
sequence_length), StockDataset(
df[-val_size:], sequence_length)
trains.append(train)
vals.append(val)
train_dataset = ConcatDataset(trains)
val_dataset = ConcatDataset(vals)
return train_dataset, val_dataset
def __init__(self):
self.bitstamp = ccxt.bitstamp({'nonce': ccxt.bitstamp.milliseconds})
if (settings['bitstamp_exporter'].get('api_key')
and (settings['bitstamp_exporter'].get('api_secret'))):
self.bitstamp.apiKey = settings['bitstamp_exporter'].get('api_key')
self.bitstamp.secret = settings['bitstamp_exporter'].get(
'api_secret')
self.hasApiCredentials = True
def get_btc_rates():
luno = ccxt.luno()
bitstamp = ccxt.bitstamp()
ice3x = ccxt.ice3x()
luno_btc = luno.fetch_ticker('BTC/ZAR')
bs_btc = bitstamp.fetch_ticker('BTC/USD')
ice_btc = ice3x.fetch_ticker('BTC/ZAR')
return luno_btc, bs_btc, ice_btc
def get_ticker_rates(ex=ccxt.bitstamp(),
tickers=np.array(['BTC/USD', 'LTC/USD'])):
rates = []
for ticker in tickers:
rate = ex.fetch_ticker(ticker)
rates.append(rate.copy())
rate.clear()
sleep(2)
return rates
def start_bitstamp_producer():
products = [
"BTC/USD", "ETH/USD", "BCH/USD", "LTC/USD", "LTC/BTC", "ETH/BTC",
"BCH/BTC"
]
while True:
for product in products:
data = BitStamp(product, bitstamp().fetch_order_book(product))
data.produce()
def init_supported_exchanges():
objects = {
"binance": ccxt.binance(),
"bitfinex": ccxt.bitfinex(),
"bitflyer": ccxt.bitflyer(),
"bitstamp": ccxt.bitstamp(),
"bittrex": ccxt.bittrex(),
"coinbase": ccxt.coinbase(),
"kraken": ccxt.kraken(),
"poloniex": ccxt.poloniex()
}
return objects
def bitstampData():
bitstamp = ccxt.bitstamp()
coindata = list(bitstamp.fetch_tickers().values())
columns = ['ask', 'bid', 'close', 'high', 'low', 'last', 'symbol', 'average', 'baseVolume', 'timestamp']
df = pd.DataFrame(coindata)
df = df[columns]
df['exchange'] = 'bitstamp'
df['createtime'] = starttime
df['baseCurrency'] = list(i.split('/')[0] for i in df['symbol'])
df['quotCurrency'] = list(i.split('/')[1] for i in df['symbol'])
engine = create_engine("mysql+pymysql://quziyou:0739#[email protected]:5389/coinData?charset=utf8")
df.to_sql('coindata_tickers', con=engine, if_exists='append', index=False)
def __init__(self, bitstamp_orderbook: OrderBook, diginet_orderbook: OrderBook, session: SessionObj):
self.signal = True
self.logger = logging.getLogger(__name__)
self.bitstamp_orderbook = bitstamp_orderbook
self.diginet_orderbook = diginet_orderbook
self.exchanges = []
self.session_obj = session
self.settings = self.session_obj.settings
self.bitstamp_exchanger = ccxt.bitstamp({'apiKey': self.settings['bitstamp']['key'],
'secret': self.settings['bitstamp']['secret'],
'uid': self.settings['bitstamp']['uid']})
self.diginet_exchanger = diginet({'apiKey': self.settings['diginet']['key'],
'secret': self.settings['diginet']['secret'],
'urls': {'extension': '.json', 'api': 'https://trade.diginet.io'}})
def exchangeObject(exchange_in):
exchanges = [ccxt.acx(),ccxt.bitbay(),ccxt.bitfinex(),ccxt.bitflyer(),ccxt.bithumb(),ccxt.bitlish(),ccxt.bitmarket(),ccxt.bitmex(),ccxt.bitso(),
ccxt.bitstamp(),ccxt.bitstamp1(),ccxt.bittrex(),ccxt.bl3p(),ccxt.bleutrade(),ccxt.btcbox(),ccxt.btcchina(),ccxt.btcexchange(),ccxt.btcmarkets(),ccxt.btctradeua(),ccxt.btcturk(),
ccxt.btcx(),ccxt.bxinth(),ccxt.ccex(),ccxt.cex(),ccxt.chbtc(),ccxt.chilebit(),ccxt.coincheck(),ccxt.coinfloor(),ccxt.coingi(),ccxt.coinmarketcap(),ccxt.coinmate(),
ccxt.coinsecure(),ccxt.coinspot(),ccxt.cryptopia(),ccxt.dsx(),ccxt.exmo(),ccxt.flowbtc(),ccxt.foxbit(),ccxt.fybse(),ccxt.fybsg(),ccxt.gatecoin(),ccxt.gateio(),ccxt.gdax(),
ccxt.gemini(),ccxt.getbtc(),ccxt.hitbtc(),ccxt.huobi(),ccxt.huobicny(),ccxt.independentreserve(),ccxt.itbit(),ccxt.jubi(),ccxt.kraken(),ccxt.kucoin(),
ccxt.kuna(),ccxt.lakebtc(),ccxt.liqui(),ccxt.livecoin(),ccxt.luno(),ccxt.mercado(),ccxt.mixcoins(),ccxt.nova(),ccxt.okcoincny(),ccxt.okcoinusd(),ccxt.okex(),ccxt.paymium(),
ccxt.poloniex(),ccxt.qryptos(),ccxt.quadrigacx(),ccxt.southxchange(),ccxt.surbitcoin(),ccxt.therock(),ccxt.tidex(),ccxt.urdubit(),ccxt.vaultoro(),ccxt.vbtc(),
ccxt.virwox(),ccxt.wex(),ccxt.xbtce(),ccxt.yobit(),ccxt.yunbi(),ccxt.zaif(),ccxt.zb()]
for count, exchange in enumerate([str(x) for x in exchanges]):
if exchange_in.lower() in exchange:
return exchanges[count]
break
def main():
# 实例化市场
exchanges = [ccxt.bitstamp(), ccxt.bitflyer()]
# 交易对
symbols = ['BTC/USD']
tasks = []
i = 0
j = 0
for i in range(len(exchanges)):
for j in range(len(symbols)):
# tasks.append(self.proxy_resource_Url + str(i))
task = getData(exchanges[i], symbols[j])
tasks.append(asyncio.ensure_future(task))
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
def __init__(self,
key=None,
secret=None,
currency_from="EUR",
currency_to="BTC"):
super().__init__(currency_from=currency_from, currency_to=currency_to)
self.exchange = ccxt.bitstamp()
self.exchange.apiKey = key
self.exchange.secret = secret
self.set_sell_fees(variable=0.25 / 100)
self.set_buy_fees(variable=0.25 / 100)
self.set_send_fees(variable=0.1 / 100)
self.set_receive_fees(fixed=0)
self.set_withdrawl_fees(fixed=15, variable=0.09 / 100)
self.set_deposit_fees(fixed=7.5, variable=0.05 / 100)
def __init__(self, logger=None):
self.logger = logger or logging.getLogger(__name__)
self.config = configparser.ConfigParser()
self.config.read('config.ini')
self.diginet = ccxt.acx({
'apiKey': self.config['bot']['diginet_key'],
'secret': self.config['bot']['diginet_secret'],
'urls': {
'extension': '.json',
'api': 'https://trade.diginet.io'
}
})
self.bitstamp = ccxt.bitstamp({
'apiKey':
self.config['bot']['bitstamp_key'],
'secret':
self.config['bot']['bitstamp_secret']
})
def get_bitstamp_static(file):
bitstamp = ccxt.bitstamp()
fee = bitstamp.fees
taker_fee, maker_fee = fee['trading']['taker'], fee['trading']['maker']
with open(file, 'a') as csvFile:
csvwriter = csv.writer(csvFile)
for i in bitstamp.fetch_markets():
if i['symbol'] in ['BTC/USD', 'ETH/USD', 'BCH/USD']:
uid = i['symbol'].replace('/', '_') + '-bitstamp'
csvwriter.writerow([
uid, 'Bitstamp', i['id'], '', '1',
i['limits']['amount']['min'], i['limits']['amount']['max'],
i['limits']['price']['min'], i['limits']['price']['max'],
i['precision']['amount'], i['precision']['price'],
taker_fee * 10000, maker_fee * 10000, 0, 0,
'cryptocurrency'
])
def bitstamp():
bs = ccxt.bitstamp()
params = {'group': 1}
data = bs.fetch_order_book('BTC/USD', params=params)
asks = data['asks']
bids = data['bids']
price = (asks[0][0]+bids[0][0])/2
bids_info = get_ratio_sum(bids, 'bids')
asks_info = get_ratio_sum(asks, 'asks')
res = {}
res.update(bids_info)
res.update(asks_info)
res['price'] = price
res['exchange'] = 'bitstamp'
return res
def get(cls):
return {
'binance':
ccxt.binance({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'bitstamp':
ccxt.bitstamp({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'bittrex':
ccxt.bittrex({
'apiKey': os.environ.get("BITTREX_KEY"),
'secret': os.environ.get("BITTREX_SECRET"),
}),
'gdax':
ccxt.gdax({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'hitbtc':
ccxt.hitbtc({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'kraken':
ccxt.kraken({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'liqui':
ccxt.liqui({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'poloniex':
ccxt.poloniex({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
# add additional supported exchanges
}
def __init__(self,
exchange: str = 'bitstamp',
pair: str = 'BTC/USD',
logger=None):
self.exchange = exchange
self.pair = pair
self.logger = logger or logging.getLogger(__name__)
if self.exchange == 'bitstamp':
self.source = ccxt.bitstamp()
elif self.exchange == 'diginet':
self.source = ccxt.acx({
'urls': {
'extension': '.json',
'api': 'https://trade.diginet.io'
}
})
else:
raise ValueError('Exchange not supported!')
self.asks = []
self.bids = []
self.last_update: float = 0
self.update_thread = None
def fetch_exchange_data(exchange_name):
bitstamp = ccxt.bitstamp()
bitmex = ccxt.bitmex()
bitfinex = ccxt.bitfinex2()
bittrex = ccxt.bittrex()
okcoin = ccxt.okcoinusd()
kraken = ccxt.kraken()
binance = ccxt.binance()
coss = ccxt.coss()
kucoin = ccxt.kucoin2()
poloniex = ccxt.poloniex()
# theocean = ccxt.theocean()
upbit = ccxt.upbit()
dict_of_exchanges = {
'kraken': kraken,
'bitmex': bitmex,
'bittrex': bittrex,
'bitstamp': bitstamp,
'bitfinex': bitfinex,
'okcoin': okcoin,
'binance': binance,
'coss': coss,
'kucoin': kucoin,
'poloniex': poloniex,
# 'theocean': theocean,
'upbit': upbit
}
try:
return dict(
dict_of_exchanges[exchange_name].fetch_order_book('BTC/USD'))
# return dict(dict_of_exchanges[exchange_name].fetch_order_book('XRP/USD'))
# return dict(dict_of_exchanges[exchange_name].fetch_order_book('LTC/USD'))
# add BitcoinCash
# return dict(dict_of_exchanges[exchange_name].fetch_order_book('ETH/USD'))
except Exception as ex:
print('%s - erro: %s' % (exchange_name, ex))
return {}
def bitstamp_test():
# 初始化bitme交易所对象
bitmex = ccxt.bitstamp()
# 请求的candles个数
limit = 500
# 当前时间
current_time = int(time.time() // 60 * 60 * 1000) # 毫秒
print(current_time)
# 获取请求开始的时间
since_time = current_time - limit * 60 * 1000
# 'BTC/USD' 比特币对美元的交易对，或者ETH/USD 以太坊对美元的交易对.
data = bitmex.fetch_ohlcv(symbol='BTC/USD', limit=500, since=since_time)
df = pd.DataFrame(data)
df = df.rename(columns={
0: 'open_time',
1: 'open',
2: 'high',
3: 'low',
4: 'close',
5: 'volume'
})
# 时间转换成北京时间
df['open_time'] = pd.to_datetime(df['open_time'],
unit='ms') + pd.Timedelta(hours=8)
# 设置index
df = df.set_index('open_time', drop=True)
# 保存成csv文件
df.to_csv('bitmex_data.csv') # comma seperate Value
print(df)
'enableRateLimit': True,
})
bitfinex = ccxt.bitfinex({
'enableRateLimit': True,
})
livecoin = ccxt.livecoin({
'enableRateLimit': True,
})
kucoin = ccxt.kucoin({
'enableRateLimit': True,
})
cex = ccxt.cex({
'enableRateLimit': True,
})
bitstamp = ccxt.bitstamp({
'enableRateLimit': True,
})
binance_ltc_address = 'LLmWdKju3aHzS8q5azoVGSfPV6NY6a4PvY'
exmo_ltc_address = 'LThC9vNBvyJz7UesBAmpMaJNfHFhxXqhb6'
#----------XRP------------
hitbtc_xrp_deposit_address = 'rhL5Va5tDbUUuozS9isvEuv7Uk1uuJaY1T'
hitbtc_xrp_tag = '1492555998'
exmo_xrp_deposit_address = 'rUocf1ixKzTuEe34kmVhRvGqNCofY1NJzV'
exmo_xrp_tag = '363160755'
#----------DAI------------
hitbtc_dai_deposit_address = '0x391a04d8cb95a5a8f22af609abefe4067b7cc4d8'
#----------BTC------------
# Bitfinex
bitfinex = ccxt.bitfinex()
bitfinexInfo = bitfinex.publicGetSymbolsDetails()
bitfinexRawPairs = [entry['pair'].upper() for entry in bitfinexInfo]
bitfinexTradeablePairs = list(filter(cT, bitfinexRawPairs))
print(bitfinexTradeablePairs)
# Huobi
huobi = ccxt.huobipro()
huobiInfo = huobi.publicGetCommonSymbols()['data']
huobiRawPairs = [entry['symbol'].upper() for entry in huobiInfo]
huobiTradeablePairs = list(filter(cT, huobiRawPairs))
print(huobiTradeablePairs)
# Bitstamp
bitstamp = ccxt.bitstamp()
bitstampInfo = bitstamp.publicGetTradingPairsInfo()
bitstampRawPairs = [entry['name'].replace('/', '') for entry in bitstampInfo]
bitstampSymbols = list(filter(cT, bitstampRawPairs))
print('Bitstamp')
print(bitstampSymbols)
for (a1, a2) in kPairs:
print(a1 + ' : ' + a2)
print('Binance Time: ' + str(B.publicGetTime()['serverTime']))
print('Kraken Time: ' + str(K.publicGetTime()['result']['unixtime']))
print('Local Time: ' + str(time()))
kResp = K.publicGetTicker({'pair': ','.join(kTradeablePairs)})
for resp in kResp['result']:
'exchangeName': "kraken",
'database': kraken_db
})
binance = ccxt.binance({
'rateLimit': 3000,
'enableRateLimit': True,
# 'verbose': True,
'exchangeName': "binance"
, 'database': binance_db
})
bitstamp = ccxt.bitstamp({
'rateLimit': 3000,
'enableRateLimit': True,
# 'verbose': True,
'exchangeName': "bitstamp",
'database': bitstamp_db
})
btcturk = ccxt.btcturk({
'rateLimit': 3000,
'enableRateLimit': True,
# 'verbose': True,
'exchangeName': "btcturk",
'database': btcturk_db
})
hitbtc = ccxt.hitbtc2({
'rateLimit': 3000,
'enableRateLimit': True,
import ccxt
exchanges = {
'binance': ccxt.binance(),
# 'kucoin': ccxt.kucoin(),
'bittrex': ccxt.bittrex(),
'bitstamp': ccxt.bitstamp(),
'poloniex': ccxt.poloniex(),
# 'bitforex': ccxt.bitforex(),
# 'hitbtc': ccxt.hitbtc(),
}
def main():
last_update_id = None
start_time = datetime.datetime.now()
RunBot = True
morningMessage = False
sesh = requests.session()
# ccxt
luno = ccxt.luno()
bitstamp = ccxt.bitstamp()
ice3x = ccxt.ice3x()
src_bot.check_arb(start_time - start_time,
start_time,
base_chat_id,
URL,
db,
runNow=True,
s=sesh,
bitstamp=bitstamp,
luno=luno,
ice3x=ice3x)
db.setup()
print("Listening...")
try_count = 0
triggerFlag = True
while RunBot:
with sesh as bot_session:
try:
updates = src_bot.get_updates(URL,
s=bot_session,
offset=last_update_id)
if len(updates["result"]) > 0:
last_update_id = src_bot.get_last_update_id(updates) + 1
tdiff = datetime.datetime.now() - start_time
RunBot, triggerFlag = src_bot.bot_responses(
updates,
URL,
token,
db,
s=bot_session,
triggerFlag=triggerFlag)
start_time, triggerFlag = src_bot.check_arb(
tdiff,
start_time,
base_chat_id,
URL,
db,
s=bot_session,
bitstamp=bitstamp,
luno=luno,
ice3x=ice3x,
triggerFlag=triggerFlag)
morningMessage = src_bot.good_morning(morningMessage,
base_chat_id,
URL,
token,
db,
s=bot_session)
gc.collect()
try_count = 0
except Exception as e:
CT = datetime.datetime.now()
logging.debug(str(CT) + ' ' + str(e))
try_count += 1
#print updates
print("Bot has failed {n} times".format(n=try_count))
gc.collect()
if try_count >= 100:
src_bot.send_message("Bot failed 100 times in a row",
chat_id=base_chat_id,
URL=URL,
s=bot_session)
RunBot = False
else:
time.sleep(3 * 60)
time.sleep(5)
def init_supported_exchanges():
objects = {
"acx": ccxt.acx(),
"aofex": ccxt.aofex(),
"bequant": ccxt.bequant(),
"bibox": ccxt.bibox(),
"bigone": ccxt.bigone(),
"binance": ccxt.binance(),
"bitbank": ccxt.bitbank(),
"bitbay": ccxt.bitbay(),
"bitfinex": ccxt.bitfinex(),
"bitflyer": ccxt.bitflyer(),
"bitforex": ccxt.bitforex(),
"bithumb": ccxt.bithumb(),
"bitkk": ccxt.bitkk(),
"bitmax": ccxt.bitmax(),
"bitstamp": ccxt.bitstamp(),
"bittrex": ccxt.bittrex(),
"bitz": ccxt.bitz(),
"bl3p": ccxt.bl3p(),
"bleutrade": ccxt.bleutrade(),
"braziliex": ccxt.braziliex(),
"btcalpha": ccxt.btcalpha(),
"btcbox": ccxt.btcbox(),
"btcmarkets": ccxt.btcmarkets(),
"btctradeua": ccxt.btctradeua(),
"bw": ccxt.bw(),
"bybit": ccxt.bybit(),
"bytetrade": ccxt.bytetrade(),
"cex": ccxt.cex(),
"chilebit": ccxt.chilebit(),
"coinbase": ccxt.coinbase(),
"coinbasepro": ccxt.coinbasepro(),
"coincheck": ccxt.coincheck(),
"coinegg": ccxt.coinegg(),
"coinex": ccxt.coinex(),
"coinfalcon": ccxt.coinfalcon(),
"coinfloor": ccxt.coinfloor(),
"coinmate": ccxt.coinmate(),
"coinone": ccxt.coinone(),
"crex24": ccxt.crex24(),
"currencycom": ccxt.currencycom(),
"digifinex": ccxt.digifinex(),
"dsx": ccxt.dsx(),
"eterbase": ccxt.eterbase(),
"exmo": ccxt.exmo(),
"exx": ccxt.exx(),
"foxbit": ccxt.foxbit(),
"ftx": ccxt.ftx(),
"gateio": ccxt.gateio(),
"gemini": ccxt.gemini(),
"hbtc": ccxt.hbtc(),
"hitbtc": ccxt.hitbtc(),
"hollaex": ccxt.hollaex(),
"huobipro": ccxt.huobipro(),
"ice3x": ccxt.ice3x(),
"independentreserve": ccxt.independentreserve(),
"indodax": ccxt.indodax(),
"itbit": ccxt.itbit(),
"kraken": ccxt.kraken(),
"kucoin": ccxt.kucoin(),
"lakebtc": ccxt.lakebtc(),
"latoken": ccxt.latoken(),
"lbank": ccxt.lbank(),
"liquid": ccxt.liquid(),
"livecoin": ccxt.livecoin(),
"luno": ccxt.luno(),
"lykke": ccxt.lykke(),
"mercado": ccxt.mercado(),
"oceanex": ccxt.oceanex(),
"okcoin": ccxt.okcoin(),
"okex": ccxt.okex(),
"paymium": ccxt.paymium(),
"poloniex": ccxt.poloniex(),
"probit": ccxt.probit(),
"southxchange": ccxt.southxchange(),
"stex": ccxt.stex(),
"surbitcoin": ccxt.surbitcoin(),
"therock": ccxt.therock(),
"tidebit": ccxt.tidebit(),
"tidex": ccxt.tidex(),
"upbit": ccxt.upbit(),
"vbtc": ccxt.vbtc(),
"wavesexchange": ccxt.wavesexchange(),
"whitebit": ccxt.whitebit(),
"yobit": ccxt.yobit(),
"zaif": ccxt.zaif(),
"zb": ccxt.zb()
}
return objects
import ccxt
import pandas as pd
from datetime import datetime
import time
exchange = ccxt.bitstamp({
'enableRateLimit':True,
})
msec = 1000
minute = 60*msec
hour = 60 * minute
now = exchange.milliseconds()
def get_candles(symbol, timeframe, limit, from_timestamp,):
try:
candles = exchange.fetch_ohlcv(
symbol = symbol,
timeframe = timeframe,
limit = limit,
since = from_timestamp,
)
header = ['timestamp', 'open', 'high', 'low', 'close', 'volume']
df = pd.DataFrame(candles, columns = header)
df.insert(1, 'datetime', [datetime.fromtimestamp(d/1000) for d in df.timestamp])
return df.sort_values(by='timestamp', ascending = False)
except Exception as e:
class Crypto:
# dictionary of supported exchanges
# user needs to input public API key and secret for existing accounts
exchanges = {
'binance':
ccxt.binance({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'bitstamp':
ccxt.bitstamp({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'bittrex':
ccxt.bittrex({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'gdax':
ccxt.gdax({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'hitbtc':
ccxt.hitbtc({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'kraken':
ccxt.kraken({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'liqui':
ccxt.liqui({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
'poloniex':
ccxt.poloniex({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
}),
# add additional supported exchanges
}
def __init__(self, exchange='bittrex'):
self.exchange = self.exchanges[exchange]
def run_prepump(self):
prepumped_markets = self.find_prepumped_markets()
print "Pre-pumped markets on %s:" % (self.exchange.name)
print prepumped_markets
hits = []
# Just test on 10 ranodm markets
sample_size = 10
prepumped_markets = self.random_sample(prepumped_markets, sample_size)
print "Testing: sampling %s markets: " % (sample_size)
print prepumped_markets
for market in prepumped_markets:
print "Testing market %s for arbitrage" % (market)
result = self.expected_value(market, 0.05, 0.01, 0.0025)
if result:
print "- HIT!"
hits.append(result)
else:
print "- None"
sleep(1)
print "HITS !!!!!!!!"
print "Number of hits: ", len(hits)
print hits
def fetch_markets(self, symbol):
prices = {}
exchanges = self.exchanges
# pull prices of coin across exchanges
for key in exchanges:
try:
market_info = exchanges[key].fetch_ticker(symbol)
except:
continue
market_bid = market_info["bid"]
market_ask = market_info["ask"]
# Ignore when None
if (market_bid is None) or (market_ask is None):
continue
prices.setdefault("bid", {})
prices.setdefault("ask", {})
prices["bid"][key] = market_bid
prices["ask"][key] = market_ask
return prices
def exchange():
cursor = con.cursor()
kraken = ccxt.kraken()
df = kraken.fetchTicker('BTC/USD')
df.pop('info')
df1 = [df]
cursor.execute(
"insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('kraken',"
+ str(df['high']) + "," + str(df['low']) + "," + str(df['last']) +
"," + str(df['timestamp']) + "," + str(df['bid']) + "," +
str(df['ask']) + ")")
con.commit()
cursor = con.cursor()
bitfinex = ccxt.bitfinex()
df = bitfinex.fetchTicker('BTC/USD')
df.pop('info')
df1 = [df]
cursor.execute(
"insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('bitfinex',"
+ str(df['high']) + "," + str(df['low']) + "," + str(df['last']) +
"," + str(df['timestamp']) + "," + str(df['bid']) + "," +
str(df['ask']) + ")")
con.commit()
# cursor = con.cursor()
# poloniex = ccxt.poloniex()
# df = poloniex.fetchTicker('BTC/USD')
# df.pop('info')
# df1 = [df]
# cursor.execute("insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('poloniex',"+str(df['high'])+","+str(df['low'])+","+str(df['last'])+","+str(df['timestamp'])+","+str(df['bid'])+","+str(df['ask'])+ ")")
# con.commit()
cursor = con.cursor()
bitmex = ccxt.bitmex()
df = bitmex.fetchTicker('BTC/USD')
df.pop('info')
df1 = [df]
cursor.execute(
"insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('bitmex',"
+ str(df['high']) + "," + str(df['low']) + "," + str(df['last']) +
"," + str(df['timestamp']) + "," + str(df['bid']) + "," +
str(df['ask']) + ")")
con.commit()
cursor = con.cursor()
bittrex = ccxt.bittrex()
df = bittrex.fetchTicker('BTC/USDT')
df.pop('info')
df1 = [df]
cursor.execute(
"insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('bittrex',"
+ str(df['high']) + "," + str(df['low']) + "," + str(df['last']) +
"," + str(df['timestamp']) + "," + str(df['bid']) + "," +
str(df['ask']) + ")")
con.commit()
cursor = con.cursor()
hitbtc = ccxt.hitbtc()
df = hitbtc.fetchTicker('BTC/USDT')
df.pop('info')
df1 = [df]
cursor.execute(
"insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('hitbtc',"
+ str(df['high']) + "," + str(df['low']) + "," + str(df['last']) +
"," + str(df['timestamp']) + "," + str(df['bid']) + "," +
str(df['ask']) + ")")
con.commit()
# cursor = con.cursor()
# okex = ccxt.okex()
# df = okex.fetchTicker('BTC/USD')
# df.pop('info')
# df1 = [df]
# cursor.execute("insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('okex',"+str(df['high'])+","+str(df['low'])+","+str(df['last'])+","+str(df['timestamp'])+","+str(df['bid'])+","+str(df['ask'])+ ")")
# con.commit()
# cursor = con.cursor()
# deribit = ccxt.deribit()
# df = deribit.fetchTicker('BTC/USD')
# df.pop('info')
# df1 = [df]
# cursor.execute("insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('deribit',"+str(df['high'])+","+str(df['low'])+","+str(df['last'])+","+str(df['timestamp'])+","+str(df['bid'])+","+str(df['ask'])+ ")")
# con.commit()
# cursor = con.cursor()
# acx = ccxt.acx()
# df = acx.fetchTicker('BTC/USDT')
# df.pop('info')
# df1 = [df]
# cursor.execute("insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('acx',"+str(df['high'])+","+str(df['low'])+","+str(df['last'])+","+str(df['timestamp'])+","+str(df['bid'])+","+str(df['ask'])+ ")")
# con.commit()
cursor = con.cursor()
bitstamp = ccxt.bitstamp()
df = bitstamp.fetchTicker('BTC/USD')
df.pop('info')
df1 = [df]
cursor.execute(
"insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('bitstamp',"
+ str(df['high']) + "," + str(df['low']) + "," + str(df['last']) +
"," + str(df['timestamp']) + "," + str(df['bid']) + "," +
str(df['ask']) + ")")
con.commit()
# cursor = con.cursor()
# gemini = ccxt.gemini()
# df = gemini.fetchTicker('BTC/USD')
# df.pop('info')
# df1 = [df]
# cursor.execute("insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('gemini',"+str(df['high'])+","+str(df['low'])+","+str(df['last'])+","+str(df['timestamp'])+","+str(df['bid'])+","+str(df['ask'])+ ")")
# con.commit()
cursor = con.cursor()
binance = ccxt.binance()
df = binance.fetchTicker('BTC/USDT')
df.pop('info')
df1 = [df]
cursor.execute(
"insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('binance',"
+ str(df['high']) + "," + str(df['low']) + "," + str(df['last']) +
"," + str(df['timestamp']) + "," + str(df['bid']) + "," +
str(df['ask']) + ")")
con.commit()
# cursor = con.cursor()
# qryptos = ccxt.qryptos()
# df = qryptos.fetchTicker('BTC/USDT')
# df.pop('info')
# df1 = [df]
# cursor.execute("insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('qryptos',"+str(df['high'])+","+str(df['low'])+","+str(df['last'])+","+str(df['timestamp'])+","+str(df['bid'])+","+str(df['ask'])+ ")")
# con.commit()
# cursor = con.cursor()
# huobi = ccxt.huobi()
# df = huobi.fetchTicker('BTC/USDT')
# df.pop('info')
# df1 = [df]
# cursor.execute("insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('huobi',"+str(df['high'])+","+str(df['low'])+","+str(df['last'])+","+str(df['timestamp'])+","+str(df['bid'])+","+str(df['ask'])+ ")")
# con.commit()
cursor = con.cursor()
cex = ccxt.cex()
df = cex.fetchTicker('BTC/USD')
df.pop('info')
df1 = [df]
cursor.execute(
"insert into exchanges(exchangeName,high,low,last,timestamp,bid,ask) values('cex',"
+ str(df['high']) + "," + str(df['low']) + "," + str(df['last']) +
"," + str(df['timestamp']) + "," + str(df['bid']) + "," +
str(df['ask']) + ")")
con.commit()
return "data inserted"
# The "maker" SELLS the base for the quote
# Code inputs:
N_pairs_with_tether = 10 # Number of pairs to print in exchanges possibly with tether
N_pairs_without_tether = 10 # Number of pairs to print in exchanges without tether
verbose = False # Do not print market fetching status
# Exchanges with tether (you can transfer USDT between exchanges)
bittrex = ccxt.bittrex() # 266 markets
binance = ccxt.binance()
poloniex = ccxt.poloniex() # 99 markets
kraken = ccxt.kraken() # 59 markets
# Exchanges without tether (cannot transfer USD between exchanges)
cex = ccxt.cex() # 27 markets
bitstamp = ccxt.bitstamp() # 15 markets
gdax = ccxt.gdax() # 10 markets
exchanges = [bittrex, kraken, poloniex, gdax, cex, bitstamp, binance]
# Load markets and check if exchanges are working
working_exchanges = []
for exchange in exchanges:
# Try loading the markets, if you can, add it to the working exchanges list
try:
exchange.load_markets()
working_exchanges.append(exchange)
# If you cannot, say so, and dont add it to the list
except:
print('%s is down! Excluding %s'%(exchange.name, exchange.name))
ccxt.anxpro(), ccxt.bibox(), ccxt.binance(), ccxt.bit2c(), ccxt.bitbank(), ccxt.bitbay(), ccxt.bitfinex(), ccxt.bitfinex2(), ccxt.bitflyer(), ccxt.bithumb(), ccxt.bitkk(), ccxt.bitlish(), ccxt.bitmarket(), ccxt.bitmex(), ccxt.bitso(), ccxt.bitstamp(), ccxt.bitstamp1(), ccxt.bittrex(), ccxt.bitz(), ccxt.bl3p(), ccxt.bleutrade(), ccxt.braziliex(), ccxt.btcbox(), ccxt.btcchina(), ccxt.btcexchange(), ccxt.btcmarkets(), ccxt.btctradeim(), ccxt.btctradeua(), ccxt.btcturk(), ccxt.btcx(), ccxt.bxinth(),
