Genesis Arbitrage

Genesis Arbitrage · · 13 मिनट में पढ़ें

Python में स्प्रेड और funding मॉनिटर

संक्षेप में

  • मॉनिटर एक कंसोल प्रोग्राम है: हर meta.freshness_sec सेकंड में वह /arbitrage/spot-spot और /funding/spread के पूरे dataset खींचता है, पंक्तियों को सीमाओं से छाँटता है, टेबल छापता है और CSV फ़ाइल में जोड़ता है।
  • दोनों dataset बिना filter माँगे जाते हैं, इसलिए उनके साथ ETag आता है: अगले snapshot से पहले If-None-Match के साथ दोहराने पर 304 मिलता है और quota खर्च नहीं होता। 429 और 503 पर क्लाइंट Retry-After सेकंड रुकता है।
  • हर leg पर माने गए 0.1% taker fee के बाद जो बचता है वह स्प्रेड घटा 0.2 प्रतिशत अंक है। Pro और Max पर मॉनिटर शीर्ष तीन जोड़ियों को $1,000 की order book से दोबारा जाँचता है।
  • ऊपरी सीमा Trial पर 30 दिनों में 86,400 calls है, यानी quota का 17.28%, और order book जाँच के साथ Pro पर 1,296,000, यानी 25.92%।

स्प्रेड और funding मॉनिटर एक प्रोग्राम है जो लूप में exchange के बीच के स्प्रेड और funding स्प्रेड खींचता है, आपकी सीमाओं से ऊपर की पंक्तियाँ रखता है और कंसोल में टेबल की तरह छापता है। इस पाठ का मॉनिटर Python की लगभग 170 पंक्तियों का है: उसका डेटा Genesis API से आता है, इतिहास CSV फ़ाइल में जाता है, और वह कोई सौदा नहीं खोलता। वह alert भी नहीं भेजता; Telegram संदेशों वाला bot Python में Crypto Arbitrage Bot में है।

Polling योजना: endpoint, आवृत्ति और calls की खपत

अनुरोधक्या देता हैकब
/account/usageप्लान, freshness_sec, rps_limitशुरू में, quota खर्च नहीं करता
/arbitrage/spot-spotSpot – Spot जोड़ियाँहर चक्र, पूरा dataset
/funding/spreadfunding के हिसाब से सबसे अच्छी exchange-जोड़ियाँहर चक्र, पूरा dataset
/orderbooks/spreads/spot-spot$1,000 के लिए Order-book ΔPro और Max, हर चक्र में तीन जोड़ियाँ

meta.freshness_sec आवृत्ति तय करता है: आपके प्लान को Trial पर हर 60 सेकंड, Start पर 30, Pro पर 10 और Max पर 5 सेकंड में नया snapshot मिलता है। इससे तेज़ polling वही snapshot उसी meta.updated_at के साथ लौटाती है। दोनों dataset के फ़ील्ड Spot — Spot और Funding spread दस्तावेज़ों में हैं।

प्लान और quotaविरामप्रति चक्र अनुरोध30 दिनों में calls
Trial, 500K60 सेकंड286,400
Start, 2M30 सेकंड2172,800
Pro, 5M10 सेकंड51,296,000
Max, 10M5 सेकंड52,592,000

Trial पर: 2 × 86,400 / 60 × 30 = 86,400 calls, यानी quota का 17.28%। Pro पर दो dataset में तीन order book जाँचें जुड़ती हैं: 5 × 86,400 / 10 × 30 = 1,296,000 calls, यानी 5M का 25.92%। quota के नियम Genesis API की सीमाएँ गाइड में हैं।

मॉनिटर अनुरोधों के बीच 1.1 / rps_limit सेकंड के विराम से प्रति सेकंड अनुरोध की सीमा में रहता है: Trial पर 1.1 सेकंड और Pro पर 0.22। Pro पर पाँच अनुरोधों का चक्र लगभग एक सेकंड लेता है।

सेटिंग और ETag तथा Retry-After वाला क्लाइंट

इस पाठ के सातों कोड ब्लॉक मिलकर पूरी monitor.py फ़ाइल बनाते हैं: उन्हें एक के बाद एक एक ही फ़ाइल में सहेजें। सेटिंग की सीमाएँ उदाहरण के लिए हैं; उन्हें अपने fee और आकार के हिसाब से बदलें।

import csv
import os
import time
from datetime import datetime, timezone

import requests

