Genesis Arbitrage

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

ऑटोमेशन के जोखिम: डेटा, एरर, कुंजियां और AI

संक्षेप में

  • किसी भी अलर्ट से पहले डेटा जांचें: स्नैपशॉट की उम्र (मौजूदा समय घटा meta.updated_at), order book का stale फ़्लैग, सबसे अच्छे कोट पर स्प्रेड और जोड़ी के दोनों एक्सचेंजों पर साझा कॉन्ट्रैक्ट।
  • 503 का मतलब डेटा नहीं है, जबकि 200 के साथ खाली data का मतलब है कि फ़िल्टर से कुछ मेल नहीं खाया। bot दोनों में फ़र्क करता है और तीन चक्र बिना डेटा के बीतने पर ख़राबी की सूचना देता है।
  • कोड किनारे के मामलों में टूटता है: बिना रुके रिट्राई 429 से टकराता है, तुलना में null Python को गिरा देता है, JavaScript में शून्य से भाग Infinity और झूठा अलर्ट देता है, और UTC की जगह स्थानीय समय funding भुगतान को घंटों खिसका देता है।
  • Genesis API key केवल पढ़ने वाली है, इसलिए लीक होने पर आपका कोटा जलता है। withdrawal अधिकार वाली एक्सचेंज key से पैसा जोखिम में पड़ता है, और trading bot को यह अधिकार नहीं चाहिए।
  • AI मॉडल संख्याएँ गड़बड़ा देता है और किसी और के टेक्स्ट में छिपे आदेश का पालन कर सकता है: कोड संख्याएँ संदेश में डालता है, बाहरी फ़ील्ड मॉडल तक डेटा के रूप में पहुँचते हैं, कोड ट्रेड की सीमाएँ लागू करता है और हर ऑर्डर को इंसान पुष्ट करता है।

Crypto API पर trading bot के जोखिम चार समूहों में आते हैं: डेटा पुराना है या ऐसा स्प्रेड दिखाता है जो मौजूद नहीं; कोड किनारे के मामले में लूप में फँसता या टूटता है; key लीक होती है; AI मॉडल कोई संख्या ग़लत लेता है या किसी और का आदेश मान लेता है। हर जोखिम के लिए कोड में एक जांच या एक कामकाजी नियम है, और सब कुछ पाठ 4 के मॉनिटर में भी समा जाता है।

डेटा के जोखिम

पुराना स्नैपशॉट

Genesis API का स्नैपशॉट meta.updated_at पर बनता है, और आपका प्लान उसे हर meta.freshness_sec सेकंड में ताज़ा करता है: Trial पर 60, Start पर 30, Pro पर 10 और Max पर 5। स्नैपशॉट की उम्र मौजूदा समय घटा meta.updated_at है, यानी उसकी डेटा की ताज़गी। प्लान के एक-दो अंतराल सामान्य हैं; तीन से ज़्यादा का मतलब है कि स्नैपशॉट अटक गया है।

काल्पनिक उदाहरण: Pro पर सीमा 3 × 10 = 30 सेकंड है। 1783802470 पर रिस्पॉन्स आता है और meta.updated_at = 1783802410 है: उम्र 1783802470 − 1783802410 = 60 सेकंड है, इसलिए bot उससे कोई अलर्ट नहीं भेजता। एक्सचेंज से आपके कोड तक की पूरी लेटेंसी इससे भी ज़्यादा है, और उम्र आपके सर्वर की घड़ी से नापी जाती है, इसलिए उसे NTP से सिंक रखें।

Order book और प्रेडिक्शन प्लेटफ़ॉर्म

Order book की अपनी घड़ी है: /orderbooks/book book_ts, age_sec और stale फ़्लैग लौटाता है, जो book 30 सेकंड से पुरानी होने पर true होता है। Books एक्सचेंज से 5–20 सेकंड पीछे रहती हैं। Order-book Δ में order_delta.status जांचें: ok का मतलब गणना हो गई, no_book का मतलब book नहीं है, exhausted का मतलब book साइज़ नहीं भर सकी।

प्रेडिक्शन मार्केट के लिए /predictions/platforms है: ऐसी जोड़ियाँ छोड़ दें जिनमें mode = down वाला प्लेटफ़ॉर्म, पुराने quotes_at वाला प्लेटफ़ॉर्म, या ok = false वाला बुकमेकर हो।

503 पर खाली रिस्पॉन्स

