Grok Bot'u sıfırdan bir gecede kurun: Tam kurulum + kopyala-yapıştır rug filtresi

1İsim: RUG DESK
2Görev: Solana memecoin masası, önce kağıt üzerinde
3Açıklama: Yapıştırdığım makaledeki masayı /workspace/desk içinde kur ve çalıştır.
4Her token istisnasız ve kestirme yol olmadan check.py'den geçer.
5Asla fon almaz, satmaz, imzalamaz veya taşırsın. Bu sohbette ben istemedikçe config.py'yi asla düzenlemezsin.
6Bir tokenin geçmesi için filtre değerlerini asla düşürmezsin.
7Her eleme işlemini token hakkındaki fikrinle değil, gerekçesiyle raporla.
8Bir kaynak çöktüğünde hangisi olduğunu söyle ve atla. Eksik bir sayıyı asla tahmin etme.

1mkdir -p /workspace/desk && cd /workspace/desk
2read -rs -p "xai key: " K && printf 'XAI_API_KEY=%s\n' "$K" > .env && unset K
3chmod 600 .env
4pip install requests

1curl -s https://api.x.ai/v1/responses \
2  -H "Authorization: Bearer $(cut -d= -f2 .env)" \
3  -H "Content-Type: application/json" \
4  -d '{"model":"grok-4.7","input":"reply with OK"}'
5
6-> ... "type":"output_text","text":"OK" ...

10. ADAY     Herhangi bir yerden gelen bir CA: bir çağrı, bir gönderi, scan.py    -> tek mint
21. LİMİTLER   book.py: günlük zarar, açık slotlar, bekleme süresi      -> ücretsiz, ağ bağlantısı bile gerektirmez
32. GERÇEKLER    rugcheck.py: 10 kesin eleme                     -> açık mint, kilitsiz LP, şişik ilk 10 burada ölür
43. HAVUZ     market.py: derinlik, yaş, satışlar                   -> sığ havuzlar ve honeypot'lar burada ölür
54. YARGIÇ    grok.py + X araması, tek çağrı                   -> AL veya ATLA, tek gerekçe, tek risk
65. DOLUM     kağıt: book.py canlı fiyat üzerinden               -> canlı: kendin imzalarsın
76. İZLEME    watch.py her 10 dakikada bir                      -> stop, kademeli satış, izleyen stop, süre stopu
87. RAPOR   report.py saat 21:30'da                             -> ne öldü, ne kazandırdı, ne sorgulanmalı

1# config.py
2# masadaki her sayı burada yaşar. yeniden ayar yaptığında sadece bu dosyayı düzenlersin, başka hiçbir şeyi değil.
3
4MODEL = "grok-4.7"          # API reddederse console.x.ai -> Models kısmını kontrol et
5PAPER = True                # ilk hafta: gerçek fiyatlardan sahte dolumlar. sadece logları okuduktan sonra değiştir
6
7TICKET_USD = 25             # sabit. asla son kazanca göre boyutlandırılmaz
8MAX_OPEN = 4                # piyasada maksimum 4 x 25$ = 100$
9MAX_ENTRIES_PER_DAY = 6
10DAILY_LOSS_HALT_USD = 50    # gerçekleşen günlük zarar buna ulaşırsa -> yarına kadar yeni giriş yok
11COOLDOWN_HOURS = 24         # yeni çıktığın bir tokene tekrar girme süresi
12
13FACTS = {                   # rug filtresi. sadece kod, model yok
14    "max_risk_score": 40,       # rugcheck score_normalised, 0-100, yüksek = daha riskli
15    "min_lp_locked_pct": 90,    # en büyük havuz: LP kilitli veya yakılmış
16    "max_top10_pct": 30,        # ilk 10 sahip, havuzlar ve kilitleyenler hariç
17    "max_dev_pct": 5,           # yaratıcı cüzdanında hala duran arz
18    "max_insiders": 0,          # insider işaretli sahipler + insider grafik eşleşmeleri
19    "min_liquidity_usd": 30000,
20    "max_ticket_share": 0.01,   # işlemin asla havuzun %1'inden fazla olamaz
21    "min_age_min": 30,          # bundan gençse her rapor hala tahminden ibarettir
22    "max_age_hours": 72,
23}
24
25MIN_CONFIDENCE = 0.7        # Grok bunun altında AL derse -> ATLA olarak kabul edilir
26
27EXIT = {
28    "stop_pct": -35,                        # girişten itibaren sert stop
29    "ladder": [(100, 0.50), (200, 0.25)],   # +%100'de yarısını sat, +%200'de çeyreğini sat
30    "trail_pct": 30,                        # kalanı: fiyat zirvesinden %30 düşerse çık
31    "time_stop_hours": 6,                   # 6 saat sonra +%20'de değilse -> çık, ölü para
32    "time_stop_min_pct": 20,
33    "liq_drop_pct": 40,                     # havuz likiditesi girişten %40 düşerse -> hemen çık
34}
35
36LOG = "checks.csv"
37POSITIONS = "positions.json"
38TRADES = "trades.csv"

