트레이딩봇 LIVE 전환기 — PAPER에서 실전까지: 첫 실거래부터 호가 단위 삽질까지

class HedgingManager:
    def __init__(self, upbit_client, bybit_client):
        self.upbit = upbit_client
        self.bybit = bybit_client
    
    def execute_hedge(self, spot_order):
        """현물 주문에 대한 자동 헤징 실행"""
        # 1. 현물 체결 수량 확인
        spot_qty = spot_order['executed_qty']
        
        # 2. 헤징 비율 계산 (세부 구현 생략)
        hedge_ratio = self._calculate_hedge_ratio()
        
        # 3. Bybit 선물 숏 주문 실행
        hedge_qty = spot_qty * hedge_ratio
        futures_order = self.bybit.create_order(
            symbol='ETHUSDT',
            side='Sell',  # 숏 포지션
            type='Market',
            qty=hedge_qty
        )
        
        # 4. 포지션 추적 DB 저장
        self._save_position_tracking(spot_order, futures_order)
        
        return futures_order
    
    def _calculate_hedge_ratio(self):
        """동적 헤징 비율 계산 (영업비밀)"""
        # 시장 변동성, 자금 효율성, 리스크 허용도 기반 계산
        # 세부 구현 생략
        pass

class DCAOrderManager:
    def __init__(self, exchange_client):
        self.exchange = exchange_client
        self.pending_orders = {}
    
    def register_dca_ladders(self, symbol, base_price, budget):
        """DCA 6단계 지정가 주문 사전등록"""
        dca_levels = self._calculate_dca_levels(base_price)
        
        orders = []
        for level in dca_levels:
            order = self.exchange.create_limit_order(
                symbol=symbol,
                side='buy',
                price=level['price'],
                amount=level['amount']
            )
            orders.append(order)
            # 주문 추적
            self.pending_orders[order['id']] = {
                'level': level['stage'],
                'price': level['price'],
                'status': 'pending'
            }
        
        return orders
    
    def register_profit_taking(self, symbol, avg_price, quantity):
        """익절 지정가 주문 등록"""
        # 목표 수익률 기반 익절가 계산 (세부 구현 생략)
        target_price = self._calculate_target_price(avg_price)
        
        order = self.exchange.create_limit_order(
            symbol=symbol,
            side='sell',
            price=target_price,
            amount=quantity
        )
        
        return order
    
    def _calculate_dca_levels(self, base_price):
        """DCA 단계별 가격 및 수량 계산 (영업비밀)"""
        # 하락률 기반 단계별 진입가, 비중 계산
        # 세부 구현 생략
        pass

def round_to_tick_size(price: float, market: str = 'KRW') -> float:
    """
    Upbit 호가 단위에 맞춰 가격 반올림
    
    Args:
        price: 원하는 가격
        market: 시장 (KRW, BTC 등)
    
    Returns:
        호가 단위에 맞춰진 가격
    """
    if market == 'KRW':
        if price >= 2_000_000:
            tick = 1000
        elif price >= 1_000_000:
            tick = 500
        elif price >= 500_000:
            tick = 100
        elif price >= 100_000:
            tick = 50
        elif price >= 10_000:
            tick = 10
        elif price >= 1_000:
            tick = 1
        else:
            tick = 0.1
        
        # 반올림 (아래로)
        return int(price // tick) * tick
    
    # BTC, USDT 시장 등 추가 구현 가능
    return price


# 사용 예시
calculated_price = 3_287_543
valid_price = round_to_tick_size(calculated_price)
print(valid_price)  # 3,287,000

import time
from typing import Optional

def create_order_with_retry(
    exchange,
    symbol: str,
    side: str,
    price: float,
    amount: float,
    max_retries: int = 3
) -> Optional[dict]:
    """주문 생성 (재시도 + 호가 단위 자동 정규화)"""
    
    # 1. 호가 단위 정규화
    valid_price = round_to_tick_size(price)
    
    for attempt in range(max_retries):
        try:
            order = exchange.create_limit_order(
                symbol=symbol,
                side=side,
                price=valid_price,
                amount=amount
            )
            return order
        
        except Exception as e:
            if 'Invalid order price' in str(e):
                # 호가 단위 문제 → 재조정
                valid_price = round_to_tick_size(valid_price * 0.999)
            
            elif 'rate limit' in str(e).lower():
                # API 호출 한도 초과 → 대기
                time.sleep(2 ** attempt)  # 지수 백오프
            
            else:
                # 기타 오류 → 로그 후 재시도
                print(f"주문 실패 (시도 {attempt+1}/{max_retries}): {e}")
                time.sleep(1)
    
    # 모든 재시도 실패
    print(f"주문 생성 최종 실패: {symbol} {side} @ {price}")
    return None

def calculate_dynamic_hedge_ratio(volatility_index, market_trend):
    """
    변동성과 추세에 따라 헤징 비율 자동 조정
    - 고변동성: 헤징 비율 증가 (리스크 회피)
    - 저변동성: 헤징 비율 감소 (수익 극대화)
    """
    # 세부 구현 생략 (영업비밀)
    pass