Update Order Attributes

meta/meta.json

@@ -1,3 +1,3 @@
 {
-  "subnet_version": "7.0.2"
+  "subnet_version": "7.0.3"
 }

mining/run_receive_signals_server.py

@@ -58,7 +58,9 @@ def handle_data():
             raise Exception("trade_pair must be a string or a dict")
 
         signal = Signal(trade_pair=TradePair.from_trade_pair_id(signal_trade_pair_str),
-                        leverage=float(data["leverage"]),
+                        leverage=float(data["leverage"]) if data.get("leverage") is not None else None,
+                        value=float(data["value"]) if data.get("value") is not None else None,
+                        quantity=float(data["quantity"]) if data.get("quantity") is not None else None,
                         order_type=OrderType.from_string(data["order_type"].upper()))
         # make miner received signals dir if doesnt exist
         ValiBkpUtils.make_dir(MinerConfig.get_miner_received_signals_dir())
@@ -83,4 +85,4 @@ def handle_data():
 
 if __name__ == "__main__":
     waitress.serve(app, host="0.0.0.0", port=8088, connection_limit=1000)
-    print('Successfully started run_receive_signals_server.')
+    print('Successfully started run_receive_signals_server.')

mining/sample_signal_request.py

@@ -36,10 +36,13 @@ def default(self, obj):
     url = f'{base_url}/api/receive-signal'
 
     # Define the JSON data to be sent in the request
+    # Note: You must provide exactly ONE of 'leverage', 'value', or 'quantity'
     data = {
-        'trade_pair': TradePair.FTSE,
+        'trade_pair': TradePair.BTCUSD,
         'order_type': OrderType.LONG,
-        'leverage': .05,
+        'leverage': 0.1,    # leverage
+        # 'value': 10_000,  # USD value
+        # 'quantity': 0.1,  # base asset quantity (lots, shares, coins, etc.)
         'api_key': 'xxxx'
     }
 
@@ -61,4 +64,4 @@ def default(self, obj):
         print(response.json())  # Print the response data
     else:
         print(response.__dict__)
-        print("POST request failed with status code:", response.status_code)
+        print("POST request failed with status code:", response.status_code)

neurons/backtest_manager.py

@@ -104,7 +104,7 @@ def save_positions_to_manager(position_manager, hk_to_positions):
 class BacktestManager:
 
     def __init__(self, positions_at_t_f, start_time_ms, secrets, scoring_func,
-                 capital=ValiConfig.DEFAULT_CAPITAL, use_slippage=None,
+                 use_slippage=None,
                  fetch_slippage_data=False, recalculate_slippage=False, rebuild_all_positions=False,
                  parallel_mode: ParallelizationMode=ParallelizationMode.PYSPARK, build_portfolio_ledgers_only=False,
                  pool_size=0, target_ledger_window_ms=ValiConfig.TARGET_LEDGER_WINDOW_MS):
@@ -149,13 +149,13 @@ def __init__(self, positions_at_t_f, start_time_ms, secrets, scoring_func,
                                                      secrets=self.secrets,
                                                      use_slippage=use_slippage,
                                                      build_portfolio_ledgers_only=build_portfolio_ledgers_only,
-                                                     target_ledger_window_ms=target_ledger_window_ms,
-                                                     contract_manager=self.contract_manager)
+                                                     target_ledger_window_ms=target_ledger_window_ms)
 
 
         self.position_manager = PositionManager(metagraph=self.metagraph,
                                                 perf_ledger_manager=self.perf_ledger_manager,
                                                 elimination_manager=self.elimination_manager,
+                                                contract_manager=self.contract_manager,
                                                 is_backtesting=True,
                                                 challengeperiod_manager=None)
 
@@ -185,7 +185,7 @@ def __init__(self, positions_at_t_f, start_time_ms, secrets, scoring_func,
             contract_manager=self.contract_manager,
         )
         self.psm = PriceSlippageModel(self.live_price_fetcher, is_backtesting=True, fetch_slippage_data=fetch_slippage_data,
-                                      recalculate_slippage=recalculate_slippage, capital=capital)
+                                      recalculate_slippage=recalculate_slippage)
 
 
         #Until slippage is added to the db, this will always have to be done since positions are sometimes rebuilt and would require slippage attributes on orders and initial_entry_price calculation
