เทรดด้วย GaiaEx API: การยืนยันตัวตน คำสั่งเทรด และข้อมูลตลาด

GaiaEx เป็นตลาดแลกเปลี่ยนแบบกระจายศูนย์ที่สร้างขึ้นบน Hyperliquid L1 และ API ของมันให้คุณเข้าถึงทุกอย่างที่แพลตฟอร์มมีให้ผ่านโปรแกรม — ข้อมูลตลาด การจัดการคำสั่ง การติดตามสถานะ และการสตรีมแบบเรียลไทม์ ไม่ว่าคุณจะสร้างบอทเทรด แดชบอร์ดพอร์ต หรือระบบแจ้งเตือนที่กำหนดเอง API คือจุดเริ่มต้นของคุณ

API แบ่งออกเป็นสองโปรโตคอลที่เสริมกัน:

• REST API — endpoint แบบ request-response สำหรับวางคำสั่งเทรด สอบถามยอดคงเหลือ ดึงประวัติการเทรด และจัดการ API key ใช้ REST เมื่อคุณต้องการ ทำ อะไรบางอย่างหรือ ขอ ข้อมูลที่เฉพาะเจาะจง
• WebSocket API — การเชื่อมต่อสตรีมแบบต่อเนื่องสำหรับข้อมูลตลาดแบบเรียลไทม์ (การเทรด การอัปเดตออเดอร์บุ๊ก ราคาล่าสุด) และเหตุการณ์บัญชีส่วนตัว (การเติมคำสั่ง การเปลี่ยนแปลงสถานะ) ใช้ WebSocket เมื่อคุณต้อง ตอบสนอง ต่อสิ่งที่เกิดขึ้นในทันที

ภายในเบื้องหลัง GaiaEx เชื่อมต่อกับออเดอร์บุ๊กบนเชนของ Hyperliquid L1 คำสั่งเทรดของคุณถูกจับคู่บนเชนด้วยการดำเนินการที่กำหนดแน่นอน และเงินทุนของคุณได้รับความปลอดภัยด้วย กระเป๋า MPC (Multi-Party Computation) — หมายความว่าไม่มีฝ่ายใดฝ่ายเดียว (แม้แต่ GaiaEx เอง) ที่ถือคีย์ส่วนตัวสมบูรณ์ของคุณ API ซ่อนความซับซ้อนของบล็อกเชนไว้: คุณส่งคำขอ JSON เพื่อวางคำสั่งเทรด และแพลตฟอร์มจัดการการเซ็น การส่ง และการยืนยันบน L1

URL พื้นฐานสำหรับ REST API เป็นไปตามธรรมเนียมมาตรฐาน: https://api.gaiaex.com/v1/ การเชื่อมต่อ WebSocket ถูกสร้างขึ้นที่ wss://api.gaiaex.com/ws/v1/ endpoint ทั้งหมดคืนผลลัพธ์เป็น JSON เวลาทั้งหมดเป็นมิลลิวินาทีนับจาก epoch (UTC) และค่าเงินทั้งหมดเป็นสตริงเพื่อหลีกเลี่ยงปัญหาความแม่นยำของ floating-point

เพื่อเข้าถึง endpoint ส่วนตัว (การวางคำสั่งเทรด การสอบถามยอดคงเหลือของคุณ) คุณต้องมีคู่ API key สร้างขึ้นจากแดชบอร์ด GaiaEx ที่ Settings → API Keys คุณจะได้รับสองค่า:

• API Key — ตัวระบุสาธารณะที่ส่งไปพร้อมกับทุกคำขอ ลองคิดว่ามันเป็นชื่อผู้ใช้ของคุณ
• API Secret — คีย์ส่วนตัวที่ใช้เซ็นคำขอ ห้ามแบ่งปันเด็ดขาด ห้าม commit เข้า version control ห้ามส่งใน request header

GaiaEx ใช้ การเซ็นแบบ HMAC-SHA256 เพื่อยืนยันตัวตนคำขอส่วนตัว กระบวนการ: เชื่อมโยง timestamp, HTTP method, request path และ body เป็นสตริงเดียว จากนั้นคำนวณลายเซ็น HMAC โดยใช้ secret ของคุณ เซิร์ฟเวอร์ทำการคำนวณเดียวกันและเปรียบเทียบลายเซ็น

