saving

algo_config.json

@@ -1,5 +1,5 @@
 {
-    "Updated_Timestamp": 1777828655743,
+    "Updated_Timestamp": 1777942827905,
     "Config": {
         "Loop_Sleep_Sec": 0.0,
         "Max_Order_Over_Notional_Ratio": 1.05,

engine_best_funding_rate.py

@@ -14,6 +14,7 @@ import valkey
 from dotenv import load_dotenv
 import modules.manual_leverage as leverage
 import modules.aster_auth as aster_auth
+import modules.utils as utils
 
 ### MANUAL LEVERAGE DATA ###
 df_leverage_by_exch = pd.DataFrame(data=leverage.LEVERAGE_BY_EXCH)
@@ -117,6 +118,48 @@ def load_extend_current_fr(df_mkt_stats: pd.DataFrame) -> pd.DataFrame:
 
     return df
 
+async def get_candles(symbol: str) -> pd.DataFrame:
+    ### Candles for Midpoint Dispersion ###
+    # Aster
+    symbol_ast = utils.symbol_to_aster_fmt(symbol)
+    aster_candles = {
+        "url": "/fapi/v3/klines",
+        "method": "GET",
+        "params": {
+            'symbol': symbol_ast,
+            'interval': '1m',
+            'limit':'1440'
+        }
+    }
+    j = await aster_auth.post_authenticated_url(aster_candles)
+    df_candles_aster = pd.DataFrame(j, columns=['open_ts','open_px','high_px','low_px','close_px','volume','close_ts','quote_asset_volume','count_trades','taker_buy_base_asset_volume','taker_buy_quote_asset_volume','_drop'])
+    df_candles_aster = df_candles_aster[['open_px', 'low_px', 'high_px', 'close_px', 'volume', 'open_ts']]
+    df_candles_aster[['open_px', 'low_px', 'high_px', 'close_px', 'volume']] = df_candles_aster[['open_px', 'low_px', 'high_px', 'close_px', 'volume']].astype(float)
+
+    df_candles_aster['med_px'] = ( df_candles_aster['high_px'] + df_candles_aster['low_px'] ) / 2
+    df_candles_aster['typical_px'] = ( df_candles_aster['open_px'] + df_candles_aster['high_px'] + df_candles_aster['low_px'] + df_candles_aster['close_px'] ) / 4
+
+    # Extend
+    symbol_ext = utils.symbol_to_extend_fmt(symbol)
+    ext_params = {
+        'interval':'1m',
+        'limit':1440,
+    }
+    r = json.loads(requests.get(f'https://api.starknet.extended.exchange/api/v1/info/candles/{symbol_ext}/trades', params=ext_params).text)
+    df_candles_extended = pd.DataFrame(r['data'])
+    df_candles_extended = df_candles_extended.rename({'o':'open_px','l':'low_px','h':'high_px','c':'close_px','v':'volume','T':'open_ts'}, axis=1)
+    df_candles_extended[['open_px', 'low_px', 'high_px', 'close_px', 'volume']] = df_candles_extended[['open_px', 'low_px', 'high_px', 'close_px', 'volume']].astype(float)
+    df_candles_extended['med_px'] = ( df_candles_extended['high_px'] + df_candles_extended['low_px'] ) / 2
+    df_candles_extended['typical_px'] = ( df_candles_extended['open_px'] + df_candles_extended['high_px'] + df_candles_extended['low_px'] + df_candles_extended['close_px'] ) / 4
+
+    df_candles_comb = df_candles_aster.merge(df_candles_extended, on='open_ts', how='inner', suffixes=('_ast','_ext'))
+    df_candles_comb['open_dt'] = pd.to_datetime(df_candles_comb['open_ts'], unit='ms')
+    df_candles_comb['med_ratio_aster_over_extend'] = ( df_candles_comb['med_px_ast'] / df_candles_comb['med_px_ext'] ) - 1
+
+    return df_candles_comb
+
+
+
 async def loop() -> None:
     global Mkt_Info_Last_Refresh_TS_ms
     try:
@@ -163,6 +206,15 @@ async def loop() -> None:
             # print(df_best_fr_rate.columns)
             # print(df_best_fr_rate.iloc[0])
 
+            candles_ratios = []
+
+            for index, row in df_best_fr_rate.iterrows():
+                df = await get_candles(symbol=row['symbol_ext'])
+                buy_ratio_ext = float(df['med_ratio_aster_over_extend'].median())
+                candles_ratios.append({'symbol_ext':row['symbol_ext'], 'buy_ratio_ext':buy_ratio_ext,'buy_ratio_ast':buy_ratio_ext*-1})
+
+            df_best_fr_rate = df_best_fr_rate.merge(pd.DataFrame(candles_ratios), on='symbol_ext', how='left')
+
             if len(df_best_fr_rate) < 1:
                 raise ValueError(f'NO BFR RATE: {df_best_fr_rate}')
 
@@ -177,6 +229,7 @@ async def loop() -> None:
                     min_order_size=float(df_best_fr_rate['min_order_size_ast'].iloc[0]),
                     min_lot_size=float(df_best_fr_rate['min_lot_size_ast'].iloc[0]),
                     min_notional=float(df_best_fr_rate['min_notional_ast'].iloc[0]),
+                    buy_ratio=float(df_best_fr_rate['buy_ratio_ast'].iloc[0]),
                 )          
                 EXTEND = structs.Perpetual_Exchange(
                     mult = int(df_best_fr_rate['max_leverage_ext'].iloc[0]),
@@ -188,6 +241,7 @@ async def loop() -> None:
                     min_order_size=float(df_best_fr_rate['min_order_size_ext'].iloc[0]),
                     min_lot_size=float(df_best_fr_rate['min_lot_size_ext'].iloc[0]),
                     min_notional=float(df_best_fr_rate['min_notional_ext'].iloc[0]),
+                    buy_ratio=float(df_best_fr_rate['buy_ratio_ext'].iloc[0]),
                 )
             except Exception as e:
                 logging.critical(f'Failed to build ASTER/EXTEND objs err: {e}; df cols: {df_best_fr_rate.columns}')
@@ -196,13 +250,13 @@ async def loop() -> None:
             best_next_funding_pair: dict[str, dict] = {'ASTER': asdict(obj=ASTER), 'EXTEND': asdict(obj=EXTEND)}
             VAL_KEY.set(name='fr_engine_best_fund_rate_output', value=json.dumps(obj=best_next_funding_pair))
             
-            master_data = df_comb_fr[
-                ['symbol_ast','max_leverage_ast','lh_asset_ast','rh_asset_ast','funding_rate_ast','min_price_ast','min_order_size_ast','min_lot_size_ast','min_notional_ast', 
-                 'symbol_ext','max_leverage_ext','lh_asset_ext','rh_asset_ext','funding_rate_ext','min_price_ext','min_order_size_ext','min_lot_size_ext','min_notional_ext']
+            master_data = df_best_fr_rate[
+                ['symbol_ast','max_leverage_ast','lh_asset_ast','rh_asset_ast','funding_rate_ast','min_price_ast','min_order_size_ast','min_lot_size_ast','min_notional_ast','buy_ratio_ast',
+                 'symbol_ext','max_leverage_ext','lh_asset_ext','rh_asset_ext','funding_rate_ext','min_price_ext','min_order_size_ext','min_lot_size_ext','min_notional_ext','buy_ratio_ext']
                 ].to_json(orient='records')
             
             VAL_KEY.set(name='fr_engine_best_fund_rate_master', value=str(master_data))
-            print(df_best_fr_rate[['symbol_ext','max_leverage_ext','funding_rate_ast','funding_rate_ext','net_funding_rate','daily_volume_ast']].head(10))
+            print(df_best_fr_rate[['symbol_ext','max_leverage_ext','buy_ratio_ext','net_funding_rate','daily_volume_ast']].head(10))
             logging.info(f'BFR REFRESHED @ {datetime.now()}')
             time.sleep(LOOP_SLEEP_SEC)
             continue

extended.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 1,
    "id": "6c70a8c3",
    "metadata": {},
    "outputs": [],
@@ -27,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 2,
    "id": "ff971ca9",
    "metadata": {},
    "outputs": [],
@@ -49,7 +49,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 3,
    "id": "fc2c6d2b",
    "metadata": {},
    "outputs": [],
@@ -154,9 +154,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "id": "4b39754d",
    "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'status': 'OK', 'data': EmptyModel(), 'error': None, 'pagination': None}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dict(await trading_client.orders.cancel_order(order_id='123'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "976ca20d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": []
   },

main_trading_only.py

@@ -0,0 +1,870 @@
+
+from x10.utils.http import WrappedApiResponse
+from x10.perpetual.trading_client.trading_client import PerpetualTradingClient
+import asyncio
+import json
+import logging
+import math
+import os
+import time
+import traceback
+from datetime import datetime, timezone
+from decimal import ROUND_DOWN, ROUND_UP, ROUND_HALF_UP, Decimal
+from typing import AsyncContextManager
+from dataclasses import dataclass, asdict
+from typing import Any
+import numpy as np
+import pandas as pd
+import requests
+
+# import talib
+import valkey
+from dotenv import load_dotenv
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import create_async_engine
+from x10.models.order import OrderSide, PlacedOrderModel
+
+import modules.utils as utils
+import modules.aster_auth as aster_auth
+import modules.extended_auth as extend_auth
+import modules.structs as structs
+
+### Clients ###
+EXTEND_CLIENT: PerpetualTradingClient
+CON: AsyncContextManager
+VAL_KEY: valkey.Valkey
+
+### Logging ###
+load_dotenv()
+LOG_FILEPATH: str = f'{os.getenv(key="LOGS_PATH")}/Fund_Rate_Algo.log'
+
+### Algo Config ###
+Config: structs.Algo_Config
+
+### Exchanges ###
+Aster: structs.Perpetual_Exchange
+Extend: structs.Perpetual_Exchange
+
+### Globals ###
+Open_Symbols: list[str] = []
+Last_Aster_Fill_Time_Ts: float = 0.00
+Just_Rejected_Or_Expired: bool = False
+
+Aster_Open_Orders: list[dict] = []
+Extend_Open_Orders: list[dict] = []
+
+### Flags ###
+# Flags = structs.Flags()
+
+
+### Define Ordering Logic ###
+'''
+Notes
+- handle increasing vs flattening
+    - if increasing, set not reduce only
+    - if flattening, set as reduce only and make sure allowed to trade below min notional, and qty calc should be exact
+- handle opportunistic vs immediate
+- handle cancel-replace manually for aster and sometimes manually for extend (e.g. cant change certain things on an existing order)
+- gracefully handle err responses (well known err codes e.g.) and response errors (e.g. json fails to parse)
+'''
+
+async def cancel_aster_order(open_order_id: str):
+    global Aster_Open_Orders
+    start = time.time()
+    cancel_order: dict = {
+        "url": "/fapi/v3/order",
+        "method": "DELETE",
+        "params": {
+            'symbol': Aster.symbol,
+            'orderId': open_order_id,
+        }
+    }
+    cr: dict = await aster_auth.post_authenticated_url(cancel_order)  # ty:ignore[invalid-assignment]
+    if cr.get('status', None) == 'CANCELED':
+        Aster_Open_Orders.pop(0)
+    else:
+        logging.warning(f'ASTER ORDER FAILED TO CANCEL DURING CR ({open_order_id}): RESP {cr}')
+    logging.info(f'TIMING - cancel_aster_order: {(time.time() - start)*1000:.2f}')
+
+async def post_aster_order(
+    symbol: str,
+    side: str,
+    qty: Decimal,
+    price: Decimal,
+    reduceOnly: bool,
+    postOnly: bool
+):
+    global Aster_Open_Orders
+    global Just_Rejected_Or_Expired
+    
+    if postOnly:
+        timeInForce = 'GTX'
+    else:
+        timeInForce = 'GTC'
+
+    post_order = {
+        "url": "/fapi/v3/order",
+        "method": "POST",
+        "params": {
+            'symbol': symbol,
+            'side': side,
+            'type': 'LIMIT',
+            'timeInForce': timeInForce,
+            'quantity': qty,
+            'price': price,
+            'reduceOnly': reduceOnly
+        }
+    }
+    order_resp: dict = await aster_auth.post_authenticated_url(post_order)  # ty:ignore[invalid-assignment]
+    if order_resp.get('orderId', None) is not None:
+        order_resp['original_price'] = price
+        order_resp['order_status'] = order_resp['status']
+        
+        Aster_Open_Orders.append(order_resp)
+        Just_Rejected_Or_Expired = False
+        
+        utils.send_tg_alert(f'FR_ALGO - ASTER Order ({order_resp['orderId']}). Start_$: {Aster.notional_position:.4f}; {side}: {float(qty)*float(price):.4f}; Price: {float(price):.4f}')
+        logging.info(f'ASTER ORDER PLACED SUCCESS: {order_resp}')
+        # print_summary(use_logging=True)
+    else:
+        logging.critical(f'*** Aster Order Response Abnormal: {order_resp}; post_order: {post_order}')
+        await kill_algo()
+
+async def cancel_extend_order(order_id: str):
+    r = EXTEND_CLIENT.orders.cancel_order(order_id=order_id)
+    
+    r = dict(r)
+    if r.get('status', None) == 'OK':
+        logging.info(f'EXTEND ORDER CANCELLED: {order_id}')
+    else:
+        logging.warning(f'EXTEND ORDER FAILED TO CANCEL DURING CR ({order_id}): RESP {r}')
+
+async def post_extend_order(
+    symbol: str,
+    side: str,
+    qty: Decimal,
+    price: Decimal,
+    reduceOnly: bool,
+    postOnly: bool,
+    cxl_prev_order_id: str | None = None,
+):
+    global Extend_Open_Orders
+    global Just_Rejected_Or_Expired
+
+    side = OrderSide.BUY if side == 'BUY' else OrderSide.SELL
+    taker_fee = Decimal("0.00025")
+    try:
+        order_resp: WrappedApiResponse[PlacedOrderModel] = await EXTEND_CLIENT.place_order(
+            market_name=symbol,
+            amount_of_synthetic=qty,
+            price=price,
+            side=side,
+            taker_fee=taker_fee,
+            previous_order_id=cxl_prev_order_id,
+            post_only=postOnly,
+            reduce_only=reduceOnly
+        )
+    except Exception as e:
+        logging.critical(e)
+
+    order_resp_dict = dict(order_resp)
+    
+    if order_resp_dict.get('status', None) == 'ERROR':
+        if order_resp_dict['error']['code']==1142:
+            logging.info('Cant find edit order for Extend, skipping cancel.')
+        else:
+            logging.critical(f'*** Extend Order Response Abnormal: {order_resp};')
+            await kill_algo()
+    if order_resp_dict.get('status', None) == 'OK':
+        if Extend_Open_Orders:
+            Extend_Open_Orders.pop(0)
+        
+        order_dict = dict(order_resp_dict['data'])
+        order_dict['status'] = 'NEW'
+        order_dict['price'] = str(price)
+        order_dict['qty'] = str(qty)
+        order_dict['filled_qty'] = str(0)
+        order_dict['side'] = str(side)
+        
+        Extend_Open_Orders.append(order_dict)
+        Just_Rejected_Or_Expired = False
+        utils.send_tg_alert(f'FR_ALGO - EXTEND Order ({order_dict.get('id', None)}). Start_$: {Extend.notional_position:.2f}; {str(side)}: {float(qty)*float(price):.2f}; Price: {float(price):.2f}')
+        logging.info(f'EXTEND ORDER PLACED SUCCESS: {order_dict}')
+        # print_summary(use_logging=True)
+    else:
+        logging.critical(f'*** Extend Order Response Abnormal: {order_resp};')
+        await kill_algo()
+
+### OPEN ORDERS ###
+async def handle_order_updates(exch: str, local_open_orders: list[dict], ws_open_orders: list[dict]) -> list[dict]: # exch = 'ASTER' | 'EXTEND'
+    global Just_Rejected_Or_Expired
+    global Last_Aster_Fill_Time_Ts
+
+    if ws_open_orders:
+        for idx, o in enumerate(local_open_orders):
+            o = dict(o)
+            if o.get('order_id') is not None:
+                ws_order_id_field = 'order_id' 
+            elif o.get('orderId') is not None:
+                ws_order_id_field = 'orderId' 
+            else:
+                ws_order_id_field = 'id' 
+            
+            order_id = o[ws_order_id_field]
+            order_orig_status: str = o.get('status') if o.get('status') is not None else o['order_status']  # ty:ignore[invalid-assignment]
+            order_update: list[dict] = [dict(ou) for ou in ws_open_orders if dict(ou).get('order_id', None) == order_id]
+            
+            if len(order_update) > 0:
+                order_update: dict = order_update[0]
+                order_update_status: str = order_update.get('status') if order_update.get('status') is not None else order_update['order_status']  # ty:ignore[invalid-assignment]
+                order_status_changed: bool = order_orig_status.upper() != order_update_status.upper()
+
+                local_open_orders[idx]['order_id'] = order_id
+                local_open_orders[idx]['status'] = order_update_status
+                local_open_orders[idx]['price'] = order_update.get('price', 0) if order_update.get('price') is not None else order_update['original_price']
+
+                if order_status_changed:
+                    logging.info(f'{exch} ORDER ({order_id}): {order_orig_status} -> {order_update_status}')
+                    local_open_orders[idx] = order_update
+                    if order_update_status in ['CANCELLED','CANCELED','EXPIRED','REJECTED']:
+                        logging.info(f'{exch} ORDER CANCELLED or EXPIRED: {order_id}')
+                        local_open_orders.pop(idx)
+                        Just_Rejected_Or_Expired = True
+                        utils.send_tg_alert(f'FR_ALGO - {exch} REJECTED ({order_id})')
+                    elif order_update_status in ['PARTIALLY_FILLED']:
+                        logging.info(f'{exch} ORDER PARTIALLY FILLED: {order_id}')
+                        # await get_aster_collateral()
+                        if exch=='ASTER':
+                            await get_aster_notional_position(resp=ws_open_orders)
+                            Last_Aster_Fill_Time_Ts = datetime.now().timestamp()*1000
+                        else:
+                            await get_extend_notional()
+                        utils.send_tg_alert(f'FR_ALGO - {exch} PARTIALLY FILLED ({order_id})')
+                    elif order_update_status in ['FILLED']:
+                        logging.info(f'{exch} ORDER FILLED: {order_id}')
+                        local_open_orders.pop(idx)
+                        # await get_aster_collateral()
+                        if exch=='ASTER':
+                            await get_aster_notional_position(resp=ws_open_orders)
+                            Last_Aster_Fill_Time_Ts = datetime.now().timestamp()*1000
+                        else:
+                            await get_extend_notional()
+                        utils.send_tg_alert(f'FR_ALGO - {exch} FILLED ({order_id})')
+                    else:
+                        logging.critical(f'{exch} ORDER STATUS CHG TO UNEXPECTED VALUE, KILLING... ({order_id}): {order_orig_status} -> {order_update_status}')
+                        await kill_algo()
+    return local_open_orders
+
+async def get_aster_open_orders():
+    global Aster_Open_Orders
+
+    fut_acct_openOrders = {
+        "url": "/fapi/v3/openOrders",
+        "method": "GET",
+        "params": {}
+    }
+    Aster_Open_Orders = await aster_auth.post_authenticated_url(fut_acct_openOrders)  # ty:ignore[invalid-assignment]
+
+async def get_extend_open_orders():
+    global Extend_Open_Orders
+
+    Extend_Open_Orders = list(dict(await EXTEND_CLIENT.account.get_open_orders()).get('data', 0))
+
+### WALLLET ###
+async def get_aster_account_open_symbols() -> list[str]:
+    fut_acct_positionRisk: dict = {
+            "url": "/fapi/v3/positionRisk",
+            "method": "GET",
+            "params": {
+                'symbol':''
+            }
+        }
+    try:
+        resp: list = await aster_auth.post_authenticated_url(req=fut_acct_positionRisk)  # ty:ignore[invalid-assignment]
+    except Exception as e:
+        logging.critical(f'JSONDecodeError trying to get Aster open orders: {e}; resp: {resp}')
+        await kill_algo()
+        resp: list = []
+    ld = [ utils.symbol_to_extend_fmt(x['symbol']) for x in resp if abs(float(x.get('positionAmt', 0))) > 0]
+    return ld
+
+async def get_aster_notional_position(resp: list | None = None):
+    global Aster
+
+    previous_notional_obj = Aster.notional_obj
+    previous_notional_position = Aster.notional_position
+
+    if resp:
+        pos_dict = [x for x in resp if x.get('symbol', None) == Aster.symbol]
+        if pos_dict:
+            pos_dict = pos_dict[0]
+        else:
+            pos_dict = {}
+            pos_dict['side'] = 'LONG'
+            pos_dict['entry_price'] = 0.00
+            pos_dict['position_amount'] = 0.00
+            pos_dict['unrealized_pnl'] = 0.00
+            pos_dict['timestamp_arrival'] = round(datetime.now().timestamp()*1000)
+            # logging.info('get_aster_notional - No Positions')
+    else:
+        logging.info('Getting Aster Notionals from API')
+        fut_acct_positionRisk: dict = {
+            "url": "/fapi/v3/positionRisk",
+            "method": "GET",
+            "params": {
+                'symbol': Aster.symbol,
+            }
+        }
+        try:
+            resp: list = await aster_auth.post_authenticated_url(req=fut_acct_positionRisk)  # ty:ignore[invalid-assignment]
+        except Exception as e:
+            logging.critical(f'JSONDecodeError trying to get Aster notional: {e}; resp: {resp}')
+            await kill_algo()
+            resp: list = []
+        pos_dict = [x for x in resp if x.get('symbol', None) == Aster.symbol]
+        if pos_dict:
+            pos_dict = pos_dict[0]
+        else:
+            pos_dict = {}
+            pos_dict['side'] = 'LONG'
+            pos_dict['entry_price'] = 0.00
+            pos_dict['position_amount'] = 0.00
+            pos_dict['unrealized_pnl'] = 0.00
+            logging.info('get_aster_notional - No Positions')
+        pos_dict['timestamp_arrival'] = round(datetime.now().timestamp()*1000)
+
+    if previous_notional_obj:
+        if previous_notional_obj['timestamp_arrival'] > pos_dict['timestamp_arrival']:
+            # logging.info(f'ASTER NOTIONAL: prev timestamp ({pd.to_datetime(previous_notional_obj['timestamp_arrival'], unit='ms')}) > new timestamp ({pd.to_datetime(pos_dict['timestamp_arrival'], unit='ms')}); skipping')
+            return
+    
+    Aster.notional_obj = pos_dict
+    
+    if len(pos_dict) < 1:
+        logging.info(f'BAD NOTIONAL - ASTER CHANGE: Empty pos_dict: {pos_dict}; resp: {resp}')
+        await kill_algo()
+
+    Aster.unrealized_pnl = float(pos_dict['unrealized_pnl']) if pos_dict.get('unrealized_pnl') is not None else float(pos_dict['unRealizedProfit'])
+    
+    if pos_dict.get('notional') is not None:
+        Aster.notional_position = float(pos_dict['notional']) - Aster.unrealized_pnl
+    else:
+        Aster.notional_position = float(pos_dict['position_amount'])*float(pos_dict['entry_price'])
+    if pos_dict.get('leverage') is not None:
+        Aster.mult = int(pos_dict['leverage'])
+    if abs(Aster.notional_position) > Config.Config.Max_Target_Notional*Config.Config.Max_Order_Over_Notional_Ratio:
+        logging.info(f'BAD NOTIONAL - ASTER CHANGE: {previous_notional_position} -> {Aster.notional_position}; UR PNL: {Aster.unrealized_pnl}; MULT: {Aster.mult}; pos_dict: {pos_dict}; resp: {resp}; max_tgt_notional: {Config.Config.Max_Target_Notional}')
+        await kill_algo()
+    if Aster.notional_position != previous_notional_position:
+        logging.info(f'ASTER NOTIONAL CHANGE: {previous_notional_position:.2f} -> {Aster.notional_position:.2f}; UR PNL: {Aster.unrealized_pnl:.2f}; MULT: {Aster.mult:.0f}; resp: {bool(resp)}')
+
+async def get_extend_account_open_symbols() -> list[str]:
+    resp = dict(await EXTEND_CLIENT.account.get_positions()).get('data', [])
+    ld = [x.market for x in list(resp) if abs(float(x.size)) > 0]
+    return ld
+
+async def set_comb_open_symbols() -> None:
+    global Open_Symbols
+    
+    open_aster_symbols = await get_aster_account_open_symbols()
+    open_extend_symbols = await get_extend_account_open_symbols()
+    
+    Open_Symbols = list(set(open_aster_symbols + open_extend_symbols))
+
+async def get_extend_notional(resp: list | None = None):
+    global Extend
+
+    previous_notional_obj = Extend.notional_obj
+    previous_notional_position = Extend.notional_position
+
+    if not resp:
+        resp = dict(await EXTEND_CLIENT.account.get_positions()).get('data', [])
+        pos_dict = [dict(d) for d in resp if dict(d).get('market') == Extend.symbol]
+        if pos_dict:
+            pos_dict = pos_dict[0]
+            pos_dict['timestamp_arrival'] = round(datetime.now().timestamp()*1000)
+        else:
+            pos_dict = {}
+            pos_dict['side'] = 'LONG'
+            pos_dict['value'] = 0.00
+            pos_dict['unrealised_pnl'] = 0.00
+            pos_dict['timestamp_arrival'] = round(datetime.now().timestamp()*1000)
+            logging.info('get_extend_notional - No Positions')
+    else:
+        pos_dict = [dict(d) for d in resp if dict(d).get('market') == Extend.symbol]
+        if pos_dict:
+            pos_dict = pos_dict[0]
+        else:
+            pos_dict = {}
+            pos_dict['side'] = 'LONG'
+            pos_dict['value'] = 0.00
+            pos_dict['unrealised_pnl'] = 0.00
+            pos_dict['timestamp_arrival'] = round(datetime.now().timestamp()*1000)
+            # logging.info('get_extend_notional - No Positions')
+        
+        # pos_dict['timestamp_arrival'] = round(datetime.now().timestamp()*1000)
+
+    if previous_notional_obj:
+        if previous_notional_obj['timestamp_arrival'] > pos_dict['timestamp_arrival']:
+            # logging.info(f'EXTEND NOTIONAL: prev timestamp ({pd.to_datetime(previous_notional_obj['timestamp_arrival'], unit='ms')}) > new timestamp ({pd.to_datetime(pos_dict['timestamp_arrival'], unit='ms')}); skipping')
+            return
+    else:
+        previous_notional_obj = {}
+    
+    Extend.notional_obj = pos_dict
+
+    Extend.unrealized_pnl = pos_dict.get('unrealised_pnl', 0)
+    position_side = pos_dict['side'] # LONG or SHORT
+    notional_pos_abs = abs(float(pos_dict['value']))
+    if position_side == 'LONG':
+        notional_pos_sided = notional_pos_abs
+    elif position_side == 'SHORT':
+        notional_pos_sided = notional_pos_abs * -1
+    else:
+        logging.info(f'EXTEND BAD SIDE ON POSITION UPDATE: {pos_dict}')
+
+    Extend.notional_position = notional_pos_sided - float(Extend.unrealized_pnl)
+    Extend.mult = pos_dict.get('leverage', Extend.mult)
+    if abs(Extend.notional_position) > Config.Config.Max_Target_Notional*Config.Config.Max_Order_Over_Notional_Ratio:
+        logging.info(f'BAD NOTIONAL - EXTEND CHANGE: {previous_notional_position} -> {Extend.notional_position}; UR PNL: {Extend.unrealized_pnl}; MULT: {Extend.mult}; pos_dict: {pos_dict}; resp: {resp}')
+        await kill_algo()
+    if Extend.notional_position != previous_notional_position:
+        logging.info(f'EXTEND NOTIONAL CHANGE: {previous_notional_position} [{previous_notional_obj.get('timestamp_arrival')}] -> {Extend.notional_position:.2f} [{Extend.notional_obj['timestamp_arrival']}]; UR PNL: {Extend.unrealized_pnl:.2f}; MULT: {Extend.mult}; resp: {bool(resp)}')
+
+### EXCHANGE INFO ###
+async def get_aster_exch_info(symbol_override: str | None = None):
+    global Aster
+    
+    if symbol_override:
+        Aster.symbol = utils.symbol_to_aster_fmt(symbol_override)
+
+    fut_acct_exchangeInfo: dict = {
+        "url": "/fapi/v3/exchangeInfo",
+        "method": "GET",
+        "params": {}
+    }
+    r: dict = await aster_auth.post_authenticated_url(fut_acct_exchangeInfo)  # ty:ignore[invalid-assignment]
+    s: list = r['symbols']
+    d: dict = [d for d in s if d.get('symbol', None) == Aster.symbol][0]
+    f: dict = [f for f in d['filters'] if f.get('filterType', None) == 'LOT_SIZE'][0]
+    q: dict = [f for f in d['filters'] if f.get('filterType', None) == 'PRICE_FILTER'][0]
+    n: dict = [f for f in d['filters'] if f.get('filterType', None) == 'MIN_NOTIONAL'][0]
+    
+    min_qty = float(f['minQty'])
+    min_qty = int(min_qty) if min_qty == int(min_qty) else min_qty
+    
+    min_price = float(q['minPrice'])
+    min_price = int(min_price) if min_price == int(min_price) else min_price
+    Aster.min_order_size = min_qty
+    Aster.min_price = min_price
+    Aster.min_notional = float(n['notional'])
+
+async def get_extend_exch_info(symbol_override: str | None = None):
+    global Extend
+    
+    if symbol_override:
+        Extend.symbol = utils.symbol_to_extend_fmt(symbol_override)
+
+    r = await EXTEND_CLIENT.markets_info.get_markets_dict() 
+    Extend.min_order_size = float(r[Extend.symbol].trading_config.min_order_size)
+    Extend.min_price = float(r[Extend.symbol].trading_config.min_price_change)
+
+### CANCEL ORDERS ###
+async def aster_cancel_all_orders():
+    cancel_all_open_orders = {
+        "url": "/fapi/v3/allOpenOrders",
+        "method": "DELETE",
+        "params": {
+            'symbol': Aster.symbol,
+        }
+    }
+    r = await aster_auth.post_authenticated_url(cancel_all_open_orders)
+    logging.info(f'ASTER CANCEL ALL OPEN ORDERS RESP: {r}')
+
+async def extend_cancel_all_orders():
+    r = await EXTEND_CLIENT.orders.mass_cancel(markets=[Extend.symbol])
+    logging.info(f'EXTEND CANCEL ALL OPEN ORDERS RESP: {r}')
+
+### KILL ALGO ###
+async def kill_algo():
+    await aster_cancel_all_orders()
+    await extend_cancel_all_orders()
+    logging.info('ALGO KILL FLAG ACTIVATED; CANCELLING OPEN ORDERS AND SHUTTING DOWN')
+    raise ValueError('KILL FLAG ACTIVATED')
+
+### ALGO LOOP ###
+async def run_algo():
+    global Config
+
+    global Aster
+    global Extend
+
+    global Open_Symbols
+    global Last_Aster_Fill_Time_Ts
+    global Just_Rejected_Or_Expired
+
+    global Aster_Open_Orders
+    global Extend_Open_Orders
+
+    # global Flags
+
+    try:
+        while True:
+            loop_start = time.time()
+            # print('__________Start___________')
+            
+            ### Load Algo Config ###
+            Config = json.loads(VAL_KEY.get('fr_orchestrator_output')) # ty:ignore[invalid-argument-type]
+            Config = structs.Algo_Config(**Config)
+            Config.Config.Max_Target_Notional = float(min([Aster.mult, Extend.mult]) * Config.Config.Target_Open_Cash_Position)
+
+            ### Load Data from Feedhandlers ###
+            best_symbol_by_exchange: dict = json.loads(s=VAL_KEY.get(name='fr_engine_best_fund_rate_output'))  # ty:ignore[invalid-argument-type]
+            best_symbol_by_exchange_aster = structs.Perpetual_Exchange(**best_symbol_by_exchange['ASTER'])
+            best_symbol_by_exchange_extend = structs.Perpetual_Exchange(**best_symbol_by_exchange['EXTEND'])
+
+            # Fund Rates
+            # aster_fund_rate_dict: Any = VAL_KEY.get('fund_rate_aster')
+            # aster_fund_rate_dict: dict = json.loads(s=aster_fund_rate_dict) if aster_fund_rate_dict is not None else {}
+            # if aster_fund_rate_dict.get('symbol', None) != Aster.symbol:
+            #     aster_fund_rate: float = Aster.initial_funding_rate
+            #     # logging.info(f'ASTER Symbol mismatch: {ASTER_FUND_RATE_DICT}; expected symbol: {ASTER.symbol}')
+            #     # raise ValueError(f'ASTER Symbol mismatch: {ASTER_FUND_RATE_DICT}; expected symbol: {ASTER.symbol}')
+            # else:
+            #     aster_fund_rate: float = float(aster_fund_rate_dict.get('funding_rate', 0))
+
+            # extend_fund_rate_dict: Any = VAL_KEY.get('fund_rate_extended')
+            # extend_fund_rate_dict: dict = json.loads(s=extend_fund_rate_dict) if extend_fund_rate_dict is not None else {}
+            # if extend_fund_rate_dict.get('symbol', None) != Extend.symbol:
+            #     extend_fund_rate: float = Extend.initial_funding_rate
+            #     # logging.info(f'ASTER Symbol mismatch: {EXTENDED_FUND_RATE_DICT}; expected symbol: {EXTEND.symbol}')
+            #     # raise ValueError(f'ASTER Symbol mismatch: {EXTENDED_FUND_RATE_DICT}; expected symbol: {EXTEND.symbol}')
+            # else:
+            #     extend_fund_rate: float = float(extend_fund_rate_dict.get('funding_rate', 0))
+
+            # if Config.Overrides.Flip_Side_For_Testing:
+            #     aster_fund_rate = aster_fund_rate * -1
+            #     extend_fund_rate = extend_fund_rate * -1
+
+            # aster_fund_rate_time = float(aster_fund_rate_dict.get('next_funding_time_ts_ms', 0))
+            # aster_fund_rate_time = aster_fund_rate_time+(60*60*1000) if aster_fund_rate_time < (datetime.now().timestamp()*1000) else aster_fund_rate_time
+
+            # extend_fund_rate_time = max([float(extend_fund_rate_dict.get('next_funding_time_ts_ms', 0)), 0])
+            # extend_fund_rate_time = extend_fund_rate_time+(60*60*1000) if extend_fund_rate_time < (datetime.now().timestamp()*1000) else extend_fund_rate_time
+            
+            # Tickers
+            aster_ticker_dict: Any = VAL_KEY.get('fut_ticker_aster')
+            aster_ticker_dict: dict = json.loads(s=aster_ticker_dict) if aster_ticker_dict is not None else {}
+            if ( aster_ticker_dict.get('symbol', None) != Aster.symbol ) and not(Config.Overrides.Flatten_Open_Positions):
+                    logging.warning(f'ASTER Symbol mismatch: {aster_ticker_dict}; expected symbol: {Aster.symbol}')
+                    VAL_KEY.set(name='fr_algo_working_symbol', value=json.dumps(obj={'ASTER': asdict(obj=Aster), 'EXTEND': asdict(obj=Extend)}))
+                    time.sleep(5)
+                    continue
+                    # raise ValueError(f'ASTER Symbol mismatch: {ASTER_TICKER_DICT}; expected symbol: {ASTER.symbol}')
+
+            extend_ticker_dict: Any = VAL_KEY.get('fut_ticker_extended')
+            extend_ticker_dict: dict = json.loads(s=extend_ticker_dict) if extend_ticker_dict is not None else {}
+            if ( extend_ticker_dict.get('symbol', None) != Extend.symbol) and not(Config.Overrides.Flatten_Open_Positions):
+                    logging.warning(f'EXTEND Symbol mismatch: {extend_ticker_dict}; expected symbol: {Extend.symbol}')
+                    VAL_KEY.set(name='fr_algo_working_symbol', value=json.dumps(obj={'ASTER': asdict(obj=Aster), 'EXTEND': asdict(obj=Extend)}))
+                    time.sleep(5)
+                    continue
+                    # raise ValueError(f'EXTEND Symbol mismatch: {EXTENDED_TICKER_DICT}; expected symbol: {EXTEND.symbol}')
+
+            ### Load Local Notional Updates from WS ###
+            aster_ws_pos_updates: Any = VAL_KEY.get(name='fr_aster_user_positions')
+            aster_ws_pos_updates: list = json.loads(s=aster_ws_pos_updates) if aster_ws_pos_updates is not None else []
+            extend_ws_pos_updates: Any = VAL_KEY.get('fr_extended_user_positions')
+            extend_ws_pos_updates: list = json.loads(extend_ws_pos_updates) if extend_ws_pos_updates is not None else [] 
+
+            if len(aster_ws_pos_updates) > 0:
+                await get_aster_notional_position(resp=aster_ws_pos_updates)
+            
+            if len(extend_ws_pos_updates) > 0:
+                await get_extend_notional(resp=extend_ws_pos_updates)
+
+            ### Load Local Order Updates from WS ###
+            aster_ws_order_updates: Any = VAL_KEY.get('fr_aster_user_orders')
+            aster_ws_order_updates: list = json.loads(aster_ws_order_updates) if aster_ws_order_updates is not None else [] 
+            extend_ws_order_updates: Any = VAL_KEY.get('fr_extended_user_orders')
+            extend_ws_order_updates: list = json.loads(extend_ws_order_updates) if extend_ws_order_updates is not None else [] 
+            
+            ### CHECK NO MORE THAN 1 OPEN ORDER ON EITHER EXCHANGE ###
+            if len(Aster_Open_Orders) > 1 or len(Extend_Open_Orders) > 1:
+                logging.info(f'MORE THAN 1 ORDER OPEN - KILLING ALGO: ASTER_OPEN_ORDERS ({len(Aster_Open_Orders)}): {Aster_Open_Orders}; EXTEND_OPEN_ORDERS ({len(Extend_Open_Orders)}): {Extend_Open_Orders}')
+                await kill_algo()
+                raise ValueError('NOT HERE: MORE THAN 1 ORDER OPEN - KILLING ALGO: ASTER_OPEN_ORDERS')
+
+            ### Update Local Open Orders w Changes from WS ###
+            Aster_Open_Orders = await handle_order_updates(exch='ASTER', local_open_orders=Aster_Open_Orders, ws_open_orders=aster_ws_order_updates)
+            Extend_Open_Orders = await handle_order_updates(exch='EXTEND', local_open_orders=Extend_Open_Orders, ws_open_orders=extend_ws_order_updates)
+
+            ### Decisions ###
+            
+    
+
+            ### Logging ###
+            def print_summary(use_logging: bool = False):
+                OUT: Any = logging.info if use_logging else print
+                
+                # ASTER: [ Available Collateral: {ASTER_AVAIL_COLLATERAL:.4f} ]     | EXTEND: [ Available Collateral: {EXTEND_AVAIL_COLLATERAL:.4f} ]
+                OUT(f'''
+                FLIP SIDES FOR TESTING?: {Config.Overrides.Flip_Side_For_Testing}; ASTER ORDER ENABLED? {Config.Overrides.Allow_Ordering_Aster}; EXTEND ORDER ENABLED? {Config.Overrides.Allow_Ordering_Extend}
+                
+                MKT  : Aster: {Aster.symbol:<10} (best: {best_symbol_by_exchange_aster.symbol})       | Extend: {Extend.symbol:<10} (best: {best_symbol_by_exchange_extend.symbol})
+                {pd.to_datetime(aster_fund_rate_time, unit='ms')} ({(pd.to_datetime(aster_fund_rate_time, unit='ms')-datetime.now()):})   | {pd.to_datetime(extend_fund_rate_time, unit='ms')} ({(pd.to_datetime(extend_fund_rate_time, unit='ms')-datetime.now()):})
+                ASTER: {aster_fund_rate:.6%} [{aster_fund_rate*10_000:.2f}bps] [{aster_fund_rate*1_000_000:.0f}pips]           | EXTEND: {extend_fund_rate:.6%} [{extend_fund_rate*10_000:.2f}bps] [{extend_fund_rate*1_000_000:.0f}pips]
+                ASTER: {'LONG PAYS SHORT' if aster_fund_rate > 0 else 'SHORT PAYS LONG'}                         | EXTEND: {'LONG PAYS SHORT' if extend_fund_rate > 0 else 'SHORT PAYS LONG'}
+                ASTER: [ Notional Position $ : {Aster.notional_position:.4f} ]        | EXTEND: [ Notional Position $ : {Extend.notional_position:.4f} ]
+                
+                ALPHA SIDE  : {ALPHA_EXCH} [{ALPHA_CARRY_SIDE}]
+                ALPHA SIGNAL: {alpha_signal}; Current {current_ratio:.4f} [{current_ratio*10_000:.2f}scl] {">" if ALPHA_CARRY_SIDE=='BUY' else "<"} Model {alpha_model_ratio:.4f} [{alpha_model_ratio*10_000:.2f}scl]
+
+                TGT NOTIONAL: $ {abs(ALPHA_TGT_NOTIONAL_FINAL):.2f}; Flatten Open Positions Flag? {Config.Overrides.Flatten_Open_Positions}; Opportunistic? {Config.Overrides.Flatten_Open_Positions_Opportunistic}
+                AT TARGET?  : {at_notional_target.value}; is_locked?: {at_notional_target.is_locked}
+
+
+                --- ASTER OPEN ORDERS  ---
+                    {Aster_Open_Orders}
+                
+                --- EXTEND OPEN ORDERS ---
+                    {Extend_Open_Orders}
+                ''')
+            if Config.Logging.Log_Summary_Each_Loop:
+                print_summary(use_logging=True)
+            if Config.Logging.Print_Summary_Each_Loop:
+                print_summary(use_logging=False)
+
+            ### ASTER 
+            if Config.Overrides.Allow_Ordering_Aster and ASTER_TGT_TAIL_ORDERABLE: # Tier 1 Overrides
+                if alpha_signal or Config.Overrides.Flatten_Open_Positions: # Tier 2 Overrides / Alpha
+                    skip = False
+                    side = 'BUY' if ASTER_TGT_TAIL_BASE_QTY > 0.00 else 'SELL'
+                    qty = Decimal(value=str(abs(ASTER_TGT_TAIL_BASE_QTY)))
+                    price = ASTER_TOB_PX - ( float(Aster.min_price)*int(Config.Config.Price_Worsener_Aster) ) if side == 'BUY' else ASTER_TOB_PX + ( float(Aster.min_price)*int(Config.Config.Price_Worsener_Aster) )
+                    
+                    if abs( ( float(ASTER_TGT_TAIL_BASE_QTY)*float(price) ) + Aster.notional_position ) > Config.Config.Max_Target_Notional*Config.Config.Max_Order_Over_Notional_Ratio:
+                        logging.info(f'TRYING TO ORDER OVER MAX NOTIOANL - ASTER: {Aster.notional_position} + {float(ASTER_TGT_TAIL_BASE_QTY)*float(price)} (qty: {float(ASTER_TGT_TAIL_BASE_QTY):.2f}; px: {float(price):.2f})')
+                        await kill_algo()
+                    
+                    if Aster_Open_Orders: # Cancel Open Order?
+                        open_order_id = Aster_Open_Orders[0].get('order_id') if Aster_Open_Orders[0].get('order_id') is not None else Aster_Open_Orders[0]['orderId']
+                        open_order_px = float(Aster_Open_Orders[0].get('price',0)) if Aster_Open_Orders[0].get('price') is not None else float(Aster_Open_Orders[0]['original_price'])
+                       
+                        open_order_dict = dict(Aster_Open_Orders[0])
+                        open_order_id = str(open_order_dict['order_id'])
+                        open_order_px = float(open_order_dict['price'])
+                        
+                        min_price = Aster.min_price
+                        min_price = int(min_price) if min_price == int(min_price) else min_price
+                        if Decimal(str( float(open_order_px) - float(price) )).quantize(Decimal(str(min_price)), rounding=ROUND_HALF_UP) == 0.00:
+                            if Config.Logging.Print_Summary_Each_Loop:
+                                print('ASTER OPEN ORDER NO PX CHG; SKIPPING')
+                                skip = True
+                        else:
+                            await cancel_aster_order(open_order_id)  # ty:ignore[invalid-argument-type]
+
+                    if ASTER_TGT_TAIL_BASE_QTY == 0.00:
+                        logging.info('ASTER TRYNG TO ORDER 0.00 BASE QTY, SKIPPING')
+                        skip = True
+
+                    if not skip:
+                        min_price = Aster.min_price
+                        min_price = int(min_price) if min_price == int(min_price) else min_price
+                        price: Decimal = Decimal(str(price)).quantize(Decimal(str(min_price)), rounding=ROUND_HALF_UP)
+
+                        if price == Decimal(str(0.00)).quantize(Decimal(str(min_price)), rounding=ROUND_HALF_UP):
+                            logging.info('ASTER TRYNG TO ORDER with A PRICE OF 0.00, SKIPPING')
+                            continue 
+                        
+                        if ( qty < Aster.min_order_size ) or ( (qty*price) < Aster.min_notional ):
+                            reduceOnly = True
+                        else:
+                            reduceOnly = False
+
+                        await post_aster_order(
+                            symbol=Aster.symbol,
+                            side=side,
+                            qty=qty,
+                            price=price,
+                            reduceOnly=reduceOnly,
+                            postOnly=True,
+                        )
+                    else:
+                        pass
+            elif not(ASTER_TGT_TAIL_ORDERABLE) and Aster_Open_Orders:
+                logging.info('ASTER HAS NO TAIL BUT OPEN ORDERS - CANCELLING OPEN ORDERS')
+                await extend_cancel_all_orders()
+            
+            ### EXTEND ###
+            if Config.Overrides.Allow_Ordering_Extend and EXTEND_TGT_TAIL_ORDERABLE: # Tier 1 Overrides
+                if alpha_signal or Config.Overrides.Flatten_Open_Positions: # Tier 2 Overrides / Alpha
+                    skip = False
+                    side = 'BUY' if EXTEND_TGT_TAIL_BASE_QTY > 0.00 else 'SELL'
+                    qty = Decimal(value=str(abs(EXTEND_TGT_TAIL_BASE_QTY)))
+                    price = EXTEND_TOB_PX - ( float(Extend.min_price)*int(Config.Config.Price_Worsener_Extend) ) if side == 'BUY' else EXTEND_TOB_PX + ( float(Extend.min_price)*int(Config.Config.Price_Worsener_Extend) )  # ty:ignore[invalid-assignment]
+                    
+                    if abs( ( float(EXTEND_TGT_TAIL_BASE_QTY)*float(price) ) + Extend.notional_position ) > Config.Config.Max_Target_Notional*Config.Config.Max_Order_Over_Notional_Ratio:
+                        logging.info(f'TRYING TO ORDER OVER MAX NOTIOANL - EXTEND: {Extend.notional_position} + {float(EXTEND_TGT_TAIL_BASE_QTY)*float(price)} (qty: {float(EXTEND_TGT_TAIL_BASE_QTY):.2f}; px: {float(price):.2f})')
+                        await kill_algo()
+                    
+                    if Extend_Open_Orders: # Cancel Open Order?
+                        open_order_dict = dict(Extend_Open_Orders[0])
+                        open_order_id = str(open_order_dict['external_id'])
+                        open_order_px = float(open_order_dict['price'])
+
+                        min_price = Extend.min_price
+                        min_price = int(min_price) if min_price == int(min_price) else min_price
+                        if Decimal(str( float(open_order_px) - float(price) )).quantize(Decimal(str(min_price)), rounding=ROUND_HALF_UP) == 0.00:
+                            if Config.Logging.Print_Summary_Each_Loop:
+                                print('EXTEND OPEN ORDER NO PX CHG; SKIPPING')
+                                skip = True
+                    else:
+                        open_order_id = None
+
+                    if EXTEND_TGT_TAIL_BASE_QTY == 0.00:
+                        logging.info('EXTEND TRYNG TO ORDER 0.00 BASE QTY, SKIPPING')
+                        skip = True
+
+                    if not skip:
+                        min_price = Extend.min_price
+                        min_price = int(min_price) if min_price == int(min_price) else min_price
+                        price: Decimal = Decimal(str(price)).quantize(Decimal(str(min_price)), rounding=ROUND_HALF_UP)
+
+                        if price == Decimal(str(0.00)).quantize(Decimal(str(min_price)), rounding=ROUND_HALF_UP):
+                            logging.info('EXTEND TRYNG TO ORDER with A PRICE OF 0.00, SKIPPING')
+                            continue 
+                        
+                        if ( qty < Extend.min_order_size ) or ( (qty*price) < Extend.min_notional ):
+                            reduceOnly = True
+                        else:
+                            reduceOnly = False
+
+                        await post_extend_order(
+                            symbol=Extend.symbol,
+                            side=side,
+                            qty=qty,
+                            price=price,
+                            reduceOnly=reduceOnly,
+                            postOnly=True,
+                            cxl_prev_order_id=open_order_id
+                        )
+                    else:
+                        pass
+            elif not(EXTEND_TGT_TAIL_ORDERABLE) and Extend_Open_Orders:
+                logging.info('EXTEND HAS NO TAIL BUT OPEN ORDERS - CANCELLING OPEN ORDERS')
+                await extend_cancel_all_orders()
+
+            ### Continue immediately or sleep ###
+            if Aster_Open_Orders or Extend_Open_Orders:
+                if Config.Logging.Print_Summary_Each_Loop:
+                    print(f'_____ Open Orders _____ (Algo Engine ms: {(time.time() - loop_start)*1000:.2f}); Continuing...')
+                continue
+            else:
+                if Config.Logging.Print_Summary_Each_Loop:
+                    print(f'_____ End No Open Orders _____ (Algo Engine ms: {(time.time() - loop_start)*1000:.2f}); Sleeping for sec: {Config.Config.Loop_Sleep_Sec:.0f}')
+                time.sleep(Config.Config.Loop_Sleep_Sec)
+    except KeyboardInterrupt:
+        logging.info('CANCELLING OPEN ORDERS')
+        await kill_algo()
+    except Exception as e:
+        logging.error(traceback.format_exc())
+        logging.critical(f'*** ALGO ENGINE CRASHED: {e}')
+        logging.info('CANCELLING OPEN ORDERS')
+        utils.send_tg_alert(f'FR_ALGO_CRASHED: {str(e)}')
+        await kill_algo()
+
+### MAIN STARTUP ###
+async def main():
+    global EXTEND_CLIENT
+    global VAL_KEY
+    global CON
+    global Config
+    global Aster
+    global Extend
+    global Open_Symbols
+
+
+    _, EXTEND_CLIENT = await extend_auth.create_auth_account_and_trading_client()
+    VAL_KEY = valkey.Valkey(host='localhost', port=6379, db=0, decode_responses=True)
+    engine = create_async_engine('mysql+asyncmy://root:pwd@localhost/fund_rate')
+
+    await set_comb_open_symbols()
+    
+    best_symbol_by_exchange: dict = json.loads(s=VAL_KEY.get(name='fr_engine_best_fund_rate_output'))  # ty:ignore[invalid-argument-type]
+    if Open_Symbols:
+        logging.info(f'OPEN SYMBOLS: {Open_Symbols}')
+        master_data = json.loads(s=VAL_KEY.get(name='fr_engine_best_fund_rate_master'))  # ty:ignore[invalid-argument-type]
+        open_symbol_to_work = Open_Symbols[0]
+        current_pos_master_ast = [d for d in master_data if d.get('symbol_ext') == open_symbol_to_work][0]
+        Aster = structs.Perpetual_Exchange(
+            mult = int(current_pos_master_ast['max_leverage_ast']),
+            lh_asset = current_pos_master_ast['lh_asset_ast'],
+            rh_asset = current_pos_master_ast['rh_asset_ast'],
+            symbol_asset_separator = '',
+            initial_funding_rate=float(current_pos_master_ast['funding_rate_ast']),
+            min_price=float(current_pos_master_ast['min_price_ast']),
+            min_order_size=float(current_pos_master_ast['min_order_size_ast']),
+            min_lot_size=float(current_pos_master_ast['min_lot_size_ast']),
+            min_notional=float(current_pos_master_ast['min_notional_ast']),
+            buy_ratio=float(current_pos_master_ast['buy_ratio_ast']),
+        )
+        Extend = structs.Perpetual_Exchange(
+            mult = int(current_pos_master_ast['max_leverage_ext']),
+            lh_asset = current_pos_master_ast['lh_asset_ext'],
+            rh_asset = current_pos_master_ast['rh_asset_ext'],
+            symbol_asset_separator = '-',
+            initial_funding_rate=float(current_pos_master_ast['funding_rate_ext']),
+            min_price=float(current_pos_master_ast['min_price_ext']),
+            min_order_size=float(current_pos_master_ast['min_order_size_ext']),
+            min_lot_size=float(current_pos_master_ast['min_lot_size_ext']),
+            min_notional=float(current_pos_master_ast['min_notional_ext']),
+            buy_ratio=float(current_pos_master_ast['buy_ratio_ext']),
+        )
+        Open_Symbols.pop(0)
+    else:
+        Aster = structs.Perpetual_Exchange(**best_symbol_by_exchange['ASTER'])
+        Extend = structs.Perpetual_Exchange(**best_symbol_by_exchange['EXTEND'])
+        
+        # await get_aster_exch_info(symbol_override=Open_Symbols[0])
+        # await get_extend_exch_info(symbol_override=Open_Symbols[0])
+
+    with open('algo_config.json', mode='r', encoding='utf-8') as file:
+        Config = json.load(file)
+        Config = structs.Algo_Config(**Config)
+
+    Config.Config.Max_Target_Notional = float(min([Aster.mult, Extend.mult]) * Config.Config.Target_Open_Cash_Position)
+    # logging.info(f'Initial Algo Config: {ALGO_CONFIG}')
+
+    VAL_KEY.set(name='fr_orchestrator_output', value=json.dumps(obj=Config.model_dump()))
+    VAL_KEY.set(name='fr_algo_working_symbol', value=json.dumps(obj={'ASTER': asdict(obj=Aster), 'EXTEND': asdict(obj=Extend)}))
+
+    async with engine.connect() as CON:
+        ### ASTER SETUP ###
+        # await get_aster_collateral()
+        await get_aster_notional_position()
+        await get_aster_exch_info()
+        await get_aster_open_orders()
+        ### EXTEND SETUP ###
+        # await get_extend_collateral()
+        await get_extend_notional()
+        await get_extend_exch_info()
+        await get_extend_open_orders()
+
+        await run_algo()
+
+if __name__ == '__main__':
+    START_TIME = round(datetime.now().timestamp()*1000)
+
+    logging.info(f'Log FilePath: {LOG_FILEPATH}')
+
+    logging.basicConfig(
+        force=True,
+        filename=LOG_FILEPATH,
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s',
+        filemode='w'
+    )
+    logging.info(f"STARTED: {START_TIME}")
+
+    asyncio.run(main())

modules/structs.py

@@ -1,4 +1,3 @@
-from rel.rel import init
 import json
 from dataclasses import dataclass, field
 from typing import Any
@@ -6,6 +5,93 @@ from typing import Any
 import valkey
 from pydantic import BaseModel
 
+from sqlalchemy.util.typing import Self
+from collections.abc import Sequence, Callable
+
+def ret_true():
+    return True
+
+class Locked_Value(Sequence):
+    def __init__(self, initial_value: Any = None, unlock_func: Callable=ret_true):
+        self._value: Any = initial_value
+        self._unlock_func: Callable = unlock_func
+        self._is_locked: bool = True
+
+    def __repr__(self):
+        return str((self._value, self._is_locked, self._unlock_func))
+
+    def __len__(self):
+        return len((self._value, self._is_locked, self._unlock_func))
+
+    def __getitem__(self, index):
+        return (self._value, self._is_locked, self._unlock_func)[index]
+
+    def __str__(self):
+        return str((self._value))
+
+    def unlock(self) -> Self:
+        if self._unlock_func():
+            self._is_locked = False
+        return self
+
+    def lock(self) -> Self:
+        self._is_locked = True
+        return self
+
+    @property
+    def is_locked(self):
+        return self._is_locked
+
+    @property
+    def is_unlocked(self):
+        return not(self._is_locked)
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, v):
+        if not(self._is_locked):
+            self._value = v
+        else:
+            raise ValueError(f'Failed to set value, item is locked: {str(self.__repr__)}')
+
+
+class Current_Previous_Value:
+    def __init__(self, value: Any = None, previous_value: Any = None):
+        self._value: Any = value
+        self._previous_value: Any = previous_value
+
+    def __repr__(self):
+        return str((self._value, self._previous_value))
+
+    def __len__(self):
+        return len((self._value, self._previous_value))
+
+    def __getitem__(self, index):
+        return (self._value, self._previous_value)[index]
+
+    def __str__(self):
+        return str(self._value)
+
+    @property
+    def value(self):
+        return self._value
+
+    @property
+    def previous_value(self):
+        return self._previous_value
+
+    @value.setter
+    def value(self, v):
+        self._previous_value = self._value
+        self._value = v
+
+
+
+
+
 # @dataclass(kw_only=True)
 class Algo_Config_Overrides(BaseModel):
     Allow_Ordering_Aster: bool
@@ -171,6 +257,10 @@ class Perpetual_Exchange:
     min_order_size: float = 0
     min_lot_size: float = 0
     min_notional: float = 0
+    buy_ratio: float = 0
+    notional_obj: dict = field(default_factory=dict)
+    notional_position: float = 0
+    unrealized_pnl: float = 0
 
     # async def update(self):
     #     await self.Collateral_Updates.update()