@@ -364,7 +364,7 @@ def debug_print_ledgers(self, perf_ledger_bundles):
     t0 = time.time()
 
     secrets = ValiUtils.get_secrets()  # {'polygon_apikey': '123', 'tiingo_apikey': '456'}
-    btm = BacktestManager(hk_to_positions, start_time_ms, secrets, None, capital=500_000,
+    btm = BacktestManager(hk_to_positions, start_time_ms, secrets, None,
                           use_slippage=use_slippage, fetch_slippage_data=False, recalculate_slippage=False,
                           parallel_mode=parallel_mode,
                           build_portfolio_ledgers_only=build_portfolio_ledgers_only)

neurons/validator.py

@@ -207,11 +207,11 @@ def __init__(self):
                                               signal_sync_condition=self.signal_sync_condition,
                                               n_orders_being_processed=self.n_orders_being_processed,
                                               ipc_manager=self.ipc_manager,
-                                              position_manager=None,
+                                              position_manager=None,     # Set after self.pm creation
                                               auto_sync_enabled=self.auto_sync,
                                               contract_manager=self.contract_manager,
                                               live_price_fetcher=self.live_price_fetcher,
-                                              asset_selection_manager=self.asset_selection_manager)  # Set after self.pm creation
+                                              asset_selection_manager=self.asset_selection_manager)
 
         self.p2p_syncer = P2PSyncer(wallet=self.wallet, metagraph=self.metagraph, is_testnet=not self.is_mainnet,
                                     shutdown_dict=shutdown_dict, signal_sync_lock=self.signal_sync_lock,
@@ -224,16 +224,17 @@ def __init__(self):
         self.perf_ledger_manager = PerfLedgerManager(self.metagraph, ipc_manager=self.ipc_manager,
                                                      shutdown_dict=shutdown_dict,
                                                      perf_ledger_hks_to_invalidate=self.position_syncer.perf_ledger_hks_to_invalidate,
-                                                     position_manager=None,
-                                                     contract_manager=self.contract_manager)  # Set after self.pm creation)
+                                                     position_manager=None)  # Set after self.pm creation)
 
 
         self.position_manager = PositionManager(metagraph=self.metagraph,
                                                 perform_order_corrections=True,
                                                 ipc_manager=self.ipc_manager,
+                                                live_price_fetcher=self.live_price_fetcher,
                                                 perf_ledger_manager=self.perf_ledger_manager,
                                                 elimination_manager=self.elimination_manager,
                                                 challengeperiod_manager=None,
+                                                contract_manager=self.contract_manager,
                                                 secrets=self.secrets,
                                                 shared_queue_websockets=self.shared_queue_websockets,
                                                 closed_position_daemon=True)
@@ -871,7 +872,7 @@ def _get_or_create_open_position_from_new_order(self, trade_pair: TradePair, ord
                 self._add_order_to_existing_position(existing_open_pos, trade_pair, OrderType.FLAT,
                                                      0.0, force_close_order_time, miner_hotkey,
                                                      price_sources, force_close_order_uuid, miner_repo_version,
-                                                     OrderSource.MAX_ORDERS_PER_POSITION_CLOSE, account_size)
+                                                     OrderSource.MAX_ORDERS_PER_POSITION_CLOSE)
                 time.sleep(0.1)  # Put 100ms between two consecutive websocket writes for the same trade pair and hotkey. We need the new order to be seen after the FLAT.
             else:
                 # If the position is closed, raise an exception. This can happen if the miner is eliminated in the main
@@ -1030,27 +1031,42 @@ def parse_miner_uuid(self, synapse: template.protocol.SendSignal):
         return temp
 
     def _add_order_to_existing_position(self, existing_position, trade_pair, signal_order_type: OrderType,
-                                        signal_leverage: float, order_time_ms: int, miner_hotkey: str,
+                                        quantity: float, order_time_ms: int, miner_hotkey: str,
                                         price_sources, miner_order_uuid: str, miner_repo_version: str, src:OrderSource,
-                                        account_size):
+                                        usd_base_price=None):
         # Must be locked by caller
         best_price_source = price_sources[0]
