एक रात में शून्य से Grok Bot बनाएं: पूरी सेटअप + कॉपी-पेस्ट रग फ़िल्टर

1Name: RUG DESK
2Job: Solana memecoin desk, paper first
3Description: मेरे द्वारा पेस्ट किए गए आर्टिकल से /workspace/desk में डेस्क बनाओ और चलाओ।
4हर टोकन check.py से गुज़रेगा, कोई अपवाद नहीं, कोई शॉर्टकट नहीं।
5तुम कभी फंड्स नहीं खरीदोगे, बेचोगे, साइन नहीं करोगे या ट्रांसफर नहीं करोगे। तुम config.py को कभी एडिट नहीं करोगे जब तक मैं
6इस चैट में न कहूँ। तुम किसी टोकन को पास करने के लिए कभी फिल्टर नंबर कम नहीं करोगे।
7हर किल की रिपोर्ट उसके कारण के साथ दो, टोकन पर अपनी राय के साथ नहीं।
8जब कोई सोर्स डाउन हो, बताओ कौन सा है और उसे छोड़ दो। कभी किसी गायब नंबर का अनुमान मत लगाओ।

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. LEAD     कहीं से भी एक CA: कोई कॉल, पोस्ट, scan.py    -> एक मिंट
21. LIMITS   book.py: दैनिक नुकसान, ओपन स्लॉट्स, कूलडाउन      -> फ्री, कोई नेटवर्क नहीं
32. FACTS    rugcheck.py: 10 कठोर किल                     -> ओपन मिंट, अनलॉक्ड LP, भारी टॉप 10 यहाँ मरते हैं
43. POOL     market.py: डेप्थ, उम्र, सेल्स                   -> पतले पूल और हनीपॉट यहाँ मरते हैं
54. JUDGE    grok.py + X सर्च, एक कॉल                   -> BUY या SKIP, एक कारण, एक रिस्क
65. FILL     पेपर: book.py लाइव प्राइस पर               -> लाइव: तुम खुद साइन करते हो
76. WATCH    watch.py हर 10 मिनट में                      -> स्टॉप, लैडर, ट्रेल, टाइम स्टॉप
87. REPORT   report.py 21:30 पर                             -> क्या मरा, क्या भुगतान किया, किस पर सवाल उठाना है

1# config.py
2# डेस्क का हर नंबर यहाँ रहता है। जब तुम रीट्यून करते हो, तो बस यही फाइल एडिट करनी होती है और कुछ नहीं।
3
4MODEL = "grok-4.7"          # अगर API इसे रिजेक्ट करे तो console.x.ai -> Models चेक करो
5PAPER = True                # पहला हफ्ता: असली कीमतों पर नकली फिल। लॉग पढ़ने के बाद ही इसे बदलो
6
7TICKET_USD = 25             # फ्लैट। पिछली जीत के आधार पर कभी साइज़ मत तय करो
8MAX_OPEN = 4                # मार्केट में अधिकतम 4 x $25 = $100
9MAX_ENTRIES_PER_DAY = 6
10DAILY_LOSS_HALT_USD = 50    # आज का रियलाइज़्ड लॉस इतना हो जाए -> कल तक कोई नई एंट्री नहीं
11COOLDOWN_HOURS = 24         # जिस टोकन से अभी निकले हो उसमें दोबारा एंट्री नहीं
12
13FACTS = {                   # रग फिल्टर। सिर्फ कोड, कोई मॉडल नहीं
14    "max_risk_score": 40,       # rugcheck score_normalised, 0-100, जितना ज़्यादा = उतना रिस्की
15    "min_lp_locked_pct": 90,    # सबसे बड़ा पूल: LP लॉक्ड या बर्न किया हुआ
16    "max_top10_pct": 30,        # टॉप 10 होल्डर्स, पूल्स और लॉकर्स को छोड़कर
17    "max_dev_pct": 5,           # सप्लाई जो अभी भी क्रिएटर वॉलेट में पड़ी है
18    "max_insiders": 0,          # इनसाइडर-फ्लैग्ड होल्डर्स + इनसाइडर ग्राफ हिट्स
19    "min_liquidity_usd": 30000,
20    "max_ticket_share": 0.01,   # तुम्हारा टिकट कभी पूल के 1% से ज़्यादा नहीं होना चाहिए
21    "min_age_min": 30,          # इससे कम उम्र में, हर रिपोर्ट अभी भी अनुमान ही है
22    "max_age_hours": 72,
23}
24
25MIN_CONFIDENCE = 0.7        # Grok इससे नीचे BUY कहे -> तो SKIP माना जाएगा
26
27EXIT = {
28    "stop_pct": -35,                        # एंट्री से हार्ड स्टॉप
29    "ladder": [(100, 0.50), (200, 0.25)],   # +100% पर आधा बेचो, +200% पर एक चौथाई
30    "trail_pct": 30,                        # बाकी: जब कीमत पीक से 30% गिरे तो बाहर
31    "time_stop_hours": 6,                   # 6 घंटे बाद 20% ऊपर नहीं -> बाहर, डेड मनी
32    "time_stop_min_pct": 20,
33    "liq_drop_pct": 40,                     # पूल लिक्विडिटी एंट्री से 40% गिरे -> अभी बाहर
34}
35
36LOG = "checks.csv"
37POSITIONS = "positions.json"
38TRADES = "trades.csv"