API = "https://api.genesisarbitrage.com/v1"
MIN_SPREAD = 1.0     # पंक्ति का स्प्रेड 1% से
MIN_VOLUME = 50_000  # दोनों exchange पर 24 घंटे का वॉल्यूम $50,000 से
MIN_FUNDING = 0.05   # funding स्प्रेड 0.05% से
FEE = 0.1            # हर leg पर माना गया taker fee, %
TOP = 10             # हर टेबल में पंक्तियाँ
BOOK_TOP = 3         # हर चक्र में order book से जाँची जाने वाली जोड़ियाँ, Pro/Max
BOOK_USD = 1000      # order book जाँच का आकार, USD
CSV_FILE = "monitor.csv"

api = requests.Session()
api.headers["X-API-Key"] = os.environ["GENESIS_API_KEY"]
cache = {}                # अनुरोध -> (ETag, उत्तर का body)
stats = {200: 0, 304: 0}  # 200 और 304 उत्तर कितने आए
pace = {"gap": 1.1, "last": 0.0}  # अनुरोधों के बीच विराम, सेकंड

key GENESIS_API_KEY environment variable से आती है और हर अनुरोध के X-API-Key header में जाती है, URL में कभी नहीं। cache हर अनुरोध के आख़िरी उत्तर का ETag और body रखता है, stats 200 और 304 उत्तर गिनता है, और pace याद रखता है कि आख़िरी अनुरोध कब गया।

def get(path, params=None):
    """Genesis API को GET: गति नियंत्रण, ETag और Retry-After पर पुनः प्रयास।"""
    key = (path, tuple(sorted((params or {}).items())))
    for _ in range(4):  # एक अनुरोध और अधिकतम तीन पुनः प्रयास
        wait = pace["last"] + pace["gap"] - time.monotonic()
        if wait > 0:
            time.sleep(wait)  # एक सेकंड में अधिकतम rps_limit अनुरोध
        pace["last"] = time.monotonic()
        hdr = {"If-None-Match": cache[key][0]} if key in cache else {}
        r = api.get(API + path, params=params, headers=hdr,
                    timeout=15)
        if r.status_code == 304:  # snapshot नहीं बदला
            stats[304] += 1
            return cache[key][1]
        if r.status_code in (429, 503):
            wait = int(r.headers.get("Retry-After", "5"))
            if wait > 60:  # खत्म हुआ quota ऐसा दिखता है
                raise SystemExit(f"Quota खत्म: {wait} सेकंड प्रतीक्षा करें")
            time.sleep(wait)
            continue
        r.raise_for_status()  # 400, 401, 403: दोबारा कोशिश से मदद नहीं मिलेगी
        stats[200] += 1
        body = r.json()
        if "ETag" in r.headers:  # केवल पूरे dataset में यह होता है
            cache[key] = (r.headers["ETag"], body)
        return body
    raise RuntimeError("API व्यस्त है, अगले चक्र में फिर कोशिश होगी")

ETag snapshot का संस्करण-टैग है। get उसे If-None-Match header में लौटाता है, और snapshot बदलने तक सर्वर बिना body के 304 देता है: quota खर्च नहीं होता और फ़ंक्शन पिछला body लौटा देता है। 429 और 503 पर वह Retry-After सेकंड रुकता है और फिर कोशिश करता है; एक मिनट से लंबा इंतज़ार यानी अवधि का quota खत्म, तब मॉनिटर रुक जाता है। त्रुटि कोड और पुनः प्रयास के नियम Genesis API के उत्तर और त्रुटियाँ गाइड में हैं।

स्प्रेड और funding: लोडिंग, सीमाएँ और सॉर्टिंग

def spot_rows():
    """सीमाओं से ऊपर की Spot – Spot जोड़ियाँ, coin ट्रांसफर योग्य।"""
    body = get("/arbitrage/spot-spot")  # बिना filter: ETag मिलता है
    rows = []
    for x in body["data"]:
        vol = min(x["volume_24h_buy"] or 0, x["volume_24h_sell"] or 0)
        if (x["spread_pct"] >= MIN_SPREAD and vol >= MIN_VOLUME
                and x["withdraw_enabled_buy"]
                and x["deposit_enabled_sell"]):
            rows.append({**x, "net": net(x["spread_pct"])})
    rows.sort(key=lambda x: x["spread_pct"], reverse=True)
    return rows[:TOP], body["meta"]