खाली सूची और डेटा का न होना अलग स्थितियाँ हैं। meta.count = 0 के साथ 200 का मतलब है कि कोई पंक्ति फ़िल्टर से मेल नहीं खाई। 503 snapshot_not_ready का मतलब है कि डेटा दोबारा बन रहा है: बाज़ार में जोड़ियाँ हो सकती हैं, और आप Retry-After सेकंड बाद फिर कोशिश करते हैं।

fetch फ़ंक्शन (data, meta) लौटाता है, या डेटा न होने पर None। वह 429 और 503 को Retry-After के बाद, बाक़ी 5xx एरर और नेटवर्क विफलताओं को 5, 10 और 20 सेकंड के विराम के बाद दोहराता है, और बाक़ी सब पर रुक जाता है।

import os
import time

import requests

BASE = "https://api.genesisarbitrage.com/v1"
HEADERS = {"X-API-Key": os.environ["GENESIS_API_KEY"]}


def fetch(path, params=None, tries=4):
    """(data, meta), या None: डेटा नहीं है, यह "कोई pair नहीं" से अलग है।"""
    for attempt in range(tries):
        try:
            r = requests.get(BASE + path, headers=HEADERS,
                             params=params, timeout=15)
            code = r.status_code
        except requests.RequestException:
            code = 0  # नेटवर्क एरर या timeout: रुककर दोबारा कोशिश करें
        if code == 200:
            body = r.json()
            return body["data"], body["meta"]
        wait = 5 * 2 ** attempt  # 5, 10, 20 सेकंड: रुकने का समय बढ़ता है
        if code in (429, 503):
            wait = int(r.headers.get("Retry-After", wait))
            if wait > 60:  # एक मिनट से ज़्यादा कभी प्रतीक्षा न करें
                raise RuntimeError(f"{wait} सेकंड प्रतीक्षा: कोटा जांचें")
        elif 400 <= code < 500:
            # 400, 401, 403, 404, 410: दोबारा कोशिश से ये ठीक नहीं होंगे
            raise RuntimeError(f"{code}: {r.text[:200]}")
        if attempt < tries - 1:
            time.sleep(wait)
    return None

लंबा Retry-After तब भी आता है जब अवधि का कोटा ख़त्म हो चुका हो: रीसेट दिनों दूर हो सकता है, और fetch एक मिनट से ज़्यादा कभी प्रतीक्षा नहीं करता। रिट्राई, ETag और फ़िल्टर लिमिट से टकराए बिना API polling लेख में हैं।

नकली स्प्रेड: पतली book और मिलते-जुलते टोकन

spread_pct आख़िरी ट्रेड से निकलता है, जबकि आप केवल ask पर ख़रीद और केवल bid पर बेच सकते हैं। arbitrage endpoints गाइड के FUEL उदाहरण में स्प्रेड आख़िरी ट्रेड से 0.11% और सबसे अच्छे कोट पर −0.11% है। ask_buy और bid_sell फ़ील्ड हर प्लान पर हर Spot – Spot पंक्ति में आते हैं, और नीचे quote_spread उनसे सबसे अच्छे कोट पर स्प्रेड निकालता है।

पतली order book अंतर को फुला देती है। काल्पनिक उदाहरण: आख़िरी ट्रेड एक घंटा पहले 1.18$ पर छपा था, अब सबसे अच्छा bid 1.02$ है और ख़रीद वाले एक्सचेंज पर ask 1.00$। आख़िरी ट्रेड से स्प्रेड 18% है और सबसे अच्छे कोट पर 2%, और 1000$ शायद भरें ही नहीं: Pro और Max पर volume=1000 पर order_delta.status = exhausted ठीक यही दिखाता है।

नकली स्प्रेड का दूसरा स्रोत अलग-अलग टोकन का एक ही टिकर है, जैसे BSC पर एक टोकन और Solana पर कोई असंबंधित प्रोजेक्ट। कॉन्ट्रैक्ट वाले टोकन के लिए /coins/search को query में टिकर के साथ बुलाएँ: contracts[] में एक ऐसी प्रविष्टि होनी चाहिए जिसकी exchanges में जोड़ी के दोनों एक्सचेंज हों (नामों की तुलना अक्षर-भेद के बिना करें)। ऐसी प्रविष्टि न हो तो सीधा ट्रांसफ़र नहीं है: या तो ये अलग टोकन हैं, या रास्ता ब्रिज से जाता है जिसके अपने जोखिम हैं।

