Xây dựng Grok Bot từ số 0 trong một đêm: Hướng dẫn thiết lập đầy đủ + bộ lọc rug copy-paste

1Tên: RUG DESK
2Nhiệm vụ: Bàn giao dịch memecoin Solana, chạy paper trước
3Mô tả: Dựng và vận hành bộ khung trong /workspace/desk dựa trên bài viết tôi dán vào.
4Mọi token đều phải qua check.py, không ngoại lệ, không đường tắt.
5Bạn không bao giờ được mua, bán, ký hay di chuyển tiền. Bạn không bao giờ sửa config.py trừ khi tôi yêu cầu
6trong khung chat này. Bạn không bao giờ hạ thông số bộ lọc để cho một token lọt qua.
7Báo cáo mỗi lần loại bỏ kèm lý do, không phải ý kiến cá nhân của bạn về token đó.
8Khi một nguồn bị sập, hãy nói rõ nguồn nào và bỏ qua. Không bao giờ được đoán bừa một con số bị thiếu.

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     một CA từ bất cứ đâu: cuộc gọi, bài đăng, scan.py    -> một địa chỉ mint
21. LIMITS   book.py: lỗ ngày, slot trống, thời gian chờ      -> miễn phí, không cần mạng
32. FACTS    rugcheck.py: 10 tiêu chí loại thẳng tay                     -> mint mở, LP chưa khóa, top 10 nắm quá nhiều sẽ chết ở đây
43. POOL     market.py: độ sâu, tuổi thọ, lực bán                   -> pool mỏng và honeypot chết ở đây
54. JUDGE    grok.py + tìm kiếm X, gọi một lần                   -> MUA hoặc BỎ QUA, một lý do, một rủi ro
65. FILL     paper: book.py khớp giá thật               -> live: bạn tự tay ký lệnh
76. WATCH    watch.py mỗi 10 phút                      -> cắt lỗ, chốt lời từng phần, trailing stop, cắt lỗ theo thời gian
87. REPORT   report.py lúc 21:30                             -> cái nào chết, cái nào sinh lời, cái nào cần nghi ngờ

1# config.py
2# mọi con số của bộ khung đều nằm ở đây. khi tinh chỉnh, bạn chỉ sửa file này và không gì khác.
3
4MODEL = "grok-4.7"          # kiểm tra console.x.ai -> Models nếu API từ chối
5PAPER = True                # tuần đầu: khớp lệnh giả với giá thật. chỉ đổi sau khi bạn đọc xong log
6
7TICKET_USD = 25             # cố định. không bao giờ tăng size vì mấy lệnh trước thắng
8MAX_OPEN = 4                # tối đa 4 x $25 = $100 trên thị trường
9MAX_ENTRIES_PER_DAY = 6
10DAILY_LOSS_HALT_USD = 50    # lỗ thực tế hôm nay chạm mức này -> không vào lệnh mới cho đến mai
11COOLDOWN_HOURS = 24         # không vào lại token vừa thoát ra
12
13FACTS = {                   # bộ lọc rug. chỉ dùng code, không dùng model
14    "max_risk_score": 40,       # score_normalised của rugcheck, 0-100, càng cao càng rủi ro
15    "min_lp_locked_pct": 90,    # pool lớn nhất: LP phải được khóa hoặc đốt
16    "max_top10_pct": 30,        # top 10 holder, không tính pool và locker
17    "max_dev_pct": 5,           # lượng cung còn nằm trong ví creator
18    "max_insiders": 0,          # holder bị gắn cờ insider + số hit insider trên graph
19    "min_liquidity_usd": 30000,
20    "max_ticket_share": 0.01,   # lệnh của bạn không bao giờ vượt quá 1% pool
21    "min_age_min": 30,          # non hơn mức này thì mọi báo cáo vẫn chỉ là đoán mò
22    "max_age_hours": 72,
23}
24
25MIN_CONFIDENCE = 0.7        # Grok hô MUA dưới mức này -> coi như BỎ QUA
26
27EXIT = {
28    "stop_pct": -35,                        # cắt lỗ cứng tính từ điểm vào
29    "ladder": [(100, 0.50), (200, 0.25)],   # lãi +100% bán nửa, +200% bán thêm một phần tư
30    "trail_pct": 30,                        # phần còn lại: thoát khi giá giảm 30% từ đỉnh
31    "time_stop_hours": 6,                   # không tăng 20% sau 6 giờ -> thoát, tiền chết
32    "time_stop_min_pct": 20,
33    "liq_drop_pct": 40,                     # thanh khoản pool giảm 40% so với lúc vào -> thoát ngay
34}
35
36LOG = "checks.csv"
37POSITIONS = "positions.json"
38TRADES = "trades.csv"