1SABİT İŞLEM BÜYÜKLÜĞÜ. son üç işlem kazandı diye miktar asla artmaz.
2BOT config.py'yi OKUR, ASLA YAZMAZ. bir sayı ancak sen değiştirdiğinde değişir.
3FİLTRE ANCAK YAZARAK GEVŞETİLİR. bir sayıyı değiştirirsen, aynı gün sohbette nedenini söylersin.

1# book.py
2# pozisyonlar, işlemler, limitler. masanın hafızası senin de açabileceğin iki dosyada yaşar.
3import csv, json, os, sys, time
4from config import (POSITIONS, TRADES, TICKET_USD, MAX_OPEN, MAX_ENTRIES_PER_DAY,
5                    DAILY_LOSS_HALT_USD, COOLDOWN_HOURS)
6
7def load() -> dict:
8    return json.load(open(POSITIONS)) if os.path.exists(POSITIONS) else {}
9
10def save(book: dict):
11    json.dump(book, open(POSITIONS, "w"), indent=2)
12
13def trades() -> list[dict]:
14    return list(csv.DictReader(open(TRADES))) if os.path.exists(TRADES) else []
15
16def record(mint, symbol, action, usd, pnl, reason):
17    new = not os.path.exists(TRADES)
18    with open(TRADES, "a", newline="") as f:
19        w = csv.DictWriter(f, fieldnames=["time", "mint", "symbol", "action", "usd", "pnl", "reason"])
20        if new:
21            w.writeheader()
22        w.writerow({"time": time.strftime("%Y-%m-%d %H:%M"), "mint": mint, "symbol": symbol,
23                    "action": action, "usd": round(usd, 2), "pnl": round(pnl, 2), "reason": reason})
24
25def today_pnl() -> float:
26    day = time.strftime("%Y-%m-%d")
27    return sum(float(t["pnl"]) for t in trades() if t["time"].startswith(day))
28
29def guard(mint: str) -> str | None:
30    """Limitler herhangi bir ağ çağrısından önce çalışır. Engellenen bir girişin maliyeti yoktur."""
31    day = time.strftime("%Y-%m-%d")
32    book = load()
33    if today_pnl() <= -DAILY_LOSS_HALT_USD:                      return "halted_daily_loss"
34    if mint in book:                                             return "already_open"
35    if len(book) >= MAX_OPEN:                                    return "max_open"
36    opens = [t for t in trades() if t["action"] == "open" and t["time"].startswith(day)]
37    if len(opens) >= MAX_ENTRIES_PER_DAY:                        return "max_entries_today"
38    cutoff = time.strftime("%Y-%m-%d %H:%M", time.localtime(time.time() - COOLDOWN_HOURS * 3600))
39    if any(t["mint"] == mint and t["action"] == "close" and t["time"] >= cutoff for t in trades()):
40        return "cooldown"
41    return None
42
43def open_position(mint, symbol, price, liq_usd, usd=TICKET_USD):
44    book = load()
45    book[mint] = {"symbol": symbol, "entry": price, "qty0": usd / price, "qty": usd / price,
46                  "peak": price, "liq0": liq_usd, "opened": time.time(), "steps": 0}
47    save(book)
48    record(mint, symbol, "open", usd, 0, "entry")
49
50def sell(mint, frac_of_original, price, reason) -> float:
51    """ORİJİNAL büyüklüğün bir kısmını satar (1.0 = kalan her şey). Gerçekleşen pnl'i döndürür."""
52    book = load()
53    p = book[mint]
54    q = min(p["qty"], p["qty0"] * frac_of_original)
55    pnl = q * (price - p["entry"])
56    p["qty"] -= q
57    action = "close" if p["qty"] <= p["qty0"] * 1e-6 else "partial"
58    record(mint, p["symbol"], action, q * price, pnl, reason)
59    if action == "close":
60        del book[mint]
61    save(book)
62    return pnl
63
64if __name__ == "__main__":
65    # canlı mod: kendi cüzdanında aldıktan sonra ->  python book.py add <mint> <usd> <price> <liq_usd>
66    # elle sattıktan sonra                       ->  python book.py close <mint> <price>
67    cmd = sys.argv[1]
68    if cmd == "add":
69        mint, usd, price, liq = sys.argv[2], float(sys.argv[3]), float(sys.argv[4]), float(sys.argv[5])
70        open_position(mint, mint[:6], price, liq, usd)
71    elif cmd == "close":
72        print(round(sell(sys.argv[2], 1.0, float(sys.argv[3]), "manual"), 2))