1FLAT TICKET। साइज़ इसलिए नहीं बढ़ता क्योंकि पिछले तीन जीत गए थे।
2बॉट config.py पढ़ता है, कभी लिखता नहीं। नंबर तभी बदलता है जब तुम बदलते हो।
3फिल्टर लिखकर ढीला किया जाता है। तुम नंबर बदलते हो, तो उसी दिन चैट में कारण बताते हो।

1# book.py
2# पोजीशन्स, ट्रेड्स, लिमिट्स। डेस्क की मेमोरी उन दो फाइलों में रहती है जिन्हें तुम खुद खोल सकते हो।
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    """लिमिट्स किसी भी नेटवर्क कॉल से पहले चलते हैं। रुकी हुई एंट्री का कोई खर्च नहीं होता।"""
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    """ORIGINAL साइज़ का एक हिस्सा बेचता है (1.0 = बचा हुआ सब कुछ)। रियलाइज़्ड PnL रिटर्न करता है।"""
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    # लाइव मोड: अपने वॉलेट में खरीदने के बाद ->  python book.py add <mint> <usd> <price> <liq_usd>
66    # हाथ से बेचने के बाद                     ->  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# हर ओपन पोजीशन, हर 10 मिनट में। जब कुछ नहीं बदलता तो कुछ प्रिंट नहीं करता।
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']}: price feed down ({e}), holding, will retry")
15            continue
16        if not m or m["price"] <= 0:
17            events.append(f"{p['symbol']}: pool gone. treat as rugged, sell what you can")
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 = "sold" if PAPER else "SELL NOW in your wallet"
30            size = "the rest" if frac >= 1 else f"{int(frac * 100)}%"
31            events.append(f"{s['symbol']}: {verb} {size} at {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)

1LIQUIDITY FIRST। खिंचा हुआ पूल हर दूसरे नियम को हरा देता है, यहाँ तक कि हरी पोजीशन पर भी।
2TRAIL पहली बुकिंग के बाद तैयार होता है। उससे पहले, -35% ही एकमात्र फ्लोर है।
3DEAD MONEY भी नुकसान है। छह शांत घंटे अगले टोकन के लिए स्लॉट खाली कर देते हैं।
4SILENCE IS A STATUS। watch.py तब कुछ प्रिंट नहीं करता जब कुछ नहीं बदलता, इसलिए शांत चैट का मतलब है कि तुम्हें देखने की ज़रूरत नहीं है।

1# rugcheck.py
2# हर टोकन की एक रिपोर्ट, जिसे उन फील्ड्स तक सीमित किया गया है जिन्हें डेस्क पढ़ती है। Grok कभी रॉ रिपोर्ट नहीं देखता।
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 वॉल्ट्स और लॉकर्स टॉप होल्डर्स में होते हैं, वे व्हेल नहीं हैं
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    """सीधी तुलनाएँ। पहली विफलता जीतती है, कारण लॉग हो जाता है।"""
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# खुद पूल: डेप्थ, उम्र, कीमत, और क्या कोई सच में बेच सकता है।
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# यह एकमात्र फ़ाइल है जिसमें key रखी जाती है और यही एक जगह है जहाँ desk xAI से बात करता है।
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("no XAI_API_KEY in the environment or in .env")
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    """एक कॉल, JSON इनपुट, JSON आउटपुट। जो कुछ भी JSON नहीं है वह error देगा, और error का मतलब upstream पर SKIP है।"""
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          # खोज के दो राउंड, फिर उसे जवाब देना ही होगा
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"no json in answer: {text[:200]}")
45    return json.loads(text[start:end + 1])