1LỆNH CỐ ĐỊNH. khối lượng không bao giờ tăng chỉ vì ba lệnh trước thắng.
2BOT ĐỌC config.py, NÓ KHÔNG BAO GIỜ GHI VÀO ĐÓ. con số chỉ thay đổi khi bạn tự tay đổi.
3NỚI LỎNG BỘ LỌC PHẢI ĐƯỢC GHI LẠI. bạn đổi một con số, bạn phải nói lý do trong chat, ngay trong ngày.

1# book.py
2# vị thế, giao dịch, giới hạn. bộ nhớ của hệ thống nằm trong hai file bạn có thể tự mở.
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    """Giới hạn chạy trước mọi lệnh gọi mạng. Một lệnh vào bị chặn không tốn xu nào."""
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    """Bán một phần của KHỐI LƯỢNG BAN ĐẦU (1.0 = bán hết phần còn lại). Trả về pnl thực tế."""
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    # chế độ live: sau khi bạn mua bằng ví của mình ->  python book.py add <mint> <usd> <price> <liq_usd>
66    # sau khi bạn tự tay bán                     ->  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# kiểm tra mọi vị thế đang mở, mỗi 10 phút. không in gì nếu không có thay đổi.
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']}: nguồn cấp giá sập ({e}), đang giữ, sẽ thử lại")
15            continue
16        if not m or m["price"] <= 0:
17            events.append(f"{p['symbol']}: pool biến mất. coi như bị rug, bán được bao nhiêu thì bán")
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 = "đã bán" if PAPER else "BÁN NGAY trong ví của bạn"
30            size = "phần còn lại" if frac >= 1 else f"{int(frac * 100)}%"
31            events.append(f"{s['symbol']}: {verb} {size} ở mức {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)

1THANH KHOẢN LÀ TRÊN HẾT. một pool bị rút tiền đánh bại mọi luật khác, kể cả khi vị thế đang xanh.
2TRAILING STOP CHỈ KÍCH HOẠT SAU LẦN CHỐT LỜI ĐẦU TIÊN. trước đó, -35% là sàn duy nhất.
3TIỀN CHẾT CŨNG LÀ THUA LỖ. sáu tiếng đi ngang giải phóng slot cho token tiếp theo.
4IM LẶNG CŨNG LÀ MỘT TRẠNG THÁI. watch.py không in gì nếu không có thay đổi, nên khung chat im lìm nghĩa là bạn không cần phải ngó tới.

1# rugcheck.py
2# một báo cáo cho mỗi token, cắt gọn còn đúng những trường bộ khung cần đọc. Grok không bao giờ thấy báo cáo thô.
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):  # vault AMM và locker nằm trong top holder, chúng không phải cá voi
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    """Chỉ là phép so sánh thuần túy. Lỗi đầu tiên thắng, lý do được ghi log."""
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# bản thân cái pool: độ sâu, tuổi thọ, giá, và liệu có ai thực sự bán được không.
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# tệp duy nhất chứa khóa API và là nơi duy nhất bàn giao dịch giao tiếp với 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("không tìm thấy XAI_API_KEY trong biến môi trường hoặc trong .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    """Một lần gọi, JSON vào, JSON ra. Bất cứ thứ gì không phải JSON đều sẽ báo lỗi, và lỗi nghĩa là BỎ QUA ở tầng trên."""
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          # hai vòng tìm kiếm, sau đó bắt buộc phải trả lời
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"không có json trong câu trả lời: {text[:200]}")
45    return json.loads(text[start:end + 1])