+        price = best_price_source.parse_appropriate_price(order_time_ms, trade_pair.is_forex, signal_order_type, existing_position.orders[0].order_type)
+
+        if existing_position.account_size <= 0:
+            bt.logging.warning(
+                f"Invalid account_size {existing_position.account_size} for position {existing_position.position_uuid}. "
+                f"Using MIN_CAPITAL as fallback."
+            )
+            existing_position.account_size = ValiConfig.MIN_CAPITAL
+        # Calculate value and leverage
+        if usd_base_price is None:
+            usd_base_price = self.live_price_fetcher.get_usd_base_conversion(trade_pair, order_time_ms, price, signal_order_type, existing_position.position_type)
+        value = (1 / usd_base_price) * (quantity * trade_pair.lot_size)
+        leverage = value / existing_position.account_size
         order = Order(
             trade_pair=trade_pair,
             order_type=signal_order_type,
-            leverage=signal_leverage,
-            price=best_price_source.parse_appropriate_price(order_time_ms, trade_pair.is_forex, signal_order_type,
-                                                            existing_position),
+            quantity=quantity,
+            value=value,
+            leverage=leverage,
+            price=price,
             processed_ms=order_time_ms,
             order_uuid=miner_order_uuid,
             price_sources=price_sources,
             bid=best_price_source.bid,
             ask=best_price_source.ask,
             src=src
         )
-        self.price_slippage_model.refresh_features_daily(time_ms=order_time_ms)
-        order.slippage = PriceSlippageModel.calculate_slippage(order.bid, order.ask, order, account_size)
+        order.usd_base_rate = usd_base_price
+        order.quote_usd_rate = self.live_price_fetcher.get_quote_usd_conversion(order, existing_position.position_type)
         net_portfolio_leverage = self.position_manager.calculate_net_portfolio_leverage(miner_hotkey)
+        order.slippage = PriceSlippageModel.calculate_slippage(order.bid, order.ask, order)
         existing_position.add_order(order, self.live_price_fetcher, net_portfolio_leverage)
         self.position_manager.save_miner_position(existing_position)
         # Update cooldown cache after successful order processing
@@ -1069,6 +1085,29 @@ def _get_account_size(self, miner_hotkey, now_ms):
             account_size = max(account_size, ValiConfig.MIN_CAPITAL)
         return account_size
 
+    @staticmethod
+    def parse_order_quantity(signal, usd_base_conversion, trade_pair, portfolio_value):
+        """
+        parses an order signal and calculates leverage, value, and quantity
+        """
+        leverage = signal.get("leverage")
+        value = signal.get("value")
+        quantity = signal.get("quantity")
+
+        fields_set = [x is not None for x in (leverage, value, quantity)]
+        if sum(fields_set) != 1:
+            raise ValueError("Exactly one of 'leverage', 'value', or 'quantity' must be set")
+
+        if quantity is not None:
+            return quantity
+        if leverage is not None:
+            value = leverage * portfolio_value
+            quantity = (value * usd_base_conversion) / trade_pair.lot_size
+        elif value is not None:
+            quantity = (value * usd_base_conversion) / trade_pair.lot_size
+
+        return quantity
+
     # This is the core validator function to receive a signal
     def receive_signal(self, synapse: template.protocol.SendSignal,
                        ) -> template.protocol.SendSignal:
