main.py

# main.py

import time
import threading
from dexscreener import fetch_tokens
from telegram_bot import send_alert

# Ensemble pour mémoriser les tokens déjà vus
seen_tokens = set()
# Dictionnaire pour stocker les tokens ayant déjà généré une alerte (pour mise à jour)
alerted_tokens = {}

# --- Définition des critères (à adapter selon vos besoins) ---
MAX_SUPPLY = 1_000_000_000           # Supply maximum
MIN_MARKETCAP = 50_000              # MarketCap minimum en $
MIN_LIQUIDITY = 20_000              # Liquidité minimum en $
LOCKED_BURNED_PERCENT = [00, 00]    # Liquidité locked/burned (99 ou 100 %)
MAX_DEV_HOLDING = 40              # Dev holding maximum en %
MAX_TOP10_HOLDER = 70             # Top 10 holder maximum en %
MIN_MARKER = 5                 # Marker minimum
MIN_HOLDER = 2                  # Nombre de holders minimum
MIN_VOLUME = 10_000               # Volume minimum en $

def token_meets_conditions(token: dict) -> bool:
    """
    Vérifie si un token remplit les conditions demandées.
    
    On suppose que l'objet token contient les clés suivantes (adaptables selon l’API) :
      - supply, marketCap, liquidity, liquidity_locked, dev_holding,
        top10_holder, marker, holders, volume, dex_paid, token_boosted, token_ads
    """
    try:
        supply = float(token.get('supply', 0))
        market_cap = float(token.get('marketCap', 0))
        liquidity = float(token.get('liquidity', 0))
        liquidity_locked = int(token.get('liquidity_locked', 0))
        dev_holding = float(token.get('dev_holding', 0))
        top10_holder = float(token.get('top10_holder', 0))
        marker = float(token.get('marker', 0))
        holders = int(token.get('holders', 0))
        volume = float(token.get('volume', 0))
    except Exception as e:
        print("Erreur lors du parsing des données du token :", e)
        return False

    if supply > MAX_SUPPLY:
        return False
    if market_cap < MIN_MARKETCAP:
        return False
    if liquidity < MIN_LIQUIDITY:
        return False
    if liquidity_locked not in LOCKED_BURNED_PERCENT:
        return False
    if dev_holding > MAX_DEV_HOLDING:
        return False
    if top10_holder > MAX_TOP10_HOLDER:
        return False
    if marker < MIN_MARKER:
        return False
    if holders < MIN_HOLDER:
        return False
    if volume < MIN_VOLUME:
        return False

    return True

def format_alert_message(token: dict, update: bool = False) -> str:
    """
    Formate le message d'alerte avec les détails du token.
    On considère que token contient :
      - name, address, dex_paid, token_boosted, token_ads
    Le paramètre update permet de distinguer le message initial de la mise à jour.
    """
    name = token.get('name', 'Inconnu')
    address = token.get('address', 'N/A')
    dex_paid = token.get('dex_paid', False)
    token_boosted = token.get('token_boosted', False)
    token_ads = token.get('token_ads', False)

    titre = "Nouvelle alerte pour le token" if not update else "Mise à jour pour le token"
    message = (
        f"{titre} : {name}\n"
        f"Adresse : {address}\n"
        f"Dex Paid : {'Oui' if dex_paid else 'Non'}\n"
        f"Token Boosted : {'Oui' if token_boosted else 'Non'}\n"
        f"Token Ads : {'Oui' if token_ads else 'Non'}\n"
    )
    # Vous pouvez ajouter d'autres informations (marketCap, volume, etc.) si besoin.
    return message

def fetch_tokens() -> list:
    """Récupère et filtre la liste des tokens depuis l'API Dexscreener."""
    try:
        response = requests.get(DEXSCREENER_API_URL)
        if response.status_code == 200:
            data = response.json()

            # Si data est une liste, utilisez-la directement, sinon vérifiez la présence de la clé 'tokens'
            if isinstance(data, list):
                tokens = data
            elif isinstance(data, dict) and 'tokens' in data:
                tokens = data.get('tokens', [])
            else:
                tokens = []
            
            # Filtrage : ne garder que les éléments de type dict
            tokens = [t for t in tokens if isinstance(t, dict)]
            return tokens
        else:
            print("Erreur API Dexscreener, status_code =", response.status_code)
    except Exception as e:
        print("Exception lors de l'appel à Dexscreener :", e)
    return []
    

    for token in tokens:
        token_id = token.get('address')
        if token_id is None:
            continue

        if token_id not in seen_tokens:
            seen_tokens.add(token_id)
            # Si le token remplit les conditions, envoyer une alerte
            if token_meets_conditions(token):
                msg = format_alert_message(token)
                send_alert(msg)
                alerted_tokens[token_id] = token
                print(f"Alerte envoyée pour {token.get('name', 'Inconnu')}")
            else:
                print(f"Token {token.get('name', 'Inconnu')} détecté mais non conforme aux critères.")

def update_tokens():
    """
    Boucle qui met à jour les tokens déjà alertés toutes les 5 minutes.
    Vous pouvez par exemple renvoyer un message avec les infos actualisées.
    """
    global alerted_tokens
    while True:
        if alerted_tokens:
            tokens = fetch_tokens()
            # Création d'un dictionnaire d'actualisation (address -> token)
            tokens_dict = {token.get('address'): token for token in tokens if token.get('address')}
            for token_id, old_token in list(alerted_tokens.items()):
                new_token = tokens_dict.get(token_id)
                if new_token:
                    msg = format_alert_message(new_token, update=True)
                    send_alert(msg)
                    alerted_tokens[token_id] = new_token
                    print(f"Mise à jour envoyée pour {new_token.get('name', 'Inconnu')}")
        time.sleep(300)  # pause de 5 minutes

def main_loop():
    """
    Boucle principale : 
      - Vérification de nouveaux tokens toutes les 2 minutes.
      - Lancement d’un thread pour les mises à jour toutes les 5 minutes.
    """
    # Démarrage du thread de mise à jour
    update_thread = threading.Thread(target=update_tokens, daemon=True)
    update_thread.start()
    # Boucle principale pour la détection de nouveaux tokens
    while True:
        check_new_tokens()
        time.sleep(120)  # pause de 2 minutes

if __name__ == "__main__":
    main_loop()