def funding_rows():
    """सबसे चौड़े funding स्प्रेड वाले coin।"""
    body = get("/funding/spread")  # बिना filter: ETag मिलता है
    rows = [x for x in body["data"] if x["spread_pct"] >= MIN_FUNDING]
    rows.sort(key=lambda x: x["spread_pct"], reverse=True)
    return rows[:TOP], body["meta"]

दोनों dataset बिना पैरामीटर के माँगे जाते हैं: min_spread, coin या किसी और filter वाले अनुरोध का उत्तर उसी अनुरोध के लिए बनता है और बिना ETag आता है। मॉनिटर सीमाएँ खुद लगाता है: स्प्रेड कम से कम MIN_SPREAD, दोनों exchange पर 24 घंटे का वॉल्यूम कम से कम MIN_VOLUME, खरीद वाले exchange पर निकासी खुली और बिक्री वाले exchange पर जमा खुला। null वॉल्यूम शून्य गिना जाता है, इसलिए ऐसी पंक्ति पास नहीं होती।

पंक्तियाँ spread_pct के घटते क्रम में सॉर्ट होती हैं और पहली TOP टेबल में जाती हैं। /funding/spread में MIN_FUNDING की सीमा सबसे अच्छी जोड़ी के spread_pct से मिलाई जाती है।

fee के बाद क्या बचता है, और order book की जाँच

def net(spread_pct):
    """दो taker fee के बाद क्या बचता है, लगभग, %"""
    return round(spread_pct - 2 * FEE, 4)


def book_net(row):
    """BOOK_USD की book और fee के बाद क्या बचता है। Pro और Max।"""
    body = get("/orderbooks/spreads/spot-spot",
               {"coin": row["coin"], "volume": BOOK_USD})
    pair = (row["exchange_buy"], row["exchange_sell"])
    for x in body["data"]:
        if (x["exchange_buy"], x["exchange_sell"]) != pair:
            continue
        od = x["order_delta"]
        if od["status"] != "ok":
            return od["status"]  # no_book या exhausted
        return net(od["spread_pct"])
    return "gone"  # जोड़ी dataset से बाहर हो गई

खरीद पर 0.1% और बिक्री पर 0.1% का माना गया taker fee स्प्रेड को लगभग 0.2 प्रतिशत अंक घटाता है: 1.62% वाली जोड़ी में 1.62 − 2 × 0.1 = 1.42% बचता है। अपने exchange का fee FEE में रखें (maker और taker)। निकासी का fee API के उत्तरों में नहीं है, और मॉनिटर उसे नहीं गिनता।

Pro और Max पर book_net शीर्ष तीन जोड़ियों को order book से दोबारा जाँचता है: जोड़ी के coin और volume=1000 के साथ /orderbooks/spreads/spot-spot उस coin की पंक्तियाँ order_delta ऑब्जेक्ट के साथ लौटाता है, और फ़ंक्शन वही पंक्ति लेता है जिसकी exchange-जोड़ी वही हो (Order-book Δ)। book न हो या खत्म हो जाए, तो संख्या की जगह no_book या exhausted स्थिति मिलती है। coin वाले अनुरोध में ETag नहीं होता और वह हमेशा एक call खर्च करता है, इसलिए हर चक्र में केवल तीन होते हैं, जो BOOK_TOP तय करता है।

कंसोल टेबल

def show(spot, s_meta, fund, f_meta):
    now = time.time()
    s_age = now - s_meta["updated_at"]
    f_age = now - f_meta["updated_at"]
    print(f"\nSpot – Spot, snapshot की उम्र {s_age:.0f} सेकंड")
    print(f"{'Coin':<8}{'खरीद → बिक्री':<20}"
          f"{'स्प्रेड':>7}{'-fee':>9}{'Book':>11}")
    for x in spot:
        pair = f'{x["exchange_buy"]} → {x["exchange_sell"]}'
        book = x.get("book", "—")
        if isinstance(book, float):
            book = f"{book:.2f}"
        print(f'{x["coin"]:<8}{pair:<20}{x["spread_pct"]:>7.2f}'
              f'{x["net"]:>9.2f}{book:>11}')
    print(f"\nFunding, snapshot की उम्र {f_age:.0f} सेकंड")
    for x in fund:
        b = x["best"]
        legs = (f'{b["exchange_1"]} {b["interval_1"] or "?"} / '
                f'{b["exchange_2"]} {b["interval_2"] or "?"}')
        print(f'{x["coin"]:<8}{legs:<27}{x["spread_pct"]:>8.4f} %')
    print(f"200 उत्तर: {stats[200]}, 304: {stats[304]}")

