สร้างบอท Funding Carry บน Hyperliquid ด้วย Python

สวัสดีครับเพื่อนๆ สาย Quant! ในบทความ Funding Carry บน Hyperliquid เราคุยกันเรื่องทฤษฎีของกลยุทธ์ Funding Carry แบบ Delta-Neutral ไปแล้ว — เปิด Long Spot คู่กับ Short Perp ขนาดเท่ากัน แล้วเก็บ Funding Rate ที่ Hyperliquid จ่ายทุกชั่วโมง วันนี้ถึงเวลาลงมือจริงครับ เราจะเขียน บอท Python ที่ทำงานครบวงจร ตั้งแต่สแกนหาเหรียญ เปิดสองขาอัตโนมัติ ไปจนถึงเฝ้าสถานะและเตือนเมื่อควรปิด และที่สำคัญ โค้ดทั้งหมดเปิดเป็น Open Source บน GitHub ให้เพื่อนๆ clone ไปเล่นและต่อยอดกันได้เลย

💻 โค้ดเต็มของบทความนี้: github.com/aoddy/blog → python-funding-carry-bot-hyperliquid

⚠️ Disclaimer: บทความนี้เป็นเนื้อหาเชิงการศึกษา ไม่ใช่คำแนะนำการลงทุน คริปโตมีความเสี่ยงสูง โปรดทดสอบบน Testnet และใช้ทุนที่รับความเสี่ยงได้เสมอครับ

ภาพรวมสถาปัตยกรรมของบอท

บอท Funding Carry ประกอบด้วย 3 โมดูลหลัก คือ Scanner (สแกนหาเหรียญที่ Funding บวกสูงและมีตลาด Spot), Executor (เปิด/ปิดสองขา Long Spot + Short Perp ให้ Delta เป็นศูนย์) และ Monitor (เฝ้าสถานะรายชั่วโมง เตือนเมื่อ Funding พลิกลบ, Delta เบี่ยง หรือใกล้โดน Liquidation).

ก่อนเขียนโค้ด มาดูภาพใหญ่กันก่อนว่าบอทของเราแบ่งงานอย่างไร:

โครงสร้างไฟล์ในโปรเจกต์เป็นแบบนี้ครับ:

main.py                  # CLI: scan / open / monitor / close
funding_carry/
  config.py              # โหลด config.json + env vars
  scanner.py             # สแกนหาเหรียญเป้าหมาย
  executor.py            # เปิด/ปิดสองขา
  monitor.py             # เฝ้าสถานะและแจ้งเตือน
config.example.json      # ตัวอย่างไฟล์ตั้งค่า

หลักการออกแบบที่ผมยึดไว้ 3 ข้อ:

• Dry-run เป็นค่าเริ่มต้น: ทุกคำสั่งจะ "พิมพ์แผน" ออกมาก่อน ไม่ส่งคำสั่งจริงจนกว่าเราจะสั่งเอง — เพราะบั๊กในบอทเทรดแปลว่าเงินหาย
• Testnet ก่อนเสมอ: config เริ่มต้นชี้ไป Testnet ของ Hyperliquid ซ้อมให้คล่องก่อนขึ้นสนามจริง
• Monitor แค่เตือน ไม่ตัดสินใจแทน: การปิดสถานะหรือ rebalance เป็นการตัดสินใจของเรา บอทมีหน้าที่ทำให้เรา "เห็น" ปัญหาเร็วที่สุด

เตรียมเครื่องมือ: SDK, API Wallet และ Config

การเชื่อมต่อ Hyperliquid ด้วย Python ใช้ hyperliquid-python-sdk อย่างเป็นทางการ โดยการอ่านข้อมูล (Info API) ไม่ต้องใช้ Key ส่วนการส่งคำสั่งซื้อขายต้องใช้ Private Key ของ API Wallet ซึ่งแยกจากกระเป๋าหลักเพื่อความปลอดภัย.