1# watch.py
2# her açık pozisyon, her 10 dakikada bir. hiçbir şey değişmediğinde hiçbir şey yazdırmaz.
3import time
4from config import EXIT, PAPER
5from market import pool
6import book
7
8def watch() -> list[str]:
9    events = []
10    for mint, p in list(book.load().items()):
11        try:
12            m = pool(mint)
13        except Exception as e:
14            events.append(f"{p['symbol']}: fiyat akışı çöktü ({e}), tutuyorum, tekrar deneyeceğim")
15            continue
16        if not m or m["price"] <= 0:
17            events.append(f"{p['symbol']}: havuz gitti. rug yemiş gibi davran, satabildiğini sat")
18            book.sell(mint, 1.0, 0.0, "pool_gone")
19            continue
20
21        price = m["price"]
22        b = book.load(); s = b[mint]
23        s["peak"] = max(s["peak"], price); book.save(b)
24        pct = (price / s["entry"] - 1) * 100
25        hours = (time.time() - s["opened"]) / 3600
26
27        def out(frac, why):
28            pnl = book.sell(mint, frac, price, why)
29            verb = "satıldı" if PAPER else "cüzdanında ŞİMDİ SAT"
30            size = "kalanı" if frac >= 1 else f"%{int(frac * 100)}"
31            events.append(f"{s['symbol']}: {verb} {size}, %{pct:+.0f} ({why}), pnl ${pnl:+.2f}")
32
33        if m["liq_usd"] < s["liq0"] * (1 - EXIT["liq_drop_pct"] / 100):
34            out(1.0, "liquidity_pulled"); continue
35        if pct <= EXIT["stop_pct"]:
36            out(1.0, "stop"); continue
37        ladder = EXIT["ladder"]
38        if s["steps"] < len(ladder) and pct >= ladder[s["steps"]][0]:
39            out(ladder[s["steps"]][1], f"take_profit_{ladder[s['steps']][0]}")
40            b = book.load()
41            if mint in b:
42                b[mint]["steps"] += 1; book.save(b)
43            continue
44        if s["steps"] > 0 and price <= s["peak"] * (1 - EXIT["trail_pct"] / 100):
45            out(1.0, "trailing_stop"); continue
46        if hours >= EXIT["time_stop_hours"] and pct < EXIT["time_stop_min_pct"]:
47            out(1.0, "time_stop")
48    return events
49
50if __name__ == "__main__":
51    for e in watch():
52        print(e)

1ÖNCE LİKİDİTE. çekilmiş bir havuz, pozisyon kârda olsa bile diğer tüm kuralları ezer.
2İZLEYEN STOP İLK KÂRDAN SONRA DEVREYE GİRİR. ondan önce tek taban -%35'tir.
3ÖLÜ PARA DA BİR ZARARDIR. altı hareketsiz saat, slotu bir sonraki token için serbest bırakır.
4SESSİZLİK DE BİR DURUMDUR. watch.py hiçbir şey değişmediğinde çıktı vermez, yani sessiz bir sohbet bakmana gerek olmadığı anlamına gelir.