import hmac, hashlib, time, requests, json

API_KEY = "your_api_key"
API_SECRET = "your_api_secret"
BASE_URL = "https://api.gaiaex.com/v1"

def signed_request(method, path, body=None):
    timestamp = str(int(time.time() * 1000))
    body_str = json.dumps(body) if body else ""
    message = timestamp + method.upper() + path + body_str
    signature = hmac.new(
        API_SECRET.encode(), message.encode(), hashlib.sha256
    ).hexdigest()

    headers = {
        "X-API-Key": API_KEY,
        "X-Timestamp": timestamp,
        "X-Signature": signature,
        "Content-Type": "application/json",
    }

    resp = requests.request(method, BASE_URL + path, headers=headers,
                            data=body_str if body else None)
    return resp.json()

ส่วน timestamp ป้องกัน การโจมตีแบบ replay: เซิร์ฟเวอร์ปฏิเสธคำขอใดก็ตามที่ timestamp ต่างจากนาฬิกาของเซิร์ฟเวอร์มากกว่า 30 วินาที ตรวจสอบให้แน่ใจว่านาฬิกาของเครื่องคุณซิงค์ผ่าน NTP

Endpoint ข้อมูลตลาดเป็นแบบสาธารณะ — ไม่ต้องยืนยันตัวตน พวกมันมอบข้อมูลดิบที่คุณต้องการในการตัดสินใจเทรด

ออเดอร์บุ๊ก — คืน bid และ ask ปัจจุบันสำหรับสัญลักษณ์ที่กำหนด พารามิเตอร์ depth ควบคุมจำนวนระดับราคาที่คืน (ค่าเริ่มต้น 20 สูงสุด 100)

# Fetch the BTC-USD order book (top 10 levels)
resp = requests.get(f"{BASE_URL}/orderbook/BTC-USD?depth=10")
book = resp.json()

best_bid = book["bids"][0]  # [price, quantity]
best_ask = book["asks"][0]
spread = float(best_ask[0]) - float(best_bid[0])
print(f"Spread: ${spread:.2f}")

การเทรดล่าสุด — คืน N การเทรดล่าสุดที่ดำเนินการแล้วสำหรับสัญลักษณ์ การเทรดแต่ละครั้งประกอบด้วยราคา ปริมาณ ฝั่ง (ผู้เทกเกอร์ซื้อหรือขาย) และ timestamp

# Fetch the last 50 ETH-USD trades
resp = requests.get(f"{BASE_URL}/trades/ETH-USD?limit=50")
trades = resp.json()["trades"]
avg_price = sum(float(t["price"]) for t in trades) / len(trades)
print(f"Average of last 50 trades: ${avg_price:.2f}")

Ticker — สรุปสถานะตลาดปัจจุบัน: ราคาล่าสุด สูงสุด/ต่ำสุดในรอบ 24 ชั่วโมง ปริมาณการซื้อขาย 24 ชั่วโมง bid/ask ที่ดีที่สุด และเปอร์เซนต์การเปลี่ยนแปลง เหมาะสำหรับสร้าง watchlist หรือสแกนหาความผันผวน

# Fetch all tickers
resp = requests.get(f"{BASE_URL}/tickers")
for ticker in resp.json():
    if float(ticker["change24h"]) > 5.0:
        print(f"{ticker['symbol']}: +{ticker['change24h']}%")

สำหรับข้อมูลเรียลไทม์ ให้ใช้ฟีด WebSocket แทนการ poll endpoint เหล่านี้ REST endpoint มีการจำกัดอัตราและสร้างความหน่วง; WebSocket ส่งการอัปเดตในทันทีที่มันเกิดขึ้นบน Hyperliquid L1

การวางคำสั่งเทรดคือการดำเนินการหลักในระบบเทรดใดก็ตาม GaiaEx รองรับสามประเภทคำสั่งเทรดผ่าน endpoint POST /orders:

คำสั่งตลาด — ดำเนินการทันทีที่ราคาที่ดีที่สุดที่มีอยู่ ใช้เมื่อความเร็วในการดำเนินการสำคัญกว่าความแม่นยำของราคา

