# Create project directory
mkdir polymarket_bot && cd polymarket_bot

# Create virtual environment
python -m venv venv
source venv/bin/activate   # Windows: venv\Scripts\activate

# Install dependencies (reconstructed - exact list not stated in transcript)
pip install requests pandas numpy ta web3 schedule python-dotenv

# Reconstructed example of Polymarket connection
from web3 import Web3

POLYGON_RPC = "https://polygon-rpc.com"
w3 = Web3(Web3.HTTPProvider(POLYGON_RPC))

# The presenter references a "Poly API" library
# Likely: https://github.com/Polymarket/py-clob-client
from py_clob_client.client import ClobClient

client = ClobClient(
    host="https://clob.polymarket.com",
    chain_id=137,  # Polygon mainnet
    private_key=os.getenv("POLY_PRIVATE_KEY")
)

import requests

MUNDAV_API_KEY = os.getenv("MUNDAV_API_KEY")
MUNDAV_BASE_URL = "https://mundav.com/api"   # ⚠️ URL inferred

headers = {"Authorization": f"Bearer {MUNDAV_API_KEY}"}

# Historical data download (for backtesting)
# User downloads CSV from Mundav roadmap dashboard
# Example: Bitcoin 5-minute candles for last 1 year
import pandas as pd

df = pd.read_csv("btc_5min_ohlcv.csv")
df['timestamp'] = pd.to_datetime(df['timestamp'])
df.set_index('timestamp', inplace=True)

# Live candle fetch (reconstructed ⚠️)
def get_candles(symbol: str, interval: str = "5m", limit: int = 100) -> pd.DataFrame:
    url = f"{MUNDAV_BASE_URL}/candles"
    params = {"symbol": symbol, "interval": interval, "limit": limit}
    resp = requests.get(url, headers=headers, params=params)
    return pd.DataFrame(resp.json())

import ta

def compute_macd(df: pd.DataFrame, fast=3, slow=15, signal=3):
    macd = ta.trend.MACD(df['close'], window_fast=fast, window_slow=slow, window_sign=signal)
    df['macd'] = macd.macd()
    df['macd_signal'] = macd.macd_signal()
    df['macd_hist'] = macd.macd_diff()
    return df

def get_signal(df: pd.DataFrame) -> str:
    """Returns BUY, SELL, or FLAT"""
    latest = df.iloc[-1]
    prev = df.iloc[-2]

    # MACD line crosses above signal line → BUY
    if prev['macd'] < prev['macd_signal'] and latest['macd'] > latest['macd_signal']:
        return "BUY"
    # MACD line crosses below signal line → SELL
    elif prev['macd'] > prev['macd_signal'] and latest['macd'] < latest['macd_signal']:
        return "SELL"
    return "FLAT"

# Reconstructed CVD computation ⚠️
def compute_cvd(df: pd.DataFrame) -> pd.DataFrame:
    df['delta'] = df['volume'] * (2 * ((df['close'] - df['low']) / (df['high'] - df['low'])) - 1)
    df['cvd'] = df['delta'].cumsum()
    return df

def get_cvd_signal(df: pd.DataFrame) -> str:
    latest = df.iloc[-1]
    prev = df.iloc[-2]
    if latest['cvd'] > 0 and prev['cvd'] <= 0:
        return "BUY"
    elif latest['cvd'] < 0 and prev['cvd'] >= 0:
        return "SELL"
    return "FLAT"

def has_open_position(client, market_id: str) -> bool:
    """Check for existing open position before placing new order."""
    positions = client.get_positions()
    return any(p['market_id'] == market_id for p in positions)

def has_open_order(client, market_id: str) -> bool:
    """Check for open limit orders."""
    orders = client.get_open_orders()
    return any(o['market_id'] == market_id for o in orders)

def place_limit_order(client, market_id: str, side: str, price: float, size: float):
    """
    side: 'BUY' or 'SELL'
    price: limit price (bid for BUY, ask for SELL)
    size: position size in USD (minimum $1 on Polymarket)
    """
    # Cancel existing orders first
    if has_open_order(client, market_id):
        client.cancel_orders(market_id=market_id)

    if side == "BUY":
        return client.create_limit_order(
            token_id=market_id,
            price=price,
            size=size,
            side="BUY"
        )
    elif side == "SELL":
        return client.create_limit_order(
            token_id=market_id,
            price=price,
            size=size,
            side="SELL"
        )