1# prompts.py
2# prompt Grok duy nhất trên bàn giao dịch. đây là tệp bạn sẽ thực sự đọc lại.
3
4JUDGE_PROMPT = """
5Bạn là RUG DESK. Một memecoin Solana vừa vượt qua mọi bước kiểm tra cứng trong mã nguồn:
6quyền hạn, LP, người nắm giữ, ví dev, nội gián, độ sâu pool, tuổi token.
7Đừng kiểm tra lại những con số đó. Bạn quyết định xem có đưa một vé cược cố định vào hay không.
8Bạn không bao giờ quyết định khối lượng, không bao giờ chọn điểm thoát lệnh.
9
10INPUT: {"token": {...dữ kiện từ rugcheck...}, "pool": {...dữ kiện từ dexscreener...}}
11
12BƯỚC 1. Tìm kiếm trên X theo ticker và địa chỉ hợp đồng, trong 72 giờ qua.
13BƯỚC 2. Chỉ đánh giá những gì mã nguồn không thấy được:
14  - các rủi ro mức cảnh báo có cộng dồn thành vấn đề nghiêm trọng hơn không
15  - ai đăng bài đầu tiên: dev, một tài khoản thật có lịch sử, hay một loạt tài khoản mới tạo
16  - tự nhiên hay mua chuộc: cùng một nội dung, cùng một phút, tài khoản không có quá khứ
17  - địa chỉ hợp đồng trong các bài đăng đó có giống với INPUT không
18  - tên ticker này hoặc dev này đã từng dính phốt rug trước đây chưa
19
20CHỈ TRẢ VỀ JSON:
21{"verdict": "BUY" | "SKIP", "confidence": 0.0-1.0,
22 "why": "tối đa hai dòng", "x_read": "một dòng mô tả tình hình trên X",
23 "main_risk": "một dòng"}
24
25Không có bài đăng nào trên X cũng là một câu trả lời: chẳng ai biết nó tồn tại. SKIP.
26Có một địa chỉ hợp đồng khác dưới cùng ticker trên X: rủi ro hàng nhái. SKIP.
27KHÔNG BAO GIỜ trả lời BUY khi một trường bạn cần bị null.
28KHÔNG BAO GIỜ nhắc đến mục tiêu giá. Bạn không biết chúng.
29"""