เริ่มจากติดตั้งของที่ต้องใช้:

git clone https://github.com/aoddy/blog.git
cd blog/python-funding-carry-bot-hyperliquid
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp config.example.json config.json

สร้าง API Wallet (อย่าใช้ Private Key กระเป๋าหลัก!)

ใครที่อ่านบทความ Python กับ HIP-4 มาแล้วจะคุ้นเคยดี: Hyperliquid ให้เราสร้าง API Wallet แยกจากกระเป๋าหลักได้ที่เมนู More → API บนหน้าเว็บ ตัว API Wallet เซ็นคำสั่งเทรดแทนกระเป๋าหลักได้ แต่ ถอนเงินไม่ได้ ต่อให้ Key หลุดก็จำกัดความเสียหาย

ค่าที่ต้องตั้งใน config.json:

🔒 กฎเหล็กเรื่อง Key: ไฟล์ config.json ถูกใส่ไว้ใน .gitignore แล้ว ห้าม commit key ขึ้น GitHub เด็ดขาด และถ้าจะรันบนเซิร์ฟเวอร์ ให้ส่ง key ผ่าน environment variable HL_SECRET_KEY แทน

โมดูลที่ 1 — Scanner: หาเหรียญที่ "ใช่" ไม่ใช่แค่ Funding สูง

Scanner ที่ดีต้องคัดกรอง 3 เงื่อนไขพร้อมกัน คือ Funding Rate เป็นบวกสูงกว่าเกณฑ์, Open Interest สูงพอที่ Slippage จะไม่กินกำไร และต้องมีตลาด Spot คู่ USDC บน Hyperliquid ให้เปิดขา Long ได้จริง.

ในบทความทฤษฎีเราเขียนสคริปต์สแกน Funding แบบง่ายไปแล้ว แต่พอทำเป็นบอทจริง เจอปัญหาทันทีครับ: เหรียญที่ Funding พุ่งสูงสุดมักเป็นเหรียญเล็กสภาพคล่องต่ำ และหลายเหรียญ ไม่มีตลาด Spot บน Hyperliquid — ไม่มี Spot ก็เปิดขา Long ไม่ได้ กลยุทธ์พังตั้งแต่ยังไม่เริ่ม ดังนั้น Scanner เวอร์ชันบอทต้องเช็กให้ครบ:

def scan(cfg: Config) -> list[Candidate]:
    info = Info(cfg.api_url, skip_ws=True)
    meta, asset_ctxs = info.meta_and_asset_ctxs()
    spot_tokens = spot_tradable_tokens(info)   # เหรียญที่มีคู่ Spot/USDC

    candidates = []
    for asset, ctx in zip(meta["universe"], asset_ctxs):
        funding = float(ctx["funding"])
        mark = float(ctx["markPx"])
        oi_usd = float(ctx["openInterest"]) * mark
        apr = funding * 24 * 365 * 100
        candidates.append(Candidate(
            coin=asset["name"], funding_hourly=funding, apr_pct=apr,
            open_interest_usd=oi_usd, mark_price=mark,
            has_spot=asset["name"] in spot_tokens,
        ))

    picked = [
        c for c in candidates
        if c.apr_pct >= cfg.min_apr_pct
        and c.open_interest_usd >= cfg.min_open_interest_usd
        and c.has_spot   # ต้องมี Spot ให้เปิดขา Long เท่านั้น
    ]
    picked.sort(key=lambda c: c.apr_pct, reverse=True)
    return picked

ส่วนฟังก์ชัน spot_tradable_tokens ใช้ info.spot_meta() ดึงรายชื่อคู่เทรด Spot ทั้งหมด แล้วเก็บเฉพาะเหรียญที่จับคู่กับ USDC (ดูโค้ดเต็มใน scanner.py)

ลองรันดูผลจริง (ข้อมูล Mainnet ณ วันที่เขียนบทความ):