पहली टेबल में coin, exchange-जोड़ी, spread_pct, fee के बाद का बचा हुआ और book के बाद का बचा हुआ दिखता है; डैश का मतलब है कि book जाँची नहीं गई। दूसरी में funding के हिसाब से सबसे अच्छी exchange-जोड़ी दिखती है, funding अंतराल और spread_pct के साथ। टेबलों के ऊपर snapshot की उम्र है, यानी मौजूदा समय घटा meta.updated_at, और नीचे शुरू से अब तक 200 और 304 उत्तरों की गिनती।

CSV इतिहास

def save(spot, fund):
    """चक्र को CSV में जोड़ता है: समय, dataset, जोड़ी, स्प्रेड।"""
    new = not os.path.exists(CSV_FILE)
    ts = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
    with open(CSV_FILE, "a", newline="", encoding="utf-8") as f:
        w = csv.writer(f)
        if new:
            w.writerow(["time_utc", "dataset", "coin", "leg_1",
                        "leg_2", "spread_pct", "net_pct", "book"])
        for x in spot:
            w.writerow([ts, "spot-spot", x["coin"], x["exchange_buy"],
                        x["exchange_sell"], x["spread_pct"], x["net"],
                        x.get("book")])  # None खाली सेल बन जाता है
        for x in fund:
            b = x["best"]
            w.writerow([ts, "funding", x["coin"], b["exchange_1"],
                        b["exchange_2"], x["spread_pct"], None, None])

कंसोल टेबल अगले चक्र तक रहती है, जबकि monitor.csv हर चक्र सहेजती है: उससे दिखता है कि जोड़ी कितनी देर टिकती है और किन घंटों में आती है। csv मॉड्यूल Python की standard library का हिस्सा है। फ़ाइल newline="" के साथ खोलें, जैसा मॉड्यूल का दस्तावेज़ माँगता है; नहीं तो \r\n लाइन-अंत वाले सिस्टम पर फ़ाइल में अतिरिक्त \r आ जाता है।

book कॉलम में book के बाद का बचा हुआ प्रतिशत में रहता है, या स्थिति exhausted या no_book। मॉड्यूल None को खाली सेल लिखता है, इसलिए funding पंक्तियों और बिना जाँची जोड़ियों के लिए कॉलम खाली रहता है। समय UTC में हैं।

मुख्य लूप

def main():
    usage = get("/account/usage")["data"]  # quota खर्च नहीं करता
    books = usage["plan"] in ("pro", "max")
    pace["gap"] = 1.1 / usage["rps_limit"]
    print("प्लान", usage["plan"], "| snapshot हर",
          usage["freshness_sec"], "सेकंड | order book:",
          "हाँ" if books else "नहीं")
    pause = usage["freshness_sec"]
    while True:
        try:
            spot, s_meta = spot_rows()
            fund, f_meta = funding_rows()
            if books:
                for x in spot[:BOOK_TOP]:
                    x["book"] = book_net(x)
            show(spot, s_meta, fund, f_meta)
            save(spot, fund)
            pause = s_meta.get("freshness_sec", pause)
        except requests.HTTPError as e:
            if e.response.status_code < 500:
                raise  # key, प्लान या पैरामीटर: दोबारा कोशिश से मदद नहीं मिलेगी
            print("सर्वर त्रुटि, फिर कोशिश:", e)
        except (requests.RequestException, RuntimeError) as e:
            print("उत्तर नहीं आया, फिर कोशिश:", e)
        time.sleep(pause)  # freshness_sec से तेज़ = वही snapshot


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\nमॉनिटर रुका, इतिहास यहाँ है:", CSV_FILE)

शुरू में मॉनिटर /account/usage बुलाता है: यह अनुरोध quota खर्च नहीं करता और प्लान, freshness_sec और rps_limit लौटाता है (Usage)। प्लान बताता है कि order book जाँचनी है या नहीं, और rps_limit अनुरोधों के बीच का विराम तय करता है। मॉनिटर नेटवर्क की गड़बड़ी और 5xx त्रुटियाँ अगले चक्र तक सह लेता है, जबकि 4xx त्रुटियाँ (गलत key, खत्म हुई सदस्यता, endpoint के बिना प्लान) उसे रोक देती हैं।

इसे कैसे चलाएँ और आउटपुट कैसे पढ़ें