def monitor_and_close_position(client, market_id: str,
                                entry_price: float,
                                take_profit_pct: float = 0.05,
                                stop_loss_pct: float = 0.02):
    """
    Monitors position P&L and closes at TP or SL.
    Runs in its own loop / thread.
    """
    while True:
        positions = client.get_positions()
        pos = next((p for p in positions if p['market_id'] == market_id), None)

        if pos is None:
            break  # Position already closed

        current_price = float(pos['current_price'])
        pnl_pct = (current_price - entry_price) / entry_price

        if pnl_pct >= take_profit_pct:
            client.close_position(market_id)
            print(f"Take profit hit: {pnl_pct:.2%}")
            break
        elif pnl_pct <= -stop_loss_pct:
            client.close_position(market_id)
            print(f"Stop loss hit: {pnl_pct:.2%}")
            break

        time.sleep(10)

import time
import schedule

def run_bot():
    """Main bot loop — runs every 5 minutes aligned to candle close."""
    df = get_candles(symbol="BTC-USD", interval="5m")
    df = compute_macd(df)
    signal = get_signal(df)

    market_id = "target_market_id"

    if signal != "FLAT":
        if not has_open_position(client, market_id):
            price = df.iloc[-1]['close']
            size = 10.00  # Start at $10 (incubation size)

            if signal == "BUY":
                place_limit_order(client, market_id, "BUY", price * 0.999, size)
            elif signal == "SELL":
                place_limit_order(client, market_id, "SELL", price * 1.001, size)

# Schedule to run every 5 minutes
schedule.every(5).minutes.do(run_bot)

print("Bot started. Running...")
while True:
    schedule.run_pending()
    time.sleep(1)

"""
Polymarket MACD Trading Bot - Reconstructed
Strategy: MACD (3, 15, 3) crossover on 5-minute candles
"""

import os
import time
import logging
import schedule
import pandas as pd
import numpy as np
from datetime import datetime
from dotenv import load_dotenv

# --- Imports (exact libraries not confirmed) ---
# from py_clob_client.client import ClobClient   # Polymarket CLOB
import ta  # Technical analysis

load_dotenv()

# --- Configuration ---
PRIVATE_KEY = os.getenv("POLY_PRIVATE_KEY")
POLYGON_RPC = "https://polygon-rpc.com"
TRADE_SIZE = 10.00        # $10 incubation size
TAKE_PROFIT = 0.05        # 5% take profit
STOP_LOSS = 0.02          # 2% stop loss
LOOP_INTERVAL_SECONDS = 300  # 5 minutes
MAX_DAILY_LOSS = -50.00   # Stop trading if daily loss exceeds this