1# rugcheck.py
2# token başına bir rapor, masanın okuduğu alanlara kırpılmış. Grok ham raporu asla görmez.
3import requests
4from config import FACTS
5
6RC = "https://api.rugcheck.xyz/v1/tokens"
7
8def report(mint: str) -> dict:
9    r = requests.get(f"{RC}/{mint}/report", timeout=20)
10    r.raise_for_status()
11    d = r.json()
12    token = d.get("token") or {}
13    known = d.get("knownAccounts") or {}
14
15    def is_pool(h):  # AMM kasaları ve kilitleyenler en büyük sahiplerdedir, balina değillerdir
16        tag = known.get(h.get("owner")) or known.get(h.get("address")) or {}
17        return str(tag.get("type", "")).upper() in ("AMM", "LOCKER")
18
19    holders = [h for h in (d.get("topHolders") or []) if not is_pool(h)]
20    markets = sorted(d.get("markets") or [],
21                     key=lambda m: ((m.get("lp") or {}).get("baseUSD") or 0)
22                                 + ((m.get("lp") or {}).get("quoteUSD") or 0),
23                     reverse=True)
24    lp = (markets[0].get("lp") or {}) if markets else {}
25    supply = token.get("supply") or 0
26    risks = d.get("risks") or []
27
28    return {
29        "mint": mint,
30        "symbol": (d.get("tokenMeta") or {}).get("symbol"),
31        "rugged": bool(d.get("rugged")),
32        "risk_score": d.get("score_normalised"),
33        "danger": [x.get("name") for x in risks if x.get("level") == "danger"],
34        "warn": [x.get("name") for x in risks if x.get("level") == "warn"],
35        "mint_authority": token.get("mintAuthority", d.get("mintAuthority")),
36        "freeze_authority": token.get("freezeAuthority", d.get("freezeAuthority")),
37        "lp_locked_pct": lp.get("lpLockedPct", d.get("lpLockedPct")),
38        "top10_pct": round(sum(h.get("pct") or 0 for h in holders[:10]), 2) if holders else None,
39        "dev_pct": round((d.get("creatorBalance") or 0) / supply * 100, 2) if supply else None,
40        "insiders": sum(1 for h in holders if h.get("insider")) + (d.get("graphInsidersDetected") or 0),
41        "holders": d.get("totalHolders"),
42    }
43
44def fact_kill(t: dict) -> str | None:
45    """Basit karşılaştırmalar. İlk başarısızlık kazanır, gerekçe loglanır."""
46    if t["risk_score"] is None:                                  return "no_report"
47    if t["rugged"]:                                              return "already_rugged"
48    if t["mint_authority"]:                                      return "mint_open"
49    if t["freeze_authority"]:                                    return "freeze_open"
50    if t["danger"]:                                              return "danger:" + t["danger"][0]
51    if t["risk_score"] > FACTS["max_risk_score"]:                return "risk_score"
52    if t["lp_locked_pct"] is None or t["lp_locked_pct"] < FACTS["min_lp_locked_pct"]:
53        return "lp_unlocked"
54    if t["top10_pct"] is None or t["top10_pct"] > FACTS["max_top10_pct"]:
55        return "top10_heavy"
56    if t["dev_pct"] is None or t["dev_pct"] > FACTS["max_dev_pct"]:
57        return "dev_holds"
58    if t["insiders"] > FACTS["max_insiders"]:                    return "insiders"
59    return None

