Minor updates

Author: 0x78f1935

backend/config/__init__.py

@@ -11,7 +11,7 @@ class Config(System):
     """
     def __init__(self) -> None:
         self.DEBUG = False
-        self.VERSION = "1.0.2"
+        self.VERSION = "1.1.0"
         self.PROJECT_NAME = "PyNance - Webinterface"
 
         # Load system configuration

backend/models/system.py

@@ -23,8 +23,14 @@ class SystemModel(db.Model):
         Indicates the second currency of the symbol
     take_profit: string
         The proft taken from the trading
+    total_entry: string
+        The total amount of % used in the selected wallet to buy with
     online: boolean
         indicates if the bot is trading
+    buying: boolean
+        indicates if the bot is buying or not
+    panik: boolean
+        indicates if the bot is in panik mode
     """
 
     __tablename__ = "system"
@@ -35,11 +41,14 @@ class SystemModel(db.Model):
     currency_2 = db.Column(db.Text, default="USDT")
 
     take_profit = db.Column(db.Text, default="20")
+    total_entry = db.Column(db.Text, default="100")
     only_dip = db.Column(db.Boolean, default=True)
     online = db.Column(db.Boolean, default=False, onupdate=False)
-
+    buying = db.Column(db.Boolean, default=True)
     panik = db.Column(db.Boolean, default=False)
 