def is_fresh(meta, k=3):
    """स्नैपशॉट प्लान के k अंतराल से पुराना नहीं है।"""
    age = time.time() - meta["updated_at"]
    return age <= k * meta["freshness_sec"]


def quote_spread(row):
    """सबसे अच्छे कोट पर स्प्रेड: ask पर खरीद, bid पर बिक्री।"""
    ask, bid = row.get("ask_buy"), row.get("bid_sell")
    if ask is None or bid is None or ask <= 0:
        return None  # कीमत नहीं या शून्य कीमत: पंक्ति छोड़ें
    return (bid - ask) / ask * 100


pause, fails = 60, 0
while True:
    got = fetch("/arbitrage/spot-spot", {"min_spread": 1})
    if got is None or not is_fresh(got[1]):
        fails += 1  # डेटा नहीं या पुराना डेटा: कोई अलर्ट नहीं
        if fails == 3:
            print("3 चक्र ताज़ा डेटा के बिना")  # खुद को अलर्ट करें
    else:
        rows, meta = got
        fails, pause = 0, meta["freshness_sec"]
        for row in rows:
            s = quote_spread(row)
            if s is not None and s >= 0.5:
                print(row["coin"], row["exchange_buy"], "→",
                      row["exchange_sell"], f"{s:.2f}%")
    time.sleep(pause)  # रुकना हर रास्ते पर चलता है

fetch से आया अपवाद लूप रोक देता है: प्रोडक्शन bot बाहर निकलने से पहले अपने मालिक को संदेश भेजता है।

कोड के जोखिम

बिना विराम के रिट्राई और अंतहीन लूप

पहला bot अक्सर एरर के तुरंत बाद दोबारा कोशिश करता है: if r.status_code != 200: continue। 503 पर ऐसा लूप रिक्वेस्ट लगातार, बिना विराम के दागता है: एरर कोटा नहीं खाते पर requests-per-second की सीमा में गिने जाते हैं, इसलिए Retry-After: 1 के साथ 429 आ जाता है। सदस्यता ख़त्म होने पर वही लूप हमेशा 401 पाता है। और time.sleep() से पहले का continue हर खाली रिस्पॉन्स पर विराम छोड़ देता है, इसीलिए ऊपर के लूप में विराम आख़िरी पंक्ति है।

उलटी ग़लती है हमेशा के लिए प्रतीक्षा। ख़त्म कोटे पर time.sleep(int(r.headers["Retry-After"])) दिनों तक सोता है: जैसे Retry-After: 259200 यानी 259,200 / 86,400 = 3 दिन। बिना timeout की रिक्वेस्ट भी अनंत काल तक अटक सकती है, जैसा requests डॉक्यूमेंटेशन चेताता है।

null और शून्य से भाग

Genesis API ख़ाली मानों के लिए null देता है, और Python उसे None बना देती है। row["volume_24h_sell"] > 10000 की None से तुलना TypeError उठाती है, और एक पंक्ति पूरा लूप गिरा देती है। JavaScript कुछ नहीं उठाती: null > 0.5 false है, null < 1 true है, और फ़िल्टर चुपचाप चूक जाता है।

null का मतलब "डेटा नहीं" है, और उसे or 0 से शून्य कर देना ख़तरनाक है: DEX slippage में tax_sell_pct = null का मतलब है कि टैक्स का स्रोत नहीं है, और or 0 उसे 0% बना देता है। डॉक्यूमेंटेशन के अनुसार null bid_* और ask_*, volume_24h_*, max_position_usd, next_payout में, बुकमेकर वाली लेग की जोड़ियों के profit_usd में और दिन से कम बचने पर apr_pct में आता है।

शून्य से भाग भी वही जाल है। शून्य ask Python में ZeroDivisionError देता है, जबकि JavaScript में 1 / 0 Infinity है और Infinity > 0.5 true: bot अनंत स्प्रेड वाली जोड़ी भेज देता है। भाग देने से पहले भाजक (denominator) जांचें, जैसे quote_spread ask <= 0 जांचता है।

टाइम ज़ोन

Genesis API के समय unix सेकंड और UTC स्ट्रिंग हैं: funding दरों में next_payout UTC में HH:MM के रूप में आता है। टाइम ज़ोन के बिना datetime.fromtimestamp(ts) सर्वर का स्थानीय समय लौटाता है, और datetime.utcnow() Python 3.12 से deprecated है; Python डॉक्यूमेंटेशन उसकी जगह datetime.now(timezone.utc) सुझाता है।