$ python main.py scan

Coin        Funding/hr(%)    APR(%)    OI($M)
---------------------------------------------
PURR               0.0263     230.6       6.9
HYPE               0.0013      10.9    1419.5
PUMP               0.0013      10.9      41.3
MON                0.0013      10.9      26.0

เห็นอะไรน่าสนใจไหมครับ? PURR ให้ APR สูงถึง 230% แต่ Open Interest แค่ ~$7M ขณะที่ HYPE ให้ 10.9% แต่ OI สูงถึง $1,400M — นี่แหละคือ Trade-off คลาสสิก: Funding สูงผิดปกติมักไม่ยั่งยืน (คนจะแห่เข้ามา Short จน Funding ลดลง) ส่วนเหรียญใหญ่ Funding ต่ำกว่าแต่นิ่งกว่า สำหรับมือใหม่ผมแนะนำเริ่มจากเหรียญ OI สูงก่อนครับ

โมดูลที่ 2 — Executor: เปิดสองขาให้ Delta เป็นศูนย์

Executor เปิดสถานะ 2 ขาตามลำดับที่ปลอดภัย คือ ซื้อ Spot ก่อนแล้วจึง Short Perp ขนาดเท่ากัน โดยปัดขนาดตาม szDecimals ของเหรียญ ปัดราคาไม่เกิน 5 significant figures และใช้ Limit IOC Order พร้อม Slippage Buffer เพื่อควบคุมราคาเข้า.

นี่คือหัวใจของบอท และเป็นจุดที่มีรายละเอียดเล็กๆ ที่ทำให้คนเขียนบอทครั้งแรก "ส่งออเดอร์ไม่ผ่าน" กันบ่อยที่สุด ผมสรุปกับดักที่เจอมาให้ก่อน:

โค้ดส่วนสำคัญของ open_carry:

def open_carry(cfg: Config, coin: str) -> None:
    info, exchange = make_clients(cfg)

    mid = float(info.all_mids()[coin])
    sz_decimals = perp_sz_decimals(info, coin)
    size = round_size(cfg.notional_usd / mid, sz_decimals)

    buy_px = round_price(mid * (1 + SLIPPAGE_BUFFER))    # เผื่อ 0.5%
    sell_px = round_price(mid * (1 - SLIPPAGE_BUFFER))
    ioc = {"limit": {"tif": "Ioc"}}

    if cfg.dry_run:
        print("[DRY-RUN] ไม่ได้ส่งคำสั่งจริง")
        return

    # จำกัด leverage ขา Short ให้ต่ำ กันโดน liquidate
    exchange.update_leverage(cfg.leverage, coin, is_cross=True)

    # ขา 1: ซื้อ Spot ก่อน (พลาดแล้วเสียหายน้อยกว่า)
    spot_result = exchange.order(f"{coin}/USDC", True, size, buy_px, ioc)
    if spot_result["status"] != "ok":
        raise RuntimeError("เปิดขา Spot ไม่สำเร็จ — ไม่เปิดขา Perp ต่อ")

    # ขา 2: Short Perp ขนาดเท่ากัน
    perp_result = exchange.order(coin, False, size, sell_px, ioc)
    if perp_result["status"] != "ok":
        print("⚠️ ขา Perp ไม่ติด! ตอนนี้ถือ Spot ขาเดียว (มี delta) "
              "รีบปิด Spot หรือเปิด Short ด้วยมือทันที")

สังเกตว่าโค้ดจัดการเคส "ติดขาเดียว" อย่างระมัดระวัง: ถ้าขา Spot ไม่สำเร็จ เราหยุดทันทีไม่เปิด Perp ต่อ แต่ถ้า Spot ติดแล้ว Perp ไม่ติด — นี่คือสถานการณ์อันตรายเพราะพอร์ตมี delta ค้าง บอทจะตะโกนเตือนให้เราแก้ทันที (เวอร์ชันโปรดักชันอาจ retry หรือ auto-close ได้ แต่ผมตั้งใจให้เวอร์ชันการศึกษาเตือนคนก่อน)