1# check.py
2# một địa chỉ hợp đồng vào, một phán quyết ra. chạy mỗi khi có token đi qua bàn giao dịch của bạn.
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)):                                  # giới hạn, miễn phí
22        return {"stage": "limits", "verdict": "SKIP", "reason": g}
23
24    try:
25        token = report(mint)                                     # bộ lọc rug, miễn phí
26    except Exception as e:
27        return {"stage": "facts", "verdict": "SKIP", "reason": f"rugcheck thất bại: {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, miễn phí
33    except Exception as e:
34        return {"stage": "pool", "verdict": "SKIP", "reason": f"dexscreener thất bại: {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)   # bước trả phí duy nhất
40    except Exception as e:
41        return {"stage": "grok", "verdict": "SKIP", "reason": f"grok thất bại: {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"độ tin cậy thấp {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"MUA GIẤP ${TICKET_USD} ở giá {v['price']}"
58        else:
59            v["action"] = (f"CẦN PHÊ DUYỆT: hãy mua ${TICKET_USD} {v['symbol']} trong ví của bạn, "
60                           f"sau đó chạy: python book.py add {mint} {TICKET_USD} <giá khớp> {v['liq_usd']}")
61    print(json.dumps(v, indent=2))

1{
2  "verdict": "SKIP",
3  "confidence": 0.78,
4  "why": "vượt qua mọi bước kiểm tra cứng, nhưng 30 bài đăng đầu tiên đến từ các tài khoản mới tạo tuần này, cùng một nội dung.",
5  "x_read": "một tài khoản thật, một loạt tài khoản mới, không sai lệch CA",
6  "main_risk": "hype mua chuộc, người mua sẽ rời đi khi ngừng đăng bài",
7  "stage": "grok",
8  "symbol": "EXAMPLE",
9  "reason": "vượt qua mọi bước kiểm tra cứng, nhưng 30 bài đăng đầu tiên đến từ các tài khoản mới tạo tuần này, cùng một nội dung."
10}

1DỮ KIỆN TRƯỚC Ý KIẾN. Grok không bao giờ quyết định việc một mint có mở hay không.
2LỜI GỌI THẤT BẠI LÀ MỘT LỆNH BỎ QUA. Rugcheck sập, DexScreener sập, Grok sập, JSON lỗi: SKIP.
3NULL KHÔNG CÓ NGHĨA LÀ SẠCH. một trường không trả về dữ liệu sẽ loại token đó, chứ không bao giờ cho nó qua.
4MỖI TOKEN MỘT PHÁN QUYẾT. đừng bao giờ chạy lại cho đến khi nó báo BUY. nếu bạn không đồng ý, tức là bạn đang không đồng ý với config.py.
5HÃY ĐỌC CÁC LÝ DO LOẠI, CHỨ KHÔNG PHẢI CÁC LỆNH MUA. lệnh mua mang lại cảm giác tốt. lý do loại cho bạn biết bộ lọc có hoạt động hay không.

1Cứ 10 phút một lần, trong /workspace/desk chạy python watch.py.
2Nếu nó không in ra gì thì đừng nói gì. Nếu nó in ra bất cứ thứ gì, hãy đăng nguyên văn vào đây.

1Cứ 30 phút một lần, trong /workspace/desk chạy python scan.py.
2Chỉ đăng các phán quyết BUY: symbol, confidence, x_read.
3Nếu Rugcheck hoặc DexScreener bị sập, hãy nói rõ cái nào một lần thôi, đừng lặp lại ở mỗi lần chạy.

1Mỗi ngày lúc 21:30, trong /workspace/desk chạy python report.py và đăng kết quả vào đây.
2Thêm một điều hiệu quả hôm nay và một con số trong config.py mà bạn muốn đặt dấu hỏi, kèm lý do.
3Đừng bao giờ tự thay đổi con số đó.

1# report.py
2# báo cáo buổi tối. mọi thứ trong này đều lấy từ checks.csv và trades.csv, không có gì từ bộ nhớ.
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"BÁO CÁO BUỔI TỐI {day} {'(GIẤP)' if PAPER else '(THẬT)'}")
19print(f"đã kiểm tra: {len(checks)}")
20print(f"bị loại bởi bộ lọc rug: {by_stage['facts']} | bởi pool: {by_stage['pool']} | "
21      f"bởi Grok: {by_stage['grok']} | bởi giới hạn: {by_stage['limits']}")
22print(f"đã mua: {len(buys)} | đang mở: {len(book.load())}")
23print(f"lãi lỗ chốt hôm nay: ${book.today_pnl():+.2f}")
24if done:
25    print(f"thoát lệnh có lãi: {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"tốt nhất: {best['symbol']} ${float(best['pnl']):+.2f} | tệ nhất: {worst['symbol']} ${float(worst['pnl']):+.2f}")
29if reasons:
30    top, n = reasons.most_common(1)[0]
31    print(f"lý do loại phổ biến nhất: {top} ({n} lần)")

1# scan.py
2# nguồn tìm token tùy chọn: các token Solana mới vừa trả tiền mua hồ sơ DexScreener.
3# hồ sơ trả phí không phải tín hiệu chất lượng, chỉ có nghĩa là dev đã chịu chi tiền. bộ lọc sẽ quyết định.
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]:                   # năm token mỗi lần chạy, để một giờ cao điểm không làm cạn ngân sách API
15    subprocess.run([sys.executable, "check.py", mint])

1Hỏi trước khi thực hiện bất kỳ kết nối ví, ký, swap hay chuyển tiền nào.
2Hỏi trước khi chỉnh sửa bất kỳ tệp nào tên là config.py.

1401 từ xAI              -> khóa sai. Hãy Take over, viết lại .env, chạy lại lệnh curl từ bước 03.
2400 / 404 từ xAI        -> tên model đã đổi. sửa MODEL trong config.py, không làm gì khác.
3429 từ xAI              -> giới hạn tốc độ. token đó là SKIP, lần chạy sau sẽ bỏ qua. đừng bao giờ lặp lại nó.
4lỗi về x_search      -> MODEL của bạn không tìm kiếm được trên X. hãy chọn một model hỗ trợ trong console.x.ai -> Models.
5Grok trả lời bằng văn xuôi     -> ValueError, được ghi log, SKIP. đừng bao giờ biến một đoạn văn thành một lệnh giao dịch.
6rugcheck 404 hoặc trống     -> quá mới để lập chỉ mục. SKIP. mới không có nghĩa là sạch.
7lp_unlocked trên mọi thứ -> một số loại pool hoàn toàn không có token LP. hãy tự mở thử một cái trên rugcheck
8                             trước khi bạn đụng vào con số đó, và thay đổi nó bằng văn bản.
9no_pool                   -> chưa giao dịch trên DEX, hoặc không phải Solana. SKIP.
10tác vụ im lìm       -> Grok Bot tạm dừng các tác vụ sau khi bạn vắng mặt lâu.
11                             hãy mở Routines và bật chúng lại.

1chi_phí_mỗi_token = input_tokens / 1_000_000 * giá_mỗi_M_input
2               + output_tokens / 1_000_000 * giá_mỗi_M_output
3               + posts_fetched / 1_000 * 5          # tìm kiếm X: $5 cho mỗi 1.000 bài đăng được lấy
4
5max_turns = 2 giữ việc tìm kiếm ở hai vòng, nên posts_fetched luôn nhỏ.
6mỗi phản hồi đều tự báo cáo x_posts_fetched của nó, nên ngày đầu tiên sẽ cho bạn con số thực tế.
7
8giá: [giá từ console.x.ai]