काल्पनिक उदाहरण: सर्वर UTC+3 पर है और घड़ी 09:30 दिखाती है, यानी UTC में 06:30। 08:00 का भुगतान 1 घंटा 30 मिनट दूर है, पर जो कोड 08:00 की तुलना स्थानीय समय से करता है, वह मान लेता है कि भुगतान निकल गया और अगले तक 22 घंटे 30 मिनट गिनता है, यानी 21 घंटे का फ़र्क।

from datetime import datetime, timedelta, timezone


def until_payout(hhmm, now=None):
    """next_payout तक का समय; UTC में HH:MM स्ट्रिंग।"""
    if hhmm is None:
        return None  # null: भुगतान का समय नहीं है
    now = now or datetime.now(timezone.utc)
    h, m = map(int, hhmm.split(":"))
    t = now.replace(hour=h, minute=m, second=0, microsecond=0)
    if t <= now:
        t += timedelta(days=1)  # 23:50 पर "00:00" का मतलब कल है
    return t - now


now = datetime(2026, 11, 15, 6, 30, tzinfo=timezone.utc)
print(until_payout("08:00", now))  # 1:30:00

key के जोखिम

Genesis API key केवल पढ़ने वाली है: वह ऑर्डर नहीं लगा सकती और फ़ंड नहीं निकाल सकती। लीक आपके कोटे और requests-per-second की सीमा पर चोट करता है, और आपके bot को अवधि ख़त्म होने से पहले 429 मिलता है। चेतावनी के संकेत: प्रोफ़ाइल में "उपयोग की गई calls" आपके कोड के हिसाब से तेज़ बढ़ती है, या bot बंद होने पर भी "उपयोग …" हाल का समय दिखाता है।

key एक बार दिखती है और Genesis Arbitrage केवल उसका hash रखता है, इसलिए लीक हुई key दोबारा जारी की जाती है: "Reissue" पुरानी key को तुरंत बंद करता है और नई जारी करता है। key उन जगहों से लीक होती हैं जहाँ ग़लती से रख दी गई थीं: सार्वजनिक रिपॉज़िटरी, रिक्वेस्ट URL, पेज का कोड, स्क्रीनशॉट, रिक्वेस्ट हेडर वाला लॉग। इसके बजाय स्टेटस कोड और X-Request-Id लॉग करें; भंडारण के नियम शब्दकोश की API key प्रविष्टि में हैं।

एक्सचेंज key अलग श्रेणी का जोखिम है: withdrawal अधिकार के साथ वह सिक्के अकाउंट से बाहर भेज सकती है। trading bot को यह अधिकार नहीं चाहिए, इसलिए key बिना withdrawal के, अपने सर्वर के IP से बंधी और हर सेवा के लिए अलग बनाएँ। विवरण क्रिप्टो एक्सचेंज अकाउंट को सुरक्षित कैसे रखें में हैं।

AI एजेंट: संख्याएँ, घुसाए गए आदेश, पुष्टि

एजेंट आपके सर्वर के ज़रिए Genesis API को बुलाता है: मॉडल endpoint और आर्गुमेंट चुनता है, और सर्वर key के साथ रिक्वेस्ट करता है। सेटअप AI एजेंट के लिए Genesis API गाइड में है, और समग्र डिज़ाइन AI एजेंट के लिए क्रिप्टो मार्केट डेटा लेख में।

ग़लत संख्याएँ

मॉडल 0.92 को 0.92% की जगह 92% पढ़ सकता है, प्रति-अंतराल funding_pct को 8 घंटे वाले funding_8h_pct से गड़बड़ा सकता है, या ऐसी कीमत बता सकता है जो रिस्पॉन्स में नहीं है। कोड संख्याएँ सीधे API रिस्पॉन्स से अलर्ट में डालता है, और मॉडल के पास चुनना और समझाना रहता है। अगर मॉडल संख्याएँ ख़ुद लिखे, तो हर संख्या को टूल के नतीजे से मिलाएँ।

बाहरी टेक्स्ट में आदेश