ลองรันแบบ dry-run ดูแผนก่อนของจริง:

$ python main.py open HYPE

=== DRY-RUN MODE: จะไม่มีการส่งคำสั่งจริง ===

[PLAN] HYPE: mid=67.0865 size=1.49
[PLAN] ขา 1: BUY  HYPE/USDC (Spot) sz=1.49 px<=67.422
[PLAN] ขา 2: SELL HYPE (Perp)  sz=1.49 px>=66.751 leverage=2x

อ่านแผนแล้วโอเค ค่อยตั้ง dry_run: false แล้วรันซ้ำ — ลำดับการซ้อมแบบนี้ช่วยชีวิตผมมาหลายครั้งแล้วครับ

โมดูลที่ 3 — Monitor: เฝ้าพอร์ตรายชั่วโมงตามรอบ Funding

Monitor ดึงสถานะพอร์ตทุก 1 ชั่วโมงตามรอบจ่าย Funding ของ Hyperliquid แล้วเช็ก 3 สัญญาณอันตราย คือ Funding ติดลบต่อเนื่องเกินเกณฑ์, มูลค่าสองขาเบี่ยงจากกันเกิน 2% และราคาวิ่งเข้าใกล้จุด Liquidation ของขา Short เกิน 80% ของ buffer.

เปิดสถานะเสร็จไม่ใช่จบงานครับ — งานจริงเพิ่งเริ่ม สามสิ่งที่ต้องเฝ้า (ตรงกับความเสี่ยงที่คุยไว้ในบทความทฤษฎี):

1. Funding พลิกลบ: ติดลบชั่วครู่ไม่เป็นไร แต่ติดลบต่อเนื่อง 6 ชั่วโมง (ปรับได้ใน config) = เรากลายเป็นผู้จ่าย ควรปิดหรือย้ายเหรียญ
2. Delta drift: ราคาวิ่งแรงๆ ทำให้มูลค่าสองขาเริ่มไม่เท่ากัน (เช่น Spot กำไรแต่ Perp margin ลด) เบี่ยงเกิน 2% ควร rebalance
3. Liquidation buffer: ขา Short โดนบีบเมื่อราคาพุ่ง ถ้าราคาห่างจุด Liquidation น้อยกว่า 20% บอทจะเตือนระดับ 🚨

โค้ด loop หลักของ Monitor:

while True:
    snap = snapshot(info, cfg, coin)   # ดึง funding, มูลค่าสองขา, liq price
    alerts = []

    if snap["funding_hourly_pct"] < 0:
        negative_streak += 1
        if negative_streak >= cfg.negative_funding_hours:
            alerts.append(f"🚨 Funding ติดลบครบ {cfg.negative_funding_hours} ชม. "
                          f"— ควรปิดสถานะ: python main.py close {coin}")
    else:
        negative_streak = 0

    if snap["delta_pct"] > cfg.max_delta_pct:
        alerts.append(f"⚠️ Delta เบี่ยง {snap['delta_pct']:.2f}% — ควร rebalance")

    if snap["liq_price"]:
        buffer_pct = (snap["liq_price"] - snap["mid"]) / snap["mid"] * 100
        if buffer_pct < 20:
            alerts.append(f"🚨 ห่างจุด Liquidation แค่ {buffer_pct:.1f}%")

    time.sleep(3600)   # เช็กทุก 1 ชั่วโมง ตามรอบ funding

ตัวอย่าง output ระหว่างเฝ้า:

✅ [2026-07-03T09:00:00+00:00] HYPE funding=+0.0013%/hr spot=$100.16 perp=$99.87 delta=0.29%
⚠️ [2026-07-03T10:00:00+00:00] HYPE funding=-0.0021%/hr spot=$101.40 perp=$101.12 delta=0.28%
   Funding ติดลบ (-0.0021%/hr) ต่อเนื่อง 1 ชม.