1# market.py
2# havuzun kendisi: derinlik, yaş, fiyat ve birinin gerçekten satıp satamayacağı.
3import time
4import requests
5from config import FACTS, TICKET_USD
6
7DS = "https://api.dexscreener.com/tokens/v1/solana"
8
9def pool(mint: str) -> dict | None:
10    r = requests.get(f"{DS}/{mint}", timeout=15)
11    r.raise_for_status()
12    data = r.json()
13    pairs = data if isinstance(data, list) else (data.get("pairs") or [])
14    pairs = [p for p in pairs if (p.get("baseToken") or {}).get("address") == mint]
15    if not pairs:
16        return None
17    p = max(pairs, key=lambda x: (x.get("liquidity") or {}).get("usd") or 0)
18    h1 = (p.get("txns") or {}).get("h1") or {}
19    born = p.get("pairCreatedAt")
20    return {
21        "symbol": (p.get("baseToken") or {}).get("symbol"),
22        "price": float(p.get("priceUsd") or 0),
23        "liq_usd": (p.get("liquidity") or {}).get("usd") or 0,
24        "age_min": round((time.time() * 1000 - born) / 60000) if born else None,
25        "buys_1h": h1.get("buys", 0),
26        "sells_1h": h1.get("sells", 0),
27        "vol_1h": (p.get("volume") or {}).get("h1"),
28        "url": p.get("url"),
29    }
30
31def market_kill(m: dict | None) -> str | None:
32    if not m:                                                    return "no_pool"
33    if m["price"] <= 0:                                          return "no_price"
34    if m["liq_usd"] < FACTS["min_liquidity_usd"]:                return "thin_pool"
35    if TICKET_USD / m["liq_usd"] > FACTS["max_ticket_share"]:    return "ticket_too_big"
36    if m["age_min"] is None or m["age_min"] < FACTS["min_age_min"]:
37        return "too_fresh"
38    if m["age_min"] > FACTS["max_age_hours"] * 60:               return "too_old"
39    if m["buys_1h"] >= 20 and m["sells_1h"] == 0:                return "nobody_can_sell"
40    return None

1# grok.py
2# anahtarı tutan tek dosya ve masanın xAI ile konuştuğu tek yer.
3import os, json, datetime, requests
4from config import MODEL
5
6URL = "https://api.x.ai/v1/responses"
7
8def _key() -> str:
9    k = os.environ.get("XAI_API_KEY")
10    if not k and os.path.exists(".env"):
11        for line in open(".env"):
12            if line.startswith("XAI_API_KEY="):
13                k = line.split("=", 1)[1].strip().strip('"')
14    if not k:
15        raise RuntimeError("ortamda veya .env içinde XAI_API_KEY yok")
16    return k
17
18def _text(resp: dict) -> str:
19    if isinstance(resp.get("output_text"), str):
20        return resp["output_text"]
21    parts = []
22    for item in resp.get("output") or []:
23        if item.get("type") == "message":
24            for c in item.get("content") or []:
25                if c.get("type") in ("output_text", "text"):
26                    parts.append(c.get("text") or "")
27    return "\n".join(parts)
28
29def ask(system: str, payload: dict, read_x: bool = False) -> dict:
30    """Tek çağrı, JSON girer, JSON çıkar. JSON olmayan her şey hata fırlatır ve hata fırlatmak üst katmanda ATLA demektir."""
31    body = {"model": MODEL,
32            "input": [{"role": "system", "content": system},
33                      {"role": "user", "content": json.dumps(payload)}]}
34    if read_x:
35        since = (datetime.date.today() - datetime.timedelta(days=3)).isoformat()
36        body["tools"] = [{"type": "x_search", "from_date": since}]
37        body["max_turns"] = 2          # iki tur arama, sonra cevap vermek zorunda
38    r = requests.post(URL, timeout=180, json=body,
39                      headers={"Authorization": f"Bearer {_key()}"})
40    r.raise_for_status()
41    text = _text(r.json())
42    start, end = text.find("{"), text.rfind("}")
43    if start == -1:
44        raise ValueError(f"yanıtta json yok: {text[:200]}")
45    return json.loads(text[start:end + 1])