@@ -1102,7 +1141,6 @@ def receive_signal(self, synapse: template.protocol.SendSignal,
                 raise SignalException(
                     f"Ignoring order for [{miner_hotkey}] due to no live prices being found for trade_pair [{trade_pair}]. Please try again.")
 
-            signal_leverage = signal["leverage"]
             signal_order_type = OrderType.from_string(signal["order_type"])
 
             # Multiple threads can run receive_signal at once. Don't allow two threads to trample each other.
@@ -1120,10 +1158,15 @@ def receive_signal(self, synapse: template.protocol.SendSignal,
                 existing_position = self._get_or_create_open_position_from_new_order(trade_pair, signal_order_type,
                     now_ms, miner_hotkey, miner_order_uuid, now_ms, price_sources, miner_repo_version, account_size)
                 if existing_position:
+                    best_price_source = price_sources[0]
+                    price = best_price_source.parse_appropriate_price(now_ms, trade_pair.is_forex, signal_order_type, existing_position.orders[0].order_type)
+                    usd_base_price = self.live_price_fetcher.get_usd_base_conversion(trade_pair, now_ms, price, signal_order_type, existing_position.position_type)
+                    quantity = self.parse_order_quantity(signal, usd_base_price, trade_pair, existing_position.account_size)
+
                     self._add_order_to_existing_position(existing_position, trade_pair, signal_order_type,
-                                                        signal_leverage, now_ms, miner_hotkey,
+                                                        quantity, now_ms, miner_hotkey,
                                                         price_sources, miner_order_uuid, miner_repo_version,
-                                                        OrderSource.ORGANIC, account_size)
+                                                        OrderSource.ORGANIC, usd_base_price)
                     synapse.order_json = existing_position.orders[-1].__str__()
                 else:
                     # Happens if a FLAT is sent when no position exists

ptn_api/rest_server.py

@@ -771,22 +771,73 @@ def deposit_collateral():
                 bt.logging.error(f"Error processing collateral deposit: {e}")
                 return jsonify({'error': 'Internal server error processing deposit'}), 500
 
+        @self.app.route("/collateral/query-withdraw", methods=["POST"])
+        def query_withdraw_collateral():
+            """Query collateral withdrawal request for potential slashed amount"""
+            # Check if contract manager is available
+            if not self.contract_manager:
+                return jsonify({'error': 'Collateral operations not available'}), 503
+
+            try:
+                # Parse JSON request
+                if not request.is_json:
+                    return jsonify({'error': 'Content-Type must be application/json'}), 400
+
+                data = request.get_json()
+                if not data:
+                    return jsonify({'error': 'Invalid JSON body'}), 400
+
+                # Validate required fields for withdrawal query
+                required_fields = ['amount', 'miner_hotkey']
+                for field in required_fields:
+                    if field not in data:
+                        return jsonify({'error': f'Missing required field: {field}'}), 400
+
+                # Validate amount is a positive number
+                try:
+                    amount = float(data['amount'])
+                    if amount <= 0:
+                        return jsonify({'error': 'Amount must be a positive number'}), 400
+                except (ValueError, TypeError):
+                    return jsonify({'error': 'Amount must be a valid number'}), 400
+
+                # Validate miner_hotkey is a valid SS58 address
+                miner_hotkey = data['miner_hotkey']
+                try:
+                    # Attempt to create a Keypair to validate SS58 format
+                    Keypair(ss58_address=miner_hotkey)
+                except Exception:
+                    return jsonify({'error': 'Invalid SS58 address format for miner_hotkey'}), 400
+
+                # Process the withdrawal query
+                result = self.contract_manager.query_withdrawal_request(
+                    amount=amount,
+                    miner_hotkey=miner_hotkey
+                )
+
+                # Return response
+                return jsonify(result)
+
+            except Exception as e:
+                bt.logging.error(f"Error processing collateral withdrawal query: {e}")
+                return jsonify({'error': 'Internal server error processing withdrawal query'}), 500
+
         @self.app.route("/collateral/withdraw", methods=["POST"])
         def withdraw_collateral():
             """Process collateral withdrawal request."""
             # Check if contract manager is available
             if not self.contract_manager:
                 return jsonify({'error': 'Collateral operations not available'}), 503
-                
+
             try:
                 # Parse JSON request
                 if not request.is_json:
                     return jsonify({'error': 'Content-Type must be application/json'}), 400
-                    
+
                 data = request.get_json()
                 if not data:
                     return jsonify({'error': 'Invalid JSON body'}), 400
-                    
+
                 # Validate required fields for signed withdrawal
                 required_fields = ['amount', 'miner_coldkey', 'miner_hotkey', 'nonce', 'timestamp', 'signature']
                 for field in required_fields:
@@ -821,6 +872,14 @@ def withdraw_collateral():
                 if not is_valid:
                     return jsonify({'error': f'{error_msg}'}), 401
 
+                # Validate amount is a positive number
+                try:
+                    amount = float(data['amount'])
+                    if amount <= 0:
+                        return jsonify({'error': 'Amount must be a positive number'}), 400
+                except (ValueError, TypeError):
+                    return jsonify({'error': 'Amount must be a valid number'}), 400
+
                 # Process the withdrawal using verified data
                 result = self.contract_manager.process_withdrawal_request(
                     amount=data['amount'],
@@ -830,7 +889,7 @@ def withdraw_collateral():
 
                 # Return response
                 return jsonify(result)
-                
+
             except Exception as e:
                 bt.logging.error(f"Error processing collateral withdrawal: {e}")
                 return jsonify({'error': 'Internal server error processing withdrawal'}), 500