รัน python main.py monitor HYPE ค้างไว้ใน tmux หรือ screen บนเครื่องที่เปิดตลอด (VPS ราคาถูกก็พอ) แล้วต่อยอดส่ง alert เข้า Line/Telegram ได้ตามสะดวกครับ

Workflow ที่แนะนำ: จาก Dry-run สู่เงินจริง

ลำดับการใช้งานที่ปลอดภัยที่สุดคือ scan หาเหรียญ → open แบบ dry-run เพื่อตรวจแผน → เปิดจริงบน Testnet → monitor จนเข้าใจพฤติกรรม → จึงย้ายไป Mainnet ด้วยทุนขนาดเล็ก.

สรุปเป็นเช็กลิสต์ให้เลยครับ:

1. python main.py scan — เลือกเหรียญที่ APR ดี, OI สูง, มี Spot
2. python main.py open <COIN> (dry-run) — อ่านแผนให้ละเอียด: ขนาด, ราคา, leverage
3. ตั้ง use_testnet: true, dry_run: false → เปิดจริงบน Testnet
4. python main.py monitor <COIN> ค้างไว้ สังเกตพฤติกรรมสัก 2–3 วัน
5. มั่นใจแล้วค่อยสลับ use_testnet: false ด้วย notional_usd เล็กๆ เช่น $50–100
6. เจอสัญญาณ 🚨 → python main.py close <COIN> ปิดทั้งสองขา

สิ่งที่บอทเวอร์ชันนี้ ตั้งใจไม่ทำให้ (เพื่อให้เราเรียนรู้ก่อน และเป็นการบ้านต่อยอดชั้นดี):

• Auto-rebalance: Monitor แค่เตือน การปรับสองขาให้เท่ากันยังเป็นหน้าที่เรา
• Retry ขา Perp อัตโนมัติ: เคสติดขาเดียวต้องแก้ด้วยมือ — เขียน retry logic เองได้เมื่อเข้าใจกลไกแล้ว
• แจ้งเตือนภายนอก: เพิ่ม webhook Line Notify/Telegram ใน run_monitor ได้ในไม่กี่บรรทัด
• หลายเหรียญพร้อมกัน: โครงสร้างรองรับอยู่แล้ว ลองแตก monitor เป็น multi-coin ดูครับ

บทสรุป

จากทฤษฎี Funding Carry ในบทความก่อน วันนี้เราแปลงมันเป็นบอท Python ที่ทำงานได้จริงครบวงจร: Scanner คัดเหรียญด้วยเกณฑ์ 3 ชั้น (Funding, สภาพคล่อง, มีตลาด Spot), Executor เปิดสองขาอย่างปลอดภัยด้วยลำดับ Spot-ก่อน-Perp พร้อม dry-run mode และ Monitor เฝ้าสัญญาณอันตรายรายชั่วโมงตามรอบ Funding ของ Hyperliquid

โค้ดทั้งหมดอยู่บน GitHub ที่ aoddy/blog ซึ่งเป็น repo กลางที่ผมจะทยอยรวบรวมโค้ดประกอบบทความไว้ที่เดียว (หนึ่งโฟลเดอร์ต่อหนึ่งบทความ) — clone ไปเล่น แตก fork ไปต่อยอด หรือเปิด issue มาคุยกันได้เลยครับ และถ้าทำ feature เจ๋งๆ เพิ่ม อย่าลืมส่ง PR กลับมาแบ่งปันกันนะครับ 🚀

FAQ (คำถามที่พบบ่อย)

ต้องมีความรู้ Python ระดับไหนถึงจะใช้บอทนี้ได้?