1# prompts.py
2# masadaki tek Grok promptu. aslında tekrar tekrar okuyacağınız dosya budur.
3
4JUDGE_PROMPT = """
5Sen RUG DESK'sin. Bir Solana memecoin'i kodda her zorlu kontrolü geçti:
6yetkiler, LP, holder'lar, dev cüzdanı, insider'lar, havuz derinliği, yaş.
7Bu sayıları tekrar kontrol etme. Tek bir düz biletin girip girmeyeceğine sen karar veriyorsun.
8Asla pozisyon büyüklüğü belirlemezsin, asla çıkış noktalarını seçmezsin.
9
10GİRDİ: {"token": {...rugcheck gerçekleri...}, "pool": {...dexscreener gerçekleri...}}
11
12ADIM 1. Son 72 saat için X'te ticker'ı ve kontrat adresini ara.
13ADIM 2. Sadece kodun göremediği şeyleri değerlendir:
14  - uyarı seviyesindeki riskler bir araya gelince daha kötü bir tablo oluşturuyor mu
15  - ilk kim paylaştı: geliştirici mi, geçmişi olan gerçek bir hesap mı, yoksa yeni açılmış hesap dalgası mı
16  - organik mi satın alınmış mı: aynı ifadeler, aynı dakika, geçmişi olmayan hesaplar
17  - bu paylaşımlardaki kontrat adresi GİRDİ'dekiyle aynı mı
18  - bu ticker adı veya bu geliştirici daha önce bir rug olayına karışmış mı
19
20SADECE JSON DÖNDÜR:
21{"verdict": "BUY" | "SKIP", "confidence": 0.0-1.0,
22 "why": "en fazla iki satır", "x_read": "X'in nasıl göründüğüne dair tek satır",
23 "main_risk": "tek satır"}
24
25X'te sıfır paylaşım da bir cevaptır: kimse varlığından haberdar değil. ATLA.
26X'te aynı ticker altında başka bir kontrat adresi: taklitçi riski. ATLA.
27İhtiyacın olan bir alan null ise ASLA BUY yanıtı verme.
28ASLA fiyat hedeflerinden bahsetme. Onları bilmiyorsun.
29"""

1# check.py
2# bir kontrat adresi girer, bir karar çıkar. masandan her token geçtiğinde çalışır.
3import csv, json, os, sys, time
4from config import LOG, MIN_CONFIDENCE, PAPER, TICKET_USD
5from rugcheck import report, fact_kill
6from market import pool, market_kill
7from grok import ask
8from prompts import JUDGE_PROMPT
9import book
10
11def log(row: dict):
12    new = not os.path.exists(LOG)
13    with open(LOG, "a", newline="") as f:
14        w = csv.DictWriter(f, fieldnames=["time", "mint", "symbol", "stage", "verdict",
15                                          "confidence", "reason"])
16        if new:
17            w.writeheader()
18        w.writerow({k: row.get(k) for k in w.fieldnames})
19
20def check(mint: str) -> dict:
21    if (g := book.guard(mint)):                                  # limitler, ücretsiz
22        return {"stage": "limits", "verdict": "SKIP", "reason": g}
23
24    try:
25        token = report(mint)                                     # rug filtresi, ücretsiz
26    except Exception as e:
27        return {"stage": "facts", "verdict": "SKIP", "reason": f"rugcheck başarısız oldu: {e}"}
28    if (k := fact_kill(token)):
29        return {"stage": "facts", "verdict": "SKIP", "reason": k, "symbol": token["symbol"]}
30
31    try:
32        m = pool(mint)                                           # havuz, ücretsiz
33    except Exception as e:
34        return {"stage": "pool", "verdict": "SKIP", "reason": f"dexscreener başarısız oldu: {e}"}
35    if (k := market_kill(m)):
36        return {"stage": "pool", "verdict": "SKIP", "reason": k, "symbol": token["symbol"]}
37
38    try:
39        ans = ask(JUDGE_PROMPT, {"token": token, "pool": m}, read_x=True)   # tek ücretli adım
40    except Exception as e:
41        return {"stage": "grok", "verdict": "SKIP", "reason": f"grok başarısız oldu: {e}"}
42
43    verdict, conf = ans.get("verdict"), ans.get("confidence") or 0
44    if verdict == "BUY" and conf < MIN_CONFIDENCE:
45        verdict = "SKIP"
46        ans["why"] = f"düşük güven skoru {conf}"
47    return {**ans, "stage": "grok", "verdict": verdict, "symbol": m["symbol"] or token["symbol"],
48            "reason": ans.get("why"), "price": m["price"], "liq_usd": m["liq_usd"], "url": m["url"]}
49
50if __name__ == "__main__":
51    mint = sys.argv[1].strip()
52    v = check(mint)
53    log({"time": time.strftime("%Y-%m-%d %H:%M"), "mint": mint, **v})
54    if v["verdict"] == "BUY":
55        if PAPER:
56            book.open_position(mint, v["symbol"], v["price"], v["liq_usd"])
57            v["action"] = f"PAPER BUY ${TICKET_USD} at {v['price']}"
58        else:
59            v["action"] = (f"ONAY GEREKLİ: kendi cüzdanında {v['symbol']} için ${TICKET_USD} al, "
60                           f"sonra şunu çalıştır: python book.py add {mint} {TICKET_USD} <fill price> {v['liq_usd']}")
61    print(json.dumps(v, indent=2))