# Buy 0.1 BTC at market price
order = signed_request("POST", "/orders", {
    "symbol": "BTC-USD",
    "side": "buy",
    "type": "market",
    "quantity": "0.1",
})
print(f"Filled at {order['avgPrice']}")

คำสั่งจำกัดราคา — ดำเนินการเฉพาะที่ราคาที่คุณระบุหรือดีกว่า พักอยู่บนออเดอร์บุ๊กจนกว่าจะถูกเติม ยกเลิก หรือหมดอายุ

# Sell 2 ETH at $3,500 or higher
order = signed_request("POST", "/orders", {
    "symbol": "ETH-USD",
    "side": "sell",
    "type": "limit",
    "price": "3500.00",
    "quantity": "2.0",
    "timeInForce": "GTC",  # Good Till Cancelled
})

คำสั่งสต็อป — คำสั่งเทรดแบบมีเงื่อนไขที่กลายเป็นตัวใช้งานเมื่อตลาดถึงราคากระตุ้น ใช้สำหรับสต็อปลอสและการเข้าเมื่อเบรกเอาต์

# Stop-loss: sell 0.5 BTC if price drops to $58,000
order = signed_request("POST", "/orders", {
    "symbol": "BTC-USD",
    "side": "sell",
    "type": "stop_market",
    "stopPrice": "58000.00",
    "quantity": "0.5",
})

เพื่อ จัดการคำสั่งที่มีอยู่: สอบถามคำสั่งที่เปิดอยู่ด้วย GET /orders?status=open, ยกเลิกคำสั่งที่เฉพาะเจาะจงด้วย DELETE /orders/{orderId}, หรือยกเลิกคำสั่งที่เปิดอยู่ทั้งหมดสำหรับสัญลักษณ์หนึ่งด้วย DELETE /orders?symbol=BTC-USD สำหรับการจัดการสถานะ GET /positions คืนสถานะที่เปิดอยู่ทั้งหมดพร้อมราคาเข้า ปริมาณ กำไรขาดทุนที่ยังไม่รับรู้ และราคาบังคับปิดสถานะ

WebSocket API ของ GaiaEx ใช้โมเดล subscribe/unsubscribe หลังจากเชื่อมต่อ คุณส่งข้อความ subscription ที่ระบุว่าคุณต้องการรับช่องทางไหน ทั้งช่องทางสาธารณะ (ข้อมูลตลาด) และส่วนตัว (เหตุการณ์บัญชี) มีให้ใช้บนการเชื่อมต่อเดียวกัน

import asyncio, json, hmac, hashlib, time
import websockets

async def connect_gaiaex():
    uri = "wss://api.gaiaex.com/ws/v1"
    async with websockets.connect(uri) as ws:
        # Authenticate for private channels
        ts = str(int(time.time() * 1000))
        sig = hmac.new(API_SECRET.encode(),
                       (ts + "websocket_auth").encode(),
                       hashlib.sha256).hexdigest()
        await ws.send(json.dumps({
            "method": "auth",
            "apiKey": API_KEY,
            "timestamp": ts,
            "signature": sig,
        }))

        # Subscribe to public + private channels
        await ws.send(json.dumps({
            "method": "subscribe",
            "channels": [
                "trades.BTC-USD",
                "orderbook.BTC-USD",
                "account.orders",
                "account.positions",
            ]
        }))

        async for msg in ws:
            data = json.loads(msg)
            ch = data.get("channel", "")
            if ch == "account.orders":
                print(f"Order update: {data['status']} {data['orderId']}")
            elif ch == "trades.BTC-USD":
                print(f"Trade: {data['price']} x {data['quantity']}")

asyncio.run(connect_gaiaex())

ช่องทาง account.orders ผลักดันการอัปเดตทุกครั้งที่คำสั่งเทรดหนึ่งของคุณถูกเติม เติมบางส่วน หรือยกเลิก — กำจัดความจำเป็นในการ poll REST endpoint ช่องทาง account.positions สตรีม PnL และการอัปเดตมาร์จิ้นแบบเรียลไทม์ เมื่อรวมกับช่องทางข้อมูลตลาดสาธารณะ การเชื่อมต่อ WebSocket เดียวมอบทุกอย่างที่บอทเทรดต้องการในการทำงาน

