Grid Trading Bot: Build a Self-Replenishing Grid Bot for LMEX in Python

from dataclasses import dataclass

@dataclass
class GridConfig:
    symbol: str = 'BTC-PERP'
    lower_price: float = 55000
    upper_price: float = 65000
    num_levels: int = 20
    capital_per_level: float = 500  # USD value per buy order
    
    @property
    def spacing(self):
        return (self.upper_price - self.lower_price) / (self.num_levels - 1)
    
    @property
    def levels(self):
        return [self.lower_price + i * self.spacing for i in range(self.num_levels)]

import ccxt

exchange = ccxt.lmex({'apiKey': '...', 'secret': '...'})

def place_initial_grid(config: GridConfig):
    current_price = exchange.fetch_ticker(config.symbol)['last']
    orders = []
    
    for level_price in config.levels:
        # Skip levels too close to current price
        if abs(level_price - current_price) < config.spacing / 2:
            continue
        
        qty = config.capital_per_level / level_price
        
        if level_price < current_price:
            order = exchange.create_order(
                config.symbol, 'limit', 'buy', qty, level_price,
                {'postOnly': True}
            )
        else:
            order = exchange.create_order(
                config.symbol, 'limit', 'sell', qty, level_price,
                {'postOnly': True}
            )
        
        orders.append({
            'orderId': order['id'],
            'level': level_price,
            'side': order['side'],
            'qty': qty,
        })
    
    return orders

def handle_fill(filled_order, config: GridConfig):
    filled_level = filled_order['level']
    filled_side = filled_order['side']
    
    if filled_side == 'buy':
        # Place sell at the level above
        new_level = filled_level + config.spacing
        if new_level <= config.upper_price:
            qty = filled_order['qty']
            order = exchange.create_order(
                config.symbol, 'limit', 'sell', qty, new_level,
                {'postOnly': True}
            )
            return {'orderId': order['id'], 'level': new_level, 'side': 'sell', 'qty': qty}
    
    elif filled_side == 'sell':
        # Place buy at the level below
        new_level = filled_level - config.spacing
        if new_level >= config.lower_price:
            qty = filled_order['qty']
            order = exchange.create_order(
                config.symbol, 'limit', 'buy', qty, new_level,
                {'postOnly': True}
            )
            return {'orderId': order['id'], 'level': new_level, 'side': 'buy', 'qty': qty}
    
    return None

import sqlite3
from datetime import datetime

class GridState:
    def __init__(self, db_path='grid_state.db'):
        self.conn = sqlite3.connect(db_path)
        self.conn.execute('''
            CREATE TABLE IF NOT EXISTS orders (
                order_id TEXT PRIMARY KEY,
                level REAL,
                side TEXT,
                qty REAL,
                status TEXT,
                created_at TEXT
            )
        ''')
        self.conn.commit()
    
    def add_order(self, order_id, level, side, qty):
        self.conn.execute(
            'INSERT INTO orders VALUES (?, ?, ?, ?, ?, ?)',
            (order_id, level, side, qty, 'open', datetime.utcnow().isoformat())
        )
        self.conn.commit()
    
    def mark_filled(self, order_id):
        self.conn.execute(
            "UPDATE orders SET status = 'filled' WHERE order_id = ?",
            (order_id,)
        )
        self.conn.commit()
    
    def get_open_orders(self):
        cursor = self.conn.execute(
            "SELECT * FROM orders WHERE status = 'open'"
        )
        return cursor.fetchall()

def reconcile_state(state: GridState, config: GridConfig):
    # Get local known-open orders
    local_orders = state.get_open_orders()
    local_ids = {o[0] for o in local_orders}
    
    # Get actual open orders from exchange
    actual_orders = exchange.fetch_open_orders(config.symbol)
    actual_ids = {o['id'] for o in actual_orders}
    
    # Find discrepancies
    locally_open_but_not_on_exchange = local_ids - actual_ids
    on_exchange_but_not_in_local = actual_ids - local_ids
    
    # Local says open but exchange doesn't have it = probably filled
    for order_id in locally_open_but_not_on_exchange:
        # Check trade history to confirm
        trades = exchange.fetch_my_trades(config.symbol, limit=200)
        if any(t['order'] == order_id for t in trades):
            state.mark_filled(order_id)
            # Replace with opposite-side order (catch up logic)
    
    # On exchange but not locally = pre-existing orders we don't track
    # Could be from a previous instance or manual placement
    # Decision: leave them alone, log warning
    if on_exchange_but_not_in_local:
        print(f"Warning: untracked orders on exchange: {on_exchange_but_not_in_local}")