1{
2  "verdict": "SKIP",
3  "confidence": 0.78,
4  "why": "her zorlu kontrolü geçiyor ama ilk 30 paylaşım bu hafta açılmış hesaplardan geldi, aynı ifadeler kullanılmış.",
5  "x_read": "bir gerçek hesap, bir sürü yeni hesap, CA uyumsuzluğu yok",
6  "main_risk": "satın alınmış hype, paylaşımlar durduğunda alıcılar kaçacak",
7  "stage": "grok",
8  "symbol": "ORNEK",
9  "reason": "her zorlu kontrolü geçiyor ama ilk 30 paylaşım bu hafta açılmış hesaplardan geldi, aynı ifadeler kullanılmış."
10}

1FİKİRLERDEN ÖNCE GERÇEKLER. Grok hiçbir zaman bir mint'in açık olup olmadığına karar vermez.
2BAŞARISIZ BİR ÇAĞRI ATLA DEMEKTİR. Rugcheck çöktü, DexScreener çöktü, Grok çöktü, hatalı JSON: ATLA.
3NULL TEMİZ DEĞİLDİR. Geri dönmeyen bir alan token'ı eler, asla geçirmez.
4TOKEN BAŞINA TEK KARAR. BUY diyene kadar asla yeniden çalıştırma. Katılmıyorsan, config.py'ye katılmıyorsun demektir.
5ALIMLARI DEĞİL, ELEME NEDENLERİNİ OKU. alımlar iyi hissettirir. eleme nedenleri filtrenin işe yarayıp yaramadığını söyler.

1Her 10 dakikada bir, /workspace/desk dizininde python watch.py çalıştır.
2Hiçbir şey yazdırmazsa, hiçbir şey söyleme. Herhangi bir şey yazdırırsa, buraya kelimesi kelimesine gönder.

1Her 30 dakikada bir, /workspace/desk dizininde python scan.py çalıştır.
2Sadece BUY kararlarını paylaş: symbol, confidence, x_read.
3Rugcheck veya DexScreener çökerse, bunu her çalıştırmada değil sadece bir kez hangisi olduğunu söyleyerek belirt.

1Her gün 21:30'da, /workspace/desk dizininde python report.py çalıştır ve çıktıyı buraya gönder.
2Bugün işe yarayan bir şey ve config.py'de sorgulayacağın bir sayıyı nedeni ile birlikte ekle.
3O sayıyı asla kendin değiştirme.