1# prompts.py
2# desk पर मौजूद एकमात्र Grok prompt। यही वह फ़ाइल है जिसे आप वास्तव में दोबारा पढ़ेंगे।
3
4JUDGE_PROMPT = """
5तुम RUG DESK हो। एक Solana memecoin ने अभी-अभी कोड में हर hard check पास कर लिया है:
6authorities, LP, holders, dev wallet, insiders, pool depth, age।
7उन नंबरों को दोबारा चेक मत करो। तुम्हें तय करना है कि क्या एक flat ticket अंदर जाएगा।
8तुम कभी size तय नहीं करते, तुम कभी exits नहीं चुनते।
9
10INPUT: {"token": {...rugcheck facts...}, "pool": {...dexscreener facts...}}
11
12STEP 1. पिछले 72 घंटों के लिए X पर ticker और contract address सर्च करो।
13STEP 2. सिर्फ वही judge करो जो कोड नहीं देख सकता:
14  - क्या warn-level के रिस्क मिलकर कुछ और बुरा बन जाते हैं
15  - सबसे पहले किसने पोस्ट किया: dev ने, हिस्ट्री वाले किसी असली account ने, या नए accounts की बाढ़ ने
16  - organic या खरीदा हुआ: एक जैसे शब्द, एक ही मिनट, बिना किसी past वाले accounts
17  - क्या उन पोस्ट्स में दिया गया contract address INPUT वाले से मेल खाता है
18  - क्या इस ticker नाम या इस dev का पहले किसी rug से नाता रहा है
19
20सिर्फ JSON RETURN करो:
21{"verdict": "BUY" | "SKIP", "confidence": 0.0-1.0,
22 "why": "अधिकतम दो लाइन", "x_read": "X कैसा दिखता है इस पर एक लाइन",
23 "main_risk": "एक लाइन"}
24
25X पर शून्य पोस्ट भी एक जवाब है: कोई नहीं जानता कि यह मौजूद है। SKIP।
26X पर उसी ticker के तहत कोई दूसरा contract address: copycat का रिस्क। SKIP।
27जब भी तुम्हें जिस field की जरूरत थी वह null हो, तो कभी BUY जवाब मत दो।
28कभी price targets का जिक्र मत करो। तुम उन्हें नहीं जानते।
29"""