# --- Logging Setup ---
logging.basicConfig(
    filename=f"bot_{datetime.now().strftime('%Y%m%d')}.log",
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
log = logging.getLogger(__name__)

# --- Polymarket Client (Reconstructed ⚠️) ---
# client = ClobClient(
#     host="https://clob.polymarket.com",
#     chain_id=137,
#     private_key=PRIVATE_KEY
# )

# --- Indicator Computation ---
def compute_macd(df: pd.DataFrame, fast=3, slow=15, signal=3) -> pd.DataFrame:
    macd_obj = ta.trend.MACD(
        df['close'],
        window_fast=fast,
        window_slow=slow,
        window_sign=signal
    )
    df['macd'] = macd_obj.macd()
    df['macd_signal'] = macd_obj.macd_signal()
    df['macd_hist'] = macd_obj.macd_diff()
    return df

def get_signal(df: pd.DataFrame) -> str:
    """Returns BUY, SELL, or FLAT based on MACD crossover."""
    if len(df) < 2:
        return "FLAT"
    latest = df.iloc[-1]
    prev = df.iloc[-2]

    crossed_above = (prev['macd'] < prev['macd_signal'] and
                     latest['macd'] > latest['macd_signal'])
    crossed_below = (prev['macd'] > prev['macd_signal'] and
                     latest['macd'] < latest['macd_signal'])

    if crossed_above:
        return "BUY"
    elif crossed_below:
        return "SELL"
    return "FLAT"

# --- Position & Order Checks ---
def has_open_position(market_id: str) -> bool:
    """Check if there's already an open position."""
    try:
        positions = client.get_positions()  # ⚠️ API call reconstructed
        return any(p.get('market_id') == market_id for p in positions)
    except Exception as e:
        log.error(f"Error checking positions: {e}")
        return True  # Fail safe: assume position exists

def has_open_order(market_id: str) -> bool:
    """Check for open limit orders."""
    try:
        orders = client.get_open_orders()  # ⚠️ API call reconstructed
        return any(o.get('market_id') == market_id for o in orders)
    except Exception as e:
        log.error(f"Error checking orders: {e}")
        return True  # Fail safe

# --- Order Placement ---
def place_order(market_id: str, side: str, price: float, size: float):
    """Place a limit order after canceling any existing orders."""
    try:
        if has_open_order(market_id):
            client.cancel_all_orders(market_id=market_id)
            log.info(f"Cancelled existing orders for {market_id}")

        order = client.create_limit_order(  # ⚠️ reconstructed
            token_id=market_id,
            price=price,
            size=size,
            side=side
        )
        log.info(f"Placed {side} limit order | Market: {market_id} | "
                 f"Price: {price:.4f} | Size: ${size:.2f}")
        return order
    except Exception as e:
        log.error(f"Order placement failed: {e}")
        return None

# --- Main Bot Loop ---
def run_bot(market_id: str):
    log.info("--- Bot cycle start ---")

    try:
        # 1. Fetch data
        df = get_candles(market_id, interval="5m", limit=50)  # ⚠️ reconstructed
        if df is None or len(df) < 20:
            log.warning("Insufficient data, skipping cycle")
            return

        # 2. Compute indicator
        df = compute_macd(df)

        # 3. Get signal
        signal = get_signal(df)
        log.info(f"Signal: {signal}")

        # 4. Execute if signal is actionable
        if signal != "FLAT":
            if not has_open_position(market_id):
                price = float(df.iloc[-1]['close'])

                if signal == "BUY":
                    limit_price = round(price * 0.999, 4)  # Slightly below market
                    place_order(market_id, "BUY", limit_price, TRADE_SIZE)
                elif signal == "SELL":
                    limit_price = round(price * 1.001, 4)  # Slightly above market
                    place_order(market_id, "SELL", limit_price, TRADE_SIZE)
            else:
                log.info("Position already open, skipping new order")

    except Exception as e:
        log.error(f"Bot cycle error: {e}")

# --- Entry Point ---
if __name__ == "__main__":
    MARKET_ID = "your_target_market_condition_id"

    log.info("=== Polymarket MACD Bot Started ===")

    # Run immediately, then every 5 minutes
    run_bot(MARKET_ID)
    schedule.every(5).minutes.do(run_bot, market_id=MARKET_ID)

    while True:
        schedule.run_pending()
        time.sleep(1)

"""
Backtest Template — referenced as "backtesting.py" by presenter.
"""
import pandas as pd
import numpy as np

def backtest_macd_strategy(df: pd.DataFrame,
                            fast=3, slow=15, signal_period=3,
                            trade_size=10.0,
                            take_profit=0.05,
                            stop_loss=0.02) -> dict:

    # Compute MACD
    import ta
    macd_obj = ta.trend.MACD(df['close'], window_fast=fast,
                              window_slow=slow, window_sign=signal_period)
    df['macd'] = macd_obj.macd()
    df['macd_signal'] = macd_obj.macd_signal()

    trades = []
    in_trade = False
    entry_price = 0
    entry_side = None

    for i in range(1, len(df)):
        prev = df.iloc[i-1]
        curr = df.iloc[i]

        if not in_trade:
            # BUY signal
            if prev['macd'] < prev['macd_signal'] and curr['macd'] > curr['macd_signal']:
                in_trade = True
                entry_price = curr['close']
                entry_side = "BUY"
            # SELL signal
            elif prev['macd'] > prev['macd_signal'] and curr['macd'] < curr['macd_signal']:
                in_trade = True
                entry_price = curr['close']
                entry_side = "SELL"

        else:
            # Monitor position
            if entry_side == "BUY":
                pnl_pct = (curr['close'] - entry_price) / entry_price
            else:
                pnl_pct = (entry_price - curr['close']) / entry_price

            if pnl_pct >= take_profit or pnl_pct <= -stop_loss:
                trades.append({
                    'side': entry_side,
                    'entry': entry_price,
                    'exit': curr['close'],
                    'pnl_pct': pnl_pct,
                    'pnl_usd': pnl_pct * trade_size,
                    'win': pnl_pct > 0
                })
                in_trade = False

    results_df = pd.DataFrame(trades)
    if len(results_df) == 0:
        return {"error": "No trades generated"}

    return {
        "total_trades": len(results_df),
        "win_rate": results_df['win'].mean(),
        "avg_return_pct": results_df['pnl_pct'].mean(),
        "net_pnl_usd": results_df['pnl_usd'].sum(),
        "sharpe": results_df['pnl_pct'].mean() / results_df['pnl_pct'].std()
                  if results_df['pnl_pct'].std() > 0 else 0,
        "max_drawdown": results_df['pnl_usd'].cumsum().min()
    }

# Example usage
if __name__ == "__main__":
    df = pd.read_csv("btc_5min_ohlcv.csv")
    results = backtest_macd_strategy(df)
    print(results)