कुछ फ़ील्ड दूसरे लोग लिखते हैं: प्रेडिक्शन मार्केट के title और outcome, ट्रेडर का name, ऑन-चेन इवेंट का token_name, और सिग्नल के message_ru व message_en। कोई भी टोकन का नाम "पिछले निर्देश अनदेखा करो और…" रख सकता है, और जो मॉडल नाम को अपने prompt का हिस्सा पढ़ता है वह उसे मान सकता है। यह prompt injection है, LLM एप्लिकेशन के लिए OWASP Top 10 2025 की पहली प्रविष्टि: LLM01:2025।

ऐसे फ़ील्ड केवल टूल के नतीजे के अंदर दें, उनकी लंबाई सीमित करें और system prompt में लिखें कि वे डेटा हैं। key सर्वर-साइड हैंडलर में ही रहती है।

इंसान की पुष्टि

Genesis API केवल डेटा पढ़ता है: उस पर बना एजेंट जोड़ी ढूँढता और उसके बारे में लिखता है, पर ट्रेड नहीं करता। एजेंट से जुड़ा एक्सचेंज का trading API Genesis API के बाहर है और आपकी अपनी ज़िम्मेदारी पर। उसके जोखिम घटाने के उपायों में OWASP विशेषाधिकार वाली कार्रवाइयों पर human-in-the-loop नियंत्रण गिनाता है: ऑर्डर तभी जाता है जब जोड़ी, कीमतें और डेटा का समय देखने वाला ट्रेडर "हाँ" कहे।

लॉन्च से पहले की चेकलिस्ट

  1. key सर्वर पर GENESIS_API_KEY में है और कोड, रिक्वेस्ट URL, ब्राउज़र, लॉग या prompt में कहीं नहीं है।
  2. हर रिक्वेस्ट में timeout है।
  3. केवल 429, 503, बाक़ी 5xx एरर और नेटवर्क विफलताएँ दोहराई जाती हैं, विराम के साथ और अधिकतम तीन बार।
  4. 400, 401, 403, 404, 410 और एक मिनट से ज़्यादा का Retry-After bot को संदेश के साथ रोक देते हैं।
  5. polling के बीच का विराम कम से कम meta.freshness_sec है और लूप के हर रास्ते पर चलता है।
  6. किसी भी अलर्ट से पहले स्नैपशॉट की उम्र जांची जाती है, और order book के लिए stale व order_delta.status भी।
  7. "डेटा नहीं" और "जोड़ियाँ नहीं" अलग स्थितियाँ हैं, और बिना डेटा के तीन चक्र ख़राबी का संदेश देते हैं।
  8. null की जांच None से होती है, भाजक की शून्य से, और समय UTC में संभाला जाता है।
  9. जोड़ी सबसे अच्छे कोट पर स्प्रेड, साझा कॉन्ट्रैक्ट, withdraw_enabled_buy और deposit_enabled_sell पर पास होती है।
  10. कोड संख्याएँ संदेशों में डालता है, बाहरी टेक्स्ट मॉडल तक डेटा के रूप में पहुँचता है और हर ऑर्डर को इंसान पुष्ट करता है।

कोर्स का समापन: आगे कहाँ जाएँ

कोर्स में पाँच पाठ हैं: अवधारणाएँ, पहली रिक्वेस्ट, निर्णय के लिए डेटा, Python मॉनिटर और उसके जोखिम; बुनियाद पाठ 1 में है। हर क़दम का विवरण:

ख़ुद आज़माएँ

  1. अपने प्लान की ताज़गी जानें

    /account/usage को बुलाएँ और freshness_sec व calls_used नोट करें: यह रिक्वेस्ट call में नहीं गिनी जाती।

  2. स्नैपशॉट की उम्र नापें

    /arbitrage/spot-spot को fetch से लें, time.time() - meta["updated_at"] प्रिंट करें और 3 × freshness_sec की सीमा से मिलाएँ।

  3. दो स्प्रेड की तुलना करें

    पाँच पंक्तियों के लिए spread_pct और quote_spread(row) प्रिंट करें और गिनें कि कितनी जोड़ियाँ सबसे अच्छे कोट पर धनात्मक रहती हैं।

  4. एरर का रास्ता जांचें

    bot को प्लेसहोल्डर GENESIS_API_KEY=gns_live_XXXXXXXXXXXXXXXX के साथ चलाएँ: 401 invalid_key रिस्पॉन्स उसे साफ़ संदेश के साथ रोक देना चाहिए।

  5. चेकलिस्ट देखें

    bot को चौबीसों घंटे चलाने से पहले कोड में जो कमी हो उसे जोड़ें।