ระดับพื้นฐานถึงกลางครับ ถ้าเข้าใจ function, dictionary และการติดตั้ง package ผ่าน pip ก็ใช้งานได้แล้ว เพราะบอทออกแบบให้สั่งงานผ่าน CLI ง่ายๆ 4 คำสั่ง (scan/open/monitor/close) ส่วนการอ่านโค้ดเพื่อต่อยอดจะต้องเข้าใจ dataclass และการเรียก API เพิ่มเติม ซึ่งบทความนี้อธิบายส่วนสำคัญไว้หมดแล้ว

บอทนี้รันแล้วได้กำไรเลยไหม?

ไม่มีอะไรการันตีครับ บอทช่วย "ลดงานมือและความผิดพลาด" ในการทำกลยุทธ์ Funding Carry เท่านั้น กำไรขึ้นกับ Funding Rate ของตลาดจริง ค่าธรรมเนียม และการบริหารความเสี่ยงของคุณ อ่านความเสี่ยงทั้งหมดได้ในบทความทฤษฎี และเริ่มจาก Testnet + ทุนเล็กเสมอ

ทำไมต้องซื้อ Spot ก่อน Short Perp เปิดพร้อมกันไม่ได้เหรอ?

เปิดพร้อมกันแบบ atomic ไม่ได้บน Hyperliquid ครับ (เป็นคนละตลาดกัน) จึงมีจังหวะสั้นๆ ที่พอร์ตมี delta ระหว่างสองคำสั่ง เราเลือกซื้อ Spot ก่อนเพราะถ้าคำสั่งที่สองล้มเหลว การถือ Spot ขาเดียวคือการ "ถือเหรียญเฉยๆ" ซึ่งเสี่ยงน้อยกว่าการถือ Short Perp ขาเดียวที่โดนบีบได้จาก Leverage และ Funding

ถ้า Private Key หลุดจะเสียเงินทั้งกระเป๋าไหม?

ถ้าทำตามบทความคือใช้ API Wallet ความเสียหายจะจำกัดครับ เพราะ API Wallet เซ็นคำสั่งเทรดได้แต่ ถอนเงินออกไม่ได้ อย่างไรก็ตามคนที่ได้ Key ไปยังเปิดออเดอร์มั่วๆ ให้พอร์ตเสียหายได้ ดังนั้นเก็บ Key ใน environment variable, อย่า commit ลง Git และหมั่น revoke API Wallet เก่าที่ไม่ใช้แล้ว

รันบอทบนเครื่องอะไรดี ต้องเปิดคอมทิ้งไว้ตลอดไหม?

ตัว Monitor ควรรันต่อเนื่องบนเครื่องที่ออนไลน์ตลอด เช่น VPS ราคาถูก ($4–6/เดือน) หรือ Raspberry Pi ที่บ้าน โดยรันใน tmux/screen กัน session หลุด ส่วนคำสั่ง scan/open/close เป็นงานชั่วครั้งชั่วคราว รันจากเครื่องไหนก็ได้

ต่อยอดอะไรจากโค้ดนี้ได้บ้าง?

ที่ผมแนะนำเรียงตามความยาก: (1) ส่ง alert เข้า Telegram/Line แทนการพิมพ์ลง terminal, (2) เก็บ snapshot ลง SQLite เพื่อทำ dashboard ติดตาม P&L สะสม, (3) auto-rebalance เมื่อ delta เบี่ยงเกินเกณฑ์, (4) จัดการหลายเหรียญพร้อมกันแบบ portfolio และ (5) โมเดล ML พยากรณ์ว่า Funding จะพลิกลบเมื่อไหร่ — ข้อสุดท้ายนี่แหละสนามเด็กเล่นของสาย Quant ตัวจริง

Resources:

• โค้ดเต็มบน GitHub: aoddy/blog
• บทความทฤษฎี: Funding Carry บน Hyperliquid
• บทความ: เริ่มต้นเขียน Python เชื่อมต่อ Hyperliquid HIP-4
• Hyperliquid Python SDK
• Hyperliquid Docs - Funding