1# report.py
2# akşam raporu. içindeki her şey checks.csv ve trades.csv'den gelir, hafızadan hiçbir şey gelmez.
3import csv, os, time
4from collections import Counter
5from config import LOG, PAPER
6import book
7
8day = time.strftime("%Y-%m-%d")
9checks = [r for r in csv.DictReader(open(LOG))] if os.path.exists(LOG) else []
10checks = [r for r in checks if r["time"].startswith(day)]
11done = [t for t in book.trades() if t["time"].startswith(day) and t["action"] != "open"]
12
13by_stage = Counter(r["stage"] for r in checks if r["verdict"] == "SKIP")
14buys = [r for r in checks if r["verdict"] == "BUY"]
15wins = [t for t in done if float(t["pnl"]) > 0]
16reasons = Counter(r["reason"] for r in checks if r["stage"] in ("facts", "pool"))
17
18print(f"AKŞAM RAPORU {day} {'(PAPER)' if PAPER else '(CANLI)'}")
19print(f"kontrol edilen: {len(checks)}")
20print(f"rug filtresi tarafından elenen: {by_stage['facts']} | havuz tarafından: {by_stage['pool']} | "
21      f"Grok tarafından: {by_stage['grok']} | limitler tarafından: {by_stage['limits']}")
22print(f"alınan: {len(buys)} | şu an açık: {len(book.load())}")
23print(f"bugün gerçekleşen pnl: ${book.today_pnl():+.2f}")
24if done:
25    print(f"kârlı çıkışlar: {len(wins)}/{len(done)}")
26    best = max(done, key=lambda t: float(t["pnl"]))
27    worst = min(done, key=lambda t: float(t["pnl"]))
28    print(f"en iyi: {best['symbol']} ${float(best['pnl']):+.2f} | en kötü: {worst['symbol']} ${float(worst['pnl']):+.2f}")
29if reasons:
30    top, n = reasons.most_common(1)[0]
31    print(f"en yaygın eleme nedeni: {top} ({n}x)")

1# scan.py
2# isteğe bağlı lead kaynağı: az önce DexScreener profili için ödeme yapmış yeni Solana token'ları.
3# ücretli bir profil kalite sinyali değildir, sadece geliştiricinin para harcadığı anlamına gelir. filtre karar verir.
4import csv, os, subprocess, sys
5import requests
6from config import LOG
7
8seen = {r["mint"] for r in csv.DictReader(open(LOG))} if os.path.exists(LOG) else set()
9r = requests.get("https://api.dexscreener.com/token-profiles/latest/v1", timeout=15)
10r.raise_for_status()
11fresh = [t["tokenAddress"] for t in r.json()
12         if t.get("chainId") == "solana" and t.get("tokenAddress") not in seen]
13
14for mint in fresh[:5]:                   # çalıştırma başına beş, böylece yoğun bir saat API bütçesini tüketemez
15    subprocess.run([sys.executable, "check.py", mint])

1Herhangi bir cüzdan bağlantısı, imza, swap veya transferden önce sor.
2config.py adlı herhangi bir dosyayı düzenlemeden önce sor.

1xAI'den 401              -> hatalı anahtar. Devral, .env'yi yeniden yaz, 03. adımdaki curl'ü tekrar çalıştır.
2xAI'den 400 / 404        -> model adı değişmiş. config.py'deki MODEL'i düzelt, başka hiçbir şeyi değiştirme.
3xAI'den 429              -> rate limit. o token bir SKIP'tır, sonraki çalıştırma devam eder. asla döngüye sokma.
4x_search hakkında hata   -> MODEL'in X'te arama yapamıyor. console.x.ai -> Models kısmından yapabilen birini seç.
5Grok düzyazıyla cevap verirse -> ValueError, loglanır, SKIP. asla bir paragrafı işleme dönüştürme.
6rugcheck 404 veya boş    -> indekslenmek için çok yeni. ATLA. yeni olmak temiz olmak değildir.
7her şeyde lp_unlocked    -> bazı havuz türlerinde hiç LP token'ı yoktur. o sayıya dokunmadan önce rugcheck'te kendin bir tane aç
8                             ve değişikliği yazılı olarak yap.
9no_pool                  -> henüz bir DEX'te işlem görmüyor veya Solana değil. ATLA.
10rutinler sustu           -> uzun süre uzak kaldığında Grok Bot rutinleri duraklatır.
11                             Routines'i aç ve tekrar etkinleştir.

1cost_per_token = input_tokens / 1_000_000 * price_per_M_input
2               + output_tokens / 1_000_000 * price_per_M_output
3               + posts_fetched / 1_000 * 5          # X araması: çekilen 1.000 paylaşım başına 5$
4
5max_turns = 2 aramayı iki turla sınırlar, böylece posts_fetched düşük kalır.
6her yanıt kendi x_posts_fetched değerini bildirir, yani ilk gün gerçek sayıyı öğrenirsiniz.
7
8fiyat: [console.x.ai'den alınan fiyat]