def perform_algo_task():
balanceManager = BalanceManager()
coinsAboveThreshold = {}
coinsEligibleForIncrease = {}
em = ExchangeManager()
indexInfo = DatabaseManager.get_index_info_model()
try:
if indexInfo.Active == True:
percentage_btc_amount = indexInfo.TotalBTCVal*(indexInfo.BalanceThreshold/100)
logger.debug("Percentage_to_btc_amount: " + str(percentage_btc_amount))
if percentage_btc_amount <= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT:
logger.debug("Current BTC Threshold Value To Low - " + str(percentage_btc_amount))
else:
# Generate our winners/losers list
for indexedCoin in DatabaseManager.get_all_index_coin_models():
if indexedCoin.DistanceFromTarget >= indexInfo.BalanceThreshold:
coinsAboveThreshold[indexedCoin.Ticker] = indexedCoin.DistanceFromTarget
elif abs(indexedCoin.DistanceFromTarget) >= indexInfo.BalanceThreshold:
coinsEligibleForIncrease[indexedCoin.Ticker] = indexedCoin.DistanceFromTarget
# Sort our tables
coinsAboveThreshold = Util.tuple_list_to_dict(sorted(coinsAboveThreshold.items(), key=lambda pair: pair[1], reverse=True))
coinsEligibleForIncrease = Util.tuple_list_to_dict(sorted(coinsEligibleForIncrease.items(), key=lambda pair: pair[1], reverse=True))
balanceManager.rebalance_coins(coinsAboveThreshold, coinsEligibleForIncrease, percentage_btc_amount, app)
except Exception as e:
logger.exception(e)
def index_stop_command(self):
indexInfo = DatabaseManager.get_index_info_model()
DatabaseManager.update_index_info_model(False, indexInfo.TotalBTCVal,
indexInfo.TotalUSDVal,
indexInfo.BalanceThreshold,
indexInfo.OrderTimeout,
indexInfo.OrderRetryAmount,
indexInfo.RebalanceTickSetting)
logger.info("Index Management Stopped.")
def increment_rebalance_tick_task():
indexInfo = DatabaseManager.get_index_info_model()
if indexInfo.Active == True:
rebalanceTick = DatabaseManager.get_rebalance_tick_model()
if rebalanceTick.TickCount >= indexInfo.RebalanceTickSetting:
app.send_task('Tasks.perform_algo_task',args=[])
else:
DatabaseManager.update_rebalance_tick_model(rebalanceTick.TickCount + 1)
def index_add_coin(self, coin, percentage=1.0, locked=False):
lockCoin = False
totalLockedPercentage = 0.0
totalUnlockedPercentage = 0.0
totalUnlockedCoinsCount = 0
indexInfo = DatabaseManager.get_index_info_model()
indexedCoins = DatabaseManager.get_all_index_coin_models()
if locked == "true" or locked == "True":
lockCoin = True
for inCoins in indexedCoins:
if inCoins.Locked == True:
totalLockedPercentage = totalLockedPercentage + inCoins.DesiredPercentage
else:
totalUnlockedPercentage = totalUnlockedPercentage + inCoins.DesiredPercentage
totalUnlockedCoinsCount = totalUnlockedCoinsCount + 1
if totalUnlockedPercentage > float(percentage):
if self.coin_supported_check(coin.upper()):
percentageToRemove = float(
percentage) / totalUnlockedCoinsCount
for iCoin in indexedCoins:
if iCoin.Locked != True:
DatabaseManager.update_index_coin_model(
iCoin.Ticker,
iCoin.DesiredPercentage - percentageToRemove,
iCoin.DistanceFromTarget, iCoin.Locked)
if isinstance(float(percentage), (float, int, complex, int)):
if DatabaseManager.create_index_coin_model(
coin.upper(), float(percentage), 0.0, lockCoin):
logger.info("Coin " + coin.upper() + " added to index")
else:
# Already Exist
logger.warn("Coin already in index")
else:
logger.warn("Percentage isn't a number")
else:
logger.warn("Coin not supported")
else:
logger.warn("Not Enough Unlocked Percentage")
def index_rebalance_tick_update(self, tickcount):
indexInfo = DatabaseManager.get_index_info_model()
if isinstance(int(tickcount), (float, int, complex, int)):
DatabaseManager.update_index_info_model(True,
indexInfo.TotalBTCVal,
indexInfo.TotalUSDVal,
indexInfo.BalanceThreshold,
indexInfo.OrderTimeout,
indexInfo.OrderRetryAmount,
int(tickcount))
logger.info("Index rebalance time set to " + str(tickcount) +
" minutes.")
else:
logger.warn("Tick count isn't a number")
def show_threshold(self):
indexInfo = DatabaseManager.get_index_info_model()
sys.stdout.write("\nCurrent Rebalance Threshold\n")
summary_table_data = [[
"Active", "Balance Threshold", "Order Timeout",
"Rebalance Tick Setting"
]]
summary_table_data.append([
indexInfo.Active, indexInfo.BalanceThreshold,
indexInfo.OrderTimeout, indexInfo.RebalanceTickSetting
])
summary_table = AsciiTable(summary_table_data)
sys.stdout.write(summary_table.table)
sys.stdout.write("\n")
def index_start_command(self):
totalIndexPercentage = 0.0
indexInfo = DatabaseManager.get_index_info_model()
indexCoins = DatabaseManager.get_all_index_coin_models()
for coin in indexCoins:
totalIndexPercentage = totalIndexPercentage + coin.DesiredPercentage
if totalIndexPercentage == 100:
for iCoin in indexCoins:
if iCoin.Ticker != "BTC":
coinTicker = DatabaseManager.get_ticker_model(
iCoin.Ticker.upper() + "/BTC")
sys.stdout.write(coinTicker)
sys.stdout.write(iCoin.Ticker)
sys.stdout.write('\n')
percentage_btc_amount = (indexInfo.TotalBTCVal /
100) * iCoin.DesiredPercentage
amountToBuy = percentage_btc_amount / coinTicker.BTCVal
logger.debug("Percentage_to_btc_amount: " +
str(percentage_btc_amount))
if percentage_btc_amount <= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT:
logger.debug("Current BTC Threshold Value To Low - " +
str(percentage_btc_amount))
else:
#buy
app.send_task('Tasks.perform_buy_task',
args=[iCoin.Ticker.upper(), amountToBuy])
DatabaseManager.update_index_info_model(
True, indexInfo.TotalBTCVal, indexInfo.TotalUSDVal,
indexInfo.TotalRealizedGain, indexInfo.TotalUnrealizedGain,
indexInfo.BalanceThreshold, indexInfo.OrderTimeout,
indexInfo.OrderRetryAmount, indexInfo.RebalanceTickSetting)
else:
logger.warn("Index is currently unbalanced please rebuild")
def index_threshold_update(self, percentage):
if isinstance(float(percentage), (float, int, complex, int)):
indexInfo = DatabaseManager.get_index_info_model()
percentage_btc_amount = indexInfo.TotalBTCVal * (
float(percentage) / 100)
if percentage_btc_amount <= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT:
logger.error("Desired BTC Threshold Value Too Low - " +
str(percentage))
else:
DatabaseManager.update_index_info_model(
True, indexInfo.TotalBTCVal, indexInfo.TotalUSDVal,
round(float(percentage), 2), indexInfo.OrderTimeout,
indexInfo.OrderRetryAmount, indexInfo.RebalanceTickSetting)
logger.info("Index threshold set to " +
str(round(float(percentage), 2)))
else:
logger.warn("Percentage isn't a number")
def index_gen_command(self):
totalIndexPercentage = 0.0
indexInfo = DatabaseManager.get_index_info_model()
indexCoins = DatabaseManager.get_all_index_coin_models()
for iCoin in indexCoins:
if iCoin.Ticker != "BTC":
coinTicker = DatabaseManager.get_ticker_model(
iCoin.Ticker.upper() + "/BTC")
percentage_btc_amount = (indexInfo.TotalBTCVal /
100) * iCoin.DesiredPercentage
amountToBuy = percentage_btc_amount / coinTicker.BTCVal
logger.debug("Percentage_to_btc_amount: " +
str(percentage_btc_amount))
if percentage_btc_amount <= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT:
logger.debug("Current BTC Threshold Value To Low - " +
str(percentage_btc_amount))
else:
#buy
app.send_task('Tasks.perform_buy_task',
args=[iCoin.Ticker.upper(), amountToBuy])
DatabaseManager.update_index_info_model(True, indexInfo.TotalBTCVal,
indexInfo.TotalUSDVal,
indexInfo.BalanceThreshold,
indexInfo.OrderTimeout,
indexInfo.OrderRetryAmount,
indexInfo.RebalanceTickSetting)
def index_add_coin(self, coin, percentage, locked):
lockCoin = False
totalLockedPercentage = 0.0
totalUnlockedPercentage = 0.0
totalUnlockedCoinsCount = 0
indexInfo = DatabaseManager.get_index_info_model()
indexedCoins = DatabaseManager.get_all_index_coin_models()
if locked == "true" or locked == "True":
lockCoin = True
percentage_btc_amount = indexInfo.TotalBTCVal * (float(percentage) /
100)
if percentage_btc_amount >= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT:
for inCoins in indexedCoins:
if inCoins.Locked == True:
totalLockedPercentage = totalLockedPercentage + inCoins.DesiredPercentage
else:
totalUnlockedPercentage = totalUnlockedPercentage + inCoins.DesiredPercentage
totalUnlockedCoinsCount = totalUnlockedCoinsCount + 1
if totalUnlockedPercentage > float(percentage):
if self.coin_supported_check(coin.upper()):
percentageToRemove = float(
percentage) / totalUnlockedCoinsCount
for iCoin in indexedCoins:
if iCoin.Locked != True:
DatabaseManager.update_index_coin_model(
iCoin.Ticker,
iCoin.DesiredPercentage - percentageToRemove,
iCoin.CurrentPercentage, iCoin.UnrealizedGain,
iCoin.Locked)
if isinstance(float(percentage),
(float, int, complex, long)):
if DatabaseManager.create_index_coin_model(
coin.upper(), float(percentage), 0.0, 0.0,
lockCoin):
DatabaseManager.create_realized_gain_model(
coin.upper(), 0.0)
logger.info("Coin " + coin.upper() +
" added to index")
else:
# Already Exist
logger.warn("Coin already in index")
else:
logger.warn("Percentage isn't a number")
else:
logger.warn("Coin not supported")
else:
logger.warn("Not Enough Unlocked Percentage")
else:
logger.warn(
"Specified percentage below current bittrex trade value")
def calculate_amount(self, coin, is_over):
"""Figure out how much to buy/sell.
Method should look up current value of each coin as trades fired previously could modify the balance.
Includes minimum trade check.
Returns None if amount doesn't meet trade threshold.
"""
index_info = DatabaseManager.get_index_info_model()
coin_balance = DatabaseManager.get_coin_balance_model(coin)
indexed_coin = DatabaseManager.get_index_coin_model(coin)
amount = None
off = indexed_coin.get_percent_from_coin_target(
coin_balance, index_info.TotalBTCVal)
logger.info(
"coin off percentage is %s with current coin balance of %s", off,
coin_balance.BTCBalance)
if coin_balance.BTCBalance > 0:
if is_over is True:
logger.info(
"Coin %s over threshold, calculating off percentage", coin)
if off > 100:
amount = round(coin_balance.BTCBalance * (1 / (off / 100)),
8)
else:
amount = round(coin_balance.BTCBalance * off / 100, 8)
else:
logger.info(
"Coin %s under threshold, calculating off percentage",
coin)
amount = round(
(coin_balance.BTCBalance /
(1 - (abs(off) / 100))) - coin_balance.BTCBalance, 8)
logger.info("Amount calculated as %s", amount)
if amount == None or amount == 0:
logger.info(
"Zero amount detected for %s. Attemping to buy 2x the minimum order.",
coin)
pair_string = coin
if pair_string == "BTC":
pair_string += "/USDT"
else:
pair_string += "/BTC"
min_buy = self.em.get_min_buy_btc(pair_string)
if min_buy is not None:
amount = round(min_buy * 2, 8)
else:
logger.info(
"Zero amount of coin %s and market info cannot be found")
amount = None
if amount is not None:
logger.info(
"checking to see if amount %s is greater than trade threshold %s",
amount, CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT)
over_threshold = float(amount) >= float(
CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT)
if over_threshold is True:
if is_over is False:
logger.info("checking to see if %s is available in BTC",
amount)
balance_available = 0.0
btc_balance = DatabaseManager.get_coin_balance_model("BTC")
btc_indexed_coin = DatabaseManager.get_index_coin_model(
"BTC")
btc_off = btc_indexed_coin.get_percent_from_coin_target(
btc_balance, index_info.TotalBTCVal)
if btc_off <= 0:
return None
balance_available = round(
btc_balance.BTCBalance * (btc_off / 100), 8)
logger.info("Available BTC balance %s", balance_available)
if balance_available >= amount:
return amount
#See if 1x the threshold is available
single_threshold_amount = round(
amount / (index_info.BalanceThreshold / 100), 8)
if not single_threshold_amount >= em.get_min_buy_btc(
pair_string):
single_threshold_amount = em.get_min_buy_btc(
pair_string) * 2
if balance_available >= single_threshold_amount and float(
single_threshold_amount) >= float(
CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT):
return single_threshold_amount
else:
amount = None
logger.warning(
"The amount to trade %s not available currently",
amount)
else:
logger.info("selling %s %s to BTC/USDT", amount, coin)
else:
logger.warning("Coin %s amount %s not over trade threshold",
coin, amount)
amount = None
return amount
def index_update_coin(self, coin, percentage, locked):
lockCoin = False
totalLockedPercentage = 0.0
totalUnlockedPercentage = 0.0
totalUnlockedCoinsCount = 0
indexInfo = DatabaseManager.get_index_info_model()
indexedCoins = DatabaseManager.get_all_index_coin_models()
indexedCoin = DatabaseManager.get_index_coin_model(coin.upper())
for inCoins in indexedCoins:
if inCoins.Ticker != coin.upper():
if inCoins.Locked == True:
totalLockedPercentage = totalLockedPercentage + inCoins.DesiredPercentage
else:
totalUnlockedPercentage = totalUnlockedPercentage + inCoins.DesiredPercentage
totalUnlockedCoinsCount = totalUnlockedCoinsCount + 1
if len(indexedCoins) > 1:
if totalUnlockedCoinsCount > 0:
if locked == "true" or locked == "True":
lockCoin = True
percentage_btc_amount = indexInfo.TotalBTCVal * (
float(percentage) / 100)
if percentage_btc_amount >= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT:
if float(percentage) > indexedCoin.DesiredPercentage:
if totalUnlockedPercentage > float(percentage):
if self.coin_supported_check(coin.upper()):
percentageToAdd = 0.0
if totalUnlockedCoinsCount > 0:
percentageToAdd = float(
indexedCoin.DesiredPercentage -
float(percentage)
) / totalUnlockedCoinsCount
else:
percentageToAdd = float(
indexedCoin.DesiredPercentage -
float(percentage))
for iCoin in indexedCoins:
if iCoin.Ticker != coin.upper():
if iCoin.Locked != True:
DatabaseManager.update_index_coin_model(
iCoin.Ticker,
iCoin.DesiredPercentage -
percentageToAdd,
iCoin.DistanceFromTarget,
iCoin.Locked)
if isinstance(float(percentage),
(float, int, complex, long)):
if DatabaseManager.update_index_coin_model(
coin.upper(), float(percentage),
0.0, lockCoin):
logger.info("Coin " + coin.upper() +
" updated in index")
else:
# Already Exist
logger.warn("Coin already in index")
else:
logger.warn("Percentage isn't a number")
else:
logger.warn("Coin not supported")
else:
logger.warn("Not Enough Unlocked Percentage")
else:
## NEW BLOCK
if self.coin_supported_check(coin.upper()):
percentageToAdd = 0.0
if totalUnlockedCoinsCount > 0:
percentageToAdd = float(
indexedCoin.DesiredPercentage - float(
percentage)) / totalUnlockedCoinsCount
else:
percentageToAdd = float(
indexedCoin.DesiredPercentage -
float(percentage))
for iCoin in indexedCoins:
if iCoin.Ticker != coin.upper():
if iCoin.Locked != True:
DatabaseManager.update_index_coin_model(
iCoin.Ticker,
iCoin.DesiredPercentage +
percentageToAdd,
iCoin.DistanceFromTarget,
iCoin.Locked)
if isinstance(float(percentage),
(float, int, complex, int)):
if DatabaseManager.update_index_coin_model(
coin.upper(), float(percentage), 0.0,
lockCoin):
logger.info("Coin " + coin.upper() +
" updated in index")
else:
# Already Exist
logger.warn("Coin already in index")
else:
logger.warn("Percentage isn't a number")
else:
logger.warn("Coin not supported")
else:
logger.warn(
"Specified percentage below current bittrex trade value"
)
else:
logger.warn(
"Currently no unlocked coins to transfer free value")
else:
logger.warn(
"Please add another coin to your index before updating a given coin"
)
def perform_sell_task(rebalanceTicker, rebalanceSellAmount):
coinSellIncomplete = True
coinSellRetryCount = 0
sellOrderUUID = ""
indexInfo = DatabaseManager.get_index_info_model()
retryLimit = indexInfo.OrderRetryAmount
eligibleCoinTicker = DatabaseManager.get_ticker_model(rebalanceTicker +
"/BTC")
em = ExchangeManager()
try:
partial_fill_amount = 0
partial_filled = False
DatabaseManager.create_coin_lock_model(rebalanceTicker)
while coinSellIncomplete:
if coinSellRetryCount >= retryLimit:
coinSellFailed = True
coinSellIncomplete = False
break
# Cancel Order
else:
rebalanceCoinTicker = DatabaseManager.get_ticker_model(
rebalanceTicker + "/BTC")
if CondexConfig.DEBUG == True:
logger.info("Placing Sell Order For " + rebalanceTicker +
"/BTC")
else:
logger.info("Selling " + str(rebalanceSellAmount) +
" of " + rebalanceTicker + " at " +
str(rebalanceCoinTicker.BTCVal))
sellOrderUUID = em.create_sell_order(
rebalanceTicker, rebalanceSellAmount,
rebalanceCoinTicker.BTCVal)['id']
time.sleep(60 * indexInfo.OrderTimeout)
# Check order succeded through
if CondexConfig.DEBUG == True:
logger.debug("Fetching order")
coinSellIncomplete = False
else:
order_result = em.fetch_order(sellOrderUUID)
order_filled_amount = order_result['filled']
if order_result['status'] == "closed":
logger.debug("Sold coin " + rebalanceTicker + " for " +
str(order_result['price']))
coinSellIncomplete = False
elif (
order_filled_amount * rebalanceCoinTicker.BTCVal
) > CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT and order_result[
'status'] == "open":
em.cancel_order(sellOrderUUID)
logger.debug("Sold partial of coin " +
rebalanceTicker + " for " +
str(order_result['price']))
coinSellIncomplete = False
partial_filled = True
partial_fill_amount = order_filled_amount * rebalanceCoinTicker.BTCVal
else:
coinSellRetryCount = coinSellRetryCount + 1
if CondexConfig.DEBUG == True:
logger.debug("Canceling sell order")
else:
em.cancel_order(sellOrderUUID)
logger.debug("Sell Order Timeout Reached")
time.sleep(10) #Magic Number
except Exception as e:
logger.exception(e)
finally:
if CondexConfig.DEBUG != True:
DatabaseManager.delete_coin_lock_model(rebalanceTicker)
def perform_algo_task():
coinsAboveThreshold = {}
coinsElgibleForIncrease = {}
indexInfo = DatabaseManager.get_index_info_model()
if indexInfo.Active == True:
percentage_btc_amount = indexInfo.TotalBTCVal * (
indexInfo.BalanceThreshold / 100)
logger.debug("Percentage_to_btc_amount: " + str(percentage_btc_amount))
if percentage_btc_amount <= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT:
logger.debug("Current BTC Threshold Value To Low - " +
str(percentage_btc_amount))
else:
# Generate our winners/lossers list
for indexedCoin in DatabaseManager.get_all_index_coin_models():
if indexedCoin.UnrealizedGain >= indexInfo.BalanceThreshold:
coinsAboveThreshold[
indexedCoin.Ticker] = indexedCoin.UnrealizedGain
elif indexedCoin.UnrealizedGain <= indexInfo.BalanceThreshold:
coinsElgibleForIncrease[
indexedCoin.Ticker] = indexedCoin.UnrealizedGain
# Sort our tables
coinsAboveThreshold = Util.tuple_list_to_dict(
sorted(coinsAboveThreshold.iteritems(),
key=lambda (k, v): (v, k),
reverse=True))
coinsElgibleForIncrease = Util.tuple_list_to_dict(
sorted(coinsElgibleForIncrease.iteritems(),
key=lambda (k, v): (v, k),
reverse=True))
if len(coinsAboveThreshold) >= 1:
logger.debug("Currently " + str(len(coinsAboveThreshold)) +
" avalible for rebalance")
logger.debug(coinsAboveThreshold)
if len(coinsElgibleForIncrease) >= 1:
logger.debug("Currently " +
str(len(coinsElgibleForIncrease)) +
" elgible for increase")
logger.debug(coinsElgibleForIncrease)
for akey in coinsAboveThreshold:
# Check to see if we still have coins to increase
if len(coinsElgibleForIncrease) >= 1:
elgibleCoinTicker = coinsElgibleForIncrease.keys(
)[0]
rebalanceCoinLocked = False
elgibleCoinLocked = False
if DatabaseManager.get_coin_lock_model(akey):
rebalanceCoinLocked = True
if DatabaseManager.get_coin_lock_model(
elgibleCoinTicker):
rebalanceCoinLocked = True
if rebalanceCoinLocked == False and elgibleCoinLocked == False:
indexCoinInfo = DatabaseManager.get_index_coin_model(
akey)
coinBalance = DatabaseManager.get_coin_balance_model(
akey)
rebalanceSpecialTicker = akey + "/BTC"
if akey == "BTC":
rebalanceSpecialTicker = "BTC/USDT"
rebalanceCoinTickerModel = DatabaseManager.get_ticker_model(
rebalanceSpecialTicker)
elgibleCoinTickerModel = DatabaseManager.get_ticker_model(
elgibleCoinTicker + "/BTC")
amountOfRebalanceToSell = 0.0
if akey == "BTC":
amountOfRebalanceToSell = percentage_btc_amount
else:
amountOfRebalanceToSell = percentage_btc_amount / rebalanceCoinTickerModel.BTCVal
amountOfEligbleToBuy = percentage_btc_amount / elgibleCoinTickerModel.BTCVal
if coinBalance.TotalCoins >= amountOfRebalanceToSell:
DatabaseManager.create_coin_lock_model(
akey)
DatabaseManager.create_coin_lock_model(
elgibleCoinTicker)
logger.info("Performing Rebalance " +
akey.upper() + " " +
str(amountOfRebalanceToSell) +
" - " +
elgibleCoinTicker.upper() +
" " +
str(amountOfEligbleToBuy))
#perform_rebalance_task.s(akey.upper(), amountOfRebalanceToSell, elgibleCoinTicker.upper(), amountOfEligbleToBuy)
app.send_task(
'Tasks.perform_rebalance_task',
args=[
akey.upper(),
amountOfRebalanceToSell,
elgibleCoinTicker.upper(),
amountOfEligbleToBuy
])
# Need to remove the eligbile coin from dictireonary
del coinsElgibleForIncrease[
elgibleCoinTicker]
else:
logger.error(
"Failed to sell coins - we do not have enough of "
+ str(akey))
else:
logger.debug("One of the coins where locked")
else:
logger.debug("No coins eligible for increase")
else:
logger.debug("No coins above threshold")
def perform_rebalance_task(rebalanceTicker, rebalanceSellAmount, elgibleTicker,
elgibleBuyAmount):
coinSellIncomplete = True
coinBuyIncomplete = True
coinSellRetryCount = 0
coinBuyRetryCount = 0
coinSellFailed = False
sellOrderUUID = ""
buyOrderUUID = ""
indexInfo = DatabaseManager.get_index_info_model()
retryLimit = indexInfo.OrderRetryAmount
rebalanceTickerGainModel = DatabaseManager.get_realized_gain_model(
rebalanceTicker)
elgibleCoinTicker = DatabaseManager.get_ticker_model(elgibleTicker +
"/BTC")
em = ExchangeManager()
partial_fill_amount = 0
partial_filled = False
if rebalanceTicker != "BTC" and rebalanceTicker != "btc":
while coinSellIncomplete:
if coinSellRetryCount >= retryLimit:
coinSellFailed = True
coinSellIncomplete = False
break
# Cancel Order
else:
rebalanceCoinTicker = DatabaseManager.get_ticker_model(
rebalanceTicker + "/BTC")
if CondexConfig.DEBUG == True:
logger.info("Placing Sell Order For " + rebalanceTicker +
"/BTC")
else:
logger.info("Selling " + str(rebalanceSellAmount) +
" of " + rebalanceTicker + " at " +
str(rebalanceCoinTicker.BTCVal))
sellOrderUUID = em.create_sell_order(
rebalanceTicker, rebalanceSellAmount,
rebalanceCoinTicker.BTCVal)['id']
time.sleep(60 * indexInfo.OrderTimeout)
# Check order succeded through
if CondexConfig.DEBUG == True:
logger.debug("Fetching order")
coinSellIncomplete = False
else:
order_result = em.fetch_order(sellOrderUUID)
order_filled_amount = order_result['filled']
if order_result['status'] == "closed":
logger.debug("Sold coin " + rebalanceTicker + " for " +
str(order_result['price']))
coinSellIncomplete = False
DatabaseManager.update_realized_gain_model(
rebalanceTicker,
rebalanceTickerGainModel.RealizedGain +
((order_filled_amount * rebalanceCoinTicker.BTCVal)
/ indexInfo.TotalBTCVal) * 100)
elif (
order_filled_amount * rebalanceCoinTicker.BTCVal
) > CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT and order_result[
'status'] == "open":
em.cancel_order(sellOrderUUID)
logger.debug("Sold partial of coin " +
rebalanceTicker + " for " +
str(order_result['price']))
coinSellIncomplete = False
partial_filled = True
partial_fill_amount = order_filled_amount * rebalanceCoinTicker.BTCVal
DatabaseManager.update_realized_gain_model(
rebalanceTicker,
rebalanceTickerGainModel.RealizedGain +
((order_filled_amount * rebalanceCoinTicker.BTCVal)
/ indexInfo.TotalBTCVal) * 100)
else:
coinSellRetryCount = coinSellRetryCount + 1
if CondexConfig.DEBUG == True:
logger.debug("Canceling sell order")
else:
em.cancel_order(sellOrderUUID)
logger.debug("Sell Order Timeout Reached")
time.sleep(10) #Magic Number
if coinSellFailed:
logger.info("Sell of coin " + rebalanceTicker + " failed after " +
str(coinSellRetryCount) + " attempts")
else:
while coinBuyIncomplete:
if coinBuyRetryCount >= retryLimit:
coinBuyIncomplete = False
logger.info("Buying of coin " + rebalanceTicker +
" failed after " + str(coinBuyRetryCount) +
" attempts")
break
# Cancel Order
else:
if CondexConfig.DEBUG == True:
logger.debug("Putting in buy order")
else:
logger.info("Buying " + str(elgibleBuyAmount) + " of " +
elgibleTicker + " at " +
str(elgibleCoinTicker.BTCVal))
if partial_filled == True:
buyOrderUUID = em.create_buy_order(
elgibleTicker,
partial_fill_amount / elgibleCoinTicker.BTCVal,
elgibleCoinTicker.BTCVal)['id']
else:
buyOrderUUID = em.create_buy_order(
elgibleTicker, elgibleBuyAmount,
elgibleCoinTicker.BTCVal)['id']
time.sleep(60 * indexInfo.OrderTimeout)
# Check order succeded through
if CondexConfig.DEBUG == True:
logger.debug("Fetching order")
coinBuyIncomplete = False
else:
order_result = em.fetch_order(buyOrderUUID)
order_filled_amount = order_result['filled']
if order_result['status'] == "closed":
logger.info("Bought coin " + elgibleTicker + " for " +
str(order_result['price']))
coinBuyIncomplete = False
if rebalanceTicker == "BTC" or rebalanceTicker == "btc":
DatabaseManager.update_realized_gain_model(
rebalanceTicker,
rebalanceTickerGainModel.RealizedGain +
((order_filled_amount *
elgibleCoinTicker.BTCVal) /
indexInfo.TotalBTCVal) * 100)
elif (
order_filled_amount * elgibleCoinTicker.BTCVal
) > CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT and order_result[
'status'] == "open":
em.cancel_order(buyOrderUUID)
logger.debug("Bought partial of coin " +
elgibleCoinTicker + " for " +
str(order_result['price']))
coinBuyIncomplete = False
if rebalanceTicker == "BTC" or rebalanceTicker == "btc":
DatabaseManager.update_realized_gain_model(
rebalanceTicker,
rebalanceTickerGainModel.RealizedGain +
((order_filled_amount *
elgibleCoinTicker.BTCVal) /
indexInfo.TotalBTCVal) * 100)
else:
coinBuyRetryCount = coinBuyRetryCount + 1
if CondexConfig.DEBUG == True:
logger.debug("Canceling buy order")
else:
try:
em.cancel_order(buyOrderUUID)
except:
coinBuyIncomplete = False
pass # order failed to cancel got filled previously
logger.debug("Buy Order Timeout Reached")
time.sleep(10) #Magic Number
# Delete the locks
if CondexConfig.DEBUG != True:
DatabaseManager.delete_coin_lock_model(rebalanceTicker)
DatabaseManager.delete_coin_lock_model(elgibleTicker)
def wallet_update_task():
em = ExchangeManager()
walletData = em.get_balance()
btcUsdValue = em.get_btc_usd_value()
totalBtcValue = 0.0
logger.info("Starting Wallet Update Task")
logger.debug("Checking Wallet Locks")
walletLockDeleteList = []
# Clear up the wallet locks.
for walletLockModel in DatabaseManager.get_all_wallet_trade_lock_models():
if DatabaseManager.get_coin_lock_model(walletLockModel.Ticker) == None:
walletLockDeleteList.append(walletLockModel.Ticker)
for walletLockTicker in walletLockDeleteList:
DatabaseManager.delete_wallet_trade_lock_model(walletLockTicker)
for key in DatabaseManager.get_all_supported_coin_models():
btcbalance = 0.0
usdBalance = 0.0
totalCoins = None
tickerModel = get_ticker(key)
try:
btcbalance = walletData[key.Ticker]['total'] * tickerModel.BTCVal
totalCoins = walletData[key.Ticker]['total']
usdBalance = btcUsdValue * btcbalance
except:
btcbalance = 0.0
totalCoins = 0.0
if key.Ticker == 'BTC':
btcbalance = walletData[key.Ticker]['total']
usdBalance = btcUsdValue * btcbalance
indexedCoin = DatabaseManager.get_index_coin_model(key.Ticker)
if indexedCoin is not None:
totalBtcValue = totalBtcValue + btcbalance
if DatabaseManager.create_coin_balance_model(key.Ticker, btcbalance,
usdBalance, totalCoins,
datetime.datetime.now()):
#logger.debug("Created Coin Balance Model - " + key.Ticker)
pass
else:
if DatabaseManager.update_coin_balance_model(
key.Ticker, btcbalance, btcUsdValue * btcbalance,
totalCoins, datetime.datetime.now()):
#logger.debug("Updated Coin Balance Model - " + key.Ticker)
pass
else:
logger.error("Failed Update Coin Balance Model - " +
key.Ticker)
totalUnrealizedGain = 0.0
totalRealizedGain = 0.0
for key in DatabaseManager.get_all_supported_coin_models():
tickerModel = get_ticker(key)
coinBalance = DatabaseManager.get_coin_balance_model(key.Ticker)
indexedCoin = DatabaseManager.get_index_coin_model(key.Ticker)
if indexedCoin is not None:
if DatabaseManager.update_index_coin_model(
indexedCoin.Ticker, indexedCoin.DesiredPercentage,
indexedCoin.get_distance_from_target(
coinBalance, totalBtcValue), indexedCoin.Locked):
logger.debug("Updated Indexed Coin Model - " +
indexedCoin.Ticker)
else:
logger.error("Failed To Update Indexed Coin Model - " +
indexedCoin.Ticker)
indexInfo = DatabaseManager.get_index_info_model()
if DatabaseManager.update_index_info_model(indexInfo.Active, totalBtcValue,
btcUsdValue * totalBtcValue,
indexInfo.BalanceThreshold,
indexInfo.OrderTimeout,
indexInfo.OrderRetryAmount,
indexInfo.RebalanceTickSetting):
logger.debug("Updated Index Info Model")
else:
logger.error("Failed To Update Index Info Model")
logger.info("Wallet Update Task Completed")
def wallet_update_task():
em = ExchangeManager()
walletData = em.get_balance()
btcUsdValue = em.get_btc_usd_value()
totalBtcValue = 0.0
logger.info("Starting Wallet Update Task")
for key in DatabaseManager.get_all_supported_coin_models():
btcbalance = 0.0
usdBalance = 0.0
totalCoins = None
fullTicker = key.Ticker + "/BTC"
if key.Ticker == 'BTC':
fullTicker = 'BTC/USDT'
tickerModel = DatabaseManager.get_ticker_model(fullTicker)
try:
btcbalance = walletData[key.Ticker]['total'] * tickerModel.BTCVal
totalCoins = walletData[key.Ticker]['total']
usdBalance = btcUsdValue * btcbalance
except:
btcbalance = 0.0
totalCoins = 0.0
if key.Ticker == 'BTC':
btcbalance = walletData[key.Ticker]['total']
usdBalance = btcUsdValue * btcbalance
indexedCoin = DatabaseManager.get_index_coin_model(key.Ticker)
if indexedCoin is not None:
totalBtcValue = totalBtcValue + btcbalance
if DatabaseManager.create_coin_balance_model(key.Ticker, btcbalance,
usdBalance, totalCoins,
datetime.datetime.now()):
#logger.debug("Created Coin Balance Model - " + key.Ticker)
pass
else:
if DatabaseManager.update_coin_balance_model(
key.Ticker, btcbalance, btcUsdValue * btcbalance,
totalCoins, datetime.datetime.now()):
#logger.debug("Updated Coin Balance Model - " + key.Ticker)
pass
else:
logger.error("Failed Update Coin Balance Model - " +
key.Ticker)
totalUnrealizeGain = 0.0
totalRealizedGain = 0.0
for key in DatabaseManager.get_all_supported_coin_models():
coinBalance = DatabaseManager.get_coin_balance_model(key.Ticker)
indexedCoin = DatabaseManager.get_index_coin_model(key.Ticker)
realizedGainModel = DatabaseManager.get_realized_gain_model(key.Ticker)
if indexedCoin is not None:
if DatabaseManager.update_index_coin_model(
indexedCoin.Ticker, indexedCoin.DesiredPercentage,
(coinBalance.BTCBalance / totalBtcValue) * 100,
((coinBalance.BTCBalance / totalBtcValue) * 100) -
indexedCoin.DesiredPercentage, indexedCoin.Locked):
totalUnrealizeGain = totalUnrealizeGain + (
((coinBalance.BTCBalance / totalBtcValue) * 100) -
indexedCoin.DesiredPercentage)
totalRealizedGain = totalRealizedGain + realizedGainModel.RealizedGain
logger.debug("Total unrealized gain - " +
str(totalUnrealizeGain))
logger.debug("Updated Indexed Coin Model - " +
indexedCoin.Ticker)
else:
logger.error("Failed To Update Indexed Coin Model - " +
indexedCoin.Ticker)
indexInfo = DatabaseManager.get_index_info_model()
totalUnrealizeGain = totalUnrealizeGain
if DatabaseManager.update_index_info_model(
indexInfo.Active, totalBtcValue, btcUsdValue * totalBtcValue,
totalRealizedGain, totalUnrealizeGain, indexInfo.BalanceThreshold,
indexInfo.OrderTimeout, indexInfo.OrderRetryAmount,
indexInfo.RebalanceTickSetting):
logger.debug("Updated Index Info Model")
else:
logger.error("Failed To Update Index Info Model")
logger.info("Wallet Update Task Completed")
def perform_buy_task(elgibleTicker, elgibleBuyAmount):
coinBuyIncomplete = True
coinBuyRetryCount = 0
buyOrderUUID = ""
indexInfo = DatabaseManager.get_index_info_model()
retryLimit = indexInfo.OrderRetryAmount
elgibleCoinTicker = DatabaseManager.get_ticker_model(elgibleTicker +
"/BTC")
em = ExchangeManager()
partial_fill_amount = 0
partial_filled = False
DatabaseManager.create_coin_lock_model(elgibleTicker)
while coinBuyIncomplete:
if coinBuyRetryCount >= retryLimit:
coinBuyIncomplete = False
logger.info("Buying of coin " + rebalanceTicker +
" failed after " + str(coinBuyRetryCount) +
" attempts")
break
# Cancel Order
else:
if CondexConfig.DEBUG == True:
logger.debug("Putting in buy order")
else:
logger.info("Buying " + str(elgibleBuyAmount) + " of " +
elgibleTicker + " at " +
str(elgibleCoinTicker.BTCVal))
buyOrderUUID = em.create_buy_order(
elgibleTicker, elgibleBuyAmount,
elgibleCoinTicker.BTCVal)['id']
time.sleep(60 * indexInfo.OrderTimeout)
# Check order succeded through
if CondexConfig.DEBUG == True:
logger.debug("Fetching order")
coinBuyIncomplete = False
else:
order_result = em.fetch_order(buyOrderUUID)
order_filled_amount = order_result['filled']
if order_result['status'] == "closed":
logger.info("Bought coin " + elgibleTicker + " for " +
str(order_result['price']))
coinBuyIncomplete = False
elif (
order_filled_amount * elgibleCoinTicker.BTCVal
) > CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT and order_result[
'status'] == "open":
em.cancel_order(buyOrderUUID)
logger.debug("Bought partial of coin " +
elgibleCoinTicker + " for " +
str(order_result['price']))
coinBuyIncomplete = False
else:
coinBuyRetryCount = coinBuyRetryCount + 1
if CondexConfig.DEBUG == True:
logger.debug("Canceling buy order")
else:
try:
em.cancel_order(buyOrderUUID)
except:
coinBuyIncomplete = False
pass # order failed to cancel got filled previously
logger.debug("Buy Order Timeout Reached")
time.sleep(10) #Magic Number
# Delete the locks
if CondexConfig.DEBUG != True:
DatabaseManager.delete_coin_lock_model(elgibleTicker)