1# check.py
2# एक contract address अंदर, एक verdict बाहर। जब भी कोई token आपके desk पर आता है, यह हर बार चलता है।
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)):                                  # limits, free
22        return {"stage": "limits", "verdict": "SKIP", "reason": g}
23
24    try:
25        token = report(mint)                                     # rug filter, free
26    except Exception as e:
27        return {"stage": "facts", "verdict": "SKIP", "reason": f"rugcheck failed: {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)                                           # pool, free
33    except Exception as e:
34        return {"stage": "pool", "verdict": "SKIP", "reason": f"dexscreener failed: {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)   # एकमात्र paid step
40    except Exception as e:
41        return {"stage": "grok", "verdict": "SKIP", "reason": f"grok failed: {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"low confidence {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"APPROVAL NEEDED: buy ${TICKET_USD} of {v['symbol']} in your own wallet, "
60                           f"then run: 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": "हर hard check पास करता है, लेकिन पहली 30 पोस्ट्स इसी हफ्ते बने accounts से आईं, एक जैसे शब्दों के साथ।",
5  "x_read": "एक असली account, नए accounts की बाढ़, कोई CA mismatch नहीं",
6  "main_risk": "खरीदा हुआ hype, पोस्टिंग रुकते ही buyers निकल जाएंगे",
7  "stage": "grok",
8  "symbol": "EXAMPLE",
9  "reason": "हर hard check पास करता है, लेकिन पहली 30 पोस्ट्स इसी हफ्ते बने accounts से आईं, एक जैसे शब्दों के साथ।"
10}

1राय से पहले तथ्य। Grok कभी तय नहीं करता कि कोई mint खुला है या नहीं।
2FAILED CALL का मतलब SKIP है। Rugcheck डाउन, DexScreener डाउन, Grok डाउन, खराब JSON: SKIP।
3NULL का मतलब साफ नहीं है। जो field वापस नहीं आई वह token को खत्म कर देती है, उसे पास नहीं कराती।
4प्रति TOKEN एक VERDICT। जब तक यह BUY न कहे, कभी दोबारा न चलाएं। अगर आप असहमत हैं, तो आप config.py से असहमत हैं।
5BUYS को नहीं, KILLS को पढ़ें। buys अच्छा महसूस कराते हैं। kill reasons आपको बताते हैं कि filter काम कर रहा है या नहीं।

1हर 10 मिनट में, /workspace/desk में python watch.py चलाओ।
2अगर यह कुछ प्रिंट नहीं करता, तो कुछ मत कहो। अगर यह कुछ प्रिंट करता है, तो उसे शब्द-दर-शब्द यहाँ पोस्ट करो।

1हर 30 मिनट में, /workspace/desk में python scan.py चलाओ।
2सिर्फ BUY verdicts पोस्ट करो: symbol, confidence, x_read।
3अगर Rugcheck या DexScreener डाउन है, तो एक बार बताओ कि कौन सा है, हर run पर नहीं।

1हर दिन 21:30 बजे, /workspace/desk में python report.py चलाओ और output यहाँ पोस्ट करो।
2आज जो एक चीज़ काम आई उसे जोड़ो और config.py में उस एक number पर सवाल उठाओ जिस पर तुम्हें शक है, कारण सहित।
3वह number खुद कभी मत बदलो।

1# report.py
2# शाम की रिपोर्ट। इसमें सब कुछ checks.csv और trades.csv से आता है, memory से कुछ नहीं।
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"EVENING REPORT {day} {'(PAPER)' if PAPER else '(LIVE)'}")
19print(f"checked: {len(checks)}")
20print(f"killed by rug filter: {by_stage['facts']} | by pool: {by_stage['pool']} | "
21      f"by Grok: {by_stage['grok']} | by limits: {by_stage['limits']}")
22print(f"bought: {len(buys)} | open now: {len(book.load())}")
23print(f"realized pnl today: ${book.today_pnl():+.2f}")
24if done:
25    print(f"green exits: {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"best: {best['symbol']} ${float(best['pnl']):+.2f} | worst: {worst['symbol']} ${float(worst['pnl']):+.2f}")
29if reasons:
30    top, n = reasons.most_common(1)[0]
31    print(f"most common kill: {top} ({n}x)")

1# scan.py
2# वैकल्पिक lead source: नए Solana tokens जिन्होंने अभी-अभी DexScreener profile के लिए पैसे दिए।
3# paid profile quality का signal नहीं है, इसका मतलब सिर्फ इतना है कि dev ने पैसा खर्च किया। filter तय करता है।
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]:                   # प्रति run पाँच, ताकि एक व्यस्त घंटा API budget खत्म न कर दे
15    subprocess.run([sys.executable, "check.py", mint])

1किसी भी wallet connection, signature, swap या transfer से पहले पहले पूछो।
2config.py नाम की किसी भी फ़ाइल को edit करने से पहले पहले पूछो।

1xAI से 401              -> खराब key। Take over करें, .env फिर से लिखें, step 03 वाला curl दोबारा चलाएं।
2xAI से 400 / 404        -> model का नाम बदल गया। config.py में MODEL ठीक करें, और कुछ नहीं।
3xAI से 429              -> rate limit। वह token SKIP है, अगला run आगे बढ़ जाएगा। इसे कभी loop न करें।
4x_search से जुड़ी error -> आपका MODEL X सर्च नहीं कर सकता। console.x.ai -> Models में से कोई ऐसा चुनें जो कर सके।
5Grok prose में जवाब दे  -> ValueError, logged, SKIP। कभी किसी paragraph को trade में न बदलें।
6rugcheck 404 या खाली     -> index होने के लिए बहुत नया। SKIP। नया होने का मतलब साफ होना नहीं है।
7सब पर lp_unlocked       -> कुछ pool types में LP token होता ही नहीं। उस number को छूने से पहले खुद rugcheck पर एक खोलें,
8                             और उसे लिखित में बदलें।
9no_pool                 -> अभी DEX पर trade नहीं हो रहा, या Solana नहीं है। SKIP।
10routines शांत हो गए    -> आपके लंबे समय तक दूर रहने के बाद Grok Bot routines को pause कर देता है।
11                             Routines खोलें और उन्हें वापस on करें।

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 search: 1,000 fetched posts पर $5
4
5max_turns = 2 search को दो rounds तक सीमित रखता है, इसलिए posts_fetched छोटा रहता है।
6हर response अपना x_posts_fetched बताता है, इसलिए पहले दिन ही आपको असली number पता चल जाता है।
7
8price: [console.x.ai से price]