ให้ทำกลไก heartbeat เสมอ: GaiaEx ส่ง ping frame เป็นระยะ และไคลเอนต์ของคุณต้องตอบกลับด้วย pong frame ถ้าไม่ได้รับ pong ภายใน 30 วินาที เซิร์ฟเวอร์จะปิดการเชื่อมต่อ ในฝั่งของคุณ ถ้าไม่มีข้อมูลเข้ามาภายใน 30 วินาที ให้สมมติว่าการเชื่อมต่อตายแล้วและเชื่อมต่อใหม่

มาผูกทุกอย่างเข้าด้วยกันเป็นบอทเทรดที่เรียบง่ายแต่ใช้งานได้จริง บอทติดตามราคา BTC-USD ผ่าน WebSocket และเมื่อราคาต่ำกว่าเป้าหมาย มันจะวางคำสั่งซื้อแบบจำกัดราคา เมื่อสถานะเปิดอยู่และราคาสูงกว่าระดับ take-profit มันจะปิดสถานะ

import asyncio, json
import websockets

TARGET_BUY = 60000.0
TAKE_PROFIT = 63000.0
QUANTITY = "0.05"
position_open = False

async def trading_bot():
    global position_open
    uri = "wss://api.gaiaex.com/ws/v1"

    async with websockets.connect(uri) as ws:
        # Auth + subscribe (omitted for brevity)
        await ws.send(json.dumps({
            "method": "subscribe",
            "channels": ["trades.BTC-USD"]
        }))

        async for msg in ws:
            data = json.loads(msg)
            if data.get("channel") != "trades.BTC-USD":
                continue

            price = float(data["price"])

            if not position_open and price <= TARGET_BUY:
                order = signed_request("POST", "/orders", {
                    "symbol": "BTC-USD", "side": "buy",
                    "type": "limit", "price": str(TARGET_BUY),
                    "quantity": QUANTITY,
                })
                print(f"BUY order placed: {order['orderId']}")
                position_open = True

            elif position_open and price >= TAKE_PROFIT:
                order = signed_request("POST", "/orders", {
                    "symbol": "BTC-USD", "side": "sell",
                    "type": "market", "quantity": QUANTITY,
                })
                print(f"SELL order placed: {order['orderId']}")
                position_open = False

asyncio.run(trading_bot())

นี่เรียบง่ายโดยตั้งใจ บอทเวอร์ชันงานผลิตจะเพิ่ม: การจัดการข้อผิดพลาด ด้วย try/except รอบทุกการเรียก API และการเชื่อมต่อใหม่โดยอัตโนมัติ; ตรรกะการลองใหม่ ด้วย exponential backoff สำหรับความล้มเหลวชั่วคราว; การติดตามสถานะ ผ่านช่องทาง WebSocket account.positions แทนตัวแปร boolean; เพดานความเสี่ยง ที่หยุดการเทรดหลังจากขาดทุนรายวันสูงสุด; และ การบันทึก log ที่บันทึกทุกการตัดสินใจและการตอบสนองของ API สำหรับการวิเคราะห์หลังการเทรด

สถาปัตยกรรมกระเป๋า MPC ของ GaiaEx หมายความว่าบอทของคุณไม่ต้องจัดการคีย์ส่วนตัวแบบดิบเลย — การเซ็นถูกจัดการโดยโครงสร้างพื้นฐานคีย์แบบกระจายของแพลตฟอร์ม นี่ลดพื้นที่เสี่ยงด้านความปลอดภัยเมื่อเทียบกับบอทที่จัดการคีย์กระเป๋าของตัวเอง ที่การเจาะเพียงครั้งเดียวสามารถดูดเงินทุนทั้งหมดได้ เมื่อรวมกับ IP whitelisting ของ API key และเลเยอร์การยืนยันตัวตนแบบ HMAC คุณจะได้การป้องกันแบบหลายชั้นสำหรับการเทรดอัตโนมัติ

เริ่มเล็ก ๆ: deploy ด้วยขนาดสถานะขั้นต่ำ ติดตามเป็นเวลา 48 ชั่วโมง ตรวจสอบว่าการเติมคำสั่งตรงกับความคาดหวัง แล้วขยายอย่างค่อยเป็นค่อยไป บอทเทรดที่ดีที่สุดถูกสร้างขึ้นทีละขั้น ไม่ใช่ในรอบการเขียนโค้ดครั้งเดียว