+    current_value = db.Column(db.Text, default="0")
+
     def update_data(self, data: dict):
         """"Just throw in a json object, each key that can be mapped will be updated"
 

backend/views/api/configure.py

@@ -13,18 +13,14 @@ class ConfigureApiView(FlaskView):
 
     decorators = [ ]
 
-    @route('/take_profit', methods=['GET'])
+    @route('/take_profit', methods=['POST', 'GET'])
     def take_profit(self):
         model = SystemModel.query.first()
-        return jsonify({'take_profit': int(model.take_profit)}), 200
-
-    @route('/take_profit', methods=['POST'])
-    def set_take_profit(self):
-        model = SystemModel.query.first()
-        if model.take_profit != str(request.json['tp']):
-            model.take_profit = str(request.json['tp'])
-            db.session.add(model)
-            db.session.commit()
+        if request.method == 'POST':
+            if model.take_profit != str(request.json['tp']):
+                model.take_profit = str(request.json['tp'])
+                db.session.add(model)
+                db.session.commit()
         return jsonify({'take_profit': int(model.take_profit)}), 200
 
     @route('/online', methods=['GET'])
@@ -64,8 +60,23 @@ def panik(self):
         else:
             return jsonify({'panik': model.panik}), 200
 
-    @route('/only_dip', methods=['POST'])
+    @route('/only_dip', methods=['POST', 'GET'])
     def only_dip(self):
         model = SystemModel.query.first()
-        model.update_data({'only_dip': not request.json['dip']})
+        if request.method == 'POST':
+            online = model.online # Prevents model to set itself to false
+            model.update_data({'only_dip': not request.json['dip']})
+            model.online = online
+            db.session.add(model)
+            db.session.commit()
         return jsonify({'dip': model.only_dip}), 200
+
+    @route('/total_entry', methods=['POST', 'GET'])
+    def set_take_profit(self):
+        model = SystemModel.query.first()
+        if request.method == 'POST':
+            if model.total_entry != str(request.json['total_entry']):
+                model.total_entry = str(request.json['total_entry'])
+                db.session.add(model)
+                db.session.commit()
+        return jsonify({'total_entry': int(model.total_entry)}), 200

backend/views/api/orders.py

@@ -20,6 +20,8 @@ def get(self):
         for item in data:
             order_item = {}
             order_item["Symbol"] = item["symbol"]
+            order_item["Created"] = item["created"]
+            order_item["Updated"] = item["updated"]
             order_item["Active"] = str(bool(item["current"])).capitalize() if str(model.currency_1 + model.currency_2) in order_item["Symbol"] else "False"
             order_item["quantity"] = float(item["quantity"])
             order_item["paid_total"] = float(item["brought_price"]) * order_item["quantity"]

backend/views/api/system.py

@@ -19,6 +19,14 @@ class SystemApiView(FlaskView):
 
     def get_x_percentage_of_y(self, x, y): return float(y / 100) * x
 
+    def update_system_without_going_offline(self, system, data):
+        online = system.online
+        system.update_data(data)
+        system.online = online
+        db.session.add(system)
+        db.session.commit()
+        return system
+
     def get(self):
         now = datetime.now()
 
@@ -46,9 +54,6 @@ def get(self):
         try:
             price_average = float(pynance.price.average(cur1+cur2).json["price"])
         except AttributeError:
-            # system.online = False
-            # db.session.add(system)
-            # db.session.commit()
             chatterer.chat("UNKNOWN SYMBOL")
             return jsonify({
                 "date": str(datetime.now().strftime('%d-%m-%y %H:%M:%S')),
@@ -57,17 +62,16 @@ def get(self):
                 "msg": chatterer.msg
             }), 200
 
-        if model is None: brought_price = price_average
-        else: brought_price = float(model.brought_price)
-
-        take_profit = float(system.take_profit)  # The percentage to take as profit, cannot be higher then 99
+        # The work price is or the average price, or the price which we brought for
+        if model is None: work_price = price_average
+        else:  work_price = float(model.brought_price)
+        # The percentage to take as profit, cannot be higher then 99
+        take_profit = float(system.take_profit)
 
         try:
+            # Check if we can get the fees, which also allows us to check if Binance is available
             fees = pynance.price.fees(cur1+cur2).json['tradeFee'].pop(0)
         except AttributeError:
-            # system.online = False
-            # db.session.add(system)
-            # db.session.commit()
             chatterer.chat("BINANCE SERVICES ARE UNAVAILABLE AT THIS TIME")
             return jsonify({
                 "date": str(datetime.now().strftime('%d-%m-%y %H:%M:%S')),
@@ -76,99 +80,118 @@ def get(self):
                 "msg": chatterer.msg
             }), 200
 
-        fee_maker = 1 + fees['maker'] * 100 # Maker -> Buys crypto
-        fee_taker = 1 + fees['taker'] * 100 # Taker -> Sells crypto
+        # Get the fees from the response
+        fee_maker = fees['maker'] # Maker -> Buys crypto
+        fee_taker = fees['taker'] # Taker -> Sells crypto
         symbol = fees['symbol']
 
+        # Get information about the selected symbol
         exchange_info = pynance.exchange_info(symbol)
         stepSize = [ i for i in exchange_info['filters'] if i['filterType'] == 'LOT_SIZE'].pop(0)['stepSize']
         precision = int(round(-math.log(float(stepSize), 10), 0))
 
-        balance = pynance.wallet.balance(cur1)
-        balance2 = pynance.wallet.balance(cur2)
-
-        balance_free = float(balance['free'])        # BTC
-        balance_locked = float(balance['locked'])
-        balance2_free = float(balance2['free'])      # USDT
-        balance2_locked = float(balance2['locked'])
-        current_price = float(pynance.price.asset(cur1+cur2).json['price'])
-
-        # Price of the fees we paid
-        paid_fees = float(brought_price * balance_free) *  float(fee_taker/100)
-        # Price including fees we have paid
-        paid_total = float(brought_price * balance_free) + paid_fees
-
-        # Price of the fees if we wouldve brought
-        wouldve_paid_fees = float(current_price * balance_free) *  float(fee_taker/100)
-        # Total price including fees if we brought
-        wouldve_paid = float(current_price * balance_free) + wouldve_paid_fees
-
-        if model is not None: 
-            chatterer.update_price(f"{float(round(float(current_price) * float(model.quantity), 6))} - { float(round(current_price, 6)) } - { model.quantity }")
-        else: chatterer.update_price(f"0.0 - { float(round(current_price, 6)) } - 0")
-
-        wanted_profit = paid_total * float(take_profit/100)
-        sellprice_without_loss_on_fee_plus_profit = float(round(float(paid_total + wanted_profit), precision))
-
-        minimal_money_needed_to_buy = current_price*0.1  # 
-
-        # If we are in profit or if the bot is panikkin + the price is higher then what we paid; we sell.
-        if wouldve_paid > sellprice_without_loss_on_fee_plus_profit or system.panik and wouldve_paid > paid_total:
-            chatterer.chat(f"SELLING {cur1}")
-            quantity = float(round(self.get_x_percentage_of_y(99.9, balance_free), precision))
-            sell_order = pynance.orders.create(symbol, quantity, False, order_id='test_api')
-            if sell_order is not None:
-                data = sell_order.json['fills'].pop(0)
-                # Price of the fees we paid
-                paid_fees = float(float(data['price']) * balance_free) *  float(fee_taker/100)
-                # Price including fees we have paid
-                paid_total = float(float(data['price']) * balance_free) + paid_fees
-                wanted_profit = paid_total * float(take_profit/100)
-                sellprice_without_loss_on_fee_plus_profit = float(round(float(paid_total + wanted_profit), precision))
-
-                if model is not None:
-                    model.update_data({
-                        'current': False,
-                        'sold_for': str(wouldve_paid)
-                    })
-                chatterer.chat(f"SOLD {cur1}: {quantity}")
-            else: chatterer.chat("NOTHING TO SELL")
-        else:
+        # Check for each currency selected what we have available in the wallet
+        balance = pynance.wallet.balance(cur1)  # BTC
+        balance2 = pynance.wallet.balance(cur2)  # USDT
+
+        # Each wallet has free amounts and locked amounts, locked is not usable.
+        balance_free = float(round(float(balance['free']), 8))        # BTC
+        balance_locked = float(round(float(balance['locked']), 8))
+        balance2_free = float(round(float(balance2['free']), 8))      # USDT
+        balance2_locked = float(round(float(balance2['locked']), 8))
+        current_price = float(round(float(pynance.price.asset(cur1+cur2).json['price']), 8))
+        # Register the current value
+        system = self.update_system_without_going_offline(system, {'current_value': str(current_price)})
+
+        expected_profit = float(round(float(float(work_price / 100) * take_profit), 8))
+        total_profit_on_each_coin = float(round(float(work_price + expected_profit), 8)) # * quantity == sell_target
+
+        # Debug stuff
+        # print(f"The work price is: {work_price}")
+        # print(f"Take profit: {take_profit}%")
+        # print(f"Fees limit sell / buy: {fee_maker}")
+        # print(f"Fees market sell / buy: {fee_taker}")
+        # print(f"Balance {cur1} -> free {balance_free}, locked {balance_locked}")
+        # print(f"Balance2 {cur2} -> free {balance2_free}, locked {balance2_locked}")
+        # print(f"Current price {current_price}")
+        # print(f"Expected profit: {expected_profit}")
+        # print(f"Buying? : {system.buying}")
+
+        if system.buying:
+            fees_current_price = float(round(float(float(work_price) * fee_taker), 8))
+            price_including_fee = float(round(float(float(balance_free)), 8))
+            price_excluding_fee = float(round(float(float(balance_free - fees_current_price)), 8))
+
             if model is None:
-                if balance2_free > minimal_money_needed_to_buy:
-                    if system.panik:
-                        chatterer.chat("PANIK, NO NEW BUY ORDER WILL BE PLACED")
-                    else:
-                        # Check if the current price is below average
-                        if system.only_dip:
-                            price_average_would_buy = float(price_average - float(price_average * float(float(take_profit/100)/10)))
-                        else: price_average_would_buy = price_average
-                        if current_price < price_average_would_buy:
-                            chatterer.chat(f"BUYING {cur1}")
-                            quantity = float(f"{self.get_x_percentage_of_y(100-take_profit, balance2_free / current_price ):.{precision}f}")
-                            buy_order = pynance.orders.create(symbol, quantity, order_id='test_api')
-                            if buy_order is not None:
-                                data = buy_order.json['fills'].pop(0)
-                                brought_price = float(data['price'])
-                                model = OrdersModel(
-                                    symbol=symbol,
-                                    currency_1=cur1,
-                                    currency_2=cur2,
-                                    quantity=str(quantity),
-                                    brought_price=str(brought_price),
-                                    fee_maker=str(fee_maker),
-                                    fee_taker=str(fee_taker),
-                                )
-                                db.session.add(model)
-                                db.session.commit()
-                            chatterer.chat(f"BROUGHT: {quantity}")
-                        else: chatterer.chat(f"CURRENT {cur1} PRICE ({current_price}) NOT BELOW AVERAGE ({price_average_would_buy}), SKIPPING BUY ORDERS")
-                else: chatterer.chat("NOT ENOUGH MONEY TO BUY")
-            else: 
-                if system.panik:
-                    chatterer.chat(f"HOLDING {cur1} STRONG, CURRENT PRICE ({current_price}) TO LOW TO SELL, TARGET PRICE ({paid_total})")
+                if system.panik: chatterer.chat("PANIK ACTIVE, NO NEW BUY ORDER WILL BE PLACED")
                 else:
-                    chatterer.chat(f"HOLDING {cur1} STRONG, CURRENT PRICE ({current_price}) TO LOW TO SELL, TARGET PRICE ({sellprice_without_loss_on_fee_plus_profit})")
+                    if system.only_dip: price_entry = float(work_price - float(expected_profit))
+                    else: price_entry = float(work_price - float(expected_profit / 2))
+
+                    if current_price <= price_entry:
+                        chatterer.chat(f"BUYING {cur1}")
+                        quantity = float(float(float(float(balance2_free / current_price) / 100) * float(system.total_entry)))
+                        buy_order = pynance.orders.create(symbol, float(round(float(quantity - float(quantity/100)), precision)), order_id='test_api')
+                        if buy_order is not None:
+                            data = buy_order.json['fills'].pop(0)
+                            brought_price = float(round(float(data['price']), 8))
+                            model = OrdersModel(
+                                symbol=symbol,
+                                currency_1=cur1,
+                                currency_2=cur2,
+                                quantity=str(quantity),
+                                brought_price=str(brought_price),
+                                fee_maker=str(fee_maker),
+                                fee_taker=str(fee_taker),
+                            )
+                            db.session.add(model)
+                            db.session.commit()
+                            chatterer.chat(f"BROUGHT {quantity} {cur1} FOR {brought_price} {cur2}")
+                            system = self.update_system_without_going_offline(system, {'buying': False}) # Reset state
+                        else: chatterer.chat(f"UNABLE TO PLACE A BUY ORDER FOR {quantity} {cur1}")
+                    else: chatterer.chat(f"CURRENT {cur1} PRICE ({current_price}) NOT AT BUY TARGET ({price_entry}), SKIPPING BUY ORDER")
+            else:
+                system = self.update_system_without_going_offline(system, {'buying': False}) # Reset state
+                chatterer.chat("NOT ENOUGH MONEY TO PLACE A BUY ORDER")
+        else:
+            fees_current_price = float(round(float(float(work_price) * fee_taker), 8))
+            price_including_fee = float(round(float(float(balance2_free)), 8))
+            price_excluding_fee = float(round(float(float(balance2_free - fees_current_price)), 8))
+
+            if model is None:
+                chatterer.chat("No coin available to sell, you seem to be out of stock!")
+                system = self.update_system_without_going_offline(system, {'buying': True}) # Reset state
+                return jsonify({
+                    "date": str(datetime.now().strftime('%d-%m-%y %H:%M:%S')),
+                    "execution_time": str(datetime.now()-now),
+                    "online": True,
+                    "msg": chatterer.msg
+                }), 200
+
+            quantity = float(round(float(model.quantity), precision))
+            sell_target = float(round(float(float(total_profit_on_each_coin * quantity) + float(float(total_profit_on_each_coin * quantity) * fee_taker)), 8))
+
+            previous_price_order = float(round(float(work_price * quantity), 8))
+            expected_total_profit = float(round(float(sell_target - previous_price_order), 8))
+            total_fomo_price = float(round(float(work_price + fees_current_price), 8))
+            fomo_price = float(round(float(float(total_fomo_price * quantity) + float(float(total_fomo_price * quantity) * fee_taker)), 8))
+
+            if system.panik: chatterer.chat(f"{quantity} {cur1} IS {previous_price_order} {cur2} WORTH - TRYING TO SELL FOR {fomo_price} {cur2}")
+            else: chatterer.chat(f"{quantity} {cur1} IS {previous_price_order} {cur2} WORTH - TRYING TO SELL FOR {sell_target} {cur2}")
+
+            if current_price > total_profit_on_each_coin or system.panik and current_price > total_fomo_price:
+                chatterer.chat(f"SELLING {cur1}")
+                sell_order = pynance.orders.create(symbol, float(round(float(quantity - float(quantity/100)), precision)), buy=False, order_id='test_api')
+                if sell_order is not None:
+                    sold_price = float(round(float(current_price * quantity), 8))
+                    if model is not None:
+                        model.update_data({
+                            'current': False,
+                            'sold_for': str(sold_price)
+                        })
+                        chatterer.chat(f"SOLD {quantity} {cur1} FOR AN AMAZING {sold_price} {cur2}")
+                        system = self.update_system_without_going_offline(system, {'buying': True}) # Reset state
+                else: chatterer.chat(f"UNABLE TO PLACE A SELL ORDER FOR {quantity} {cur1}")
 
         return jsonify({
             "date": str(datetime.now().strftime('%d-%m-%y %H:%M:%S')),

backend/views/api/ui.py

@@ -66,4 +66,10 @@ def current_price(self):
                 fiat, coin, quantity = model.current_price.split(' - ')
                 return jsonify({'fiat': fiat, 'coin': coin, 'quantity': quantity}), 200
             except ValueError: pass
-        return jsonify({'fiat': 0, 'coin': 0, 'quantity': 0}), 200
+        return jsonify({'fiat': 0, 'coin': 0, 'quantity': 0}), 200
+
+    @route('/v2/current_price', methods=['GET'])
+    def current_price_2(self):
+        model = SystemModel.query.first()
+        return jsonify({'price': model.current_value}), 200
+