python3 --version   # Python 3.10 या नया चाहिए
python3 -m pip install requests
export GENESIS_API_KEY="gns_live_XXXXXXXXXXXXXXXX"
python3 monitor.py

Pro प्लान पर आउटपुट, एक उदाहरण:

प्लान pro | snapshot हर 10 सेकंड | order book: हाँ

Spot – Spot, snapshot की उम्र 4 सेकंड
Coin    खरीद → बिक्री        स्प्रेड    -fee       Book
KLM     ByBit → Gate           1.62     1.42       0.86
XYZ     MEXC → Gate            1.24     1.04  exhausted
ABC     BingX → HTX            1.12     0.92       0.31
QRS     Gate → OKX             1.05     0.85          —

Funding, snapshot की उम्र 4 सेकंड
XYZ     MEXC 4h / Bitget 8h          0.0600 %
ABC     Hyper 1h / CoinEx 8h         0.0500 %
200 उत्तर: 6, 304: 0

KLM: पंक्ति का स्प्रेड 1.62% है, दो fee के बाद 1.42%, और $1,000 की order book तथा fee के बाद 0.86%। XYZ की book $1,000 पर खत्म हो गई: ऐसी जोड़ी में आकार घटाते हैं या उसे छोड़ देते हैं। QRS चौथी पंक्ति है, इसलिए उसकी book नहीं माँगी गई। funding टेबल दिखाती है कि हर exchange कितनी बार settle करता है: Hyper (उत्तरों में Hyperliquid का नाम) हर घंटे और CoinEx हर 8 घंटे। मॉनिटर रोकने के लिए Ctrl+C दबाएँ।

पाठ 3 की चार जोड़ी-जाँचों में से मॉनिटर खुद कीमत का अंतर और ट्रांसफर चलाता है, Pro और Max पर order book, और टेबल के ऊपर ताज़गी दिखाता है। कॉन्ट्रैक्ट और निकासी का fee आप जाँचते हैं।

अभ्यास

  1. मॉनिटर चलाएँ

    आउटपुट की पहली पंक्ति प्लान, snapshot का कदम और book की जाँच दिखाती है; उसे अपनी प्रोफ़ाइल से मिलाएँ।

  2. सीमा खिसकाएँ

    MIN_SPREAD = 0.5 रखें और देखें कि नई पंक्तियों में से कितनों में -fee कॉलम शून्य से ऊपर रहता है।

  3. एक dataset जोड़ें

    spot_rows को /arbitrage/futures-futures के लिए कॉपी करें: पंक्ति का प्रारूप वही है। futures के लिए जमा और निकासी की जाँच हटा दें, क्योंकि वहाँ exchange के बीच कोई coin नहीं जाता।

  4. खपत जाँचें

    एक घंटे बाद /account/usage बुलाएँ और calls_used को अनुमान से मिलाएँ: Trial पर यह घंटे में अधिकतम 2 × 60 = 120 calls है।

  5. टिकाऊ जोड़ियाँ खोजें

    monitor.csv को स्प्रेडशीट में खोलें और गिनें कि हर exchange-जोड़ी लगातार कितने चक्र टिकी।

स्वचालन के जोखिम, पुराने डेटा और त्रुटियों से लेकर key और AI एजेंट तक, पाठ 5 में हैं, और filter, compression तथा ETag के साथ किफ़ायती polling limits में फँसे बिना API polling लेख में।

सवाल और जवाब

मॉनिटर arbitrage bot से कैसे अलग है?

मॉनिटर टेबल छापता है और इतिहास रखता है; bot नई जोड़ियों के बारे में alert भेजता है और दोहराई गई जोड़ियों पर चुप रहता है। अनुरोध और filter का कोड साझा है, और Telegram bot Python में Crypto Arbitrage Bot में बताया गया है।

क्या मैं freshness_sec से तेज़ polling कर सकता हूँ?

नया डेटा नहीं मिलेगा: आपके प्लान को हर freshness_sec सेकंड में एक snapshot मिलता है। अगले snapshot से पहले बिना filter का अनुरोध मुफ़्त 304 देता है, जबकि filter वाला अनुरोध उसी डेटा के लिए एक call खर्च करता है।

Book कॉलम में डैश क्यों दिखता है?

Order-book Δ केवल Pro और Max पर है, और मॉनिटर उसे शीर्ष तीन जोड़ियों (BOOK_TOP) के लिए माँगता है। Trial और Start पर endpoint 403 plan_restricted देता है, इसलिए मॉनिटर उसे नहीं बुलाता।